static void Init(void) { const GLubyte *version; static const char *vertShaderText = "#version 150 \n" "uniform mat4 ModelViewProjection; \n" "in vec4 Vertex; \n" "void main() \n" "{ \n" " gl_Position = ModelViewProjection * Vertex; \n" "} \n"; static const char *geomShaderText = "#version 150 \n" "layout(triangles) in; \n" "layout(triangle_strip, max_vertices = 3) out; \n" "uniform vec2 ViewportSize; \n" "out vec2 Vert0, Vert1, Vert2; \n" "\n" "// Transform NDC coord to window coord \n" "vec2 vpxform(vec4 p) \n" "{ \n" " return (p.xy / p.w + 1.0) * 0.5 * ViewportSize; \n" "} \n" "\n" "void main() \n" "{ \n" " Vert0 = vpxform(gl_in[0].gl_Position); \n" " Vert1 = vpxform(gl_in[1].gl_Position); \n" " Vert2 = vpxform(gl_in[2].gl_Position); \n" " gl_Position = gl_in[0].gl_Position; \n" " EmitVertex(); \n" " gl_Position = gl_in[1].gl_Position; \n" " EmitVertex(); \n" " gl_Position = gl_in[2].gl_Position; \n" " EmitVertex(); \n" "} \n"; static const char *fragShaderText = "#version 150 \n" "#define LINE_WIDTH 2.5 \n" "uniform vec4 Color; \n" "in vec2 Vert0, Vert1, Vert2; \n" "out vec4 FragColor; \n" "// Compute distance from a point to a line \n" "float point_line_dist(vec2 p, vec2 v1, vec2 v2) \n" "{ \n" " float s = (v2.x - v1.x) * (v1.y - p.y) - (v1.x - p.x) * (v2.y - v1.y); \n" " float t = length(v2 - v1); \n" " return abs(s) / t; \n" "} \n" "\n" "void main() \n" "{ \n" " float d0 = point_line_dist(gl_FragCoord.xy, Vert0, Vert1); \n" " float d1 = point_line_dist(gl_FragCoord.xy, Vert1, Vert2); \n" " float d2 = point_line_dist(gl_FragCoord.xy, Vert2, Vert0); \n" " float m = min(d0, min(d1, d2)); \n" " FragColor = Color * smoothstep(0.0, LINE_WIDTH, m); \n" "} \n"; static const GLfloat verts[3][2] = { { -1, -1 }, { 1, -1 }, { 0, 1 } }; if (!ShadersSupported()) exit(1); if (!GLEW_VERSION_3_2) { fprintf(stderr, "Sorry, OpenGL 3.2 or later required.\n"); exit(1); } VertShader = CompileShaderText(GL_VERTEX_SHADER, vertShaderText); FragShader = CompileShaderText(GL_FRAGMENT_SHADER, fragShaderText); GeomShader = CompileShaderText(GL_GEOMETRY_SHADER, geomShaderText); Program = LinkShaders3(VertShader, GeomShader, FragShader); assert(Program); CheckError(__LINE__); glBindAttribLocation(Program, 0, "Vertex"); glBindFragDataLocation(Program, 0, "FragColor"); /* relink */ glLinkProgram(Program); assert(glIsProgram(Program)); assert(glIsShader(FragShader)); assert(glIsShader(VertShader)); assert(glIsShader(GeomShader)); glUseProgram(Program); uViewportSize = glGetUniformLocation(Program, "ViewportSize"); uModelViewProj = glGetUniformLocation(Program, "ModelViewProjection"); uColor = glGetUniformLocation(Program, "Color"); glUniform4fv(uColor, 1, Orange); glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW); glGenVertexArrays(1, &vao); glBindVertexArray(vao); glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL); glEnableVertexAttribArray(0); glClearColor(0.3f, 0.3f, 0.3f, 0.0f); glEnable(GL_DEPTH_TEST); printf("GL_RENDERER = %s\n",(const char *) glGetString(GL_RENDERER)); }
void Vec4ArrayShaderUniform::apply() { glUniform4fv(getLocation(), length, glm::value_ptr(value[0])); }
void uniform(const char* loc, const vec4& v) { GLuint index = glGetUniformLocation(program, loc); glUniform4fv(index, 1, glm::value_ptr(v)); }
void ShaderProgram::setUniform(const char *name, const glm::vec4 *v, GLsizei count) { int index = glGetUniformLocation(shaderProgram, name); // Sends the uniform to the shader glUniform4fv(index, count, &v[0][0]); }
//--Implementations void render() { //--Render the scene //clear the screen glClearColor(0.0, 0.0, 0.2, 1.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //premultiply the matrix for this example mv = view * model; //enable the shader program glUseProgram(program); //upload the matrix to the shader glUniform4fv(loc_dp,1,glm::value_ptr(DP)); glUniform4fv(loc_dp,1,glm::value_ptr(SP)); glUniform1f(loc_shininess,shininess); glUniformMatrix4fv(loc_modelView, 1, GL_FALSE, glm::value_ptr(mv)); glUniformMatrix4fv(loc_projection, 1, GL_FALSE, glm::value_ptr(projection)); glUniform3fv(loc_slColor, 1, spotLight.color); glUniform3fv(loc_slPosition, 1, spotLight.position); glUniform3fv(loc_slDirection, 1, spotLight.direction); glUniform1f( loc_slFOV, spotLight.fov); glUniform1i( loc_slOn, spotLight.on); glUniform3fv(loc_plColor, 1, pointLight.color); glUniform3fv(loc_plPosition, 1, pointLight.position); glUniform1i( loc_plOn, pointLight.on); glUniform3fv(loc_dlColor, 1, distantLight.color); glUniform3fv(loc_dlDirection, 1, distantLight.direction); glUniform1i( loc_dlOn, distantLight.on); glUniform3fv(loc_alColor, 1, ambientLight.color); glUniform1i( loc_alOn, ambientLight.on); //set up the Vertex Buffer Object so it can be drawn glEnableVertexAttribArray(loc_position); glEnableVertexAttribArray(loc_color); glEnableVertexAttribArray(loc_norm); glBindBuffer(GL_ARRAY_BUFFER, vbo_geometry); //set pointers into the vbo for each of the attributes(position and color) glVertexAttribPointer( loc_position,//location of attribute 3,//number of elements GL_FLOAT,//type GL_FALSE,//normalized? sizeof(Vertex),//stride (void*)offsetof(Vertex,position));//offset glVertexAttribPointer( loc_color, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex,color)); glVertexAttribPointer( loc_norm, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex,normal)); glDrawArrays(GL_TRIANGLES, 0, vertexCount);//mode, starting index, count //clean up glDisableVertexAttribArray(loc_position); glDisableVertexAttribArray(loc_color); glDisableVertexAttribArray(loc_norm); //swap the buffers glutSwapBuffers(); }
//-------------------------------------------------------------------------------------- // Name: DrawSkinnedMesh() // Desc: Draw the skinned mesh //-------------------------------------------------------------------------------------- VOID CSample::DrawSkinnedMesh() { // Set the skinning shader glUseProgram( m_hSkinningShader ); // Create the view matrix m_matView = FrmMatrixLookAtRH( m_cameraPosition, m_cameraLookAt, m_cameraUp ); // Set view and projection matrices glUniformMatrix4fv( m_SkinningConstants.m_slotViewMatrix, 1, FALSE, (FLOAT32*) &m_matView ); glUniformMatrix4fv( m_SkinningConstants.m_slotProjMatrix, 1, FALSE, (FLOAT32*) &m_matProj ); // Set camera and light positions glUniform3fv( m_SkinningConstants.m_slotCameraPosition, 1, (FLOAT32*) &m_cameraPosition ); glUniform3fv( m_SkinningConstants.m_slotLightPosition, 1, (FLOAT32*) &m_lightPosition ); // Set material color properties FRMVECTOR3 vAmbient( 0.05f, 0.05f, 0.05f ); FRMVECTOR4 vDiffuse( 1.0f, 0.5f, 0.5f, 1.0f ); FRMVECTOR4 vSpecular( 0.5f, 0.5f, 0.5f, 1.0f ); FLOAT32 fShininess = 16.0f; glUniform3fv( m_SkinningConstants.m_slotMaterialAmbient, 1, (FLOAT32*) &vAmbient ); glUniform4fv( m_SkinningConstants.m_slotMaterialDiffuse, 1, (FLOAT32*) &vDiffuse ); glUniform4fv( m_SkinningConstants.m_slotMaterialSpecular, 1, (FLOAT32*) &vSpecular ); glUniform1f( m_SkinningConstants.m_slotMaterialShininess, fShininess ); // Render each of the meshes for ( INT32 meshIndex = 0; meshIndex < m_pModel->NumMeshes; ++meshIndex ) { Adreno::Mesh* pMesh = m_pModel->Meshes + meshIndex; // Set vertex buffer FrmSetVertexBuffer( m_hVertexBuffer[meshIndex] ); // Set vertex attributes Adreno::VertexProperty* pPositionProperty = pMesh->Vertices.Format.Properties + m_vertexFormatMap[meshIndex].position; Adreno::VertexProperty* pNormalProperty = pMesh->Vertices.Format.Properties + m_vertexFormatMap[meshIndex].normal; Adreno::VertexProperty* pTangentProperty = pMesh->Vertices.Format.Properties + m_vertexFormatMap[meshIndex].tangent; Adreno::VertexProperty* pBinormalProperty = pMesh->Vertices.Format.Properties + m_vertexFormatMap[meshIndex].binormal; Adreno::VertexProperty* pBoneIndexProperty = pMesh->Vertices.Format.Properties + m_vertexFormatMap[meshIndex].boneIndex; Adreno::VertexProperty* pBoneWeightProperty = pMesh->Vertices.Format.Properties + m_vertexFormatMap[meshIndex].boneWeight; Adreno::VertexProperty* pTexCoordProperty = pMesh->Vertices.Format.Properties + m_vertexFormatMap[meshIndex].texCoord; glVertexAttribPointer( FRM_VERTEX_POSITION, 3, GL_FLOAT, pPositionProperty->IsNormalized(), pMesh->Vertices.Format.Stride, ( GLvoid* ) pPositionProperty->Offset ); glEnableVertexAttribArray( FRM_VERTEX_POSITION ); glVertexAttribPointer( FRM_VERTEX_NORMAL, 3, GL_FLOAT, pNormalProperty->IsNormalized(), pMesh->Vertices.Format.Stride, ( GLvoid* ) pNormalProperty->Offset ); glEnableVertexAttribArray( FRM_VERTEX_NORMAL ); glVertexAttribPointer( FRM_VERTEX_TANGENT, 3, GL_FLOAT, pTangentProperty->IsNormalized(), pMesh->Vertices.Format.Stride, ( GLvoid* ) pTangentProperty->Offset ); glEnableVertexAttribArray( FRM_VERTEX_TANGENT ); glVertexAttribPointer( FRM_VERTEX_BINORMAL, 3, GL_FLOAT, pBinormalProperty->IsNormalized(), pMesh->Vertices.Format.Stride, ( GLvoid* ) pBinormalProperty->Offset ); glEnableVertexAttribArray( FRM_VERTEX_BINORMAL ); glVertexAttribPointer( FRM_VERTEX_CUSTOM_BONEINDEX1, 1, GL_UNSIGNED_BYTE, pBoneIndexProperty->IsNormalized(), pMesh->Vertices.Format.Stride, ( GLvoid* ) ( pBoneIndexProperty->Offset + 0 ) ); glEnableVertexAttribArray( FRM_VERTEX_CUSTOM_BONEINDEX1 ); #if defined( USE_TWO_BONES ) || defined( USE_THREE_BONES ) glVertexAttribPointer( FRM_VERTEX_CUSTOM_BONEINDEX2, 1, GL_UNSIGNED_BYTE, pBoneIndexProperty->IsNormalized(), pMesh->Vertices.Format.Stride, ( GLvoid* ) ( pBoneIndexProperty->Offset + 4 ) ); glEnableVertexAttribArray( FRM_VERTEX_CUSTOM_BONEINDEX2 ); #endif #if defined( USE_THREE_BONES ) glVertexAttribPointer( FRM_VERTEX_CUSTOM_BONEINDEX3, 1, GL_UNSIGNED_BYTE, pBoneIndexProperty->IsNormalized(), pMesh->Vertices.Format.Stride, ( GLvoid* ) ( pBoneIndexProperty->Offset + 8 ) ); glEnableVertexAttribArray( FRM_VERTEX_CUSTOM_BONEINDEX3 ); #endif glVertexAttribPointer( FRM_VERTEX_BONEWEIGHTS, 3, GL_FLOAT, pBoneWeightProperty->IsNormalized(), pMesh->Vertices.Format.Stride, ( GLvoid* ) pBoneWeightProperty->Offset ); glEnableVertexAttribArray( FRM_VERTEX_BONEWEIGHTS ); glVertexAttribPointer( FRM_VERTEX_TEXCOORD0, 2, GL_FLOAT, pMesh->Vertices.Format.Properties[6].IsNormalized(), pMesh->Vertices.Format.Stride, ( GLvoid* ) pMesh->Vertices.Format.Properties[6].Offset ); glEnableVertexAttribArray( FRM_VERTEX_TEXCOORD0 ); // Set index buffer FrmSetIndexBuffer( m_hIndexBuffer[meshIndex] ); // Prepare this frame's transforms for each of the bones FRMMATRIX4X3 matWorldMatrixArray[MAX_BONES]; for( UINT32 boneIndex = 0; boneIndex < m_boneRemapCount; ++boneIndex ) { FRMMATRIX4X4 matBoneMatrix = FrmMatrixIdentity(); // Get the current and last transforms Adreno::Joint* pJoint = m_pModel->Joints + m_boneRemap[boneIndex]; Adreno::AnimationTrack* pTrack = m_pAnim->Tracks + m_boneRemap[boneIndex]; Adreno::Transform* pCurTransform; Adreno::Transform* pLastTransform; if ( pTrack->NumKeyframes >= 0 ) { pCurTransform = pTrack->Keyframes + m_curAnimFrame; pLastTransform = pTrack->Keyframes + m_lastAnimFrame; } else { pCurTransform = &pJoint->Transform; pLastTransform = &pJoint->Transform; } // Interpolate between the last and current transforms Adreno::Transform transform; transform.Position = FrmVector3Lerp( pLastTransform->Position, pCurTransform->Position, m_frameWeight ); transform.Rotation = FrmVector4SLerp( pLastTransform->Rotation, pCurTransform->Rotation, m_frameWeight ); // Apply inverse bind transform to final matrix FRMMATRIX4X4 matInverseBindPosition = FrmMatrixTranslate( pJoint->InverseBindPose.Position ); FRMMATRIX4X4 matInverseBindRotation = FrmMatrixRotate( pJoint->InverseBindPose.Rotation ); matBoneMatrix = matInverseBindRotation; matBoneMatrix = FrmMatrixMultiply( matBoneMatrix, matInverseBindPosition ); // Apply interpolated transform to final matrix FRMMATRIX4X4 matBonePosition = FrmMatrixTranslate( transform.Position ); FRMMATRIX4X4 matBoneRotation = FrmMatrixRotate( transform.Rotation ); matBoneMatrix = FrmMatrixMultiply( matBoneMatrix, matBoneRotation ); matBoneMatrix = FrmMatrixMultiply( matBoneMatrix, matBonePosition ); // Place it in a 4x3 matrix matBoneMatrix = FrmMatrixTranspose( matBoneMatrix ); memcpy( &matWorldMatrixArray[boneIndex], &matBoneMatrix, sizeof(FRMMATRIX4X3) ); } // Set bone transforms glUniform4fv( m_SkinningConstants.m_slotWorldMatrix, MAX_BONES * 3, (GLfloat*) &matWorldMatrixArray[0] ); // Render each mesh surface for ( UINT32 surfaceIndex = 0; surfaceIndex < pMesh->Surfaces.NumSurfaces; ++surfaceIndex ) { Adreno::MeshSurface* pSurface = pMesh->Surfaces.Surfaces + surfaceIndex; // Set the material for the surface FrmSetTexture( 0, m_pModelTexture[pSurface->MaterialId]->m_hTextureHandle ); // Set the normal mapping for the surface FrmSetTexture( 1, m_pNormalMapping->m_hTextureHandle ); // Draw the surface glDrawElements( GL_TRIANGLES, pSurface->NumTriangles * 3, GL_UNSIGNED_INT, ( GLvoid* ) ( pSurface->StartIndex * sizeof(UINT32) ) ); } } FrmSetVertexBuffer( NULL ); FrmSetIndexBuffer( NULL ); }
void GPUPipeline::bind_shader_input(void *data, const Shader::InputDef& input, GLsizei stride) { switch (input.def_type) { case Shader::InputDef::ATTRIBUTE: { GLenum attrib_type; GLint size; switch (input.type) { case GL_FLOAT_VEC2: case GL_FLOAT_VEC3: case GL_FLOAT_VEC4: attrib_type = GL_FLOAT; break; default: throw CSG::UnsupportedException("shader attribute type"); } switch (input.type) { case GL_FLOAT_VEC2: size = 2; break; case GL_FLOAT_VEC3: size = 3; break; case GL_FLOAT_VEC4: size = 4; break; default: throw CSG::UnsupportedException("shader attribute type"); } glEnableVertexAttribArray(input.location); glVertexAttribPointer(input.location, size, attrib_type, GL_FALSE, stride, data); break; } case Shader::InputDef::UNIFORM: switch (input.type) { case GL_FLOAT_MAT4: glUniformMatrix4fv(input.location, input.num, GL_FALSE, (float *)data); break; case GL_FLOAT_VEC4: glUniform4fv(input.location, input.num, (float*)data); break; default: throw CSG::UnsupportedException("shader uniform type"); } break; } }
GLUSboolean init(GLUSvoid) { // This is a white light. struct LightProperties light = { { 1.0f, 1.0f, 1.0f }, { 0.3f, 0.3f, 0.3f, 1.0f }, { 1.0f, 1.0f, 1.0f, 1.0f }, { 1.0f, 1.0f, 1.0f, 1.0f } }; // Blue color material with white specular color. struct MaterialProperties material = { { 0.0f, 1.0f, 0.0f, 1.0f }, { 0.0f, 1.0f, 0.0f, 1.0f }, { 1.0f, 1.0f, 1.0f, 1.0f }, 20.0f }; GLUStextfile vertexSource; GLUStextfile fragmentSource; GLUSshape wavefrontObj; glusFileLoadText("../Example16/shader/phong.vert.glsl", &vertexSource); glusFileLoadText("../Example16/shader/phong.frag.glsl", &fragmentSource); glusProgramBuildFromSource(&g_program, (const GLUSchar**) &vertexSource.text, 0, 0, 0, (const GLUSchar**) &fragmentSource.text); glusFileDestroyText(&vertexSource); glusFileDestroyText(&fragmentSource); // g_projectionMatrixLocation = glGetUniformLocation(g_program.program, "u_projectionMatrix"); g_modelViewMatrixLocation = glGetUniformLocation(g_program.program, "u_modelViewMatrix"); g_normalMatrixLocation = glGetUniformLocation(g_program.program, "u_normalMatrix"); g_light.directionLocation = glGetUniformLocation(g_program.program, "u_light.direction"); g_light.ambientColorLocation = glGetUniformLocation(g_program.program, "u_light.ambientColor"); g_light.diffuseColorLocation = glGetUniformLocation(g_program.program, "u_light.diffuseColor"); g_light.specularColorLocation = glGetUniformLocation(g_program.program, "u_light.specularColor"); g_material.ambientColorLocation = glGetUniformLocation(g_program.program, "u_material.ambientColor"); g_material.diffuseColorLocation = glGetUniformLocation(g_program.program, "u_material.diffuseColor"); g_material.specularColorLocation = glGetUniformLocation(g_program.program, "u_material.specularColor"); g_material.specularExponentLocation = glGetUniformLocation(g_program.program, "u_material.specularExponent"); g_vertexLocation = glGetAttribLocation(g_program.program, "a_vertex"); g_normalLocation = glGetAttribLocation(g_program.program, "a_normal"); // // Use a helper function to load an wavefront object file. glusShapeLoadWavefront("monkey.obj", &wavefrontObj); g_numberVertices = wavefrontObj.numberVertices; glGenBuffers(1, &g_verticesVBO); glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO); glBufferData(GL_ARRAY_BUFFER, wavefrontObj.numberVertices * 4 * sizeof(GLfloat), (GLfloat*) wavefrontObj.vertices, GL_STATIC_DRAW); glGenBuffers(1, &g_normalsVBO); glBindBuffer(GL_ARRAY_BUFFER, g_normalsVBO); glBufferData(GL_ARRAY_BUFFER, wavefrontObj.numberVertices * 3 * sizeof(GLfloat), (GLfloat*) wavefrontObj.normals, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); glusShapeDestroyf(&wavefrontObj); // glUseProgram(g_program.program); glGenVertexArrays(1, &g_vao); glBindVertexArray(g_vao); glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO); glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(g_vertexLocation); glBindBuffer(GL_ARRAY_BUFFER, g_normalsVBO); glVertexAttribPointer(g_normalLocation, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(g_normalLocation); // glusMatrix4x4LookAtf(g_viewMatrix, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f); // glusVector3Normalizef(light.direction); // Transform light to camera space, as it is currently in world space. glusMatrix4x4MultiplyVector3f(light.direction, g_viewMatrix, light.direction); // Set up light ... glUniform3fv(g_light.directionLocation, 1, light.direction); glUniform4fv(g_light.ambientColorLocation, 1, light.ambientColor); glUniform4fv(g_light.diffuseColorLocation, 1, light.diffuseColor); glUniform4fv(g_light.specularColorLocation, 1, light.specularColor); // ... and material values. glUniform4fv(g_material.ambientColorLocation, 1, material.ambientColor); glUniform4fv(g_material.diffuseColorLocation, 1, material.diffuseColor); glUniform4fv(g_material.specularColorLocation, 1, material.specularColor); glUniform1f(g_material.specularExponentLocation, material.specularExponent); // glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClearDepth(1.0f); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); return GLUS_TRUE; }
DEBUG_MSG("status=%04x", glCheckFramebufferStatus(GL_FRAMEBUFFER)); GCHK(glBindFramebuffer(GL_FRAMEBUFFER, fbo)); GCHK(glDrawBuffers(1, (const GLenum[]){GL_COLOR_ATTACHMENT0})); GCHK(glViewport(0, 0, width, height)); GCHK(glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vertices)); GCHK(glEnableVertexAttribArray(0)); /* now set up our uniform. */ GCHK(uniform_location = glGetUniformLocation(program, "uColor")); GCHK(glUniform4fv(uniform_location, 1, quad_color)); GCHK(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4)); GCHK(glFlush()); // ECHK(eglSwapBuffers(display, surface)); GCHK(glFlush()); ECHK(eglDestroySurface(display, surface)); ECHK(eglTerminate(display)); RD_END(); } int main(int argc, char *argv[]) {
void uniform4fv(GLint uniform, Vector vec) { DirectX::XMFLOAT4 fVec; XMStoreFloat4(&fVec, vec.getXMVector()); glUniform4fv(uniform, 1, &fVec.x); }
void ShaderProgram::setUniformValue(GLint id, glm::vec4& value) { glUniform4fv(id, 1, &value[0]); }
void uniformColor(GLint uniform, Color color) { glUniform4fv(uniform, 1, &color.r); }
void uniform4fv(GLint uniform, Vector4 vec) { glUniform4fv(uniform, 1, &vec.x); }
void GLSLProgram::setUniform(const char *name, const glm::vec4 &v) { glUniform4fv(getUniformLocation(name), 1, glm::value_ptr(v)); }
//OpenGL Loop Logic void glLoop() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); /*gModelMat = glm::rotate(gModelMat, -0.01f, glm::vec3(0.f, 0.f, 1.f)); glUniformMatrix4fv(gModelMatLoc, 1, GL_FALSE, glm::value_ptr(gModelMat));*/ glUseProgram(gShadowProg); glBindVertexArray(gShadowVao); glBindFramebuffer(GL_FRAMEBUFFER, gShadowFbo); glViewport(0, 0, SHADOW_DEPTH_TEXTURE_SIZE, SHADOW_DEPTH_TEXTURE_SIZE); glClearDepth(1.0f); glClear(GL_DEPTH_BUFFER_BIT); glEnable(GL_POLYGON_OFFSET_FILL); glPolygonOffset(2.f, 4.f); for (auto& e: gSceneGraph) { glUniformMatrix4fv(gShadowModelMatLoc, 1, GL_FALSE, glm::value_ptr(e.modelMat)); glBindBuffer(GL_ARRAY_BUFFER, e.glPosBuf); glVertexAttribPointer(gShadowPosLoc, 4, GL_FLOAT, GL_FALSE, 0, NULL); glDrawArrays(GL_TRIANGLES, 0, e.vertCount); } glDisable(GL_POLYGON_OFFSET_FILL); glBindFramebuffer(GL_FRAMEBUFFER, 0); glViewport(0, 0, WIN_WIDTH * 2, WIN_HEIGHT * 2); glUseProgram(gRenderProg); glBindVertexArray(gVao); for (auto& e: gSceneGraph) { glUniformMatrix4fv(gModelMatLoc, 1, GL_FALSE, glm::value_ptr(e.modelMat)); glUniform3fv(gAmbientLoc, 1, glm::value_ptr(e.ambientColor)); glUniform3fv(gDiffuseLoc, 1, glm::value_ptr(e.diffuseColor)); glUniform3fv(gSpecularLoc, 1, glm::value_ptr(e.specularColor)); glUniform1f(gShininessLoc, e.shininess); glUniform1f(gSpecStrengthLoc, e.specStrength); glUniform1i(gIsTexturedLoc, e.isTextured); glUniform1i(gTexUnitLoc, e.glTexUnit); glUniform4fv(gColorLoc, 1, glm::value_ptr(e.objColor)); glBindBuffer(GL_ARRAY_BUFFER, e.glPosBuf); glVertexAttribPointer(gPosLoc, 4, GL_FLOAT, GL_FALSE, 0, NULL); glBindBuffer(GL_ARRAY_BUFFER, e.glTexCoordBuf); glVertexAttribPointer(gTexCoordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL); glBindBuffer(GL_ARRAY_BUFFER, e.glNormBuf); glVertexAttribPointer(gNormLoc, 3, GL_FLOAT, GL_FALSE, 0, NULL); glDrawArrays(GL_TRIANGLES, 0, e.vertCount); } /*glUseProgram(gTextureProg); glBindVertexArray(gTextureVao); glDrawArrays(GL_TRIANGLES, 0, 6);*/ }
_Bool gl_init(void) { GLuint vertshader, fragshader; GLint status; const GLchar *data; vertshader = glCreateShader(GL_VERTEX_SHADER); if(!vertshader) { debug("glCreateShader() failed (vert)\n"); return 0; } data = &vertex_shader[0]; glShaderSource(vertshader, 1, &data, NULL); glCompileShader(vertshader); glGetShaderiv(vertshader, GL_COMPILE_STATUS, &status); if(!status) { #ifdef DEBUG debug("glCompileShader() failed (vert):\n%s\n", data); GLint infologsize = 0; glGetShaderiv(vertshader, GL_INFO_LOG_LENGTH, &infologsize); if(infologsize) { char* infolog = malloc(infologsize); glGetShaderInfoLog(vertshader, infologsize, NULL, (GLbyte*)infolog); debug("Infolog: %s\n", infolog); free(infolog); } #endif return 0; } fragshader = glCreateShader(GL_FRAGMENT_SHADER); if(!fragshader) { return 0; } data = &fragment_shader[0]; glShaderSource(fragshader, 1, &data, NULL); glCompileShader(fragshader); glGetShaderiv(fragshader, GL_COMPILE_STATUS, &status); if(!status) { #ifdef DEBUG debug("glCompileShader failed (frag):\n%s\n", data); GLint infologsize = 0; glGetShaderiv(fragshader, GL_INFO_LOG_LENGTH, &infologsize); if(infologsize) { char* infolog = malloc(infologsize); glGetShaderInfoLog(fragshader, infologsize, NULL, (GLbyte*)infolog); debug("Infolog: %s\n", infolog); free(infolog); } #endif return 0; } prog = glCreateProgram(); glAttachShader(prog, vertshader); glAttachShader(prog, fragshader); glBindAttribLocation(prog, 0, "pos"); glBindAttribLocation(prog, 1, "tex"); glLinkProgram(prog); glGetProgramiv(prog, GL_LINK_STATUS, &status); if(!status) { #ifdef DEBUG debug("glLinkProgram failed\n"); GLint infologsize = 0; glGetShaderiv(prog, GL_INFO_LOG_LENGTH, &infologsize); if(infologsize) { char* infolog = malloc(infologsize); glGetShaderInfoLog(prog, infologsize, NULL, (GLbyte*)infolog); debug("Infolog: %s\n", infolog); free(infolog); } #endif return 0; } glUseProgram(prog); matrix = glGetUniformLocation(prog, "matrix"); k = glGetUniformLocation(prog, "k"); k2 = glGetUniformLocation(prog, "k2"); samp = glGetUniformLocation(prog, "samp"); debug("uniforms: %i %i %i\n", matrix, k, samp); GLint zero = 0; float one[] = {1.0, 1.0, 1.0}; glUniform1iv(samp, 1, &zero); glUniform3fv(k2, 1, one); uint8_t wh = {255}; glGenTextures(1, &white); glBindTexture(GL_TEXTURE_2D, white); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 1, 1, 0, GL_ALPHA, GL_UNSIGNED_BYTE, &wh); // glVertexAttribPointer(0, 2, GL_SHORT, GL_FALSE, sizeof(VERTEX2D), &quads[0]); glVertexAttribPointer(1, 2, GL_UNSIGNED_SHORT, GL_FALSE, sizeof(VERTEX2D), &quads[0].vertex[0].tx); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); //Alpha blending glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND); // glPixelStorei(GL_UNPACK_ALIGNMENT, 1); #ifndef NO_OPENGL_ES uint8_t i = 0; uint16_t ii = 0; do { quad_indices[ii] = i + 0; quad_indices[ii + 1] = i + 1; quad_indices[ii + 2] = i + 3; quad_indices[ii + 3] = i + 3; quad_indices[ii + 4] = i + 1; quad_indices[ii + 5] = i + 2; i += 4; ii += 6; } while(i); #endif glGenTextures(countof(bitmap), bitmap); svg_draw(0); loadfonts(); float vec[4]; vec[0] = -(float)utox_window_width / 2.0; vec[1] = -(float)utox_window_height / 2.0; vec[2] = 2.0 / (float)utox_window_width; vec[3] = -2.0 / (float)utox_window_height; glUniform4fv(matrix, 1, vec); ui_size(utox_window_width, utox_window_height); glViewport(0, 0, utox_window_width, utox_window_height); redraw(); return 1; }
GLUSboolean update(GLUSfloat time) { static GLfloat angle = 0.0f; GLuint primitivesWritten; // Field of view GLfloat rotationMatrix[16]; GLfloat positionTextureSpace[4]; GLfloat directionTextureSpace[3]; GLfloat leftNormalTextureSpace[3]; GLfloat rightNormalTextureSpace[3]; GLfloat backNormalTextureSpace[3]; GLfloat xzPosition2D[4]; // GLfloat tmvpMatrix[16]; // Animation update g_personView.cameraPosition[0] = -cosf(2.0f * PIf * angle / TURN_DURATION) * TURN_RADIUS * METERS_TO_VIRTUAL_WORLD_SCALE; g_personView.cameraPosition[2] = -sinf(2.0f * PIf * angle / TURN_DURATION) * TURN_RADIUS * METERS_TO_VIRTUAL_WORLD_SCALE; g_personView.cameraDirection[0] = sinf(2.0f * PIf * angle / TURN_DURATION); g_personView.cameraDirection[2] = -cosf(2.0f * PIf * angle / TURN_DURATION); if (g_animationOn) { angle += time; } glusLookAtf(g_viewMatrix, g_activeView->cameraPosition[0], g_activeView->cameraPosition[1], g_activeView->cameraPosition[2], g_activeView->cameraPosition[0] + g_activeView->cameraDirection[0], g_activeView->cameraPosition[1] + g_activeView->cameraDirection[1], g_activeView->cameraPosition[2] + g_activeView->cameraDirection[2], g_activeView->cameraUp[0], g_activeView->cameraUp[1], g_activeView->cameraUp[2]); glusMatrix4x4Identityf(tmvpMatrix); glusMatrix4x4Multiplyf(tmvpMatrix, tmvpMatrix, g_projectionMatrix); glusMatrix4x4Multiplyf(tmvpMatrix, tmvpMatrix, g_viewMatrix); glusMatrix4x4Multiplyf(tmvpMatrix, tmvpMatrix, g_textureToWorldMatrix); // Position xzPosition2D[0] = g_personView.cameraPosition[0]; xzPosition2D[1] = 0.0f; xzPosition2D[2] = g_personView.cameraPosition[2]; xzPosition2D[3] = g_personView.cameraPosition[3]; glusMatrix4x4MultiplyPoint4f(positionTextureSpace, g_worldToTextureMatrix, xzPosition2D); // Direction glusMatrix4x4MultiplyVector3f(directionTextureSpace, g_worldToTextureMatrix, g_personView.cameraDirection); // Left normal of field of view glusMatrix4x4Identityf(rotationMatrix); glusMatrix4x4RotateRyf(rotationMatrix, g_personView.fov * (g_width / g_height) / 2.0f + 90.0f); glusMatrix4x4MultiplyVector3f(leftNormalTextureSpace, rotationMatrix, g_personView.cameraDirection); glusMatrix4x4MultiplyVector3f(leftNormalTextureSpace, g_worldToTextureNormalMatrix, leftNormalTextureSpace); // Right normal of field of view glusMatrix4x4Identityf(rotationMatrix); glusMatrix4x4RotateRyf(rotationMatrix, -g_personView.fov * (g_width / g_height) / 2.0f - 90.0f); glusMatrix4x4MultiplyVector3f(rightNormalTextureSpace, rotationMatrix, g_personView.cameraDirection); glusMatrix4x4MultiplyVector3f(rightNormalTextureSpace, g_worldToTextureNormalMatrix, rightNormalTextureSpace); // Back normal of field of view glusMatrix4x4Identityf(rotationMatrix); glusMatrix4x4RotateRyf(rotationMatrix, 180.0f); glusMatrix4x4MultiplyVector3f(backNormalTextureSpace, rotationMatrix, g_personView.cameraDirection); glusMatrix4x4MultiplyVector3f(backNormalTextureSpace, g_worldToTextureNormalMatrix, backNormalTextureSpace); // OpenGL stuff glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Pass one. // Disable any rasterization glEnable(GL_RASTERIZER_DISCARD); glUseProgram(g_programPassOne.program); glUniform4fv(g_positionTextureSpacePassOneLocation, 1, positionTextureSpace); glUniform3fv(g_leftNormalTextureSpacePassOneLocation, 1, leftNormalTextureSpace); glUniform3fv(g_rightNormalTextureSpacePassOneLocation, 1, rightNormalTextureSpace); glUniform3fv(g_backNormalTextureSpacePassOneLocation, 1, backNormalTextureSpace); glBindVertexArray(g_vaoPassOne); // Bind to vertices used in render pass two. To this buffer is written. glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, g_verticesPassTwoVBO); // We need to know, how many primitives are written. So start the query. glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, g_transformFeedbackQuery); // Start the operation ... glBeginTransformFeedback(GL_POINTS); // ... render the elements ... glDrawElements(GL_POINTS, g_sNumPoints * g_tNumPoints, GL_UNSIGNED_INT, 0); // ... and stop the operation. glEndTransformFeedback(); // Now, we can also stop the query. glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN); glDisable(GL_RASTERIZER_DISCARD); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0); glBindVertexArray(0); // Pass two glUseProgram(g_shaderProgramPassTwo.program); glUniformMatrix4fv(g_tmvpPassTwoLocation, 1, GL_FALSE, tmvpMatrix); glUniform4fv(g_positionTextureSpacePassTwoLocation, 1, positionTextureSpace); glBindVertexArray(g_vaoPassTwo); // Now get the number of primitives written in the first render pass. glGetQueryObjectuiv(g_transformFeedbackQuery, GL_QUERY_RESULT, &primitivesWritten); // No draw the final terrain. glDrawArrays(GL_PATCHES, 0, primitivesWritten); return GLUS_TRUE; }
/*!**************************************************************************** @Function DoStencilTest @Description Performs the Stencil test ******************************************************************************/ void OGLES2ShadowVolumes::DoStencilTest() { /* For a detailed explanation on how to use the Stencil Buffer see the training course Stencil Buffer. */ // Use the shader program that is used for the shadow volumes glUseProgram(m_ShadowVolShader.uiId); // Set the VolumeScale variable in the shader to say how much to extrude the volume by glUniform1f(m_ShadowVolShader.auiLoc[eVolumeScale], 1000.0f); const float afColor[] = { 0.4f, 1.0f, 0.0f, 0.2f }; glUniform4fv(m_ShadowVolShader.auiLoc[eColor], 1, afColor); //If we want to display the shadow volumes don't disable the colour mask and enable blending if(m_bDisplayVolumes) { glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); } else // Disable the colour mask so we don't draw to the colour buffer glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); // Disable writing to the depth buffer glDepthMask(GL_FALSE); // disable culling as we will want the front and back faces glDisable(GL_CULL_FACE); // Setup the stencil function glStencilFunc(GL_ALWAYS, 1, 0xFFFFFFFF); /* Setup the stencil operations for front facing triangles and for the back facing triangles Note: We are using INCR_WRAP and DECR_WRAP since we are submitting the front and back faces together so we won't be rendering all the INCR faces first. This way it stops the stencil value getting clamped at 0 or the maximum possible value. */ glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_KEEP, GL_INCR_WRAP); glStencilOpSeparate(GL_BACK, GL_KEEP, GL_KEEP, GL_DECR_WRAP); DrawShadowVolumes(&m_vLightPosWorld); // Enable Culling as we would like it back glEnable(GL_CULL_FACE); // Set the stencil function so we only draw where the stencil buffer isn't 0 glStencilFunc(GL_NOTEQUAL, 0, 0xFFFFFFFF); glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); // Enable writing to the depth buffer glDepthMask(GL_TRUE); // If we're displaying the volumes disable blending else enable the colour buffer if(m_bDisplayVolumes) glDisable(GL_BLEND); else #if defined(__PALMPDK__) glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE); // The alpha part is false as we don't want to blend with the video layer on the Palm Pre #else glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); #endif }
void display() { if(active){ compute(psi,temp,step); setupTexture(); } int viewport[4]; glGetIntegerv(GL_VIEWPORT,viewport); width = viewport[2]; height = viewport[3]; #ifdef PIPE frame = (unsigned char*)malloc(3*width*height*sizeof(unsigned char)); glReadPixels(0,0,width,height,GL_RGB,GL_UNSIGNED_BYTE,frame); for(int i = height-1; i >= 0; i--) for(int j = 0; j < width; j++) fwrite(&frame[(i*width+j)*3], sizeof(unsigned char), 3, stdout); free(frame); #endif glClearColor(1.0, 1.0, 1.0, 0.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glUseProgram(program); glUniform1i(uniform_mytexture, 0); /*Transformations*/ GLfloat texture_transform[16], vertex_transform[16]; /*set vertex transformations*/ glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); gluPerspective(45.0f, 1.0f * 640 / 480, 0.1f, 500.0f); if(camera_angle + yrot > PI/2.1) yrot = PI/2.1 - camera_angle; if(camera_angle + yrot < -PI/2.1) yrot = -PI/2.1-camera_angle; gluLookAt( 0, -camera_distance * cos(camera_angle + yrot), camera_distance * sin(camera_angle + yrot), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f); if(rotate && !mouse_down) texture_angle += 0.5; glRotatef(texture_angle + xrot, 0.0f, 0.0f, 1.0f); glGetFloatv(GL_MODELVIEW_MATRIX, vertex_transform); glUniformMatrix4fv(uniform_vertex_transform, 1, GL_FALSE, vertex_transform); glPopMatrix(); /*set texture transformations*/ glMatrixMode(GL_TEXTURE); glPushMatrix(); glLoadIdentity(); glScalef(texture_scale, texture_scale, texture_scale); glTranslatef(texture_offset_x, texture_offset_y, 0.0f); glGetFloatv(GL_TEXTURE_MATRIX, texture_transform); glUniformMatrix4fv(uniform_texture_transform, 1, GL_FALSE, texture_transform); glPopMatrix(); /* Set texture wrapping mode */ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, clamp ? GL_CLAMP_TO_EDGE : GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, clamp ? GL_CLAMP_TO_EDGE : GL_REPEAT); /* Set texture interpolation mode */ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, interpolate ? GL_LINEAR : GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, interpolate ? GL_LINEAR : GL_NEAREST); /* Draw the triangles, a little dark, with a slight offset in depth. */ GLfloat grey[4] = {0.5, 0.5, 0.5, 1}; glUniform4fv(uniform_color, 1, grey); glEnable(GL_DEPTH_TEST); if(polygonoffset) { glPolygonOffset(1, 0); glEnable(GL_POLYGON_OFFSET_FILL); } glEnableVertexAttribArray(attribute_coord2d); glBindBuffer(GL_ARRAY_BUFFER, vbo[0]); glVertexAttribPointer(attribute_coord2d, 2, GL_FLOAT, GL_FALSE, 0, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[2]); glDrawElements(GL_TRIANGLES, grid * grid * 6, GL_UNSIGNED_SHORT, 0); glPolygonOffset(0, 0); glDisable(GL_POLYGON_OFFSET_FILL); /* Draw the grid, very bright */ GLfloat bright[4] = {2, 2, 2, 1}; glUniform4fv(uniform_color, 1, bright); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[1]); glDrawElements(GL_LINES, grid * (grid+1) * 4, GL_UNSIGNED_SHORT, 0); /* Stop using the vertex buffer object */ glDisableVertexAttribArray(attribute_coord2d); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glutSwapBuffers(); }
void render(int clientWidth, int clientHeight) { GLuint screenVao=geometryVaoManager->get(screenGeomFn,positionsVaoFn)->getVao(); GeometryDraw *screenDraw=geometryVaoManager->get(screenGeomFn,positionsVaoFn)->getDraw(); glViewport(0,0,clientWidth,clientHeight); //states glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glFrontFace(GL_CCW); glDisable(GL_BLEND); glDisable(GL_STENCIL_TEST); glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); glDepthFunc(GL_LEQUAL); //bind fbo glBindFramebuffer(GL_DRAW_FRAMEBUFFER, deferredFbo); //clear glClearColor(0.0f,0.0f,0.0f,0.0f); glClearDepth(1); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); //states glColorMask(GL_FALSE,GL_FALSE,GL_FALSE,GL_FALSE); //draw entity geom depths //states glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE); //draw entity geoms { for(Mesh *m : scene->getMeshes()) { GLuint prog=0; if(m->material==Mesh::Color) { prog=programManager->get(geometryColoredProgFn); } else if(m->material==Mesh::Parallax) { prog=programManager->get(geometryParallaxProgFn); if(m->reliefTex.empty()) { prog=programManager->get("data/shader/geometry/Parallax2.json"); } else { prog=programManager->get("data/shader/geometry/Parallax.json"); } } if(GLuint tex=textureManager->get2d(m->colorTex)) { glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D,tex); } if(GLuint tex=textureManager->get2d(m->normalTex)) { glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D,tex); // std::cout << "n " << tex << std::endl; } if(GLuint tex=textureManager->get2d(m->heightTex)) { glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D,tex); } if(GLuint tex=textureManager->get2d(m->reliefTex)) { glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_2D,tex); } // glUseProgram(prog); int modelViewProjMatLoc=glGetUniformLocation(prog,"u_modelViewProjMat"); int modelViewMatLoc=glGetUniformLocation(prog,"u_modelViewMat"); int normalMatLoc=glGetUniformLocation(prog,"u_normalMat"); int colLoc=glGetUniformLocation(prog,"u_col"); int shininessLoc=glGetUniformLocation(prog,"u_shininess"); int emissiveLoc=glGetUniformLocation(prog,"u_emissive"); int reflectiveLoc=glGetUniformLocation(prog,"u_reflective"); int bumpScaleLoc=glGetUniformLocation(prog,"u_bumpScale"); int bumpBiasLoc=glGetUniformLocation(prog,"u_bumpBias"); int reliefScaleLoc=glGetUniformLocation(prog,"u_reliefScale"); int parallaxScaleLoc=glGetUniformLocation(prog,"u_parallaxScale"); int parallaxBiasLoc=glGetUniformLocation(prog,"u_parallaxBias"); int parallaxInvertHeightLoc=glGetUniformLocation(prog,"u_parallaxInvertHeight"); int zNearFarLoc=glGetUniformLocation(prog,"u_zNearFar"); // if(colLoc!=-1) { glUniform3fv(colLoc,1,m->color); } glUniformMatrix4fv(modelViewProjMatLoc,1,GL_TRUE,m->modelViewProjMat); if(modelViewMatLoc!=-1) { glUniformMatrix4fv(modelViewMatLoc,1,GL_TRUE,m->modelViewMat); } if(normalMatLoc!=-1) { glUniformMatrix3fv(normalMatLoc,1,GL_TRUE,m->normalMat); } if(shininessLoc!=-1) { glUniform1fv(shininessLoc,1,&m->shininess); } if(emissiveLoc!=-1) { glUniform1i(emissiveLoc,m->emissive?1:0); } if(reflectiveLoc!=-1) { glUniform1fv(reflectiveLoc,1,&m->reflective); } // if(bumpScaleLoc!=-1) { glUniform1fv(bumpScaleLoc,1,&m->bumpScale); } if(bumpBiasLoc!=-1) { glUniform1fv(bumpBiasLoc,1,&m->bumpBias); } // if(reliefScaleLoc!=-1) { glUniform1fv(reliefScaleLoc,1,&m->reliefScale); } // if(parallaxScaleLoc!=-1) { glUniform1fv(parallaxScaleLoc,1,&m->parallaxScale); } if(parallaxBiasLoc!=-1) { glUniform1fv(parallaxBiasLoc,1,&m->parallaxBias); } if(parallaxInvertHeightLoc!=-1) { glUniform1i(parallaxInvertHeightLoc,m->parallaxInvertHeight?1:0); } if(zNearFarLoc!=-1) { float zNearFar[2]={m->zNear,m->zFar}; glUniform2fv(zNearFarLoc,1,zNearFar); } // if(GeometryVao *gv=geometryVaoManager->get(m->geometry,m->vao)) { glBindVertexArray(gv->getVao()); if(GeometryDraw *d=gv->getDraw(m->draw)) { d->draw(); } } } } //bind fbo glBindFramebuffer(GL_FRAMEBUFFER, 0); //bind textures glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, deferredColorTex); glBindSampler(0,0); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, deferredNormalTex); glBindSampler(1,0); glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, deferredDepthTex); glBindSampler(2,0); //states glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); glDepthFunc(GL_LESS); //clear glClearDepth(1.0f); glClear(GL_DEPTH_BUFFER_BIT); //render deferred depth texture glUseProgram(programManager->get(deferredDepthCopyProgFn)); glBindVertexArray(screenVao); screenDraw->draw(); //states glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glDepthMask(GL_FALSE); //clear glClearColor(0.0f,0.0f,0.0f,1.0f); glClearStencil(0); glClear(GL_COLOR_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); //bind vao glBindVertexArray(screenVao); //states glEnable(GL_BLEND); glBlendEquation(GL_FUNC_ADD); glBlendFunc(GL_ONE, GL_ONE); //draw point lights { GLuint p=programManager->get(deferredPointlightProgFn); glUseProgram(p); GLint invProjLoc=glGetUniformLocation(p,"u_invProjMat"); glUniformMatrix4fv(invProjLoc,1,GL_TRUE,scene->getInvProjMat()); GLint lightPosLoc=glGetUniformLocation(p,"u_lightPos"); GLint lightAttenLoc=glGetUniformLocation(p,"u_lightAtten"); GLint lightColLoc=glGetUniformLocation(p,"u_lightCol"); GLint strengthLoc=glGetUniformLocation(p,"u_strength"); for(Pointlight *pl : scene->getPointlights()) { if(!pl->shadow) { glUniform4fv(lightPosLoc,1,pl->viewPos); glUniform3fv(lightAttenLoc,1,pl->attenuation); glUniform3fv(lightColLoc,1,pl->color); glUniform1fv(strengthLoc,1,&pl->strength); screenDraw->draw(); } } } //draw spot lights { GLuint p=programManager->get(deferredSpotlightProgFn); glUseProgram(p); GLint invProjLoc=glGetUniformLocation(p,"u_invProjMat"); glUniformMatrix4fv(invProjLoc,1,GL_TRUE,scene->getInvProjMat()); for(Spotlight *sl : scene->getSpotlights()) { if(!sl->shadow) { } } } //draw directional lights { GLuint p=programManager->get(deferredDirectionallightProgFn); glUseProgram(p); GLint invProjLoc=glGetUniformLocation(p,"u_invProjMat"); glUniformMatrix4fv(invProjLoc,1,GL_TRUE,scene->getInvProjMat()); GLint lightDirLoc=glGetUniformLocation(p,"u_lightDir"); GLint lightColLoc=glGetUniformLocation(p,"u_lightCol"); GLint strengthLoc=glGetUniformLocation(p,"u_strength"); for(Directionallight *dl : scene->getDirectionallights()) { if(!dl->shadow) { glUniform4fv(lightDirLoc,1,dl->viewDir); glUniform3fv(lightColLoc,1,dl->color); glUniform1fv(strengthLoc,1,&dl->strength); screenDraw->draw(); } } } //states glEnable(GL_STENCIL_TEST); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glFrontFace(GL_CCW); glEnable(GL_BLEND); glBlendEquation(GL_FUNC_ADD); glBlendFunc(GL_ONE, GL_ONE); //draw point lights with shadows { // GLuint lightProg=programManager->get(deferredPointlightProgFn); GLuint invProjLoc=glGetUniformLocation(lightProg,"u_invProjMat"); GLint lightPosLoc=glGetUniformLocation(lightProg,"u_lightPos"); GLint lightAttenLoc=glGetUniformLocation(lightProg,"u_lightAtten"); GLint lightColLoc=glGetUniformLocation(lightProg,"u_lightCol"); GLint strengthLoc=glGetUniformLocation(lightProg,"u_strength"); glUseProgram(lightProg); glUniformMatrix4fv(invProjLoc,1,GL_TRUE,scene->getInvProjMat()); // GLuint shadowProg=0; GLint zpassLoc2=-1; GLint robustLoc2=-1; if(geometryShaderSupport && scene->isGeometryShadows()) { shadowProg=programManager->get(pointLightShadowGpuProgFn); zpassLoc2=glGetUniformLocation(shadowProg,"u_zpass"); robustLoc2=glGetUniformLocation(shadowProg,"u_robust"); } else { shadowProg=programManager->get(pointLightShadowCpuProgFn); } GLint projMatLoc2=glGetUniformLocation(shadowProg,"u_projMat"); GLint modelViewMatLoc2=glGetUniformLocation(shadowProg,"u_modelViewMat"); GLint lightPosLoc2=glGetUniformLocation(shadowProg,"u_lightPos"); glUseProgram(shadowProg); glUniformMatrix4fv(projMatLoc2,1,GL_TRUE,scene->getProjMat()); // for(Pointlight *pl : scene->getPointlights()) { if(pl->shadow) { glDisable(GL_BLEND); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); glDisable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_CLAMP); glStencilFunc(GL_ALWAYS, 0, 0xff); //... bool lastZpass=false; glStencilOpSeparate(GL_BACK, GL_KEEP, GL_INCR_WRAP, GL_KEEP); glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR_WRAP, GL_KEEP); glEnable(GL_POLYGON_OFFSET_FILL); glPolygonOffset(0.1f,1.0f); glClearStencil(0); glClear(GL_STENCIL_BUFFER_BIT); //use shadow program glUseProgram(shadowProg); glUniform4fv(lightPosLoc2,1,pl->viewPos); // if(geometryShaderSupport && scene->isGeometryShadows()) { // glEnable(GL_PRIMITIVE_RESTART); for(Shadow *shadow : scene->getShadows()) { if(lastZpass !=shadow->zpass) { lastZpass=shadow->zpass; if(!shadow->zpass) { glStencilOpSeparate(GL_BACK, GL_KEEP, GL_INCR_WRAP, GL_KEEP); glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR_WRAP, GL_KEEP); } else { glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_KEEP, GL_INCR_WRAP); glStencilOpSeparate(GL_BACK , GL_KEEP, GL_KEEP, GL_DECR_WRAP); } } glUniform1i(zpassLoc2,shadow->zpass?1:0); glUniform1i(robustLoc2,shadow->robust?1:0); glUniformMatrix4fv(modelViewMatLoc2,1,GL_TRUE,shadow->modelViewMat); if(GeometryVao *gv=geometryVaoManager->get(shadow->geometry,positionsVaoFn)) { glBindVertexArray(gv->getVao()); gv->getDraw("default")->draw(); } } } else { for(Shadow *shadow : scene->getShadows()) { if(!shadow->zpass) { glStencilOpSeparate(GL_BACK, GL_KEEP, GL_INCR_WRAP, GL_KEEP); glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR_WRAP, GL_KEEP); } else { glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_KEEP, GL_INCR_WRAP); glStencilOpSeparate(GL_BACK , GL_KEEP, GL_KEEP, GL_DECR_WRAP); } if(shadow->cpuShadow) { glUniformMatrix4fv(modelViewMatLoc2,1,GL_TRUE, shadow->modelViewMat); shadow->cpuShadow->draw(geometryVaoManager,pl,shadowCpuThreads,false); } } } } //draw light glDisable(GL_POLYGON_OFFSET_FILL); glEnable(GL_BLEND); glEnable(GL_CULL_FACE); glDisable(GL_DEPTH_TEST); glDisable(GL_DEPTH_CLAMP); glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE); glStencilOpSeparate(GL_BACK, GL_KEEP, GL_KEEP, GL_KEEP); glStencilFunc(GL_EQUAL, 0, 0xff); glUseProgram(lightProg); glUniform4fv(lightPosLoc,1,pl->viewPos); glUniform3fv(lightAttenLoc,1,pl->attenuation); glUniform3fv(lightColLoc,1,pl->color); glUniform1fv(strengthLoc,1,&pl->strength); glBindVertexArray(screenVao); screenDraw->draw(); } } //draw spot lights with shadows { } //draw directional lights with shadows //if(geometryShaderSupport && scene->isGeometryShadows()) //cpu directional shadows not implemented { GLuint p=programManager->get(deferredDirectionallightProgFn); glUseProgram(p); GLint invProjLoc=glGetUniformLocation(p,"u_invProjMat"); glUniformMatrix4fv(invProjLoc,1,GL_TRUE,scene->getInvProjMat()); GLint lightDirLoc=glGetUniformLocation(p,"u_lightDir"); GLint lightColLoc=glGetUniformLocation(p,"u_lightCol"); GLint strengthLoc=glGetUniformLocation(p,"u_strength"); // GLuint shadowProg=0; GLint zpassLoc2=-1; GLint robustLoc2=-1; if(geometryShaderSupport && scene->isGeometryShadows()) { shadowProg=programManager->get(directionalLightShadowGpuProgFn); zpassLoc2=glGetUniformLocation(shadowProg,"u_zpass"); robustLoc2=glGetUniformLocation(shadowProg,"u_robust"); } else { shadowProg=programManager->get(directionalLightShadowCpuProgFn); } GLint projMatLoc2=glGetUniformLocation(shadowProg,"u_projMat"); GLint modelViewMatLoc2=glGetUniformLocation(shadowProg,"u_modelViewMat"); GLint lightDirLoc2=glGetUniformLocation(shadowProg,"u_lightDir"); glUseProgram(shadowProg); glUniformMatrix4fv(projMatLoc2,1,GL_TRUE,scene->getProjMat()); for(Directionallight *dl : scene->getDirectionallights()) { if(dl->shadow) { glDisable(GL_BLEND); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); glDisable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_CLAMP); glStencilFunc(GL_ALWAYS, 0, 0xff); glEnable(GL_POLYGON_OFFSET_FILL); glPolygonOffset(0.3f,1.0f); glClearStencil(0); glClear(GL_STENCIL_BUFFER_BIT); //use shadow program glUseProgram(shadowProg); glUniform4fv(lightDirLoc2,1,dl->viewDir); // if(geometryShaderSupport && scene->isGeometryShadows()) { for(Shadow *shadow : scene->getShadows()) { if(!shadow->zpass) { glStencilOpSeparate(GL_BACK, GL_KEEP, GL_INCR_WRAP, GL_KEEP); glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR_WRAP, GL_KEEP); } else { glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_KEEP, GL_INCR_WRAP); glStencilOpSeparate(GL_BACK , GL_KEEP, GL_KEEP, GL_DECR_WRAP); } glUniform1i(zpassLoc2,shadow->zpass?1:0); glUniform1i(robustLoc2,shadow->robust?1:0); glUniformMatrix4fv(modelViewMatLoc2,1,GL_TRUE,shadow->modelViewMat); if(GeometryVao *gv=geometryVaoManager->get(shadow->geometry,positionsVaoFn)) { glBindVertexArray(gv->getVao()); gv->getDraw("default")->draw(); } } } else { for(Shadow *shadow : scene->getShadows()) { if(!shadow->zpass) { glStencilOpSeparate(GL_BACK, GL_KEEP, GL_INCR_WRAP, GL_KEEP); glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR_WRAP, GL_KEEP); } else { glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_KEEP, GL_INCR_WRAP); glStencilOpSeparate(GL_BACK , GL_KEEP, GL_KEEP, GL_DECR_WRAP); } if(shadow->cpuShadow) { glUniformMatrix4fv(modelViewMatLoc2,1,GL_TRUE, shadow->modelViewMat); shadow->cpuShadow->draw(geometryVaoManager,dl,shadowCpuThreads,false); } } } //draw light glDisable(GL_POLYGON_OFFSET_FILL); glEnable(GL_BLEND); glEnable(GL_CULL_FACE); glDisable(GL_DEPTH_TEST); glDisable(GL_DEPTH_CLAMP); glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE); glStencilOpSeparate(GL_BACK, GL_KEEP, GL_KEEP, GL_KEEP); glStencilFunc(GL_EQUAL, 0, 0xff); glUseProgram(p); glUniform4fv(lightDirLoc,1,dl->viewDir); glUniform3fv(lightColLoc,1,dl->color); glUniform1fv(strengthLoc,1,&dl->strength); glBindVertexArray(screenVao); screenDraw->draw(); } } } // glDisable(GL_STENCIL_TEST); //states glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glFrontFace(GL_CCW); glDepthMask(GL_FALSE); glDisable(GL_DEPTH_TEST); glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE); //bind vao glBindVertexArray(screenVao); //draw ambients { GLuint prog=programManager->get(deferredAmbientProgFn); GLuint ambienceLoc=glGetUniformLocation(prog,"u_ambience"); glUseProgram(prog); glUniform1f(ambienceLoc,0.05f); screenDraw->draw(); } //draw emissives glUseProgram(programManager->get(deferredEmissiveProgFn)); screenDraw->draw(); //bind sky texture to 3 glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_CUBE_MAP,textureManager->getCube(cubeEnvTexFn)); //states glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE); //draw reflections { GLuint prog=programManager->get(deferredReflectionProgFn); glUseProgram(prog); GLint invProjLoc=glGetUniformLocation(prog,"u_invProjMat"); glUniformMatrix4fv(invProjLoc,1,GL_TRUE,scene->getInvProjMat()); GLint viewLoc=glGetUniformLocation(prog,"u_invViewMat"); glUniformMatrix4fv(viewLoc,1,GL_TRUE,scene->getInvViewMat()); screenDraw->draw(); } //states glBlendFunc(GL_ONE, GL_ONE); //draw color test // glUseProgram(programManager->get("")); // screenDraw->draw(); //states glDisable(GL_BLEND); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); glEnable(GL_STENCIL_TEST); glStencilFunc(GL_ALWAYS, 0, 0xff); glStencilOp(GL_KEEP, GL_KEEP, GL_INCR); //clear stencil glClearStencil(0); glClear(GL_STENCIL_BUFFER_BIT); //stencil out sky area glUseProgram(programManager->get(deferredDepthStencilProg)); screenDraw->draw(); //states glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE); glStencilFunc(GL_EQUAL, 0x0, 0xff); glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); //draw sky { GLuint skyProg=programManager->get(skyboxProgFn); GeometryVao *gv=geometryVaoManager->get(skyboxGeomFn,positionsVaoFn); glUseProgram(skyProg); GLuint loc=glGetUniformLocation(skyProg,"u_viewRotProjMat"); glUniformMatrix4fv(loc,1,GL_TRUE,scene->getViewRotProjMat()); glBindVertexArray(gv->getVao()); gv->getDraw()->draw(); } //states glDisable(GL_STENCIL_TEST); glDisable(GL_CULL_FACE); glDisable(GL_BLEND); //glBlendEquation(GL_FUNC_ADD); glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_CLAMP); //point light shadow debug if(scene->isShadowDebug()) { GLuint shadowProg=0; GLint zpassLoc2=-1; GLint robustLoc2=-1; if(geometryShaderSupport && scene->isGeometryShadows()) { shadowProg=programManager->get(pointLightShadowGpuDebugProgFn); zpassLoc2=glGetUniformLocation(shadowProg,"u_zpass"); robustLoc2=glGetUniformLocation(shadowProg,"u_robust"); } else { shadowProg=programManager->get(pointLightShadowCpuProgFn); } GLint projMatLoc2=glGetUniformLocation(shadowProg,"u_projMat"); GLint modelViewMatLoc2=glGetUniformLocation(shadowProg,"u_modelViewMat"); GLint lightPosLoc2=glGetUniformLocation(shadowProg,"u_lightPos"); glUseProgram(shadowProg); glUniformMatrix4fv(projMatLoc2,1,GL_TRUE,scene->getProjMat()); for(Pointlight *pl : scene->getPointlights()) { if(pl->shadow) { glUniform4fv(lightPosLoc2,1,pl->viewPos); if(geometryShaderSupport && scene->isGeometryShadows()) { for(Shadow *shadow : scene->getShadows()) { glUniform1i(zpassLoc2,shadow->zpass?1:0); glUniform1i(robustLoc2,shadow->robust?1:0); glUniformMatrix4fv(modelViewMatLoc2,1,GL_TRUE,shadow->modelViewMat); if(GeometryVao *gv=geometryVaoManager->get(shadow->geometry,positionsVaoFn)) { glBindVertexArray(gv->getVao()); gv->getDraw("default")->draw(); } } } else { for(Shadow *shadow : scene->getShadows()) { if(shadow->cpuShadow ) { glUniformMatrix4fv(modelViewMatLoc2,1,GL_TRUE, shadow->modelViewMat); shadow->cpuShadow->draw(geometryVaoManager,pl,shadowCpuThreads,true); } } } } } } //directional light shadow debug if(scene->isShadowDebug()) { // GLuint shadowProg=0; GLint zpassLoc2=-1; GLint robustLoc2=-1; if(geometryShaderSupport && scene->isGeometryShadows()) { shadowProg=programManager->get(directionalLightShadowGpuDebugProgFn); zpassLoc2=glGetUniformLocation(shadowProg,"u_zpass"); robustLoc2=glGetUniformLocation(shadowProg,"u_robust"); } else { shadowProg=programManager->get(directionalLightShadowCpuProgFn); } GLint projMatLoc2=glGetUniformLocation(shadowProg,"u_projMat"); GLint modelViewMatLoc2=glGetUniformLocation(shadowProg,"u_modelViewMat"); GLint lightDirLoc2=glGetUniformLocation(shadowProg,"u_lightDir"); glUseProgram(shadowProg); glUniformMatrix4fv(projMatLoc2,1,GL_TRUE,scene->getProjMat()); for(Directionallight *dl : scene->getDirectionallights()) { if(dl->shadow) { //use shadow program glUniform4fv(lightDirLoc2,1,dl->viewDir); // if(geometryShaderSupport && scene->isGeometryShadows()) { for(Shadow *shadow : scene->getShadows()) { glUniform1i(zpassLoc2,shadow->zpass?1:0); glUniform1i(robustLoc2,shadow->robust?1:0); glUniformMatrix4fv(modelViewMatLoc2,1,GL_TRUE,shadow->modelViewMat); if(GeometryVao *gv=geometryVaoManager->get(shadow->geometry,positionsVaoFn)) { glBindVertexArray(gv->getVao()); gv->getDraw("default")->draw(); } } } else { for(Shadow *shadow : scene->getShadows()) { if(shadow->cpuShadow) { glUniformMatrix4fv(modelViewMatLoc2,1,GL_TRUE, shadow->modelViewMat); shadow->cpuShadow->draw(geometryVaoManager,dl,shadowCpuThreads,true); } } } } } } //states glEnable(GL_CULL_FACE); glDisable(GL_DEPTH_CLAMP); glDepthMask(GL_FALSE); //glDisable(GL_DEPTH_TEST); //glDepthFunc(GL_LESS); //draw normals, triangle normals, tangents, bitangents if(false && geometryShaderSupport) { GLuint prog=programManager->get(normalsDebugProgFn); glUseProgram(prog); int modelViewProjMatLoc=glGetUniformLocation(prog,"u_modelViewProjMat"); int modelViewMatLoc=glGetUniformLocation(prog,"u_modelViewMat"); int normalMatLoc=glGetUniformLocation(prog,"u_normalMat"); int projLoc=glGetUniformLocation(prog,"u_projMat"); if(projLoc!=-1) glUniformMatrix4fv(projLoc,1,GL_TRUE,scene->getProjMat() ); for(Mesh *m : scene->getMeshes()) { if(modelViewProjMatLoc!=-1) glUniformMatrix4fv(modelViewProjMatLoc,1,GL_TRUE,m->modelViewProjMat); if(normalMatLoc!=-1) glUniformMatrix4fv(normalMatLoc,1,GL_TRUE,m->normalMat); if(modelViewMatLoc!=-1) glUniformMatrix4fv(modelViewMatLoc,1,GL_TRUE,m->modelViewMat); if( m->material==Mesh::Normal || m->material==Mesh::Bump || m->material==Mesh::Parallax) { if(GeometryVao *gv=geometryVaoManager->get(m->geometry,m->vao)) { glBindVertexArray(gv->getVao()); if(GeometryDraw *d=gv->getDraw(m->draw)) { d->draw(); } } } } } }
void ShaderProgram::setUniform(const char *name, const glm::vec4 &v) { int index = glGetUniformLocation(shaderProgram, name); GLfloat vect[] = {v.x, v.y, v.z, v.w}; glUniform4fv(index, 1, vect); }
void Shader::uni4fv (GLuint uniLoc, const float* uniValue, int _count /* = 1*/) { glUniform4fv (uniLoc, _count, uniValue); }
void ShaderProgram::setUniform(int index, const glm::vec4 &v) { GLfloat vect[] = {v.x, v.y, v.z, v.w}; glUniform4fv(index, 1, vect); }
/* Inits the shader program for this object */ void GLSphereGreen::initShader(void) { #ifdef _WIN32 // This loads the shader program from a file _program = LoadAndCreateShaderProgram("../data/shaders/greensphere.vs", "../data/shaders/greensphere.vs"); #else // This loads the shader program from a file _program = LoadAndCreateShaderProgram("/Users/geethanjalijeevanatham/Desktop/Helloworld/myopenGL/model/testing/assignment2/Problem2/Problem2/data/shaders/greensphere.vs", "/Users/geethanjalijeevanatham/Desktop/Helloworld/myopenGL/model/testing/assignment2/Problem2/Problem2/data/shaders/greensphere.fs"); #endif glUseProgram(_program); /////////////////////////////////////////////////////////////////////////////////////////////// // Vertex information / names glBindAttribLocation(_program, 0, "in_Position"); glBindAttribLocation(_program, 1, "in_Normal"); glBindAttribLocation(_program, 2, "in_Color"); /////////////////////////////////////////////////////////////////////////////////////////////// // Define the model view matrix. _modelMatrix = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, 0.0f)); // Create our model matrix which will halve the size of our model _projectionMatrixLocation = glGetUniformLocation(_program, "projectionMatrixBox"); // Get the location of our projection matrix in the shader _viewMatrixLocation = glGetUniformLocation(_program, "viewMatrixBox"); // Get the location of our view matrix in the shader _modelMatrixLocation = glGetUniformLocation(_program, "modelMatrixBox"); // Get the location of our model matrix in the shader _inverseViewMatrixLocation = glGetUniformLocation(_program, "inverseViewMatrix"); glUniformMatrix4fv(_projectionMatrixLocation, 1, GL_FALSE, &projectionMatrix()[0][0] ); // Send our projection matrix to the shader glUniformMatrix4fv(_viewMatrixLocation, 1, GL_FALSE, &viewMatrix()[0][0]); // Send our view matrix to the shader glUniformMatrix4fv(_modelMatrixLocation, 1, GL_FALSE, &_modelMatrix[0][0]); // Send our model matrix to the shader glUniformMatrix4fv(_inverseViewMatrixLocation, 1, GL_FALSE, &invRotatedViewMatrix()[0][0]); /////////////////////////////////////////////////////////////////////////////////////////////// // Material _material._diffuse_material = glm::vec3(0.0, 1.0, 0.0); _material._ambient_material = glm::vec3(0.0, 1.0, 0.0); _material._specular_material = glm::vec3(1.0, 1.0, 1.0); _material._shininess = 150.0; _material._ambientColorPos = glGetUniformLocation(_program, "ambient_color"); _material._diffuseColorPos = glGetUniformLocation(_program, "diffuse_color"); _material._specularColorPos = glGetUniformLocation(_program, "specular_color"); _material._shininessIdx = glGetUniformLocation(_program, "shininess"); // Send the material to your shader program glUniform3fv(_material._ambientColorPos, 1, &_material._ambient_material[0] ); glUniform3fv(_material._diffuseColorPos, 1, &_material._diffuse_material[0]); glUniform3fv(_material._specularColorPos, 1, &_material._specular_material[0]); glUniform1f(_material._shininessIdx, _material._shininess); // define the position of the light and send the light position to your shader program _light_source3._lightPos = glm::vec4(4.5,2.5,13.0, 1.0); _light_source3._ambient_intensity = 0.0; _light_source3._specular_intensity = 10.0; _light_source3._diffuse_intensity = 20.0; _light_source3._attenuation_coeff = 0.02; _light_source3._cone_angle = 25.0; // in degree _light_source3._cone_direction = glm::vec3(0.0, 0.0, -1.0); // this must be aligned with the object and light position. // Read all the index values from the shader program _light_source3._ambientIdx = glGetUniformLocation(_program, "ambient_intensity"); _light_source3._diffuseIdx = glGetUniformLocation(_program, "diffuse_intensity"); _light_source3._specularIdx = glGetUniformLocation(_program, "specular_intensity"); _light_source3._attenuation_coeffIdx = glGetUniformLocation(_program, "attenuationCoefficient"); _light_source3._lightPosIdx = glGetUniformLocation(_program, "light_position"); _light_source3._cone_angleIdx = glGetUniformLocation(_program, "cone_angle"); _light_source3._cone_directionIdx = glGetUniformLocation(_program, "cone_direction"); // Send the light information to your shader program glUniform1f(_light_source3._ambientIdx, _light_source3._ambient_intensity ); glUniform1f(_light_source3._diffuseIdx, _light_source3._diffuse_intensity); glUniform1f(_light_source3._specularIdx, _light_source3._specular_intensity); glUniform1f(_light_source3._attenuation_coeffIdx, _light_source3._attenuation_coeff); glUniform4fv(_light_source3._lightPosIdx, 1, &_light_source3._lightPos[0]); glUniform1f(_light_source3._cone_angleIdx, _light_source3._cone_angle); glUniform3fv(_light_source3._cone_directionIdx, 1, &_light_source3._cone_direction[0]); glUseProgram(0); }
void Vec4ShaderUniform::apply() { glUniform4fv(getLocation(), 1, glm::value_ptr(value)); }
void display() { glUseProgram(program); glUniform1i(uniform_mytexture, 0); glm::mat4 model; if (rotate) model = glm::rotate(glm::mat4(1.0f), glm::radians(SDL_GetTicks() / 100.0f), glm::vec3(0.0f, 0.0f, 1.0f)); else model = glm::mat4(1.0f); glm::mat4 view = glm::lookAt(glm::vec3(0.0, -2.0, 2.0), glm::vec3(0.0, 0.0, 0.0), glm::vec3(0.0, 0.0, 1.0)); glm::mat4 projection = glm::perspective(45.0f, 1.0f * 640 / 480, 0.1f, 10.0f); glm::mat4 vertex_transform = projection * view * model; glm::mat4 texture_transform = glm::translate(glm::scale(glm::mat4(1.0f), glm::vec3(scale, scale, 1)), glm::vec3(offset_x, offset_y, 0)); glUniformMatrix4fv(uniform_vertex_transform, 1, GL_FALSE, glm::value_ptr(vertex_transform)); glUniformMatrix4fv(uniform_texture_transform, 1, GL_FALSE, glm::value_ptr(texture_transform)); glClearColor(0.0, 0.0, 0.0, 0.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); /* Set texture wrapping mode */ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, clamp ? GL_CLAMP_TO_EDGE : GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, clamp ? GL_CLAMP_TO_EDGE : GL_REPEAT); /* Set texture interpolation mode */ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, interpolate ? GL_LINEAR : GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, interpolate ? GL_LINEAR : GL_NEAREST); /* Draw the triangles, a little dark, with a slight offset in depth. */ GLfloat grey[4] = { 0.5, 0.5, 0.5, 1 }; glUniform4fv(uniform_color, 1, grey); glEnable(GL_DEPTH_TEST); if (polygonoffset) { glPolygonOffset(1, 0); glEnable(GL_POLYGON_OFFSET_FILL); } glEnableVertexAttribArray(attribute_coord2d); glBindBuffer(GL_ARRAY_BUFFER, vbo[0]); glVertexAttribPointer(attribute_coord2d, 2, GL_FLOAT, GL_FALSE, 0, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[2]); glDrawElements(GL_TRIANGLES, 100 * 100 * 6, GL_UNSIGNED_SHORT, 0); glPolygonOffset(0, 0); glDisable(GL_POLYGON_OFFSET_FILL); /* Draw the grid, very bright */ GLfloat bright[4] = { 2, 2, 2, 1 }; glUniform4fv(uniform_color, 1, bright); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[1]); glDrawElements(GL_LINES, 100 * 101 * 4, GL_UNSIGNED_SHORT, 0); /* Stop using the vertex buffer object */ glDisableVertexAttribArray(attribute_coord2d); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); }
// 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( "vshader_a6.glsl", "fshader_a6.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 ); }
//OpenGL Initialization Logic void glInit() { glEnable(GL_TEXTURE_2D); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glEnable(GL_LINE_SMOOTH); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_POLYGON_OFFSET_LINE); glPolygonOffset(-1.f, -1.0f); glHint(GL_LINE_SMOOTH_HINT, GL_NICEST); glm::vec3 coneDir = {0.f, -1.f, -1.f}; glm::vec4 lightPos = {0.f, 30.f, 30.f, 1.f}; glm::mat4 scaleBiasMat = {{0.5f, 0.f, 0.f, 0.f}, {0.f, 0.5f, 0.f, 0.f}, {0.f, 0.f, 0.5f, 0.f}, {0.5f, 0.5f, 0.5f, 1.f}}; //Shadow Map Creation gShadowProg = glCreateProgram(); gShadowVS = CreateShader(GL_VERTEX_SHADER, "shadow.vert"); gShadowFS = CreateShader(GL_FRAGMENT_SHADER, "shadow.frag"); glAttachShader(gShadowProg, gShadowVS); glAttachShader(gShadowProg, gShadowFS); glLinkProgram(gShadowProg); glUseProgram(gShadowProg); glGenFramebuffers(1, &gShadowFbo); glBindFramebuffer(GL_FRAMEBUFFER, gShadowFbo); glDrawBuffer(GL_NONE); glGenTextures(1, &gShadowTexture); glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, gShadowTexture); glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, SHADOW_DEPTH_TEXTURE_SIZE, SHADOW_DEPTH_TEXTURE_SIZE, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glActiveTexture(GL_TEXTURE0); glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, gShadowTexture, 0); if (glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE) { std::cout << "Framebuffer Initialised" << std::endl; } glBindFramebuffer(GL_FRAMEBUFFER, 0); glm::mat4 shadowViewMat = glm::lookAt(glm::vec3(lightPos), glm::vec3(lightPos) + coneDir, glm::vec3(0, 1, 0)); glm::mat4 shadowProjMat = glm::frustum(-1.f, 1.f, -1.f, 1.f, 1.f, SHADOW_FRUSTRUM_DEPTH); gShadowModelMatLoc = glGetUniformLocation(gShadowProg, "uModelMat"); gShadowViewMatLoc = glGetUniformLocation(gShadowProg, "uViewMat"); glUniformMatrix4fv(gShadowViewMatLoc, 1, GL_FALSE, glm::value_ptr(shadowViewMat)); gShadowProjMatLoc = glGetUniformLocation(gShadowProg, "uProjMat"); glUniformMatrix4fv(gShadowProjMatLoc, 1, GL_FALSE, glm::value_ptr(shadowProjMat)); glGenVertexArrays(1, &gShadowVao); glBindVertexArray(gShadowVao); gShadowPosLoc = glGetAttribLocation(gShadowProg, "vPosition"); glEnableVertexAttribArray(gShadowPosLoc); //Program Creation gRenderProg = glCreateProgram(); gRenderVS = CreateShader(GL_VERTEX_SHADER, "shader.vert"); gRenderFS = CreateShader(GL_FRAGMENT_SHADER, "shader.frag"); glAttachShader(gRenderProg, gRenderVS); glAttachShader(gRenderProg, gRenderFS); glLinkProgram(gRenderProg); glUseProgram(gRenderProg); //Texture //Uniforms gModelMatLoc = glGetUniformLocation(gRenderProg, "uModelMat"); gModelMat = glm::rotate(glm::mat4(1.f), -1.57f, glm::vec3(1.f, 0.f, 0.f)); glUniformMatrix4fv(gModelMatLoc, 1, GL_FALSE, glm::value_ptr(gModelMat)); gViewMatLoc = glGetUniformLocation(gRenderProg, "uViewMat"); glm::mat4 viewMat = glm::mat4(1.f); viewMat = glm::rotate(glm::mat4(1.f), 0.75f, glm::vec3(1.f, 0.f, 0.f)) * viewMat; viewMat = glm::translate(glm::mat4(1.f), glm::vec3(0.f, 0.f, -50.f)) * viewMat; glUniformMatrix4fv(gViewMatLoc, 1, GL_FALSE, glm::value_ptr(viewMat)); gProjMatLoc = glGetUniformLocation(gRenderProg, "uProjMat"); glm::mat4 projMat = glm::perspective(45.f, (float)gScreenWidth / (float)gScreenHeight, PROJ_NEAR, PROJ_FAR); glUniformMatrix4fv(gProjMatLoc, 1, GL_FALSE, glm::value_ptr(projMat)); gScaleBiasMatLoc = glGetUniformLocation(gRenderProg, "uScaleBiasMat"); glUniformMatrix4fv(gScaleBiasMatLoc, 1, GL_FALSE, glm::value_ptr(scaleBiasMat)); gShadowMatLoc = glGetUniformLocation(gRenderProg, "uShadowMat"); glm::mat4 shadowMat = shadowProjMat * shadowViewMat; glUniformMatrix4fv(gShadowMatLoc, 1, GL_FALSE, glm::value_ptr(shadowMat)); gTexUnitLoc = glGetUniformLocation(gRenderProg, "uTexUnit"); glUniform1i(gTexUnitLoc, 0); gIsTexturedLoc = glGetUniformLocation(gRenderProg, "uIsTextured"); glUniform1i(gIsTexturedLoc, 1); gColorLoc = glGetUniformLocation(gRenderProg, "uColor"); glm::vec4 color = {1.0f, 0.f, 0.f, 1.f}; glUniform4fv(gColorLoc, 1, glm::value_ptr(color)); gAmbientLoc = glGetUniformLocation(gRenderProg, "uAmbient"); glm::vec3 ambVec = {0.3f, 0.3f, 0.3f}; glUniform3fv(gAmbientLoc, 1, glm::value_ptr(ambVec)); gDiffuseLoc = glGetUniformLocation(gRenderProg, "uDiffuse"); glm::vec3 difVec = {0.5f, 0.f, 0.f}; glUniform3fv(gDiffuseLoc, 1, glm::value_ptr(difVec)); gSpecularLoc = glGetUniformLocation(gRenderProg, "uSpecular"); glm::vec3 specVec = {1.f, 1.f, 1.f}; glUniform3fv(gSpecularLoc, 1, glm::value_ptr(specVec)); gShininessLoc = glGetUniformLocation(gRenderProg, "uShininess"); float shininess = 20.0f; glUniform1f(gShininessLoc, shininess); gLightPosLoc = glGetUniformLocation(gRenderProg, "uLightPos"); glUniform4fv(gLightPosLoc, 1, glm::value_ptr(lightPos)); gSpecStrengthLoc = glGetUniformLocation(gRenderProg, "uSpecStrength"); float strength = 3.f; glUniform1f(gSpecStrengthLoc, strength); gConstAttenuationLoc = glGetUniformLocation(gRenderProg, "uConstAttenuation"); float constAttenuation = 1.f; glUniform1f(gConstAttenuationLoc, constAttenuation); gLinearAttenuationLoc = glGetUniformLocation(gRenderProg, "uLinearAttenuation"); float linearAttenuation = 0.05f; glUniform1f(gLinearAttenuationLoc, linearAttenuation); gConeDirectionLoc = glGetUniformLocation(gRenderProg, "uConeDirection"); glUniform3fv(gConeDirectionLoc, 1, glm::value_ptr(coneDir)); gConeAngleLoc = glGetUniformLocation(gRenderProg, "uConeAngle"); float coneAngle = 0.8f; glUniform1f(gConeAngleLoc, coneAngle); gSpotExponentLoc = glGetUniformLocation(gRenderProg, "uSpotExponent"); float spotExponent = 1.0f; glUniform1f(gSpotExponentLoc, spotExponent); gAmbientSkyLoc = glGetUniformLocation(gRenderProg, "uAmbientSky"); glm::vec3 ambientSky = {0.3f, 0.3f, 0.3f}; glUniform3fv(gAmbientSkyLoc, 1, glm::value_ptr(ambientSky)); gAmbientGroundLoc = glGetUniformLocation(gRenderProg, "uAmbientGround"); glm::vec3 ambientGround = {0.1f, 0.1f, 0.1f}; glUniform3fv(gAmbientGroundLoc, 1, glm::value_ptr(ambientGround)); gDepthTextureLoc = glGetUniformLocation(gRenderProg, "uDepthTexture"); glUniform1i(gDepthTextureLoc, 2); //Vertex Array Object glGenVertexArrays(1, &gVao); glBindVertexArray(gVao); //Vertex Attribute Specification gPosLoc = glGetAttribLocation(gRenderProg, "vPosition"); glEnableVertexAttribArray(gPosLoc); gTexCoordLoc = glGetAttribLocation(gRenderProg, "vTexCoord"); glEnableVertexAttribArray(gTexCoordLoc); gNormLoc = glGetAttribLocation(gRenderProg, "vNormal"); glEnableVertexAttribArray(gNormLoc); //Floor gFloorObj.modelMat = glm::mat4(1.f); GLuint floorBuffers[3]; glGenBuffers(3, &floorBuffers[0]); glBindBuffer(GL_ARRAY_BUFFER, floorBuffers[0]); glm::vec4 floorPosData[] = {{-60.f, 0.f, -30.f, 1.f}, {-60, 0.f, 30.f, 1.f}, {60.f, 0.f, -30.f, 1.f}, {60.f, 0.f, -30.f, 1.f}, {-60.f, 0.f, 30.f, 1.f}, {60.f, 0.f, 30.f, 1.f}}; glBufferData(GL_ARRAY_BUFFER, 4 * 6 * sizeof(float), &floorPosData[0], GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, floorBuffers[1]); glm::vec2 floorTexCoordData[] = {{0.f, 0.f}, {0.f, 1.f}, {1.f, 0.f}, {1.f, 0.f}, {0.f, 1.f}, {1.f, 1.f}}; glBufferData(GL_ARRAY_BUFFER, 2 * 6 * sizeof(float), &floorTexCoordData[0], GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, floorBuffers[2]); glm::vec3 floorNormData[] = {{0.f, 1.f, 0.f}, {0.f, 1.f, 0.f}, {0.f, 1.f, 0.f}, {0.f, 1.f, 0.f}, {0.f, 1.f, 0.f}, {0.f, 1.f, 0.f}}; glBufferData(GL_ARRAY_BUFFER, 3 * 6 * sizeof(float), &floorNormData[0], GL_STATIC_DRAW); gFloorObj.glPosBuf = floorBuffers[0]; gFloorObj.glTexCoordBuf = floorBuffers[1]; gFloorObj.glNormBuf = floorBuffers[2]; gFloorObj.vertCount = 6; gFloorObj.ambientColor = {0.3f, 0.3f, 0.3f}; gFloorObj.diffuseColor = {0.5f, 0.5f, 0.5f}; gFloorObj.specularColor = {1.f, 1.f, 1.f}; gFloorObj.shininess = 20.f; gFloorObj.specStrength = 0.f; gFloorObj.isTextured = false; gFloorObj.objColor = {0.5f, 0.5f, 0.5f, 1.f}; //Teapot gTeapotObj.modelMat = glm::rotate(glm::mat4(1.f), -1.57f, glm::vec3(1.f, 0.f, 0.f)); GLuint TeapotBuffers[3]; glGenBuffers(3, &TeapotBuffers[0]); glBindBuffer(GL_ARRAY_BUFFER, TeapotBuffers[0]); glBufferData(GL_ARRAY_BUFFER, teapot.m_Info.vertCount * 4 * sizeof(float), &teapot.m_Info.v[0], GL_STREAM_DRAW); glBindBuffer(GL_ARRAY_BUFFER, TeapotBuffers[1]); glBufferData(GL_ARRAY_BUFFER, teapot.m_Info.vertCount * 2 * sizeof(float), &teapot.m_Info.vt[0], GL_STREAM_DRAW); glBindBuffer(GL_ARRAY_BUFFER, TeapotBuffers[2]); glBufferData(GL_ARRAY_BUFFER, teapot.m_Info.vertCount * 3 * sizeof(float), &teapot.m_Info.vn[0], GL_STREAM_DRAW); gTeapotObj.glPosBuf = TeapotBuffers[0]; gTeapotObj.glTexCoordBuf = TeapotBuffers[1]; gTeapotObj.glNormBuf = TeapotBuffers[2]; gTeapotObj.vertCount = teapot.m_Info.vertCount; gTeapotObj.ambientColor = {0.3f, 0.3f, 0.3f}; gTeapotObj.diffuseColor = {0.8f, 0.f, 0.f}; gTeapotObj.specularColor = {1.f, 1.f, 1.f}; gTeapotObj.shininess = 20.f; gTeapotObj.specStrength = 5.f; gTeapotObj.isTextured = false; GLuint TeapotTexture; int imgWidth, imgHeight, imgComp; gTexImage = stbi_load("texture.jpg", &imgWidth, &imgHeight, &imgComp, STBI_rgb); glGenTextures(1, &TeapotTexture); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, TeapotTexture); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, imgWidth, imgHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, gTexImage); glActiveTexture(GL_TEXTURE0); gTeapotObj.glTexture = TeapotTexture; gTeapotObj.glTexUnit = 1; gSceneGraph.push_back(gTeapotObj); gSceneGraph.push_back(gFloorObj); gTextureProg = glCreateProgram(); gTextureVS = CreateShader(GL_VERTEX_SHADER, "texture.vert"); gTextureFS = CreateShader(GL_FRAGMENT_SHADER, "texture.frag"); glAttachShader(gTextureProg, gTextureVS); glAttachShader(gTextureProg, gTextureFS); glLinkProgram(gTextureProg); glUseProgram(gTextureProg); gTextureTexLoc = glGetUniformLocation(gTextureProg, "uTexture"); glUniform1i(gTextureTexLoc, 2); glGenBuffers(1, &gTexturePosBuf); glBindBuffer(GL_ARRAY_BUFFER, gTexturePosBuf); glm::vec4 texturePosData[] = {{-0.5f, 0.5f, 0.f, 1.f}, {-0.5f, -0.5f, 0.f, 1.f}, {0.5f, 0.5f, 0.f, 1.f}, {0.5f, 0.5f, 0.f, 1.f}, {-0.5f, -0.5f, 0.f, 1.f}, {0.5f, -0.5f, 0.f, 1.f}}; glBufferData(GL_ARRAY_BUFFER, 6 * 4 * sizeof(float), &texturePosData[0], GL_STATIC_DRAW); glGenBuffers(1, &gTextureTexCoordBuf); glBindBuffer(GL_ARRAY_BUFFER, gTextureTexCoordBuf); glm::vec2 textureTexCoordData[] = {{0.f, 1.f}, {0.f, 0.f}, {1.f, 1.f}, {1.f, 1.f}, {0.f, 0.f}, {1.f, 0.f}}; glBufferData(GL_ARRAY_BUFFER, 6 * 2 * sizeof(float), &textureTexCoordData[0], GL_STATIC_DRAW); glGenVertexArrays(1, &gTextureVao); glBindVertexArray(gTextureVao); gTexturePosLoc = glGetAttribLocation(gTextureProg, "vPosition"); glEnableVertexAttribArray(gTexturePosLoc); glBindBuffer(GL_ARRAY_BUFFER, gTexturePosBuf); glVertexAttribPointer(gTexturePosLoc, 4, GL_FLOAT, GL_FALSE, 0, NULL); gTextureTexCoordLoc = glGetAttribLocation(gTextureProg, "vTexCoord"); glEnableVertexAttribArray(gTextureTexCoordLoc); glBindBuffer(GL_ARRAY_BUFFER, gTextureTexCoordBuf); glVertexAttribPointer(gTextureTexCoordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL); }
void program_draw( void *ptr ) { unsigned int i = 0; PROGRAM *program = ( PROGRAM * )ptr; while( i != program->uniform_count ) { if( program->uniform_array[ i ].constant ) { ++i; continue; } else if( !strcmp( program->uniform_array[ i ].name, "MODELVIEWPROJECTIONMATRIX" ) ) { glUniformMatrix4fv( program->uniform_array[ i ].location, 1, GL_FALSE, ( float * )GFX_get_modelview_projection_matrix() ); } else if( !strcmp( program->uniform_array[ i ].name, "DIFFUSE" ) ) { glUniform1i( program->uniform_array[ i ].location, 1 ); program->uniform_array[ i ].constant = 1; } else if( !strcmp( program->uniform_array[ i ].name, "BUMP" ) ) { glUniform1i( program->uniform_array[ i ].location, 4 ); program->uniform_array[ i ].constant = 1; } // Matrix Data else if( !strcmp( program->uniform_array[ i ].name, "MODELVIEWMATRIX" ) ) { glUniformMatrix4fv( program->uniform_array[ i ].location, 1, GL_FALSE, ( float * )GFX_get_modelview_matrix() ); } else if( !strcmp( program->uniform_array[ i ].name, "PROJECTIONMATRIX" ) ) { glUniformMatrix4fv( program->uniform_array[ i ].location, 1, GL_FALSE, ( float * )GFX_get_projection_matrix() ); program->uniform_array[ i ].constant = 1; } else if( !strcmp( program->uniform_array[ i ].name, "NORMALMATRIX" ) ) { glUniformMatrix3fv( program->uniform_array[ i ].location, 1, GL_FALSE, ( float * )GFX_get_normal_matrix() ); } // Material Data else if( !strcmp( program->uniform_array[ i ].name, "MATERIAL.ambient" ) ) { glUniform4fv( program->uniform_array[ i ].location, 1, ( float * )&objmesh->current_material->ambient ); program->uniform_array[ i ].constant = 1; } else if( !strcmp( program->uniform_array[ i ].name, "MATERIAL.diffuse" ) ) { glUniform4fv( program->uniform_array[ i ].location, 1, ( float * )&objmesh->current_material->diffuse ); program->uniform_array[ i ].constant = 1; } else if( !strcmp( program->uniform_array[ i ].name, "MATERIAL.specular" ) ) { glUniform4fv( program->uniform_array[ i ].location, 1, ( float * )&objmesh->current_material->specular ); program->uniform_array[ i ].constant = 1; } else if( !strcmp( program->uniform_array[ i ].name, "MATERIAL.shininess" ) ) { glUniform1f( program->uniform_array[ i ].location, objmesh->current_material->specular_exponent * 0.128f ); program->uniform_array[ i ].constant = 1; } ++i; } char tmp[ MAX_CHAR ] = {""}; sprintf( tmp, "LAMP_FS.color" ); glUniform4fv( PROGRAM_get_uniform_location( program, tmp ), 1, ( float * )&lamp->color ); if( lamp->type == 0 ) { vec3 direction; sprintf( tmp, "LAMP_VS.direction" ); LAMP_get_direction_in_eye_space( lamp, &gfx.modelview_matrix[ gfx.modelview_matrix_index - 1 ], &direction ); glUniform3fv( PROGRAM_get_uniform_location( program, tmp ), 1, ( float * )&direction ); } else if( lamp->type == 1 ) { vec4 position; sprintf( tmp, "LAMP_VS.position" ); LAMP_get_position_in_eye_space( lamp, &gfx.modelview_matrix[ gfx.modelview_matrix_index - 1 ], &position ); glUniform3fv( PROGRAM_get_uniform_location( program, tmp ), 1, ( float * )&position ); } else if( lamp->type == 2 ) { vec4 position; sprintf( tmp, "LAMP_VS.position" ); LAMP_get_position_in_eye_space( lamp, &gfx.modelview_matrix[ gfx.modelview_matrix_index - 1 ], &position ); glUniform3fv( PROGRAM_get_uniform_location( program, tmp ), 1, ( float * )&position ); sprintf( tmp, "LAMP_FS.distance" ); glUniform1f( PROGRAM_get_uniform_location( program, tmp ), lamp->distance ); sprintf( tmp, "LAMP_FS.linear_attenuation" ); glUniform1f( PROGRAM_get_uniform_location( program, tmp ), lamp->linear_attenuation ); sprintf( tmp, "LAMP_FS.quadratic_attenuation" ); glUniform1f( PROGRAM_get_uniform_location( program, tmp ), lamp->quadratic_attenuation ); } }
void ShaderProgram::uniform4fv(const std::string& name, int count, const float* data) { glUniform4fv(uniforms_[name], count, data); }