// Initialize our rendering device
int GLDriver::initialize(IWindow* pWindow)
{
Assert(pWindow != NULL);
Trace("Initializing OpenGL");
glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
glClearColor(0.0,0.0,0.0,0.0);
glDepthFunc(GL_LEQUAL);
glEnable(GL_TEXTURE_2D);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
resize(pWindow->getWidth(), pWindow->getHeight());
//resize
/*HWND hwnd;
Trace("Initializing OpenGL graphics driver");
hwnd = static_cast< HWND > (pWindow->getWindowHandle());
// Create an OpenGL pixel format descriptor
PIXELFORMATDESCRIPTOR pfd =
{
sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor
1, // Version Number
PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER, // Format Must Support OpenGL and double buffering
PFD_TYPE_RGBA, // Request An RGBA Format
pWindow->getBpp(), // Select Our Color Depth
0, 0, 0, 0, 0, 0, // Color Bits Ignored
0, // No Alpha Buffer
0, // Shift Bit Ignored
0, // No Accumulation Buffer
0, 0, 0, 0, // Accumulation Bits Ignored
16, // 16Bit Z-Buffer (Depth Buffer)
0, // No Stencil Buffer
0, // No Auxiliary Buffer
PFD_MAIN_PLANE, // Main Drawing Layer
0, // Reserved
0, 0, 0 // Layer Masks Ignored
};
// Initialise stuff, and check for errors
Trace("Acquiring device context");
if (!(hdc = GetDC(hwnd)))
CEngine::CriticalError("Unable to create GL device context!");
Trace("Finding pixel format");
if (!(pixelFormat = ChoosePixelFormat(hdc, &pfd)))
CEngine::CriticalError("Unable to find a pixel format!");
Trace("Setting pixel format");
if(!SetPixelFormat(hdc, pixelFormat, &pfd))
CEngine::CriticalError("Unable to set the pixel format!");
Trace("Acquiring rendering context");
if(!(hrc = wglCreateContext(hdc)))
CEngine::CriticalError("Unable to create GL rendering context!");
Trace("Setting current GL window");
if(!wglMakeCurrent(hdc, hrc))
CEngine::CriticalError("Unable to activate GL rendering context!");
resize(pWindow->getWidth(), pWindow->getHeight());
// Set up initial gl parameters
glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
glClearColor(0.0,0.0,0.0,0.0);
glDepthFunc(GL_LEQUAL);
glEnable(GL_TEXTURE_2D);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
// Grab GL vendor information
Trace("Getting OpenGL driver info ...");
char* str;
str = (char*)glGetString(GL_VENDOR);
vendor.assign(str);
Trace("OpenGL Vendor: %s", vendor.c_str());
str = (char*)glGetString(GL_RENDERER);
renderer.assign(str);
Trace("OpenGL Renderer: %s", renderer.c_str());
str = (char*)glGetString(GL_VERSION);
version.assign(str);
Trace("OpenGL Version: %s", version.c_str());
str = (char*)glGetString(GL_EXTENSIONS);
extensions.assign(str);
// Replace all spaces with newlines
for(int i = 0; i < extensions.length(); ++i)
{
if(extensions[i] == ' ')
extensions[i] = '\n';
}
// Acquire pointer to extension functions
// Multitexturing
glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)wglGetProcAddress("glActiveTextureARB");
glClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC)wglGetProcAddress("glClientActiveTextureARB");
glMultiTexCoord2fARB = (PFNGLMULTITEXCOORD2FARBPROC)wglGetProcAddress("glMultiTexCoord2fARB");
// Set up hardware gamma, if we are using it
if(Config::getIntValue("UseHardwareGamma") == 1)
{
GetDeviceGammaRamp(hdc, &oldGamma);
float gamma = 2.0f;
for(int i = 0; i < 3; i++)
{
for(int j = 0;j < 256; j++)
{
DWORD d = oldGamma[j][i] * gamma;
if(d > 65535)
d = 65535;
newGamma[j][i] = d;
}
}
SetDeviceGammaRamp(hdc, &newGamma);
}
// Set up the font
HFONT oldfont;
fontDispListBase = glGenLists(96);
font = CreateFont(-17, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ANSI_CHARSET, OUT_TT_PRECIS,
CLIP_DEFAULT_PRECIS, ANTIALIASED_QUALITY, FF_DONTCARE | DEFAULT_PITCH, "Arial");
oldfont = (HFONT)SelectObject(hdc, font);
wglUseFontBitmaps(hdc, 32, 96, fontDispListBase);
SelectObject(hdc, oldfont);
DeleteObject(font);
*/
return 0;
}
//Called to update the display.
//You should call glutSwapBuffers after all of your rendering to display what you rendered.
//If you need continuous updates of the screen, call glutPostRedisplay() at the end of the function.
void display()
{
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if(g_pConeMesh && g_pCylinderMesh && g_pCubeTintMesh && g_pCubeColorMesh && g_pPlaneMesh)
{
g_camMatrix.SetMatrix(mainCharacter.AcquireCamera().CalcLookAtMatrix());
glutil::MatrixStack modelMatrix;
//Render the ground plane.
{
glutil::PushStack push(modelMatrix);
modelMatrix.ApplyMatrix(g_camMatrix.Top());
modelMatrix.Scale(glm::vec3(100.0f, 1.0f, 100.0f));
glUseProgram(UniformColor.theProgram);
glUniformMatrix4fv(UniformColor.modelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(modelMatrix.Top()));
glUniform4f(UniformColor.baseColorUnif, 0.302f, 0.416f, 0.0589f, 1.0f);
g_pPlaneMesh->Render();
glUseProgram(0);
}
//Draw the trees
DrawForest(UniformColorTint, modelMatrix, g_camMatrix);
//Draw the building.
{
glutil::PushStack push(modelMatrix);
modelMatrix.ApplyMatrix(g_camMatrix.Top());
modelMatrix.Translate(glm::vec3(20.0f, 0.0f, -10.0f));
DrawParthenon(UniformColorTint, ObjectColor, modelMatrix);
}
//Draw the treasure
for(int i = 0; i < COUNT; i++)
{
if(littleTreasures[i].IsRemoved() == false)
{
glutil::PushStack push(modelMatrix);
modelMatrix.ApplyMatrix(g_camMatrix.Top());
littleTreasures[i].Update();
littleTreasures[i].Render(UniformColorTint, modelMatrix);
}
else
{
littleTreasures[i].Spawn(g_parthenonBaseVolume, g_treeVolumes, ARRAY_COUNT(g_forest), mainCharacter.GetCollisionVolume());
}
}
}
HandleMouse();
glutPostRedisplay();
glutSwapBuffers();
userMouse.OverrideLastPosition(userMouse.GetCurrentPosition());
}
void OrientationOverlay::process() {
if (!inport_.isReady())
outport_.activateTarget();
else
privatePort_.activateTarget();
//draw the cube in the desired position
// set modelview and projection matrices
MatStack.matrixMode(tgt::MatrixStack::PROJECTION);
MatStack.pushMatrix();
MatStack.loadMatrix(tgt::mat4::createOrtho(-1,1,1,-1,-2,2));
MatStack.matrixMode(tgt::MatrixStack::MODELVIEW);
MatStack.pushMatrix();
MatStack.translate(shiftX_.get()*2.0f-1.0f, shiftY_.get()*2.0f-1.0f, 0);
tgt::mat4 view = camera_.get().getViewMatrix().getRotationalPart();
MatStack.scale((float)outport_.getSize().y / (float)outport_.getSize().x, 1, 1);
MatStack.multMatrix(view);
glClearDepth(1);
glEnable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
// render cube and axis overlays
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (drawCube_.get() == true)
renderCube();
if (drawAxes_.get() == true)
renderAxes();
if (!inport_.isReady())
outport_.deactivateTarget();
else
privatePort_.deactivateTarget();
// restore OpenGL state
glCullFace(GL_BACK);
glDisable(GL_CULL_FACE);
MatStack.matrixMode(tgt::MatrixStack::PROJECTION);
MatStack.popMatrix();
MatStack.matrixMode(tgt::MatrixStack::MODELVIEW);
MatStack.popMatrix();
LGL_ERROR;
glEnable(GL_DEPTH_TEST);
// now do the composition of the OrientationOverlay with the inport render data by shader
if (inport_.isReady()) {
outport_.activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// use the shader to draw cube and axis over inport render data
// therefore bind rgba and depth values of both to textures
TextureUnit colorUnit0, depthUnit0, colorUnit1, depthUnit1;
privatePort_.bindTextures(colorUnit0.getEnum(), depthUnit0.getEnum());
inport_.bindTextures(colorUnit1.getEnum(), depthUnit1.getEnum());
// initialize shader
program_->activate();
setGlobalShaderParameters(program_);
program_->setUniform("colorTexMe_", colorUnit0.getUnitNumber());
program_->setUniform("depthTexMe_", depthUnit0.getUnitNumber());
program_->setUniform("colorTexIn_", colorUnit1.getUnitNumber());
program_->setUniform("depthTexIn_", depthUnit1.getUnitNumber());
privatePort_.setTextureParameters(program_, "textureParametersMe_");
inport_.setTextureParameters(program_, "textureParametersIn_");
glDepthFunc(GL_ALWAYS);
renderQuad(); // render quad primitive textured by fragment shader
glDepthFunc(GL_LESS);
outport_.deactivateTarget();
program_->deactivate();
glActiveTexture(GL_TEXTURE0);
}
LGL_ERROR;
}
void CRenderer::ClearDepth(GLclampf depth)
{
BEATS_ASSERT(depth >= 0 && depth <= 1);
glClearDepth(depth);
FC_CHECK_GL_ERROR_DEBUG();
}
GLvoid InitGL(){
//All the stuff we need to draw
std::string hero_geo_file = "geo/tank.obj";
std::string target_geo_file = "geo/target.obj";
std::string swivel_geo_file = "geo/turret.obj";
std::string barrel_geo_file = "geo/barrel.obj";
std::string environment_geo_file = "geo/cube.obj";
std::string enemy_geo_file = "geo/enemy.obj";
std::string tile_geo_file = "geo/tile.obj";
std::string tree_geo_file = "geo/tree.obj";
std::string rock_geo_file = "geo/rocks.obj";
std::string hero_tex_file = "tex/tank.ppm";
std::string target_tex_file = "tex/target.ppm";
std::string swivel_tex_file = "tex/turret.ppm";
std::string barrel_tex_file = "tex/barrel.ppm";
std::string environment_tex_file = "tex/cubemape.ppm";
std::string enemy_tex_file = "tex/enemy.ppm";
std::string tile_tex_file = "tex/naked_tile_baked.ppm";
std::string tree_tex_file = "tex/tree.ppm";
std::string rock_tex_file = "tex/rocks.ppm";
std::string tree_tile_tex = "tex/tree_tile.ppm";
std::string rock_tile_tex = "tex/rocky_tile.ppm";
std::string blob_tile_tex = "tex/blob_shadow.ppm";
mesh hero(hero_geo_file);
mesh target(target_geo_file);
mesh swivel(swivel_geo_file);
mesh barrel(barrel_geo_file);
mesh environment(environment_geo_file);
mesh enemy(enemy_geo_file);
mesh tile(tile_geo_file);
mesh tree(tree_geo_file);
mesh rock(rock_geo_file);
HERO_ID = meshes.size();
meshes.push_back(hero);
TARGET_ID = meshes.size();
meshes.push_back(target);
SWIVEL_ID = meshes.size();
meshes.push_back(swivel);
BARREL_ID = meshes.size();
meshes.push_back(barrel);
ENVIRONMENT_ID = meshes.size();
meshes.push_back(environment);
ENEMY_ID = meshes.size();
meshes.push_back(enemy);
TILE_ID = meshes.size();
meshes.push_back(tile);
TREE_ID = meshes.size();
meshes.push_back(tree);
ROCK_ID = meshes.size();
meshes.push_back(rock);
glEnable(GL_TEXTURE_2D);
glGenTextures(1, &HERO_TEX);
glGenTextures(1, &TARGET_TEX);
glGenTextures(1, &SWIVEL_TEX);
glGenTextures(1, &BARREL_TEX);
glGenTextures(1, &ENVIRONMENT_TEX);
glGenTextures(1, &ENEMY_TEX);
glGenTextures(1, &TILE_TEX);
glGenTextures(1, &TREE_TEX);
glGenTextures(1, &ROCK_TEX);
glGenTextures(1, &TREETILE_TEX);
glGenTextures(1, &ROCKTILE_TEX);
glGenTextures(1, &BLOBTILE_TEX);
loadPPM(hero_tex_file.c_str(), HERO_TEX);
loadPPM(target_tex_file.c_str(), TARGET_TEX);
loadPPM(swivel_tex_file.c_str(), SWIVEL_TEX);
loadPPM(barrel_tex_file.c_str(), BARREL_TEX);
loadPPM(environment_tex_file.c_str(), ENVIRONMENT_TEX);
loadPPM(enemy_tex_file.c_str(), ENEMY_TEX);
loadPPM(tile_tex_file.c_str(), TILE_TEX);
loadPPM(tree_tex_file.c_str(), TREE_TEX);
loadPPM(rock_tex_file.c_str(), ROCK_TEX);
loadPPM(tree_tile_tex.c_str(), TREETILE_TEX);
loadPPM(rock_tile_tex.c_str(), ROCKTILE_TEX);
loadPPM(blob_tile_tex.c_str(), BLOBTILE_TEX, true);
camera = new game_object(-1,-1,-1);
game_object *hero_character = new game_object(characters.size(), HERO_ID, HERO_TEX);
characters.push_back(hero_character);
game_object *target_character = new game_object(characters.size(), TARGET_ID, TARGET_TEX);
target_character->transform.translate(0.0,0.0,-7.0);
characters.push_back(target_character);
game_object *swivel_character = new game_object(characters.size(), SWIVEL_ID, SWIVEL_TEX);
swivel_character->transform.translate(0.0,0.4,0.0);
characters.push_back(swivel_character);
game_object *barrel_character = new game_object(characters.size(), BARREL_ID, BARREL_TEX);
barrel_character->transform.translate(0.0,0.0,-0.15);
barrel_character->parent_to(characters[SWIVEL_ID]);
characters.push_back(barrel_character);
game_object *environment_character = new game_object(characters.size(), ENVIRONMENT_ID, ENVIRONMENT_TEX);
environment_character->transform.scale(TILES_DIMENSION,TILES_DIMENSION,TILES_DIMENSION);
environment_character->parent_to(camera);
characters.push_back(environment_character);
// game_object *enemy_character = new game_object(characters.size(), ENEMY_ID, ENEMY_TEX);
// enemy_character->transform.translate(0.0, 0.0, -7.0);
// enemy_character->parent_to(camera);
// characters.push_back(enemy_character);
// bad_guys.push_back(ENEMY_ID);
srand(time(NULL));
int spread = TILES_DIMENSION;
for(int i=1; i<BAD_GUY_COUNT; i++)
{
game_object *enemyX = new game_object(characters.size(), ENEMY_ID, ENEMY_TEX);
enemyX->transform.translate(rand()%spread-spread/2, 0.0, rand()%spread-spread/2);
enemyX->transform.rotateY(rand()%180);
enemyX->parent_to(camera);
bad_guys.push_back(characters.size());
colliders.push_back(characters.size());
characters.push_back(enemyX);
}
double tile_width = meshes[TILE_ID].xmax - meshes[TILE_ID].xmin;
double tile_length = meshes[TILE_ID].zmax - meshes[TILE_ID].zmin;
for(int i=0; i<TILES_DIMENSION; i++)
{
int xmult = i - TILES_DIMENSION/2;
for(int j=0; j<TILES_DIMENSION; j++)
{
int zmult = j - TILES_DIMENSION/2;
double rot = rand() % 4 * 90.0;
// std::cout << rot << std::endl;
game_object *tileX = new game_object(characters.size(), TILE_ID, TILE_TEX);
tileX->transform.rotateY(rot);
tileX->transform.translate(tile_width*xmult, 0.0, tile_length*zmult);
tileX->parent_to(camera);
characters.push_back(tileX);
int tile_type = rand() % 100;
if(tile_type >= 96 && tile_type < 98)
{
tileX->tex = TREETILE_TEX;
game_object *treeX = new game_object(characters.size(), TREE_ID, TREE_TEX);
treeX->transform = tileX->transform;
treeX->parent_to(camera);
bad_guys.push_back(characters.size());
colliders.push_back(characters.size());
characters.push_back(treeX);
}
else if(tile_type >= 98)
{
tileX->tex = ROCKTILE_TEX;
game_object *rockX = new game_object(characters.size(), ROCK_ID, ROCK_TEX);
rockX->transform = tileX->transform;
rockX->parent_to(camera);
bad_guys.push_back(characters.size());
colliders.push_back(characters.size());
characters.push_back(rockX);
}
}
}
game_object *blob_character = new game_object(characters.size(), TILE_ID, BLOBTILE_TEX);
blob_character->transform.translate(0.0,0.001,0.0);
blob_character->transform.scale(2.0, 1.0, 3.0);
characters.push_back(blob_character);
last_update = (double)clock() / ((double)CLOCKS_PER_SEC);
//GL boilerplate initialization
glShadeModel(GL_SMOOTH); // Enable Smooth Shading
glClearColor(0.5f, 0.5f, 0.5f, 0.5f); // grey Background
glClearDepth(1.0f); // Depth Buffer Setup
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
glEnable(GL_CULL_FACE);
glShadeModel(GL_SMOOTH);
glDepthFunc(GL_LEQUAL); // The Type Of Depth Testing To Do
glEnable(GL_COLOR_MATERIAL);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
//
// Init GL
//
int InitGL(GLvoid) // All Setup For OpenGL Goes Here
{
// seed rand generator
srand(getclock());
#if 0
QueryPerformanceFrequency(&timerFrequency);
QueryPerformanceCounter(&lastTime);
#endif
// use the mouse only
// for camera movement
// disable the cursor
ShowCursor(FALSE);
Super_LoadGlobals();
Load_ConfigFile();
// Now load main variables
Super_LoadBots();
Super_FireAnts();
Create_Col_List();
Create_Wall_List();
// enable all the goodies
//glEnable(GL_TEXTURE_2D); // enable texture mapping
glShadeModel(GL_SMOOTH); // Enable Smooth Shading
glClearColor(0.0f, 0.0f, 0.0f, 0.5f); // Black Background
glClearDepth(1.0f); // Depth Buffer Setup
glEnable(GL_NORMALIZE);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
glDepthFunc(GL_LEQUAL); // The Type Of Depth Testing To Do
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculations
// have to load the quadrice to be used
quadric=gluNewQuadric(); // Create A Pointer To The Quadric Object (Return 0 If No Memory) (NEW)
gluQuadricNormals(quadric, GLU_SMOOTH); // Create Smooth Normals (NEW)
gluQuadricTexture(quadric, GL_TRUE); // Create Texture Coords (NEW)
#if ENABLE_LIGHTS
// InitMaterial();
#endif
GenerateBots();
GenerateFireAnts(); // a new breed of warrior
CreateWorld();
LoadCameras();
BuildFont(); // Build The Font
// Load the objects
InitObjects();
GenerateLights();
InitGlobals(); // for printing data, etc
// generate the nest objects
nest.generate();
garden.generate();
trail_set.generate();
// give the ant food
InitFood();
Build_ParticleSet();
Reset_FontID();
// load the title screen text
Load_Titles();
// the text library
Super_MainText();
CreateWalls();
//
// Load the collision test for the wall
// very easy test
// 4 different walls
//
// front wall
InsertColSegment(world_ptr->x_min, world_ptr->y_max,
world_ptr->x_max, world_ptr->y_max);
// right wall
InsertColSegment(world_ptr->x_max, world_ptr->y_min,
world_ptr->x_max, world_ptr->y_max);
// back wall (top)
InsertColSegment(world_ptr->x_min, world_ptr->y_min,
world_ptr->x_max, world_ptr->y_min);
// left wall
InsertColSegment(world_ptr->x_min, world_ptr->y_min,
world_ptr->x_min, world_ptr->y_max);
// end insertion --
//
// The first thing to do is begin in paused mode
//
Super_BeginPaused();
mSuper_Loaded = LOADED_TRUE;
return TRUE; // Initialization Went OK
} // end of the function
//Called to update the display.
//You should call glutSwapBuffers after all of your rendering to display what you rendered.
//If you need continuous updates of the screen, call glutPostRedisplay() at the end of the function.
void display()
{
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if(g_pConeMesh && g_pCylinderMesh && g_pCubeTintMesh && g_pCubeColorMesh && g_pPlaneMesh)
{
const glm::vec3 &camPos = ResolveCamPosition();
glutil::MatrixStack camMatrix;
camMatrix.SetMatrix(CalcLookAtMatrix(camPos, g_camTarget, glm::vec3(0.0f, 1.0f, 0.0f)));
glUseProgram(UniformColor.theProgram);
glUniformMatrix4fv(UniformColor.worldToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(camMatrix.Top()));
glUseProgram(ObjectColor.theProgram);
glUniformMatrix4fv(ObjectColor.worldToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(camMatrix.Top()));
glUseProgram(UniformColorTint.theProgram);
glUniformMatrix4fv(UniformColorTint.worldToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(camMatrix.Top()));
glUseProgram(0);
glutil::MatrixStack modelMatrix;
//Render the ground plane.
{
glutil::PushStack push(modelMatrix);
modelMatrix.Scale(glm::vec3(100.0f, 1.0f, 100.0f));
glUseProgram(UniformColor.theProgram);
glUniformMatrix4fv(UniformColor.modelToWorldMatrixUnif, 1, GL_FALSE, glm::value_ptr(modelMatrix.Top()));
glUniform4f(UniformColor.baseColorUnif, 0.302f, 0.416f, 0.0589f, 1.0f);
g_pPlaneMesh->Render();
glUseProgram(0);
}
//Draw the trees
DrawForest(modelMatrix);
//Draw the building.
{
glutil::PushStack push(modelMatrix);
modelMatrix.Translate(glm::vec3(20.0f, 0.0f, -10.0f));
DrawParthenon(modelMatrix);
}
if(g_bDrawLookatPoint)
{
glDisable(GL_DEPTH_TEST);
glm::mat4 idenity(1.0f);
glutil::PushStack push(modelMatrix);
glm::vec3 cameraAimVec = g_camTarget - camPos;
modelMatrix.Translate(0.0f, 0.0, -glm::length(cameraAimVec));
modelMatrix.Scale(1.0f, 1.0f, 1.0f);
glUseProgram(ObjectColor.theProgram);
glUniformMatrix4fv(ObjectColor.modelToWorldMatrixUnif, 1, GL_FALSE, glm::value_ptr(modelMatrix.Top()));
glUniformMatrix4fv(ObjectColor.worldToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(idenity));
g_pCubeColorMesh->Render();
glUseProgram(0);
glEnable(GL_DEPTH_TEST);
}
}
glutSwapBuffers();
}
void GameEngine::Prerender() {
glClearDepth(1.0); // Set depth to 1.0
glClearColor(0.05f, 0.05f, 0.05f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear the color and depth buffer
}
void COGLGraphicsContext::InitState(void)
{
m_pRenderStr = glGetString(GL_RENDERER);
m_pExtensionStr = glGetString(GL_EXTENSIONS);
m_pVersionStr = glGetString(GL_VERSION);
m_pVendorStr = glGetString(GL_VENDOR);
glMatrixMode(GL_PROJECTION);
OPENGL_CHECK_ERRORS;
glLoadIdentity();
OPENGL_CHECK_ERRORS;
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
OPENGL_CHECK_ERRORS;
glClearDepth(1.0f);
OPENGL_CHECK_ERRORS;
#ifndef USE_GLES
glShadeModel(GL_SMOOTH);
OPENGL_CHECK_ERRORS;
//position viewer
//glMatrixMode(GL_MODELVIEW);
//glLoadIdentity();
glDisable(GL_ALPHA_TEST);
OPENGL_CHECK_ERRORS;
#endif
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
OPENGL_CHECK_ERRORS;
glDisable(GL_BLEND);
OPENGL_CHECK_ERRORS;
glFrontFace(GL_CCW);
OPENGL_CHECK_ERRORS;
glDisable(GL_CULL_FACE);
OPENGL_CHECK_ERRORS;
#ifndef USE_GLES
glDisable(GL_NORMALIZE);
OPENGL_CHECK_ERRORS;
#endif
glDepthFunc(GL_LEQUAL);
OPENGL_CHECK_ERRORS;
glEnable(GL_DEPTH_TEST);
OPENGL_CHECK_ERRORS;
#ifndef USE_GLES
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
OPENGL_CHECK_ERRORS;
#endif
glEnable(GL_BLEND);
OPENGL_CHECK_ERRORS;
#ifndef USE_GLES
glEnable(GL_ALPHA_TEST);
OPENGL_CHECK_ERRORS;
glMatrixMode(GL_PROJECTION);
OPENGL_CHECK_ERRORS;
glLoadIdentity();
OPENGL_CHECK_ERRORS;
glDepthRange(-1, 1);
#else
glDepthRangef(0.0f, 1.0f);
#endif
OPENGL_CHECK_ERRORS;
}
GLUSboolean init(GLUSvoid)
{
GLfloat textureToWorldNormalMatrix[16];
// The maximum detail level which is 2^s = sMapExtend.
GLuint sMaxDetailLevel;
// The maximum detail level which is 2^t = tMapExtend.
GLuint tMaxDetailLevel;
// The overall maximum detail level from s and t.
GLuint overallMaxDetailLevel;
// Step for s and t direction.
GLfloat detailStep;
GLuint s, t;
GLUStgaimage image;
GLfloat* map = 0;
GLuint* indices = 0;
GLUStextfile vertexSource;
GLUStextfile controlSource;
GLUStextfile evaluationSource;
GLUStextfile geometrySource;
GLUStextfile fragmentSource;
GLfloat lightDirection[3] = { 1.0f, 1.0f, 1.0f };
glusVector3Normalizef(lightDirection);
g_topView.cameraPosition[0] = 0.0f;
g_topView.cameraPosition[1] = 30000.0f * METERS_TO_VIRTUAL_WORLD_SCALE;
g_topView.cameraPosition[2] = 0.0f;
g_topView.cameraPosition[3] = 1.0;
g_topView.cameraDirection[0] = 0.0f;
g_topView.cameraDirection[1] = -1.0f;
g_topView.cameraDirection[2] = 0.0f;
g_topView.cameraUp[0] = 0.0f;
g_topView.cameraUp[1] = 0.0f;
g_topView.cameraUp[2] = -1.0f;
g_topView.fov = 40.0f;
g_personView.cameraPosition[0] = 0.0f;
g_personView.cameraPosition[1] = 4700.0f * METERS_TO_VIRTUAL_WORLD_SCALE;
g_personView.cameraPosition[2] = 0.0f;
g_personView.cameraPosition[3] = 1.0;
g_personView.cameraDirection[0] = 0.0f;
g_personView.cameraDirection[1] = 0.0f;
g_personView.cameraDirection[2] = -1.0f;
g_personView.cameraUp[0] = 0.0f;
g_personView.cameraUp[1] = 1.0f;
g_personView.cameraUp[2] = 0.0f;
g_personView.fov = 60.0f;
g_activeView = &g_personView;
if (!glusLoadTgaImage(NORMAL_MAP, &image))
{
printf("Could not load normal picture '%s'!\n", NORMAL_MAP);
return GLUS_FALSE;
}
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glGenTextures(1, &g_normalMapTexture);
glBindTexture(GL_TEXTURE_RECTANGLE, g_normalMapTexture);
glTexImage2D(GL_TEXTURE_RECTANGLE, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glusDestroyTgaImage(&image);
if (!glusLoadTgaImage(HEIGHT_MAP, &image))
{
printf("Could not load height picture '%s'!\n", HEIGHT_MAP);
return GLUS_FALSE;
}
glGenTextures(1, &g_heightMapTexture);
glBindTexture(GL_TEXTURE_RECTANGLE, g_heightMapTexture);
glTexImage2D(GL_TEXTURE_RECTANGLE, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
g_sMapExtend = (GLfloat) image.width;
g_tMapExtend = (GLfloat) image.height;
glusDestroyTgaImage(&image);
// Calculate the detail level for the s and ...
sMaxDetailLevel = (GLuint) floorf(logf(g_sMapExtend) / logf(2.0f));
// ... t extend
tMaxDetailLevel = (GLuint) floorf(logf(g_tMapExtend) / logf(2.0f));
overallMaxDetailLevel = glusMinf(sMaxDetailLevel, tMaxDetailLevel);
// Do checking of calculated parameters
if (MINIMUM_DETAIL_LEVEL > overallMaxDetailLevel)
{
printf("Detail level to high %d > %d\n", MINIMUM_DETAIL_LEVEL, overallMaxDetailLevel);
return GLUS_FALSE;
}
if (MINIMUM_DETAIL_LEVEL + DETAIL_LEVEL_FIRST_PASS > overallMaxDetailLevel)
{
printf("First pass detail level to high %d > %d\n", MINIMUM_DETAIL_LEVEL + DETAIL_LEVEL_FIRST_PASS, overallMaxDetailLevel);
return GLUS_FALSE;
}
if (powf(2.0f, overallMaxDetailLevel - (MINIMUM_DETAIL_LEVEL + DETAIL_LEVEL_FIRST_PASS)) > 32.0f)
{
printf("Tessellation level to high %d > 32\n", (GLint) powf(2.0f, overallMaxDetailLevel - (MINIMUM_DETAIL_LEVEL + DETAIL_LEVEL_FIRST_PASS)));
return GLUS_FALSE;
}
detailStep = powf(2.0f, overallMaxDetailLevel - MINIMUM_DETAIL_LEVEL);
g_sNumPoints = (GLuint) ceilf(g_sMapExtend / detailStep) - 1;
g_tNumPoints = (GLuint) ceilf(g_tMapExtend / detailStep) - 1;
//
// Generate the flat terrain mesh.
//
map = (GLUSfloat*) malloc(g_sNumPoints * g_tNumPoints * 2 * sizeof(GLfloat));
indices = (GLuint*) malloc(g_sNumPoints * g_tNumPoints * sizeof(GLuint));
for (t = 0; t < g_tNumPoints; t++)
{
for (s = 0; s < g_sNumPoints; s++)
{
map[t * g_sNumPoints * 2 + s * 2 + 0] = 0.5f + detailStep / 2.0f + (GLfloat) s * detailStep;
map[t * g_sNumPoints * 2 + s * 2 + 1] = 0.5f + detailStep / 2.0f + (GLfloat) t * detailStep;
indices[t * g_sNumPoints + s + 0] = (t + 0) * g_sNumPoints + s + 0;
}
}
//
// Transferring vertices and indices into GPU
//
// Pass one
glGenBuffers(1, &g_verticesPassOneVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesPassOneVBO);
glBufferData(GL_ARRAY_BUFFER, g_sNumPoints * g_tNumPoints * 2 * sizeof(GLfloat), map, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &g_indicesPassOneVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesPassOneVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, g_sNumPoints * g_tNumPoints * sizeof(GLuint), indices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
// Pass two.
glGenBuffers(1, &g_verticesPassTwoVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesPassTwoVBO);
// Calculate enough space!
glBufferData(GL_ARRAY_BUFFER, g_sNumPoints * g_tNumPoints * (GLuint) pow(4, DETAIL_LEVEL_FIRST_PASS + 1) * 2 * sizeof(GLfloat), 0, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
//
free(map);
map = 0;
free(indices);
indices = 0;
//
if (!glusLoadTgaImage(COLOR_MAP, &image))
{
printf("Could not load color picture '%s'!\n", COLOR_MAP);
return GLUS_FALSE;
}
glGenTextures(1, &g_colorMapTexture);
glBindTexture(GL_TEXTURE_2D, g_colorMapTexture);
glTexImage2D(GL_TEXTURE_2D, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
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_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glusDestroyTgaImage(&image);
//
glGenQueries(1, &g_transformFeedbackQuery);
//
// Creating the shader program.
//
// Pass one.
glusLoadTextFile("../Example14/shader/PassOne.vert.glsl", &vertexSource);
glusLoadTextFile("../Example14/shader/PassOne.geom.glsl", &geometrySource);
glusLoadTextFile("../Example14/shader/PassOne.frag.glsl", &fragmentSource);
// Compile and ...
glusCreateProgramFromSource(&g_programPassOne, (const GLUSchar**) &vertexSource.text, 0, 0, (const GLUSchar**) &geometrySource.text, (const GLUSchar**) &fragmentSource.text);
// ... add the transform variable ...
glTransformFeedbackVaryings(g_programPassOne.program, 1, (const GLchar**) &TRANSFORM_VARYING, GL_SEPARATE_ATTRIBS);
// ... and link the program
if (!glusLinkProgram(&g_programPassOne))
{
printf("Could not build program one\n");
return GLUS_FALSE;
}
// Destroy the text resource
glusDestroyTextFile(&vertexSource);
glusDestroyTextFile(&geometrySource);
glusDestroyTextFile(&fragmentSource);
g_halfDetailStepPassOneLocation = glGetUniformLocation(g_programPassOne.program, "u_halfDetailStep");
g_detailLevelPassOneLocation = glGetUniformLocation(g_programPassOne.program, "u_detailLevel");
g_fovRadiusPassOneLocation = glGetUniformLocation(g_programPassOne.program, "u_fovRadius");
g_positionTextureSpacePassOneLocation = glGetUniformLocation(g_programPassOne.program, "u_positionTextureSpace");
g_leftNormalTextureSpacePassOneLocation = glGetUniformLocation(g_programPassOne.program, "u_leftNormalTextureSpace");
g_rightNormalTextureSpacePassOneLocation = glGetUniformLocation(g_programPassOne.program, "u_rightNormalTextureSpace");
g_backNormalTextureSpacePassOneLocation = glGetUniformLocation(g_programPassOne.program, "u_backNormalTextureSpace");
// Pass two.
glusLoadTextFile("../Example14/shader/PassTwo.vert.glsl", &vertexSource);
glusLoadTextFile("../Example14/shader/PassTwo.cont.glsl", &controlSource);
glusLoadTextFile("../Example14/shader/PassTwo.eval.glsl", &evaluationSource);
glusLoadTextFile("../Example14/shader/PassTwo.geom.glsl", &geometrySource);
glusLoadTextFile("../Example14/shader/PassTwo.frag.glsl", &fragmentSource);
if (!glusBuildProgramFromSource(&g_shaderProgramPassTwo, (const GLUSchar**) &vertexSource.text, (const GLUSchar**) &controlSource.text, (const GLUSchar**) &evaluationSource.text, (const GLUSchar**) &geometrySource.text, (const GLUSchar**) &fragmentSource.text))
{
printf("Could not build program two\n");
return GLUS_FALSE;
}
glusDestroyTextFile(&vertexSource);
glusDestroyTextFile(&controlSource);
glusDestroyTextFile(&evaluationSource);
glusDestroyTextFile(&geometrySource);
glusDestroyTextFile(&fragmentSource);
g_maxTessellationLevelPassTwoLocation = glGetUniformLocation(g_shaderProgramPassTwo.program, "u_maxTessellationLevel");
g_quadrantStepPassTwoLocation = glGetUniformLocation(g_shaderProgramPassTwo.program, "u_quadrantStep");
g_positionTextureSpacePassTwoLocation = glGetUniformLocation(g_shaderProgramPassTwo.program, "u_positionTextureSpace");
g_heightMapTexturePassTwoLocation = glGetUniformLocation(g_shaderProgramPassTwo.program, "u_heightMapTexture");
g_normalMapTexturePassTwoLocation = glGetUniformLocation(g_shaderProgramPassTwo.program, "u_normalMapTexture");
g_tmvpPassTwoLocation = glGetUniformLocation(g_shaderProgramPassTwo.program, "u_tmvpMatrix");
g_lightDirectionPassTwoLocation = glGetUniformLocation(g_shaderProgramPassTwo.program, "u_lightDirection");
g_colorMapTexturePassTwoLocation = glGetUniformLocation(g_shaderProgramPassTwo.program, "u_colorMapTexture");
//
// One time matrix calculations to convert between texture and world space
glusMatrix4x4Identityf(g_textureToWorldMatrix);
glusMatrix4x4Identityf(textureToWorldNormalMatrix);
glusMatrix4x4Scalef(g_textureToWorldMatrix, HORIZONTAL_PIXEL_SPACING * METERS_TO_VIRTUAL_WORLD_SCALE, VERTICAL_PIXEL_RANGE * METERS_TO_VIRTUAL_WORLD_SCALE, HORIZONTAL_PIXEL_SPACING * METERS_TO_VIRTUAL_WORLD_SCALE);
// Skip this scale for the normal matrix
glusMatrix4x4Scalef(g_textureToWorldMatrix, 1.0f, 1.0f, -1.0f);
glusMatrix4x4Scalef(textureToWorldNormalMatrix, 1.0f, 1.0f, -1.0f);
glusMatrix4x4Translatef(g_textureToWorldMatrix, -g_sMapExtend / 2.0f, 0.0f, -g_tMapExtend / 2.0f);
// No need for the translation matrix in the normal matrix
glusMatrix4x4Copyf(g_worldToTextureMatrix, g_textureToWorldMatrix, GLUS_FALSE);
glusMatrix4x4Inversef(g_worldToTextureMatrix);
glusMatrix4x4Copyf(g_worldToTextureNormalMatrix, textureToWorldNormalMatrix, GLUS_FALSE);
glusMatrix4x4Inversef(g_worldToTextureNormalMatrix);
// Pass one
glUseProgram(g_programPassOne.program);
glUniform1f(g_halfDetailStepPassOneLocation, detailStep / 2.0f);
glUniform1ui(g_detailLevelPassOneLocation, DETAIL_LEVEL_FIRST_PASS);
glUniform1f(g_fovRadiusPassOneLocation, FOV_RADIUS / HORIZONTAL_PIXEL_SPACING * METERS_TO_VIRTUAL_WORLD_SCALE);
glGenVertexArrays(1, &g_vaoPassOne);
glBindVertexArray(g_vaoPassOne);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesPassOneVBO);
// First 0 is the location = 0. See shader source
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
// Enable location = 0
glEnableVertexAttribArray(0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesPassOneVBO);
// Pass two
glUseProgram(g_shaderProgramPassTwo.program);
glUniform3fv(g_lightDirectionPassTwoLocation, 1, lightDirection);
glUniform1ui(g_maxTessellationLevelPassTwoLocation, overallMaxDetailLevel - (MINIMUM_DETAIL_LEVEL + DETAIL_LEVEL_FIRST_PASS));
glUniform1i(g_quadrantStepPassTwoLocation, QUADRANT_STEP);
glGenVertexArrays(1, &g_vaoPassTwo);
glBindVertexArray(g_vaoPassTwo);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesPassTwoVBO);
// First 0 is the location = 0. See shader source
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
// Enable location = 0
glEnableVertexAttribArray(0);
//
glActiveTexture(GL_TEXTURE0);
glUniform1i(g_heightMapTexturePassTwoLocation, 0);
glBindTexture(GL_TEXTURE_RECTANGLE, g_heightMapTexture);
glActiveTexture(GL_TEXTURE1);
glUniform1i(g_colorMapTexturePassTwoLocation, 1);
glBindTexture(GL_TEXTURE_2D, g_colorMapTexture);
glActiveTexture(GL_TEXTURE2);
glUniform1i(g_normalMapTexturePassTwoLocation, 2);
glBindTexture(GL_TEXTURE_RECTANGLE, g_normalMapTexture);
//
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glPatchParameteri(GL_PATCH_VERTICES, 4);
return GLUS_TRUE;
}
bool glWindow::ResetGL () {
if (m_resetGLMode == RGM_RECREATEWINDOW) {
RecreateWindow (m_fullScreen, m_border, m_width, m_height, m_bpp, m_stencil, m_title, m_allowResizing, m_fitToWorkArea);
return true;
}
else if (m_resetGLMode == RGM_RECREATECONTEXT) {
RecreateGLContext ();
return true;
}
// Setup OpenGL defaults.
// This should reset as much as possible back to the initial state of OpenGL.
// Exceptions:
// * Projection matrix is initialised to a perspective transform
// End current gl block
try { glEnd (); } catch (...) { ; }
m_dontPaint = false;
// Intialise matrices
try { glMatrixMode (GL_PROJECTION); ClearGLMatrix (); } catch (...) { ; }
try { glMatrixMode (GL_TEXTURE); ClearGLMatrix (); } catch (...) { ; }
try { glMatrixMode (GL_MODELVIEW); ClearGLMatrix (); } catch (...) { ; }
// Initialise state
int i;
try { glColor4f (1, 1, 1, 1); } catch (...) { ; }
try { glIndexi (1); } catch (...) { ; }
try { glTexCoord4f (0, 0, 0, 1); } catch (...) { ; }
try { glNormal3f (0, 0, 1); } catch (...) { ; }
// try { glRasterPos4f (0, 0, 0, 1); } catch (...) { ; }
try { glEdgeFlag (GL_TRUE); } catch (...) { ; }
try { glDisable (GL_VERTEX_ARRAY); } catch (...) { ; }
try { glDisable (GL_NORMAL_ARRAY); } catch (...) { ; }
try { glDisable (GL_COLOR_ARRAY); } catch (...) { ; }
try { glDisable (GL_INDEX_ARRAY); } catch (...) { ; }
try { glDisable (GL_TEXTURE_COORD_ARRAY); } catch (...) { ; }
try { glDisable (GL_EDGE_FLAG_ARRAY); } catch (...) { ; }
try { glDepthRange (0, 1); } catch (...) { ; }
try { glDisable (GL_NORMALIZE); } catch (...) { ; }
for (i = 0; i < GL_MAX_CLIP_PLANES; i++)
try { glDisable (GL_CLIP_PLANE0 + i); } catch (...) { ; }
GLfloat fog[] = {0, 0, 0, 0};
try { glFogfv (GL_FOG_COLOR, fog); } catch (...) { ; }
try { glFogi (GL_FOG_INDEX, 0); } catch (...) { ; }
try { glFogf (GL_FOG_DENSITY, 1.0); } catch (...) { ; }
try { glFogf (GL_FOG_START, 0.0); } catch (...) { ; }
try { glFogf (GL_FOG_END, 1.0); } catch (...) { ; }
try { glFogi (GL_FOG_MODE, GL_EXP); } catch (...) { ; }
try { glDisable (GL_FOG); } catch (...) { ; }
try { glShadeModel (GL_SMOOTH); } catch (...) { ; }
try { glDisable (GL_LIGHTING); } catch (...) { ; }
try { glDisable (GL_COLOR_MATERIAL); } catch (...) { ; }
try { glColorMaterial (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE); } catch (...) { ; }
GLfloat ambient[] = { 0.2, 0.2, 0.2, 1.0 },
diffuse[] = { 0.8, 0.8, 0.8, 1.0 },
specular[] = { 0.0, 0.0, 0.0, 1.0 },
emission[] = { 0.0, 0.0, 0.0, 1.0 },
shininess[] = { 0.0 };
try { glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT, ambient); } catch (...) { ; }
try { glMaterialfv (GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse); } catch (...) { ; }
try { glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, specular); } catch (...) { ; }
try { glMaterialfv (GL_FRONT_AND_BACK, GL_EMISSION, emission); } catch (...) { ; }
try { glMaterialfv (GL_FRONT_AND_BACK, GL_SHININESS, shininess); } catch (...) { ; }
try { glLightModelfv (GL_LIGHT_MODEL_AMBIENT, ambient); } catch (...) { ; }
try { glLightModeli (GL_LIGHT_MODEL_LOCAL_VIEWER, GL_FALSE); } catch (...) { ; }
try { glLightModeli (GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE); } catch (...) { ; }
GLfloat lambient[] = { 0.0, 0.0, 0.0, 1.0 },
ldiffuse0[] = { 1.0, 1.0, 1.0, 1.0 },
ldiffuse1[] = { 0.0, 0.0, 0.0, 1.0 },
lspecular0[] = { 1.0, 1.0, 1.0, 1.0 },
lspecular1[] = { 0.0, 0.0, 0.0, 1.0 },
lposition[] = { 0.0, 0.0, 1.0, 0.0 };
for (i = 0; i < 8; i++) {
try { glLightfv (GL_LIGHT0 + i, GL_AMBIENT, lambient); } catch (...) { ; }
try { glLightfv (GL_LIGHT0 + i, GL_DIFFUSE, i == 0 ? ldiffuse0 : ldiffuse1); } catch (...) { ; }
try { glLightfv (GL_LIGHT0 + i, GL_SPECULAR, i == 0 ? lspecular0 : lspecular1); } catch (...) { ; }
try { glLightfv (GL_LIGHT0 + i, GL_POSITION, lposition); } catch (...) { ; }
try { glLightf (GL_LIGHT0 + i, GL_SPOT_EXPONENT, 0.0); } catch (...) { ; }
try { glLightf (GL_LIGHT0 + i, GL_CONSTANT_ATTENUATION, 1.0); } catch (...) { ; }
try { glLightf (GL_LIGHT0 + i, GL_LINEAR_ATTENUATION, 0.0); } catch (...) { ; }
try { glLightf (GL_LIGHT0 + i, GL_QUADRATIC_ATTENUATION, 0.0); } catch (...) { ; }
try { glDisable (GL_LIGHT0 + i); } catch (...) { ; }
}
try { glPointSize (1.0); } catch (...) { ; }
try { glDisable (GL_POINT_SMOOTH); } catch (...) { ; }
try { glLineWidth (1.0); } catch (...) { ; }
try { glDisable (GL_LINE_SMOOTH); } catch (...) { ; }
try { glLineStipple (1, 0xffff); } catch (...) { ; }
try { glDisable (GL_LINE_STIPPLE); } catch (...) { ; }
try { glDisable (GL_CULL_FACE); } catch (...) { ; }
try { glCullFace (GL_BACK); } catch (...) { ; }
try { glFrontFace (GL_CCW); } catch (...) { ; }
try { glDisable (GL_POLYGON_SMOOTH); } catch (...) { ; }
try { glPolygonMode (GL_FRONT_AND_BACK, GL_FILL); } catch (...) { ; }
try { glDisable (GL_TEXTURE_1D); } catch (...) { ; }
try { glDisable (GL_TEXTURE_2D); } catch (...) { ; }
try { glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); } catch (...) { ; }
try { glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); } catch (...) { ; }
try { glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); } catch (...) { ; }
try { glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); } catch (...) { ; }
GLfloat texBorder[] = {0, 0, 0, 0};
try { glTexParameterfv (GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, texBorder); } catch (...) { ; }
try { glDisable (GL_TEXTURE_GEN_T); } catch (...) { ; }
try { glDisable (GL_TEXTURE_GEN_S); } catch (...) { ; }
try { glDisable (GL_TEXTURE_GEN_R); } catch (...) { ; }
try { glDisable (GL_TEXTURE_GEN_Q); } catch (...) { ; }
for (i = 0; i < 4; i++) {
GLenum coord;
switch (i) {
case 0: coord = GL_T; break;
case 1: coord = GL_S; break;
case 2: coord = GL_R; break;
case 3: coord = GL_Q; break;
}
try { glTexGeni (coord, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); } catch (...) { ; }
}
try { glDisable (GL_SCISSOR_TEST); } catch (...) { ; }
try { glDisable (GL_ALPHA_TEST); } catch (...) { ; }
try { glAlphaFunc (GL_ALWAYS, 0); } catch (...) { ; }
try { glDisable (GL_STENCIL_TEST); } catch (...) { ; }
try { glStencilFunc (GL_ALWAYS, 0, 0xffffffff); } catch (...) { ; }
try { glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP); } catch (...) { ; }
try { glDisable (GL_DEPTH_TEST); } catch (...) { ; }
try { glDepthFunc (GL_LESS); } catch (...) { ; }
try { glDisable (GL_BLEND); } catch (...) { ; }
try { glBlendFunc (GL_ONE, GL_ZERO); } catch (...) { ; }
try { glDrawBuffer (GL_BACK); } catch (...) { ; }
try { glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); } catch (...) { ; }
try { glDepthMask (GL_TRUE); } catch (...) { ; }
try { glClearAccum (0, 0, 0, 0); } catch (...) { ; }
try { glClearColor (0, 0, 0, 0); } catch (...) { ; }
try { glClearDepth (1); } catch (...) { ; }
try { glClearIndex (0); } catch (...) { ; }
try { glClearStencil (0); } catch (...) { ; }
try { glPixelStorei (GL_PACK_SWAP_BYTES, GL_FALSE); } catch (...) { ; }
try { glPixelStorei (GL_PACK_LSB_FIRST, GL_FALSE); } catch (...) { ; }
try { glPixelStoref (GL_PACK_ROW_LENGTH, 0); } catch (...) { ; }
try { glPixelStoref (GL_PACK_SKIP_PIXELS, 0); } catch (...) { ; }
try { glPixelStorei (GL_PACK_ALIGNMENT, 4); } catch (...) { ; }
try { glPixelStorei (GL_UNPACK_SWAP_BYTES, GL_FALSE); } catch (...) { ; }
try { glPixelStorei (GL_UNPACK_LSB_FIRST, GL_FALSE); } catch (...) { ; }
try { glPixelStoref (GL_UNPACK_ROW_LENGTH, 0); } catch (...) { ; }
try { glPixelStoref (GL_UNPACK_SKIP_PIXELS, 0); } catch (...) { ; }
try { glPixelStorei (GL_UNPACK_ALIGNMENT, 4); } catch (...) { ; }
try { glPixelTransferi (GL_MAP_COLOR, GL_FALSE); } catch (...) { ; }
try { glPixelTransferi (GL_MAP_STENCIL, GL_FALSE); } catch (...) { ; }
try { glPixelTransferi (GL_INDEX_SHIFT, 0); } catch (...) { ; }
try { glPixelTransferi (GL_INDEX_OFFSET, 0); } catch (...) { ; }
try { glPixelTransferf (GL_RED_SCALE, 1.0); } catch (...) { ; }
try { glPixelTransferf (GL_GREEN_SCALE, 1.0); } catch (...) { ; }
try { glPixelTransferf (GL_BLUE_SCALE, 1.0); } catch (...) { ; }
try { glPixelTransferf (GL_ALPHA_SCALE, 1.0); } catch (...) { ; }
try { glPixelTransferf (GL_DEPTH_SCALE, 1.0); } catch (...) { ; }
try { glPixelTransferf (GL_RED_BIAS, 0.0); } catch (...) { ; }
try { glPixelTransferf (GL_GREEN_BIAS, 0.0); } catch (...) { ; }
try { glPixelTransferf (GL_BLUE_BIAS, 0.0); } catch (...) { ; }
try { glPixelTransferf (GL_ALPHA_BIAS, 0.0); } catch (...) { ; }
try { glPixelTransferf (GL_DEPTH_BIAS, 0.0); } catch (...) { ; }
try { glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_DONT_CARE); } catch (...) { ; }
try { glHint (GL_POINT_SMOOTH_HINT, GL_DONT_CARE); } catch (...) { ; }
try { glHint (GL_LINE_SMOOTH_HINT, GL_DONT_CARE); } catch (...) { ; }
try { glHint (GL_POLYGON_SMOOTH_HINT, GL_DONT_CARE); } catch (...) { ; }
try { glHint (GL_FOG_HINT, GL_DONT_CARE); } catch (...) { ; }
// Multitexturing
if (ExtensionSupported ("GL_ARB_multitexture")) {
// Disable texturing for all texture units
int units;
try { glGetIntegerv (GL_MAX_TEXTURE_UNITS_ARB, &units); } catch (...) { ; }
for (int i = 0; i < units; i++) {
if (glActiveTexture != NULL)
glActiveTexture (GL_TEXTURE0_ARB + i);
try { glDisable (GL_TEXTURE_2D); } catch (...) { ; }
try { glDisable (GL_TEXTURE_1D); } catch (...) { ; }
if (i == 0) try { glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); } catch (...) { ; }
else try { glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND); } catch (...) { ; }
}
if (glActiveTexture != NULL)
try { glActiveTexture (GL_TEXTURE0_ARB); } catch (...) { ; }
}
// Setup OpenGL defaults
OpenGLDefaults ();
return TRUE; // Initialization Went OK
}
//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);*/
}
void GraphicsWindow::Paint(void) {
int i;
havePainted = true;
int w, h;
GetGraphicsWindowSize(&w, &h);
width = w; height = h;
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glScaled(scale*2.0/w, scale*2.0/h, scale*1.0/30000);
double mat[16];
// Last thing before display is to apply the perspective
double clp = SS.CameraTangent()*scale;
MakeMatrix(mat, 1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
0, 0, clp, 1);
glMultMatrixd(mat);
// Before that, we apply the rotation
Vector n = projUp.Cross(projRight);
MakeMatrix(mat, projRight.x, projRight.y, projRight.z, 0,
projUp.x, projUp.y, projUp.z, 0,
n.x, n.y, n.z, 0,
0, 0, 0, 1);
glMultMatrixd(mat);
// And before that, the translation
MakeMatrix(mat, 1, 0, 0, offset.x,
0, 1, 0, offset.y,
0, 0, 1, offset.z,
0, 0, 0, 1);
glMultMatrixd(mat);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glShadeModel(GL_SMOOTH);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
glEnable(GL_LINE_SMOOTH);
// don't enable GL_POLYGON_SMOOTH; that looks ugly on some graphics cards,
// drawn with leaks in the mesh
glEnable(GL_POLYGON_OFFSET_LINE);
glEnable(GL_POLYGON_OFFSET_FILL);
glEnable(GL_DEPTH_TEST);
glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
glEnable(GL_NORMALIZE);
// At the same depth, we want later lines drawn over earlier.
glDepthFunc(GL_LEQUAL);
if(SS.AllGroupsOkay()) {
glClearColor(REDf(SS.backgroundColor),
GREENf(SS.backgroundColor),
BLUEf(SS.backgroundColor), 1.0f);
} else {
// Draw a different background whenever we're having solve problems.
DWORD rgb = Style::Color(Style::DRAW_ERROR);
glClearColor(0.4f*REDf(rgb), 0.4f*GREENf(rgb), 0.4f*BLUEf(rgb), 1.0f);
// And show the text window, which has info to debug it
ForceTextWindowShown();
}
glClear(GL_COLOR_BUFFER_BIT);
glClearDepth(1.0);
glClear(GL_DEPTH_BUFFER_BIT);
if(SS.bgImage.fromFile) {
// If a background image is loaded, then we draw it now as a texture.
// This handles the resizing for us nicely.
glBindTexture(GL_TEXTURE_2D, TEXTURE_BACKGROUND_IMG);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
SS.bgImage.rw, SS.bgImage.rh,
0,
GL_RGB, GL_UNSIGNED_BYTE,
SS.bgImage.fromFile);
double tw = ((double)SS.bgImage.w) / SS.bgImage.rw,
th = ((double)SS.bgImage.h) / SS.bgImage.rh;
double mmw = SS.bgImage.w / SS.bgImage.scale,
mmh = SS.bgImage.h / SS.bgImage.scale;
Vector origin = SS.bgImage.origin;
origin = origin.DotInToCsys(projRight, projUp, n);
// Place the depth of our origin at the point that corresponds to
// w = 1, so that it's unaffected by perspective.
origin.z = (offset.ScaledBy(-1)).Dot(n);
origin = origin.ScaleOutOfCsys(projRight, projUp, n);
// Place the background at the very back of the Z order, though, by
// mucking with the depth range.
glDepthRange(1, 1);
glEnable(GL_TEXTURE_2D);
glBegin(GL_QUADS);
glTexCoord2d(0, 0);
glxVertex3v(origin);
glTexCoord2d(0, th);
glxVertex3v(origin.Plus(projUp.ScaledBy(mmh)));
glTexCoord2d(tw, th);
glxVertex3v(origin.Plus(projRight.ScaledBy(mmw).Plus(
projUp. ScaledBy(mmh))));
glTexCoord2d(tw, 0);
glxVertex3v(origin.Plus(projRight.ScaledBy(mmw)));
glEnd();
glDisable(GL_TEXTURE_2D);
}
glxDepthRangeOffset(0);
// Nasty case when we're reloading the imported files; could be that
// we get an error, so a dialog pops up, and a message loop starts, and
// we have to get called to paint ourselves. If the sketch is screwed
// up, then we could trigger an oops trying to draw.
if(!SS.allConsistent) return;
// Let's use two lights, at the user-specified locations
GLfloat f;
glEnable(GL_LIGHT0);
f = (GLfloat)SS.lightIntensity[0];
GLfloat li0[] = { f, f, f, 1.0f };
glLightfv(GL_LIGHT0, GL_DIFFUSE, li0);
glLightfv(GL_LIGHT0, GL_SPECULAR, li0);
glEnable(GL_LIGHT1);
f = (GLfloat)SS.lightIntensity[1];
GLfloat li1[] = { f, f, f, 1.0f };
glLightfv(GL_LIGHT1, GL_DIFFUSE, li1);
glLightfv(GL_LIGHT1, GL_SPECULAR, li1);
Vector ld;
ld = VectorFromProjs(SS.lightDir[0]);
GLfloat ld0[4] = { (GLfloat)ld.x, (GLfloat)ld.y, (GLfloat)ld.z, 0 };
glLightfv(GL_LIGHT0, GL_POSITION, ld0);
ld = VectorFromProjs(SS.lightDir[1]);
GLfloat ld1[4] = { (GLfloat)ld.x, (GLfloat)ld.y, (GLfloat)ld.z, 0 };
glLightfv(GL_LIGHT1, GL_POSITION, ld1);
if(SS.drawBackFaces) {
// For debugging, draw the backs of the triangles in red, so that we
// notice when a shell is open
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, 1);
} else {
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, 0);
}
GLfloat ambient[4] = { (float)SS.ambientIntensity,
(float)SS.ambientIntensity,
(float)SS.ambientIntensity, 1 };
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
glxUnlockColor();
if(showSnapGrid && LockedInWorkplane()) {
hEntity he = ActiveWorkplane();
EntityBase *wrkpl = SK.GetEntity(he),
*norm = wrkpl->Normal();
Vector wu, wv, wn, wp;
wp = SK.GetEntity(wrkpl->point[0])->PointGetNum();
wu = norm->NormalU();
wv = norm->NormalV();
wn = norm->NormalN();
double g = SS.gridSpacing;
double umin = VERY_POSITIVE, umax = VERY_NEGATIVE,
vmin = VERY_POSITIVE, vmax = VERY_NEGATIVE;
int a;
for(a = 0; a < 4; a++) {
// Ideally, we would just do +/- half the width and height; but
// allow some extra slop for rounding.
Vector horiz = projRight.ScaledBy((0.6*width)/scale + 2*g),
vert = projUp. ScaledBy((0.6*height)/scale + 2*g);
if(a == 2 || a == 3) horiz = horiz.ScaledBy(-1);
if(a == 1 || a == 3) vert = vert. ScaledBy(-1);
Vector tp = horiz.Plus(vert).Minus(offset);
// Project the point into our grid plane, normal to the screen
// (not to the grid plane). If the plane is on edge then this is
// impossible so don't try to draw the grid.
bool parallel;
Vector tpp = Vector::AtIntersectionOfPlaneAndLine(
wn, wn.Dot(wp),
tp, tp.Plus(n),
¶llel);
if(parallel) goto nogrid;
tpp = tpp.Minus(wp);
double uu = tpp.Dot(wu),
vv = tpp.Dot(wv);
umin = min(uu, umin);
umax = max(uu, umax);
vmin = min(vv, vmin);
vmax = max(vv, vmax);
}
int i, j, i0, i1, j0, j1;
i0 = (int)(umin / g);
i1 = (int)(umax / g);
j0 = (int)(vmin / g);
j1 = (int)(vmax / g);
if(i0 > i1 || i1 - i0 > 400) goto nogrid;
if(j0 > j1 || j1 - j0 > 400) goto nogrid;
glLineWidth(1);
glxColorRGBa(Style::Color(Style::DATUM), 0.3);
glBegin(GL_LINES);
for(i = i0 + 1; i < i1; i++) {
glxVertex3v(wp.Plus(wu.ScaledBy(i*g)).Plus(wv.ScaledBy(j0*g)));
glxVertex3v(wp.Plus(wu.ScaledBy(i*g)).Plus(wv.ScaledBy(j1*g)));
}
for(j = j0 + 1; j < j1; j++) {
glxVertex3v(wp.Plus(wu.ScaledBy(i0*g)).Plus(wv.ScaledBy(j*g)));
glxVertex3v(wp.Plus(wu.ScaledBy(i1*g)).Plus(wv.ScaledBy(j*g)));
}
glEnd();
// Clear the depth buffer, so that the grid is at the very back of
// the Z order.
glClear(GL_DEPTH_BUFFER_BIT);
nogrid:;
}
// Draw the active group; this does stuff like the mesh and edges.
(SK.GetGroup(activeGroup))->Draw();
// Now draw the entities
if(showHdnLines) glDisable(GL_DEPTH_TEST);
Entity::DrawAll();
// Draw filled paths in all groups, when those filled paths were requested
// specially by assigning a style with a fill color, or when the filled
// paths are just being filled by default. This should go last, to make
// the transparency work.
Group *g;
for(g = SK.group.First(); g; g = SK.group.NextAfter(g)) {
if(!(g->IsVisible())) continue;
g->DrawFilledPaths();
}
glDisable(GL_DEPTH_TEST);
// Draw the constraints
for(i = 0; i < SK.constraint.n; i++) {
SK.constraint.elem[i].Draw();
}
// Draw the traced path, if one exists
glLineWidth(Style::Width(Style::ANALYZE));
glxColorRGB(Style::Color(Style::ANALYZE));
SContour *sc = &(SS.traced.path);
glBegin(GL_LINE_STRIP);
for(i = 0; i < sc->l.n; i++) {
glxVertex3v(sc->l.elem[i].p);
}
glEnd();
// And the naked edges, if the user did Analyze -> Show Naked Edges.
glLineWidth(Style::Width(Style::DRAW_ERROR));
glxColorRGB(Style::Color(Style::DRAW_ERROR));
glxDrawEdges(&(SS.nakedEdges), true);
// Then redraw whatever the mouse is hovering over, highlighted.
glDisable(GL_DEPTH_TEST);
glxLockColorTo(Style::Color(Style::HOVERED));
hover.Draw();
// And finally draw the selection, same mechanism.
glxLockColorTo(Style::Color(Style::SELECTED));
for(Selection *s = selection.First(); s; s = selection.NextAfter(s)) {
s->Draw();
}
glxUnlockColor();
// If a marquee selection is in progress, then draw the selection
// rectangle, as an outline and a transparent fill.
if(pending.operation == DRAGGING_MARQUEE) {
Point2d begin = ProjectPoint(orig.marqueePoint);
double xmin = min(orig.mouse.x, begin.x),
xmax = max(orig.mouse.x, begin.x),
ymin = min(orig.mouse.y, begin.y),
ymax = max(orig.mouse.y, begin.y);
Vector tl = UnProjectPoint(Point2d::From(xmin, ymin)),
tr = UnProjectPoint(Point2d::From(xmax, ymin)),
br = UnProjectPoint(Point2d::From(xmax, ymax)),
bl = UnProjectPoint(Point2d::From(xmin, ymax));
glLineWidth((GLfloat)1.3);
glxColorRGB(Style::Color(Style::HOVERED));
glBegin(GL_LINE_LOOP);
glxVertex3v(tl);
glxVertex3v(tr);
glxVertex3v(br);
glxVertex3v(bl);
glEnd();
glxColorRGBa(Style::Color(Style::HOVERED), 0.10);
glBegin(GL_QUADS);
glxVertex3v(tl);
glxVertex3v(tr);
glxVertex3v(br);
glxVertex3v(bl);
glEnd();
}
// An extra line, used to indicate the origin when rotating within the
// plane of the monitor.
if(SS.extraLine.draw) {
glLineWidth(1);
glxLockColorTo(Style::Color(Style::DATUM));
glBegin(GL_LINES);
glxVertex3v(SS.extraLine.ptA);
glxVertex3v(SS.extraLine.ptB);
glEnd();
}
// A note to indicate the origin in the just-exported file.
if(SS.justExportedInfo.draw) {
glxColorRGB(Style::Color(Style::DATUM));
Vector p = SS.justExportedInfo.pt,
u = SS.justExportedInfo.u,
v = SS.justExportedInfo.v;
glLineWidth(1.5);
glBegin(GL_LINES);
glxVertex3v(p.Plus(u.WithMagnitude(-15/scale)));
glxVertex3v(p.Plus(u.WithMagnitude(30/scale)));
glxVertex3v(p.Plus(v.WithMagnitude(-15/scale)));
glxVertex3v(p.Plus(v.WithMagnitude(30/scale)));
glEnd();
glxWriteText("(x, y) = (0, 0) for file just exported",
DEFAULT_TEXT_HEIGHT,
p.Plus(u.ScaledBy(10/scale)).Plus(v.ScaledBy(10/scale)),
u, v, NULL, NULL);
glxWriteText("press Esc to clear this message",
DEFAULT_TEXT_HEIGHT,
p.Plus(u.ScaledBy(40/scale)).Plus(
v.ScaledBy(-(DEFAULT_TEXT_HEIGHT)/scale)),
u, v, NULL, NULL);
}
// And finally the toolbar.
if(SS.showToolbar) {
ToolbarDraw();
}
}
void EDA_3D_CANVAS::Redraw()
{
// SwapBuffer requires the window to be shown before calling
if( !IsShownOnScreen() )
return;
wxString err_messages;
WX_STRING_REPORTER errorReporter( &err_messages );
STATUS_TEXT_REPORTER activityReporter( Parent(), 0 );
// Display build time at the end of build
unsigned strtime = GetRunningMicroSecs();
SetCurrent( *m_glRC );
// Set the OpenGL viewport according to the client size of this canvas.
// This is done here rather than in a wxSizeEvent handler because our
// OpenGL rendering context (and thus viewport setting) is used with
// multiple canvases: If we updated the viewport in the wxSizeEvent
// handler, changing the size of one canvas causes a viewport setting that
// is wrong when next another canvas is repainted.
wxSize size = GetClientSize();
InitGL();
if( isRealisticMode() && isEnabled( FL_RENDER_SHADOWS ) )
{
generateFakeShadowsTextures( &errorReporter, &activityReporter );
}
// *MUST* be called *after* SetCurrent( ):
glViewport( 0, 0, size.x, size.y );
// clear color and depth buffers
glClearColor( 0.95, 0.95, 1.0, 1.0 );
glClearStencil( 0 );
glClearDepth( 1.0 );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
glShadeModel( GL_SMOOTH );
// Draw background
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glDisable( GL_LIGHTING );
glDisable( GL_COLOR_MATERIAL );
glDisable( GL_DEPTH_TEST );
glDisable( GL_TEXTURE_2D );
// Draw the background ( rectangle with color gradient)
glBegin( GL_QUADS );
SetGLColor( GetPrm3DVisu().m_BgColor_Top, 1.0 );
glVertex2f( -1.0, 1.0 ); // Top left corner
SetGLColor( GetPrm3DVisu().m_BgColor, 1.0 );
glVertex2f( -1.0,-1.0 ); // bottom left corner
glVertex2f( 1.0,-1.0 ); // bottom right corner
SetGLColor( GetPrm3DVisu().m_BgColor_Top, 1.0 );
glVertex2f( 1.0, 1.0 ); // top right corner
glEnd();
glEnable( GL_DEPTH_TEST );
// set viewing projection
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
#define MAX_VIEW_ANGLE 160.0 / 45.0
if( GetPrm3DVisu().m_Zoom > MAX_VIEW_ANGLE )
GetPrm3DVisu().m_Zoom = MAX_VIEW_ANGLE;
if( Parent()->ModeIsOrtho() )
{
// OrthoReductionFactor is chosen to provide roughly the same size as
// Perspective View
const double orthoReductionFactor = 400 / GetPrm3DVisu().m_Zoom;
// Initialize Projection Matrix for Ortographic View
glOrtho( -size.x / orthoReductionFactor, size.x / orthoReductionFactor,
-size.y / orthoReductionFactor, size.y / orthoReductionFactor, 1, 100 );
}
else
{
// Ratio width / height of the window display
double ratio_HV = (double) size.x / size.y;
// Initialize Projection Matrix for Perspective View
gluPerspective( 45.0f * GetPrm3DVisu().m_Zoom, ratio_HV, 1, 100 );
}
// position viewer
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glTranslatef( 0.0f, 0.0f, -(m_ZBottom + m_ZTop) / 2.0f );
// Setup light sources:
SetLights();
CheckGLError( __FILE__, __LINE__ );
glMatrixMode( GL_MODELVIEW ); // position viewer
// transformations
GLfloat mat[4][4];
// Translate motion first, so rotations don't mess up the orientation...
glTranslatef( m_draw3dOffset.x, m_draw3dOffset.y, 0.0F );
build_rotmatrix( mat, GetPrm3DVisu().m_Quat );
glMultMatrixf( &mat[0][0] );
glRotatef( GetPrm3DVisu().m_Rot[0], 1.0, 0.0, 0.0 );
glRotatef( GetPrm3DVisu().m_Rot[1], 0.0, 1.0, 0.0 );
glRotatef( GetPrm3DVisu().m_Rot[2], 0.0, 0.0, 1.0 );
if( ! m_glLists[GL_ID_BOARD] || ! m_glLists[GL_ID_TECH_LAYERS] )
CreateDrawGL_List( &errorReporter, &activityReporter );
if( isEnabled( FL_AXIS ) && m_glLists[GL_ID_AXIS] )
glCallList( m_glLists[GL_ID_AXIS] );
// move the board in order to draw it with its center at 0,0 3D coordinates
glTranslatef( -GetPrm3DVisu().m_BoardPos.x * GetPrm3DVisu().m_BiuTo3Dunits,
-GetPrm3DVisu().m_BoardPos.y * GetPrm3DVisu().m_BiuTo3Dunits,
0.0f );
if( isEnabled( FL_MODULE ) )
{
if( ! m_glLists[GL_ID_3DSHAPES_SOLID_FRONT] )
CreateDrawGL_List( &errorReporter, &activityReporter );
}
glEnable( GL_LIGHTING );
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
if( isRealisticMode() && isEnabled( FL_RENDER_TEXTURES ) )
glEnable( GL_TEXTURE_2D );
else
glDisable( GL_TEXTURE_2D );
// Set material for the board
glEnable( GL_COLOR_MATERIAL );
SetOpenGlDefaultMaterial();
//glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, FALSE );
// Board Body
GLint shininess_value = 32;
glMateriali( GL_FRONT_AND_BACK, GL_SHININESS, shininess_value );
if( isEnabled( FL_SHOW_BOARD_BODY ) )
{
if( m_glLists[GL_ID_BODY] )
{
glCallList( m_glLists[GL_ID_BODY] );
}
}
// Board
// specify material parameters for the lighting model.
shininess_value = 52;
glMateriali( GL_FRONT_AND_BACK, GL_SHININESS, shininess_value );
glm::vec4 specular( GetPrm3DVisu().m_CopperColor.m_Red * 0.20f,
GetPrm3DVisu().m_CopperColor.m_Green * 0.20f,
GetPrm3DVisu().m_CopperColor.m_Blue * 0.20f, 1.0f );
glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, &specular.x );
if( m_glLists[GL_ID_BOARD] )
{
glCallList( m_glLists[GL_ID_BOARD] );
}
// Tech layers
shininess_value = 32;
glMateriali( GL_FRONT_AND_BACK, GL_SHININESS, shininess_value );
glm::vec4 specularTech( 0.0f, 0.0f, 0.0f, 1.0f );
glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, &specularTech.x );
if( m_glLists[GL_ID_TECH_LAYERS] )
{
glCallList( m_glLists[GL_ID_TECH_LAYERS] );
}
if( isEnabled( FL_COMMENTS ) || isEnabled( FL_ECO ) )
{
if( ! m_glLists[GL_ID_AUX_LAYERS] )
CreateDrawGL_List( &errorReporter, &activityReporter );
glCallList( m_glLists[GL_ID_AUX_LAYERS] );
}
//glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, TRUE );
// Draw Component Shadow
if( isEnabled( FL_MODULE ) && isRealisticMode() &&
isEnabled( FL_RENDER_SHADOWS ) )
{
glEnable( GL_CULL_FACE );
glDisable( GL_DEPTH_TEST );
glEnable( GL_COLOR_MATERIAL ) ;
SetOpenGlDefaultMaterial();
glColor4f( 1.0f, 1.0f, 1.0f, 1.0f );
glEnable( GL_TEXTURE_2D );
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
if( m_glLists[GL_ID_SHADOW_FRONT] )
{
glBindTexture( GL_TEXTURE_2D, m_text_fake_shadow_front );
glCallList( m_glLists[GL_ID_SHADOW_FRONT] );
}
if( m_glLists[GL_ID_SHADOW_BACK] )
{
glBindTexture( GL_TEXTURE_2D, m_text_fake_shadow_back );
glCallList( m_glLists[GL_ID_SHADOW_BACK] );
}
glColor4f( 1.0f, 1.0f, 1.0f, 1.0f );
glEnable( GL_DEPTH_TEST );
glDisable( GL_TEXTURE_2D );
glDisable( GL_CULL_FACE );
}
glEnable( GL_COLOR_MATERIAL );
SetOpenGlDefaultMaterial();
glDisable( GL_BLEND );
// Draw Solid Shapes
if( isEnabled( FL_MODULE ) )
{
if( ! m_glLists[GL_ID_3DSHAPES_SOLID_FRONT] )
CreateDrawGL_List( &errorReporter, &activityReporter );
glCallList( m_glLists[GL_ID_3DSHAPES_SOLID_FRONT] );
}
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
// Grid uses transparency: draw it after all objects
if( isEnabled( FL_GRID ) )
{
if( ! m_glLists[GL_ID_GRID] )
CreateDrawGL_List( &errorReporter, &activityReporter );
glCallList( m_glLists[GL_ID_GRID] );
}
// Draw Board Shadow
if( isRealisticMode() && isEnabled( FL_RENDER_SHADOWS ) )
{
if( m_glLists[GL_ID_SHADOW_BOARD] )
{
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glColor4f( 1.0, 1.0, 1.0, 0.75f );
glEnable( GL_CULL_FACE );
glDisable( GL_COLOR_MATERIAL );
glEnable( GL_TEXTURE_2D );
glBindTexture( GL_TEXTURE_2D, m_text_fake_shadow_board );
glCallList( m_glLists[GL_ID_SHADOW_BOARD] );
glDisable( GL_CULL_FACE );
glDisable( GL_TEXTURE_2D );
}
}
// This list must be drawn last, because it contains the
// transparent gl objects, which should be drawn after all
// non transparent objects
if( isEnabled( FL_MODULE ) && m_glLists[GL_ID_3DSHAPES_TRANSP_FRONT] )
{
glEnable( GL_COLOR_MATERIAL );
SetOpenGlDefaultMaterial();
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glCallList( m_glLists[GL_ID_3DSHAPES_TRANSP_FRONT] );
}
// Debug bounding boxes
/*
glDisable( GL_BLEND );
glDisable( GL_COLOR_MATERIAL );
glDisable( GL_LIGHTING );
glColor4f( 1.0f, 0.0f, 1.0f, 1.0f );
m_fastAABBox_Shadow.GLdebug();
glColor4f( 0.0f, 1.0f, 1.0f, 1.0f );
m_boardAABBox.GLdebug();
*/
SwapBuffers();
// Show calculation time if some activity was reported
if( activityReporter.HasMessage() )
{
// Calculation time in seconds
double calculation_time = (double)( GetRunningMicroSecs() - strtime) / 1e6;
activityReporter.Report( wxString::Format( _( "Build time %.3f s" ),
calculation_time ) );
}
else
activityReporter.Report( wxEmptyString );
if( !err_messages.IsEmpty() )
wxLogMessage( err_messages );
}
/* Init the models */
void init(void){
/* Create the robot base */
Model* base = new_cube(ROBOT_X_ORIGIN, ROBOT_Y_ORIGIN, ROBOT_Z_ORIGIN, update_base);
models.push_back(base);
/* Create the lower arm */
Model* lower_arm = new_cube(ROBOT_X_ORIGIN, ROBOT_Y_ORIGIN, ROBOT_Z_ORIGIN, update_lower_arm);
models.push_back(lower_arm);
/* Create the upper arm */
Model* upper_arm = new_cube(ROBOT_X_ORIGIN, ROBOT_Y_ORIGIN, ROBOT_Z_ORIGIN, update_upper_arm);
models.push_back(upper_arm);
/* Create the first shapes */
for(int i=0;i<SHAPE_SIZE;i++){
Model* m = new_shape(i);
models.push_back(m);
shape_t s;
s.model = m;
shapes[i].push_back(s);
}
/* Create the second shapes */
for(int i=0;i<SHAPE_SIZE;i++){
Model* m = new_shape(i);
models.push_back(m);
shape_t s;
s.model = m;
shapes[i].push_back(s);
}
/* Update colors as random */
update_colors();
/* Select the hold and true shape */
hold_shape = shapes[0][0].model;
hold_shape->update = update_holded;
true_shape = shapes[0][1].model;
/* Init the all models */
for(list<Model*>::iterator i = models.begin();i != models.end();i++){
(*i)->point_init();
(*i)->apply_material(diffuse, ambient, specular, shininess);
(*i)->lightp = light_p;
}
/* Init the view matrix */
view = LookAt(eye_point, look_at_point, vec3(0.0,1.0,0.0));
view *= RotateX(ROTATE_X);
view *= RotateY(ROTATE_Y);
projection = Perspective(fovy, aspect, z_near, z_far);
/* Enable some features */
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glClearDepth(1.0);
glEnable(GL_MULTISAMPLE);
glHint(GL_MULTISAMPLE_FILTER_HINT_NV, GL_NICEST);
glEnable(GL_LINE_SMOOTH);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glClearColor(0, 0, 0, 0);
/* Init the clock */
past = clock();
}
void COGLGraphicsContext::UpdateFrame(bool swaponly)
{
status.gFrameCount++;
glFlush();
OPENGL_CHECK_ERRORS;
//glFinish();
//wglSwapIntervalEXT(0);
/*
if (debuggerPauseCount == countToPause)
{
static int iShotNum = 0;
// get width, height, allocate buffer to store image
int width = windowSetting.uDisplayWidth;
int height = windowSetting.uDisplayHeight;
printf("Saving debug images: width=%i height=%i\n", width, height);
short *buffer = (short *) malloc(((width+3)&~3)*(height+1)*4);
glReadBuffer( GL_FRONT );
// set up a BMGImage struct
struct BMGImageStruct img;
memset(&img, 0, sizeof(BMGImageStruct));
InitBMGImage(&img);
img.bits = (unsigned char *) buffer;
img.bits_per_pixel = 32;
img.height = height;
img.width = width;
img.scan_width = width * 4;
// store the RGB color image
char chFilename[64];
sprintf(chFilename, "dbg_rgb_%03i.png", iShotNum);
glReadPixels(0,0,width,height, GL_BGRA, GL_UNSIGNED_BYTE, buffer);
WritePNG(chFilename, img);
// store the Z buffer
sprintf(chFilename, "dbg_Z_%03i.png", iShotNum);
glReadPixels(0,0,width,height, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, buffer);
//img.bits_per_pixel = 16;
//img.scan_width = width * 2;
WritePNG(chFilename, img);
// dump a subset of the Z data
for (int y = 0; y < 480; y += 16)
{
for (int x = 0; x < 640; x+= 16)
printf("%4hx ", buffer[y*640 + x]);
printf("\n");
}
printf("\n");
// free memory and get out of here
free(buffer);
iShotNum++;
}
*/
// if emulator defined a render callback function, call it before buffer swap
if(renderCallback)
(*renderCallback)(status.bScreenIsDrawn);
CoreVideo_GL_SwapBuffers();
/*if(options.bShowFPS)
{
static unsigned int lastTick=0;
static int frames=0;
unsigned int nowTick = SDL_GetTicks();
frames++;
if(lastTick + 5000 <= nowTick)
{
char caption[200];
sprintf(caption, "%s v%i.%i.%i - %.3f VI/S", PLUGIN_NAME, VERSION_PRINTF_SPLIT(PLUGIN_VERSION), frames/5.0);
CoreVideo_SetCaption(caption);
frames = 0;
lastTick = nowTick;
}
}*/
glDepthMask(GL_TRUE);
OPENGL_CHECK_ERRORS;
glClearDepth(1.0f);
OPENGL_CHECK_ERRORS;
if( !g_curRomInfo.bForceScreenClear )
{
glClear(GL_DEPTH_BUFFER_BIT);
OPENGL_CHECK_ERRORS;
}
else
needCleanScene = true;
status.bScreenIsDrawn = false;
}
void CPreviewDlg::display_func(){
static bool init = false;
static timemeas_t tm;
static double realtime = 0.;
if(!init){
init = true;
TimeMeasStart(&tm);
}
double t1 = TimeMeasLap(&tm);
double rdt, dt;
/* if(g_fix_dt)
rdt = g_fix_dt;
else*/
rdt = (t1 - realtime);
realtime = t1;
dt = !init ? 0. : rdt < 1. ? rdt : 1.;
MotionPose *dnmv = main.dnmv;
/* if(main.dnmv){
if(fmod(realtime, .2) < .1){
dnmv->target = GetSrfName(main.selectbone);
}
else
dnmv->target = NULL;
}*/
glClearColor(0,0,0,0);
glClearDepth(1.);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslated(0,0,-dist);
gldMultQuat(viewrot);
/* grid draw */
glPushMatrix();
gldScaled(100.);
glBegin(GL_LINES);
for(int i = 0; i <= 16; i++){
glColor4ub(255,127,127,255);
glVertex3d(-8, 0, i - 8);
glVertex3d( 8, 0, i - 8);
glColor4ub(127,127,255,255);
glVertex3d(i - 8, 0, -8);
glVertex3d(i - 8, 0, 8);
}
glColor4ub(255,0,0,255);
glVertex3d(-100,0,0);
glVertex3d( 100,0,0);
glColor4ub(0,255,0,255);
glVertex3d(0,-100,0);
glVertex3d(0, 100,0);
glColor4ub(0,0,255,255);
glVertex3d(0,0,-100);
glVertex3d(0,0, 100);
glEnd();
glPopMatrix();
if(main.dnm){
glPushAttrib(GL_CURRENT_BIT | GL_LIGHTING_BIT | GL_POLYGON_BIT);
if(wireframe)
glPolygonMode(GL_FRONT, GL_LINE);
else
glPolygonMode(GL_FRONT, GL_FILL);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
{
int i;
GLfloat mat_specular[] = {0., 0., 0., 1.};
GLfloat mat_diffuse[] = { .5, .5, .5, 1.0 };
GLfloat mat_ambient_color[] = { 0.5, 0.5, 0.5, 1.0 };
GLfloat mat_shininess[] = { 50.0 };
GLfloat light_position[4] = { 1, 1, 1, 0.0 };
GLfloat light_ambient_color[] = { 0.5, 0.5, 0.5, 1.0 };
GLfloat light_diffuse[] = { 1., 1., 1., 1.0 };
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient_color);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glLightfv(GL_LIGHT0, GL_SPECULAR, mat_specular);
glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient_color);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
}
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glEnable(GL_NORMALIZE);
glEnable(GL_CULL_FACE);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
// DrawYSDNM_V(main.dnm, main.dnmv);
glPopAttrib();
/* if(boneview){
if(boneview == 2)
glDisable(GL_DEPTH_TEST);
glPushMatrix();
BoneYSDNM_V(main.dnm, main.dnmv);
glPopMatrix();
}*/
}
else if(main.model){
glPushAttrib(GL_CURRENT_BIT | GL_LIGHTING_BIT | GL_POLYGON_BIT);
if(wireframe)
glPolygonMode(GL_FRONT, GL_LINE);
else
glPolygonMode(GL_FRONT, GL_FILL);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
{
int i;
GLfloat mat_specular[] = {0., 0., 0., 1.};
GLfloat mat_diffuse[] = { .5, .5, .5, 1.0 };
GLfloat mat_ambient_color[] = { 0.5, 0.5, 0.5, 1.0 };
GLfloat mat_shininess[] = { 50.0 };
GLfloat light_position[4] = { 1, 1, 1, 0.0 };
GLfloat light_ambient_color[] = { 0.5, 0.5, 0.5, 1.0 };
GLfloat light_diffuse[] = { 1., 1., 1., 1.0 };
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient_color);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glLightfv(GL_LIGHT0, GL_SPECULAR, mat_specular);
glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient_color);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
}
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glEnable(GL_NORMALIZE);
glEnable(GL_CULL_FACE);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
// for(int i = 0; i < nsufs; i++){
// DrawSUF(sufs[i], SUF_ATR, NULL);
// }
// BoneMQO_V(sufs, bones, dnmv);
// DrawMQO_V(main.model, dnmv);
DrawMQOPose(main.model, dnmv);
glPopAttrib();
/* if(boneview){
if(boneview == 2)
glDisable(GL_DEPTH_TEST);
glPushMatrix();
glBegin(GL_LINES);
for(int i = 0; i < nsufs; i++){
glVertex3dv(bones[i]->parent ? bones[i]->parent->joint: Vec4d(0,0,0,0));
glVertex3dv(bones[i]->joint);
}
glEnd();
glPopMatrix();
}*/
}
if(main.dnm){
glDisable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslated(0,0,-.5);
ysdnm_t *dnm = main.dnm;
int selectbone = main.selectbone;
Motion *&motion = main.motion;
Motion *(&motions)[16] = main.motions;
int nmotions = main.nmotions, curmotion = main.curmotion;
double (&motion_time)[16] = main.motion_time;
glScaled(2. / g_width, 2. / g_height, 1.);
glColor4ub(0,255,0,255);
glRasterPos2d(-g_width / 2, -g_height / 2 + 32);
gldprintf("bone: %d", selectbone);
if(0 <= selectbone && selectbone < dnm->ns && dnm->s[selectbone]){
glRasterPos2d(-g_width / 2, -g_height / 2 + 16);
gldprintf("name: \"%s\" \"%s\"", dnm->s[selectbone]->name, dnm->s[selectbone]->pck->name);
}
const double (*pq)[7];
if(pq = (double (*)[7])FindBone(selectbone)){
glRasterPos2d(-g_width / 2, -g_height / 2 + 0);
gldprintf("rot: (%lg,%lg,%lg,%lg),(%lg,%lg,%lg)", (*pq)[0], (*pq)[1], (*pq)[2], (*pq)[3], (*pq)[4], (*pq)[5], (*pq)[6]);
}
/* if(motion && motion->kfl.size()){
glRasterPos2d(-g_width / 2, -g_height * 2 / 3);
gldprintf("mot: (%d)", &motion->getKeyframe(motion_time[curmotion]) - motion->kfl);
}*/
for(int n = 0; n < nmotions; n++) if(motions[n] && motions[n]->kfl.size()){
Motion *mot = motions[n];
double ttime = mot->totalTime();
glColor4ub(0,n == curmotion ? 255 : 127,0,255);
glBegin(GL_LINE_LOOP);
glVertex2d(-g_width / 2 * .8, -g_height / 2 * (.7 + .1 * n));
glVertex2d( g_width / 2 * .8, -g_height / 2 * (.7 + .1 * n));
glVertex2d( g_width / 2 * .8, -g_height / 2 * (.6 + .1 * n));
glVertex2d(-g_width / 2 * .8, -g_height / 2 * (.6 + .1 * n));
glEnd();
glBegin(GL_LINES);
double tsum = 0.;
for(int i = 0; i < mot->kfl.size(); i++){
tsum += mot->kfl[i].dt;
glVertex2d(-g_width / 2 * .8 + tsum * (g_width / 2 * 1.6) / ttime, -g_height / 2 * (.7 + .1 * n));
glVertex2d(-g_width / 2 * .8 + tsum * (g_width / 2 * 1.6) / ttime, -g_height / 2 * (.6 + .1 * n));
}
glColor4ub(255,255,0,255);
glVertex2d(-g_width / 2 * .8 + motion_time[n] * (g_width / 2 * 1.6) / ttime, -g_height / 2 * (.7 + .1 * n));
glVertex2d(-g_width / 2 * .8 + motion_time[n] * (g_width / 2 * 1.6) / ttime, -g_height / 2 * (.6 + .1 * n));
glEnd();
}
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
}
}
void RenderTexture::draw()
{
if( _autoDraw)
{
begin();
if (_clearFlags)
{
GLfloat oldClearColor[4] = {0.0f};
GLfloat oldDepthClearValue = 0.0f;
GLint oldStencilClearValue = 0;
// backup and set
if (_clearFlags & GL_COLOR_BUFFER_BIT)
{
glGetFloatv(GL_COLOR_CLEAR_VALUE, oldClearColor);
glClearColor(_clearColor.r, _clearColor.g, _clearColor.b, _clearColor.a);
}
if (_clearFlags & GL_DEPTH_BUFFER_BIT)
{
glGetFloatv(GL_DEPTH_CLEAR_VALUE, &oldDepthClearValue);
glClearDepth(_clearDepth);
}
if (_clearFlags & GL_STENCIL_BUFFER_BIT)
{
glGetIntegerv(GL_STENCIL_CLEAR_VALUE, &oldStencilClearValue);
glClearStencil(_clearStencil);
}
// clear
glClear(_clearFlags);
// restore
if (_clearFlags & GL_COLOR_BUFFER_BIT)
{
glClearColor(oldClearColor[0], oldClearColor[1], oldClearColor[2], oldClearColor[3]);
}
if (_clearFlags & GL_DEPTH_BUFFER_BIT)
{
glClearDepth(oldDepthClearValue);
}
if (_clearFlags & GL_STENCIL_BUFFER_BIT)
{
glClearStencil(oldStencilClearValue);
}
}
//! make sure all children are drawn
sortAllChildren();
Object *pElement;
CCARRAY_FOREACH(_children, pElement)
{
Node *child = static_cast<Node*>(pElement);
if (child != _sprite)
{
child->visit();
}
}
end();
}
/**
* Function for initialization.
*/
GLUSboolean init(GLUSvoid)
{
// Points of a cube.
GLfloat
points[] =
{ -0.5f, -0.5f, -0.5f, 1.0f, -0.5f, -0.5f, +0.5f, 1.0f, +0.5f, -0.5f, +0.5f, 1.0f, +0.5f, -0.5f, -0.5f, 1.0f, -0.5f, +0.5f, -0.5f, 1.0f, -0.5f, +0.5f, +0.5f, 1.0f, +0.5f, +0.5f, +0.5f, 1.0f, +0.5f, +0.5f, -0.5f, 1.0f, -0.5f, -0.5f, -0.5f, 1.0f, -0.5f, +0.5f, -0.5f, 1.0f, +0.5f, +0.5f, -0.5f, 1.0f, +0.5f, -0.5f, -0.5f, 1.0f, -0.5f, -0.5f, +0.5f, 1.0f, -0.5f, +0.5f, +0.5f, 1.0f, +0.5f, +0.5f, +0.5f, 1.0f, +0.5f, -0.5f, +0.5f, 1.0f, -0.5f, -0.5f, -0.5f, 1.0f, -0.5f, -0.5f, +0.5f, 1.0f, -0.5f, +0.5f, +0.5f, 1.0f, -0.5f, +0.5f, -0.5f, 1.0f, +0.5f, -0.5f, -0.5f, 1.0f, +0.5f, -0.5f, +0.5f, 1.0f, +0.5f, +0.5f, +0.5f, 1.0f, +0.5f, +0.5f, -0.5f, 1.0f };
// Normals of a cube.
GLfloat
normals[] =
{ +0.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f };
// The associated indices.
GLuint indices[] = { 0, 2, 1, 0, 3, 2, 4, 5, 6, 4, 6, 7, 8, 9, 10, 8, 10, 11, 12, 15, 14, 12, 14, 13, 16, 17, 18, 16, 18, 19, 20, 23, 22, 20, 22, 21 };
GLUStgaimage image;
GLUStextfile vertexSource;
GLUStextfile fragmentSource;
// Load the source of the vertex shader.
glusLoadTextFile("../src/Example07/Vertex.vs", &vertexSource);
// Load the source of the fragment shader.
glusLoadTextFile("../src/Example07/Fragment.fs", &fragmentSource);
// Build and ...
glusBuildProgram(&g_program, (const GLUSchar**) &vertexSource.text, 0, 0, 0, (const GLUSchar**) &fragmentSource.text);
// Destroy the text resource
glusDestroyTextFile(&vertexSource);
// Destroy the text resource
glusDestroyTextFile(&fragmentSource);
// ToDo:
glGenVertexArrays(1, &g_vao);
// ToDo:
glBindVertexArray(g_vao);
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_projectionLocation = glGetUniformLocation(g_program.program, "projectionMatrix");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_modelViewLocation = glGetUniformLocation(g_program.program, "modelViewMatrix");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_inverseCameraLocation = glGetUniformLocation(g_program.program, "inverseCameraMatrix");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_cubemapLocation = glGetUniformLocation(g_program.program, "cubemap");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetAttribLocation.xml
g_vertexLocation = glGetAttribLocation(g_program.program, "vertex");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetAttribLocation.xml
g_normalLocation = glGetAttribLocation(g_program.program, "normal");
// http://www.opengl.org/sdk/docs/man/xhtml/glGenBuffers.xml
glGenBuffers(1, &g_vertices);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ARRAY_BUFFER, g_vertices);
// http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml
glBufferData(GL_ARRAY_BUFFER, 24 * 4 * sizeof(GLfloat), (GLfloat*) points, GL_STATIC_DRAW);
// http://www.opengl.org/sdk/docs/man/xhtml/glGenBuffers.xml
glGenBuffers(1, &g_normals);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ARRAY_BUFFER, g_normals);
// http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml
glBufferData(GL_ARRAY_BUFFER, 24 * 3 * sizeof(GLfloat), (GLfloat*) normals, GL_STATIC_DRAW);
// http://www.opengl.org/sdk/docs/man/xhtml/glGenBuffers.xml
glGenBuffers(1, &g_indices);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indices);
// http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml
glBufferData(GL_ELEMENT_ARRAY_BUFFER, 6 * 2 * 3 * sizeof(GLuint), (GLuint*) indices, GL_STATIC_DRAW);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/gentextures.html
glGenTextures(1, &g_cubemap);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/bindtexture.html
glBindTexture(GL_TEXTURE_CUBE_MAP, g_cubemap);
glusLoadTgaImage("cm_left.tga", &image);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
glusDestroyTgaImage(&image);
glusLoadTgaImage("cm_right.tga", &image);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html
glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
glusDestroyTgaImage(&image);
glusLoadTgaImage("cm_top.tga", &image);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
glusDestroyTgaImage(&image);
glusLoadTgaImage("cm_bottom.tga", &image);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html
glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
glusDestroyTgaImage(&image);
glusLoadTgaImage("cm_back.tga", &image);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
glusDestroyTgaImage(&image);
glusLoadTgaImage("cm_front.tga", &image);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html
glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
glusDestroyTgaImage(&image);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_REPEAT);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_REPEAT);
// http://www.opengl.org/sdk/docs/man/xhtml/glUseProgram.xml
glUseProgram(g_program.program);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ARRAY_BUFFER, g_vertices);
// http://www.opengl.org/sdk/docs/man/xhtml/glVertexAttribPointer.xml
glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
// http://www.opengl.org/sdk/docs/man/xhtml/glEnableVertexAttribArray.xml
glEnableVertexAttribArray(g_vertexLocation);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ARRAY_BUFFER, g_normals);
// http://www.opengl.org/sdk/docs/man/xhtml/glVertexAttribPointer.xml
glVertexAttribPointer(g_normalLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
// http://www.opengl.org/sdk/docs/man/xhtml/glEnableVertexAttribArray.xml
glEnableVertexAttribArray(g_normalLocation);
// http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml
glUniform1i(g_cubemapLocation, 0);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/clearcolor.html
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/cleardepth.html
glClearDepth(1.0f);
//http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/enable.html
glEnable( GL_DEPTH_TEST);
//http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/enable.html
glEnable( GL_CULL_FACE);
return GLUS_TRUE;
}
static void glfw_newwindow(char* name, int heigth, int width)
{
int major, minor, rev;
GLenum error;
GLuint shaders[2];
GLint data[4];
GLfloat vertexData[] = {
// X Y Z
-1.0f,-1.0f,-1.0f, 0.0f, 0.0f,
-1.0f, 1.0f,-1.0f, 0.0f, 1.0f,
1.0f,-1.0f,-1.0f, 1.0f, 0.0f,
1.0f,-1.0f,-1.0f, 1.0f, 0.0f,
-1.0f, 1.0f,-1.0f, 0.0f, 1.0f,
1.0f, 1.0f,-1.0f, 1.0f, 1.0f
};
glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE, GL_TRUE);
if(!glfwOpenWindow(width, heigth, 8, 8, 8, 8, 16, 0, GLFW_WINDOW))
printf("glfwOpenWindow failed. Can your hardware handle OpenGL 3.2?");
if(glewInit() != GLEW_OK)
printf("glewInit failed");
glShadeModel(GL_SMOOTH);
glClearColor(0.0f, 0.0f, 0.3f, 0.0f);
glClearDepth(1.0f); // Depth Buffer Setup
glEnable(GL_BLEND);
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
glEnable(GL_TEXTURE_2D);
glDepthFunc(GL_LEQUAL);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glAlphaFunc( GL_GREATER, 0 );
glEnable(GL_POLYGON_SMOOTH);
// print out some info about the graphics drivers
printf( "OpenGL version: %s \n", glGetString(GL_VERSION));
printf( "GLSL version: %s \n",glGetString(GL_SHADING_LANGUAGE_VERSION));
printf("Vendor: %s\n",glGetString(GL_VENDOR));
printf("Renderer: %s\n",glGetString(GL_RENDERER));
shaders[0] = ShaderCreateFromStr(GL_VERTEX_SHADER, vertexShader);
shaders[1] = ShaderCreateFromStr(GL_FRAGMENT_SHADER, fragmentShader);
program = ShaderCreateProgram(shaders, 2);
shaders[0] = ShaderCreateFromStr(GL_VERTEX_SHADER, vertexShader_gui);
shaders[1] = ShaderCreateFromStr(GL_FRAGMENT_SHADER, fragmentShader);
program_gui = ShaderCreateProgram(shaders, 2);
USE_PROGRAM(program);
error = glGetError();
if(error != GL_NO_ERROR)
printf( "OpenGL Error %d: %s\n", error, (const char*)glewGetErrorString(error));
/*glm::mat4 camera = glm::lookAt(glm::vec3(0,0,1), glm::vec3(0,0,0), glm::vec3(0,1,0));
ShaderSetUniform(ShaderGetUniform(program,"camera"), 1, glm::value_ptr(camera));
*/
glfwSetCamera( 0, 0, 1);
glm::mat4 projection = glm::perspective<float>(60.0, 800.0f/600, 0.01, 10.0);
ShaderSetUniform(ShaderGetUniform(currentProgram,"projection"), 1, glm::value_ptr(projection));
glm::mat4 rotation = glm::rotate(glm::mat4(), 0.0f, glm::vec3(0,1,0));
ShaderSetUniform(ShaderGetUniform(currentProgram,"model"),1, glm::value_ptr(rotation));
ShaderSetUniformInt(ShaderGetUniform(currentProgram,"debug"), 1);
ShaderSetUniform4f(ShaderGetUniform(currentProgram,"debugcolor"), 0.0, 0, 0, 0.0f);
USE_PROGRAM(0);
USE_PROGRAM(program_gui);
glfwSetCamera_ext( "projection", 0,0, 60);
rotation = glm::rotate(glm::mat4(), 0.0f, glm::vec3(0,1,0));
ShaderSetUniform(ShaderGetUniform(currentProgram,"model"),1, glm::value_ptr(rotation));
ShaderSetUniformInt(ShaderGetUniform(currentProgram,"debug"), 1);
ShaderSetUniform4f(ShaderGetUniform(currentProgram,"debugcolor"), 0.0, 0, 0, 0.0f);
glUseProgram(0);
glGenVertexArrays(1, &gVAO);
glBindVertexArray(gVAO);
// make and bind the VBO
glGenBuffers(1, &gVBO);
glBindBuffer(GL_ARRAY_BUFFER, gVBO);
// Put the three triangle verticies into the VBO
glBufferData(GL_ARRAY_BUFFER, sizeof(vertexData), vertexData, GL_STATIC_DRAW);
// connect the xyz to the "vert" attribute of the vertex shader
glEnableVertexAttribArray(ShaderGetAttrib(program, "vert"));
glVertexAttribPointer(ShaderGetAttrib(program, "vert"), 3, GL_FLOAT, GL_FALSE, 5*sizeof(GLfloat), NULL);
// connect the uv coords to the "vertTexCoord" attribute of the vertex shader
glEnableVertexAttribArray(ShaderGetAttrib(program,"vertTexCoord"));
glVertexAttribPointer(ShaderGetAttrib(program,"vertTexCoord"), 2, GL_FLOAT, GL_TRUE, 5*sizeof(GLfloat), (const GLvoid*)(3 * sizeof(GLfloat)));
// connect the xyz to the "vert" attribute of the vertex shader
glEnableVertexAttribArray(ShaderGetAttrib(program_gui, "vert"));
glVertexAttribPointer(ShaderGetAttrib(program_gui, "vert"), 3, GL_FLOAT, GL_FALSE, 5*sizeof(GLfloat), NULL);
// connect the uv coords to the "vertTexCoord" attribute of the vertex shader
glEnableVertexAttribArray(ShaderGetAttrib(program_gui,"vertTexCoord"));
glVertexAttribPointer(ShaderGetAttrib(program_gui,"vertTexCoord"), 2, GL_FLOAT, GL_TRUE, 5*sizeof(GLfloat), (const GLvoid*)(3 * sizeof(GLfloat)));
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
error = glGetError();
if(error != GL_NO_ERROR)
printf( "OpenGL Error %d: %s\n", error, (const char*)glewGetErrorString(error));
glfwSetMousePos(800/2, 600/2);
glfwDisable(GLFW_MOUSE_CURSOR);
}
//Set up openGL
bool GLInit()
{
//set viewport
int height = 480;
int width = 640;
glViewport(0, 0, width, height); //reset viewport
//set up projection matrix
glMatrixMode(GL_PROJECTION); //select projection matrix
glLoadIdentity(); //reset
gluPerspective(45.0f, (GLfloat)width/(GLfloat)height, 1.0f, 100.0f);
//load identity modelview
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
//other states
//shading
glShadeModel(GL_SMOOTH);
glClearColor( backgroundColor.r,
backgroundColor.g,
backgroundColor.b,
backgroundColor.a);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
//depth
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
//hints
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
//Set up vertex arrays for torus
//Fixed 17th November 2002
//Instead of passing tangents as texture coords 1 and 2, use aliased attributes 9 and 10.
//This way, these texture coordinates will reach the vertex program on a geforce 2
//which only has 2 texture units.
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].position);
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].normal);
//Pass texture coords to unit 0
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].s);
//Pass tangent,binormal to attributes 9, 10
glEnableClientState(GL_VERTEX_ATTRIB_ARRAY9_NV);
glVertexAttribPointerNV(9, 3, GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].sTangent);
glEnableClientState(GL_VERTEX_ATTRIB_ARRAY10_NV);
glVertexAttribPointerNV(10, 3, GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].tTangent);
//Use compiled vertex arrays
glLockArraysEXT(0, torus.numVertices);
//Load vertex programs
glGenProgramsNV(1, &singlePassVertexProgram);
glBindProgramNV(GL_VERTEX_PROGRAM_NV, singlePassVertexProgram);
LoadNV_vertex_program("single pass vertex program.txt", singlePassVertexProgram);
glGenProgramsNV(1, &diffuseDecalVertexProgram);
glBindProgramNV(GL_VERTEX_PROGRAM_NV, diffuseDecalVertexProgram);
LoadNV_vertex_program("diffuse decal vertex program.txt", diffuseDecalVertexProgram);
glGenProgramsNV(1, &lookUpSpecularVertexProgram);
glBindProgramNV(GL_VERTEX_PROGRAM_NV, lookUpSpecularVertexProgram);
LoadNV_vertex_program("look up specular vertex program.txt", lookUpSpecularVertexProgram);
glGenProgramsNV(1, &diffuseVertexProgram);
glBindProgramNV(GL_VERTEX_PROGRAM_NV, diffuseVertexProgram);
LoadNV_vertex_program("diffuse vertex program.txt", diffuseVertexProgram);
glGenProgramsNV(1, &decalVertexProgram);
glBindProgramNV(GL_VERTEX_PROGRAM_NV, decalVertexProgram);
LoadNV_vertex_program("decal vertex program.txt", decalVertexProgram);
glGenProgramsNV(1, &simpleSpecularVertexProgram);
glBindProgramNV(GL_VERTEX_PROGRAM_NV, simpleSpecularVertexProgram);
LoadNV_vertex_program("simple specular vertex program.txt", simpleSpecularVertexProgram);
//Set Tracking Matrix
//Modelview Projection in registers c[0]-c[3]
glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 0, GL_MODELVIEW_PROJECTION_NV, GL_IDENTITY_NV);
return true;
}
void Scene::render(RenderContext* renderContext)
{
renderContext->scene = this;
renderContext->viewpoint = viewpoint;
//
// CLEAR BUFFERS
//
GLbitfield clearFlags = 0;
// Depth Buffer
glClearDepth(1.0);
glDepthFunc(GL_LESS);
glDepthMask(GL_TRUE);
// if ( unsortedShapes.size() )
clearFlags |= GL_DEPTH_BUFFER_BIT;
// Color Buffer (optional - depends on background node)
clearFlags |= background->getClearFlags(renderContext);
// clear
glClear(clearFlags);
// renderContext.clear(viewport);
// userMatrix and scale might change the length of normals. If this slows us
// down, we should test for that instead of just enabling GL_NORMALIZE
glEnable(GL_NORMALIZE);
//
// SETUP LIGHTING MODEL
//
setupLightModel(renderContext);
Sphere total_bsphere;
if (data_bbox.isValid()) {
//
// GET DATA VOLUME SPHERE
//
total_bsphere = Sphere( (bboxDeco) ? bboxDeco->getBoundingBox(data_bbox) : data_bbox );
} else {
total_bsphere = Sphere( Vertex(0,0,0), 1 );
}
//
// SETUP VIEWPORT TRANSFORMATION
//
glViewport(renderContext->rect.x,renderContext->rect.y,renderContext->rect.width, renderContext->rect.height);
//
// SETUP BACKGROUND VIEWPOINT PROJECTION
//
// FIXME: move to background
//
viewpoint->setupFrustum( renderContext, total_bsphere );
//
// RENDER BACKGROUND
//
// DISABLE Z-BUFFER TEST
glDisable(GL_DEPTH_TEST);
// DISABLE Z-BUFFER FOR WRITING
glDepthMask(GL_FALSE);
background->render(renderContext);
//
// RENDER MODEL
//
if (data_bbox.isValid() ) {
//
// SETUP VIEWPOINT TRANSFORMATION
//
viewpoint->setupTransformation( renderContext, total_bsphere);
//
// RENDER BBOX DECO
//
if (bboxDeco)
bboxDeco->render(renderContext);
//
// RENDER SOLID SHAPES
//
// ENABLE Z-BUFFER TEST
glEnable(GL_DEPTH_TEST);
// ENABLE Z-BUFFER FOR WRITING
glDepthMask(GL_TRUE);
// DISABLE BLENDING
glDisable(GL_BLEND);
{
std::vector<Shape*>::iterator iter;
for (iter = unsortedShapes.begin() ; iter != unsortedShapes.end() ; ++iter ) {
Shape* shape = *iter;
shape->render(renderContext);
}
}
// #define NO_BLEND
#ifndef NO_BLEND
//
// RENDER BLENDED SHAPES
//
// render shapes in bounding-box sorted order according to z value
//
// DISABLE Z-BUFFER FOR WRITING
glDepthMask(GL_FALSE);
// SETUP BLENDING
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
// ENABLE BLENDING
glEnable(GL_BLEND);
//
// GET THE TRANSFORMATION
//
viewpoint->setupTransformation(renderContext, total_bsphere);
double data[16];
glGetDoublev(GL_MODELVIEW_MATRIX,data);
Matrix4x4 M(data);
glGetDoublev(GL_PROJECTION_MATRIX,data);
Matrix4x4 P(data);
P = P*M;
renderContext->Zrow = P.getRow(2);
renderContext->Wrow = P.getRow(3);
{
std::vector<Shape*>::iterator iter;
std::multimap<float, int> distanceMap;
int index = 0;
for (iter = zsortShapes.begin() ; iter != zsortShapes.end() ; ++iter ) {
Shape* shape = *iter;
const AABox& aabox = shape->getBoundingBox();
float distance = renderContext->getDistance( aabox.getCenter() );
distanceMap.insert( std::pair<float,int>(-distance, index) );
index++;
}
{
std::multimap<float,int>::iterator iter;
for (iter = distanceMap.begin() ; iter != distanceMap.end() ; ++ iter ) {
int index = iter->second;
Shape* shape = zsortShapes[index];
shape->renderZSort(renderContext);
}
}
}
#endif
/* Reset flag(s) now that scene has been rendered */
renderContext->viewpoint->scaleChanged = false;
}
}
GLUSuint initWaterTexture(GLUSfloat waterPlaneLength)
{
GLfloat projectionMatrixWaterTexture[16];
GLfloat modelViewMatrixWaterTexture[16];
GLUSshape plane;
GLUStextfile vertexSource;
GLUStextfile fragmentSource;
glusLoadTextFile("../Example15/shader/WaterTexture.vert.glsl", &vertexSource);
glusLoadTextFile("../Example15/shader/WaterTexture.frag.glsl", &fragmentSource);
glusBuildProgramFromSource(&g_programWaterTexture, (const GLUSchar**) &vertexSource.text, 0, 0, 0, (const GLUSchar**) &fragmentSource.text);
glusDestroyTextFile(&vertexSource);
glusDestroyTextFile(&fragmentSource);
//
g_projectionMatrixWaterTextureLocation = glGetUniformLocation(g_programWaterTexture.program, "u_projectionMatrix");
g_modelViewMatrixWaterTextureLocation = glGetUniformLocation(g_programWaterTexture.program, "u_modelViewMatrix");
g_waterPlaneLengthWaterTextureLocation = glGetUniformLocation(g_programWaterTexture.program, "u_waterPlaneLength");
g_passedTimeWaterTextureLocation = glGetUniformLocation(g_programWaterTexture.program, "u_passedTime");
g_waveParametersWaterTextureLocation = glGetUniformLocation(g_programWaterTexture.program, "u_waveParameters");
g_waveDirectionsWaterTextureLocation = glGetUniformLocation(g_programWaterTexture.program, "u_waveDirections");
g_vertexWaterTextureLocation = glGetAttribLocation(g_programWaterTexture.program, "a_vertex");
g_texCoordWaterTextureLocation = glGetAttribLocation(g_programWaterTexture.program, "a_texCoord");
//
glGenTextures(1, &g_mirrorTexture);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, g_mirrorTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GLUS_RGB, TEXTURE_SIZE, TEXTURE_SIZE, 0, GLUS_RGB, GL_UNSIGNED_BYTE, 0);
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_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glBindTexture(GL_TEXTURE_2D, 0);
//
glGenRenderbuffers(1, &g_depthMirrorTexture);
glBindRenderbuffer(GL_RENDERBUFFER, g_depthMirrorTexture);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, TEXTURE_SIZE, TEXTURE_SIZE);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
//
glGenFramebuffers(1, &g_fboWaterTexture);
glBindFramebuffer(GL_FRAMEBUFFER, g_fboWaterTexture);
// Attach the color buffer ...
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, g_mirrorTexture, 0);
// ... and the depth buffer,
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, g_depthMirrorTexture);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
printf("GL_FRAMEBUFFER_COMPLETE error 0x%x", glCheckFramebufferStatus(GL_FRAMEBUFFER));
return GLUS_FALSE;
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
//
glBindVertexArray(0);
//
glusCreatePlanef(&plane, TEXTURE_SIZE / 2.0f);
g_numberIndicesWaterTexture = plane.numberIndices;
glGenBuffers(1, &g_verticesWaterTextureVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesWaterTextureVBO);
glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 4 * sizeof(GLfloat), (GLfloat*) plane.vertices, GL_STATIC_DRAW);
glGenBuffers(1, &g_texCoordsWaterTextureVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_texCoordsWaterTextureVBO);
glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 2 * sizeof(GLfloat), (GLfloat*) plane.texCoords, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &g_indicesWaterTextureVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesWaterTextureVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, plane.numberIndices * sizeof(GLuint), (GLuint*) plane.indices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glusDestroyShapef(&plane);
//
glUseProgram(g_programWaterTexture.program);
glusLookAtf(modelViewMatrixWaterTexture, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
glUniformMatrix4fv(g_modelViewMatrixWaterTextureLocation, 1, GL_FALSE, modelViewMatrixWaterTexture);
glusOrthof(projectionMatrixWaterTexture, -(GLfloat) TEXTURE_SIZE / 2, (GLfloat) TEXTURE_SIZE / 2, -(GLfloat) TEXTURE_SIZE / 2, (GLfloat) TEXTURE_SIZE / 2, 1.0f, 100.0f);
glUniformMatrix4fv(g_projectionMatrixWaterTextureLocation, 1, GL_FALSE, projectionMatrixWaterTexture);
glUniform1f(g_waterPlaneLengthWaterTextureLocation, waterPlaneLength);
//
glGenVertexArrays(1, &g_vaoWaterTexture);
glBindVertexArray(g_vaoWaterTexture);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesWaterTextureVBO);
glVertexAttribPointer(g_vertexWaterTextureLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexWaterTextureLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_texCoordsWaterTextureVBO);
glVertexAttribPointer(g_texCoordWaterTextureLocation, 2, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_texCoordWaterTextureLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesWaterTextureVBO);
//
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
return g_mirrorTexture;
}
BOOL Initialize(void)
{
int i;
char Line[255];
float shaderData[32][3];
FILE *In = NULL;
glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glClearColor (0.7f, 0.7f, 0.7f, 0.0f);
glClearDepth (1.0f);
glEnable (GL_DEPTH_TEST);
glDepthFunc (GL_LESS);
glShadeModel (GL_SMOOTH);
glDisable (GL_LINE_SMOOTH);
glEnable (GL_CULL_FACE);
glDisable (GL_LIGHTING);
In = fopen ("Data/Shader.txt", "r");
if (In)
{
for (i = 0; i < 32; i++)
{
if (feof (In))
break;
fgets (Line, 255, In);
shaderData[i][0] = shaderData[i][1] = shaderData[i][2] = (float)(atof (Line));
}
fclose (In);
}
else
{
printf("Error loading file Shader.txt: Initialize\n");
return False;
}
glGenTextures (1, &shaderTexture[0]);
glBindTexture (GL_TEXTURE_1D, shaderTexture[0]);
glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage1D (GL_TEXTURE_1D, 0, GL_RGB, 32, 0, GL_RGB , GL_FLOAT, shaderData);
lightAngle.X = 0.0f;
lightAngle.Y = 0.0f;
lightAngle.Z = 1.0f;
Normalize (&lightAngle);
return ReadMesh ();
}
////////////////////////////////////////////////////////////
/// Entry point of application
///
/// \return Application exit code
///
////////////////////////////////////////////////////////////
int main()
{
// Create the main window
sf::RenderWindow App(sf::VideoMode(800, 600, 32), "SFML OpenGL");
// Create a clock for measuring time elapsed
sf::Clock Clock;
// Set color and depth clear value
glClearDepth(1.f);
glClearColor(0.f, 0.f, 0.f, 0.f);
// Enable Z-buffer read and write
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
// Setup a perspective projection
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(90.f, 800.0f/600.0f, 1.f, 500.f);
// set FPS limit to 60
App.SetFramerateLimit(60);
// Preserve OpenGl States
App.PreserveOpenGLStates(true);
// Create Cube
Cube c;
// Create design
ygui::DesignButton d(200.0, 50.0);
ygui::DesignButton d1(200.0, 50.0);
ygui::DesignButton d2(50.0, 200.0);
ygui::DesignButton d3(50.0, 200.0);
// Create Button
CubeButtonUp test(d, &c);
CubeButtonDown test1(d1, &c);
CubeButtonLeft test2(d2, &c);
CubeButtonRight test3(d3, &c);
// Create scene
ygui::Scene scene;
// Set button setting
test.setX(300.0);
test.setY(50.0);
test.setText("Up");
test.setTextColor(0, 0, 0);
test.setTextY(3.0);
test.setTextX(80.0);
test1.setX(300.0);
test1.setY(500.0);
test1.setText("Down");
test1.setTextColor(0, 0, 0);
test1.setTextY(3.0);
test1.setTextX(65.0);
test2.setX(50.0);
test2.setY(200.0);
test2.setText("Left");
test2.setTextColor(0, 0, 0);
test2.setTextX(5.0);
test2.setTextY(125.0);
test2.setTextRotation(90.0f);
test3.setX(700.0);
test3.setY(200.0);
test3.setText("Right");
test3.setTextColor(0, 0, 0);
test3.setTextX(45.0);
test3.setTextY(55.0);
test3.setTextRotation(270.0f);
scene.addObject("1", &test);
scene.addObject("2", &test1);
scene.addObject("3", &test2);
scene.addObject("4", &test3);
// Start game loop
while (App.IsOpened())
{
// Process events
sf::Event Event;
while (App.GetEvent(Event))
{
// Close window : exit
if (Event.Type == sf::Event::Closed)
App.Close();
// Escape key : exit
if ((Event.Type == sf::Event::KeyPressed) && (Event.Key.Code == sf::Key::Escape))
App.Close();
// Resize event : adjust viewport
if (Event.Type == sf::Event::Resized)
glViewport(0, 0, Event.Size.Width, Event.Size.Height);
}
// Set the active window before using OpenGL commands
// It's useless here because active window is always the same,
// but don't forget it if you use multiple windows or controls
App.Clear();
App.SetActive();
// Clear color and depth buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Apply some transformations
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0.f, 0.f, -200.f);
c.draw(Clock);
scene.draw(App);
// Finally, display rendered frame on screen
App.Display();
}
return EXIT_SUCCESS;
}
void DrawingFunction()
{
window.create(sf::VideoMode(800, 600), "Client");
//window.setFramerateLimit(60);
// Set color and depth clear value
glClearDepth(1.f);
glClearColor(0.f, 0.f, 0.f, 0.f);
// Enable Z-buffer read and write
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
// Setup a perspective projection
gluPerspective(90.f, 1.f, 1.f, 500.f);
while (window.isOpen())
{
sf::Event event;
while (window.pollEvent(event))
{
if (event.type == sf::Event::Resized)
{
// adjust the viewport when the window is resized
glViewport(0, 0, event.size.width, event.size.height);
}
else if (event.type == sf::Event::GainedFocus)
{
isActive = true;
}
else if (event.type == sf::Event::LostFocus)
{
isActive = false;
}
}
// Input
if (isActive)
{
if (sf::Keyboard::isKeyPressed(sf::Keyboard::A))
{
world.GetClient()->Translate(-0.1f, 0, 0);
std::cout << "MOVING: " << world.GetClient()->playerId << std::endl;
}
else if (sf::Keyboard::isKeyPressed(sf::Keyboard::D))
{
world.GetClient()->Translate(0.1f, 0, 0);
std::cout << "MOVING: " << world.GetClient()->playerId << std::endl;
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::W))
{
world.GetClient()->Translate(0.0f, 0.1f, 0);
std::cout << "MOVING: " << world.GetClient()->playerId << std::endl;
}
else if (sf::Keyboard::isKeyPressed(sf::Keyboard::S))
{
world.GetClient()->Translate(0.0f, -0.1f, 0);
std::cout << "MOVING: " << world.GetClient()->playerId << std::endl;
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Q))
{
world.GetClient()->Translate(0.0f, 0.0f, -0.1f);
std::cout << "MOVING: " << world.GetClient()->playerId << std::endl;
}
else if (sf::Keyboard::isKeyPressed(sf::Keyboard::E))
{
world.GetClient()->Translate(0.0f, 0.0f, 0.1f);
std::cout << "MOVING: " << world.GetClient()->playerId << std::endl;
}
}
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glBegin(GL_TRIANGLES);
glColor3f(0.2f, 0.2f, 0.2f); // ???
world.DrawWorld();
// Draw all players
glColor3f(1.0f, 0.0f, 0.0f); // RED
world.DrawPlayers();
glEnd(); // triangles
window.pushGLStates(); // SFML drawing
sf::RectangleShape rectangle(sf::Vector2f(120, 50));
rectangle.setFillColor(sf::Color::Blue);
rectangle.setPosition(0, 0);
window.draw(rectangle);
window.popGLStates(); // /SFML drawing
window.display();
}
}
int main() {
int rotateX = 0;
int rotateY = 0;
//set mode 0, enable BG0 and set it to 3D
videoSetMode(MODE_0_3D);
// intialize gl
glInit();
// enable antialiasing
glEnable(GL_ANTIALIAS);
// setup the rear plane
glClearColor(0,0,0,31); // BG must be opaque for AA to work
glClearPolyID(63); // BG must have a unique polygon ID for AA to work
glClearDepth(0x7FFF);
//this should work the same as the normal gl call
glViewport(0,0,255,191);
vramSetBankA(VRAM_A_TEXTURE);
glEnable(GL_TEXTURE_2D);
int cafe_texid;
glGenTextures( 1, &cafe_texid );
glBindTexture( 0, cafe_texid );
glTexImage2D( 0, 0, GL_RGB, TEXTURE_SIZE_128 , TEXTURE_SIZE_128, 0, GL_TEXTURE_WRAP_S|GL_TEXTURE_WRAP_T|TEXGEN_NORMAL, (u8*)cafe_bin );
//any floating point gl call is being converted to fixed prior to being implemented
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(70, 256.0 / 192.0, 0.1, 40);
while(1) {
//TEXGEN_NORMAL helpfully pops our normals into this matrix and uses the result as texcoords
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
GLvector tex_scale = { 64<<16, -64<<16, 1<<16 };
glScalev( &tex_scale ); //scale normals up from (-1,1) range into texcoords
glRotateXi(rotateX); //rotate texture-matrix to match the camera
glRotateYi(rotateY);
glMatrixMode(GL_POSITION);
glLoadIdentity();
glTranslatef32(0, 0, floattof32(-3));
glRotateXi(rotateX);
glRotateYi(rotateY);
glMaterialf(GL_EMISSION, RGB15(31,31,31));
glPolyFmt(POLY_ALPHA(31) | POLY_CULL_BACK );
scanKeys();
u32 keys = keysHeld();
if( keys & KEY_UP ) rotateX += 3<<3;
if( keys & KEY_DOWN ) rotateX -= 3<<3;
if( keys & KEY_LEFT ) rotateY += 3<<3;
if( keys & KEY_RIGHT ) rotateY -= 3<<3;
int pen_delta[2];
get_pen_delta( &pen_delta[0], &pen_delta[1] );
rotateY -= pen_delta[0];
rotateX -= pen_delta[1];
glBindTexture( 0, cafe_texid );
glCallList((u32*)teapot_bin);
glFlush(0);
}
return 0;
}//end main
//Called to update the display.
//You should call glutSwapBuffers after all of your rendering to display what you rendered.
//If you need continuous updates of the screen, call glutPostRedisplay() at the end of the function.
void display()
{
g_lights.UpdateTime();
glm::vec4 bkg = g_lights.GetBackgroundColor();
glClearColor(bkg[0], bkg[1], bkg[2], bkg[3]);
glClearDepth(1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glutil::MatrixStack modelMatrix;
modelMatrix.SetMatrix(g_viewPole.CalcMatrix());
const glm::mat4 &worldToCamMat = modelMatrix.Top();
LightBlock lightData = g_lights.GetLightInformation(worldToCamMat);
glBindBuffer(GL_UNIFORM_BUFFER, g_lightUniformBuffer);
glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(lightData), &lightData);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
if(g_pScene)
{
glutil::PushStack push(modelMatrix);
g_pScene->Draw(modelMatrix, g_materialBlockIndex, g_lights.GetTimerValue("tetra"));
}
{
glutil::PushStack push(modelMatrix);
//Render the sun
{
glutil::PushStack push(modelMatrix);
glm::vec3 sunlightDir(g_lights.GetSunlightDirection());
modelMatrix.Translate(sunlightDir * 500.0f);
modelMatrix.Scale(30.0f, 30.0f, 30.0f);
glUseProgram(g_Unlit.theProgram);
glUniformMatrix4fv(g_Unlit.modelToCameraMatrixUnif, 1, GL_FALSE,
glm::value_ptr(modelMatrix.Top()));
glm::vec4 lightColor = g_lights.GetSunlightIntensity();
glUniform4fv(g_Unlit.objectColorUnif, 1, glm::value_ptr(lightColor));
g_pScene->GetSphereMesh()->Render("flat");
}
//Render the lights
if(g_bDrawLights)
{
for(int light = 0; light < g_lights.GetNumberOfPointLights(); light++)
{
glutil::PushStack push(modelMatrix);
modelMatrix.Translate(g_lights.GetWorldLightPosition(light));
glUseProgram(g_Unlit.theProgram);
glUniformMatrix4fv(g_Unlit.modelToCameraMatrixUnif, 1, GL_FALSE,
glm::value_ptr(modelMatrix.Top()));
glm::vec4 lightColor = g_lights.GetPointLightIntensity(light);
glUniform4fv(g_Unlit.objectColorUnif, 1, glm::value_ptr(lightColor));
g_pScene->GetCubeMesh()->Render("flat");
}
}
if(g_bDrawCameraPos)
{
glutil::PushStack push(modelMatrix);
modelMatrix.SetIdentity();
modelMatrix.Translate(glm::vec3(0.0f, 0.0f, -g_viewPole.GetView().radius));
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
glUseProgram(g_Unlit.theProgram);
glUniformMatrix4fv(g_Unlit.modelToCameraMatrixUnif, 1, GL_FALSE,
glm::value_ptr(modelMatrix.Top()));
glUniform4f(g_Unlit.objectColorUnif, 0.25f, 0.25f, 0.25f, 1.0f);
g_pScene->GetCubeMesh()->Render("flat");
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
glUniform4f(g_Unlit.objectColorUnif, 1.0f, 1.0f, 1.0f, 1.0f);
g_pScene->GetCubeMesh()->Render("flat");
}
}
glutPostRedisplay();
glutSwapBuffers();
}
static void
find_ideal_mrd(GLdouble *ideal_mrd_near, GLdouble *ideal_mrd_far,
GLdouble *next_to_near, GLdouble *next_to_far)
{
/* MRD stands for Minimum Resolvable Difference, the smallest distance
* in depth that suffices to separate any two polygons (or a polygon
* and the near or far clipping planes).
*
* This function tries to determine the "ideal" MRD for the current
* rendering context. It's expressed in window coordinates, because
* the value in model or clipping coordinates depends on the scale
* factors in the modelview and projection matrices and on the
* distances to the near and far clipping planes.
*
* For simple unsigned-integer depth buffers that aren't too deep (so
* that precision isn't an issue during coordinate transformations),
* it should be about one least-significant bit. For deep or
* floating-point or compressed depth buffers the situation may be
* more complicated, so we don't pass or fail an implementation solely
* on the basis of its ideal MRD.
*
* There are two subtle parts of this function. The first is the
* projection matrix we use for rendering. This matrix places the far
* clip plane at infinity (so that we don't run into arbitrary limits
* during our search process). The second is the method used for
* drawing the polygon. We scale the x and y coords of the polygon
* vertices by the polygon's depth, so that it always occupies the
* full view frustum. This makes it easier to verify that the polygon
* was resolved completely -- we just read back the entire window and
* see if any background pixels appear.
*
* To insure that we get reasonable results on machines with unusual
* depth buffers (floating-point, or compressed), we determine the MRD
* twice, once close to the near clipping plane and once as far away
* from the eye as possible. On a simple integer depth buffer these
* two values should be essentially the same. For other depth-buffer
* formats, the ideal MRD is simply the largest of the two.
*/
GLdouble near_dist, far_dist, half_dist;
int i;
/* First, find a distance that is as far away as possible, yet a quad
* at that distance can be distinguished from the background. Start
* by pushing quads away from the eye until we find an interval where
* the closer quad can be resolved, but the farther quad cannot. Then
* binary-search to find the threshold.
*/
glDepthFunc(GL_LESS);
glClearDepth(1.0);
glColor3f(1.0, 0.0, 0.0); /* red */
near_dist = 1.0;
far_dist = 2.0;
for (;;) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
draw_quad_at_distance(far_dist);
if (!red_quad_was_drawn())
break;
piglit_present_results();
near_dist = far_dist;
far_dist *= 2.0;
}
for (i = 0; i < 64; ++i) {
half_dist = 0.5 * (near_dist + far_dist);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
draw_quad_at_distance(half_dist);
if (red_quad_was_drawn())
near_dist = half_dist;
else
far_dist = half_dist;
piglit_present_results();
}
*next_to_far = near_dist;
/* We can derive a resolvable difference from the value next_to_far,
* but it's not necessarily the one we want. Consider mapping the
* object coordinate range [0,1] onto the integer window coordinate
* range [0,2]. A natural way to do this is with a linear function,
* windowCoord = 2*objectCoord. With rounding, this maps [0,0.25) to
* 0, [0.25,0.75) to 1, and [0.75,1] to 2. Note that the intervals at
* either end are 0.25 wide, but the one in the middle is 0.5 wide.
* The difference we can derive from next_to_far is related to the
* width of the final interval. We want to back up just a bit so that
* we can get a (possibly much larger) difference that will work for
* the larger interval. To do this we need to find a difference that
* allows us to distinguish two quads when the more distant one is at
* distance next_to_far.
*/
near_dist = 1.0;
far_dist = *next_to_far;
for (i = 0; i < 64; ++i) {
half_dist = 0.5 * (near_dist + far_dist);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f(0.0, 0.0, 0.0); /* black */
glDepthFunc(GL_ALWAYS);
draw_quad_at_distance(*next_to_far);
glColor3f(1.0, 0.0, 0.0); /* red */
glDepthFunc(GL_LESS);
draw_quad_at_distance(half_dist);
if (red_quad_was_drawn())
near_dist = half_dist;
else
far_dist = half_dist;
piglit_present_results();
}
*ideal_mrd_far = window_coord_depth(*next_to_far)
- window_coord_depth(near_dist);
/* Now we apply a similar strategy at the near end of the depth range,
* but swapping the senses of various comparisons so that we approach
* the near clipping plane rather than the far.
*/
glClearDepth(0.0);
glDepthFunc(GL_GREATER);
glColor3f(1.0, 0.0, 0.0); /* red */
near_dist = 1.0;
far_dist = *next_to_far;
for (i = 0; i < 64; ++i) {
half_dist = 0.5 * (near_dist + far_dist);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
draw_quad_at_distance(half_dist);
if (red_quad_was_drawn())
far_dist = half_dist;
else
near_dist = half_dist;
piglit_present_results();
}
*next_to_near = far_dist;
near_dist = *next_to_near;
far_dist = *next_to_far;
for (i = 0; i < 64; ++i) {
half_dist = 0.5 * (near_dist + far_dist);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f(0.0, 0.0, 0.0); /* black */
glDepthFunc(GL_ALWAYS);
draw_quad_at_distance(*next_to_near);
glColor3f(1.0, 0.0, 0.0); /* red */
glDepthFunc(GL_GREATER);
draw_quad_at_distance(half_dist);
if (red_quad_was_drawn())
far_dist = half_dist;
else
near_dist = half_dist;
piglit_present_results();
}
*ideal_mrd_near = window_coord_depth(far_dist)
- window_coord_depth(*next_to_near);
}
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();
}
}
}
}
}
}
