void Terrain :: CalculateNormals(){ CVertex3 f1, f2, f3, f4; float magnitude; int size1; for(int i = 0; i < map_size; ++i){ for(int k = 0; k < map_size; ++k){ size1 = i*map_size+k; if(i > 1){ f1.x = heightmap[i][k] - heightmap[i-1][k]; f1.y = 1; f1.z = 0; } else{ f1.x = 0; f1.y = 0; f1.z = 0; } if(k < map_size - 1){ f2.x = 0; f2.y = 1; f2.z = heightmap[i][k+1] - heightmap[i][k]; } else{ f2.x = 0; f2.y = 0; f2.z = 0; } if(i < map_size - 1){ f3.x = heightmap[i+1][k] - heightmap[i][k]; f3.y = 1; f3.z = 0; } else{ f3.x = 0; f3.y = 0; f3.z = 0; } if(k > 1){ f4.x = 0; f4.y = 1; f4.z = heightmap[i][k-1] - heightmap[i][k]; } else{ f4.x = 0; f4.y = 0; f4.z = 0; } data[size1].n.x = (f1.x + f2.x + f3.x + f4.x)/4; data[size1].n.y = (f1.y + f2.y + f3.y + f4.y)/4; data[size1].n.z = (f1.z + f2.z + f3.z + f4.z)/4; magnitude = (float)sqrt( (data[size1].n.x * data[size1].n.x) + (data[size1].n.y * data[size1].n.y) + (data[size1].n.z * data[size1].n.z) ); data[size1].n.x /= magnitude; data[size1].n.y /= magnitude; data[size1].n.z /= magnitude; } } glBindBuffer(GL_ARRAY_BUFFER, VertexVBID); glBufferData(GL_ARRAY_BUFFER, sizeof(Vertex)*map_size*map_size, NULL, GL_STATIC_DRAW); glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(Vertex)*map_size*map_size, data); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IndexVBID); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLint)*fc.size(), NULL, GL_STATIC_DRAW); glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, sizeof(GLint)*fc.size(), &fc[0]); }
void InitShaders() { btOverlappingPairCache* overlappingPairCache=0; int maxObjects = btMax(256,NUM_OBJECTS); #ifdef USE_NEW int maxPairsSmallProxy = 32; sBroadphase = new btGridBroadphaseCl(overlappingPairCache,btVector3(4.f, 4.f, 4.f), 128, 128, 128,maxObjects, maxObjects, maxPairsSmallProxy, 100.f, 128, g_cxMainContext ,g_device,g_cqCommandQue, g_deviceCL); #else sBroadphase = new btGpu3DGridBroadphase(btVector3(2.f, 2.f, 2.f), 32, 32, 32,maxObjects, maxObjects, 64, 100.f, 64); #endif // sBroadphase = new bt3dGridBroadphaseOCL(overlappingPairCache,btVector3(10.f, 10.f, 10.f), 32, 32, 32,NUM_OBJECTS, NUM_OBJECTS, 64, 100.f, 16, // g_cxMainContext ,g_device,g_cqCommandQue); bool loadFromFile = false; instancingShader = gltLoadShaderPair("instancing.vs","instancing.fs", loadFromFile); glLinkProgram(instancingShader); glUseProgram(instancingShader); angle_loc = glGetUniformLocation(instancingShader, "angle"); ModelViewMatrix = glGetUniformLocation(instancingShader, "ModelViewMatrix"); ProjectionMatrix = glGetUniformLocation(instancingShader, "ProjectionMatrix"); uniform_texture_diffuse = glGetUniformLocation(instancingShader, "Diffuse"); GLuint offset = 0; glGenBuffers(1, &cube_vbo); glBindBuffer(GL_ARRAY_BUFFER, cube_vbo); instance_positions_ptr = (GLfloat*)new float[NUM_OBJECTS*4]; instance_quaternion_ptr = (GLfloat*)new float[NUM_OBJECTS*4]; instance_colors_ptr = (GLfloat*)new float[NUM_OBJECTS*4]; instance_scale_ptr = (GLfloat*)new float[NUM_OBJECTS*3]; int index=0; for (int i=0;i<NUM_OBJECTS_X;i++) { for (int j=0;j<NUM_OBJECTS_Y;j++) { for (int k=0;k<NUM_OBJECTS_Z;k++) { instance_positions_ptr[index*4]=(i*X_GAP-NUM_OBJECTS_X/2); instance_positions_ptr[index*4+1]=(j*Y_GAP-NUM_OBJECTS_Y/2); instance_positions_ptr[index*4+2]=(k*Z_GAP-NUM_OBJECTS_Z/2)+(j&1); instance_positions_ptr[index*4+3]=1; int shapeType =0; void* userPtr = 0; btVector3 aabbMin( instance_positions_ptr[index*4], instance_positions_ptr[index*4+1], instance_positions_ptr[index*4+2]); btVector3 aabbMax = aabbMin; aabbMin -= btVector3(1.f,1.f,1.f); aabbMax += btVector3(1.f,1.f,1.f); void* myptr = (void*)index;//0;//&mBoxes[i] btBroadphaseProxy* proxy = sBroadphase->createProxy(aabbMin,aabbMax,shapeType,myptr,1,1,0,0);//m_dispatcher); proxyArray.push_back(proxy); instance_quaternion_ptr[index*4]=0; instance_quaternion_ptr[index*4+1]=0; instance_quaternion_ptr[index*4+2]=0; instance_quaternion_ptr[index*4+3]=1; instance_colors_ptr[index*4]=j<NUM_OBJECTS_Y/2? 0.5f : 1.f; instance_colors_ptr[index*4+1]=k<NUM_OBJECTS_Y/2? 0.5f : 1.f; instance_colors_ptr[index*4+2]=i<NUM_OBJECTS_Y/2? 0.5f : 1.f; instance_colors_ptr[index*4+3]=1.f; instance_scale_ptr[index*3] = 1; instance_scale_ptr[index*3+1] = 1; instance_scale_ptr[index*3+2] = 1; float mass = 1.f;//j? 1.f : 0.f; bool writeToGpu = false; if (narrowphaseAndSolver) narrowphaseAndSolver->registerRigidBody(gShapeIndex,mass,&instance_positions_ptr[index*4],&instance_quaternion_ptr[index*4],writeToGpu); index++; } } } float posZero[4] = {0,-NUM_OBJECTS_Y/2-1,0,0}; float ornZero[4] = {0,0,0,1}; //register a 'plane' if (narrowphaseAndSolver) narrowphaseAndSolver->registerRigidBody(-1, 0.f, posZero,ornZero,false); if (narrowphaseAndSolver) narrowphaseAndSolver->writeAllBodiesToGpu(); int size = sizeof(cube_vertices) + POSITION_BUFFER_SIZE+ORIENTATION_BUFFER_SIZE+COLOR_BUFFER_SIZE+SCALE_BUFFER_SIZE; VBOsize = size; char* bla = (char*)malloc(size); int szc = sizeof(cube_vertices); memcpy(bla,&cube_vertices[0],szc); memcpy(bla+sizeof(cube_vertices),instance_positions_ptr,POSITION_BUFFER_SIZE); memcpy(bla+sizeof(cube_vertices)+POSITION_BUFFER_SIZE,instance_quaternion_ptr,ORIENTATION_BUFFER_SIZE); memcpy(bla+sizeof(cube_vertices)+POSITION_BUFFER_SIZE+ORIENTATION_BUFFER_SIZE,instance_colors_ptr, COLOR_BUFFER_SIZE); memcpy(bla+sizeof(cube_vertices)+POSITION_BUFFER_SIZE+ORIENTATION_BUFFER_SIZE+COLOR_BUFFER_SIZE,instance_scale_ptr, SCALE_BUFFER_SIZE); glBufferData(GL_ARRAY_BUFFER, size, bla, GL_DYNAMIC_DRAW);//GL_STATIC_DRAW); ///initialize parts of the buffer #ifdef _USE_SUB_DATA glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(cube_vertices)+ 16384, bla);//cube_vertices); #endif char* dest= (char*)glMapBuffer( GL_ARRAY_BUFFER,GL_WRITE_ONLY);//GL_WRITE_ONLY memcpy(dest,cube_vertices,sizeof(cube_vertices)); //memcpy(dest+sizeof(cube_vertices),instance_colors,sizeof(instance_colors)); glUnmapBuffer( GL_ARRAY_BUFFER); writeTransforms(); /* glBufferSubData(GL_ARRAY_BUFFER, sizeof(cube_vertices) + sizeof(instance_colors), POSITION_BUFFER_SIZE, instance_positions_ptr); glBufferSubData(GL_ARRAY_BUFFER, sizeof(cube_vertices) + sizeof(instance_colors)+POSITION_BUFFER_SIZE,ORIENTATION_BUFFER_SIZE , instance_quaternion_ptr); */ glGenVertexArrays(1, &cube_vao); glBindVertexArray(cube_vao); glBindBuffer(GL_ARRAY_BUFFER, cube_vbo); glBindVertexArray(0); glGenBuffers(1, &index_vbo); int indexBufferSize = sizeof(cube_indices); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_vbo); glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexBufferSize, NULL, GL_STATIC_DRAW); glBufferSubData(GL_ELEMENT_ARRAY_BUFFER,0,indexBufferSize,cube_indices); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER,0); glBindVertexArray(0); }
void sglBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data) { glBufferSubData(target, offset, size, data); }
SplineSegmentNode::SplineSegmentNode(const char * name, SceneNode * parent): SceneNode(name, parent) { if(m_program == 0) { std::vector<GLuint> shaderList; // Push vertex shader and fragment shader shaderList.push_back(pgr::createShader(GL_VERTEX_SHADER, strVertexShader )); shaderList.push_back(pgr::createShader(GL_FRAGMENT_SHADER, strFragmentShader)); // Create the program with two shaders m_program = pgr::createProgram(shaderList); m_PVMmatrixLoc = glGetUniformLocation( m_program, "PVMmatrix"); m_colLoc = glGetUniformLocation( m_program, "color"); m_posLoc = glGetAttribLocation( m_program, "position"); } if(m_vertexArrayObject == 0) { const size_t resoulution = 10; // number of samples per parameter step m_numberOfCurveSamples = resoulution * curveTestSize; // samples of the drawn curve glGenBuffers(1, &m_vertexBufferObject); glBindBuffer(GL_ARRAY_BUFFER, m_vertexBufferObject); // reserve space for control points + the curve glBufferData(GL_ARRAY_BUFFER, (curveTestSize + m_numberOfCurveSamples + 4) * sizeof(vec3), NULL, GL_STATIC_DRAW); // 4 for tangents // put given control points first glBufferSubData(GL_ARRAY_BUFFER, 0, curveTestSize * sizeof(vec3), curveTestPoints ); // put computed curve points after GLintptr offset = curveTestSize * sizeof(vec3); for( unsigned i = 0; i < m_numberOfCurveSamples; i++ ) { float t = (float)i/m_numberOfCurveSamples; vec3 position = evaluateCurveSegment( curveTestPoints[0], curveTestPoints[1], curveTestPoints[2], curveTestPoints[3], t); // one point along the curve for parameter t glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(vec3), value_ptr(position) ); offset += sizeof(vec3); } // tangent endpoints vec3 t0 = (curveTestPoints[2] - curveTestPoints[0]) * 0.2f; vec3 t1 = (curveTestPoints[3] - curveTestPoints[1]) * 0.2f; glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(vec3), value_ptr(curveTestPoints[1]-t0) ); offset += sizeof(vec3); glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(vec3), value_ptr(curveTestPoints[1]+t0) ); offset += sizeof(vec3); glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(vec3), value_ptr(curveTestPoints[2]-t1) ); offset += sizeof(vec3); glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(vec3), value_ptr(curveTestPoints[2]+t1) ); offset += sizeof(vec3); glBindBuffer(GL_ARRAY_BUFFER, 0); glGenVertexArrays(1, &m_vertexArrayObject ); glBindVertexArray( m_vertexArrayObject ); glBindBuffer(GL_ARRAY_BUFFER, m_vertexBufferObject); // Control points folowed by the points along the curve glEnableVertexAttribArray(m_posLoc); glVertexAttribPointer(m_posLoc, 3, GL_FLOAT, GL_FALSE, 0, 0); glBindVertexArray( 0 ); } }
void operator()( size_t index ) { glBufferSubData( GL_SHADER_STORAGE_BUFFER, index * sizeof(dp::math::Mat44f), sizeof(dp::math::Mat44f), m_matricesInBasePtr + index * m_matricesInStride ); }
void init() { GLfloat skyboxVertices[] = { // Positions -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 }; planet = tetrahedron(5); object = ObjLoadModel("include/obj/torus.obj"); vec3 tangent[planet.vertexNumber]; vec3 bitangent[planet.vertexNumber]; *tangent = *generateTangents(planet.vertexNumber, planet.points, tangent, bitangent); vec3 vna[planet.vertexNumber]; *vna = *generateSmoothNormals(planet.vertexNumber, vna, planet.points, planet.normals); createShader(&skyboxShader, "src/shaders/skybox.vert", "src/shaders/skybox.frag"); createShader(&sunShader, "src/shaders/sun.vert", "src/shaders/sun.frag"); createShader(&planetShader, "src/shaders/planet.vert", "src/shaders/planet.frag"); createShader(&atmosphereShader, "src/shaders/atmosphere.vert", "src/shaders/atmosphere.frag"); glGenFramebuffers(1, &hdrFBO); glGenTextures(1, &colorBuffer); glBindTexture(GL_TEXTURE_2D, colorBuffer); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB16F, WIDTH, HEIGHT, 0, GL_RGB, GL_FLOAT, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glGenRenderbuffers(1, &rboDepth); glBindRenderbuffer(GL_RENDERBUFFER, rboDepth); glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, WIDTH, HEIGHT); glBindFramebuffer(GL_FRAMEBUFFER, hdrFBO); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, colorBuffer, 0); glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rboDepth); if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) printf("Framebuffer not complete!\n"); glBindFramebuffer(GL_FRAMEBUFFER, 0); glGenVertexArrays(1, &planetVAO); glBindVertexArray(planetVAO); glGenBuffers(1, &planetVBO); glBindBuffer(GL_ARRAY_BUFFER, planetVBO); glBufferData(GL_ARRAY_BUFFER, planet.size + planet.nsize, NULL, GL_STATIC_DRAW); glBufferSubData(GL_ARRAY_BUFFER, 0, planet.size, planet.points); glBufferSubData(GL_ARRAY_BUFFER, planet.size, planet.nsize, vna); glBufferSubData(GL_ARRAY_BUFFER, planet.size+planet.nsize, sizeof(tangent), tangent); glBufferSubData(GL_ARRAY_BUFFER, planet.size+planet.nsize+sizeof(tangent), sizeof(tangent), tangent); vPosition = glGetAttribLocation(planetShader, "vPosition"); glEnableVertexAttribArray(vPosition); glVertexAttribPointer(vPosition, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), BUFFER_OFFSET(0)); vNormal = glGetAttribLocation(planetShader, "vNormal"); glEnableVertexAttribArray(vNormal); glVertexAttribPointer(vNormal, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), BUFFER_OFFSET(planet.size)); vTangent = glGetAttribLocation(planetShader, "vTangent"); glEnableVertexAttribArray(vTangent); glVertexAttribPointer(vTangent, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), BUFFER_OFFSET(planet.size+planet.nsize)); vBitangent = glGetAttribLocation(planetShader, "vBitangent"); glEnableVertexAttribArray(vBitangent); glVertexAttribPointer(vBitangent, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), BUFFER_OFFSET(planet.size+planet.nsize+sizeof(tangent))); glBindVertexArray(0); glGenVertexArrays(1, &skyboxVAO); glBindVertexArray(skyboxVAO); glGenBuffers(1, &skyboxVBO); glBindBuffer(GL_ARRAY_BUFFER, skyboxVBO); glBufferData(GL_ARRAY_BUFFER, sizeof(skyboxVertices), skyboxVertices, GL_STATIC_DRAW); vPosition = glGetAttribLocation(skyboxShader, "vPosition"); glEnableVertexAttribArray(vPosition); glVertexAttribPointer(vPosition, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0); glBindVertexArray(0); glGenVertexArrays(1, &objectVAO); glBindVertexArray(objectVAO); glGenBuffers(1, &objectVBO); glBindBuffer(GL_ARRAY_BUFFER, objectVBO); glBufferData(GL_ARRAY_BUFFER, object.size + object.nsize, NULL, GL_STATIC_DRAW); glBufferSubData(GL_ARRAY_BUFFER, 0, object.size, object.points); glBufferSubData(GL_ARRAY_BUFFER, object.size, object.nsize, object.normals); vPosition = glGetAttribLocation(sunShader, "vPosition"); glEnableVertexAttribArray(vPosition); glVertexAttribPointer(vPosition, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), BUFFER_OFFSET(0)); vNormal = glGetAttribLocation(sunShader, "vNormal"); glEnableVertexAttribArray(vNormal); glVertexAttribPointer(vNormal, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), BUFFER_OFFSET(object.size)); glBindVertexArray(0); glGenVertexArrays(1, &atmosphereVAO); glBindVertexArray(atmosphereVAO); glGenBuffers(1, &atmosphereVBO); glBindBuffer(GL_ARRAY_BUFFER, atmosphereVBO); glBufferData(GL_ARRAY_BUFFER, planet.size + planet.nsize, NULL, GL_STATIC_DRAW); glBufferSubData(GL_ARRAY_BUFFER, 0, planet.size, planet.points); glBufferSubData(GL_ARRAY_BUFFER, planet.size, planet.nsize, planet.normals); vPosition = glGetAttribLocation(atmosphereShader, "vPosition"); glEnableVertexAttribArray(vPosition); glVertexAttribPointer(vPosition, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), BUFFER_OFFSET(0)); vNormal = glGetAttribLocation(atmosphereShader, "vNormal"); glEnableVertexAttribArray(vNormal); glVertexAttribPointer(vNormal, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), BUFFER_OFFSET(planet.size)); glBindVertexArray(0); glEnable(GL_DEPTH_TEST); }
// OpenGL initialization void init() { colorcube(); // Create a vertex array object GLuint vao; glGenVertexArrays( 1, &vao ); glBindVertexArray( vao ); // Create and initialize a buffer object GLuint buffer; glGenBuffers( 1, &buffer ); glBindBuffer( GL_ARRAY_BUFFER, buffer ); glBufferData( GL_ARRAY_BUFFER, sizeof(points) + sizeof(normals), NULL, GL_STATIC_DRAW ); glBufferSubData( GL_ARRAY_BUFFER, 0, sizeof(points), points ); glBufferSubData( GL_ARRAY_BUFFER, sizeof(points), sizeof(normals), normals ); // Load shaders and use the resulting shader program GLuint program = InitShader( "vshader53.glsl", "fshader53.glsl" ); glUseProgram( program ); // set up vertex arrays GLuint vPosition = glGetAttribLocation( program, "vPosition" ); glEnableVertexAttribArray( vPosition ); glVertexAttribPointer( vPosition, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0) ); GLuint vNormal = glGetAttribLocation( program, "vNormal" ); glEnableVertexAttribArray( vNormal ); glVertexAttribPointer( vNormal, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(sizeof(points)) ); // Initialize shader lighting parameters point4 light_position( 0.0, 0.0, -1.0, 0.0 ); color4 light_ambient( 0.2, 0.2, 0.2, 1.0 ); color4 light_diffuse( 1.0, 1.0, 1.0, 1.0 ); color4 light_specular( 1.0, 1.0, 1.0, 1.0 ); color4 material_ambient( 1.0, 0.0, 1.0, 1.0 ); color4 material_diffuse( 1.0, 0.8, 0.0, 1.0 ); color4 material_specular( 1.0, 0.8, 0.0, 1.0 ); float material_shininess = 100.0; color4 ambient_product = light_ambient * material_ambient; color4 diffuse_product = light_diffuse * material_diffuse; color4 specular_product = light_specular * material_specular; glUniform4fv( glGetUniformLocation(program, "AmbientProduct"), 1, ambient_product ); glUniform4fv( glGetUniformLocation(program, "DiffuseProduct"), 1, diffuse_product ); glUniform4fv( glGetUniformLocation(program, "SpecularProduct"), 1, specular_product ); glUniform4fv( glGetUniformLocation(program, "LightPosition"), 1, light_position ); glUniform1f( glGetUniformLocation(program, "Shininess"), material_shininess ); // Retrieve transformation uniform variable locations ModelView = glGetUniformLocation( program, "ModelView" ); Projection = glGetUniformLocation( program, "Projection" ); glEnable( GL_DEPTH_TEST ); glShadeModel(GL_FLAT); glClearColor( 1.0, 1.0, 1.0, 1.0 ); }
void BufferInfo::InsertIndexSubBuffer(GLuint /*bufferID*/, Mesh * mesh, GLsizei indexOffsetBytes) { glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBufferID); glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, /*Vert byte offset*/indexOffsetBytes, mesh->GetIndexSizeInBytes(), mesh->GetIndexDataStart()); }
void InitShaders() { bool loadFromFile = false; instancingShader = gltLoadShaderPair("instancing.vs","instancing.fs", loadFromFile); glLinkProgram(instancingShader); glUseProgram(instancingShader); angle_loc = glGetUniformLocation(instancingShader, "angle"); ModelViewMatrix = glGetUniformLocation(instancingShader, "ModelViewMatrix"); ProjectionMatrix = glGetUniformLocation(instancingShader, "ProjectionMatrix"); uniform_texture_diffuse = glGetUniformLocation(instancingShader, "Diffuse"); GLuint offset = 0; glGenBuffers(1, &cube_vbo); glBindBuffer(GL_ARRAY_BUFFER, cube_vbo); instance_positions_ptr = (GLfloat*)new float[NUM_OBJECTS*4]; instance_quaternion_ptr = (GLfloat*)new float[NUM_OBJECTS*4]; int index=0; for (int i=0;i<NUM_OBJECTS_X;i++) { for (int j=0;j<NUM_OBJECTS_Y;j++) { for (int k=0;k<NUM_OBJECTS_Z;k++) { instance_positions_ptr[index*4]=-(i-NUM_OBJECTS_X/2)*10; instance_positions_ptr[index*4+1]=-(j-NUM_OBJECTS_Y/2)*10; instance_positions_ptr[index*4+2]=-k*10; instance_positions_ptr[index*4+3]=1; instance_quaternion_ptr[index*4]=0; instance_quaternion_ptr[index*4+1]=0; instance_quaternion_ptr[index*4+2]=0; instance_quaternion_ptr[index*4+3]=1; index++; } } } int size = sizeof(cube_vertices) + POSITION_BUFFER_SIZE+ORIENTATION_BUFFER_SIZE; char* bla = (char*)malloc(size); int szc = sizeof(cube_vertices); memcpy(bla,&cube_vertices[0],szc); memcpy(bla+sizeof(cube_vertices),instance_positions_ptr,POSITION_BUFFER_SIZE); memcpy(bla+sizeof(cube_vertices)+POSITION_BUFFER_SIZE,instance_quaternion_ptr,ORIENTATION_BUFFER_SIZE); glBufferData(GL_ARRAY_BUFFER, size, bla, GL_DYNAMIC_DRAW);//GL_STATIC_DRAW); ///initialize parts of the buffer #ifdef _USE_SUB_DATA glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(cube_vertices)+ 16384, bla);//cube_vertices); #endif char* dest= (char*)glMapBuffer( GL_ARRAY_BUFFER,GL_WRITE_ONLY);//GL_WRITE_ONLY memcpy(dest,cube_vertices,sizeof(cube_vertices)); //memcpy(dest+sizeof(cube_vertices),instance_colors,sizeof(instance_colors)); glUnmapBuffer( GL_ARRAY_BUFFER); writeTransforms(); /* glBufferSubData(GL_ARRAY_BUFFER, sizeof(cube_vertices) + sizeof(instance_colors), POSITION_BUFFER_SIZE, instance_positions_ptr); glBufferSubData(GL_ARRAY_BUFFER, sizeof(cube_vertices) + sizeof(instance_colors)+POSITION_BUFFER_SIZE,ORIENTATION_BUFFER_SIZE , instance_quaternion_ptr); */ glGenVertexArrays(1, &cube_vao); glBindVertexArray(cube_vao); glBindBuffer(GL_ARRAY_BUFFER, cube_vbo); glBindVertexArray(0); glGenBuffers(1, &index_vbo); int indexBufferSize = sizeof(cube_indices); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_vbo); glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexBufferSize, NULL, GL_STATIC_DRAW); glBufferSubData(GL_ELEMENT_ARRAY_BUFFER,0,indexBufferSize,cube_indices); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER,0); glBindVertexArray(0); }
///////////////////////////////////////////////////////////////////////////////////////////// //void recursive_render (const struct aiScene *sc, const struct aiNode* nd) //{ // unsigned int n = 0; // struct aiMatrix4x4 m = nd->mTransformation; // // // update transform // aiTransposeMatrix4(&m); // glPushMatrix(); // glMultMatrixf((float*)&m); // // // draw all meshes assigned to this node // for (; n < nd->mNumMeshes; ++n) { // const struct aiMesh* mesh = scene->mMeshes[nd->mMeshes[n]]; // // apply_material(sc->mMaterials[mesh->mMaterialIndex]); ///* // if(mesh->mNormals == NULL) { // glDisable(GL_LIGHTING); // } else { // glEnable(GL_LIGHTING); // } // // if(mesh->mColors[0] != NULL) { // glEnable(GL_COLOR_MATERIAL); // } else { // glDisable(GL_COLOR_MATERIAL); // } //*/ // for (unsigned int t = 0; t < mesh->mNumFaces; ++t) { // const struct aiFace* face = &mesh->mFaces[t]; // GLenum face_mode; // // switch(face->mNumIndices) { // case 1: face_mode = GL_POINTS; break; // case 2: face_mode = GL_LINES; break; // case 3: face_mode = GL_TRIANGLES; break; // default: face_mode = GL_POLYGON; break; // } // // glBegin(face_mode); // // for(unsigned int i = 0; i < face->mNumIndices; i++) { // int index = face->mIndices[i]; // if(mesh->mColors[0] != NULL) // Color4f(&mesh->mColors[0][index]); // if(mesh->mNormals != NULL) // glNormal3fv(&mesh->mNormals[index].x); // glVertex3fv(&mesh->mVertices[index].x); // } // // glEnd(); // } // // } // // // draw all children // for (n = 0; n < nd->mNumChildren; ++n) { // recursive_render(sc, nd->mChildren[n]); // } // // glPopMatrix(); //} ///////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////// void recursive_meshGenerator (const struct aiScene *sc, const struct aiNode* nd, pSceneGeometry*& LocalScene) { LocalScene = new pSceneGeometry; int NbVertices = 0; int NbFaces = 0; struct aiMatrix4x4 m = nd->mTransformation; LocalScene->Matrix = m; //ModelmMatrix if(nd->mNumChildren) LocalScene->children= new pSceneGeometry*[nd->mNumChildren]; else LocalScene->children =NULL; LocalScene->nbChildren=nd->mNumChildren; if(nd->mNumMeshes) { glGenBuffers(1,&(LocalScene->VBOID)); glGenBuffers(1,&(LocalScene->VBOIDNormal)); glGenBuffers(1,&(LocalScene->VBOIDtextureCoor)); glGenBuffers(1,&(LocalScene->VBOIDtangent)); glGenBuffers(1,&(LocalScene->VBOIDbitangent)); glGenBuffers(1,&(LocalScene->IBOID)); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,LocalScene->IBOID); for (unsigned int n = 0; n < nd->mNumMeshes; ++n) { const struct aiMesh* mesh = scene->mMeshes[nd->mMeshes[n]]; NbVertices+=mesh->mNumVertices; NbFaces+=mesh->mNumFaces; } LocalScene->NbFaces=NbFaces; glBindBuffer(GL_ARRAY_BUFFER,LocalScene->VBOID); glBufferData(GL_ARRAY_BUFFER,NbVertices*3*sizeof(float), NULL, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER,LocalScene->VBOIDNormal); glBufferData(GL_ARRAY_BUFFER,NbVertices*3*sizeof(float), NULL, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER,LocalScene->VBOIDtextureCoor); glBufferData(GL_ARRAY_BUFFER,NbVertices*3*sizeof(float), NULL, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER,LocalScene->VBOIDtangent); glBufferData(GL_ARRAY_BUFFER,NbVertices*3*sizeof(float), NULL, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER,LocalScene->VBOIDbitangent); glBufferData(GL_ARRAY_BUFFER,NbVertices*3*sizeof(float), NULL, GL_STATIC_DRAW); unsigned short* Indices = new unsigned short[NbFaces*3]; unsigned int trueNbOfFace = 0; unsigned int nbVerticesWhenSkipped = 0; int nbverticesLocal=0; int nbFacesLocal=0; for (unsigned int n = 0; n < nd->mNumMeshes; ++n) { const struct aiMesh* mesh = scene->mMeshes[nd->mMeshes[n]]; glBindBuffer(GL_ARRAY_BUFFER,LocalScene->VBOID); glBufferSubData(GL_ARRAY_BUFFER,nbverticesLocal*3*sizeof(float), 3*sizeof(float)*mesh->mNumVertices, mesh->mVertices); glBindBuffer(GL_ARRAY_BUFFER,LocalScene->VBOIDNormal); glBufferSubData(GL_ARRAY_BUFFER,nbverticesLocal*3*sizeof(float), 3*sizeof(float)*mesh->mNumVertices, mesh->mNormals); glBindBuffer(GL_ARRAY_BUFFER,LocalScene->VBOIDtextureCoor); glBufferSubData(GL_ARRAY_BUFFER,nbverticesLocal*3*sizeof(float), 3*sizeof(float)*mesh->mNumVertices, mesh->mTextureCoords[0]); glBindBuffer(GL_ARRAY_BUFFER,LocalScene->VBOIDtangent); glBufferSubData(GL_ARRAY_BUFFER,nbverticesLocal*3*sizeof(float), 3*sizeof(float)*mesh->mNumVertices, mesh->mTangents); glBindBuffer(GL_ARRAY_BUFFER,LocalScene->VBOIDbitangent); glBufferSubData(GL_ARRAY_BUFFER,nbverticesLocal*3*sizeof(float), 3*sizeof(float)*mesh->mNumVertices, mesh->mBitangents); nbverticesLocal+=mesh->mNumVertices; for (unsigned int t = 0; t < mesh->mNumFaces; ++t) { const struct aiFace* face = &mesh->mFaces[t]; if ( face->mNumIndices == 3 ) { Indices[trueNbOfFace*3+0] = face->mIndices[0] + nbVerticesWhenSkipped ; Indices[trueNbOfFace*3+1] = face->mIndices[1] + nbVerticesWhenSkipped ; Indices[trueNbOfFace*3+2] = face->mIndices[2] + nbVerticesWhenSkipped; trueNbOfFace++; } else { nbVerticesWhenSkipped = mesh->mNumVertices; } } } glBufferData(GL_ELEMENT_ARRAY_BUFFER,(trueNbOfFace)*3*sizeof(unsigned short) , Indices, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER,LocalScene->VBOID); aiVector3D* bufferVertexRichard = (aiVector3D*)glMapBuffer(GL_ARRAY_BUFFER,GL_READ_WRITE); glUnmapBuffer(GL_ARRAY_BUFFER); } for (unsigned int n = 0; n < nd->mNumChildren; ++n) { recursive_meshGenerator(sc, nd->mChildren[n], LocalScene->children[n]); } }
void GLInstancingRenderer::drawLine(const float from[4], const float to[4], const float color[4], float lineWidth) { b3Assert(glGetError() ==GL_NO_ERROR); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D,0); b3Assert(glGetError() ==GL_NO_ERROR); glUseProgram(linesShader); b3Assert(glGetError() ==GL_NO_ERROR); glUniformMatrix4fv(lines_ProjectionMatrix, 1, false, &m_data->m_projectionMatrix[0]); glUniformMatrix4fv(lines_ModelViewMatrix, 1, false, &m_data->m_viewMatrix[0]); glUniform4f(lines_colour,color[0],color[1],color[2],color[3]); b3Assert(glGetError() ==GL_NO_ERROR); const float vertexPositions[] = { from[0],from[1],from[2],1, to[0],to[1],to[2],1 }; int sz = sizeof(vertexPositions); b3Assert(glGetError() ==GL_NO_ERROR); b3Clamp(lineWidth,(float)lineWidthRange[0],(float)lineWidthRange[1]); glLineWidth(lineWidth); b3Assert(glGetError() ==GL_NO_ERROR); glBindVertexArray(lineVertexArrayObject); b3Assert(glGetError() ==GL_NO_ERROR); glBindBuffer(GL_ARRAY_BUFFER, lineVertexBufferObject); b3Assert(glGetError() ==GL_NO_ERROR); { glBufferSubData(GL_ARRAY_BUFFER, 0,sz, vertexPositions); } b3Assert(glGetError() ==GL_NO_ERROR); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, lineVertexBufferObject); b3Assert(glGetError() ==GL_NO_ERROR); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0); b3Assert(glGetError() ==GL_NO_ERROR); glDrawArrays(GL_LINES, 0, 2); b3Assert(glGetError() ==GL_NO_ERROR); glBindVertexArray(0); glLineWidth(1); b3Assert(glGetError() ==GL_NO_ERROR); glUseProgram(0); }
void Initialize() { printf("Version Pilote OpenGL : %s\n", glGetString(GL_VERSION)); printf("Type de GPU : %s\n", glGetString(GL_RENDERER)); printf("Fabricant : %s\n", glGetString(GL_VENDOR)); printf("Version GLSL : %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION)); int numExtensions; glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions); GLenum error = glewInit(); if (error != GL_NO_ERROR) { // TODO } for (int index = 0; index < numExtensions; ++index) { printf("Extension[%d] : %s\n", index, glGetStringi(GL_EXTENSIONS, index)); } #ifdef _WIN32 // on coupe la synchro vertical pour voir l'effet du delta time wglSwapIntervalEXT(0); #endif basicShader.LoadVertexShader("basic.vs"); basicShader.LoadFragmentShader("basic.fs"); basicShader.Create(); auto program = basicShader.GetProgram(); // UN UBO SERAIT UTILE ICI auto basicProgram = basicShader.GetProgram(); auto blockIndex = glGetUniformBlockIndex(basicProgram, "ViewProj"); GLuint blockBinding = 1; glGenBuffers(1, &g_Camera.UBO); glBindBuffer(GL_UNIFORM_BUFFER, g_Camera.UBO); glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4), glm::value_ptr(g_Camera.projectionMatrix)); glBufferSubData(GL_UNIFORM_BUFFER, sizeof(glm::mat4), sizeof(glm::mat4), glm::value_ptr(g_Camera.viewMatrix)); glBindBufferBase(GL_UNIFORM_BUFFER, blockBinding, g_Camera.UBO); glBindBuffer(GL_UNIFORM_BUFFER, 0); glUniformBlockBinding(basicProgram, blockIndex, blockBinding); previousTime = glutGet(GLUT_ELAPSED_TIME); InitCube(); glBindVertexArray(g_Cube.VAO); glBindVertexArray(g_Cube.IBO); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 3, 0); glEnableVertexAttribArray(1); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 3, (void*)iPosSize); // render states par defaut glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glEnable(GL_CULL_FACE); }
void VertexBufferObject::updateVertices(void const * vertices, unsigned int numBytes, unsigned int byteOffset) { glBindBuffer(GL_ARRAY_BUFFER, arrayBuffer); glBufferSubData(GL_ARRAY_BUFFER, byteOffset, numBytes, vertices); }
void BufferObject::reSetData(const GLvoid *data, GLuint offset, GLuint size) { bind(); glBufferSubData(target, offset, size, data); }
Floor::Floor(const unsigned int width, const unsigned int height): Model(false) { _key = "FLOOR"; Logger_locator::get()(Logger::DBG, "Creating floor"); glm::vec2 ll(-0.5f * (float)width, 0.5f * (float)height); glm::vec2 ur(0.5f * (float)width, -0.5f * (float)height); std::vector<glm::vec3> vert_pos = { glm::vec3(ll.x, 0.0f, ll.y), glm::vec3(ur.x, 0.0f, ll.y), glm::vec3(ll.x, 0.0f, ur.y), glm::vec3(ur.x, 0.0f, ur.y) }; std::vector<glm::vec2> vert_tex_coords = { glm::vec2(0.0f, 0.0f), glm::vec2((float)width, 0.0f), glm::vec2(0.0f, (float)height), glm::vec2((float)width, (float)height) }; std::vector<glm::vec3> vert_normals = { glm::vec3(0.0f, 1.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f) }; std::vector<glm::vec3> vert_tangents = { glm::vec3(1.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f) }; _meshes.emplace_back(); Mesh & mesh = _meshes.back(); mesh.count = vert_pos.size(); _vao.bind(); _vbo.bind(); glBufferData(_vbo.type(), sizeof(glm::vec3) * vert_pos.size() + sizeof(glm::vec2) * vert_tex_coords.size() + sizeof(glm::vec3) * vert_normals.size() + sizeof(glm::vec3) * vert_tangents.size(), NULL, GL_STATIC_DRAW); glBufferSubData(_vbo.type(), 0, sizeof(glm::vec3) * vert_pos.size(), vert_pos.data()); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL); glEnableVertexAttribArray(0); glBufferSubData(_vbo.type(), sizeof(glm::vec3) * vert_pos.size(), sizeof(glm::vec2) * vert_tex_coords.size(), vert_tex_coords.data()); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, (const GLvoid *)(sizeof(glm::vec3) * vert_pos.size())); glEnableVertexAttribArray(1); glBufferSubData(_vbo.type(), sizeof(glm::vec3) * vert_pos.size() + sizeof(glm::vec2) * vert_tex_coords.size(), sizeof(glm::vec3) * vert_normals.size(), vert_normals.data()); glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 0, (const GLvoid *)(sizeof(glm::vec3) * vert_pos.size() + sizeof(glm::vec2) * vert_tex_coords.size())); glEnableVertexAttribArray(2); glBufferSubData(_vbo.type(), sizeof(glm::vec3) * vert_pos.size() + sizeof(glm::vec2) * vert_tex_coords.size() + sizeof(glm::vec3) * vert_normals.size(), sizeof(glm::vec3) * vert_tangents.size(), vert_tangents.data()); glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 0, (const GLvoid *)(sizeof(glm::vec3) * vert_pos.size() + sizeof(glm::vec2) * vert_tex_coords.size() + sizeof(glm::vec3) * vert_normals.size())); glEnableVertexAttribArray(3); glBindVertexArray(0); _mats.emplace_back(); Material & mat = _mats.back(); mat.specular_color = glm::vec3(0.1f, 0.1f, 0.1f); mat.diffuse_map = Texture_2D::create(check_in_pwd("mdl/AncientFlooring.jpg"), GL_RGB8); mat.normal_shininess_map = Texture_2D::create(check_in_pwd("mdl/AncientFlooring_N.jpg"), GL_RGB8); mat.shininess = 500.0f; mesh.mat = &_mats.back(); check_error("Floor::Floor"); }
void TextureAtlas::drawNumberOfQuads(ssize_t numberOfQuads, ssize_t start) { CCASSERT(numberOfQuads>=0 && start>=0, "numberOfQuads and start must be >= 0"); if(!numberOfQuads) return; GL::bindTexture2D(_texture->getName()); if (Configuration::getInstance()->supportsShareableVAO()) { // // Using VBO and VAO // // FIXME:: update is done in draw... perhaps it should be done in a timer if (_dirty) { glBindBuffer(GL_ARRAY_BUFFER, _buffersVBO[0]); // option 1: subdata // glBufferSubData(GL_ARRAY_BUFFER, sizeof(_quads[0])*start, sizeof(_quads[0]) * n , &_quads[start] ); // option 2: data // glBufferData(GL_ARRAY_BUFFER, sizeof(quads_[0]) * (n-start), &quads_[start], GL_DYNAMIC_DRAW); // option 3: orphaning + glMapBuffer glBufferData(GL_ARRAY_BUFFER, sizeof(_quads[0]) * _capacity, nullptr, GL_DYNAMIC_DRAW); void *buf = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY); memcpy(buf, _quads, sizeof(_quads[0])* _totalQuads); glUnmapBuffer(GL_ARRAY_BUFFER); glBindBuffer(GL_ARRAY_BUFFER, 0); _dirty = false; } GL::bindVAO(_VAOname); #if CC_REBIND_INDICES_BUFFER glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _buffersVBO[1]); #endif glDrawElements(GL_TRIANGLES, (GLsizei) numberOfQuads*6, GL_UNSIGNED_SHORT, (GLvoid*) (start*6*sizeof(_indices[0])) ); #if CC_REBIND_INDICES_BUFFER glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); #endif // glBindVertexArray(0); } else { // // Using VBO without VAO // #define kQuadSize sizeof(_quads[0].bl) glBindBuffer(GL_ARRAY_BUFFER, _buffersVBO[0]); // FIXME:: update is done in draw... perhaps it should be done in a timer if (_dirty) { glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(_quads[0]) * _totalQuads , &_quads[0] ); _dirty = false; } GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POS_COLOR_TEX); // vertices glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, kQuadSize, (GLvoid*) offsetof(V3F_C4B_T2F, vertices)); // colors glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, kQuadSize, (GLvoid*) offsetof(V3F_C4B_T2F, colors)); // tex coords glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_TEX_COORD, 2, GL_FLOAT, GL_FALSE, kQuadSize, (GLvoid*) offsetof(V3F_C4B_T2F, texCoords)); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _buffersVBO[1]); glDrawElements(GL_TRIANGLES, (GLsizei)numberOfQuads*6, GL_UNSIGNED_SHORT, (GLvoid*) (start*6*sizeof(_indices[0]))); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); } CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,numberOfQuads*6); CHECK_GL_ERROR_DEBUG(); }
Walls::Walls(const unsigned int width, const unsigned int height): Model(true), _grid(width, height, Grid::MAZEGEN_DFS, 25, 100) { _key = "WALLS"; Logger_locator::get()(Logger::DBG, "Creating walls"); std::vector<glm::vec3> vert_pos; std::vector<glm::vec2> vert_tex_coords; std::vector<glm::vec3> vert_normals; std::vector<glm::vec3> vert_tangents; _meshes.emplace_back(); Mesh & mesh = _meshes.back(); glm::vec3 cell_scale(1.0f, 1.0f, 1.0f); glm::vec3 base(-0.5f * (float)_grid.grid[0].size(), 0.0f, -0.5f * (float)_grid.grid.size()); glm::vec3 left_normal(1.0f, 0.0f, 0.0f); glm::vec3 left_tangent(0.0f, 0.0f, -1.0f); glm::vec3 up_normal(0.0f, 0.0f, 1.0f); glm::vec3 up_tangent(1.0f, 0.0f, 0.0f); // draw border walls for(std::size_t col = 0; col < _grid.grid[0].size(); ++col) { glm::vec3 origin(cell_scale.x * (float)col, 0.0f, cell_scale.z * (float)_grid.grid.size()); origin += base; vert_pos.push_back(origin); vert_pos.push_back(origin + glm::vec3(cell_scale.x, 0.0f, 0.0f)); vert_pos.push_back(origin + glm::vec3(0.0f, cell_scale.y, 0.0f)); vert_pos.push_back(origin + glm::vec3(0.0f, cell_scale.y, 0.0f)); vert_pos.push_back(origin + glm::vec3(cell_scale.x, 0.0f, 0.0f)); vert_pos.push_back(origin + glm::vec3(cell_scale.x, cell_scale.y, 0.0f)); for(int i = 0; i < 6; ++i) { vert_normals.push_back(up_normal); vert_tangents.push_back(up_tangent); } } for(std::size_t row = 0; row < _grid.grid.size(); ++row) { glm::vec3 origin(cell_scale.x * (float)_grid.grid[row].size(), 0.0f, cell_scale.z * (float)row); origin += base; vert_pos.push_back(origin + glm::vec3(0.0f, 0.0f, cell_scale.z)); vert_pos.push_back(origin); vert_pos.push_back(origin + glm::vec3(0.0f, cell_scale.y, cell_scale.z)); vert_pos.push_back(origin + glm::vec3(0.0f, cell_scale.y, cell_scale.z)); vert_pos.push_back(origin); vert_pos.push_back(origin + glm::vec3(0.0f, cell_scale.y, 0.0f)); for(int i = 0; i < 6; ++i) { vert_normals.push_back(left_normal); vert_tangents.push_back(left_tangent); } } // draw cell walls for(std::size_t row = 0; row < _grid.grid.size(); ++row) { for(std::size_t col = 0; col < _grid.grid[row].size(); ++col) { glm::vec3 origin(cell_scale.x * (float)col, 0.0f, cell_scale.y * (float)row); origin += base; if(_grid.grid[row][col].walls[UP]) { vert_pos.push_back(origin); vert_pos.push_back(origin + glm::vec3(cell_scale.x, 0.0f, 0.0f)); vert_pos.push_back(origin + glm::vec3(0.0f, cell_scale.y, 0.0f)); vert_pos.push_back(origin + glm::vec3(0.0f, cell_scale.y, 0.0f)); vert_pos.push_back(origin + glm::vec3(cell_scale.x, 0.0f, 0.0f)); vert_pos.push_back(origin + glm::vec3(cell_scale.x, cell_scale.y, 0.0f)); for(int i = 0; i < 6; ++i) { vert_normals.push_back(up_normal); vert_tangents.push_back(up_tangent); } } if(_grid.grid[row][col].walls[LEFT]) { vert_pos.push_back(origin + glm::vec3(0.0f, 0.0f, cell_scale.z)); vert_pos.push_back(origin); vert_pos.push_back(origin + glm::vec3(0.0f, cell_scale.y, cell_scale.z)); vert_pos.push_back(origin + glm::vec3(0.0f, cell_scale.y, cell_scale.z)); vert_pos.push_back(origin); vert_pos.push_back(origin + glm::vec3(0.0f, cell_scale.y, 0.0f)); for(int i = 0; i < 6; ++i) { vert_normals.push_back(left_normal); vert_tangents.push_back(left_tangent); } } } } // add tex coords for(std::size_t i = 0; i < vert_pos.size(); i += 6) { vert_tex_coords.push_back(glm::vec2(0.0f, 0.0f)); vert_tex_coords.push_back(glm::vec2(1.0f, 0.0f)); vert_tex_coords.push_back(glm::vec2(0.0f, 1.0f)); vert_tex_coords.push_back(glm::vec2(0.0f, 1.0f)); vert_tex_coords.push_back(glm::vec2(1.0f, 0.0f)); vert_tex_coords.push_back(glm::vec2(1.0f, 1.0f)); } mesh.count = vert_pos.size(); _vao.bind(); _vbo.bind(); glBufferData(_vbo.type(), sizeof(glm::vec3) * vert_pos.size() + sizeof(glm::vec2) * vert_tex_coords.size() + sizeof(glm::vec3) * vert_normals.size() + sizeof(glm::vec3) * vert_tangents.size(), NULL, GL_STATIC_DRAW); glBufferSubData(_vbo.type(), 0, sizeof(glm::vec3) * vert_pos.size(), vert_pos.data()); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL); glEnableVertexAttribArray(0); glBufferSubData(_vbo.type(), sizeof(glm::vec3) * vert_pos.size(), sizeof(glm::vec2) * vert_tex_coords.size(), vert_tex_coords.data()); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, (const GLvoid *)(sizeof(glm::vec3) * vert_pos.size())); glEnableVertexAttribArray(1); glBufferSubData(_vbo.type(), sizeof(glm::vec3) * vert_pos.size() + sizeof(glm::vec2) * vert_tex_coords.size(), sizeof(glm::vec3) * vert_normals.size(), vert_normals.data()); glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 0, (const GLvoid *)(sizeof(glm::vec3) * vert_pos.size() + sizeof(glm::vec2) * vert_tex_coords.size())); glEnableVertexAttribArray(2); glBufferSubData(_vbo.type(), sizeof(glm::vec3) * vert_pos.size() + sizeof(glm::vec2) * vert_tex_coords.size() + sizeof(glm::vec3) * vert_normals.size(), sizeof(glm::vec3) * vert_tangents.size(), vert_tangents.data()); glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 0, (const GLvoid *)(sizeof(glm::vec3) * vert_pos.size() + sizeof(glm::vec2) * vert_tex_coords.size() + sizeof(glm::vec3) * vert_normals.size())); glEnableVertexAttribArray(3); glBindVertexArray(0); _mats.emplace_back(); Material & mat = _mats.back(); mat.specular_color = glm::vec3(0.1f, 0.1f, 0.1f); mat.diffuse_map = Texture_2D::create(check_in_pwd("img/GroundCover.jpg"), GL_RGB8); mat.normal_shininess_map = Texture_2D::create(check_in_pwd("img/normals/GroundCover_N.jpg"), GL_RGB8); mat.shininess = 500.0f; mesh.mat = &_mats.back(); check_error("Walls::Walls"); }
// ------------------------------------------------------------------------------------------------- // ------------------------------------------------------------------------------------------------- bool cRender::create_vao_shader(const cShader *shader) { if(!cRender::m_new_render) return false; if(!shader || !m_vertex || !m_normal || !m_color) return false; int size = 0, size_tex = 0; // index buffer index size = m_geometry_type * m_num_geometries * sizeof(GLuint); glGenBuffers(1, &m_ibo_id); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ibo_id); glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, m_index, GL_DYNAMIC_DRAW); // end of index buffer index GLenum error = glGetError(); if(error != GL_NO_ERROR) printf("Error %s - %d\n" __FILE__, __LINE__); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); // vertex buffer object size = 3 * m_num_vertex * sizeof(GLfloat); glGenBuffers(1, &m_vbo_id); glBindBuffer(GL_ARRAY_BUFFER, m_vbo_id); glBufferData(GL_ARRAY_BUFFER, (4 * size) + size_tex, 0, GL_DYNAMIC_DRAW); glBufferSubData(GL_ARRAY_BUFFER, 0, size, m_vertex); glBufferSubData(GL_ARRAY_BUFFER, size, size, m_normal); // to render with texture is not necessary add color data if(m_render_texture) { size_tex = 2 * m_num_vertex * sizeof(GLfloat); glBufferSubData(GL_ARRAY_BUFFER, 2 * size, size_tex, m_texture_coord); } else { glBufferSubData(GL_ARRAY_BUFFER, 2 * size, size, m_color); } // end of vertex buffer object error = glGetError(); if(error != GL_NO_ERROR) printf("Error %s - %d\n" __FILE__, __LINE__); glBindBuffer(GL_ARRAY_BUFFER, 0); // vertex array object glGenVertexArrays(1, &m_vao_id); m_vec_vao_id.push_back(m_vao_id); glBindVertexArray(m_vao_id); glBindBuffer(GL_ARRAY_BUFFER, m_vbo_id); glVertexAttribPointer(shader->m_in_vertex_loc, 3, GL_FLOAT, GL_FALSE, 0, 0); glVertexAttribPointer(shader->m_in_normal_loc, 3, GL_FLOAT, GL_FALSE, 0, (const GLvoid *) (size)); // to render with texture is not necessary add color data if(m_render_texture) glVertexAttribPointer(shader->m_in_texture_coord_loc, 2, GL_FLOAT, GL_FALSE, 0, (const GLvoid *) (2 * size)); else glVertexAttribPointer(shader->m_in_color_loc, 3, GL_FLOAT, GL_FALSE, 0, (const GLvoid *) (2 * size)); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ibo_id); error = glGetError(); if(error != GL_NO_ERROR) printf("Error %s - %d\n" __FILE__, __LINE__); // Enable attributes glEnableVertexAttribArray(shader->m_in_vertex_loc); glEnableVertexAttribArray(shader->m_in_normal_loc); if(m_render_texture) glEnableVertexAttribArray(shader->m_in_texture_coord_loc); else { glEnableVertexAttribArray(shader->m_in_color_loc); } // end of vertex array object // disable glBindVertexArray(0); glDisableVertexAttribArray(shader->m_in_vertex_loc); glDisableVertexAttribArray(shader->m_in_normal_loc); glDisableVertexAttribArray(shader->m_in_color_loc); glDisableVertexAttribArray(shader->m_in_texture_coord_loc); //glDisableVertexAttribArray(shader->m_in_pick_loc); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); return true; }
void init() { // Vertices of a square double ext = 1.0; vec4 points[NumPoints] = { vec4( -ext, -ext, 0, 1.0 ), //v1 vec4( ext, -ext, 0, 1.0 ), //v2 vec4( -ext, ext, 0, 1.0 ), //v3 vec4( -ext, ext, 0, 1.0 ), //v3 vec4( ext, -ext, 0, 1.0 ), //v2 vec4( ext, ext, 0, 1.0 ) //v4 }; // Texture coordinates vec2 tex_coords[NumPoints] = { vec2( 0.0, 0.0 ), vec2( 1.0, 0.0 ), vec2( 0.0, 1.0 ), vec2( 0.0, 1.0 ), vec2( 1.0, 0.0 ), vec2( 1.0, 1.0 ) }; // Initialize texture objects GLuint texture; glGenTextures( 1, &texture ); glBindTexture( GL_TEXTURE_2D, texture ); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, WIN_WIDTH, WIN_HEIGHT, 0, GL_RGB, GL_FLOAT, frame ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); glActiveTexture( GL_TEXTURE0 ); // Create and initialize a buffer object GLuint buffer; glGenBuffers( 1, &buffer ); glBindBuffer( GL_ARRAY_BUFFER, buffer ); glBufferData( GL_ARRAY_BUFFER, sizeof(points) + sizeof(tex_coords), NULL, GL_STATIC_DRAW ); GLintptr offset = 0; glBufferSubData( GL_ARRAY_BUFFER, offset, sizeof(points), points ); offset += sizeof(points); glBufferSubData( GL_ARRAY_BUFFER, offset, sizeof(tex_coords), tex_coords ); // Load shaders and use the resulting shader program GLuint program = InitShader( "vshader.glsl", "fshader.glsl" ); glUseProgram( program ); // set up vertex arrays offset = 0; GLuint vPosition = glGetAttribLocation( program, "vPosition" ); glEnableVertexAttribArray( vPosition ); glVertexAttribPointer( vPosition, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(offset) ); offset += sizeof(points); GLuint vTexCoord = glGetAttribLocation( program, "vTexCoord" ); glEnableVertexAttribArray( vTexCoord ); glVertexAttribPointer( vTexCoord, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(offset) ); glUniform1i( glGetUniformLocation(program, "texture"), 0 ); glClearColor( 1.0, 1.0, 1.0, 1.0 ); }
//Called to update the display. //You should call glutSwapBuffers after all of your rendering to display what you rendered. //If you need continuous updates of the screen, call glutPostRedisplay() at the end of the function. void display() { glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClearDepth(1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); if(g_pConeMesh && g_pCylinderMesh && g_pCubeTintMesh && g_pCubeColorMesh && g_pPlaneMesh) { const glm::vec3 &camPos = ResolveCamPosition(); glutil::MatrixStack camMatrix; camMatrix.SetMatrix(CalcLookAtMatrix(camPos, g_camTarget, glm::vec3(0.0f, 1.0f, 0.0f))); glBindBuffer(GL_UNIFORM_BUFFER, g_GlobalMatricesUBO); glBufferSubData(GL_UNIFORM_BUFFER, sizeof(glm::mat4), sizeof(glm::mat4), glm::value_ptr(camMatrix.Top())); glBindBuffer(GL_UNIFORM_BUFFER, 0); glutil::MatrixStack modelMatrix; //Render the ground plane. { glutil::PushStack push(modelMatrix); modelMatrix.Scale(glm::vec3(100.0f, 1.0f, 100.0f)); glUseProgram(UniformColor.theProgram); glUniformMatrix4fv(UniformColor.modelToWorldMatrixUnif, 1, GL_FALSE, glm::value_ptr(modelMatrix.Top())); glUniform4f(UniformColor.baseColorUnif, 0.302f, 0.416f, 0.0589f, 1.0f); g_pPlaneMesh->Render(); glUseProgram(0); } //Draw the trees DrawForest(modelMatrix); //Draw the building. { glutil::PushStack push(modelMatrix); modelMatrix.Translate(glm::vec3(20.0f, 0.0f, -10.0f)); DrawParthenon(modelMatrix); } if(g_bDrawLookatPoint) { glDisable(GL_DEPTH_TEST); glutil::PushStack push(modelMatrix); modelMatrix.Translate(g_camTarget); modelMatrix.Scale(1.0f, 1.0f, 1.0f); glUseProgram(ObjectColor.theProgram); glUniformMatrix4fv(ObjectColor.modelToWorldMatrixUnif, 1, GL_FALSE, glm::value_ptr(modelMatrix.Top())); g_pCubeColorMesh->Render(); glUseProgram(0); glEnable(GL_DEPTH_TEST); } } glutSwapBuffers(); }
int main(int argc, char *argv[]) { SDL_Surface *screen; // Slightly different SDL initialization if ( SDL_Init(SDL_INIT_VIDEO) != 0 ) { printf("Unable to initialize SDL: %s\n", SDL_GetError()); return 1; } SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); // *new* screen = SDL_SetVideoMode( 640, 480, 16, SDL_OPENGL ); // *changed* if ( !screen ) { printf("Unable to set video mode: %s\n", SDL_GetError()); return 1; } // Set the OpenGL state after creating the context with SDL_SetVideoMode glClearColor( 0, 0, 0, 0 ); #ifndef __EMSCRIPTEN__ glEnable( GL_TEXTURE_2D ); // Need this to display a texture XXX unnecessary in OpenGL ES 2.0/WebGL #endif glViewport( 0, 0, 640, 480 ); glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); // Clear the screen before drawing glClear( GL_COLOR_BUFFER_BIT ); typedef struct Vertex { GLfloat x; GLfloat y; } Vertex; typedef struct Color { GLubyte r; GLubyte g; GLubyte b; GLubyte a; } Color; typedef struct Type1 { Vertex location; Color color; } Type1; typedef struct Type2 { GLuint unused1; Vertex location; GLfloat unused2; Color color; } Type2; Type1 first[3] = { {{-1.0, 0.0}, {0xFF, 0x00, 0x00, 0xFF}}, {{ 0.0, 1.0}, {0x00, 0xFF, 0x00, 0xFF}}, {{ 1.0, 0.0}, {0x00, 0x00, 0xFF, 0xFF}} }; Type2 second[3] = { {0.0, {-1.0, 0.0}, 0.0, {0xFF, 0x00, 0x00, 0xFF}}, {0.0, { 1.0, 0.0}, 0.0, {0x00, 0x00, 0xFF, 0xFF}}, {0.0, { 0.0, -1.0}, 0.0, {0x00, 0xFF, 0x00, 0xFF}}}; // make two vbo objects GLuint vbo[2]; glGenBuffers(2, &vbo[0]); // load the first into the context glBindBuffer(GL_ARRAY_BUFFER, vbo[0]); // allocate enough space for 100 vertices glBufferData(GL_ARRAY_BUFFER, sizeof(Type1)*100, NULL, GL_DYNAMIC_DRAW); // load the second into the context glBindBuffer(GL_ARRAY_BUFFER, vbo[1]); // allocate enough space for 100 vertices glBufferData(GL_ARRAY_BUFFER, sizeof(Type2)*100, NULL, GL_DYNAMIC_DRAW); // DRAW GLbyte * pointer; // Clear the screen before drawing glClear( GL_COLOR_BUFFER_BIT ); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_COLOR_ARRAY); // FIRST // load the first into the context glBindBuffer(GL_ARRAY_BUFFER, vbo[0]); // Load actual data in glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(Type1)*3, &first[0]); // point to the buffer's location data glVertexPointer(2, GL_FLOAT, sizeof(Type1), NULL); pointer = (GLbyte*)(((GLbyte*)&first[0].color) - ((GLbyte*)&first[0].location)); printf("location = %p\n", pointer); // point to the buffer's color data glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Type1), pointer); glDrawArrays(GL_TRIANGLE_STRIP, 0, 3); // SECOND // load the first into the context glBindBuffer(GL_ARRAY_BUFFER, vbo[1]); // Load actual data in glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(Type2)*3, &second[0]); pointer = (GLbyte*)((GLbyte*)&second[0].location - (GLbyte*)&second[0].unused1); // point to the buffer's location data printf("location = %p\n", pointer); glVertexPointer(2, GL_FLOAT, sizeof(Type2), pointer); pointer = (GLbyte*)((GLbyte*)&second[0].color - (GLbyte*)&second[0].unused1); // point to the buffer's location data printf("location = %p\n", pointer); glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Type2), pointer); glDrawArrays(GL_TRIANGLE_STRIP, 0, 3); glDisableClientState(GL_COLOR_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); SDL_GL_SwapBuffers(); #ifndef __EMSCRIPTEN__ // Wait for 3 seconds to give us a chance to see the image SDL_Delay(3000); #endif SDL_Quit(); return 0; }
void SkyBox::draw() { static float size=viewdistance/4; glPushMatrix(); static GLfloat M[16]; #if defined(USE_GLES) static float old_size; int offset; int vtx_size, tex_size; static int vtxA_Offset, vtxB_Offset, vtxC_Offset, vtxD_Offset, vtxE_Offset, vtxF_Offset; static int texA_Offset, texB_Offset, texC_Offset; GLfloat vtxA[] = { -size, -size, size, size, -size, size, size, size, size, -size, size, size }; GLfloat vtxB[] = { -size, -size, -size, -size, size, -size, size, size, -size, size, -size, -size }; GLfloat vtxC[] = { -size, size, -size, -size, size, size, size, size, size, size, size, -size }; GLfloat vtxD[] = { -size, -size, -size, size, -size, -size, size, -size, size, -size, -size, size }; GLfloat vtxE[] = { size, -size, -size, size, size, -size, size, size, size, size, -size, size }; GLfloat vtxF[] = { -size, -size, -size, -size, -size, size, -size, size, size, -size, size, -size }; GLfloat texA[] = { 0, 0, 1, 0, 1, 1, 0, 1 }; GLfloat texB[] = { 1, 0, 1, 1, 0, 1, 0, 0 }; GLfloat texC[] = { 0, 1, 0, 0, 1, 0, 1, 1 }; vtx_size = sizeof(GLfloat)*12; tex_size = sizeof(GLfloat)*8; if(!BufferName) { glGenBuffers(1, &BufferName); glBindBuffer(GL_ARRAY_BUFFER, BufferName); glBufferData(GL_ARRAY_BUFFER, (vtx_size*6)+(tex_size*3), NULL, GL_STATIC_DRAW); } else { glBindBuffer(GL_ARRAY_BUFFER, BufferName); } if (old_size!=size) { vtxA_Offset = offset = 0; glBufferSubData(GL_ARRAY_BUFFER, offset, vtx_size, vtxA); vtxB_Offset = (offset += vtx_size); glBufferSubData(GL_ARRAY_BUFFER, offset, vtx_size, vtxB); vtxC_Offset = (offset += vtx_size); glBufferSubData(GL_ARRAY_BUFFER, offset, vtx_size, vtxC); vtxD_Offset = (offset += vtx_size); glBufferSubData(GL_ARRAY_BUFFER, offset, vtx_size, vtxD); vtxE_Offset = (offset += vtx_size); glBufferSubData(GL_ARRAY_BUFFER, offset, vtx_size, vtxE); vtxF_Offset = (offset += vtx_size); glBufferSubData(GL_ARRAY_BUFFER, offset, vtx_size, vtxF); texA_Offset = (offset += vtx_size); glBufferSubData(GL_ARRAY_BUFFER, offset, tex_size, texA); texB_Offset = (offset += tex_size); glBufferSubData(GL_ARRAY_BUFFER, offset, tex_size, texB); texC_Offset = (offset += tex_size); glBufferSubData(GL_ARRAY_BUFFER, offset, tex_size, texC); } #endif glGetFloatv(GL_MODELVIEW_MATRIX,M); M[12]=0; M[13]=0; M[14]=0; glLoadMatrixf(M); //if(environment==2)glTranslatef(0,blurness*viewdistance/1000,0); if(environment==2)glScalef(1+blurness/1000,1,1+blurness/1000); if(environment!=2) { #if defined(USE_GLES) glColor4f(.85*skyboxr,.85*skyboxg,.95*skyboxb,1.0); #else glColor3f(.85*skyboxr,.85*skyboxg,.95*skyboxb); #endif } else { #if defined(USE_GLES) glColor4f(1*skyboxr,.95*skyboxg,.95*skyboxb,1.0); #else glColor3f(1*skyboxr,.95*skyboxg,.95*skyboxb); #endif } if(!skyboxtexture){ glDisable(GL_TEXTURE_2D); #if defined(USE_GLES) glColor4f(skyboxr*.8,skyboxg*.8,skyboxb*.8,1.0); #else glColor3f(skyboxr*.8,skyboxg*.8,skyboxb*.8); #endif } glDepthMask(0); glDisable(GL_CULL_FACE); glEnable(GL_BLEND); glDisable(GL_LIGHTING); glActiveTexture(GL_TEXTURE0); //glActiveTexture(GL_TEXTURE0_ARB); if(skyboxtexture)glEnable(GL_TEXTURE_2D); glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE ); glBindTexture(GL_TEXTURE_2D, front); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); #if defined(USE_GLES) glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glNormal3f( 0.0f, 0.0f, -1); glVertexPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(vtxA_Offset)); glTexCoordPointer(2, GL_FLOAT, 0, BUFFER_OFFSET(texA_Offset)); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); #else glBegin(GL_QUADS); glNormal3f( 0.0f, 0.0f, -1); glTexCoord2f(0, 0); glVertex3f(-size, -size, size); glTexCoord2f(1, 0); glVertex3f( size, -size, size); glTexCoord2f(1, 1); glVertex3f( size, size, size); glTexCoord2f(0, 1); glVertex3f(-size, size, size); glEnd(); #endif glBindTexture(GL_TEXTURE_2D, back); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); #if defined(USE_GLES) glNormal3f( 0.0f, 0.0f, 1); glVertexPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(vtxB_Offset)); glTexCoordPointer(2, GL_FLOAT, 0, BUFFER_OFFSET(texB_Offset)); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); #else glBegin(GL_QUADS); glNormal3f( 0.0f, 0.0f, 1); glTexCoord2f(1, 0); glVertex3f(-size, -size, -size); glTexCoord2f(1, 1); glVertex3f(-size, size, -size); glTexCoord2f(0, 1); glVertex3f( size, size, -size); glTexCoord2f(0, 0); glVertex3f( size, -size, -size); glEnd(); #endif glBindTexture(GL_TEXTURE_2D, up); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); #if defined(USE_GLES) glNormal3f( 0.0f, -1.0f, 0); glVertexPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(vtxC_Offset)); glTexCoordPointer(2, GL_FLOAT, 0, BUFFER_OFFSET(texC_Offset)); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); #else glBegin(GL_QUADS); glNormal3f( 0.0f, -1.0f, 0); glTexCoord2f(0, 1); glVertex3f(-size, size, -size); glTexCoord2f(0, 0); glVertex3f(-size, size, size); glTexCoord2f(1, 0); glVertex3f( size, size, size); glTexCoord2f(1, 1); glVertex3f( size, size, -size); glEnd(); #endif //if(detail!=0){ glBindTexture(GL_TEXTURE_2D, down); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); #if defined(USE_GLES) glNormal3f( 0.0f, 1.0f, 0); glVertexPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(vtxD_Offset)); glTexCoordPointer(2, GL_FLOAT, 0, BUFFER_OFFSET(texA_Offset)); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); #else glBegin(GL_QUADS); glNormal3f( 0.0f, 1.0f, 0); glTexCoord2f(0, 0); glVertex3f(-size, -size, -size); glTexCoord2f(1, 0); glVertex3f( size, -size, -size); glTexCoord2f(1, 1); glVertex3f( size, -size, size); glTexCoord2f(0, 1); glVertex3f(-size, -size, size); glEnd(); #endif //} glBindTexture(GL_TEXTURE_2D, right); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); #if defined(USE_GLES) glNormal3f( -1.0f, 0.0f, 0); glVertexPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(vtxE_Offset)); glTexCoordPointer(2, GL_FLOAT, 0, BUFFER_OFFSET(texB_Offset)); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); #else glBegin(GL_QUADS); glNormal3f( -1.0f, 0.0f, 0); glTexCoord2f(1, 0); glVertex3f( size, -size, -size); glTexCoord2f(1, 1); glVertex3f( size, size, -size); glTexCoord2f(0, 1); glVertex3f( size, size, size); glTexCoord2f(0, 0); glVertex3f( size, -size, size); glEnd(); #endif glBindTexture(GL_TEXTURE_2D, left); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); #if defined(USE_GLES) glNormal3f( 1.0f, 0.0f, 0); glVertexPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(vtxF_Offset)); glTexCoordPointer(2, GL_FLOAT, 0, BUFFER_OFFSET(texA_Offset)); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); #else glBegin(GL_QUADS); glNormal3f( 1.0f, 0.0f, 0); glTexCoord2f(0, 0); glVertex3f(-size, -size, -size); glTexCoord2f(1, 0); glVertex3f(-size, -size, size); glTexCoord2f(1, 1); glVertex3f(-size, size, size); glTexCoord2f(0, 1); glVertex3f(-size, size, -size); glEnd(); #endif /* glEnable(GL_BLEND); glColor4f(1,1,1,1); glBindTexture(GL_TEXTURE_2D, cloud); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glBegin(GL_QUADS); glNormal3f( 0.0f, -1.0f, 0); glTexCoord2f(0, (1+cloudmove)*30); glVertex3f(-size, size/200, -size); glTexCoord2f(0, 0); glVertex3f(-size, size/200, size); glTexCoord2f((1+cloudmove)*30, 0); glVertex3f( size, size/200, size); glTexCoord2f((1+cloudmove)*30, (1+cloudmove)*30); glVertex3f( size, size/200, -size); glEnd(); glDisable(GL_BLEND);*/ glEnable(GL_CULL_FACE); glDepthMask(1); glPopMatrix(); #if defined(USE_GLES) glBindBuffer(GL_ARRAY_BUFFER,0); old_size = size; #endif }
// Update texture coordinates for a vbo void _Graphics::UpdateVBOTextureCoords(int VBO, float *Data) { glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer[VBO]); glBufferSubData(GL_ARRAY_BUFFER, sizeof(float) * 8, sizeof(float) * 8, (GLvoid *)(&Data[0])); }
void LightRenderer::renderToBackbuffer() { glEnable(GL_BLEND); Debug::checkGLError(); glBindFramebuffer(GL_FRAMEBUFFER, 0); Debug::checkGLError(); m_shaderPassthrough->bindProgram(); Debug::checkGLError(); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, m_fboTexture); Debug::checkGLError(); GLint lightFBOLoc = glGetUniformLocation(m_shaderPassthrough->shaderProgram(), "lightFBO"); glUniform1i(lightFBOLoc, 0); Debug::checkGLError(); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, m_tileRendererTexture); GLint tileFBOLoc = glGetUniformLocation(m_shaderPassthrough->shaderProgram(), "tileFBO"); glUniform1i(tileFBOLoc, 1); Debug::checkGLError(); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_eboBackbuffer); glBindBuffer(GL_ARRAY_BUFFER, m_vboBackbuffer); glBindVertexArray(m_vaoBackbuffer); Debug::checkGLError(); int index = 0; // vertices that will be uploaded. Vertex vertices[4]; // vertices[n][0] -> X, and [1] -> Y // vertices[0] -> top left // vertices[1] -> bottom left // vertices[2] -> bottom right // vertices[3] -> top right // const glm::vec2& position = torch->position(); // const float radius = torch->radius(); float x = -1.0f; //position.x - radius; float width = 1.0f; //position.x + radius; float y = 1.0f; //position.y - radius; float height = -1.0f; //position.y + radius; vertices[0].x = x; // top left X vertices[0].y = y; //top left Y vertices[1].x = x; // bottom left X vertices[1].y = height; // bottom left Y vertices[2].x = width; // bottom right X vertices[2].y = height; //bottom right Y vertices[3].x = width; // top right X vertices[3].y = y; // top right Y Debug::checkGLError(); // copy color to the buffer for (size_t i = 0; i < sizeof(vertices) / sizeof(*vertices); i++) { // *colorp = color.bgra; uint8_t red = 255; uint8_t blue = 255; uint8_t green = 255; uint8_t alpha = 255; int32_t color = red | (green << 8) | (blue << 16) | (alpha << 24); vertices[i].color = color; } // copy texcoords to the buffer vertices[0].u = vertices[1].u = 0.0f; vertices[0].v = vertices[3].v = 1.0f; vertices[1].v = vertices[2].v = 0.0f; vertices[2].u = vertices[3].u = 1.0f; Debug::checkGLError(); // finally upload everything to the actual vbo glBindBuffer(GL_ARRAY_BUFFER, m_vboBackbuffer); glBufferSubData( GL_ARRAY_BUFFER, sizeof(vertices) * 0, sizeof(vertices), vertices); Debug::checkGLError(); Debug::checkGLError(); ////////////////////////////////FINALLY RENDER IT ALL ////////////////////////////////////////// glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_eboBackbuffer); glBindBuffer(GL_ARRAY_BUFFER, m_vboBackbuffer); glBindVertexArray(m_vaoBackbuffer); Debug::checkGLError(); Debug::checkGLError(); glDrawElements( GL_TRIANGLES, 6 * (1), // 6 indices per 2 triangles GL_UNSIGNED_INT, (const GLvoid*)0); Debug::checkGLError(); m_shaderPassthrough->unbindProgram(); glDisable(GL_BLEND); Debug::checkGLError(); glBindVertexArray(0); Debug::checkGLError(); glBindBuffer(GL_ARRAY_BUFFER, 0); Debug::checkGLError(); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glActiveTexture(GL_TEXTURE0); Debug::checkGLError(); }
static GHL_GL_API void _glBufferSubData (GLenum target, GL::GLintptr offset, GL::GLsizeiptr size, const GLvoid *data) { glBufferSubData(target, offset, size, data); }
//FIXME: TODO: take a slightly different approach, clear to white instead, draw black whereever there are tiles that have back-tiles, and then draw user-placed lights which would brighten up those tiles void LightRenderer::renderToFBO() { m_camera->setShader(m_shader); m_shader->bindProgram(); Debug::checkGLError(); glBindFramebuffer(GL_FRAMEBUFFER, m_fbo); glBindRenderbuffer(GL_RENDERBUFFER, m_rb); if (m_renderingEnabled) { glClearColor(0.f, 0.f, 0.f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); } else { //clear the lightmap to all white, aka no darkness at all, and don't bother rendering light sources //NOTE: this is just for debugging purposes..don't plan on ever using it for anything else, you sick, sick bastard... glClearColor(1.f, 1.f, 1.f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); return; } glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, m_torchLightTexture); GLint lightMapLoc = glGetUniformLocation(m_shader->shaderProgram(), "lightMap"); glUniform1i(lightMapLoc, 0); GLint timeLoc = glGetUniformLocation(m_shader->shaderProgram(), "time"); glUniform1f(timeLoc, float(SDL_GetTicks())); int index = 0; Debug::checkGLError(); for (Torch * torch : m_torches) { // vertices that will be uploaded. Vertex vertices[4]; // vertices[n][0] -> X, and [1] -> Y // vertices[0] -> top left // vertices[1] -> bottom left // vertices[2] -> bottom right // vertices[3] -> top right const glm::vec2& position = torch->position(); const float radius = torch->radius(); float x = position.x - radius; float width = position.x + radius; float y = position.y - radius; float height = position.y + radius; vertices[0].x = x; // top left X vertices[0].y = y; //top left Y vertices[1].x = x; // bottom left X vertices[1].y = height; // bottom left Y vertices[2].x = width; // bottom right X vertices[2].y = height; //bottom right Y vertices[3].x = width; // top right X vertices[3].y = y; // top right Y Debug::checkGLError(); // copy color to the buffer for (size_t i = 0; i < sizeof(vertices) / sizeof(*vertices); i++) { // *colorp = color.bgra; uint8_t red = 255; uint8_t green = 255; uint8_t blue = 255; uint8_t alpha = 255; int32_t color = red | (green << 8) | (blue << 16) | (alpha << 24); vertices[i].color = color; } // copy texcoords to the buffer vertices[0].u = vertices[1].u = 0.0f; vertices[0].v = vertices[3].v = 1.0f; vertices[1].v = vertices[2].v = 0.0f; vertices[2].u = vertices[3].u = 1.0f; Debug::checkGLError(); // finally upload everything to the actual vbo glBindBuffer(GL_ARRAY_BUFFER, m_vbo); glBufferSubData( GL_ARRAY_BUFFER, sizeof(vertices) * index, sizeof(vertices), vertices); Debug::checkGLError(); ++index; } Debug::checkGLError(); ////////////////////////////////FINALLY RENDER IT ALL ////////////////////////////////////////// glEnable(GL_BLEND); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ebo); glBindBuffer(GL_ARRAY_BUFFER, m_vbo); glBindVertexArray(m_vao); Debug::checkGLError(); glDrawElements( GL_TRIANGLES, 6 * (m_torches.size()), // 6 indices per 2 triangles GL_UNSIGNED_INT, (const GLvoid*)0); Debug::checkGLError(); m_shader->unbindProgram(); Debug::checkGLError(); glBindVertexArray(0); Debug::checkGLError(); glBindBuffer(GL_ARRAY_BUFFER, 0); Debug::checkGLError(); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); Debug::checkGLError(); glDisable(GL_BLEND); Debug::checkGLError(); glBindFramebuffer(GL_FRAMEBUFFER, 0); glBindRenderbuffer(GL_RENDERBUFFER, 0); }
void BoundingBox::Set(int index, int value) { glBindBuffer(GL_SHADER_STORAGE_BUFFER, s_bbox_buffer_id); glBufferSubData(GL_SHADER_STORAGE_BUFFER, index * sizeof(int), sizeof(int), &value); glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0); }
void Cylinder::init(const char *textureFile) { m_textureOn = (textureFile[0] != '\0')? true: false; // Allocate space for vertices memAlloc(); m_circlePoints = new vec2[m_numDivisions]; generateCylinder(); // generate cylinder points // Create a vertex array object #ifdef __APPLE__ glGenVertexArraysAPPLE(1, &m_vertexArrayObject); glBindVertexArrayAPPLE(m_vertexArrayObject); #else glGenVertexArrays(1, &m_vertexArrayObject); glBindVertexArray(m_vertexArrayObject); #endif // Create a buffer object glGenBuffers(1, &m_vertexBufferObject); glBindBuffer(GL_ARRAY_BUFFER, m_vertexBufferObject); // Initialize buffer glBufferData(GL_ARRAY_BUFFER, (sizeof(m_vertices[0]) + sizeof(m_normals[0]) + sizeof(m_textureUV[0]))*m_numVertices + sizeof(m_edges[0])*m_numEdges, NULL, GL_STATIC_DRAW); glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(m_vertices[0])*m_numVertices, m_vertices); glBufferSubData(GL_ARRAY_BUFFER, sizeof(m_vertices[0])*m_numVertices, sizeof(m_edges[0])*m_numEdges, m_edges); glBufferSubData(GL_ARRAY_BUFFER, sizeof(m_vertices[0])*m_numVertices + sizeof(m_edges[0])*m_numEdges, sizeof(m_normals[0])*m_numVertices, m_normals); glBufferSubData(GL_ARRAY_BUFFER, (sizeof(m_vertices[0]) + sizeof(m_normals[0]))*m_numVertices + sizeof(m_edges[0])*m_numEdges, sizeof(m_textureUV[0])*m_numVertices, m_textureUV); // Load shaders and use the resulting shader program m_program = InitShader("vshader.glsl", "fshader.glsl"); glUseProgram(m_program); // Specify vertex positions as an input to the shader program GLuint position = glGetAttribLocation(m_program, "vPosition"); glEnableVertexAttribArray(position); glVertexAttribPointer(position, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0)); // Specify normal vectors as an input to the shader program GLuint normal = glGetAttribLocation(m_program, "vNormal"); glEnableVertexAttribArray(normal); glVertexAttribPointer(normal, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(sizeof(m_vertices[0])*m_numVertices + sizeof(m_edges[0])*m_numEdges)); // Specify texture positions as an input to the shader program GLuint texture = glGetAttribLocation(m_program, "vTexture"); glEnableVertexAttribArray(texture); glVertexAttribPointer(texture, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET((sizeof(m_vertices[0]) + sizeof(m_normals[0]))*m_numVertices + sizeof(m_edges[0])*m_numEdges)); // Load image TgaImage image; if(m_textureOn && !image.loadTGA(textureFile)) { printf("Error loading image file\n"); exit(1); } // Bind texture glGenTextures(1, &m_textureBufferObject); glBindTexture(GL_TEXTURE_2D, m_textureBufferObject); glTexImage2D(GL_TEXTURE_2D, 0, 4, image.width, image.height, 0, (image.byteCount == 3) ? GL_BGR : GL_BGRA, GL_UNSIGNED_BYTE, image.data); glGenerateMipmap(GL_TEXTURE_2D); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glUniform1i(glGetUniformLocation(m_program, "Tex"), 0); // Clean up delete [] m_vertices; delete [] m_edges; delete [] m_textureUV; delete [] m_normals; delete [] m_circlePoints; }
void ParticleMesh::calculate(LevelsetCollider &LC, int size, float r, float mass) { float scale = 2 * r / (LC.gridStep*(LC.gridSize.x - 4) / size); vec3<double> center = vec3<double>(0, 0, 0); vec3<double> MaxB = LC.MaxBoundary; vec3<double> MinB = LC.MinBoundary; scale = CalScale(MaxB, MinB, r, size); int index_par = 0; par_list = new triple[20000]; sdf_list = new SDF[20000]; float step = r * 2 / scale; for (int i = 0; i < size; i++) { for (int j = 0; j < size; j++) { for (int k = 0; k <size; k++) { vec3<int> gridPos = vec3<int>(i, j, k); vec3<double> pos = vec3<double>(i + 0.5, j + 0.5, k + 0.5) * (2 * r / scale) + MinB; int gridInd = dot(gridPos, LC.gridSizeOffset); double sdf = 0; LC.getGridDist(pos, sdf); if (sdf < 0 && sdf > -r * 2 / scale * 2) { vec3<double> pos_par = pos - MinB;// -vec3<double>(0.5, 0.5, 0.5) * (2 * r / scale); center += mass*pos_par * scale; par_list[index_par].x[0] = pos_par.x * scale; par_list[index_par].x[1] = pos_par.y * scale; par_list[index_par].x[2] = pos_par.z * scale; sdf_list[index_par].sdf = sdf * scale; vec3<double> gradient; LC.checkCollision(pos, sdf, gradient, -1); sdf_list[index_par].gradient[0] = gradient.x; sdf_list[index_par].gradient[1] = gradient.y; sdf_list[index_par].gradient[2] = gradient.z; index_par++; } } } } center /= index_par*mass; float3 center_f3 = make_float3(center[0], center[1], center[2]); m_totalParticles = index_par; m_totalConnectedPoints = LC.meshModel->m_totalConnectedPoints; m_totalFaces = LC.meshModel->m_totalFaces; float3 vertex,relative; mp_vertexXYZ = new float[m_totalConnectedPoints * 3]; Relative_Vertex = new float3[m_totalConnectedPoints]; mp_vertexNorm = new float[m_totalConnectedPoints * 3]; mp_vertexRGB = new float[m_totalConnectedPoints * 3]; for (int i = 0; i < m_totalConnectedPoints; i++) { vertex.x = LC.meshModel->mp_vertexXYZ[i * 3]; vertex.y = LC.meshModel->mp_vertexXYZ[i * 3 + 1]; vertex.z = LC.meshModel->mp_vertexXYZ[i * 3 + 2]; //vertex *= scale; vertex -= make_float3(MinB[0], MinB[1], MinB[2]);// +make_float3(0.5, 0.5, 0.5) * (2 * r / scale); vertex *= scale; relative = vertex - center_f3; *(float3*)(mp_vertexXYZ + i * 3) = vertex; mp_vertexRGB[i * 3] = LC.meshModel->mp_vertexRGB[i * 3]; mp_vertexRGB[i * 3 + 1] = LC.meshModel->mp_vertexRGB[i * 3 + 1]; mp_vertexRGB[i * 3 + 2] = LC.meshModel->mp_vertexRGB[i * 3 + 2]; mp_vertexNorm[i * 3] = 0; //LC.meshModel->mp_vertexNorm[i * 3]; mp_vertexNorm[i * 3 + 1] = 0; //LC.meshModel->mp_vertexNorm[i * 3 + 1]; mp_vertexNorm[i * 3 + 2] = 0;// LC.meshModel->mp_vertexNorm[i * 3 + 2]; Relative_Vertex[i] = relative; } FaceVerInd = new uint[3 * m_totalFaces]; //memcpy(FaceVerInd, LC.meshModel->mp_face, 9 * m_totalFaces * sizeof(uint)); float3 n; for (int i = 0; i < m_totalFaces; i++) { uint i_1 = FaceVerInd[3 * i] = LC.meshModel->mp_face[3 * i]; uint i_2 = FaceVerInd[3 * i + 1] = LC.meshModel->mp_face[3 * i + 1]; uint i_3 = FaceVerInd[3 * i + 2] = LC.meshModel->mp_face[3 * i + 2]; float3 v1 = make_float3(mp_vertexXYZ[i_1 * 3], mp_vertexXYZ[i_1 * 3 + 1], mp_vertexXYZ[i_1 * 3 + 2]); float3 v2 = make_float3(mp_vertexXYZ[i_2 * 3], mp_vertexXYZ[i_2 * 3 + 1], mp_vertexXYZ[i_2 * 3 + 2]); float3 v3 = make_float3(mp_vertexXYZ[i_3 * 3], mp_vertexXYZ[i_3 * 3 + 1], mp_vertexXYZ[i_3 * 3 + 2]); float3 e12 = v2 - v1; float3 e13 = v3 - v1; n = cross(e12, e13); n /= length(n); mp_vertexNorm[i_1 * 3] += n.x; mp_vertexNorm[i_1 * 3 + 1] += n.y; mp_vertexNorm[i_1 * 3 + 2] += n.z; //atomicAdd(&num_tri_per_point[i_1], 1); float3 e21 = -e12; float3 e23 = v3 - v2; n = cross(e23, e21); n /= length(n); mp_vertexNorm[i_2 * 3] += n.x; mp_vertexNorm[i_2 * 3 + 1] += n.y; mp_vertexNorm[i_2 * 3 + 2] += n.z; //atomicAdd(&num_tri_per_point[i_2], 1); float3 e31 = -e13; float3 e32 = -e23; n = cross(e31, e32); n /= length(n); mp_vertexNorm[i_3 * 3] += n.x; mp_vertexNorm[i_3 * 3 + 1] += n.y; mp_vertexNorm[i_3 * 3 + 2] += n.z; } for (int i = 0; i < m_totalConnectedPoints; i++) { float3 n = make_float3(mp_vertexNorm[i * 3], mp_vertexNorm[i * 3 + 1], mp_vertexNorm[i * 3 + 2]); mp_vertexNorm[i * 3] /= length(n); mp_vertexNorm[i * 3 + 1] /= length(n); mp_vertexNorm[i * 3 + 2] /= length(n); } m_vertexVbo = createVBO(m_totalConnectedPoints * 3 * sizeof(float)); registerGLBufferObject(m_vertexVbo, &m_cuda_vertexvbo_resource); m_indexVBO = createVBO(3 * m_totalFaces * sizeof(uint)); registerGLBufferObject(m_indexVBO, &m_cuda_indexvbo_resource); m_colorVBO = createVBO(m_totalConnectedPoints * 3 * sizeof(float)); registerGLBufferObject(m_colorVBO, &m_cuda_colorvbo_resource); m_NorVBO = createVBO(m_totalConnectedPoints * 3 * sizeof(float)); registerGLBufferObject(m_NorVBO, &m_cuda_normalvbo_resource); unregisterGLBufferObject(m_cuda_vertexvbo_resource); glBindBuffer(GL_ARRAY_BUFFER, m_vertexVbo); glBufferSubData(GL_ARRAY_BUFFER, 0, m_totalConnectedPoints * 3 * sizeof(float), mp_vertexXYZ); glBindBuffer(GL_ARRAY_BUFFER, 0); registerGLBufferObject(m_vertexVbo, &m_cuda_vertexvbo_resource); unregisterGLBufferObject(m_cuda_indexvbo_resource); glBindBuffer(GL_ARRAY_BUFFER, m_indexVBO); glBufferSubData(GL_ARRAY_BUFFER, 0, 3 * m_totalFaces * sizeof(uint), FaceVerInd); glBindBuffer(GL_ARRAY_BUFFER, 0); registerGLBufferObject(m_indexVBO, &m_cuda_indexvbo_resource); unregisterGLBufferObject(m_cuda_colorvbo_resource); glBindBuffer(GL_ARRAY_BUFFER, m_colorVBO); glBufferSubData(GL_ARRAY_BUFFER, 0, m_totalConnectedPoints * 3 * sizeof(float), mp_vertexRGB); glBindBuffer(GL_ARRAY_BUFFER, 0); registerGLBufferObject(m_colorVBO, &m_cuda_colorvbo_resource); unregisterGLBufferObject(m_cuda_normalvbo_resource); glBindBuffer(GL_ARRAY_BUFFER, m_NorVBO); glBufferSubData(GL_ARRAY_BUFFER, 0, m_totalConnectedPoints * 3 * sizeof(float), mp_vertexNorm); glBindBuffer(GL_ARRAY_BUFFER, 0); registerGLBufferObject(m_NorVBO, &m_cuda_normalvbo_resource); allocateArray((void**)&dRelative_Vertex, m_totalConnectedPoints * 3 * sizeof(float)); copyArrayToDevice(dRelative_Vertex, Relative_Vertex, 0, m_totalConnectedPoints * 3 * sizeof(float)); hasMesh = true; }
void kore::Mesh:: createAttributeBuffers(const kore::EMeshBufferType bufferType) { if (_attributes.size() == 0) { Log::getInstance()->write("[ERROR] Can't create GL buffer objects for Mesh" "%s because it has no loaded attributes!", _name.c_str()); return; } glGenVertexArrays(1,&_VAOloc); glBindVertexArray(_VAOloc); GLuint uVBO; glGenBuffers(1, &uVBO); // Determine byte-size needed for the VBO uint uBufferSizeByte = 0; for (uint iAtt = 0; iAtt < _attributes.size(); ++iAtt) { MeshAttributeArray& rAttArray = _attributes[iAtt]; uBufferSizeByte += rAttArray.byteSize * (rAttArray.numValues / rAttArray.numComponents); } glBindBuffer(GL_ARRAY_BUFFER, uVBO); glBufferData(GL_ARRAY_BUFFER, (uBufferSizeByte), NULL, GL_STATIC_DRAW ); // In case of sequential layout: add all attribute arrays sequentially // into the buffer uint byteOffset = 0; if (bufferType == BUFFERTYPE_SEQUENTIAL) { for (uint iAtt = 0; iAtt < _attributes.size(); ++iAtt) { MeshAttributeArray& rAttArray = _attributes[iAtt]; uint attribArrayByteSize = rAttArray.byteSize * (rAttArray.numValues / rAttArray.numComponents); glBufferSubData(GL_ARRAY_BUFFER, byteOffset, attribArrayByteSize, rAttArray.data); free(rAttArray.data); // Delete the attribute-list rAttArray.data = reinterpret_cast<void*>(byteOffset); // Data now has the value of the offset in the // VBO to this attribute list. // (always 0 for sequential layout) rAttArray.stride = 0; byteOffset += attribArrayByteSize; } } else if (bufferType == BUFFERTYPE_INTERLEAVED) { uint stride = 0; const uint numVertices = _numVertices; for (uint iVert = 0; iVert < numVertices; ++iVert) { stride = 0; for(uint iAtt = 0; iAtt < _attributes.size(); ++iAtt) { MeshAttributeArray& rAttArray = _attributes[iAtt]; stride += rAttArray.byteSize; // Calculate the address of the current element. // Note: We are assuming that every attribute consists of floats here float* pDataPointer = static_cast<float*>(rAttArray.data); pDataPointer = &pDataPointer[iVert * rAttArray.numComponents]; glBufferSubData(GL_ARRAY_BUFFER, byteOffset, rAttArray.byteSize, pDataPointer); byteOffset += rAttArray.byteSize; } // End Attributes } // End Vertices // Now loop through attributes again to delete the attribute list and set // the correct offset value. uint offset = 0; for(uint iAtt = 0; iAtt < _attributes.size(); ++iAtt) { MeshAttributeArray& rAttArray = _attributes[iAtt]; free(rAttArray.data); rAttArray.data = reinterpret_cast<void*>(offset); rAttArray.stride = stride; offset += rAttArray.byteSize; } } // End Interleaved _VBOloc = uVBO; glBindBuffer(GL_ARRAY_BUFFER, 0); // Load indices into IBO if (_indices.size() > 0) { GLuint uIBO; glGenBuffers(1, &uIBO); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, uIBO); // TODO(dlazarek) implement other index-sizes (currently assumung a // byte-size of 4 for each element) glBufferData(GL_ELEMENT_ARRAY_BUFFER, _indices.size() * 4, &_indices[0], GL_STATIC_DRAW); _IBOloc = uIBO; glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); } }