void drawObjects(GLuint shaderId){
glUniformMatrix4fv(glGetUniformLocation(shaderId, "projMatrix"), 1, GL_TRUE, projectionMatrix.m);
glUniformMatrix4fv(glGetUniformLocation(shaderId, "viewMatrix"), 1, GL_TRUE, viewMatrix.m);
glUniform3f(glGetUniformLocation(shaderId,"lightPosition"), lightPosition.x, lightPosition.y, lightPosition.z);
//bunny
setTextureMatrix(modelMatrix);
glUniform1f(glGetUniformLocation(shaderId, "shade"), 0.9); // Brighter objects
glUniformMatrix4fv(glGetUniformLocation(shaderId, "modelMatrix"), 1, GL_TRUE, modelMatrix.m);
glUniformMatrix4fv(glGetUniformLocation(shaderId, "textureMatrix"), 1, GL_TRUE, textureMatrix.m);
glUniform3f(glGetUniformLocation(shaderId,"objectColor"), bunnyColor.x, bunnyColor.y, bunnyColor.z);
DrawModel(bunny, shaderId, "in_Position", NULL, NULL);
//Box
setTextureMatrix(boxMatrix);
glUniform1f(glGetUniformLocation(shaderId, "shade"), 0.9); // Brighter objects
glUniformMatrix4fv(glGetUniformLocation(shaderId, "modelMatrix"), 1, GL_TRUE, boxMatrix.m);
glUniformMatrix4fv(glGetUniformLocation(shaderId, "textureMatrix"), 1, GL_TRUE, textureMatrix.m);
glUniform3f(glGetUniformLocation(shaderId,"objectColor"),1.0,1.0,1.0);
DrawModel(box, shaderId, "in_Position", NULL, NULL);
//Statue
setTextureMatrix(statueMatrix);
glUniform1f(glGetUniformLocation(shaderId, "shade"), 0.9); // Brighter objects
glUniformMatrix4fv(glGetUniformLocation(shaderId, "modelMatrix"), 1, GL_TRUE, statueMatrix.m);
glUniformMatrix4fv(glGetUniformLocation(shaderId, "textureMatrix"), 1, GL_TRUE, textureMatrix.m);
glUniform3f(glGetUniformLocation(shaderId,"objectColor"),1.0,1.0,1.0);
DrawModel(statue, shaderId, "in_Position", NULL, NULL);
// //scene
// setTextureMatrix(bottomModelMatrix);
// glUniform1f(glGetUniformLocation(shaderId, "shade"), 0.5); // Brighter objects
// glUniform3f(glGetUniformLocation(shaderId,"objectColor"), sceneColor.x, sceneColor.y, sceneColor.z);
// glUniformMatrix4fv(glGetUniformLocation(shaderId, "modelMatrix"), 1, GL_TRUE, bottomModelMatrix.m);
// glUniformMatrix4fv(glGetUniformLocation(shaderId, "textureMatrix"), 1, GL_TRUE, textureMatrix.m);
// DrawModel(bottom, shaderId, "in_Position", NULL,NULL);
// setTextureMatrix(side1ModelMatrix);
// glUniform1f(glGetUniformLocation(shaderId, "shade"), 0.5); // Brighter objects
// glUniformMatrix4fv(glGetUniformLocation(shaderId, "modelMatrix"), 1, GL_TRUE, side1ModelMatrix.m);
// glUniformMatrix4fv(glGetUniformLocation(shaderId, "textureMatrix"), 1, GL_TRUE, textureMatrix.m);
// DrawModel(side1, shaderId, "in_Position", NULL, NULL);
// setTextureMatrix(side2ModelMatrix);
// glUniform1f(glGetUniformLocation(shaderId, "shade"), 0.5); // Brighter objects
// glUniformMatrix4fv(glGetUniformLocation(shaderId, "modelMatrix"), 1, GL_TRUE, side2ModelMatrix.m);
// glUniformMatrix4fv(glGetUniformLocation(shaderId, "textureMatrix"), 1, GL_TRUE, textureMatrix.m);
// DrawModel(side2, shaderId, "in_Position", NULL, NULL);
}
void draw1(void)
{
setTextureMatrix();
glTranslatef(pos[1][0], pos[1][1], pos[1][2]);
glRotatef(angle[1][2], 0.0, 0.0, 1.0);//z軸回転
glRotatef(angle[1][1], 0.0, 1.0, 0.0);//y軸回転
glRotatef(angle[1][0] + ang, 1.0, 0.0, 0.0);//x軸回転
glScalef(scale[1][0], scale[1][1], scale[1][2]);
float ambient[] = { 0.3, 0.3, 0.3, 1.0};
float diffuse[] = { 0.7, 0.7, 0.7, 1.0};
float specular[]= { 0.5, 0.5, 0.5, 1.0};
glMaterialfv(GL_FRONT,GL_AMBIENT,ambient);
glMaterialfv(GL_FRONT,GL_DIFFUSE,diffuse);
glMaterialfv(GL_FRONT,GL_SPECULAR,specular);
glMaterialf(GL_FRONT,GL_SHININESS,100);
//モデルビュー変換行列に戻す
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glTranslatef(pos[1][0], pos[1][1], pos[1][2]);
glRotatef(angle[1][2], 0.0, 0.0, 1.0);//z軸回転
glRotatef(angle[1][1], 0.0, 1.0, 0.0);//y軸回転
glRotatef(angle[1][0] + ang, 1.0, 0.0, 0.0);//x軸回転
glScalef(scale[1][0], scale[1][1], scale[1][2]);
drawBumpCube(1.0, 1, 1);
glPopMatrix();
}
void renderScene(void)
{
update();
//First step: Render from the light POV to a FBO, story depth values only
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,fboId); //Rendering offscreen
//Using the fixed pipeline to render to the depthbuffer
glUseProgramObjectARB(0);
// In the case we render the shadowmap to a higher resolution, the viewport must be modified accordingly.
glViewport(0,0,RENDER_WIDTH * SHADOW_MAP_RATIO,RENDER_HEIGHT* SHADOW_MAP_RATIO);
// Clear previous frame values
glClear( GL_DEPTH_BUFFER_BIT);
//Disable color rendering, we only want to write to the Z-Buffer
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
setupMatrices(p_light[0],p_light[1],p_light[2],l_light[0],l_light[1],l_light[2]);
// Culling switching, rendering only backface, this is done to avoid self-shadowing
glCullFace(GL_FRONT);
drawObjects();
//Save modelview/projection matrice into texture7, also add a biais
setTextureMatrix();
// Now rendering from the camera POV, using the FBO to generate shadows
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,0);
glViewport(0,0,RENDER_WIDTH,RENDER_HEIGHT);
//Enabling color write (previously disabled for light POV z-buffer rendering)
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
// Clear previous frame values
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//Using the shadow shader
glUseProgramObjectARB(shadowShaderId);
glUniform1iARB(shadowMapUniform,7);
glActiveTextureARB(GL_TEXTURE7);
glBindTexture(GL_TEXTURE_2D,depthTextureId);
setupMatrices(p_camera[0],p_camera[1],p_camera[2],l_camera[0],l_camera[1],l_camera[2]);
glCullFace(GL_BACK);
drawObjects();
glutSwapBuffers();
}
void Painter::restoreSavedState()
{
m_oldStateIndex--;
setResolution(m_olderStates[m_oldStateIndex].resolution);
setProjectionMatrix(m_olderStates[m_oldStateIndex].projectionMatrix);
setTextureMatrix(m_olderStates[m_oldStateIndex].textureMatrix);
setColor(m_olderStates[m_oldStateIndex].color);
setOpacity(m_olderStates[m_oldStateIndex].opacity);
setCompositionMode(m_olderStates[m_oldStateIndex].compositionMode);
setClipRect(m_olderStates[m_oldStateIndex].clipRect);
setShaderProgram(m_olderStates[m_oldStateIndex].shaderProgram);
setTexture(m_olderStates[m_oldStateIndex].texture);
setAlphaWriting(m_olderStates[m_oldStateIndex].alphaWriting);
}
void Painter::setTexture(Texture* texture)
{
if(m_texture == texture)
return;
m_texture = texture;
uint glTextureId;
if(texture) {
setTextureMatrix(texture->getTransformMatrix());
glTextureId = texture->getId();
} else
glTextureId = 0;
if(m_glTextureId != glTextureId) {
m_glTextureId = glTextureId;
updateGlTexture();
}
}
void PerPixelRenderer::render(Renderable& rend)
{
if(_released) {
DefaultRenderer::render(rend);
return;
}
glEnable(GL_TEXTURE_2D);
//render shadow map
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glMatrixMode(GL_PROJECTION);
glPushMatrix();
for(int i=0; i<MAX_LIGHTS; i++)
if(glIsEnabled(GL_LIGHT0+i)) {
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,_fboId[i]);
glViewport(0,0,_w*_shadowRatio,_h*_shadowRatio);
setupMatrices(i);
setTextureMatrix(i);
glCullFace(GL_FRONT);
beforeShadowDraw(i);
rend.drawObject();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,0);
afterShadowDraw(i);
}
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
//render scene
glViewport(0,0,_w,_h);
glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
if(_showLight)drawLights();
if(_shaderDraw)_shaderDraw->begin();
beforeShadowRender(_shaderDraw);
glCullFace(GL_BACK);
rend.drawObject();
if(_shaderDraw)_shaderDraw->end();
}
void drawGround()
{
setTextureMatrix();
glRotatef(-90.0, 1.0, 0.0, 0.0);
float ambient[] = { 0.2f, 0.2f, 0.2f};
float diffuse[] = { 0.8f, 0.8f, 0.8f};
float specular[]= { 0.3f, 0.3f, 0.3f};
glMaterialfv(GL_FRONT,GL_DIFFUSE,diffuse);
glMaterialfv(GL_FRONT,GL_AMBIENT,ambient);
glMaterialfv(GL_FRONT,GL_SPECULAR,specular);
glMaterialf(GL_FRONT,GL_SHININESS,100);
//モデルビュー変換行列に戻す
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glRotatef(-90.0, 1.0, 0.0, 0.0);
drawBumpPlate(10.0, 5, 5);
glPopMatrix();
}
void drawFloor0(float widthX, float widthZ, int nx, int nz)
{
int i, j;
//Floor１枚当たりの幅
float wX = widthX / (float)nx;
float wZ = widthZ / (float)nz;
float diffuse[][4] = {
{ 0.7, 0.7, 0.6, 1.0}, { 0.3f, 0.4, 0.4, 1.0} };
float ambient[] = { 0.2, 0.2, 0.2, 1.0};
float specular[]= { 0.5, 0.5, 0.5, 1.0};
glMaterialfv(GL_FRONT,GL_AMBIENT,ambient);
glMaterialfv(GL_FRONT,GL_SPECULAR,specular);
glMaterialf(GL_FRONT,GL_SHININESS,100);
setTextureMatrix();
//通常の描画設定に戻す
glMatrixMode(GL_MODELVIEW);
glNormal3f(0.0, 1.0, 0.0);
glPushMatrix();
for (j = 0; j < nz; j++)
{
float z1 = -widthZ / 2.0 + wZ * j; float z2 = z1 + wZ;
for (i = 0; i < nx; i++) {
float x1 = -widthX / 2.0 + wX * i; float x2 = x1 + wX;
glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuse[(i + j) & 1]);
glBegin(GL_QUADS);
glVertex3f(x1, 0.0, z1);
glVertex3f(x1, 0.0, z2);
glVertex3f(x2, 0.0, z2);
glVertex3f(x2, 0.0, z1);
glEnd();
}
}
glPopMatrix();
}
void draw1(void)
{
float ambient[] = { 0.2, 0.1, 0.1, 1.0};
float diffuse[] = { 0.8, 0.2, 0.2, 1.0};
float specular[]= { 0.5, 0.5, 0.5, 1.0};
if(flagShadow)
{
glMaterialfv(GL_FRONT,GL_AMBIENT_AND_DIFFUSE,shadowDiffuse);
glMaterialfv(GL_FRONT,GL_SPECULAR,shadowSpecular);
}
else
{
glMaterialfv(GL_FRONT,GL_AMBIENT,ambient);
glMaterialfv(GL_FRONT,GL_DIFFUSE,diffuse);
glMaterialfv(GL_FRONT,GL_SPECULAR,specular);
glMaterialf(GL_FRONT,GL_SHININESS,100);
}
setTextureMatrix();
//テクスチャ座標のためのモデリング変換
glTranslatef(pos[1][0], pos[1][1], pos[1][2]);
glRotatef(angle[1][2], 0.0, 0.0, 1.0);//z軸回転
glRotatef(angle[1][1], 0.0, 1.0, 0.0);//y軸回転
glRotatef(angle[1][0] + ang, 1.0, 0.0, 0.0);//x軸回転
glScalef(scale[1][0], scale[1][1], scale[1][2]);
//通常のモデルビュー変換に戻す
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glTranslatef(pos[1][0], pos[1][1], pos[1][2]);
glRotatef(angle[1][2], 0.0, 0.0, 1.0);//z軸回転
glRotatef(angle[1][1], 0.0, 1.0, 0.0);//y軸回転
glRotatef(angle[1][0] + ang, 1.0, 0.0, 0.0);//x軸回転
glScalef(scale[1][0], scale[1][1], scale[1][2]);
glutSolidCube(1.0);
glPopMatrix();
}
void Mesh::drawVBOs() {
// scale it so it fits in the window
Vec3f center; bbox.getCenter(center);
float s = 1/bbox.maxDim();
glScalef(s,s,s);
glTranslatef(-center.x(),-center.y(),-center.z());
// setup the light
Vec3f light_position = LightPosition();
GLfloat position[4] = { float(light_position.x()),float(light_position.y()),float(light_position.z()),1 };
glLightfv(GL_LIGHT1, GL_POSITION, position);
if (args->glsl_enabled) {
glEnable(GL_DEPTH_TEST);
glClearColor(0,0,0,1.0f);
glEnable(GL_CULL_FACE);
//glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
//BEGIN SHADOW FUN/////////////===================================
//First step: Render from the light POV to a FBO, story depth values only
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,fboId); //Rendering offscreen
//Using the fixed pipeline to render to the depthbuffer
glUseProgramObjectARB(0);
// In the case we render the shadowmap to a higher resolution, the viewport must be modified accordingly.
glViewport(0,0,args->width * SHADOW_MAP_RATIO,args->height* SHADOW_MAP_RATIO);
// Clear previous frame values
glClear(GL_DEPTH_BUFFER_BIT);
//Disable color rendering, we only want to write to the Z-Buffer
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
//LIGHT POSITION==========================================================================================
setupMatrices(float(light_position.x()),float(light_position.y()),float(light_position.z()),
10,10,1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45,args->width/args->height,1.0f,1000.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt((float)light_position.x(),(float)light_position.y(),(float)light_position.z(),0,0,0,0,1,0);
// Culling switching, rendering only backface, this is done to avoid self-shadowing
glCullFace(GL_FRONT);
//===========Draw the Things===================================================================================
InsertColor(floor_color);
DrawFloor();
//startTranslate(0,0,0);
//glutSolidCube(1);
InsertColor(mesh_color);
glUseProgramObjectARB(GLCanvas::program);
glColor3b(GLbyte(240-127), GLbyte(184-127), GLbyte(0-127));
DrawMesh(table, board_tri_verts_VBO);
DrawPieces(editBoard());
//endTranslate();
glUseProgramObjectARB(0);
//=============================================================================================================
//Save modelview/projection matrice into texture7, also add a biais
setTextureMatrix();
// Now rendering from the camera POV, using the FBO to generate shadows
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,0);
glViewport(0,0,args->width,args->height);
//Enabling color write (previously disabled for light POV z-buffer rendering)
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
// Clear previous frame values
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//Using the shadow shader
glUseProgramObjectARB(GLCanvas::program);
glUniform1iARB(shadowMapUniform,7);
glActiveTextureARB(GL_TEXTURE7);
glBindTexture(GL_TEXTURE_2D,depthTextureId);
Vec3f cam_position = camera->camera_position;
Vec3f interest = camera->point_of_interest;
//CAMERA MATRIX=======================================================================================================
//setupMatrices(cam_pos[0],cam_pos[1],cam_pos[2],interest[0],interest[1],interest[2]);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45,args->width/args->height,1.0f,1000.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt((float)cam_position.x(),(float)cam_position.y(),(float)cam_position.z(),(float)interest.x(),(float)interest.y(),(float)interest.z(),0,1,0);
glCullFace(GL_BACK);
//============================Draw the things
InsertColor(floor_color);
DrawFloor();
//startTranslate(0,0,0);
//glutSolidCube(1);
InsertColor(mesh_color);
glUseProgramObjectARB(GLCanvas::program);
glColor3b(GLbyte(240-127), GLbyte(184-127), GLbyte(0-127));
DrawMesh(table, board_tri_verts_VBO);
DrawPieces(editBoard());
//endTranslate();
glUseProgramObjectARB(0);
//============================All the things
// DEBUG only. this piece of code draw the depth buffer onscreen
//*
glUseProgramObjectARB(0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-args->width/2,args->width/2,-args->height/2,args->height/2,1,20);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glColor4f(1,1,1,1);
glActiveTextureARB(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D,depthTextureId);
glEnable(GL_TEXTURE_2D);
glTranslated(0,0,-1);
glBegin(GL_QUADS);
glTexCoord2d(0,0);glVertex3f(0,0,0);
glTexCoord2d(1,0);glVertex3f(args->width/2,0,0);
glTexCoord2d(1,1);glVertex3f(args->width/2,args->width/2,0);
glTexCoord2d(0,1);glVertex3f(0,args->height/2,0);
glEnd();
glDisable(GL_TEXTURE_2D);
//*/
//glutSwapBuffers();
glDisable(GL_STENCIL_TEST);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glDepthMask(1);
//END SHADOW FUN//////////////////////////////////////////////////
}
else
{
InsertColor(floor_color);
DrawFloor();
InsertColor(mesh_color);
glColor3b(GLbyte(240-127), GLbyte(184-127), GLbyte(0-127));
DrawMesh(table, board_tri_verts_VBO);
if(args->board_control)
{
DrawControlMap();
}
DrawPieces(editBoard());
}
// -------------------------
// ADDITIONAL VISUALIZATIONS (for debugging)
glColor3f(1,1,0);
//DrawLight();
if (args->bounding_box) {
glColor3f(0,0,0);
bbox.drawVBOs();
}
HandleGLError();
}
void GLAnalyzer2::paintGL() {
// Compute the dT since the last call to paintGL and update timings
timeval tv;
gettimeofday(&tv, nullptr);
double currentTime = (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0;
show.dT = currentTime - show.timeStamp;
show.timeStamp = currentTime;
// Clear frame
glClear(GL_COLOR_BUFFER_BIT);
// Shitch to MODEL matrix and reset it to default
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// Fade the previous drawings.
/* glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glBegin( GL_TRIANGLE_STRIP );
glColor4f( 0.0f, 0.0f, 0.0f, 0.2f );
glVertex2f( 10.0f, 10.0f );
glVertex2f( -10.0f, 10.0f );
glVertex2f( 10.0f, -10.0f );
glVertex2f( -10.0f, -10.0f );
glEnd();*/
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_TEXTURE_2D);
float alphaN = show.paused ? 0.2 : (frame.energy / 10.0),
alphaP = show.paused ? 1.0 : (1 - frame.energy / 20.0);
if (alphaN > 1.0) alphaN = 1.0;
if (alphaP < 0.1) alphaP = 0.1;
glBindTexture(GL_TEXTURE_2D, w2Texture);
setTextureMatrix(show.rotDegrees, 0.707 * alphaP);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(1.0, 1.0);
glVertex2f(10.0f, 10.0f);
glTexCoord2f(0.0, 1.0);
glVertex2f(-10.0f, 10.0f);
glTexCoord2f(1.0, 0.0);
glVertex2f(10.0f, -10.0f);
glTexCoord2f(0.0, 0.0);
glVertex2f(-10.0f, -10.0f);
glEnd();
glBindTexture(GL_TEXTURE_2D, w1Texture);
setTextureMatrix(-show.rotDegrees * 2, 0.707);
glColor4f(1.0f, 1.0f, 1.0f, alphaN);
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(1.0, 1.0);
glVertex2f(10.0f, 10.0f);
glTexCoord2f(0.0, 1.0);
glVertex2f(-10.0f, 10.0f);
glTexCoord2f(1.0, 0.0);
glVertex2f(10.0f, -10.0f);
glTexCoord2f(0.0, 0.0);
glVertex2f(-10.0f, -10.0f);
glEnd();
setTextureMatrix(0.0, 0.0);
glDisable(GL_TEXTURE_2D);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
// Here begins the real draw loop
// some updates to the show
show.rotDegrees += 40.0 * show.dT;
frame.rotDegrees += 80.0 * show.dT;
// handle the 'pause' status
if (show.paused) {
if (show.pauseTimer > 0.5) {
if (show.pauseTimer > 0.6) show.pauseTimer -= 0.6;
drawFullDot(0.0f, 0.4f, 0.8f, 1.0f);
drawFullDot(0.0f, 0.4f, 0.8f, 1.0f);
}
show.pauseTimer += show.dT;
return;
}
if (dotTexture) {
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, dotTexture);
} else
glDisable(GL_TEXTURE_2D);
glLoadIdentity();
// glRotatef( -frame.rotDegrees, 0,0,1 );
glBegin(GL_QUADS);
// Particle * particle = particleList.first();
// for (; particle; particle = particleList.next())
{
glColor4f(0.0f, 1.0f, 0.0f, 1.0f);
drawDot(0, 0, kMax(10.0, (10.0 * frame.energy)));
glColor4f(1.0f, 0.0f, 0.0f, 1.0f);
drawDot(6, 0, kMax(10.0, (5.0 * frame.energy)));
glColor4f(0.0f, 0.4f, 1.0f, 1.0f);
drawDot(-6, 0, kMax(10.0, (5.0 * frame.energy)));
}
glEnd();
}
/*
* The main display function. (Where all the magic happens).
* Five renders done here.
* 1) Depth render. Stores depth and depth squared for VSM
* 2) Gaussian Blur render. Blurs depth render's output
* 3) Light Path Tracing render. Path traces light rays for light scattering effect
* 4) Main render. Rendered with shadows and without light scattering. Has phong illumination and shading, bump map.
* 5) Light Scattering Overlay render. Overlays the output of the Light Path Tracing render as an additive overlay over the current scene.
*
*/
void RenderEngine::renderScene() {
//==FIRST RENDER: DEPTH BUFFER
//Render from the light POV to a FBO, store depth and square depth in a 32F frameBuffer
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,shadowFboId);
//Using the depth shader to do so
glUseProgramObjectARB(depthShade->getProgram());
// In the case we render the shadowmap to a higher resolution, the viewport must be modified accordingly.
glViewport(0,0,kRenderWidth * kShadowMapCoef,kRenderHeight* kShadowMapCoef);
//try to make shadow view "bigger" than normal view
// Clear previous frame values
glClearColor(0,0,0,1.0f);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
setupMatrices(p_light[0],p_light[1],p_light[2],l_light[0],l_light[1],l_light[2],0,1,0,10,100,120);
// Culling switching, rendering only backface, this is done to avoid self-shadowing and improve efficiency
glCullFace(GL_FRONT);
//draw objects using the depth shader
//drawObjects(depthShade);
drawObjectTarget(depthShade);
//cout << "0 " << glGetError() << endl;
glGenerateMipmapEXT(GL_TEXTURE_2D);
//Save modelview/projection matrice into texture7, also add a biais
setTextureMatrix();
//==SECOND (and a half) RENDER: DOUBLE PASS GAUSSIAN BLUR
blurShadowMap();
//==THIRD RENDER: PATH TRACED LIGHT SCATTERING EFFECT (CREPUSCULAR RAYS)
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,scatterFboId);
glViewport(0,0,kLightScatterWidth,kLightScatterHeight);
// Clear previous frame values
if(deathScatter) {
//glClearColor(1,1,1,1.0f);
glClearColor(1,0,0,1.0f);
} else {
glClearColor(0,0,0,1.0f);
}
//glClearColor(1,1,1,1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//Using the shadow shader
glUseProgramObjectARB(darkShade->getProgram());
glBindTexture(GL_TEXTURE_2D,colorTextureId);
setupMatrices(p_camera[0],p_camera[1],p_camera[2],l_camera[0],l_camera[1],l_camera[2],u_camera[0],u_camera[1],u_camera[2],0.5,120,70);
glCullFace(GL_BACK);
//Draw light
glPushMatrix();
glTranslatef(p_light_scatter[0],p_light_scatter[1],p_light_scatter[2]);
glColor4f(1.0,1.0,1.0,1.0);
glutSolidSphere(30,20,20);
glPopMatrix();
//Draw objects in black
glColor4f(0.0f,0.0f,0.0f,1);
//drawObjects(darkShade);
drawObjectTarget(darkShade);
//==FOURTH RENDER: MAIN RENDER (without light scattering)
// Now rendering from the camera POV, using the FBO to generate shadows
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,0);
glViewport(0,0,kRenderWidth,kRenderHeight);
// Clear previous frame values
//glClearColor(.764705882,.890196078,1,1.0f);
glClearColor(skyColor[0], skyColor[1], skyColor[2], skyColor[3]);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//Using the shadow shader
glUseProgramObjectARB(shade->getProgram());
//glUniform1iARB(shade->getShadowMapAttrib(),7);
glActiveTextureARB(GL_TEXTURE7);
glBindTexture(GL_TEXTURE_2D,colorTextureId);
//declared in third pass
//setupMatrices(p_camera[0],p_camera[1],p_camera[2],l_camera[0],l_camera[1],l_camera[2],u_camera[0],u_camera[1],u_camera[2],1,120);
//okay seriously, why do we have vec and float[] is required by openGL -_-
float tempLight[4] = {p_light[0], p_light[1], p_light[2], 1};
glLightfv(GL_LIGHT0, GL_POSITION, tempLight);
glCullFace(GL_BACK);
//draw objects using our shadow shader
//drawObjects(shade);
drawObjectTarget(shade);
//==FIFTH PASS: LIGHT SCATTERING OVERLAY
//uses main screen
//glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,0);
//glViewport(0,0,kRenderWidth,kRenderHeight);
glClear (GL_DEPTH_BUFFER_BIT );
//glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgramObjectARB(scatterShade->getProgram());
//default values
vec2 cameraSpaceLightPos = getLightScreenCoor();
glUniform1fARB(scatterShade->getExposureAttrib(),0.0034);
glUniform1fARB(scatterShade->getDecayAttrib(),1.0);
glUniform1fARB(scatterShade->getDensityAttrib(),0.84);
glUniform1fARB(scatterShade->getWeightAttrib(),5.65);
glUniform1iARB(scatterShade->getTextureAttrib(),0);
glUniform2fARB(scatterShade->getLightPositionOnScreenAttrib(),cameraSpaceLightPos[0],cameraSpaceLightPos[1]);
glActiveTextureARB(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D,scatterTextureId);
glEnable(GL_BLEND); //blend the resulting render
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-kRenderWidth/2,kRenderWidth/2,-kRenderHeight/2,kRenderHeight/2,1,20);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glColor4f(1.0f,1.0f,1.0f,1); //rectangle to display texture
glPushMatrix();
glTranslated(0,0,-5);
glBegin(GL_QUADS);
glTexCoord2d(0,0);glVertex3f(-kRenderWidth/2,-kRenderHeight/2,0);
glTexCoord2d(1,0);glVertex3f(kRenderWidth/2,-kRenderHeight/2,0);
glTexCoord2d(1,1);glVertex3f(kRenderWidth/2,kRenderHeight/2,0);
glTexCoord2d(0,1);glVertex3f(-kRenderWidth/2,kRenderHeight/2,0);
glEnd();
glPopMatrix();
glDisable(GL_BLEND);
drawOverlayTarget();
/*
if(renderOpt.isDepthBuffer())
drawDebugBuffer(renderOpt.getDepthBufferOption());
*/
glutSwapBuffers();
}
/** Creates the slip stream object using a moving texture.
* \param kart Pointer to the kart to which the slip stream
* belongs to.
*/
SlipStream::SlipStream(AbstractKart* kart) : MovingTexture(0, 0), m_kart(kart)
{
video::SMaterial m;
m.BackfaceCulling = false;
m.MaterialType = video::EMT_SOLID;
Material *material = material_manager->getMaterial("slipstream.png");
m.setTexture(0, material->getTexture());
m.setFlag(video::EMF_BACK_FACE_CULLING, false);
m.setFlag(video::EMF_COLOR_MATERIAL, true);
m.ColorMaterial = video::ECM_DIFFUSE_AND_AMBIENT;
m.MaterialType = video::EMT_TRANSPARENT_ADD_COLOR;
createMesh(m);
m_node = irr_driver->addMesh(m_mesh);
m_mesh->drop();
#ifdef DEBUG
std::string debug_name = m_kart->getIdent()+" (slip-stream)";
m_node->setName(debug_name.c_str());
#endif
m_node->setPosition(core::vector3df(0,
0*0.25f+2.5,
m_kart->getKartLength()) );
m_node->setVisible(false);
setTextureMatrix(&(m_node->getMaterial(0).getTextureMatrix(0)));
m_slipstream_time = 0.0f;
float length = m_kart->getKartProperties()->getSlipstreamLength();
float kw = m_kart->getKartWidth();
float ew = m_kart->getKartProperties()->getSlipstreamWidth();
float kl = m_kart->getKartLength();
Vec3 p[4];
p[0]=Vec3(-kw*0.5f, 0, -kl*0.5f );
p[1]=Vec3(-ew*0.5f, 0, -kl*0.5f-length);
p[2]=Vec3( ew*0.5f, 0, -kl*0.5f-length);
p[3]=Vec3( kw*0.5f, 0, -kl*0.5f );
m_slipstream_original_quad = new Quad(p[0], p[1], p[2], p[3]);
m_slipstream_quad = new Quad(p[0], p[1], p[2], p[3]);
if(UserConfigParams::m_slipstream_debug)
{
video::SMaterial material;
material.MaterialType = video::EMT_TRANSPARENT_ADD_COLOR;
material.setFlag(video::EMF_BACK_FACE_CULLING, false);
material.setFlag(video::EMF_LIGHTING, false);
m_debug_mesh = irr_driver->createQuadMesh(&material, true);
scene::IMeshBuffer *buffer = m_debug_mesh->getMeshBuffer(0);
assert(buffer->getVertexType()==video::EVT_STANDARD);
irr::video::S3DVertex* vertices
= (video::S3DVertex*)buffer->getVertices();
video::SColor red(128, 255, 0, 0);
for(unsigned int i=0; i<4; i++)
{
vertices[i].Pos = p[i].toIrrVector();
vertices[i].Color = red;
}
buffer->recalculateBoundingBox();
m_mesh->setBoundingBox(buffer->getBoundingBox());
m_debug_node = irr_driver->addMesh(m_debug_mesh, m_kart->getNode());
m_debug_node->grab();
}
else
{
m_debug_mesh = NULL;
m_debug_node = NULL;
}
} // SlipStream
/** Creates the slip stream object using a moving texture.
* \param kart Pointer to the kart to which the slip stream
* belongs to.
*/
SlipStream::SlipStream(AbstractKart* kart) : MovingTexture(0, 0), m_kart(kart)
{
Material *material = material_manager->getMaterial("slipstream.png");
createMesh(material);
m_node = irr_driver->addMesh(m_mesh, "splistream");
scene::IMeshBuffer* buffer = m_mesh->getMeshBuffer(0);
material->setMaterialProperties(&buffer->getMaterial(), buffer);
STKMeshSceneNode* stk_node = dynamic_cast<STKMeshSceneNode*>(m_node);
if (stk_node != NULL)
stk_node->setReloadEachFrame(true);
m_mesh->drop();
#ifdef DEBUG
std::string debug_name = m_kart->getIdent()+" (slip-stream)";
m_node->setName(debug_name.c_str());
#endif
m_node->setPosition(core::vector3df(0,
0*0.25f+2.5,
m_kart->getKartLength()) );
m_node->setVisible(false);
setTextureMatrix(&(m_node->getMaterial(0).getTextureMatrix(0)));
m_slipstream_time = 0.0f;
float length = m_kart->getKartProperties()->getSlipstreamLength() *
m_kart->getPlayerDifficulty()->getSlipstreamLength();
float kw = m_kart->getKartWidth();
float ew = m_kart->getKartProperties()->getSlipstreamWidth() *
m_kart->getPlayerDifficulty()->getSlipstreamWidth();
float kl = m_kart->getKartLength();
Vec3 p[4];
p[0]=Vec3(-kw*0.5f, 0, -kl*0.5f );
p[1]=Vec3(-ew*0.5f, 0, -kl*0.5f-length);
p[2]=Vec3( ew*0.5f, 0, -kl*0.5f-length);
p[3]=Vec3( kw*0.5f, 0, -kl*0.5f );
m_slipstream_original_quad = new Quad(p[0], p[1], p[2], p[3]);
m_slipstream_quad = new Quad(p[0], p[1], p[2], p[3]);
if(UserConfigParams::m_slipstream_debug)
{
video::SMaterial material;
material.MaterialType = video::EMT_TRANSPARENT_ADD_COLOR;
material.setFlag(video::EMF_BACK_FACE_CULLING, false);
material.setFlag(video::EMF_LIGHTING, false);
m_debug_mesh = irr_driver->createQuadMesh(&material, true);
scene::IMeshBuffer *buffer = m_debug_mesh->getMeshBuffer(0);
assert(buffer->getVertexType()==video::EVT_STANDARD);
irr::video::S3DVertex* vertices
= (video::S3DVertex*)buffer->getVertices();
video::SColor red(128, 255, 0, 0);
for(unsigned int i=0; i<4; i++)
{
vertices[i].Pos = p[i].toIrrVector();
vertices[i].Color = red;
vertices[i].TCoords = core::vector2df(0, 0);
}
video::SMaterial &mat = buffer->getMaterial();
// Meshes need a texture, otherwise stk crashes.
video::ITexture *red_texture = getUnicolorTexture(red);
mat.setTexture(0, red_texture);
buffer->recalculateBoundingBox();
m_mesh->setBoundingBox(buffer->getBoundingBox());
m_debug_node = irr_driver->addMesh(m_debug_mesh, "splistream_debug", m_kart->getNode());
m_debug_node->grab();
}
else
{
m_debug_mesh = NULL;
m_debug_node = NULL;
}
} // SlipStream
