Joda fucked around with this message at 02:50 on Sep 29, 2015

Sex Bumbo fucked around with this message at 18:19 on Sep 30, 2015

normals: 1
radNext: 1
radTot: 8
radPrev: 9

(...)
    glGenFramebuffers(1,&FBO);
    glGenFramebuffers(1,&firstRadFBO);
    glGenFramebuffers(1,&filterFBO);

    //glBindFramebuffer(GL_DRAW_FRAMEBUFFER, FBO);

    glGenTextures(1, &normals);
    glBindTexture(GL_TEXTURE_2D_ARRAY,normals);

    glTexParameteri(GL_TEXTURE_2D_ARRAY,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D_ARRAY,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D_ARRAY,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D_ARRAY,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);

    glTexImage3D(GL_TEXTURE_2D_ARRAY,0,GL_RG16F,width,height,2,0,GL_RG,GL_FLOAT,0);

    std::cout << "normals: " << normals << std::endl;
(...)

void GBuffer::setBufferSizes(unsigned int width, unsigned int height) {
    this->width = width;
    this->height = height;

    glDeleteTextures(1,&normals);
    glDeleteTextures(1,&specColors);
    glDeleteTextures(1,&diffColors);
    glDeleteTextures(1,&depths);
    glDeleteTextures(1,&depths2);
    glDeleteTextures(1,&randTex);

    glDeleteFramebuffers(1,&FBO);
    glDeleteFramebuffers(1,&firstRadFBO);
    glDeleteFramebuffers(1,&filterFBO);

    setupTextures();
}

void RenderEngine::updateBuffers(GLFWwindow* context, int width, int height) {
    this->context = context;
    this->width = width;
    this->height = height;

    glfwSetWindowSize(context,width,height);
    glViewport(0,0,width,height);
    dbg.setWindowSize(width,height);
    buffer.setBufferSizes(width,height);
    cam.updateDim(width,height);
    initTextures(width,height);
}

void RenderEngine::initTextures(int width, int height) {
    glDeleteTextures(1,&radTot);
    glDeleteTextures(1,&radNext);
    glDeleteTextures(1,&radPrev);

    glGenTextures(1, &radNext);
    glBindTexture(GL_TEXTURE_2D_ARRAY,radNext);

    glTexParameteri(GL_TEXTURE_2D_ARRAY,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D_ARRAY,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D_ARRAY,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D_ARRAY,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);

    glTexImage3D(GL_TEXTURE_2D_ARRAY,0,GL_RGBA8,width,height,2,0,GL_RGBA,GL_UNSIGNED_BYTE,0);
(...)
}

Joda fucked around with this message at 19:19 on Oct 1, 2015

Sex Bumbo fucked around with this message at 19:30 on Oct 1, 2015

Joda fucked around with this message at 22:42 on Oct 1, 2015

Joda fucked around with this message at 23:03 on Oct 1, 2015

glm::mat4 RefreshMVP(float screen_width, float screen_height, int zoom)
{
	const float ar_origin = (float)WIDTH / (float)HEIGHT;
	const float ar_new = (screen_width / screen_height);

	float scale_w = (float)screen_width / (float)WIDTH;
	float scale_h = (float)screen_height / (float)HEIGHT;
	if (ar_new > ar_origin) 
	{
		scale_w = scale_h;
	}
	else 
	{
		scale_h = scale_w;
	}

	float margin_x = (screen_width - WIDTH * scale_w) / 2;
	float margin_y = (screen_height - HEIGHT * scale_h) / 2;
	glm::mat4 Projection = glm::ortho(-WIDTH / ar_origin * 0.5f, 
WIDTH / ar_origin * 0.5f, 
HEIGHT / ar_origin * 0.5f, -HEIGHT / ar_origin * 0.5f, -1.0f, 100.0f);
	/*
	glm::mat4 Orthographic = glm::ortho((float)-(screen_width / 2) * zoom, 
(float)(screen_width / 2) * zoom,
		(float)-(screen_height / 2) * zoom, (float)(screen_height / 2) * zoom, (float)0.1, (float)100);
		*/
	// Projection matrix : 45ｰ Field of View, 4:3 ratio, display range
// : 0.1 unit <-> 100 units
	//Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f);
	// Or, for an ortho camera :
	//glm::mat4 Projection = glm::ortho(-10.0f,10.0f,-10.0f,10.0f,0.0f,100.0f); 
// In world coordinates

	// Camera matrix
	glm::mat4 View = glm::lookAt(
		glm::vec3(0, 0, 1), // Camera is at (0,0,1), in World Space
		glm::vec3(0, 0, 0), // and looks at the origin
		glm::vec3(0, 1, 0)  // Head is up (set to 0,-1,0 to look upside-down)
		);
	// Model matrix : an identity matrix (model will be at the origin)
	glm::mat4 Model = glm::mat4(1.0f);
	// Our ModelViewProjection : multiplication of our 3 matrices
	glm::mat4 MVP = Projection * View * Model; 
// Remember, matrix multiplication is the other way around

	return MVP;
}

#version 330 core

// Input vertex data, different for all executions of this shader.
layout(location = 0) in vec3 vertexPosition_modelspace;
// Values that stay constant for the whole mesh.
uniform mat4 MVP;

out vec3 mVertPositionInModelSpace;

void main(){

	mVertPositionInModelSpace = vertexPosition_modelspace;
	// Output position of the vertex, in clip space : MVP * position
	gl_Position =  MVP * vec4(vertexPosition_modelspace,1);

    //gl_Position.xyz = vertexPosition_modelspace;
    //gl_Position.w = 1.0;

}

#version 330 core

// Ouput data
out vec3 color;
in vec3 mVertPositionInModelSpace;

void main()
{

	// Output color = red 
	//color = mVertPositionInModelSpace.xyz;
	color = vec3(1,0,0).xyz;

}

int main()
{
	int screen_width = WIDTH;
	int screen_height = HEIGHT;

	// Initialise GLFW
	if (!glfwInit())
	{
		fprintf(stderr, "Failed to initialize GLFW\n");
		return -1;
	}

	glfwWindowHint(GLFW_SAMPLES, 4);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
	//glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);

	// Open a window and create its OpenGL context
	window = glfwCreateWindow(screen_width, screen_height, "Tutorial", NULL, NULL);
	if (window == NULL) {
		fprintf(stderr, "Failed to open GLFW window. If you have an Intel GPU, they are 
not 3.3 compatible. Try the 2.1 version of the tutorials.\n");
		glfwTerminate();
		return -1;
	}
	glfwMakeContextCurrent(window);

	// Initialize GLEW
	glewExperimental = GL_TRUE;
	if (glewInit() != GLEW_OK) {
		fprintf(stderr, "Failed to initialize GLEW\n");
		return -1;
	}

	// Ensure we can capture the escape key being pressed below
	glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE);

	// Dark blue background
	glClearColor(0.0f, 0.0f, 0.4f, 0.0f);

	// Here we do stuff.
	drawCircle();
	std::cout << vecCirclePts.size() << std::endl;

	GLuint VertexArrayID;
	glGenVertexArrays(1, &VertexArrayID);
	glBindVertexArray(VertexArrayID);

	// Create and compile our GLSL program from the shaders
	GLuint programID = LoadShaders("SimpleVertexShader.vert", "SimpleFragmentShader.frag");

	// Get a handle for our "MVP" uniform
	GLuint MatrixID = glGetUniformLocation(programID, "MVP");

	int zoom = 1;

	glm::mat4 MVP = RefreshMVP(screen_width, screen_height, zoom);
	static const GLfloat g_vertex_buffer_data[] = {
		-1.0f, -1.0f, 0.0f,
		1.0f, -1.0f, 0.0f,
		0.0f,  1.0f, 0.0f,
	};

	float* a = &vecCirclePts[0];
	GLuint vertexbuffer;
	glGenBuffers(1, &vertexbuffer);
	glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
	glBufferData(GL_ARRAY_BUFFER, vecCirclePts.size() * sizeof(float), a, GL_STATIC_DRAW);

	GLuint colorbuffer;
	glGenBuffers(1, &colorbuffer);
	glBindBuffer(GL_ARRAY_BUFFER, colorbuffer);
	glBufferData(GL_ARRAY_BUFFER, vecCirclePts.size() * sizeof(float), a, GL_STATIC_DRAW);
	int new_height = screen_height;
	int new_width = screen_width;

	do {
		//glfwGetWindowSize(window, &new_width, &new_height);
		MVP = RefreshMVP(new_width, new_height, zoom);
		glViewport(0, 0, screen_width, screen_height);
		double x, y;
		glfwGetCursorPos(window, &x, &y);
		

		std::cout << "x: " << x << ", y: " << y << std::endl;
		// Clear the screen
		glClear(GL_COLOR_BUFFER_BIT);

		// Use our shader
		glUseProgram(programID);

		// Send our transformation to the currently bound shader, 
		// in the "MVP" uniform
		glUniformMatrix4fv(MatrixID, 1, GL_FALSE, &MVP[0][0]);

		// 1rst attribute buffer : vertices
		glEnableVertexAttribArray(0);
		glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
		glVertexAttribPointer(
			0,                  
// attribute. No particular reason for 0, but must match the layout in the shader.
			3,                  // size
			GL_FLOAT,           // type
			GL_FALSE,           // normalized?
			0,                  // stride
			(void*)0            // array buffer offset
			);

		// 2nd attribute buffer : colors
		glEnableVertexAttribArray(1);
		glBindBuffer(GL_ARRAY_BUFFER, colorbuffer);
		glVertexAttribPointer(
			1,                                
// attribute. No particular reason for 1, but must match the layout in the shader.
			3,                                // size
			GL_FLOAT,                         // type
			GL_FALSE,                         // normalized?
			0,                                // stride
			(void*)0                          // array buffer offset
			);

		// Draw the triangle !
		glDrawArrays(GL_TRIANGLES, 0, vecCirclePts.size());

		glDisableVertexAttribArray(0);
		glDisableVertexAttribArray(1);

		// Swap buffers
		glfwSwapBuffers(window);
		glfwPollEvents();

	} // Check if the ESC key was pressed or the window was closed
	while (glfwGetKey(window, GLFW_KEY_ESCAPE) != GLFW_PRESS &&
		glfwWindowShouldClose(window) == 0);

	// Cleanup VBO and shader
	glDeleteBuffers(1, &vertexbuffer);
	glDeleteBuffers(1, &colorbuffer);
	glDeleteProgram(programID);
	glDeleteVertexArrays(1, &VertexArrayID);

	// Close OpenGL window and terminate GLFW
	glfwTerminate();

	//std::cout << "Press ENTER to continue...";
	//std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
	return 0;
}

glm::mat4 RefreshMVP(float screen_width, float screen_height, int zoom)
{
	glm::mat4 Projection = glm::ortho(-screen_width/2.0f, screen_width/ 2.0f, 
        -screen_height/ 2.0f, screen_height/ 2.0f, -1.0f, 100.0f);

	// Camera matrix
	glm::mat4 View = glm::lookAt(
		glm::vec3(0, 0, 1), // Camera is at (0,0,1), in World Space
		glm::vec3(0, 0, 0), // and looks at the origin
		glm::vec3(0, 1, 0)  // Head is up (set to 0,-1,0 to look upside-down)
		);
	// Model matrix : an identity matrix (model will be at the origin)
	glm::mat4 Model = glm::mat4(1.0f);
	// Our ModelViewProjection : multiplication of our 3 matrices
	glm::mat4 MVP = Projection * View * Model; // Remember, matrix multiplication is the other way around
	glViewport(0, 0, screen_width, screen_height);
	return MVP;
}

Raenir Salazar fucked around with this message at 03:43 on Oct 6, 2015

Sex Bumbo fucked around with this message at 22:52 on Oct 7, 2015

Polio Vax Scene fucked around with this message at 17:31 on Oct 11, 2015

Joda fucked around with this message at 00:09 on Oct 12, 2015

Raenir Salazar fucked around with this message at 01:42 on Oct 16, 2015

float gaussian(vec2 coords, float sigma) {
    return exp(-(coords.x * coords.x + coords.y * coords.y)/
                (2 * sigma * sigma));
}

Joda fucked around with this message at 14:23 on Oct 30, 2015