void WorldRenderer::CreateShadowMap(const corgi::CameraInterface& camera,
fplbase::Renderer& renderer, World* world) {
float shadow_map_resolution = static_cast<float>(
world->config->rendering_config()->shadow_map_resolution());
float shadow_map_zoom = world->config->rendering_config()->shadow_map_zoom();
float shadow_map_offset =
world->config->rendering_config()->shadow_map_offset();
vec3 light_position =
LoadVec3(world->config->rendering_config()->light_position());
SetLightPosition(light_position);
light_camera_.set_viewport_angle(kShadowMapViewportAngle / shadow_map_zoom);
light_camera_.set_viewport_resolution(
vec2(shadow_map_resolution, shadow_map_resolution));
vec3 light_camera_focus =
camera.position() + camera.facing() * shadow_map_offset;
light_camera_focus.z() = 0;
vec3 light_facing = light_camera_focus - light_camera_.position();
light_camera_.set_facing(light_facing.Normalized());
// Shadow map needs to be cleared to near-white, since that's
// the maximum (furthest) depth.
shadow_map_.SetAsRenderTarget();
renderer.ClearFrameBuffer(kShadowMapClearColor);
renderer.SetCulling(fplbase::Renderer::kCullBack);
depth_shader_->Set(renderer);
// Generate the shadow map:
// TODO - modify this so that shadowcast is its own render pass
for (int pass = 0; pass < corgi::RenderPass_Count; pass++) {
world->render_mesh_component.RenderPass(pass, light_camera_,
renderer, depth_shader_);
}
}
DirectionalLight::DirectionalLight(glm::vec3 position)
{
SetLightPosition(
position.x,
position.y,
position.z
);
}
void Environment::NewState()
{
envStates.push_back( new EnvironmentState );
// If the states are greater than 2 copy the previous last element
if( envStates.size() > 1 )
{
SetDuration( envStates[envStates.size()-2]->duration );
SetSkyColor( envStates[envStates.size()-2]->skyColor );
SetFogColor( envStates[envStates.size()-2]->fogColor );
SetFogExponent( envStates[envStates.size()-2]->fogExp );
SetLightColor( envStates[envStates.size()-2]->lightColor );
SetLightPosition( envStates[envStates.size()-2]->lightPosition );
}
}
bool GameWindow::SetupShaders()
{
Log::Printf("Setting up shaders...");
if (glGenVertexArrays && glBindVertexArray)
{
glGenVertexArrays(1, &defaultVao);
glBindVertexArray(defaultVao);
}
defaultVertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(defaultVertexShader, 1, &vertShader, NULL);
glCompileShader(defaultVertexShader);
defaultFragShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(defaultFragShader, 1, &fragShader, NULL);
glCompileShader(defaultFragShader);
GLint status;
char buffer[512];
glGetShaderiv(defaultVertexShader, GL_COMPILE_STATUS, &status);
glGetShaderInfoLog(defaultVertexShader, 512, NULL, buffer);
if (status != GL_TRUE)
{
Log::Logf("Vertex Shader Error: %s\n", buffer);
return false;
}
else
Log::Logf("Vertex Shader Status: %s\n", buffer);
glGetShaderiv(defaultFragShader, GL_COMPILE_STATUS, &status);
glGetShaderInfoLog(defaultFragShader, 512, NULL, buffer);
if (status != GL_TRUE)
{
Log::Logf("Fragment Shader Error: %s\n", buffer);
return false;
}
else Log::Logf("Fragment Shader Status: %s\n", buffer);
defaultShaderProgram = glCreateProgram();
glAttachShader(defaultShaderProgram, defaultVertexShader);
glAttachShader(defaultShaderProgram, defaultFragShader);
// glBindFragDataLocation( defaultShaderProgram, 0, "outColor" );
glLinkProgram(defaultShaderProgram);
// Use our recently compiled program.
glUseProgram(defaultShaderProgram);
// setup our projection matrix
GLuint MatrixID = glGetUniformLocation(defaultShaderProgram, "projection");
glUniformMatrix4fv(MatrixID, 1, GL_FALSE, &projection[0][0]);
// Clean up..
glDeleteShader(defaultVertexShader);
glDeleteShader(defaultFragShader);
// Set up the uniform constants we'll be using in the program.
uniforms[A_POSITION] = glGetAttribLocation(defaultShaderProgram, "position");
uniforms[A_UV] = glGetAttribLocation(defaultShaderProgram, "vertexUV");
uniforms[A_COLOR] = glGetAttribLocation(defaultShaderProgram, "colorvert");
uniforms[U_TRANM] = glGetUniformLocation(defaultShaderProgram, "tranM");
uniforms[U_MVP] = glGetUniformLocation(defaultShaderProgram, "mvp");
uniforms[U_SIM] = glGetUniformLocation(defaultShaderProgram, "siM");
uniforms[U_TRANSL] = glGetUniformLocation(defaultShaderProgram, "useTranslate");
uniforms[U_SMULT] = glGetUniformLocation(defaultShaderProgram, "sMult");
uniforms[U_CENTERED] = glGetUniformLocation(defaultShaderProgram, "Centered");
uniforms[U_COLOR] = glGetUniformLocation(defaultShaderProgram, "Color");
uniforms[U_LMUL] = glGetUniformLocation(defaultShaderProgram, "lMul");
uniforms[U_LPOS] = glGetUniformLocation(defaultShaderProgram, "lPos");
uniforms[U_INVERT] = glGetUniformLocation(defaultShaderProgram, "inverted");
uniforms[U_LIGHT] = glGetUniformLocation(defaultShaderProgram, "AffectedByLightning");
uniforms[U_HIDDEN] = glGetUniformLocation(defaultShaderProgram, "HiddenLightning");
uniforms[U_HIDLOW] = glGetUniformLocation(defaultShaderProgram, "clampHSUnder");
uniforms[U_HIDHIGH] = glGetUniformLocation(defaultShaderProgram, "clampHSOver");
uniforms[U_HIDFAC] = glGetUniformLocation(defaultShaderProgram, "HFactor");
uniforms[U_HIDSUM] = glGetUniformLocation(defaultShaderProgram, "clampFLSum");
uniforms[U_REPCOLOR] = glGetUniformLocation(defaultShaderProgram, "replaceColor");
uniforms[U_BTRANSP] = glGetUniformLocation(defaultShaderProgram, "BlackToTransparent");
SetLightPosition(glm::vec3(0, 0, 1));
SetLightMultiplier(1);
return true;
}
void Light::InitDefaultLight()
{
//set default position and colour for a light
SetLightColour(1.0, 1.0, 1.0);
SetLightPosition(0.0, 20.0, 0.0);
}
bool TMD5Renderer::Create()
{
shaderProgram = glCreateProgram();
assert( 0!=shaderProgram );
vertexShader = glCreateShader(GL_VERTEX_SHADER);
assert( 0!=vertexShader );
fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
assert( 0!=fragmentShader );
const std::string& root = TGremlinsFramework::GetInstance()->GetAssetRoot();
char vertexShaderPath[1024];
char fragmentShaderPath[1024];
#ifdef GL_ES_VERSION_2_0
sprintf(vertexShaderPath, "%s%s",root.c_str(), "media/shaders/FlatShading.vs");
sprintf(fragmentShaderPath, "%s%s",root.c_str(), "media/shaders/FlatShading.fs");
#else
sprintf(vertexShaderPath, "%s%s",root.c_str(), "media/shaders/SkinnedMeshGL4.vs");
sprintf(fragmentShaderPath, "%s%s",root.c_str(), "media/shaders/SkinnedMeshGL4.fs");
// sprintf(vertexShaderPath, "%s%s",root.c_str(), "EngineMedia/Shaders/SkinnedMeshGL4.vs");
// sprintf(fragmentShaderPath, "%s%s",root.c_str(), "EngineMedia/Shaders/SkinnedMeshGL4.fs");
#endif
bool loadVSOK = TGraphicsUtils::LoadShaderSource(vertexShader, vertexShaderPath);
assert(loadVSOK);
bool loadFSOK = TGraphicsUtils::LoadShaderSource(fragmentShader, fragmentShaderPath);
assert(loadFSOK);
glCompileShader(vertexShader);
GLint status;
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &status);
glCompileShader(fragmentShader);
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
assert( glGetError() == GL_NO_ERROR);
glBindAttribLocation(shaderProgram, 0, "vertex");
glBindAttribLocation(shaderProgram, 1, "normal");
glBindAttribLocation(shaderProgram, 2, "tangent");
glBindAttribLocation(shaderProgram, 3, "uv");
glBindAttribLocation(shaderProgram, 4, "boneIndices");
glBindAttribLocation(shaderProgram, 5, "weights");
assert( glGetError() == GL_NO_ERROR);
glLinkProgram(shaderProgram);
if( ! TGraphicsUtils::CheckProgramStatus(shaderProgram, GL_LINK_STATUS))
{
TGraphicsUtils::DumpProgramInfoLog(shaderProgram);
}
assert( glGetError() == GL_NO_ERROR);
assert( glGetError() == GL_NO_ERROR);
#ifdef GL_ES_VERSION_2_0
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);
glEnableVertexAttribArray(3);
glEnableVertexAttribArray(4);
glEnableVertexAttribArray(5);
#else
// use VAO and VBO in GLSL 4.1
PrepareBuffers(md5Model);
#endif
diffuseLocation = glGetUniformLocation(shaderProgram, "diffuse");
assert( diffuseLocation != -1 );
glValidateProgram(shaderProgram);
if( ! TGraphicsUtils::CheckProgramStatus(shaderProgram, GL_VALIDATE_STATUS) )
{
TGraphicsUtils::DumpProgramInfoLog(shaderProgram);
}
else
{
TGraphicsUtils::PrintInBlock("Shader validation OK!");
}
assert( glGetError() == GL_NO_ERROR);
glBindTexture(GL_TEXTURE_2D, 0);
glUseProgram(0);
viewMatrix = Matrix4::IDENTITY;
projectionMatrix = Matrix4::IDENTITY;
worldMatrix = Matrix4::IDENTITY;
UpdateMatrix();
SetLightPosition(Vector3(1.0f, 1.0f, 1.0f));
SetEyePosition(Vector3(0.0f, 0.0f, 100.0f));
nearPlane = 0.1f;
farPlane = 1000.0f;
return true;
}
void ObjMeshGPUDeformer::Init(ObjMesh * mesh_, ObjMeshRender * meshRender_, int renderingMode_)
{
mesh = mesh_;
meshRender = meshRender_;
renderingMode = renderingMode_;
printf("Initializing ObjMeshGPUDeformer...\n");
#ifdef OBJMESHGPUDEFORMER_USING_VBOS
// init the GL_ARB_vertex_buffer_object extension
if (!InitializeVBOs())
{
printf("Unable to load the GL_ARB_vertex_buffer_object extension\n");
throw 31;
}
printf("Detected extension: GL_ARB_vertex_buffer_object\n");
#endif
// default lighting: single light of intensity 1 at the origin
// set the other lights away from the object
// (to avoid a vertex accidentally coinciding with a light source (which will cause a division by zero in the shader when normalizing the light vector))
memset(lightPos, 0, sizeof(float) * 16);
memset(lightIntensity, 0, sizeof(float) * 4);
lightIntensity[0] = 1.0;
ambientIntensity = 0.0;
// set the other three lights to be far away and of zero intensity
float vtx_max[4] = { FLT_MAX, FLT_MAX, FLT_MAX, 1.0 };
SetLightPosition(1, vtx_max);
SetLightPosition(2, vtx_max);
SetLightPosition(3, vtx_max);
ambientEnabled = true;
diffuseEnabled = true;
specularEnabled = true;
numVertices = mesh->getNumVertices();
numGroups = mesh->getNumGroups();
numGroupTriangles = (int*) malloc (sizeof(int) * numGroups);
// count num mesh triangles
numTriangles = 0;
for(int groupNo=0; groupNo<numGroups; groupNo++)
{
const ObjMesh::Group * groupHandle = mesh->getGroupHandle(groupNo);
// count num triangles
numGroupTriangles[groupNo] = 0;
for(unsigned int iFace = 0; iFace < groupHandle->getNumFaces(); iFace++)
{
const ObjMesh::Face * faceHandle = groupHandle->getFaceHandle(iFace);
numGroupTriangles[groupNo] += faceHandle->getNumVertices() - 2;
}
numTriangles += numGroupTriangles[groupNo];
}
InitVertexDeformationTexture();
printf ("ObjMeshGPUDeformer initialization complete.\n");
}
