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);
}
