Results 1 to 4 of 4

Thread: How render per pixels

  1. #1
    Junior Member Newbie
    Join Date
    Mar 2014
    Posts
    5

    Question How render per pixels

    Hello!
    I have a project and I need to render per pixels.
    Specifically I want take in a buffer (or array or something) all the pixels by color, then apply some manipulations, then render on screen.
    For example I have this code (a green cube in the scene)

    Code :
    // Include standard headers
    #include <stdio.h>
    #include <stdlib.h>
     
    // Include GLEW
    #include <glew.h>
     
    // Include GLFW
    #include <glfw3.h>
    GLFWwindow* window;
     
    // Include GLM
    #include <glm.hpp>
    #include <gtc/matrix_transform.hpp>
    using namespace glm;
     
    #include "shader.hpp"
     
    int main( void )
    {
    	// 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);
     
    	// Open a window and create its OpenGL context
    	window = glfwCreateWindow( 1024, 768, "Cube", 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 = true; // Needed for core profile
    	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);
     
    	// Enable depth test
    	glEnable(GL_DEPTH_TEST);
    	// Accept fragment if it closer to the camera than the former one
    	glDepthFunc(GL_LESS); 
     
    	GLuint VertexArrayID;
    	glGenVertexArrays(1, &VertexArrayID);
    	glBindVertexArray(VertexArrayID);
     
    	// Create and compile our GLSL program from the shaders
    	GLuint programID = LoadShaders( "TransformVertexShader.vertexshader", "ColorFragmentShader.fragmentshader" );
     
    	// Get a handle for our "MVP" uniform
    	GLuint MatrixID = glGetUniformLocation(programID, "MVP");
     
    	// Projection matrix : 45 Field of View, 4:3 ratio, display range : 0.1 unit <-> 100 units
    	glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f);
    	// Camera matrix
    	glm::mat4 View       = glm::lookAt(
    								glm::vec3(4,3,-3), // Camera is at (4,3,-3), 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
     
    	// Our vertices. Tree consecutive floats give a 3D vertex; Three consecutive vertices give a triangle.
    	// A cube has 6 faces with 2 triangles each, so this makes 6*2=12 triangles, and 12*3 vertices
    	static const GLfloat g_vertex_buffer_data[] = { 
    		-1.0f,-1.0f,-1.0f,
    		-1.0f,-1.0f, 1.0f,
    		-1.0f, 1.0f, 1.0f,
    		 1.0f, 1.0f,-1.0f,
    		-1.0f,-1.0f,-1.0f,
    		-1.0f, 1.0f,-1.0f,
    		 1.0f,-1.0f, 1.0f,
    		-1.0f,-1.0f,-1.0f,
    		 1.0f,-1.0f,-1.0f,
    		 1.0f, 1.0f,-1.0f,
    		 1.0f,-1.0f,-1.0f,
    		-1.0f,-1.0f,-1.0f,
    		-1.0f,-1.0f,-1.0f,
    		-1.0f, 1.0f, 1.0f,
    		-1.0f, 1.0f,-1.0f,
    		 1.0f,-1.0f, 1.0f,
    		-1.0f,-1.0f, 1.0f,
    		-1.0f,-1.0f,-1.0f,
    		-1.0f, 1.0f, 1.0f,
    		-1.0f,-1.0f, 1.0f,
    		 1.0f,-1.0f, 1.0f,
    		 1.0f, 1.0f, 1.0f,
    		 1.0f,-1.0f,-1.0f,
    		 1.0f, 1.0f,-1.0f,
    		 1.0f,-1.0f,-1.0f,
    		 1.0f, 1.0f, 1.0f,
    		 1.0f,-1.0f, 1.0f,
    		 1.0f, 1.0f, 1.0f,
    		 1.0f, 1.0f,-1.0f,
    		-1.0f, 1.0f,-1.0f,
    		 1.0f, 1.0f, 1.0f,
    		-1.0f, 1.0f,-1.0f,
    		-1.0f, 1.0f, 1.0f,
    		 1.0f, 1.0f, 1.0f,
    		-1.0f, 1.0f, 1.0f,
    		 1.0f,-1.0f, 1.0f
    	};
     
    	// One color for each vertex. They were generated randomly.
    	static const GLfloat g_color_buffer_data[] = { 
    		0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f
    	};
     
    	GLuint vertexbuffer;
    	glGenBuffers(1, &vertexbuffer);
    	glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
    	glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW);
     
    	GLuint colorbuffer;
    	glGenBuffers(1, &colorbuffer);
    	glBindBuffer(GL_ARRAY_BUFFER, colorbuffer);
    	glBufferData(GL_ARRAY_BUFFER, sizeof(g_color_buffer_data), g_color_buffer_data, GL_STATIC_DRAW);
     
    	do{
     
    		// Clear the screen
    		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_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, 12*3); // 12*3 indices starting at 0 -> 12 triangles
     
    		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();
     
    	return 0;
    }

    How Can I modify my above code, for meet my purpose?
    For instance:
    1. collect all the pixel's colors in a buff
    2. manipulate the color of some pixels
    3. render the buff.

    How can I do that?

    Thanks

  2. #2
    Senior Member Regular Contributor
    Join Date
    Sep 2013
    Posts
    186
    You should just upload the pixels to a texture and then render the texture.
    Rendering pixel by pixel would possible I think but not very good in terms of performance.

  3. #3
    Junior Member Newbie
    Join Date
    Mar 2014
    Posts
    5
    Quote Originally Posted by Cornix View Post
    You should just upload the pixels to a texture and then render the texture.
    Hello, thanks for reply!
    Can you specify, how I can do that?

    Thanks a lot!

  4. #4
    Junior Member Newbie
    Join Date
    Mar 2014
    Posts
    5
    Hello I found a tutorial on how to render on a texture, so the above code become:

    Code :
    // Include standard headers
    #include <stdio.h>
    #include <stdlib.h>
    #include <iostream>
     
    #include <windows.h>
    // Include GLEW
    #include <glew.h>
     
    // Include GLFW
    #include <glfw3.h>
    GLFWwindow* window;
     
    // Include GLM
    #include <glm.hpp>
    #include <gtc/matrix_transform.hpp>
    using namespace glm;
     
    #include "shader.hpp"
     
    int main( void )
    {
    	// 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);
     
    	// Open a window and create its OpenGL context
    	window = glfwCreateWindow( 1024, 768, "Cube", 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 = true; // Needed for core profile
    	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);
     
    	// Enable depth test
    	glEnable(GL_DEPTH_TEST);
    	// Accept fragment if it closer to the camera than the former one
    	//glDepthFunc(GL_LESS); 
     
    	GLuint VertexArrayID;
    	glGenVertexArrays(1, &VertexArrayID);
    	glBindVertexArray(VertexArrayID);
     
    	// Create and compile our GLSL program from the shaders
    	GLuint programID = LoadShaders( "TransformVertexShader.vertexshader", "ColorFragmentShader.fragmentshader" );
     
    	// Get a handle for our "MVP" uniform
    	GLuint MatrixID = glGetUniformLocation(programID, "MVP");
     
    	// Projection matrix : 45 Field of View, 4:3 ratio, display range : 0.1 unit <-> 100 units
    	glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f);
    	// Camera matrix
    	glm::mat4 View       = glm::lookAt(
    								glm::vec3(4,3,-3), // Camera is at (4,3,-3), 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
     
    	// Our vertices. Tree consecutive floats give a 3D vertex; Three consecutive vertices give a triangle.
    	// A cube has 6 faces with 2 triangles each, so this makes 6*2=12 triangles, and 12*3 vertices
    	static const GLfloat g_vertex_buffer_data[] = { 
    		-1.0f,-1.0f,-1.0f,
    		-1.0f,-1.0f, 1.0f,
    		-1.0f, 1.0f, 1.0f,
    		 1.0f, 1.0f,-1.0f,
    		-1.0f,-1.0f,-1.0f,
    		-1.0f, 1.0f,-1.0f,
    		 1.0f,-1.0f, 1.0f,
    		-1.0f,-1.0f,-1.0f,
    		 1.0f,-1.0f,-1.0f,
    		 1.0f, 1.0f,-1.0f,
    		 1.0f,-1.0f,-1.0f,
    		-1.0f,-1.0f,-1.0f,
    		-1.0f,-1.0f,-1.0f,
    		-1.0f, 1.0f, 1.0f,
    		-1.0f, 1.0f,-1.0f,
    		 1.0f,-1.0f, 1.0f,
    		-1.0f,-1.0f, 1.0f,
    		-1.0f,-1.0f,-1.0f,
    		-1.0f, 1.0f, 1.0f,
    		-1.0f,-1.0f, 1.0f,
    		 1.0f,-1.0f, 1.0f,
    		 1.0f, 1.0f, 1.0f,
    		 1.0f,-1.0f,-1.0f,
    		 1.0f, 1.0f,-1.0f,
    		 1.0f,-1.0f,-1.0f,
    		 1.0f, 1.0f, 1.0f,
    		 1.0f,-1.0f, 1.0f,
    		 1.0f, 1.0f, 1.0f,
    		 1.0f, 1.0f,-1.0f,
    		-1.0f, 1.0f,-1.0f,
    		 1.0f, 1.0f, 1.0f,
    		-1.0f, 1.0f,-1.0f,
    		-1.0f, 1.0f, 1.0f,
    		 1.0f, 1.0f, 1.0f,
    		-1.0f, 1.0f, 1.0f,
    		 1.0f,-1.0f, 1.0f
    	};
     
    	// One color for each vertex. They were generated randomly.
    	static const GLfloat g_color_buffer_data[] = { 
    		0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f,
    				0.583f,  0.771f,  0.014f
    	};
     
    	GLuint vertexbuffer;
    	glGenBuffers(1, &vertexbuffer);
    	glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
    	glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW);
     
    	GLuint colorbuffer;
    	glGenBuffers(1, &colorbuffer);
    	glBindBuffer(GL_ARRAY_BUFFER, colorbuffer);
    	glBufferData(GL_ARRAY_BUFFER, sizeof(g_color_buffer_data), g_color_buffer_data, GL_STATIC_DRAW);
     
    	glUseProgram(programID);
     
     
    		// ---------------------------------------------
    	// Render to Texture - specific code begins here
    	// ---------------------------------------------
     
    	// The framebuffer, which regroups 0, 1, or more textures, and 0 or 1 depth buffer.
    	GLuint FramebufferName = 0;
    	glGenFramebuffers(1, &FramebufferName);
    	glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
     
    	// The texture we're going to render to
    	GLuint renderedTexture;
    	glGenTextures(1, &renderedTexture);
     
    	// "Bind" the newly created texture : all future texture functions will modify this texture
    	glBindTexture(GL_TEXTURE_2D, renderedTexture);
     
    	// Give an empty image to OpenGL ( the last "0" means "empty" )
    	glTexImage2D(GL_TEXTURE_2D, 0,GL_RGB, 1024, 768, 0,GL_RGBA, GL_UNSIGNED_BYTE, 0);
     
    	// Poor filtering
    	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 
    	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     
    	// The depth buffer
    	GLuint depthrenderbuffer;
    	glGenRenderbuffers(1, &depthrenderbuffer);
    	glBindRenderbuffer(GL_RENDERBUFFER, depthrenderbuffer);
    	glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, 1024, 768);
    	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthrenderbuffer);
     
    	//----------------------------
     
    	// Set "renderedTexture" as our colour attachement #0
    	glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, renderedTexture, 0);
     
    	// Set the list of draw buffers.
    	GLenum DrawBuffers[1] = {GL_COLOR_ATTACHMENT0};
    	glDrawBuffers(1, DrawBuffers); // "1" is the size of DrawBuffers
     
    	// Always check that our framebuffer is ok
    	if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
    	{
    		printf("\nFrameBuffer Error\n");
    		return false;
    	}
     
     
    	// The fullscreen quad's FBO
    	static const GLfloat g_quad_vertex_buffer_data[] = { 
    		-1.0f, -1.0f, 0.0f,
    		 1.0f, -1.0f, 0.0f,
    		-1.0f,  1.0f, 0.0f,
    		-1.0f,  1.0f, 0.0f,
    		 1.0f, -1.0f, 0.0f,
    		 1.0f,  1.0f, 0.0f,
    	};
     
    	GLuint quad_vertexbuffer;
    	glGenBuffers(1, &quad_vertexbuffer);
    	glBindBuffer(GL_ARRAY_BUFFER, quad_vertexbuffer);
    	glBufferData(GL_ARRAY_BUFFER, sizeof(g_quad_vertex_buffer_data), g_quad_vertex_buffer_data, GL_STATIC_DRAW);
     
    	// Create and compile our GLSL program from the shaders
    	GLuint quad_programID = LoadShaders( "Passthrough.vertexshader", "WobblyTexture.fragmentshader" );
    	GLuint texID = glGetUniformLocation(quad_programID, "renderedTexture");
    	GLuint timeID = glGetUniformLocation(quad_programID, "time");
     
    	do{
    		// Render to our framebuffer
    		glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
    		glViewport(0,0,1024,768); // Render on the whole framebuffer, complete from the lower left corner to the upper right
     
    		// Clear the screen
    		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_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, 12*3); // 12*3 indices starting at 0 -> 12 triangles
     
     
    		// Render to the screen
    		glBindFramebuffer(GL_FRAMEBUFFER, 0);
    		glViewport(0,0,1024,768); // Render on the whole framebuffer, complete from the lower left corner to the upper right
     
    		// Clear the screen
    		glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     
    		// Use our shader
    		glUseProgram(quad_programID);
     
     
    		// Bind our texture in Texture Unit 0
    		glActiveTexture(GL_TEXTURE0);
    		glBindTexture(GL_TEXTURE_2D, renderedTexture);
    		// Set our "renderedTexture" sampler to user Texture Unit 0
    		glUniform1i(texID, 0);
     
    		glUniform1f(timeID, (float)(glfwGetTime()*10.0f) );
     
    		// 1rst attribute buffer : vertices
    		glEnableVertexAttribArray(0);
    		glBindBuffer(GL_ARRAY_BUFFER, quad_vertexbuffer);
    		glVertexAttribPointer(
    			0,                  // attribute 0. 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
    		);
     
    		// Draw the triangles !
    		glDrawArrays(GL_TRIANGLES, 0, 6); // 2*3 indices starting at 0 -> 2 triangles
     
    		glDisableVertexAttribArray(0);
     
     
     
    		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);
     
     
    	glDeleteFramebuffers(1, &FramebufferName);
    	glDeleteTextures(1, &renderedTexture);
    	glDeleteRenderbuffers(1, &depthrenderbuffer);
    	glDeleteBuffers(1, &quad_vertexbuffer);
    	glDeleteVertexArrays(1, &VertexArrayID);
     
    	// Close OpenGL window and terminate GLFW
    	glfwTerminate();
     
    	return 0;
    }

    Now there is only one thing that I want to do. Access to the pixels and modify them.

    How Can I modify my code for to do that?

Similar Threads

  1. Replies: 3
    Last Post: 04-01-2015, 02:05 AM
  2. Render specified amount of pixels to framebuffer
    By overTaker in forum OpenGL: Basic Coding
    Replies: 2
    Last Post: 03-10-2014, 04:23 PM
  3. render only non-black pixels
    By Dardan in forum OpenGL: Advanced Coding
    Replies: 1
    Last Post: 05-19-2012, 11:04 AM
  4. How to render in pixels
    By in forum OpenGL: Basic Coding
    Replies: 3
    Last Post: 06-29-2004, 12:18 PM
  5. How to render 8 pixels per clock with NV3x?
    By John Plate in forum OpenGL: Advanced Coding
    Replies: 19
    Last Post: 07-03-2003, 01:40 PM

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •  
Proudly hosted by Digital Ocean