zoukankan      html  css  js  c++  java
  • opengl 学习 之 09 lesson

    opengl 学习 之 09 lesson

    简介

    顶点序列化?
    思想简单来说,就是如果近似的点,使用同一个点,如果不是近似的点就增加点。

    link

    http://www.opengl-tutorial.org/uncategorized/2017/06/07/website-update/

    FPS的计算

    		// Measure speed
    		double currentTime = glfwGetTime();
    		nbFrames++;
    		if ( currentTime - lastTime >= 1.0 ){ // If last prinf() was more than 1sec ago
    			// printf and reset
    			printf("%f ms/frame
    ", 1000.0/double(nbFrames));
    			nbFrames = 0;
    			lastTime += 1.0;
    		}
    

    image

    code

    #ifndef VBOINDEXER_HPP
    #define VBOINDEXER_HPP
    
    void indexVBO(
    	std::vector<glm::vec3> & in_vertices,
    	std::vector<glm::vec2> & in_uvs,
    	std::vector<glm::vec3> & in_normals,
    
    	std::vector<unsigned short> & out_indices,
    	std::vector<glm::vec3> & out_vertices,
    	std::vector<glm::vec2> & out_uvs,
    	std::vector<glm::vec3> & out_normals
    );
    
    
    void indexVBO_TBN(
    	std::vector<glm::vec3> & in_vertices,
    	std::vector<glm::vec2> & in_uvs,
    	std::vector<glm::vec3> & in_normals,
    	std::vector<glm::vec3> & in_tangents,
    	std::vector<glm::vec3> & in_bitangents,
    
    	std::vector<unsigned short> & out_indices,
    	std::vector<glm::vec3> & out_vertices,
    	std::vector<glm::vec2> & out_uvs,
    	std::vector<glm::vec3> & out_normals,
    	std::vector<glm::vec3> & out_tangents,
    	std::vector<glm::vec3> & out_bitangents
    );
    
    #endif
    
    #include <vector>
    #include <map>
    
    #include <glm/glm.hpp>
    
    #include "vboindexer.hpp"
    
    #include <string.h> // for memcmp
    
    
    // Returns true iif v1 can be considered equal to v2
    bool is_near(float v1, float v2){
    	return fabs( v1-v2 ) < 0.01f;
    }
    
    // Searches through all already-exported vertices
    // for a similar one.
    // Similar = same position + same UVs + same normal
    bool getSimilarVertexIndex( 
    	glm::vec3 & in_vertex, 
    	glm::vec2 & in_uv, 
    	glm::vec3 & in_normal, 
    	std::vector<glm::vec3> & out_vertices,
    	std::vector<glm::vec2> & out_uvs,
    	std::vector<glm::vec3> & out_normals,
    	unsigned short & result
    ){
    	// Lame linear search
    	for ( unsigned int i=0; i<out_vertices.size(); i++ ){
    		if (
    			is_near( in_vertex.x , out_vertices[i].x ) &&
    			is_near( in_vertex.y , out_vertices[i].y ) &&
    			is_near( in_vertex.z , out_vertices[i].z ) &&
    			is_near( in_uv.x     , out_uvs     [i].x ) &&
    			is_near( in_uv.y     , out_uvs     [i].y ) &&
    			is_near( in_normal.x , out_normals [i].x ) &&
    			is_near( in_normal.y , out_normals [i].y ) &&
    			is_near( in_normal.z , out_normals [i].z )
    		){
    			result = i;
    			return true;
    		}
    	}
    	// No other vertex could be used instead.
    	// Looks like we'll have to add it to the VBO.
    	return false;
    }
    
    void indexVBO_slow(
    	std::vector<glm::vec3> & in_vertices,
    	std::vector<glm::vec2> & in_uvs,
    	std::vector<glm::vec3> & in_normals,
    
    	std::vector<unsigned short> & out_indices,
    	std::vector<glm::vec3> & out_vertices,
    	std::vector<glm::vec2> & out_uvs,
    	std::vector<glm::vec3> & out_normals
    ){
    	// For each input vertex
    	for ( unsigned int i=0; i<in_vertices.size(); i++ ){
    
    		// Try to find a similar vertex in out_XXXX
    		unsigned short index;
    		bool found = getSimilarVertexIndex(in_vertices[i], in_uvs[i], in_normals[i],     out_vertices, out_uvs, out_normals, index);
    
    		if ( found ){ // A similar vertex is already in the VBO, use it instead !
    			out_indices.push_back( index );
    		}else{ // If not, it needs to be added in the output data.
    			out_vertices.push_back( in_vertices[i]);
    			out_uvs     .push_back( in_uvs[i]);
    			out_normals .push_back( in_normals[i]);
    			out_indices .push_back( (unsigned short)out_vertices.size() - 1 );
    		}
    	}
    }
    
    struct PackedVertex{
    	glm::vec3 position;
    	glm::vec2 uv;
    	glm::vec3 normal;
    	bool operator<(const PackedVertex that) const{
    		return memcmp((void*)this, (void*)&that, sizeof(PackedVertex))>0;
    	};
    };
    
    bool getSimilarVertexIndex_fast( 
    	PackedVertex & packed, 
    	std::map<PackedVertex,unsigned short> & VertexToOutIndex,
    	unsigned short & result
    ){
    	std::map<PackedVertex,unsigned short>::iterator it = VertexToOutIndex.find(packed);
    	if ( it == VertexToOutIndex.end() ){
    		return false;
    	}else{
    		result = it->second;
    		return true;
    	}
    }
    
    void indexVBO(
    	std::vector<glm::vec3> & in_vertices,
    	std::vector<glm::vec2> & in_uvs,
    	std::vector<glm::vec3> & in_normals,
    
    	std::vector<unsigned short> & out_indices,
    	std::vector<glm::vec3> & out_vertices,
    	std::vector<glm::vec2> & out_uvs,
    	std::vector<glm::vec3> & out_normals
    ){
    	std::map<PackedVertex,unsigned short> VertexToOutIndex;
    
    	// For each input vertex
    	for ( unsigned int i=0; i<in_vertices.size(); i++ ){
    
    		PackedVertex packed = {in_vertices[i], in_uvs[i], in_normals[i]};
    		
    
    		// Try to find a similar vertex in out_XXXX
    		unsigned short index;
    		bool found = getSimilarVertexIndex_fast( packed, VertexToOutIndex, index);
    
    		if ( found ){ // A similar vertex is already in the VBO, use it instead !
    			out_indices.push_back( index );
    		}else{ // If not, it needs to be added in the output data.
    			out_vertices.push_back( in_vertices[i]);
    			out_uvs     .push_back( in_uvs[i]);
    			out_normals .push_back( in_normals[i]);
    			unsigned short newindex = (unsigned short)out_vertices.size() - 1;
    			out_indices .push_back( newindex );
    			VertexToOutIndex[ packed ] = newindex;
    		}
    	}
    }
    
    
    
    
    
    
    
    void indexVBO_TBN(
    	std::vector<glm::vec3> & in_vertices,
    	std::vector<glm::vec2> & in_uvs,
    	std::vector<glm::vec3> & in_normals,
    	std::vector<glm::vec3> & in_tangents,
    	std::vector<glm::vec3> & in_bitangents,
    
    	std::vector<unsigned short> & out_indices,
    	std::vector<glm::vec3> & out_vertices,
    	std::vector<glm::vec2> & out_uvs,
    	std::vector<glm::vec3> & out_normals,
    	std::vector<glm::vec3> & out_tangents,
    	std::vector<glm::vec3> & out_bitangents
    ){
    	// For each input vertex
    	for ( unsigned int i=0; i<in_vertices.size(); i++ ){
    
    		// Try to find a similar vertex in out_XXXX
    		unsigned short index;
    		bool found = getSimilarVertexIndex(in_vertices[i], in_uvs[i], in_normals[i],     out_vertices, out_uvs, out_normals, index);
    
    		if ( found ){ // A similar vertex is already in the VBO, use it instead !
    			out_indices.push_back( index );
    
    			// Average the tangents and the bitangents
    			out_tangents[index] += in_tangents[i];
    			out_bitangents[index] += in_bitangents[i];
    		}else{ // If not, it needs to be added in the output data.
    			out_vertices.push_back( in_vertices[i]);
    			out_uvs     .push_back( in_uvs[i]);
    			out_normals .push_back( in_normals[i]);
    			out_tangents .push_back( in_tangents[i]);
    			out_bitangents .push_back( in_bitangents[i]);
    			out_indices .push_back( (unsigned short)out_vertices.size() - 1 );
    		}
    	}
    }
    
    
    // Include standard headers
    #include <stdio.h>
    #include <stdlib.h>
    #include <vector>
    
    // Include GLEW
    #include <GL/glew.h>
    
    // Include GLFW
    #include <GLFW/glfw3.h>
    GLFWwindow* window;
    
    // Include GLM
    #include <glm/glm.hpp>
    #include <glm/gtc/matrix_transform.hpp>
    using namespace glm;
    
    #include <common/shader.hpp>
    #include <common/texture.hpp>
    #include <common/controls.hpp>
    #include <common/objloader.hpp>
    #include <common/vboindexer.hpp>
    
    #include <iostream>
    
    int main( void )
    {
    	// Initialise GLFW
    	if( !glfwInit() )
    	{
    		fprintf( stderr, "Failed to initialize GLFW
    " );
    		getchar();
    		return -1;
    	}
    
    	glfwWindowHint(GLFW_SAMPLES, 4);
    	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    	glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // To make MacOS happy; should not be needed
    	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    
    	// Open a window and create its OpenGL context
    	window = glfwCreateWindow( 1024, 768, "Tutorial 09 - VBO Indexing", 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.
    " );
    		getchar();
    		glfwTerminate();
    		return -1;
    	}
    	glfwMakeContextCurrent(window);
    
    	// Initialize GLEW
    	glewExperimental = true; // Needed for core profile
    	if (glewInit() != GLEW_OK) {
    		fprintf(stderr, "Failed to initialize GLEW
    ");
    		getchar();
    		glfwTerminate();
    		return -1;
    	}
    
    	// Ensure we can capture the escape key being pressed below
    	glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE);
        // Hide the mouse and enable unlimited mouvement
        glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
        
        // Set the mouse at the center of the screen
        glfwPollEvents();
        glfwSetCursorPos(window, 1024/2, 768/2);
    
    	// 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); 
    
    	// Cull triangles which normal is not towards the camera
    	glEnable(GL_CULL_FACE);
    
    	GLuint VertexArrayID;
    	glGenVertexArrays(1, &VertexArrayID);
    	glBindVertexArray(VertexArrayID);
    
    	// Create and compile our GLSL program from the shaders
    	GLuint programID = LoadShaders( "StandardShading.vertexshader", "StandardShading.fragmentshader" );
    
    	// Get a handle for our "MVP" uniform
    	GLuint MatrixID = glGetUniformLocation(programID, "MVP");
    	GLuint ViewMatrixID = glGetUniformLocation(programID, "V");
    	GLuint ModelMatrixID = glGetUniformLocation(programID, "M");
    
    	// Load the texture
    	GLuint Texture = loadDDS("uvmap.DDS");
    	
    	// Get a handle for our "myTextureSampler" uniform
    	GLuint TextureID  = glGetUniformLocation(programID, "myTextureSampler");
    
    	// Read our .obj file
    	std::vector<glm::vec3> vertices;
    	std::vector<glm::vec2> uvs;
    	std::vector<glm::vec3> normals;
    	bool res = loadOBJ("suzanne.obj", vertices, uvs, normals);
    
    	std::vector<unsigned short> indices;
    	std::vector<glm::vec3> indexed_vertices;
    	std::vector<glm::vec2> indexed_uvs;
    	std::vector<glm::vec3> indexed_normals;
    	indexVBO(vertices, uvs, normals, indices, indexed_vertices, indexed_uvs, indexed_normals);
    	std::cout << "[DEBUG] vertices " << vertices.size() << " = " << indexed_vertices.size() << std::endl;
    	std::cout << "[DEBUG] uvs " << uvs.size() << " = " << indexed_uvs.size() << std::endl;
    	std::cout << "[DEBUG] normals " << normals.size() << " = " << indexed_normals.size() << std::endl;
    	// Load it into a VBO
    
    	GLuint vertexbuffer;
    	glGenBuffers(1, &vertexbuffer);
    	glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
    	glBufferData(GL_ARRAY_BUFFER, indexed_vertices.size() * sizeof(glm::vec3), &indexed_vertices[0], GL_STATIC_DRAW);
    
    	GLuint uvbuffer;
    	glGenBuffers(1, &uvbuffer);
    	glBindBuffer(GL_ARRAY_BUFFER, uvbuffer);
    	glBufferData(GL_ARRAY_BUFFER, indexed_uvs.size() * sizeof(glm::vec2), &indexed_uvs[0], GL_STATIC_DRAW);
    
    	GLuint normalbuffer;
    	glGenBuffers(1, &normalbuffer);
    	glBindBuffer(GL_ARRAY_BUFFER, normalbuffer);
    	glBufferData(GL_ARRAY_BUFFER, indexed_normals.size() * sizeof(glm::vec3), &indexed_normals[0], GL_STATIC_DRAW);
    
    	// Generate a buffer for the indices as well
    	GLuint elementbuffer;
    	glGenBuffers(1, &elementbuffer);
    	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementbuffer);
    	glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned short), &indices[0] , GL_STATIC_DRAW);
    
    	// Get a handle for our "LightPosition" uniform
    	glUseProgram(programID);
    	GLuint LightID = glGetUniformLocation(programID, "LightPosition_worldspace");
    
    	// For speed computation
    	double lastTime = glfwGetTime();
    	int nbFrames = 0;
    
    	do{
    
    		// Measure speed
    		double currentTime = glfwGetTime();
    		nbFrames++;
    		if ( currentTime - lastTime >= 1.0 ){ // If last prinf() was more than 1sec ago
    			// printf and reset
    			printf("%f ms/frame
    ", 1000.0/double(nbFrames));
    			nbFrames = 0;
    			lastTime += 1.0;
    		}
    
    		// Clear the screen
    		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    		// Use our shader
    		glUseProgram(programID);
    
    		// Compute the MVP matrix from keyboard and mouse input
    		computeMatricesFromInputs();
    		glm::mat4 ProjectionMatrix = getProjectionMatrix();
    		glm::mat4 ViewMatrix = getViewMatrix();
    		glm::mat4 ModelMatrix = glm::mat4(1.0);
    		glm::mat4 MVP = ProjectionMatrix * ViewMatrix * ModelMatrix;
    
    		// Send our transformation to the currently bound shader, 
    		// in the "MVP" uniform
    		glUniformMatrix4fv(MatrixID, 1, GL_FALSE, &MVP[0][0]);
    		glUniformMatrix4fv(ModelMatrixID, 1, GL_FALSE, &ModelMatrix[0][0]);
    		glUniformMatrix4fv(ViewMatrixID, 1, GL_FALSE, &ViewMatrix[0][0]);
    
    		glm::vec3 lightPos = glm::vec3(4,4,4);
    		glUniform3f(LightID, lightPos.x, lightPos.y, lightPos.z);
    
    		// Bind our texture in Texture Unit 0
    		glActiveTexture(GL_TEXTURE0);
    		glBindTexture(GL_TEXTURE_2D, Texture);
    		// Set our "myTextureSampler" sampler to use Texture Unit 0
    		glUniform1i(TextureID, 0);
    
    		// 1rst attribute buffer : vertices
    		glEnableVertexAttribArray(0);
    		glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
    		glVertexAttribPointer(
    			0,                  // attribute
    			3,                  // size
    			GL_FLOAT,           // type
    			GL_FALSE,           // normalized?
    			0,                  // stride
    			(void*)0            // array buffer offset
    		);
    
    		// 2nd attribute buffer : UVs
    		glEnableVertexAttribArray(1);
    		glBindBuffer(GL_ARRAY_BUFFER, uvbuffer);
    		glVertexAttribPointer(
    			1,                                // attribute
    			2,                                // size
    			GL_FLOAT,                         // type
    			GL_FALSE,                         // normalized?
    			0,                                // stride
    			(void*)0                          // array buffer offset
    		);
    
    		// 3rd attribute buffer : normals
    		glEnableVertexAttribArray(2);
    		glBindBuffer(GL_ARRAY_BUFFER, normalbuffer);
    		glVertexAttribPointer(
    			2,                                // attribute
    			3,                                // size
    			GL_FLOAT,                         // type
    			GL_FALSE,                         // normalized?
    			0,                                // stride
    			(void*)0                          // array buffer offset
    		);
    
    		// Index buffer
    		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementbuffer);
    
    		// Draw the triangles !
    		glDrawElements(
    			GL_TRIANGLES,      // mode
    			indices.size(),    // count
    			GL_UNSIGNED_SHORT,   // type
    			(void*)0           // element array buffer offset
    		);
    
    		glDisableVertexAttribArray(0);
    		glDisableVertexAttribArray(1);
    		glDisableVertexAttribArray(2);
    
    		// 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, &uvbuffer);
    	glDeleteBuffers(1, &normalbuffer);
    	glDeleteBuffers(1, &elementbuffer);
    	glDeleteProgram(programID);
    	glDeleteTextures(1, &Texture);
    	glDeleteVertexArrays(1, &VertexArrayID);
    
    	// Close OpenGL window and terminate GLFW
    	glfwTerminate();
    
    	return 0;
    }
    
    #version 330 core
    
    // Input vertex data, different for all executions of this shader.
    layout(location = 0) in vec3 vertexPosition_modelspace;
    layout(location = 1) in vec2 vertexUV;
    layout(location = 2) in vec3 vertexNormal_modelspace;
    
    // Output data ; will be interpolated for each fragment.
    out vec2 UV;
    out vec3 Position_worldspace;
    out vec3 Normal_cameraspace;
    out vec3 EyeDirection_cameraspace;
    out vec3 LightDirection_cameraspace;
    
    // Values that stay constant for the whole mesh.
    uniform mat4 MVP;
    uniform mat4 V;
    uniform mat4 M;
    uniform vec3 LightPosition_worldspace;
    
    void main(){
    
    	// Output position of the vertex, in clip space : MVP * position
    	gl_Position =  MVP * vec4(vertexPosition_modelspace,1);
    	
    	// Position of the vertex, in worldspace : M * position
    	Position_worldspace = (M * vec4(vertexPosition_modelspace,1)).xyz;
    	
    	// Vector that goes from the vertex to the camera, in camera space.
    	// In camera space, the camera is at the origin (0,0,0).
    	vec3 vertexPosition_cameraspace = ( V * M * vec4(vertexPosition_modelspace,1)).xyz;
    	EyeDirection_cameraspace = vec3(0,0,0) - vertexPosition_cameraspace;
    
    	// Vector that goes from the vertex to the light, in camera space. M is ommited because it's identity.
    	vec3 LightPosition_cameraspace = ( V * vec4(LightPosition_worldspace,1)).xyz;
    	LightDirection_cameraspace = LightPosition_cameraspace + EyeDirection_cameraspace;
    	
    	// Normal of the the vertex, in camera space
    	Normal_cameraspace = ( V * M * vec4(vertexNormal_modelspace,0)).xyz; // Only correct if ModelMatrix does not scale the model ! Use its inverse transpose if not.
    	
    	// UV of the vertex. No special space for this one.
    	UV = vertexUV;
    }
    
    #version 330 core
    
    // Interpolated values from the vertex shaders
    in vec2 UV;
    in vec3 Position_worldspace;
    in vec3 Normal_cameraspace;
    in vec3 EyeDirection_cameraspace;
    in vec3 LightDirection_cameraspace;
    
    // Ouput data
    out vec3 color;
    
    // Values that stay constant for the whole mesh.
    uniform sampler2D myTextureSampler;
    uniform mat4 MV;
    uniform vec3 LightPosition_worldspace;
    
    void main(){
    
    	// Light emission properties
    	// You probably want to put them as uniforms
    	vec3 LightColor = vec3(1,1,1);
    	float LightPower = 50.0f;
    	
    	// Material properties
    	vec3 MaterialDiffuseColor = texture( myTextureSampler, UV ).rgb;
    	vec3 MaterialAmbientColor = vec3(0.1,0.1,0.1) * MaterialDiffuseColor;
    	vec3 MaterialSpecularColor = vec3(0.3,0.3,0.3);
    
    	// Distance to the light
    	float distance = length( LightPosition_worldspace - Position_worldspace );
    
    	// Normal of the computed fragment, in camera space
    	vec3 n = normalize( Normal_cameraspace );
    	// Direction of the light (from the fragment to the light)
    	vec3 l = normalize( LightDirection_cameraspace );
    	// Cosine of the angle between the normal and the light direction, 
    	// clamped above 0
    	//  - light is at the vertical of the triangle -> 1
    	//  - light is perpendicular to the triangle -> 0
    	//  - light is behind the triangle -> 0
    	float cosTheta = clamp( dot( n,l ), 0,1 );
    	
    	// Eye vector (towards the camera)
    	vec3 E = normalize(EyeDirection_cameraspace);
    	// Direction in which the triangle reflects the light
    	vec3 R = reflect(-l,n);
    	// Cosine of the angle between the Eye vector and the Reflect vector,
    	// clamped to 0
    	//  - Looking into the reflection -> 1
    	//  - Looking elsewhere -> < 1
    	float cosAlpha = clamp( dot( E,R ), 0,1 );
    	
    	color = 
    		// Ambient : simulates indirect lighting
    		MaterialAmbientColor +
    		// Diffuse : "color" of the object
    		MaterialDiffuseColor * LightColor * LightPower * cosTheta / (distance*distance) +
    		// Specular : reflective highlight, like a mirror
    		MaterialSpecularColor * LightColor * LightPower * pow(cosAlpha,5) / (distance*distance);
    
    }
    
    Hope is a good thing,maybe the best of things,and no good thing ever dies.----------- Andy Dufresne
  • 相关阅读:
    Mat
    分治法-最近点对问题
    动态规划作业-最长公共子序列问题
    动态规划作业-多段图的最短路径问题
    OpenCV+VisualStudion2017配置
    R入门(二)-对象以及它们的模式和属性
    Big number
    R入门(一)
    Spring-aop
    Spring-ioc
  • 原文地址:https://www.cnblogs.com/eat-too-much/p/14071364.html
Copyright © 2011-2022 走看看