void RenderScene(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
modelViewMatrix.PushMatrix();
M3DMatrix44f mCamera;
cameraFrame.GetCameraMatrix(mCamera);
modelViewMatrix.MultMatrix(mCamera);
modelViewMatrix.MultMatrix(mRotation);
glUseProgram(myShader);
//mWcgCube.Draw(locMVP, modelViewMatrix, transformPipeline);
mWcgCube.DrawRotate(0, 30, locMVP, modelViewMatrix, transformPipeline);
//glUniformMatrix4fv(locMVP, 1, GL_FALSE, transformPipeline.GetModelViewProjectionMatrix());
//cubeBatch.Draw();
//sphereBatch.Draw();
//triangleBatch.Draw();
modelViewMatrix.PopMatrix();
glutSwapBuffers();
glutPostRedisplay();
}
///////////////////////////////////////////////////////////////////////////////
// Called to draw scene
void RenderScene(void)
{
static GLfloat vLightPos [] = { 1.0f, 1.0f, 0.0f };
static GLfloat vWhite [] = { 1.0f, 1.0f, 1.0f, 1.0f };
// Clear the window with current clearing color
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
modelViewMatrix.PushMatrix();
M3DMatrix44f mCamera;
cameraFrame.GetCameraMatrix(mCamera);
modelViewMatrix.MultMatrix(mCamera);
M3DMatrix44f mObjectFrame;
objectFrame.GetMatrix(mObjectFrame);
modelViewMatrix.MultMatrix(mObjectFrame);
glBindTexture(GL_TEXTURE_2D, textureID);
shaderManager.UseStockShader(GLT_SHADER_TEXTURE_POINT_LIGHT_DIFF,
transformPipeline.GetModelViewMatrix(),
transformPipeline.GetProjectionMatrix(),
vLightPos, vWhite, 0);
pyramidBatch.Draw();
modelViewMatrix.PopMatrix();
// Flush drawing commands
glutSwapBuffers();
}
///////////////////////////////////////////////////////////////////////////////
// Called to draw scene
void RenderScene(void)
{
// Clear the window with current clearing color
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
modelViewMatrix.PushMatrix();
M3DMatrix44f mCamera;
cameraFrame.GetCameraMatrix(mCamera);
modelViewMatrix.MultMatrix(mCamera);
M3DMatrix44f mObjectFrame;
objectFrame.GetMatrix(mObjectFrame);
modelViewMatrix.MultMatrix(mObjectFrame);
shaderManager.UseStockShader(GLT_SHADER_FLAT, transformPipeline.GetModelViewProjectionMatrix(), vBlack);
switch(nStep) {
case 0:
glPointSize(4.0f);
pointBatch.Draw();
glPointSize(1.0f);
break;
case 1:
glLineWidth(2.0f);
lineBatch.Draw();
glLineWidth(1.0f);
break;
case 2:
glLineWidth(2.0f);
lineStripBatch.Draw();
glLineWidth(1.0f);
break;
case 3:
glLineWidth(2.0f);
lineLoopBatch.Draw();
glLineWidth(1.0f);
break;
case 4:
DrawWireFramedBatch(&triangleBatch);
break;
case 5:
DrawWireFramedBatch(&triangleStripBatch);
break;
case 6:
DrawWireFramedBatch(&triangleFanBatch);
break;
}
modelViewMatrix.PopMatrix();
// Flush drawing commands
glutSwapBuffers();
}
void Display()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
static CStopWatch timer;
GLfloat yRot = timer.GetElapsedSeconds()*20.0f;
GLfloat vWhite[] = {1.0f,1.0f,1.0f,1.0f};
GLfloat vLightPos[] = {0.0f,2.0f,2.0f};
GLfloat vAmbient[] = {0.3f,0.3f,1.0f,1.0f};
modelViewMatrix.PushMatrix();
//move to camera view
M3DMatrix44f mCamera;
cameraFrame.GetCameraMatrix(mCamera);
modelViewMatrix.MultMatrix(mCamera);
modelViewMatrix.PushMatrix();
modelViewMatrix.Rotate(yRot,1.0,1.0,1.0);
glBindTexture(GL_TEXTURE_2D,fbxTexture);
shaderManager.UseStockShader(GLT_SHADER_TEXTURE_POINT_LIGHT_DIFF,
transformPipeLine.GetModelViewMatrix(),
transformPipeLine.GetProjectionMatrix(),
vLightPos, vWhite, 0);
//*/shaderManager.UseStockShader(GLT_SHADER_FLAT, transformPipeLine.GetModelViewProjectionMatrix(),vWhite);
modelViewMatrix.Scale(0.05,0.05,0.05);
rTest.DrawReader();
modelViewMatrix.PopMatrix();
modelViewMatrix.PopMatrix();
glutSwapBuffers();
glutPostRedisplay();
}
// Called to draw scene
void RenderScene(void)
{
// Clear the window
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
M3DMatrix44f mCamera;
M3DMatrix44f mCameraRotOnly;
M3DMatrix44f mInverseCamera;
viewFrame.GetCameraMatrix(mCamera, false);
viewFrame.GetCameraMatrix(mCameraRotOnly, true);
m3dInvertMatrix44(mInverseCamera, mCameraRotOnly);
modelViewMatrix.PushMatrix();
// Draw the sphere
modelViewMatrix.MultMatrix(mCamera);
glUseProgram(reflectionShader);
glUniformMatrix4fv(locMVPReflect, 1, GL_FALSE, transformPipeline.GetModelViewProjectionMatrix());
glUniformMatrix4fv(locMVReflect, 1, GL_FALSE, transformPipeline.GetModelViewMatrix());
glUniformMatrix3fv(locNormalReflect, 1, GL_FALSE, transformPipeline.GetNormalMatrix());
glUniformMatrix4fv(locInvertedCamera, 1, GL_FALSE, mInverseCamera);
glUniform1i(locCubeMap, 0);
glUniform1i(locTarnishMap, 1);
glEnable(GL_CULL_FACE);
sphereBatch.Draw();
glDisable(GL_CULL_FACE);
modelViewMatrix.PopMatrix();
modelViewMatrix.PushMatrix();
modelViewMatrix.MultMatrix(mCameraRotOnly);
glUseProgram(skyBoxShader);
glUniformMatrix4fv(locMVPSkyBox, 1, GL_FALSE, transformPipeline.GetModelViewProjectionMatrix());
cubeBatch.Draw();
modelViewMatrix.PopMatrix();
// Do the buffer Swap
glutSwapBuffers();
}
// Called to draw scene
void RenderScene(void)
{
static CStopWatch rotTimer;
float yRot = rotTimer.GetElapsedSeconds() * 60.0f;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
modelViewMatrix.PushMatrix();
M3DMatrix44f mCamera;
cameraFrame.GetCameraMatrix(mCamera);
modelViewMatrix.MultMatrix(mCamera);
// Draw the world upside down
modelViewMatrix.PushMatrix();
modelViewMatrix.Scale(1.0f, -1.0f, 1.0f); // Flips the Y Axis
modelViewMatrix.Translate(0.0f, 0.8f, 0.0f); // Scootch the world down a bit...
glFrontFace(GL_CW);
DrawSongAndDance(yRot);
glFrontFace(GL_CCW);
modelViewMatrix.PopMatrix();
// Draw the solid ground
glEnable(GL_BLEND);
glBindTexture(GL_TEXTURE_2D, uiTextures[0]);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
static GLfloat vFloorColor[] = { 1.0f, 1.0f, 1.0f, 0.75f};
shaderManager.UseStockShader(GLT_SHADER_TEXTURE_MODULATE,
transformPipeline.GetModelViewProjectionMatrix(),
vFloorColor,
0);
floorBatch.Draw();
glDisable(GL_BLEND);
DrawSongAndDance(yRot);
modelViewMatrix.PopMatrix();
// Do the buffer Swap
glutSwapBuffers();
// Do it again
glutPostRedisplay();
}
///////////////////////////////////////////////////////////////////////////////
// Called to draw scene
void RenderScene(void)
{
// Clear the window with current clearing color
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
modelViewMatrix.PushMatrix();
M3DMatrix44f mCamera;
cameraFrame.GetCameraMatrix(mCamera);
modelViewMatrix.MultMatrix(mCamera);
// Reflection step... draw cube upside down, the floor
// blended on top of it
if(nStep == 5) {
glDisable(GL_CULL_FACE);
modelViewMatrix.PushMatrix();
modelViewMatrix.Scale(1.0f, -1.0f, 1.0f);
modelViewMatrix.Translate(0.0f, 2.0f, 0.0f);
modelViewMatrix.Rotate(35.0f, 0.0f, 1.0f, 0.0f);
RenderBlock();
modelViewMatrix.PopMatrix();
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
RenderFloor();
glDisable(GL_BLEND);
}
modelViewMatrix.PushMatrix();
// Draw normally
modelViewMatrix.Rotate(35.0f, 0.0f, 1.0f, 0.0f);
RenderBlock();
modelViewMatrix.PopMatrix();
// If not the reflection pass, draw floor last
if(nStep != 5)
RenderFloor();
modelViewMatrix.PopMatrix();
// Flush drawing commands
glutSwapBuffers();
}
void RenderScene(void) {
// Clear the window with current clearing color
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
glUseProgram(shader);
glEnable(GL_CULL_FACE);
glFrontFace(GL_CW);
CStopWatch timer;
float angle = timer.GetElapsedSeconds()*3.14f;
M3DVector3f mAt={0,0,0};
M3DVector3f mUp={0,0,1};
M3DVector3f mEye;
mEye[0]=6.8f*cos(angle);
mEye[1]=6.0f*sin(angle);
mEye[2]=5.0f;
LookAt(mFrame,mEye,mAt,mUp);
mFrame.GetCameraMatrix(mCameraMatrix);
matrixStack.LoadMatrix(mFrustrum.GetProjectionMatrix());
matrixStack.MultMatrix(mCameraMatrix);
glUniformMatrix4fv(MVPMatrixLocation, 1, GL_FALSE, matrixStack.GetMatrix());
drawGrid();
matrixStack.Translate(1.0f,7.0f,0.0f);
matrixStack.Rotate(30.0f,0.0,0.0,1.0);
glUniformMatrix4fv(MVPMatrixLocation,1,GL_FALSE,matrixStack.GetMatrix());
drawPyramid();
matrixStack.PopMatrix();
matrixStack.Translate(-7.0f,0.0f,0.0f);
matrixStack.Scale(2.0f, 2.0f, 2.0f);
glUniformMatrix4fv(MVPMatrixLocation,1,GL_FALSE,matrixStack.GetMatrix());
drawPyramid();
matrixStack.PopMatrix();
// Perform the buffer swap to display back buffer
glutSwapBuffers();
glutPostRedisplay();
}
void RenderScene()
{
// Clear the window and the depth buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
{ ScopedMatrix m(modelViewMatrix);
modelViewMatrix.MultMatrix(viewFrame);
glUseProgram(texturedIdentity);
glBindTexture(GL_TEXTURE_2D, stoneTexture);
locTextureUniform = glGetUniformLocation(texturedIdentity, "colorMap");
glUniform1i(locTextureUniform, 0);
triangleBatch.Draw();
}
glutSwapBuffers();
}
void Display()
{
// Clear the color and depth buffers
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Save the current modelview matrix (the identity matrix)
modelViewMatrix.PushMatrix();
M3DMatrix44f mCamera;
cameraFrame.GetCameraMatrix(mCamera);
modelViewMatrix.MultMatrix(mCamera);
if (reflecting)
{
// Draw the "reflection" of the scene upside down
modelViewMatrix.PushMatrix();
// Flip the y-axis last.
modelViewMatrix.Scale(1.0f, -1.0f, 1.0f);
// The scene is essentially in a pit, bo elevate it an equal distance from the
// x-z plane to ensure that its reflection will appear to be below the ground.
modelViewMatrix.Translate(0.0f, -2.0f * FLOOR_HEIGHT, 0.0f);
// Reverse the orientation of all polygonsm in the scene so the orientation of
// their reflections will produce the same lighting as the above-ground scene.
glFrontFace(GL_CW);
DrawScene();
glFrontFace(GL_CCW);
modelViewMatrix.PopMatrix();
}
DrawGround();
DrawScene();
modelViewMatrix.PopMatrix();
// Do the buffer Swap
glutSwapBuffers();
// Tell GLUT to do it again
glutPostRedisplay();
}
void DrawSongAndDance(GLfloat yRot) // Called to draw dancing objects
{
static GLfloat vWhite[] = { 1.0f, 1.0f, 1.0f, 1.0f };
static GLfloat vLightPos[] = { 0.0f, 3.0f, 0.0f, 1.0f };
// Get the light position in eye space
M3DVector4f vLightTransformed;
M3DMatrix44f mCamera;
modelViewMatrix.GetMatrix(mCamera);
m3dTransformVector4(vLightTransformed, vLightPos, mCamera);
// Draw the light source
modelViewMatrix.PushMatrix();
modelViewMatrix.Translatev(vLightPos);
shaderManager.UseStockShader(GLT_SHADER_FLAT,
transformPipeLine.GetModelViewProjectionMatrix(),
vWhite);
sphereBatch.Draw();
modelViewMatrix.PopMatrix();
glBindTexture(GL_TEXTURE_2D, uiTextures[2]);
for (int i = 0; i < NUM_SPHERES; i++) {
modelViewMatrix.PushMatrix();
modelViewMatrix.MultMatrix(spheres[i]);
shaderManager.UseStockShader(GLT_SHADER_TEXTURE_POINT_LIGHT_DIFF,
modelViewMatrix.GetMatrix(),
transformPipeLine.GetProjectionMatrix(),
vLightTransformed,
vWhite,
0);
sphereBatch.Draw();
modelViewMatrix.PopMatrix();
}
// Song and dance
modelViewMatrix.Translate(0.0f, 0.2f, -2.5f);
modelViewMatrix.PushMatrix(); // Saves the translated origin
modelViewMatrix.Rotate(yRot, 0.0f, 1.0f, 0.0f);
// Draw stuff relative to the camera
glBindTexture(GL_TEXTURE_2D, uiTextures[1]);
shaderManager.UseStockShader(GLT_SHADER_TEXTURE_POINT_LIGHT_DIFF,
modelViewMatrix.GetMatrix(),
transformPipeLine.GetProjectionMatrix(),
vLightTransformed,
vWhite,
0);
torusBatch.Draw();
modelViewMatrix.PopMatrix(); // Erased the rotate
modelViewMatrix.Rotate(yRot * -2.0f, 0.0f, 1.0f, 0.0f);
modelViewMatrix.Translate(0.8f, 0.0f, 0.0f);
glBindTexture(GL_TEXTURE_2D, uiTextures[2]);
shaderManager.UseStockShader(GLT_SHADER_TEXTURE_POINT_LIGHT_DIFF,
modelViewMatrix.GetMatrix(),
transformPipeLine.GetProjectionMatrix(),
vLightTransformed,
vWhite,
0);
sphereBatch.Draw();
}
void RenderScene(void)
{
static CStopWatch rotTimer;
float yRot = rotTimer.GetElapsedSeconds() * 60.0f;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
modelViewMatrix.PushMatrix();
M3DMatrix44f mCamera;
cameraFrame.GetCameraMatrix(mCamera);
modelViewMatrix.MultMatrix(mCamera);
modelViewMatrix.PushMatrix();
{
//反向
modelViewMatrix.Scale(1.0f, -1.0f, 1.0f);
//因为是反向，所以正数是向下
modelViewMatrix.Translate(0.0f, 0.8f, 0.0f); // Scootch the world down a bit...
//三维中其中一维反向之后，缠绕方向也会呈相反，所以重新定义缠绕正方向为顺时针方向；
glFrontFace(GL_CW);
DrawSongAndDance(yRot);
glFrontFace(GL_CCW);
}
modelViewMatrix.PopMatrix();
// Draw the solid ground
glEnable(GL_BLEND);
glBindTexture(GL_TEXTURE_2D, uiTextures[0]);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
static GLfloat vFloorColor[] = { 1.0f, 1.0f, 1.0f, 0.75f };
shaderManager.UseStockShader(GLT_SHADER_TEXTURE_MODULATE,
transformPipeLine.GetModelViewProjectionMatrix(),
vFloorColor,
0);
floorBatch.Draw();
glDisable(GL_BLEND);
DrawSongAndDance(yRot);
modelViewMatrix.PopMatrix();
// Render the overlay
// Creating this matrix really doesn't need to be done every frame. I'll leave it here
// so all the pertenant code is together
M3DMatrix44f mScreenSpace;
m3dMakeOrthographicMatrix(mScreenSpace, 0.0f, 800.0f, 0.0f, 600.0f, -1.0f, 1.0f);
// Turn blending on, and depth testing off
glEnable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glUseProgram(sphereWolrdShader);
glUniform1i(locTexture, 0);
glUniformMatrix4fv(locMVP, 1, GL_FALSE, mScreenSpace);
glBindTexture(GL_TEXTURE_RECTANGLE, uiTextures[3]);
logoBatch.Draw();
// Restore no blending and depth test
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
// Do the buffer Swap
glutSwapBuffers();
// Do it again
glutPostRedisplay();
}
///////////////////////////////////////////////////////////////////////////////
// Render a frame. The owning framework is responsible for buffer swaps,
// flushes, etc.
void RenderScene(void)
{
static CStopWatch animationTimer;
static float totalTime = 6; // To go back and forth
static float halfTotalTime = totalTime/2;
float seconds = animationTimer.GetElapsedSeconds() * speedFactor;
float xPos = 0;
// Calculate the next postion of the moving object
// First perform a mod-like operation on the time as a float
while(seconds > totalTime)
seconds -= totalTime;
// Move object position, if it's gone half way across
// start bringing it back
if(seconds < halfTotalTime)
xPos = seconds -halfTotalTime*0.5f;
else
xPos = totalTime - seconds -halfTotalTime*0.5f;
// First draw world to screen
modelViewMatrix.PushMatrix();
M3DMatrix44f mCamera;
cameraFrame.GetCameraMatrix(mCamera);
modelViewMatrix.MultMatrix(mCamera);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textures[0]); // Marble
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
shaderManager.UseStockShader(GLT_SHADER_TEXTURE_MODULATE, transformPipeline.GetModelViewProjectionMatrix(), vWhite, 0);
floorBatch.Draw();
DrawWorld(0.0f, xPos);
modelViewMatrix.PopMatrix();
if(bUsePBOPath)
{
#ifndef OPENGL_ES
// First bind the PBO as the pack buffer, then read the pixels directly to the PBO
glBindBuffer(GL_PIXEL_PACK_BUFFER, pixBuffObjs[0]);
glReadPixels(0, 0, screenWidth, screenHeight, GL_RGB, GL_UNSIGNED_BYTE, NULL);
glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
// Next bind the PBO as the unpack buffer, then push the pixels straight into the texture
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pixBuffObjs[0]);
// Setup texture unit for new blur, this gets imcremented every frame
glActiveTexture(GL_TEXTURE0+GetBlurTarget0() );
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, screenWidth, screenHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
#endif
}
else
{
// Grab the screen pixels and copy into local memory
glReadPixels(0, 0, screenWidth, screenHeight, GL_RGB, GL_UNSIGNED_BYTE, pixelData);
// Push pixels from client memory into texture
// Setup texture unit for new blur, this gets imcremented every frame
glActiveTexture(GL_TEXTURE0+GetBlurTarget0() );
#ifndef OPENGL_ES
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, screenWidth, screenHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, pixelData);
#else
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, screenWidth, screenHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, pixelData);
#endif
}
// Draw full screen quad with blur shader and all blur textures
projectionMatrix.PushMatrix();
projectionMatrix.LoadIdentity();
projectionMatrix.LoadMatrix(orthoMatrix);
modelViewMatrix.PushMatrix();
modelViewMatrix.LoadIdentity();
glDisable(GL_DEPTH_TEST);
SetupBlurProg();
screenQuad.Draw();
glEnable(GL_DEPTH_TEST);
modelViewMatrix.PopMatrix();
projectionMatrix.PopMatrix();
// Move to the next blur texture for the next frame
AdvanceBlurTaget();
// Do the buffer Swap
glutSwapBuffers();
// Do it again
glutPostRedisplay();
UpdateFrameCount();
}
// Aufruf draw scene
void RenderScene(void) {
// Clearbefehle für den color buffer und den depth buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Schalte culling ein falls das Flag gesetzt ist
if (bCull) {
glEnable(GL_CULL_FACE);
}
else {
glDisable(GL_CULL_FACE);
}
// Schalte depth testing ein falls das Flag gesetzt ist
if (bDepth) {
glEnable(GL_DEPTH_TEST);
}
else {
glDisable(GL_DEPTH_TEST);
}
// Zeichne die Rückseite von Polygonen als Drahtgitter falls das Flag gesetzt ist
if (bOutline) {
glPolygonMode(GL_BACK, GL_LINE);
}
else {
glPolygonMode(GL_BACK, GL_FILL);
}
// Speichere den matrix state und führe die Rotation durch
modelViewMatrix.PushMatrix();
M3DMatrix44f rot;
m3dQuatToRotationMatrix(rot, rotation);
modelViewMatrix.MultMatrix(rot);
//setze den Shader für das Rendern
shaderManager.UseStockShader(GLT_SHADER_FLAT_ATTRIBUTES, transformPipeline.GetModelViewProjectionMatrix());
// zusaetzliche Transformationen bei persp. Projektion
if (bPerspectiveProj) {
// Vektor fuer UFO-Bewegungsmodus draufrechnen
modelViewMatrix.Translate(ufoMove[0], ufoMove[1], ufoMove[2]);
// Vektor fuer Drehungen um x- oder y-Achse draufrechnen
modelViewMatrix.Rotate(viewAngleX, 0.0f, 1.0f, 0.0f );
modelViewMatrix.Rotate(viewAngleY, 1.0f, 0.0f, 0.0f);
// Augenpunktstransformation
modelViewMatrix.Translate(0.0f, 0.0f, -1000.0f);
}
//Zeichne Objekte
modelViewMatrix.PushMatrix();
modelViewMatrix.Translate(0, -110, 0);
DrawBaeumchen();
modelViewMatrix.PopMatrix();
DrawMaennchen(animationAngle += GL_PI / 15);
// Hole die im Stack gespeicherten Transformationsmatrizen wieder zurück
modelViewMatrix.PopMatrix();
TwDraw();
// Vertausche Front- und Backbuffer
glutSwapBuffers();
glutPostRedisplay();
}
/**
* Called to draw scene
*/
void RenderScene(void)
{
static GLfloat vFloorColor[] = { 1.0f, 1.0f, 1.0f, 0.75f };
static CStopWatch rotTimer;
float yRot = rotTimer.delta() * 60.0f;
// Clear the window with current clearing color
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
modelViewMatrix.push();
M3DMatrix44f mCamera;
cameraFrame.GetCameraMatrix(mCamera);
modelViewMatrix.MultMatrix(mCamera);
// draw the world upside down
modelViewMatrix.push();
modelViewMatrix.scaleTo(1.0f, -1.0f, 1.0f); // flips the Y axis
modelViewMatrix.moveTo(0.0f, 0.8f, 0.0f); // scootch the world down a bit...
glFrontFace(GL_CW);
DrawSongAndDance(yRot);
glFrontFace(GL_CCW); // restore it
modelViewMatrix.pop();
// draw the solid ground
glEnable(GL_BLEND);
glBindTexture(GL_TEXTURE_2D, uiTextures[0]);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
shaderManager.useStockShader(GLT_SHADER_TEXTURE_MODULATE,
transformPipeline.GetMVPMatrix(),
vFloorColor,
0);
floorBatch.draw();
glDisable(GL_BLEND);
DrawSongAndDance(yRot);
modelViewMatrix.pop();
// Render the overlay
// Creating this matrix really doesn't need to be done every frame. I'll leave it here
// so all the pertenant code is together
M3DMatrix44f mScreenSpace;
m3dMakeOrthographicMatrix(mScreenSpace, 0.0f, 800.0f, 0.0f, 600.0f, -1.0f, 1.0f);
// turn blending on, and dephth testing off
glEnable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glUseProgram(rectReplaceShader);
glUniform1i(locRectTexture, 0);
glUniformMatrix4fv(locRectMVP, 1, GL_FALSE, mScreenSpace);
glBindTexture(GL_TEXTURE_RECTANGLE, uiTextures[3]);
logoBatch.draw();
// restore no blending and depth test
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
// Perform the buffer swap to display back buffer
glutSwapBuffers();
glutPostRedisplay();
}
///////////////////////////////////////////////////////////////////////////////
// Render a frame. The owning framework is responsible for buffer swaps,
// flushes, etc.
void RenderScene(void)
{
// Bind the FBO with multisample buffers
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, msFBO);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// User selected order independant transparency
if (mode == USER_OIT)
{
// Use OIT, setup sample masks
glSampleMaski(0, 0x01);
glEnable(GL_SAMPLE_MASK);
// Prevent depth test from culling covered surfaces
glDepthFunc(GL_ALWAYS);
}
modelViewMatrix.PushMatrix();
M3DMatrix44f mCamera;
cameraFrame.GetCameraMatrix(mCamera);
modelViewMatrix.MultMatrix(mCamera);
modelViewMatrix.PushMatrix();
modelViewMatrix.Translate(0.0f, -0.4f, -4.0f);
modelViewMatrix.Rotate(worldAngle, 0.0, 1.0, 0.0);
// Draw the background and disk to the first sample
modelViewMatrix.PushMatrix();
modelViewMatrix.Translate(0.0f, 3.0f, 0.0f);
modelViewMatrix.Rotate(90.0, 1.0, 0.0, 0.0);
modelViewMatrix.Rotate(90.0, 0.0, 0.0, 1.0);
glBindTexture(GL_TEXTURE_2D, textures[1]);
shaderManager.UseStockShader(GLT_SHADER_TEXTURE_REPLACE, transformPipeline.GetModelViewProjectionMatrix(), 0);
bckgrndCylBatch.Draw();
modelViewMatrix.PopMatrix();
modelViewMatrix.Translate(0.0f, -0.3f, 0.0f);
modelViewMatrix.PushMatrix();
modelViewMatrix.Rotate(90.0, 1.0, 0.0, 0.0);
shaderManager.UseStockShader(GLT_SHADER_FLAT, transformPipeline.GetModelViewProjectionMatrix(), vGrey);
diskBatch.Draw();
modelViewMatrix.PopMatrix();
modelViewMatrix.Translate(0.0f, 0.1f, 0.0f);
// User selected blending
if (mode == USER_BLEND)
{
// Setup blend state
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
switch (blendMode)
{
case 1:
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
break;
case 2:
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_DST_ALPHA);
break;
case 3:
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
break;
case 4:
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
break;
case 5:
glBlendFunc(GL_SRC_ALPHA, GL_DST_COLOR);
break;
case 6:
glBlendFuncSeparate(GL_SRC_ALPHA, GL_DST_ALPHA, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
break;
case 7:
glBlendFuncSeparate(GL_SRC_COLOR, GL_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
break;
default:
glDisable(GL_BLEND);
}
}
// Now draw the glass pieces
DrawWorld();
modelViewMatrix.PopMatrix();
modelViewMatrix.PopMatrix();
// Clean up all state
glDepthFunc(GL_LEQUAL);
glDisable(GL_BLEND);
glDisable(GL_SAMPLE_MASK);
glSampleMaski(0, 0xffffffff);
// Resolve multisample buffer
projectionMatrix.PushMatrix();
projectionMatrix.LoadMatrix(orthoMatrix);
modelViewMatrix.PushMatrix();
modelViewMatrix.LoadIdentity();
// Setup and Clear the default framebuffer
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
glViewport(0, 0, screenWidth, screenHeight);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (mode == USER_OIT)
SetupOITResolveProg();
else if (mode == USER_BLEND)
SetupResolveProg();
// Draw a full-size quad to resolve the multisample surfaces
screenQuad.Draw();
modelViewMatrix.PopMatrix();
projectionMatrix.PopMatrix();
// Reset texture state
glEnable(GL_DEPTH_TEST);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0);
// Do the buffer Swap
glutSwapBuffers();
// Do it again
glutPostRedisplay();
}
///////////////////////////////////////////////////////////////////////////////
// Render a frame. The owning framework is responsible for buffer swaps,
// flushes, etc.
void RenderScene(void)
{
// first render the scene in HDR to fbo
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, hdrFBO[0]);
glDrawBuffers(1, &fboBuffs[0]);
glClearColor(vSkyBlue[0], vSkyBlue[1], vSkyBlue[2], vSkyBlue[3]);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Draw to two textures, the first contains scene data
// the second contains only the bright areas
modelViewMatrix.PushMatrix();
M3DMatrix44f mCamera;
cameraFrame.GetCameraMatrix(mCamera);
modelViewMatrix.MultMatrix(mCamera);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textures[0]); // Marble
// Draw the floor
SetupTexReplaceProg(vLightPos, vWhite);
floorBatch.Draw();
// Draw the window
modelViewMatrix.PushMatrix();
modelViewMatrix.Translate(0.0f, -0.4f, -4.0f);
modelViewMatrix.Rotate(10.0, 0.0, 1.0, 0.0);
glBindTexture(GL_TEXTURE_2D, windowTexture); // Window Tex
// First draw the window contents from texture
SetupTexReplaceProg(vLightPos, vWhiteX2);
windowBatch.Draw();
// Now draw the border and the grid
SetupFlatColorProg(vLightPos, vLtGrey);
windowGridBatch.Draw();
windowBorderBatch.Draw();
modelViewMatrix.PopMatrix();
modelViewMatrix.PopMatrix();
projectionMatrix.PushMatrix();
projectionMatrix.LoadMatrix(orthoMatrix);
modelViewMatrix.PushMatrix();
modelViewMatrix.LoadIdentity();
// Combine original scene with blurred bright textures
// to create the bloom effect
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
glDrawBuffers(1,windowBuff);
glViewport(0, 0, screenWidth, screenHeight);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
SetupHDRProg();
screenQuad.Draw();
modelViewMatrix.PopMatrix();
projectionMatrix.PopMatrix();
// Put the texture units back the way they were
glBindTexture(GL_TEXTURE_2D, 0);
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0);
// Do the buffer Swap
glutSwapBuffers();
// Do it again
glutPostRedisplay();
}
// called to draw dancing objects
static void DrawSongAndDance(GLfloat yRot)
{
static GLfloat vWhite[] = { 1.0f, 1.0f, 1.0f, 1.0f };
static GLfloat vLightPos[] = { 0.0f, 3.0f, 0.0f, 1.0f };
// get the light position in eye space
M3DMatrix44f mCamera;
modelViewMatrix.GetMatrix(mCamera);
M3DVector4f vLightTransformed;
m3dTransformVector4(vLightTransformed, vLightPos, mCamera);
// draw the light source
modelViewMatrix.push();
modelViewMatrix.moveTo(vLightPos);
shaderManager.useStockShader(GLT_SHADER_FLAT, transformPipeline.GetMVPMatrix(),
vWhite);
sphereBatch.draw();
modelViewMatrix.pop();
glBindTexture(GL_TEXTURE_2D, uiTextures[2]);
for (int i = 0; i < NUM_SPHERES; ++i) {
modelViewMatrix.push();
modelViewMatrix.MultMatrix(spheres[i]);
shaderManager.useStockShader(GLT_SHADER_TEXTURE_POINT_LIGHT_DIFF,
modelViewMatrix.GetMatrix(),
transformPipeline.GetProjectionMatrix(),
vLightTransformed,
vWhite,
0);
sphereBatch.draw();
modelViewMatrix.pop();
}
// song and dance
modelViewMatrix.moveTo(0.0f, 0.2f, -2.5f);
modelViewMatrix.push(); // save the translated origin
modelViewMatrix.rotateTo(yRot, 0.0f, 1.0f, 0.0f);
// draw stuff relative to the camera
glBindTexture(GL_TEXTURE_2D, uiTextures[1]);
shaderManager.useStockShader(GLT_SHADER_TEXTURE_POINT_LIGHT_DIFF,
modelViewMatrix.GetMatrix(),
transformPipeline.GetProjectionMatrix(),
vLightTransformed,
vWhite,
0);
torusBatch.draw();
modelViewMatrix.pop(); // erased the rotate
modelViewMatrix.rotateTo(yRot * -2.0f, 0.0f, 1.0f, 0.0f);
modelViewMatrix.moveTo(0.8f, 0.0f, 0.0f);
glBindTexture(GL_TEXTURE_2D, uiTextures[2]);
shaderManager.useStockShader(GLT_SHADER_TEXTURE_POINT_LIGHT_DIFF,
modelViewMatrix.GetMatrix(),
transformPipeline.GetProjectionMatrix(),
vLightTransformed,
vWhite,
0);
sphereBatch.draw();
}
// main rendering loop
void RenderScene(void){
static CStopWatch rotTimer;
float yRot = rotTimer.GetElapsedSeconds() * 60.0f;
GLfloat vBarColor[] = {1.0f, 0.0f, 0.0f, 1.0f};
currentFrame = getLatestBufferIndex();
if(mapper.getSimpleArg('c')){
vBarColor[0] = .7;
vBarColor[1] = .2 + sharedBuffer[currentFrame].averageAmp * 60;
vBarColor[2] = 1.0;
b = sharedBuffer[currentFrame].averageAmp;
g = 0;
r = 0;
glClearColor(r, g, b, 1.0f);
}
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
modelViewMatrix.PushMatrix();
M3DMatrix44f mCamera;
cameraFrame.GetCameraMatrix(mCamera);
modelViewMatrix.PushMatrix(mCamera);
if(mapper.getCompoundArg('r') == "auto"){
cameraFrame.RotateWorld(.01, 0.0, 0.0, 1.0);
cameraFrame.MoveForward(-.1 * sin(yRot * .05));
}
// set up light source
M3DVector4f vLightPos = { 0.0f, 10.0f, 5.0f, 1.0f };
M3DVector4f vLightEyePos;
m3dTransformVector4(vLightEyePos, vLightPos, mCamera);
for(int m = 0; m < NUM_MACROS; m++){
if(mapper.getSimpleArg('m')){
modelViewMatrix.PushMatrix();
macros[m].refFrame.RotateLocalY(.01 * macros[m].multiplier);
macros[m].refFrame.RotateLocalX(.5 * sharedBuffer[currentFrame].averageAmp);
modelViewMatrix.MultMatrix(macros[m].refFrame);
}
for(int i = 0; i < PACKET_SIZE; i++){
modelViewMatrix.PushMatrix();
GLfloat y = 5 * fabs(sharedBuffer[currentFrame].frames[i][0]);
modelViewMatrix.MultMatrix(bars[i]);
modelViewMatrix.Scale(barWidth, y, sharedBuffer[currentFrame].averageAmp * 4);
if(mapper.getSimpleArg('t')){
modelViewMatrix.Translate(0.0, sharedBuffer[currentFrame].averageAmp, 0.0);
}
shaderManager.UseStockShader(GLT_SHADER_POINT_LIGHT_DIFF,
transformPipeline.GetModelViewMatrix(),
transformPipeline.GetProjectionMatrix(),
vLightEyePos, vBarColor);
cubeBatch.Draw();
modelViewMatrix.PopMatrix();
}
if(mapper.getSimpleArg('m')){
modelViewMatrix.PopMatrix();
}
}
// draw prisms for amplitudes
modelViewMatrix.PopMatrix();
modelViewMatrix.PopMatrix();
modelViewMatrix.PopMatrix();
glutSwapBuffers();
glutPostRedisplay();
if(currentFrame != -1){
sharedBuffer[currentFrame].free = true;
}
}
void Gripper::render(GLMatrixStack &modelViewStack, GLMatrixStack &projectionStack, float *phantomMat, GLShaderManager &shaderManager){
modelViewStack.PushMatrix();
//modelViewStack.Translate(position[0] + size[0]*0.5f, position[1] + size[1]*0.5f, position[2] + size[2]*0.5f);
modelViewStack.MultMatrix(phantomMat);
modelViewStack.Scale(scalar, scalar, scalar);
shaderManager.UseStockShader(GLT_SHADER_DEFAULT_LIGHT, modelViewStack.GetMatrix(), projectionStack.GetMatrix(), curColor);
sphereBatch.Draw();
modelViewStack.PushMatrix();
modelViewStack.PushMatrix();
modelViewStack.Rotate(90, 0, 1, 0);
modelViewStack.Scale(0.5, 0.5, endEffector[RED].curPos);
shaderManager.UseStockShader(GLT_SHADER_DEFAULT_LIGHT, modelViewStack.GetMatrix(), projectionStack.GetMatrix(), curColor);
cylBatch.Draw();
modelViewStack.PopMatrix();
modelViewStack.Translate(endEffector[RED].curPos, 0, 0.0);
shaderManager.UseStockShader(GLT_SHADER_DEFAULT_LIGHT, modelViewStack.GetMatrix(), projectionStack.GetMatrix(), vRed);
sphereBatch.Draw();
modelViewStack.Translate(0.0, 0, -8.0);
modelViewStack.PushMatrix();
modelViewStack.Scale(0.5, 0.5, 8.0);
shaderManager.UseStockShader(GLT_SHADER_DEFAULT_LIGHT, modelViewStack.GetMatrix(), projectionStack.GetMatrix(), curColor);
cylBatch.Draw();
modelViewStack.PopMatrix();
shaderManager.UseStockShader(GLT_SHADER_DEFAULT_LIGHT, modelViewStack.GetMatrix(), projectionStack.GetMatrix(), vRed);
sphereBatch.Draw();
modelViewStack.PushMatrix();
modelViewStack.Translate(0.0, 2.0, -2.0);
shaderManager.UseStockShader(GLT_SHADER_DEFAULT_LIGHT, modelViewStack.GetMatrix(), projectionStack.GetMatrix(), vRed);
sphereBatch.Draw();
modelViewStack.Translate(0.0, -4.0, 0.0);
shaderManager.UseStockShader(GLT_SHADER_DEFAULT_LIGHT, modelViewStack.GetMatrix(), projectionStack.GetMatrix(), vRed);
sphereBatch.Draw();
modelViewStack.Translate(0.0, 2.0, -2.0);
shaderManager.UseStockShader(GLT_SHADER_DEFAULT_LIGHT, modelViewStack.GetMatrix(), projectionStack.GetMatrix(), vRed);
sphereBatch.Draw();
modelViewStack.PopMatrix();
modelViewStack.PopMatrix();
modelViewStack.PushMatrix();
modelViewStack.PushMatrix();
modelViewStack.Rotate(-90, 0, 1, 0);
modelViewStack.Scale(0.5, 0.5, endEffector[GREEN].curPos);
shaderManager.UseStockShader(GLT_SHADER_DEFAULT_LIGHT, modelViewStack.GetMatrix(), projectionStack.GetMatrix(), curColor);
cylBatch.Draw();
modelViewStack.PopMatrix();
modelViewStack.Translate(-endEffector[GREEN].curPos, 0, 0.0);
shaderManager.UseStockShader(GLT_SHADER_DEFAULT_LIGHT, modelViewStack.GetMatrix(), projectionStack.GetMatrix(), vGreen);
sphereBatch.Draw();
modelViewStack.Translate(0.0, 0, -8.0);
modelViewStack.PushMatrix();
modelViewStack.Scale(0.5, 0.5, 8.0);
shaderManager.UseStockShader(GLT_SHADER_DEFAULT_LIGHT, modelViewStack.GetMatrix(), projectionStack.GetMatrix(), curColor);
cylBatch.Draw();
modelViewStack.PopMatrix();
shaderManager.UseStockShader(GLT_SHADER_DEFAULT_LIGHT, modelViewStack.GetMatrix(), projectionStack.GetMatrix(), vGreen);
sphereBatch.Draw();
modelViewStack.PushMatrix();
modelViewStack.Translate(0.0, 2.0, -2.0);
shaderManager.UseStockShader(GLT_SHADER_DEFAULT_LIGHT, modelViewStack.GetMatrix(), projectionStack.GetMatrix(), vGreen);
sphereBatch.Draw();
modelViewStack.Translate(0.0, -4.0, 0.0);
shaderManager.UseStockShader(GLT_SHADER_DEFAULT_LIGHT, modelViewStack.GetMatrix(), projectionStack.GetMatrix(), vGreen);
sphereBatch.Draw();
modelViewStack.Translate(0.0, 2.0, -2.0);
shaderManager.UseStockShader(GLT_SHADER_DEFAULT_LIGHT, modelViewStack.GetMatrix(), projectionStack.GetMatrix(), vGreen);
sphereBatch.Draw();
modelViewStack.PopMatrix();
modelViewStack.PopMatrix();
modelViewStack.PopMatrix();
}
void Display()
{
static CStopWatch timer;
GLfloat yRot = timer.GetElapsedSeconds() * 60.0;
M3DVector3f vCameraPosition;
M3DVector3f vCameraForward;
M3DVector3f vMirrorPosition;
M3DVector3f vMirrorForward;
void movingCylinder();
cameraFrame.GetOrigin(vCameraPosition);
cameraFrame.GetForwardVector(vCameraForward);
vMirrorPosition[0] = 0.0f;
vMirrorPosition[1] = 0.1f;
vMirrorPosition[2] = -20.0f;
mirrorFrame.SetOrigin(vMirrorPosition);
vMirrorForward[0] = vCameraPosition[0];
vMirrorForward[1] = vCameraPosition[1];
vMirrorForward[2] = (vCameraPosition[2] + 20);
m3dNormalizeVector3(vMirrorForward);
mirrorFrame.SetForwardVector(vMirrorForward);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER,fboName);
glDrawBuffers(1,fboBuffers);
glViewport(0,0,mirrorWidth,mirrorHeight);
modelViewMatrix.PushMatrix();
M3DMatrix44f mMirrorView;
mirrorFrame.GetCameraMatrix(mMirrorView);
modelViewMatrix.MultMatrix(mMirrorView);
modelViewMatrix.Scale(-1.0f,1.0f,1.0f);
glBindTexture(GL_TEXTURE_2D,textures[0]);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
shaderManager.UseStockShader(GLT_SHADER_TEXTURE_MODULATE,
transformPipeline.GetModelViewProjectionMatrix(),
vWhite,0);
floorBatch.Draw();
drawSun();
drawTorus(yRot);
modelViewMatrix.PopMatrix();
glBindFramebuffer(GL_DRAW_FRAMEBUFFER,0);
glDrawBuffers(1,windowBuffer);
glViewport(0,0,mirrorWidth,mirrorHeight);
modelViewMatrix.PushMatrix();
M3DMatrix44f mCamera;
cameraFrame.GetCameraMatrix(mCamera);
modelViewMatrix.MultMatrix(mCamera);
modelViewMatrix.PushMatrix();
glBindTexture(GL_TEXTURE_2D,mirrorTexture);
shaderManager.UseStockShader(GLT_SHADER_TEXTURE_REPLACE,
transformPipeline.GetModelViewProjectionMatrix(),0);
mirrorFrontBatch.Draw();
modelViewMatrix.PopMatrix();
modelViewMatrix.PushMatrix();
glBindTexture(GL_TEXTURE_2D,textures[0]);
shaderManager.UseStockShader(GLT_SHADER_TEXTURE_MODULATE,
transformPipeline.GetModelViewProjectionMatrix(),
vWhite,0);
floorBatch.Draw();
drawSun();
drawTorus(yRot);
modelViewMatrix.PopMatrix();
modelViewMatrix.PopMatrix();
//control to moving cylinder
movingCylinder();
glutSwapBuffers();
glutPostRedisplay();
}
///////////////////////////////////////////////////////////////////////////////
// Render a frame. The owning framework is responsible for buffer swaps,
// flushes, etc.
void RenderScene(void)
{
static CStopWatch animationTimer;
float yRot = animationTimer.GetElapsedSeconds() * 60.0f;
// MoveCamera();
modelViewMatrix.PushMatrix();
M3DMatrix44f mCamera;
cameraFrame.GetCameraMatrix(mCamera);
modelViewMatrix.MultMatrix(mCamera);
GLfloat vFloorColor[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
if(bUseFBO)
{
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fboName);
#ifndef OPENGL_ES
glDrawBuffers(3, fboBuffs);
#endif
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Need light position relative to the Camera
M3DVector4f vLightTransformed;
m3dTransformVector4(vLightTransformed, vLightPos, mCamera);
UseProcessProgram(vLightTransformed, vFloorColor, 0);
}
else
{
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
#ifndef OPENGL_ES
glDrawBuffers(1, windowBuff);
#endif
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
shaderManager.UseStockShader(GLT_SHADER_TEXTURE_MODULATE, transformPipeline.GetModelViewProjectionMatrix(), vFloorColor, 0);
}
glBindTexture(GL_TEXTURE_2D, textures[0]); // Marble
floorBatch.Draw();
DrawWorld(yRot);
modelViewMatrix.PopMatrix();
if(bUseFBO)
{
// Direct drawing to the window
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
#ifndef OPENGL_ES
glDrawBuffers(1, windowBuff);
#endif
glViewport(0, 0, screenWidth, screenHeight);
#ifndef OPENGL_ES
// Source buffer reads from the framebuffer object
glBindFramebuffer(GL_READ_FRAMEBUFFER, fboName);
// Copy greyscale output to the left half of the screen
glReadBuffer(GL_COLOR_ATTACHMENT1);
glBlitFramebuffer(0, 0, screenWidth/2, screenHeight,
0, 0, screenWidth/2, screenHeight,
GL_COLOR_BUFFER_BIT, GL_NEAREST );
// Copy the luminance adjusted color to the right half of the screen
glReadBuffer(GL_COLOR_ATTACHMENT2);
glBlitFramebuffer(screenWidth/2, 0, screenWidth, screenHeight,
screenWidth/2, 0, screenWidth, screenHeight,
GL_COLOR_BUFFER_BIT, GL_NEAREST );
// Scale the unaltered image to the upper right of the screen
glReadBuffer(GL_COLOR_ATTACHMENT0);
glBlitFramebuffer(0, 0, screenWidth, screenHeight,
(int)(screenWidth *(0.8)), (int)(screenHeight*(0.8)),
screenWidth, screenHeight,
GL_COLOR_BUFFER_BIT, GL_LINEAR );
glBindTexture(GL_TEXTURE_2D, 0);
#endif
}
// Do the buffer Swap
glutSwapBuffers();
// Do it again
glutPostRedisplay();
}
void renderScene()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
modelViewM.PushMatrix();
M3DMatrix44f cameraM;
cameraFrame.GetCameraMatrix(cameraM);
modelViewM.MultMatrix(cameraM);
M3DVector4f lightPos = {0.0f, 10.0f, 5.0f, 1.0f};
M3DVector4f lightEyePos;
m3dTransformVector4(lightEyePos, lightPos, cameraM);
GLfloat whiteLight[] = {1.0f, 1.0f, 1.0f, 1.0f};
modelViewM.PushMatrix();
modelViewM.Translate(0, 0, -3);
M3DMatrix44f objectM;
objectFrame.GetMatrix(objectM);
modelViewM.MultMatrix(objectM);
glBindTexture(GL_TEXTURE_2D, textureID[0]);
#if 0
shaderManager.UseStockShader(GLT_SHADER_TEXTURE_POINT_LIGHT_DIFF,
pipelineTransform.GetModelViewMatrix(),
pipelineTransform.GetProjectionMatrix(),
lightEyePos, whiteLight, 0);
#else
shaderManager.UseStockShader(GLT_SHADER_TEXTURE_REPLACE,
pipelineTransform.GetModelViewProjectionMatrix(),
0);
#endif
cuboidBatch.Draw();
modelViewM.PopMatrix();
static CStopWatch timer;
float angle = timer.GetElapsedSeconds() * 120;
modelViewM.Translate(0.5f, 0.6f, -5);
modelViewM.Rotate(angle, 1, 1, 1);
modelViewM.Scale(0.5/cuboidLength, 0.3/cuboidHeigth, 0.4/cuboidWidth);
glBindTexture(GL_TEXTURE_2D, textureID[1]);
#if 0
shaderManager.UseStockShader(GLT_SHADER_TEXTURE_POINT_LIGHT_DIFF,
pipelineTransform.GetModelViewMatrix(),
pipelineTransform.GetProjectionMatrix(),
lightEyePos, whiteLight, 0);
#else
shaderManager.UseStockShader(GLT_SHADER_TEXTURE_REPLACE,
pipelineTransform.GetModelViewProjectionMatrix(),
0);
#endif
cuboidBatch.Draw();
modelViewM.PopMatrix();
glutSwapBuffers();
glutPostRedisplay();
}
// Called to draw scene
void RenderScene(void)
{
// Color values
static GLfloat vFloorColor[] = { 0.0f, 1.0f, 0.0f, 1.0f};
static GLfloat vTorusColor[] = { 1.0f, 0.0f, 0.0f, 1.0f };
static GLfloat vSphereColor[] = { 0.0f, 0.0f, 1.0f, 1.0f };
// Time Based animation
static CStopWatch rotTimer;
float yRot = rotTimer.GetElapsedSeconds() * 60.0f;
// Clear the color and depth buffers
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Save the current modelview matrix (the identity matrix)
modelViewMatrix.PushMatrix();
M3DMatrix44f mCamera;
cameraFrame.GetCameraMatrix(mCamera);
modelViewMatrix.PushMatrix(mCamera);
// Draw the ground
shaderManager.UseStockShader(GLT_SHADER_FLAT,
transformPipeline.GetModelViewProjectionMatrix(),
vFloorColor);
floorBatch.Draw();
for(int i = 0; i < NUM_SPHERES; i++) {
modelViewMatrix.PushMatrix();
modelViewMatrix.MultMatrix(spheres[i]);
shaderManager.UseStockShader(GLT_SHADER_FLAT, transformPipeline.GetModelViewProjectionMatrix(),
vSphereColor);
sphereBatch.Draw();
modelViewMatrix.PopMatrix();
}
// Draw the spinning Torus
modelViewMatrix.Translate(0.0f, 0.0f, -2.5f);
// Save the Translation
modelViewMatrix.PushMatrix();
// Apply a rotation and draw the torus
modelViewMatrix.Rotate(yRot, 0.0f, 1.0f, 0.0f);
shaderManager.UseStockShader(GLT_SHADER_FLAT, transformPipeline.GetModelViewProjectionMatrix(),
vTorusColor);
torusBatch.Draw();
modelViewMatrix.PopMatrix(); // "Erase" the Rotation from before
// Apply another rotation, followed by a translation, then draw the sphere
modelViewMatrix.Rotate(yRot * -2.0f, 0.0f, 1.0f, 0.0f);
modelViewMatrix.Translate(0.8f, 0.0f, 0.0f);
shaderManager.UseStockShader(GLT_SHADER_FLAT, transformPipeline.GetModelViewProjectionMatrix(),
vSphereColor);
sphereBatch.Draw();
// Restore the previous modleview matrix (the identity matrix)
modelViewMatrix.PopMatrix();
modelViewMatrix.PopMatrix();
// Do the buffer Swap
glutSwapBuffers();
// Tell GLUT to do it again
glutPostRedisplay();
}
void Gripper::environmentCalc(GLMatrixStack &modelViewStack, float phantomMat[16]){
phidgets.sampleAll();
for(int i = 0; i < 2; ++i){
if(phidgets.getRaw(i) > 500)
return;
if(phidgets.getRaw(i) < 0)
return;
}
endEffector[RED].currentRaw = phidgets.getRaw(0);
endEffector[GREEN].currentRaw = phidgets.getRaw(1);
for(int i = 0; i < 2; ++i){
END_EFFECTOR *ee = &(endEffector[i]);
ee->maxRaw = max(ee->maxRaw, ee->currentRaw);
ee->minRaw = min(ee->minRaw, ee->currentRaw);
double range = ee->maxRaw - ee->minRaw;
double raw = ee->currentRaw - ee->minRaw;
ee->gripperForce = max((1.0 - (raw/range)), 0);
ee->curPos = ee->curPos - (ee->gripperForce - ee->restoreForce - ee->contactForce) * ee->scalar;
ee->curPos = min(ee->maxRange, ee->curPos);
ee->curPos = max(ee->minRange, ee->curPos);
//Dprint::add("[%d] range = %.2f, raw = %.2f, maxRaw = %d, minRaw = %d, curPos = %.2f", i, range, raw, ee->maxRaw, ee->minRaw, ee->curPos);
}
modelViewStack.PushMatrix();
modelViewStack.LoadIdentity();
modelViewStack.MultMatrix(phantomMat);
modelViewStack.Scale(scalar, scalar, scalar);
modelViewStack.GetMatrix(matrix);
setPosFromMatrix(positions[YELLOW]);
modelViewStack.PushMatrix();
modelViewStack.Translate(endEffector[RED].curPos, 0, 0.0);
modelViewStack.Translate(0.0, 0, -8.0);
modelViewStack.GetMatrix(matrix);
setPosFromMatrix(positions[RED]);
modelViewStack.PushMatrix();
modelViewStack.Translate(0.0, 2.0, -2.0);
modelViewStack.GetMatrix(matrix);
setPosFromMatrix(positions[RED2]);
modelViewStack.Translate(0.0, -4.0, 0.0);
modelViewStack.GetMatrix(matrix);
setPosFromMatrix(positions[RED3]);
modelViewStack.Translate(0.0, 2.0, -2.0);
modelViewStack.GetMatrix(matrix);
setPosFromMatrix(positions[RED4]);
modelViewStack.PopMatrix();
modelViewStack.PopMatrix();
modelViewStack.PushMatrix();
modelViewStack.Translate(-endEffector[GREEN].curPos, 0, 0.0);
modelViewStack.Translate(0.0, 0, -8.0);
modelViewStack.GetMatrix(matrix);
setPosFromMatrix(positions[GREEN]);
modelViewStack.PushMatrix();
modelViewStack.Translate(0.0, 2.0, -2.0);
modelViewStack.GetMatrix(matrix);
setPosFromMatrix(positions[GREEN2]);
modelViewStack.Translate(0.0, -4.0, 0.0);
modelViewStack.GetMatrix(matrix);
setPosFromMatrix(positions[GREEN3]);
modelViewStack.Translate(0.0, 2.0, -2.0);
modelViewStack.GetMatrix(matrix);
setPosFromMatrix(positions[GREEN4]);
modelViewStack.PopMatrix();
modelViewStack.PopMatrix();
modelViewStack.PopMatrix();
for(int i = 0; i < NUM_END_EFFECTORS; ++i){
offsets[i][0] = positions[i][0] - positions[YELLOW][0];
offsets[i][1] = positions[i][1] - positions[YELLOW][1];
offsets[i][2] = positions[i][2] - positions[YELLOW][2];
}
}
///////////////////////////////////////////////////////////////////////////////
// Render a frame. The owning framework is responsible for buffer swaps,
// flushes, etc.
void RenderScene(void)
{
static CStopWatch animationTimer;
float yRot = animationTimer.GetElapsedSeconds() * 60.0f;
M3DVector3f vCameraPos;
M3DVector3f vCameraForward;
M3DVector3f vMirrorPos;
M3DVector3f vMirrorForward;
cameraFrame.GetOrigin(vCameraPos);
cameraFrame.GetForwardVector(vCameraForward);
// Set position of mirror frame (camera)
vMirrorPos[0] = 0.0;
vMirrorPos[1] = 0.1f;
vMirrorPos[2] = -6.0f; // view pos is actually behind mirror
mirrorFrame.SetOrigin(vMirrorPos);
// Calculate direction of mirror frame (camera)
// Because the position of the mirror is known relative to the origin
// find the direction vector by adding the mirror offset to the vector
// of the viewer-origin
vMirrorForward[0] = vCameraPos[0];
vMirrorForward[1] = vCameraPos[1];
vMirrorForward[2] = (vCameraPos[2] + 5);
m3dNormalizeVector3(vMirrorForward);
mirrorFrame.SetForwardVector(vMirrorForward);
// first render from the mirrors perspective
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fboName);
glDrawBuffers(1, fboBuffs);
glViewport(0, 0, mirrorTexWidth, mirrorTexHeight);
// Draw scene from the perspective of the mirror camera
modelViewMatrix.PushMatrix();
M3DMatrix44f mMirrorView;
mirrorFrame.GetCameraMatrix(mMirrorView);
modelViewMatrix.MultMatrix(mMirrorView);
// Flip the mirror camera horizontally for the reflection
modelViewMatrix.Scale(-1.0f, 1.0f, 1.0f);
glBindTexture(GL_TEXTURE_2D, textures[0]); // Marble
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
shaderManager.UseStockShader(GLT_SHADER_TEXTURE_MODULATE, transformPipeline.GetModelViewProjectionMatrix(), vWhite, 0);
floorBatch.Draw();
DrawWorld(yRot);
// Now draw a cylinder representing the viewer
M3DVector4f vLightTransformed;
modelViewMatrix.GetMatrix(mMirrorView);
m3dTransformVector4(vLightTransformed, vLightPos, mMirrorView);
modelViewMatrix.Translate(vCameraPos[0],vCameraPos[1]-0.8f,vCameraPos[2]-1.0f);
modelViewMatrix.Rotate(-90.0f, 1.0f, 0.0f, 0.0f);
shaderManager.UseStockShader(GLT_SHADER_POINT_LIGHT_DIFF,
modelViewMatrix.GetMatrix(),
transformPipeline.GetProjectionMatrix(),
vLightTransformed, vBlue, 0);
cylinderBatch.Draw();
modelViewMatrix.PopMatrix();
// Reset FBO. Draw world again from the real cameras perspective
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
glDrawBuffers(1, windowBuff);
glViewport(0, 0, screenWidth, screenHeight);
modelViewMatrix.PushMatrix();
M3DMatrix44f mCamera;
cameraFrame.GetCameraMatrix(mCamera);
modelViewMatrix.MultMatrix(mCamera);
glBindTexture(GL_TEXTURE_2D, textures[0]); // Marble
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
shaderManager.UseStockShader(GLT_SHADER_TEXTURE_MODULATE, transformPipeline.GetModelViewProjectionMatrix(), vWhite, 0);
floorBatch.Draw();
DrawWorld(yRot);
// Now draw the mirror surfaces
modelViewMatrix.PushMatrix();
modelViewMatrix.Translate(0.0f, -0.4f, -5.0f);
if(vCameraPos[2] > -5.0)
{
glBindTexture(GL_TEXTURE_2D, mirrorTexture); // Reflection
shaderManager.UseStockShader(GLT_SHADER_TEXTURE_REPLACE, transformPipeline.GetModelViewProjectionMatrix(), 0);
}
else
{
// If the camera is behind the mirror, just draw black
shaderManager.UseStockShader(GLT_SHADER_FLAT, transformPipeline.GetModelViewProjectionMatrix(), vBlack);
}
mirrorBatch.Draw();
shaderManager.UseStockShader(GLT_SHADER_FLAT, transformPipeline.GetModelViewProjectionMatrix(), vGrey);
mirrorBorderBatch.Draw();
modelViewMatrix.PopMatrix();
modelViewMatrix.PopMatrix();
// Do the buffer Swap
glutSwapBuffers();
// Do it again
glutPostRedisplay();
}
