void CWorldDrawer::Draw() { SCOPED_TIMER("WorldDrawer::Total"); CBaseGroundDrawer* gd = readmap->GetGroundDrawer(); if (globalRendering->drawSky) { sky->Draw(); } if (globalRendering->drawGround) { SCOPED_TIMER("WorldDrawer::Terrain"); gd->Draw(DrawPass::Normal); smoothHeightMeshDrawer->Draw(1.0f); treeDrawer->DrawGrass(); gd->DrawTrees(); } if (globalRendering->drawWater && !mapInfo->map.voidWater) { SCOPED_TIMER("WorldDrawer::Water"); water->OcclusionQuery(); if (water->IsDrawSolid()) { water->UpdateWater(game); water->Draw(); } } selectedUnits.Draw(); eventHandler.DrawWorldPreUnit(); { SCOPED_TIMER("WorldDrawer::Models"); DebugColVolDrawer::Draw(); unitDrawer->Draw(false); modelDrawer->Draw(); featureDrawer->Draw(); pathDrawer->DrawAll(); } //! transparent stuff glEnable(GL_BLEND); glDepthFunc(GL_LEQUAL); const bool noAdvShading = shadowHandler->shadowsLoaded; static const double plane_below[4] = {0.0f, -1.0f, 0.0f, 0.0f}; static const double plane_above[4] = {0.0f, 1.0f, 0.0f, 0.0f}; { glClipPlane(GL_CLIP_PLANE3, plane_below); glEnable(GL_CLIP_PLANE3); //! draw cloaked objects below water surface unitDrawer->DrawCloakedUnits(noAdvShading); featureDrawer->DrawFadeFeatures(noAdvShading); glDisable(GL_CLIP_PLANE3); } //! draw water if (globalRendering->drawWater && !mapInfo->map.voidWater) { SCOPED_TIMER("WorldDrawer::Water"); if (!water->IsDrawSolid()) { //! Water rendering will overwrite features, so save them featureDrawer->SwapFeatures(); water->UpdateWater(game); water->Draw(); featureDrawer->SwapFeatures(); } } { glClipPlane(GL_CLIP_PLANE3, plane_above); glEnable(GL_CLIP_PLANE3); //! draw cloaked objects above water surface unitDrawer->DrawCloakedUnits(noAdvShading); featureDrawer->DrawFadeFeatures(noAdvShading); glDisable(GL_CLIP_PLANE3); } { SCOPED_TIMER("WorldDrawer::Projectiles"); projectileDrawer->Draw(false); } if (globalRendering->drawSky) { sky->DrawSun(); } eventHandler.DrawWorld(); LuaUnsyncedCtrl::DrawUnitCommandQueues(); if (cmdColors.AlwaysDrawQueue() || guihandler->GetQueueKeystate()) { selectedUnits.DrawCommands(); } lineDrawer.DrawAll(); cursorIcons.Draw(); cursorIcons.Clear(); mouse->DrawSelectionBox(); guihandler->DrawMapStuff(false); if (globalRendering->drawMapMarks && !game->hideInterface) { inMapDrawerView->Draw(); } //! underwater overlay if (camera->pos.y < 0.0f) { glEnableClientState(GL_VERTEX_ARRAY); const float3& cpos = camera->pos; const float vr = globalRendering->viewRange * 0.5f; glDepthMask(GL_FALSE); glDisable(GL_TEXTURE_2D); glColor4f(0.0f, 0.5f, 0.3f, 0.50f); { float3 verts[] = { float3(cpos.x - vr, 0.0f, cpos.z - vr), float3(cpos.x - vr, 0.0f, cpos.z + vr), float3(cpos.x + vr, 0.0f, cpos.z + vr), float3(cpos.x + vr, 0.0f, cpos.z - vr) }; glVertexPointer(3, GL_FLOAT, 0, verts); glDrawArrays(GL_QUADS, 0, 4); } { float3 verts[] = { float3(cpos.x - vr, 0.0f, cpos.z - vr), float3(cpos.x - vr, -vr, cpos.z - vr), float3(cpos.x - vr, 0.0f, cpos.z + vr), float3(cpos.x - vr, -vr, cpos.z + vr), float3(cpos.x + vr, 0.0f, cpos.z + vr), float3(cpos.x + vr, -vr, cpos.z + vr), float3(cpos.x + vr, 0.0f, cpos.z - vr), float3(cpos.x + vr, -vr, cpos.z - vr), float3(cpos.x - vr, 0.0f, cpos.z - vr), float3(cpos.x - vr, -vr, cpos.z - vr), }; glVertexPointer(3, GL_FLOAT, 0, verts); glDrawArrays(GL_QUAD_STRIP, 0, 10); } glDepthMask(GL_TRUE); glDisableClientState(GL_VERTEX_ARRAY); } //reset fov glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0,1,0,1); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glEnable(GL_BLEND); glDisable(GL_DEPTH_TEST); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // underwater overlay, part 2 if (camera->pos.y < 0.0f) { glEnableClientState(GL_VERTEX_ARRAY); glDisable(GL_TEXTURE_2D); glColor4f(0.0f, 0.2f, 0.8f, 0.333f); float3 verts[] = { float3 (0.f, 0.f, -1.f), float3 (1.f, 0.f, -1.f), float3 (1.f, 1.f, -1.f), float3 (0.f, 1.f, -1.f), }; glVertexPointer(3, GL_FLOAT, 0, verts); glDrawArrays(GL_QUADS, 0, 4); glDisableClientState(GL_VERTEX_ARRAY); } }
void CMiniMap::DrawButtons() { const int x = mouse->lastx; const int y = mouse->lasty; // update the showButtons state if (!showButtons) { if (mapBox.Inside(x, y) && (buttonSize > 0) && !globalRendering->dualScreenMode) { showButtons = true; } else { return; } } else if (!mouseMove && !mouseResize && !mapBox.Inside(x, y) && !buttonBox.Inside(x, y)) { showButtons = false; return; } if (buttonsTexture) { glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, buttonsTexture); glColor4f(1.0f, 1.0f, 1.0f, 1.0f); resizeBox.DrawTextureBox(); moveBox.DrawTextureBox(); maximizeBox.DrawTextureBox(); minimizeBox.DrawTextureBox(); glDisable(GL_TEXTURE_2D); } else { glColor4f(0.1f, 0.1f, 0.8f, 0.8f); resizeBox.DrawBox(); // blue glColor4f(0.0f, 0.8f, 0.0f, 0.8f); moveBox.DrawBox(); // green glColor4f(0.8f, 0.8f, 0.0f, 0.8f); maximizeBox.DrawBox(); // yellow glColor4f(0.8f, 0.0f, 0.0f, 0.8f); minimizeBox.DrawBox(); // red } // highlight glBlendFunc(GL_SRC_ALPHA, GL_ONE); glColor4f(1.0f, 1.0f, 1.0f, 0.4f); if (mouseResize || (!mouseMove && resizeBox.Inside(x, y))) { if (!buttonsTexture) { glColor4f(0.3f, 0.4f, 1.0f, 0.9f); } resizeBox.DrawBox(); } else if (mouseMove || (!mouseResize && moveBox.Inside(x, y))) { if (!buttonsTexture) { glColor4f(1.0f, 1.0f, 1.0f, 0.3f); } moveBox.DrawBox(); } else if (!mouseMove && !mouseResize) { if (minimizeBox.Inside(x, y)) { if (!buttonsTexture) { glColor4f(1.0f, 0.2f, 0.2f, 0.6f); } minimizeBox.DrawBox(); } else if (maximizeBox.Inside(x, y)) { if (!buttonsTexture) { glColor4f(1.0f, 1.0f, 1.0f, 0.3f); } maximizeBox.DrawBox(); } } glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // outline the button box glColor4f(0.0f, 0.0f, 0.0f, 1.0f); glBegin(GL_LINE_LOOP); glVertex2f(float(buttonBox.xmin - 1 - 0.5f) * globalRendering->pixelX, 1.0f - float(buttonBox.ymin + 2 - 0.5f) * globalRendering->pixelY); glVertex2f(float(buttonBox.xmin - 1 - 0.5f) * globalRendering->pixelX, 1.0f - float(buttonBox.ymax + 2 + 0.5f) * globalRendering->pixelY); glVertex2f(float(buttonBox.xmax + 2 + 0.5f) * globalRendering->pixelX, 1.0f - float(buttonBox.ymax + 2 + 0.5f) * globalRendering->pixelY); glVertex2f(float(buttonBox.xmax + 2 + 0.5f) * globalRendering->pixelX, 1.0f - float(buttonBox.ymin + 2 - 0.5f) * globalRendering->pixelY); glEnd(); glColor4f(1.0f, 1.0f, 1.0f, 1.0f); glBegin(GL_LINE_LOOP); glVertex2f(float(buttonBox.xmin - 0 - 0.5f) * globalRendering->pixelX, 1.0f - float(buttonBox.ymin + 3 - 0.5f) * globalRendering->pixelY); glVertex2f(float(buttonBox.xmin - 0 - 0.5f) * globalRendering->pixelX, 1.0f - float(buttonBox.ymax + 1 + 0.5f) * globalRendering->pixelY); glVertex2f(float(buttonBox.xmax + 1 + 0.5f) * globalRendering->pixelX, 1.0f - float(buttonBox.ymax + 1 + 0.5f) * globalRendering->pixelY); glVertex2f(float(buttonBox.xmax + 1 + 0.5f) * globalRendering->pixelX, 1.0f - float(buttonBox.ymin + 3 - 0.5f) * globalRendering->pixelY); glEnd(); }
void intro_do(long t, long delta_time) { char errorText[MAX_ERROR_LENGTH + 1]; float ftime = 0.001f*(float)t; float fdelta_time = 0.001f * (float)(delta_time); GLuint textureID; glDisable(GL_BLEND); glDisable(GL_DEPTH_TEST); // Those are key-Press indicators. I only act on 0-to-1. for (int i = 0; i < maxNumParameters; i++) { float destination_value = params.getParam(i, defaultParameters[i]); interpolatedParameters[i] = expf(-2.5f*fdelta_time) * interpolatedParameters[i] + (1.0f - expf(-2.5f*fdelta_time)) * destination_value; } // Update key press events. for (int i = 0; i < NUM_KEYS; i++) { if (params.getParam(i, 0.0) > 0.5f) keyPressed[i]++; else keyPressed[i] = 0; } // BPM => spike calculation float BPS = BPM / 60.0f; float jumpsPerSecond = BPS / 1.0f; // Jump on every fourth beat. static float phase = 0.0f; float jumpTime = (ftime * jumpsPerSecond) + phase; jumpTime -= (float)floor(jumpTime); if (keyPressed[41] == 1) { phase -= jumpTime; jumpTime = 0.0f; if (phase < 0.0f) phase += 1.0; } jumpTime = jumpTime * jumpTime; // spike is between 0.0 and 1.0 depending on the position within whatever. float spike = 0.5f * cosf(jumpTime * 3.1415926f * 1.5f) + 0.5f; // blob is growing down from 1. after keypress static float lastFTime = 0.f; blob *= (float)exp(-(float)(ftime - lastFTime) * BLOB_FADE_SPEED); lastFTime = ftime; // Set the program uniforms GLuint programID; shaderManager.getProgramID(usedProgram[usedIndex], &programID, errorText); glUseProgram(programID); #if 1 GLuint loc = glGetUniformLocation(programID, "aspectRatio"); glUniform1f(loc, aspectRatio); loc = glGetUniformLocation(programID, "time"); glUniform1f(loc, (float)(t * 0.001f)); // For now I am just sending the spike to the shader. I might need something better... loc = glGetUniformLocation(programID, "spike"); glUniform1f(loc, spike); loc = glGetUniformLocation(programID, "blob"); glUniform1f(loc, blob); loc = glGetUniformLocation(programID, "knob1"); glUniform1f(loc, interpolatedParameters[14]); loc = glGetUniformLocation(programID, "knob2"); glUniform1f(loc, interpolatedParameters[15]); loc = glGetUniformLocation(programID, "knob3"); glUniform1f(loc, interpolatedParameters[16]); loc = glGetUniformLocation(programID, "knob4"); glUniform1f(loc, interpolatedParameters[17]); loc = glGetUniformLocation(programID, "knob5"); glUniform1f(loc, interpolatedParameters[18]); loc = glGetUniformLocation(programID, "knob6"); glUniform1f(loc, interpolatedParameters[19]); loc = glGetUniformLocation(programID, "knob7"); glUniform1f(loc, interpolatedParameters[20]); loc = glGetUniformLocation(programID, "knob8"); glUniform1f(loc, interpolatedParameters[21]); loc = glGetUniformLocation(programID, "knob9"); glUniform1f(loc, interpolatedParameters[22]); loc = glGetUniformLocation(programID, "slider1"); glUniform1f(loc, interpolatedParameters[2]); loc = glGetUniformLocation(programID, "slider2"); glUniform1f(loc, interpolatedParameters[3]); loc = glGetUniformLocation(programID, "slider3"); glUniform1f(loc, interpolatedParameters[4]); loc = glGetUniformLocation(programID, "slider4"); glUniform1f(loc, interpolatedParameters[5]); loc = glGetUniformLocation(programID, "slider5"); glUniform1f(loc, interpolatedParameters[6]); loc = glGetUniformLocation(programID, "slider6"); glUniform1f(loc, interpolatedParameters[8]); loc = glGetUniformLocation(programID, "slider7"); glUniform1f(loc, interpolatedParameters[9]); loc = glGetUniformLocation(programID, "slider8"); glUniform1f(loc, interpolatedParameters[12]); loc = glGetUniformLocation(programID, "slider9"); glUniform1f(loc, interpolatedParameters[13]); #endif // Set texture identifiers GLint texture_location; texture_location = glGetUniformLocation(programID, "Noise3DTexture"); glUniform1i(texture_location, 0); texture_location = glGetUniformLocation(programID, "DepthSensorTexture"); glUniform1i(texture_location, 1); texture_location = glGetUniformLocation(programID, "BGTexture"); glUniform1i(texture_location, 2); // render to larger offscreen texture glActiveTexture(GL_TEXTURE2); textureManager.getTextureID("hermaniak.tga", &textureID, errorText); glBindTexture(GL_TEXTURE_2D, textureID); glActiveTexture(GL_TEXTURE1); //textureManager.getTextureID(TM_DEPTH_SENSOR_NAME, &textureID, errorText); glBindTexture(GL_TEXTURE_2D, textureID); glActiveTexture(GL_TEXTURE0); textureManager.getTextureID(TM_NOISE3D_NAME, &textureID, errorText); glBindTexture(GL_TEXTURE_3D, textureID); #if 1 glViewport(0, 0, X_HIGHLIGHT, Y_HIGHLIGHT); #endif // TODO: Here is the rendering done! interpolatedParameters[6] = 0.4f; shaderManager.getProgramID("SimpleTexture.gprg", &programID, errorText); glUseProgram(programID); glColor4f(1.0f, 1.0f, 1.0f, 1.0f); //glDisable(GL_BLEND); glDisable(GL_CULL_FACE); glEnable(GL_BLEND); glBlendFunc(GL_DST_COLOR, GL_ZERO); // Texture for first pass is simply black textureManager.getTextureID("black.tga", &textureID, errorText); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, textureID); const int num_passes = 4; // TODO: Make the first 1 or 2 passes to the smaller backbuffer for (int pass = 0; pass < num_passes; pass++) { // Set small // In the first pass, use highlight if (pass < num_passes - 3) { glViewport(0, 0, X_HIGHLIGHT, Y_HIGHLIGHT); } else if (pass < num_passes - 1) { glViewport(0, 0, X_OFFSCREEN, Y_OFFSCREEN); } else { // Set the whole screen as viewport so that it is used in the last pass int xres = windowRect.right - windowRect.left; int yres = windowRect.bottom - windowRect.top; glViewport(0, 0, xres, yres); } float red = 1.0f; float green = 1.0f; float blue = 1.0f; glClearColor(red, green, blue, 1.0f); glClear(GL_COLOR_BUFFER_BIT); // Draw one iteration of the IFS float transformation[2][3]; for (int i = 0; i < 20; i++) { transformation[0][0] = 0.5f * sinf(ftime * 0.133f + 0.3f + 1.3f * i) * sinf(ftime * 0.051f + 2.8f + 4.2f * i); transformation[0][1] = 0.5f * sinf(ftime * 0.051f + 2.8f + 4.2f * i) * sinf(ftime * 0.087f + 4.1f + 2.3f * i); transformation[0][2] = 0.6f * sinf(ftime * 0.087f + 4.1f + 2.3f * i) * sinf(ftime * 0.077f + 3.2f + 6.1f * i); transformation[1][0] = 0.5f * sinf(ftime * 0.077f + 3.2f + 6.1f * i) * sinf(ftime * 0.028f + 7.1f + 1.9f * i); transformation[1][1] = 0.5f * sinf(ftime * 0.028f + 7.1f + 1.9f * i) * sinf(ftime * 0.095f + 2.3f + 0.7f * i); transformation[1][2] = 0.6f * sinf(ftime * 0.095f + 2.3f + 0.7f * i) * sinf(ftime * 0.133f + 0.3f + 1.3f * i); DrawQuad(transformation, 1.0f); } // Copy backbuffer to texture if (pass < num_passes - 3) { textureManager.getTextureID(TM_HIGHLIGHT_NAME, &textureID, errorText); glBindTexture(GL_TEXTURE_2D, textureID); glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, X_HIGHLIGHT, Y_HIGHLIGHT); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, textureID); } else if (pass < num_passes - 1) { textureManager.getTextureID(TM_OFFSCREEN_NAME, &textureID, errorText); glBindTexture(GL_TEXTURE_2D, textureID); glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, X_OFFSCREEN, Y_OFFSCREEN); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, textureID); } } #if 0 // Copy backbuffer to front (so far no improvement) int xres = windowRect.right - windowRect.left; int yres = windowRect.bottom - windowRect.top; glViewport(0, 0, xres, yres); shaderManager.getProgramID("SimpleTexture.gprg", &programID, errorText); glUseProgram(programID); loc = glGetUniformLocation(programID, "time"); glUniform1f(loc, (float)(t * 0.001f)); glColor4f(1.0f, 1.0f, 1.0f, 1.0f); glDisable(GL_BLEND); glBegin(GL_QUADS); glTexCoord2f(0.0f, 0.0f); glVertex2f(-1.0f, -1.0f); glTexCoord2f(1.0f, 0.0f); glVertex2f(1.0f, -1.0f); glTexCoord2f(1.0f, 1.0f); glVertex2f(1.0f, 1.0f); glTexCoord2f(0.0f, 1.0f); glVertex2f(-1.0f, 1.0f); glEnd(); #endif }
int main(int argc, char *argv[]) { // initialize sdl int init_flags = SDL_INIT_VIDEO | SDL_INIT_TIMER; int sdl_flags = SDL_OPENGL;// | SDL_FULLSCREEN; if (SDL_Init(init_flags) != 0) { fprintf(stderr, "Error initializing SDL: %s\n", SDL_GetError()); return 1; } atexit(SDL_Quit); SDL_EnableKeyRepeat(0, 0); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); SDL_Surface *screen = SDL_SetVideoMode(640, 480, 16, sdl_flags); // initialize opengl glEnable(GL_TEXTURE_2D); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glEnable (GL_BLEND); glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glViewport(0, 0, 640, 480); glClear(GL_COLOR_BUFFER_BIT); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0f, 1.0f, 1.0f, 0.0f, -1.0f, 1.0f); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); // load images const char * img_file = "vw_topview.png"; const char * bg_file = "400px-Trollface.jpg"; GLuint car = safeImgLoad(img_file); GLuint bg = safeImgLoad(bg_file); //create world Car a; // start main loop SDL_Event event; char * keyname; int i = 0; while(true) { glClear(GL_COLOR_BUFFER_BIT); //printf("%lf, %lf, %lf\n", a.location.x, a.location.y, a.direction); drawScene(a, car, bg); SDL_GL_SwapBuffers(); SDL_Delay(50); while(SDL_PollEvent(&event) == 1) { switch(event.type) { case SDL_KEYDOWN: switch(event.key.keysym.sym) { case SDLK_q: exit(0); break; case SDLK_a: a.wheel(-1.5); break; case SDLK_d: a.wheel(1.5); break; default: keyname = SDL_GetKeyName(event.key.keysym.sym); printf("key pressed: %s\n", keyname); } break; case SDL_KEYUP: switch(event.key.keysym.sym) { case SDLK_a: a.wheel(0.0); break; case SDLK_d: a.wheel(0.0); break; default: keyname = SDL_GetKeyName(event.key.keysym.sym); printf("key released: %s\n", keyname); } break; default: printf("other event\n"); } } for (int n = 0; n < 10; n++) a.move(.005); i++; } }
void IrrDriver::renderGLSL(float dt) { World *world = World::getWorld(); // Never NULL. // Overrides video::SOverrideMaterial &overridemat = m_video_driver->getOverrideMaterial(); overridemat.EnablePasses = scene::ESNRP_SOLID | scene::ESNRP_TRANSPARENT; overridemat.EnableFlags = 0; if (m_wireframe) { overridemat.Material.Wireframe = 1; overridemat.EnableFlags |= video::EMF_WIREFRAME; } if (m_mipviz) { overridemat.Material.MaterialType = m_shaders->getShader(ES_MIPVIZ); overridemat.EnableFlags |= video::EMF_MATERIAL_TYPE; overridemat.EnablePasses = scene::ESNRP_SOLID; } // Get a list of all glowing things. The driver's list contains the static ones, // here we add items, as they may disappear each frame. std::vector<GlowData> glows = m_glowing; std::vector<GlowNode *> transparent_glow_nodes; ItemManager * const items = ItemManager::get(); const u32 itemcount = items->getNumberOfItems(); u32 i; // For each static node, give it a glow representation const u32 staticglows = glows.size(); for (i = 0; i < staticglows; i++) { scene::ISceneNode * const node = glows[i].node; const float radius = (node->getBoundingBox().getExtent().getLength() / 2) * 2.0f; GlowNode * const repnode = new GlowNode(irr_driver->getSceneManager(), radius); repnode->setPosition(node->getTransformedBoundingBox().getCenter()); transparent_glow_nodes.push_back(repnode); } for (i = 0; i < itemcount; i++) { Item * const item = items->getItem(i); if (!item) continue; const Item::ItemType type = item->getType(); if (type != Item::ITEM_NITRO_BIG && type != Item::ITEM_NITRO_SMALL && type != Item::ITEM_BONUS_BOX && type != Item::ITEM_BANANA && type != Item::ITEM_BUBBLEGUM) continue; LODNode * const lod = (LODNode *) item->getSceneNode(); if (!lod->isVisible()) continue; const int level = lod->getLevel(); if (level < 0) continue; scene::ISceneNode * const node = lod->getAllNodes()[level]; node->updateAbsolutePosition(); GlowData dat; dat.node = node; dat.r = 1.0f; dat.g = 1.0f; dat.b = 1.0f; const video::SColorf &c = ItemManager::getGlowColor(type); dat.r = c.getRed(); dat.g = c.getGreen(); dat.b = c.getBlue(); glows.push_back(dat); // Push back its representation too const float radius = (node->getBoundingBox().getExtent().getLength() / 2) * 2.0f; GlowNode * const repnode = new GlowNode(irr_driver->getSceneManager(), radius); repnode->setPosition(node->getTransformedBoundingBox().getCenter()); transparent_glow_nodes.push_back(repnode); } // Start the RTT for post-processing. // We do this before beginScene() because we want to capture the glClear() // because of tracks that do not have skyboxes (generally add-on tracks) m_post_processing->begin(); m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_COLOR), false, false); m_video_driver->beginScene(/*backBuffer clear*/ true, /*zBuffer*/ true, world->getClearColor()); // Clear normal and depth to zero m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_NORMAL_AND_DEPTH), true, false, video::SColor(0,0,0,0)); irr_driver->getVideoDriver()->enableMaterial2D(); RaceGUIBase *rg = world->getRaceGUI(); if (rg) rg->update(dt); for(unsigned int cam = 0; cam < Camera::getNumCameras(); cam++) { Camera * const camera = Camera::getCamera(cam); scene::ICameraSceneNode * const camnode = camera->getCameraSceneNode(); #ifdef ENABLE_PROFILER std::ostringstream oss; oss << "drawAll() for kart " << cam << std::flush; PROFILER_PUSH_CPU_MARKER(oss.str().c_str(), (cam+1)*60, 0x00, 0x00); #endif camera->activate(); rg->preRenderCallback(camera); // adjusts start referee const u32 bgnodes = m_background.size(); /* if (bgnodes) { // If there are background nodes (3d skybox), draw them now. m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_COLOR), false, false); m_renderpass = scene::ESNRP_SKY_BOX; m_scene_manager->drawAll(m_renderpass); const video::SOverrideMaterial prev = overridemat; overridemat.Enabled = 1; overridemat.EnableFlags = video::EMF_MATERIAL_TYPE; overridemat.Material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF; for (i = 0; i < bgnodes; i++) { m_background[i]->setPosition(camnode->getPosition() * 0.97f); m_background[i]->updateAbsolutePosition(); m_background[i]->render(); } overridemat = prev; m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_COLOR), false, true); }*/ // Fire up the MRT irr_driver->getVideoDriver()->setRenderTarget(irr_driver->getRTT(RTT_NORMAL_AND_DEPTH), false, false); PROFILER_PUSH_CPU_MARKER("- Solid Pass 1", 0xFF, 0x00, 0x00); m_renderpass = scene::ESNRP_CAMERA | scene::ESNRP_SOLID; glDepthFunc(GL_LEQUAL); glEnable(GL_DEPTH_TEST); glDisable(GL_ALPHA_TEST); glDepthMask(GL_TRUE); glDisable(GL_BLEND); glEnable(GL_CULL_FACE); irr_driver->setPhase(SOLID_NORMAL_AND_DEPTH_PASS); m_scene_manager->drawAll(m_renderpass); irr_driver->setProjMatrix(irr_driver->getVideoDriver()->getTransform(video::ETS_PROJECTION)); irr_driver->setViewMatrix(irr_driver->getVideoDriver()->getTransform(video::ETS_VIEW)); irr_driver->genProjViewMatrix(); PROFILER_POP_CPU_MARKER(); // Todo : reenable glow and shadows //ShadowImportanceProvider * const sicb = (ShadowImportanceProvider *) // irr_driver->getCallback(ES_SHADOW_IMPORTANCE); //sicb->updateIPVMatrix(); // Used to cull glowing items & lights const core::aabbox3df cambox = camnode->getViewFrustum()->getBoundingBox(); PROFILER_PUSH_CPU_MARKER("- Shadow", 0x30, 0x6F, 0x90); // Shadows if (!m_mipviz && !m_wireframe && UserConfigParams::m_shadows) //&& World::getWorld()->getTrack()->hasShadows()) { renderShadows(camnode, camera); } PROFILER_POP_CPU_MARKER(); PROFILER_PUSH_CPU_MARKER("- Light", 0x00, 0xFF, 0x00); // Lights renderLights(cambox, camnode, overridemat, cam, dt); PROFILER_POP_CPU_MARKER(); PROFILER_PUSH_CPU_MARKER("- Solid Pass 2", 0x00, 0x00, 0xFF); irr_driver->setPhase(SOLID_LIT_PASS); glEnable(GL_DEPTH_TEST); glDisable(GL_ALPHA_TEST); glDepthMask(GL_FALSE); glDisable(GL_BLEND); m_renderpass = scene::ESNRP_CAMERA | scene::ESNRP_SOLID; m_scene_manager->drawAll(m_renderpass); PROFILER_POP_CPU_MARKER(); if (World::getWorld()->getTrack()->isFogEnabled()) { PROFILER_PUSH_CPU_MARKER("- Fog", 0xFF, 0x00, 0x00); m_post_processing->renderFog(irr_driver->getInvProjMatrix()); PROFILER_POP_CPU_MARKER(); } PROFILER_PUSH_CPU_MARKER("- Glow", 0xFF, 0xFF, 0x00); // Render anything glowing. if (!m_mipviz && !m_wireframe) { irr_driver->setPhase(GLOW_PASS); renderGlow(overridemat, glows, cambox, cam); } // end glow PROFILER_POP_CPU_MARKER(); PROFILER_PUSH_CPU_MARKER("- Skybox", 0xFF, 0x00, 0xFF); renderSkybox(); PROFILER_POP_CPU_MARKER(); PROFILER_PUSH_CPU_MARKER("- Lensflare/godray", 0x00, 0xFF, 0xFF); // Is the lens flare enabled & visible? Check last frame's query. const bool hasflare = World::getWorld()->getTrack()->hasLensFlare(); const bool hasgodrays = World::getWorld()->getTrack()->hasGodRays(); if (true)//hasflare || hasgodrays) { irr::video::COpenGLDriver* gl_driver = (irr::video::COpenGLDriver*)m_device->getVideoDriver(); GLuint res = 0; if (m_query_issued) gl_driver->extGlGetQueryObjectuiv(m_lensflare_query, GL_QUERY_RESULT, &res); m_post_processing->setSunPixels(res); // Prepare the query for the next frame. glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); gl_driver->extGlBeginQuery(GL_SAMPLES_PASSED_ARB, m_lensflare_query); m_scene_manager->setCurrentRendertime(scene::ESNRP_SOLID); m_scene_manager->drawAll(scene::ESNRP_CAMERA); irr_driver->setPhase(GLOW_PASS); m_sun_interposer->render(); gl_driver->extGlEndQuery(GL_SAMPLES_PASSED_ARB); m_query_issued = true; m_lensflare->setStrength(res / 4000.0f); if (hasflare) m_lensflare->OnRegisterSceneNode(); // Make sure the color mask is reset glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); } PROFILER_POP_CPU_MARKER(); // We need to re-render camera due to the per-cam-node hack. PROFILER_PUSH_CPU_MARKER("- Transparent Pass", 0xFF, 0x00, 0x00); irr_driver->setPhase(TRANSPARENT_PASS); m_renderpass = scene::ESNRP_CAMERA | scene::ESNRP_TRANSPARENT; glEnable(GL_DEPTH_TEST); glDisable(GL_ALPHA_TEST); glDepthMask(GL_FALSE); glEnable(GL_BLEND); glBlendEquation(GL_FUNC_ADD); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_CULL_FACE); m_scene_manager->drawAll(m_renderpass); PROFILER_POP_CPU_MARKER(); PROFILER_PUSH_CPU_MARKER("- Particles", 0xFF, 0xFF, 0x00); m_renderpass = scene::ESNRP_CAMERA | scene::ESNRP_TRANSPARENT_EFFECT; glDepthMask(GL_FALSE); glDisable(GL_CULL_FACE); glEnable(GL_BLEND); glBlendEquation(GL_FUNC_ADD); m_scene_manager->drawAll(m_renderpass); PROFILER_POP_CPU_MARKER(); PROFILER_PUSH_CPU_MARKER("- Displacement", 0x00, 0x00, 0xFF); // Handle displacing nodes, if any const u32 displacingcount = m_displacing.size(); if (displacingcount) { renderDisplacement(overridemat, cam); } PROFILER_POP_CPU_MARKER(); // Drawing for this cam done, cleanup const u32 glowrepcount = transparent_glow_nodes.size(); for (i = 0; i < glowrepcount; i++) { transparent_glow_nodes[i]->remove(); transparent_glow_nodes[i]->drop(); } PROFILER_POP_CPU_MARKER(); // Note that drawAll must be called before rendering // the bullet debug view, since otherwise the camera // is not set up properly. This is only used for // the bullet debug view. if (UserConfigParams::m_artist_debug_mode) World::getWorld()->getPhysics()->draw(); } // for i<world->getNumKarts() PROFILER_PUSH_CPU_MARKER("Postprocessing", 0xFF, 0xFF, 0x00); // Render the post-processed scene m_post_processing->render(); PROFILER_POP_CPU_MARKER(); // Set the viewport back to the full screen for race gui m_video_driver->setViewPort(core::recti(0, 0, UserConfigParams::m_width, UserConfigParams::m_height)); for(unsigned int i=0; i<Camera::getNumCameras(); i++) { Camera *camera = Camera::getCamera(i); char marker_name[100]; sprintf(marker_name, "renderPlayerView() for kart %d", i); PROFILER_PUSH_CPU_MARKER(marker_name, 0x00, 0x00, (i+1)*60); rg->renderPlayerView(camera, dt); PROFILER_POP_CPU_MARKER(); } // for i<getNumKarts PROFILER_PUSH_CPU_MARKER("GUIEngine", 0x75, 0x75, 0x75); // Either render the gui, or the global elements of the race gui. GUIEngine::render(dt); PROFILER_POP_CPU_MARKER(); // Render the profiler if(UserConfigParams::m_profiler_enabled) { PROFILER_DRAW(); } #ifdef DEBUG drawDebugMeshes(); #endif PROFILER_PUSH_CPU_MARKER("EndSccene", 0x45, 0x75, 0x45); m_video_driver->endScene(); PROFILER_POP_CPU_MARKER(); getPostProcessing()->update(dt); }
void App::Run() { SDL_Init(SDL_INIT_EVERYTHING); Engine::Get().Resize(Engine::Get().getWindowWidth(), Engine::Get().getWindowHeigth()); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); glClearColor(0.3, 0.66, 0.89, 0); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glEnable(GL_TEXTURE_2D); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); const std::string atlas_filename = "data/tex.png"; Engine& engine = Engine::Get(); engine.Load(); engine.getRenderer()->LoadTexture(atlas_filename); if (Engine::Get().getPlayerSprite() == PT::Ninja) { m_player->setSprites(SpritePtr(new Sprite(engine.getSpriteConfig()->Get("ninja_right"))), SpritePtr(new Sprite(engine.getSpriteConfig()->Get("ninja_left"))), SpritePtr(new Sprite(engine.getSpriteConfig()->Get("ninja_stop")))); } else if (Engine::Get().getPlayerSprite() == PT::Samurai) { m_player->setSprites(SpritePtr(new Sprite(engine.getSpriteConfig()->Get("samurai_right"))), SpritePtr(new Sprite(engine.getSpriteConfig()->Get("samurai_left"))), SpritePtr(new Sprite(engine.getSpriteConfig()->Get("samurai_stop")))); } in_game = true; size_t last_ticks = SDL_GetTicks(); Engine::Get().setGameState(GS::Menu); while (Engine::Get().getState() != GS::Quit) { switch (Engine::Get().getState()) { case GS::InGame: ProcessEvents(); break; case GS::HallOfFame: if (!m_hall_of_fame->isActual()) m_hall_of_fame.reset(new HallOfFame()); m_hall_of_fame->proccessEvents(); break; case GS::ScoreSubmit: m_score_submit->ProcessEvents(); break; case GS::Menu: m_menu->ProcessEvents(); break; case GS::Options: m_options->processEvents(); } size_t ticks = SDL_GetTicks(); delta_time = (ticks - last_ticks) / (CLOCKS_PER_SEC/10.0); if ((delta_time*(CLOCKS_PER_SEC / 10.0)) < ((CLOCKS_PER_SEC / 10.0) / Engine::Get().fps)) SDL_Delay(((CLOCKS_PER_SEC / 10.0) / Engine::Get().fps) - (delta_time*(CLOCKS_PER_SEC / 10.0))); delta_time = ((CLOCKS_PER_SEC / 10.0) / Engine::Get().fps)/ (CLOCKS_PER_SEC / 10.0); last_ticks = ticks; switch (Engine::Get().getState()) { case GS::InGame: if (delta_time > 0.0) { Update(delta_time); } Draw(); break; case GS::HallOfFame: m_hall_of_fame->draw(); break; case GS::ScoreSubmit: m_score_submit->Draw(); break; case GS::Menu: m_menu->Draw(); break; case GS::Options: m_options->draw(); break; } } SDL_Quit(); }
int main() { float retinaScale = 1.f; b3gDefaultOpenGLWindow* window = new b3gDefaultOpenGLWindow(); b3gWindowConstructionInfo wci; wci.m_width = sWidth; wci.m_height = sHeight; window->createWindow(wci); window->setResizeCallback(MyResizeCallback); window->setWindowTitle("render test"); #ifndef __APPLE__ glewInit(); #endif retinaScale = window->getRetinaScale(); primRenderer = new GLPrimitiveRenderer(sWidth,sHeight); sth_stash* font = initFont(primRenderer ); gwenRenderer = new GwenOpenGL3CoreRenderer(primRenderer,font,sWidth,sHeight,retinaScale); // // Create a GWEN OpenGL Renderer // // Gwen::Renderer::OpenGL_DebugFont * pRenderer = new Gwen::Renderer::OpenGL_DebugFont(); // // Create a GWEN skin // #ifdef USE_TEXTURED_SKIN Gwen::Skin::TexturedBase skin; skin.SetRender( pRenderer ); skin.Init("DefaultSkin.png"); #else Gwen::Skin::Simple skin; skin.SetRender( gwenRenderer ); #endif // // Create a Canvas (it's root, on which all other GWEN panels are created) // pCanvas = new Gwen::Controls::Canvas( &skin ); pCanvas->SetSize( sWidth, sHeight); pCanvas->SetDrawBackground( true ); pCanvas->SetBackgroundColor( Gwen::Color( 150, 170, 170, 255 ) ); window->setMouseButtonCallback(MyMouseButtonCallback); window->setMouseMoveCallback(MyMouseMoveCallback); // // Create our unittest control (which is a Window with controls in it) // UnitTest* pUnit = new UnitTest( pCanvas ); pUnit->SetPos( 10, 10 ); // // Create a Windows Control helper // (Processes Windows MSG's and fires input at GWEN) // //Gwen::Input::Windows GwenInput; //GwenInput.Initialize( pCanvas ); // // Begin the main game loop // // MSG msg; while( !window->requestedExit() ) { // Skip out if the window is closed //if ( !IsWindowVisible( g_pHWND ) ) //break; // If we have a message from windows.. // if ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) ) { // .. give it to the input handler to process // GwenInput.ProcessMessage( msg ); // if it's QUIT then quit.. // if ( msg.message == WM_QUIT ) // break; // Handle the regular window stuff.. // TranslateMessage(&msg); // DispatchMessage(&msg); } window->startRendering(); // Main OpenGL Render Loop { glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); glEnable(GL_BLEND); GLint err = glGetError(); assert(err==GL_NO_ERROR); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); err = glGetError(); assert(err==GL_NO_ERROR); err = glGetError(); assert(err==GL_NO_ERROR); glDisable(GL_DEPTH_TEST); err = glGetError(); assert(err==GL_NO_ERROR); //glColor4ub(255,0,0,255); err = glGetError(); assert(err==GL_NO_ERROR); err = glGetError(); assert(err==GL_NO_ERROR); glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); // saveOpenGLState(width,height);//m_glutScreenWidth,m_glutScreenHeight); err = glGetError(); assert(err==GL_NO_ERROR); err = glGetError(); assert(err==GL_NO_ERROR); glDisable(GL_CULL_FACE); glDisable(GL_DEPTH_TEST); err = glGetError(); assert(err==GL_NO_ERROR); err = glGetError(); assert(err==GL_NO_ERROR); glEnable(GL_BLEND); err = glGetError(); assert(err==GL_NO_ERROR); pCanvas->RenderCanvas(); // SwapBuffers( GetDC( g_pHWND ) ); } window->endRendering(); } window->closeWindow(); delete window; }
void ParticleSystem::drawHighlight() { /* // just draw points: glDisable(GL_TEXTURE_2D); glDisable(GL_LIGHTING); glColor4f(1,1,1,1); glBegin(GL_POINTS); for (ParticleList::iterator it = particles.begin(); it != particles.end(); ++it) { glVertex3fv(it->tpos); } glEnd(); glEnable(GL_LIGHTING); glEnable(GL_TEXTURE_2D); */ Vec3D bv0, bv1, bv2, bv3; // setup blend mode switch (blend) { case 0: glDisable(GL_BLEND); glDisable(GL_ALPHA_TEST); break; case 1: glEnable(GL_BLEND); glBlendFunc(GL_SRC_COLOR, GL_ONE); glDisable(GL_ALPHA_TEST); break; case 2: glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_ALPHA_TEST); break; case 3: glDisable(GL_BLEND); glEnable(GL_ALPHA_TEST); break; case 4: glEnable(GL_BLEND); glDisable(GL_ALPHA_TEST); glBlendFunc(GL_SRC_ALPHA, GL_ONE); break; } glDisable(GL_LIGHTING); glDisable(GL_CULL_FACE); glDepthMask(GL_FALSE); // glPushName(texture); _texture->bind(); Matrix mbb; mbb.unit(); ModelHighlight(Vec4D(1.00, 0.25, 0.25, 0.50)); if (billboard) { // get a billboard matrix Matrix mtrans; glGetFloatv(GL_MODELVIEW_MATRIX, &(mtrans.m[0][0])); mtrans.transpose(); mtrans.invert(); Vec3D camera = mtrans * Vec3D(0, 0, 0); Vec3D look = (camera - pos).normalize(); Vec3D up = ((mtrans * Vec3D(0, 1, 0)) - camera).normalize(); Vec3D right = (up % look).normalize(); up = (look % right).normalize(); // calculate the billboard matrix mbb.m[0][1] = right.x; mbb.m[1][1] = right.y; mbb.m[2][1] = right.z; mbb.m[0][2] = up.x; mbb.m[1][2] = up.y; mbb.m[2][2] = up.z; mbb.m[0][0] = look.x; mbb.m[1][0] = look.y; mbb.m[2][0] = look.z; } if (type == 0 || type == 2) { //! \todo figure out type 2 (deeprun tram subway sign) // - doesn't seem to be any different from 0 -_- // regular particles float f = 0.707106781f; // sqrt(2)/2 if (billboard) { bv0 = mbb * Vec3D(0, -f, +f); bv1 = mbb * Vec3D(0, +f, +f); bv2 = mbb * Vec3D(0, +f, -f); bv3 = mbb * Vec3D(0, -f, -f); } else { bv0 = Vec3D(-f, 0, +f); bv1 = Vec3D(+f, 0, +f); bv2 = Vec3D(+f, 0, -f); bv3 = Vec3D(-f, 0, -f); } //! \todo per-particle rotation in a non-expensive way?? :| glBegin(GL_QUADS); for (ParticleList::iterator it = particles.begin(); it != particles.end(); ++it) { //glColor4fv(it->color); glColor4f(1.0f, 0.25f, 0.25f, it->color.w*0.5f); glTexCoord2fv(tiles[it->tile].tc[0]); glVertex3fv(it->pos + bv0 * it->size); glTexCoord2fv(tiles[it->tile].tc[1]); glVertex3fv(it->pos + bv1 * it->size); glTexCoord2fv(tiles[it->tile].tc[2]); glVertex3fv(it->pos + bv2 * it->size); glTexCoord2fv(tiles[it->tile].tc[3]); glVertex3fv(it->pos + bv3 * it->size); } glEnd(); } else if (type == 1) { // particles from origin to position bv0 = mbb * Vec3D(0, -1.0f, 0); bv1 = mbb * Vec3D(0, +1.0f, 0); glBegin(GL_QUADS); for (ParticleList::iterator it = particles.begin(); it != particles.end(); ++it) { glColor4fv(it->color); glTexCoord2fv(tiles[it->tile].tc[0]); glVertex3fv(it->pos + bv0 * it->size); glTexCoord2fv(tiles[it->tile].tc[1]); glVertex3fv(it->pos + bv1 * it->size); glTexCoord2fv(tiles[it->tile].tc[2]); glVertex3fv(it->origin + bv1 * it->size); glTexCoord2fv(tiles[it->tile].tc[3]); glVertex3fv(it->origin + bv0 * it->size); } glEnd(); } ModelUnhighlight(); glEnable(GL_LIGHTING); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDepthMask(GL_TRUE); glColor4f(1, 1, 1, 1); // glPopName(); }
void display(void) { curTime = timeGetTime(); float dt = (float)(curTime - lastTime) * 0.001;//secに変換 elapseTime1 += dt; elapseTime2 += dt; fps ++; if(elapseTime1 >= 1.0) { printf("frame per sec = %d \n", fps); elapseTime1 = 0.0; fps = 0; } lastTime = curTime; //カラーバッファ,デプスバッファのクリア glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity();//視点を変えるときはこの位置に必要 if(cos(M_PI * view.theta /180.0) >= 0.0)//カメラ仰角90度でビューアップベクトル切替 gluLookAt(view.pos[0], view.pos[1], view.pos[2], view.cnt[0], view.cnt[1], view.cnt[2], 0.0, 1.0, 0.0); else gluLookAt(view.pos[0], view.pos[1], view.pos[2], view.cnt[0], view.cnt[1], view.cnt[2], 0.0, -1.0, 0.0); //光源設定//'l'を押した後光源位置可変 glLightfv(GL_LIGHT0, GL_POSITION, lightPos); if(flagWireframe)//'w'でwireframeとsolid model切り替え { glPolygonMode(GL_FRONT,GL_LINE); glPolygonMode(GL_BACK,GL_POINT); } else glPolygonMode(GL_FRONT_AND_BACK,GL_FILL); //描画 // シェーダプログラムの適用 glUseProgram(shaderProg); //テクスチャユニットをシェーダ側のサンプラに関連付け,レンダリング //fragment shaderのユニフォーム変数texのインデックスを取得 GLint texLoc = glGetUniformLocation(shaderProg, "tex"); glUniform1i(texLoc, 0);//GL_TEXTURE0を適用 drawTerrain(); // シェーダプログラムの適用を解除 glUseProgram(0); drawParticle(dt); drawParticle2(dt); //テクスチャ、半透明物体があるとき glDepthMask(GL_FALSE); //デプスバッファを書き込み禁止 glEnable(GL_BLEND);//アルファブレンディングを有効にする glBlendFunc(GL_DST_ALPHA,GL_ONE_MINUS_SRC_ALPHA);//色混合係数を決める //半透明描画 makeRiver(elapseTime2); drawRiver(); //テクスチャ、半透明物体があるとき glDepthMask(GL_TRUE); //デプスバッファの書き込みを許可 glDisable(GL_BLEND); if(flagHelp) { printf("矢印キーによるアフィン変換/光源移動 \n"); printf(" →,←:x軸 \n"); printf(" ↑,↓:y軸 \n"); printf(" [Shift]+↑,↓:z軸 \n"); printf(" 'r'を押した後:回転 \n"); printf(" 't'を押した後:平行移動 \n"); printf(" 's'を押した後:スケーリング \n"); printf(" 'l'を押した後、光源位置の移動可 \n"); printf("'w'でワイヤーフレームとソリッドモデル切り替え \n"); printf("マウス操作で視点変更可 \n"); printf(" dolly:中央付近を左ボタンクリックで近づき,右ボタンクリックで遠ざかる \n"); printf(" pan:左横および右横を右ボタンクリックで注視点が左右に変化する \n"); printf(" tilt:真上および真下を右ボタンクリックで注視点が上下に変化する \n"); printf(" tumble:左右にドラッグすると視点が左右に変化する \n"); printf(" crane:上下にドラッグすると視点が上下に変化する \n"); printf(" zoom:左下を右ボタンクリックでズームイン \n"); printf(" 右下を右ボタンクリックでズームアウト \n"); printf("[Shift]+'r'でリセット \n"); printf("[F1]キー:βの調整 \n"); printf("[F2]キー:σの調整 \n"); printf("[F3]キー:seedの変更 \n"); printf("[F4]キー:x方向の風力変更 \n"); flagHelp = false; } //終了 glutSwapBuffers(); }
void Building::RenderPorts() { START_PROFILE( "RenderPorts" ); int buildingDetail = g_prefsManager->GetInt( "RenderBuildingDetail" ); for( int i = 0; i < GetNumPorts(); ++i ) { Vector3 portPos; Vector3 portFront; GetPortPosition( i, portPos, portFront ); // // Render the port shape portPos.y = g_app->m_location->m_landscape.m_heightMap->GetValue( portPos.x, portPos.z ) + 0.5; Vector3 portUp = g_upVector; Matrix34 mat( portFront, portUp, portPos ); if( buildingDetail < 3 ) { g_app->m_renderer->SetObjectLighting(); s_controlPad->Render( 0.0, mat ); g_app->m_renderer->UnsetObjectLighting(); } // // Render the status light double size = 6.0; Vector3 camR = g_app->m_camera->GetRight() * size; Vector3 camU = g_app->m_camera->GetUp() * size; Vector3 statusPos = s_controlPadStatus->GetWorldMatrix( mat ).pos; if( GetPortOccupant(i).IsValid() ) glColor4f( 0.3, 1.0, 0.3, 1.0 ); else glColor4f( 1.0, 0.3, 0.3, 1.0 ); glDisable ( GL_CULL_FACE ); glEnable ( GL_TEXTURE_2D ); glBindTexture ( GL_TEXTURE_2D, g_app->m_resource->GetTexture( "textures/starburst.bmp" ) ); glDepthMask ( false ); glEnable ( GL_BLEND ); glBlendFunc ( GL_SRC_ALPHA, GL_ONE ); glBegin( GL_QUADS ); glTexCoord2i( 0, 0 ); glVertex3dv( (statusPos - camR - camU).GetData() ); glTexCoord2i( 1, 0 ); glVertex3dv( (statusPos + camR - camU).GetData() ); glTexCoord2i( 1, 1 ); glVertex3dv( (statusPos + camR + camU).GetData() ); glTexCoord2i( 0, 1 ); glVertex3dv( (statusPos - camR + camU).GetData() ); glEnd(); glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); glDisable ( GL_BLEND ); glDepthMask ( true ); glDisable ( GL_TEXTURE_2D ); glEnable ( GL_CULL_FACE ); } END_PROFILE( "RenderPorts" ); }
void ParticleSystem::draw() { /* // just draw points: glDisable(GL_TEXTURE_2D); glDisable(GL_LIGHTING); glColor4f(1,1,1,1); glBegin(GL_POINTS); for (ParticleList::iterator it = particles.begin(); it != particles.end(); ++it) { glVertex3fv(it->tpos); } glEnd(); glEnable(GL_LIGHTING); glEnable(GL_TEXTURE_2D); */ // setup blend mode switch (blend) { case 0: glDisable(GL_BLEND); glDisable(GL_ALPHA_TEST); break; case 1: glEnable(GL_BLEND); glBlendFunc(GL_SRC_COLOR, GL_ONE); glDisable(GL_ALPHA_TEST); break; case 2: glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_ALPHA_TEST); break; case 3: glDisable(GL_BLEND); glEnable(GL_ALPHA_TEST); break; case 4: glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE); glDisable(GL_ALPHA_TEST); break; } //glDisable(GL_LIGHTING); //glDisable(GL_CULL_FACE); //glDepthMask(GL_FALSE); // glPushName(texture); _texture->bind(); /* if (supportPointSprites && rows==1 && cols==1) { // This is how will our point sprite's size will be modified by // distance from the viewer float quadratic[] = {0.1f, 0.0f, 0.5f}; //float quadratic[] = {0.88f, 0.001f, 0.000004f}; glPointParameterfvARB( GL_POINT_DISTANCE_ATTENUATION_ARB, quadratic); // Query for the max point size supported by the hardware float maxSize = 512.0f; //glGetFloatv(GL_POINT_SIZE_MAX_ARB, &maxSize ); // Clamp size to 100.0f or the sprites could get a little too big on some // of the newer graphic cards. My ATI card at home supports a max point // size of 1024.0f! //if( maxSize > 100.0f ) // maxSize = 100.0f; glPointSize(maxSize); // The alpha of a point is calculated to allow the fading of points // instead of shrinking them past a defined threshold size. The threshold // is defined by GL_POINT_FADE_THRESHOLD_SIZE_ARB and is not clamped to // the minimum and maximum point sizes. glPointParameterfARB(GL_POINT_FADE_THRESHOLD_SIZE_ARB, 60.0f); glPointParameterfARB(GL_POINT_SIZE_MIN_ARB, 1.0f ); glPointParameterfARB(GL_POINT_SIZE_MAX_ARB, maxSize ); // Specify point sprite texture coordinate replacement mode for each texture unit glTexEnvf(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE); // Render point sprites... glEnable(GL_POINT_SPRITE_ARB); glBegin(GL_POINTS); { for (ParticleList::iterator it = particles.begin(); it != particles.end(); ++it) { glPointSize(it->size); glTexCoord2fv(tiles[it->tile].tc[0]); glColor4fv(it->color); glVertex3fv(it->pos); } } glEnd(); glDisable(GL_POINT_SPRITE_ARB); glTexEnvf(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_FALSE); } else { // Old slow method */ Vec3D vRight(1, 0, 0); Vec3D vUp(0, 1, 0); // position stuff const float f = 1;//0.707106781f; // sqrt(2)/2 Vec3D bv0 = Vec3D(-f, +f, 0); Vec3D bv1 = Vec3D(+f, +f, 0); Vec3D bv2 = Vec3D(+f, -f, 0); Vec3D bv3 = Vec3D(-f, -f, 0); if (billboard) { float modelview[16]; glGetFloatv(GL_MODELVIEW_MATRIX, modelview); vRight = Vec3D(modelview[0], modelview[4], modelview[8]); vUp = Vec3D(modelview[1], modelview[5], modelview[9]); // Spherical billboarding //vUp = Vec3D(0,1,0); // Cylindrical billboarding } /* * type: * 0 "normal" particle * 1 large quad from the particle's origin to its position (used in Moonwell water effects) * 2 seems to be the same as 0 (found some in the Deeprun Tram blinky-lights-sign thing) */ if (type == 0 || type == 2) { //! \todo figure out type 2 (deeprun tram subway sign) // - doesn't seem to be any different from 0 -_- // regular particles if (billboard) { glBegin(GL_QUADS); //! \todo per-particle rotation in a non-expensive way?? :| for (ParticleList::iterator it = particles.begin(); it != particles.end(); ++it) { if (tiles.size() - 1 < it->tile) // Alfred, 2009.08.07, error prevent break; const float size = it->size;// / 2; glColor4fv(it->color); glTexCoord2fv(tiles[it->tile].tc[0]); glVertex3fv(it->pos - (vRight + vUp) * size); glTexCoord2fv(tiles[it->tile].tc[1]); glVertex3fv(it->pos + (vRight - vUp) * size); glTexCoord2fv(tiles[it->tile].tc[2]); glVertex3fv(it->pos + (vRight + vUp) * size); glTexCoord2fv(tiles[it->tile].tc[3]); glVertex3fv(it->pos - (vRight - vUp) * size); } glEnd(); } else { glBegin(GL_QUADS); for (ParticleList::iterator it = particles.begin(); it != particles.end(); ++it) { if (tiles.size() - 1 < it->tile) // Alfred, 2009.08.07, error prevent break; glColor4fv(it->color); glTexCoord2fv(tiles[it->tile].tc[0]); glVertex3fv(it->pos + it->corners[0] * it->size); glTexCoord2fv(tiles[it->tile].tc[1]); glVertex3fv(it->pos + it->corners[1] * it->size); glTexCoord2fv(tiles[it->tile].tc[2]); glVertex3fv(it->pos + it->corners[2] * it->size); glTexCoord2fv(tiles[it->tile].tc[3]); glVertex3fv(it->pos + it->corners[3] * it->size); } glEnd(); } } else if (type == 1) { // Sphere particles // particles from origin to position /* bv0 = mbb * Vec3D(0,-1.0f,0); bv1 = mbb * Vec3D(0,+1.0f,0); bv0 = mbb * Vec3D(-1.0f,0,0); bv1 = mbb * Vec3D(1.0f,0,0); */ glBegin(GL_QUADS); for (ParticleList::iterator it = particles.begin(); it != particles.end(); ++it) { if (tiles.size() - 1 < it->tile) // Alfred, 2009.08.07, error prevent break; glColor4fv(it->color); glTexCoord2fv(tiles[it->tile].tc[0]); glVertex3fv(it->pos + bv0 * it->size); glTexCoord2fv(tiles[it->tile].tc[1]); glVertex3fv(it->pos + bv1 * it->size); glTexCoord2fv(tiles[it->tile].tc[2]); glVertex3fv(it->origin + bv1 * it->size); glTexCoord2fv(tiles[it->tile].tc[3]); glVertex3fv(it->origin + bv0 * it->size); } glEnd(); } //} //glEnable(GL_LIGHTING); //glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); //glDepthMask(GL_TRUE); //glColor4f(1.0f, 1.0f, 1.0f, 1.0f); }
void GLCanvas::renderSkeleton() { Vector3 lookAt = _cameraPosition + _cameraFront; gluLookAt(_cameraPosition.x(), _cameraPosition.y(), _cameraPosition.z(), lookAt.x() , lookAt.y() , lookAt.z(), _cameraUp.x() , _cameraUp.y() , _cameraUp.z()); if (_style & DRAW_GRID) { drawGrid(); } if (_skeleton == nullptr) { return; } for (auto it = _skeleton->beginBones(); it != _skeleton->endBones(); ++it) { glPushMatrix(); Bone bone = *(it->second); int boneId = bone.getId(); // don't draw any bone without valid id if (boneId < 0) { continue; } // get the bone id as color for SELECTION_MODE GLubyte boneIdColor[4] = {GLubyte((boneId >> 8) & 255), GLubyte((boneId >> 8) & 255), GLubyte(boneId & 255), 255}; const GLubyte* boneColor1 = boneStandardColor1; const GLubyte* boneColor2 = boneStandardColor2; if (_style & SELECTION_MODE) { boneColor1 = boneIdColor; boneColor2 = boneIdColor; } else if (_style & HIGHLIGHT_SELECTED_BONE && bone.getId() == _skeleton->getSelectedBoneId()) { boneColor1 = boneHighlightedColor1; boneColor2 = boneHighlightedColor2; } Vector3 startPos = bone.getStartPos(); glTranslatef(startPos.x(), startPos.y(), startPos.z()); float length = bone.getLength(); Vector3 dir = bone.getDirection(); Vector3 up = bone.getUpDirection(); Vector3 right = bone.getRightDirection(); Vector3 endPos = dir*length; startPos = Vector3(0, 0, 0); float length_10 = length * 0.1f; Vector3 endPos_10 = endPos * 0.1f; Vector3 upPoint = up*length_10 + endPos_10; Vector3 downPoint = - up*length_10 + endPos_10; Vector3 rightPoint = right*length_10 + endPos_10; Vector3 leftPoint = - right*length_10 + endPos_10; if (!(_style & SELECTION_MODE)) { //set point size to 10 pixels glPointSize(10.0f); glColor4ubv(pointColor); // TODO(JK#9#): maybe don't draw points for bones (or add render style flag) glBegin(GL_POINTS); glVertex3f(endPos.x(), endPos.y(), endPos.z()); glEnd(); } // set line width glLineWidth(_lineWidth); // draw local coordinate system if (_style & DRAW_LOCAL_COORDINATE_SYSTEM) { glBegin(GL_LINES); glColor4ubv(red); glVertex3f(endPos.x(), endPos.y(), endPos.z()); glVertex3f(endPos.x() + dir.x()*0.1f, endPos.y() + dir.y()*0.1f, endPos.z() + dir.z()*0.1f); glColor4ubv(green); glVertex3f(endPos.x(), endPos.y(), endPos.z()); glVertex3f(endPos.x() + up.x()*0.1f, endPos.y() + up.y()*0.1f, endPos.z() + up.z()*0.1f); glColor4ubv(blue); glVertex3f(endPos.x(), endPos.y(), endPos.z()); glVertex3f(endPos.x() + right.x()*0.1f, endPos.y() + right.y()*0.1f, endPos.z() + right.z()*0.1f); glEnd(); } if (_style & DRAW_ROTATION_AXIS) { Vector3 rotAxis = bone.getRelOrientation().getRotationAxis(); glBegin(GL_LINES); glColor4ubv(yellow); glVertex3f(-rotAxis.x()*0.2f, -rotAxis.y()*0.2f, -rotAxis.z()*0.2f); glVertex3f(rotAxis.x()*0.2f, rotAxis.y()*0.2f, rotAxis.z()*0.2f); glEnd(); } // draw bone glPolygonMode(GL_FRONT, GL_FILL); glColor4ubv(boneColor1); glBegin(GL_TRIANGLE_FAN); glVertex3f(0.0f, 0.0f, 0.0f); glVertex3f(upPoint.x(), upPoint.y(), upPoint.z()); glVertex3f(leftPoint.x(), leftPoint.y(), leftPoint.z()); glVertex3f(downPoint.x(), downPoint.y(), downPoint.z()); glVertex3f(rightPoint.x(), rightPoint.y(), rightPoint.z()); glVertex3f(upPoint.x(), upPoint.y(), upPoint.z()); glEnd(); glColor4ubv(boneColor2); glBegin(GL_TRIANGLE_FAN); glVertex3f(endPos.x(), endPos.y(), endPos.z()); glVertex3f(upPoint.x(), upPoint.y(), upPoint.z()); glVertex3f(rightPoint.x(), rightPoint.y(), rightPoint.z()); glVertex3f(downPoint.x(), downPoint.y(), downPoint.z()); glVertex3f(leftPoint.x(), leftPoint.y(), leftPoint.z()); glVertex3f(upPoint.x(), upPoint.y(), upPoint.z()); glEnd(); if (!(_style & SELECTION_MODE)) { // draw black mesh lines around bones glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); glColor4ubv(black); glBegin(GL_TRIANGLE_FAN); glVertex3f(0.0f, 0.0f, 0.0f); glVertex3f(upPoint.x(), upPoint.y(), upPoint.z()); glVertex3f(leftPoint.x(), leftPoint.y(), leftPoint.z()); glVertex3f(downPoint.x(), downPoint.y(), downPoint.z()); glVertex3f(rightPoint.x(), rightPoint.y(), rightPoint.z()); glVertex3f(upPoint.x(), upPoint.y(), upPoint.z()); glEnd(); glBegin(GL_TRIANGLE_FAN); glVertex3f(endPos.x(), endPos.y(), endPos.z()); glVertex3f(upPoint.x(), upPoint.y(), upPoint.z()); glVertex3f(rightPoint.x(), rightPoint.y(), rightPoint.z()); glVertex3f(downPoint.x(), downPoint.y(), downPoint.z()); glVertex3f(leftPoint.x(), leftPoint.y(), leftPoint.z()); glVertex3f(upPoint.x(), upPoint.y(), upPoint.z()); glEnd(); // draw labels if (_style & DRAW_LABEL) { // glDisable(GL_DEPTH_TEST); GLImage* image = _labels.find(boneId)->second; image->setPosition(0.5f * bone.getLength() * dir - 0.06f * bone.getLength() * _cameraFront); image->render(); // glEnable(GL_DEPTH_TEST); } } // reset line width glLineWidth(1.0f); if (_style & DRAW_SPIN_ARROWS && bone.getId() == _skeleton->getSelectedBoneId()) { drawSpinArrows(endPos - 0.2 * bone.getLength() * dir, dir, up, right); } glPopMatrix(); // append trace point and draw trace if (_traceLength > 0) { Vector3 globalEndPos = bone.getEndPos(); std::map<int, std::vector<Vector3> >::iterator traceIt = _boneIdsWithTracePoints.find(boneId); if (traceIt != _boneIdsWithTracePoints.end()) { if (traceIt->second.size() < _traceLength) { traceIt->second.push_back(globalEndPos); } else { traceIt->second[_tracePos] = globalEndPos; } glBegin(GL_LINES); glColor4ubv(yellow); for (size_t i = 0; i < traceIt->second.size() - 1; ++i) { if (i != _tracePos) { glVertex3f(traceIt->second[i].x(), traceIt->second[i].y(), traceIt->second[i].z()); glVertex3f(traceIt->second[i+1].x(), traceIt->second[i+1].y(), traceIt->second[i+1].z()); } } // draw gab between end and beginning of the vector data if (traceIt->second.size() > 1 && _tracePos != traceIt->second.size() - 1) { glVertex3f(traceIt->second.back().x(), traceIt->second.back().y(), traceIt->second.back().z()); glVertex3f(traceIt->second[0].x(), traceIt->second[0].y(), traceIt->second[0].z()); } glEnd(); } } } // draw joints (after everything else, as they are transparent and need everything else be rendered) if (_style & DRAW_JOINT_CONSTRAINTS) { for (auto it = _skeleton->beginBones(); it != _skeleton->endBones(); ++it) { glPushMatrix(); Bone bone = *(it->second); Vector3 startPos = bone.getStartPos(); glTranslatef(startPos.x(), startPos.y(), startPos.z()); JointConstraint constraint = bone.getJointConstraint(); drawJoint(constraint); glPopMatrix(); } } // update trace position if (++_tracePos >= _traceLength) { _tracePos = 0; } if (!(_style & SELECTION_MODE) && _style & DRAW_AABB) { drawAABB(_skeleton->getAABB()); } } void GLCanvas::drawSpinArrows(Vector3 pos, Vector3 dir, Vector3 up, Vector3 right) const { float length = 0.03f; float offset = 0.05f; GLubyte red[4] = {255, 0, 0, 255}; GLubyte green[4] = {0, 255, 0, 255}; GLubyte blue[4] = {0, 0, 255, 255}; GLubyte black[4] = {0, 0, 0, 255}; // set arroe ids to next available free ids int idArrowDir = _skeleton->getNextFreeId(); int idArrowUp = _skeleton->getNextFreeId() + 1; int idArrowRight = _skeleton->getNextFreeId() + 2; GLubyte idArrowDirColor[4] = {GLubyte((idArrowDir >> 8) & 255), GLubyte((idArrowDir >> 8) & 255), GLubyte(idArrowDir & 255), 255}; GLubyte idArrowUpColor[4] = {GLubyte((idArrowUp >> 8) & 255), GLubyte((idArrowUp >> 8) & 255), GLubyte(idArrowUp & 255), 255}; GLubyte idArrowRightColor[4] = {GLubyte((idArrowRight >> 8) & 255), GLubyte((idArrowRight >> 8) & 255), GLubyte(idArrowRight & 255), 255}; const GLubyte* arrowDirColor = red; const GLubyte* arrowUpColor = green; const GLubyte* arrowRightColor = blue; // base points of the arrow pyramids Vector3 basePointUp = pos + up * offset; Vector3 basePointRight = pos + right * offset; Vector3 basePointDown = pos - up * offset; Vector3 basePointLeft = pos - right * offset; dir *= length; up *= length; right *= length; Vector3 dirHalf = dir * 0.5; Vector3 rightHalf = right * 0.5; // base vertices of the circle like arrow Vector3 upperCircle[4]; upperCircle[0] = basePointDown; upperCircle[1] = basePointDown - right; upperCircle[2] = basePointLeft - up; upperCircle[3] = basePointLeft; Vector3 lowerCircle[4]; lowerCircle[0] = basePointDown - up; lowerCircle[1] = basePointDown - right*1.4 - up; lowerCircle[2] = basePointLeft - right - up*1.4; lowerCircle[3] = basePointLeft - right; // the arrow rendering is done twice, one iteration for filling color, one for having black corner lines int numIterations = 2; if (_style & SELECTION_MODE) { // do not draw the corner lines in selection mode numIterations = 1; // draw the arrows with their id color arrowDirColor = idArrowDirColor; arrowUpColor = idArrowUpColor; arrowRightColor = idArrowRightColor; } // draw vertices twice, one run with filling and one with black lines for (int j = 0; j < numIterations; ++j) { if (j == 0) { glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); } else { glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); glColor4f(0.0, 0.0, 0.0, 1.0); arrowDirColor = arrowUpColor = arrowRightColor = black; } if (j == 0) { glColor4ubv(arrowUpColor); } glColor4ubv(arrowUpColor); // arrow pointing upwards glBegin(GL_TRIANGLE_FAN); glVertex3f(basePointUp.x() + up.x()*2.0, basePointUp.y() + up.y()*2.0, basePointUp.z() + up.z()*2.0); glVertex3f(basePointUp.x() + dir.x(), basePointUp.y() + dir.y(), basePointUp.z() + dir.z()); glVertex3f(basePointUp.x() + right.x(), basePointUp.y() + right.y(), basePointUp.z() + right.z()); glVertex3f(basePointUp.x() - dir.x(), basePointUp.y() - dir.y(), basePointUp.z() - dir.z()); glVertex3f(basePointUp.x() - right.x(), basePointUp.y() - right.y(), basePointUp.z() - right.z()); glVertex3f(basePointUp.x() + dir.x(), basePointUp.y() + dir.y(), basePointUp.z() + dir.z()); glEnd(); // arrow pointing downwards /* glBegin(GL_TRIANGLE_FAN); glVertex3f(basePointDown.x() - up.x(), basePointDown.y() - up.y(), basePointDown.z() - up.z()); glVertex3f(basePointDown.x() + dir.x(), basePointDown.y() + dir.y(), basePointDown.z() + dir.z()); glVertex3f(basePointDown.x() + right.x(), basePointDown.y() + right.y(), basePointDown.z() + right.z()); glVertex3f(basePointDown.x() - dir.x(), basePointDown.y() - dir.y(), basePointDown.z() - dir.z()); glVertex3f(basePointDown.x() - right.x(), basePointDown.y() - right.y(), basePointDown.z() - right.z()); glVertex3f(basePointDown.x() + dir.x(), basePointDown.y() + dir.y(), basePointDown.z() + dir.z()); glEnd(); */ if (j == 0) { glColor4f(0.0, 0.0, 1.0, 1.0); } glColor4ubv(arrowRightColor); // arrow pointing to the right glBegin(GL_TRIANGLE_FAN); glVertex3f(basePointRight.x() + right.x()*2.0, basePointRight.y() + right.y()*2.0, basePointRight.z() + right.z()*2.0); glVertex3f(basePointRight.x() + dir.x(), basePointRight.y() + dir.y(), basePointRight.z() + dir.z()); glVertex3f(basePointRight.x() - up.x(), basePointRight.y() - up.y(), basePointRight.z() - up.z()); glVertex3f(basePointRight.x() - dir.x(), basePointRight.y() - dir.y(), basePointRight.z() - dir.z()); glVertex3f(basePointRight.x() + up.x(), basePointRight.y() + up.y(), basePointRight.z() + up.z()); glVertex3f(basePointRight.x() + dir.x(), basePointRight.y() + dir.y(), basePointRight.z() + dir.z()); glEnd(); // arrow pointing to the left /* glBegin(GL_TRIANGLE_FAN); glVertex3f(basePointLeft.x() - right.x(), basePointLeft.y() - right.y(), basePointLeft.z() - right.z()); glVertex3f(basePointLeft.x() + dir.x(), basePointLeft.y() + dir.y(), basePointLeft.z() + dir.z()); glVertex3f(basePointLeft.x() - up.x(), basePointLeft.y() - up.y(), basePointLeft.z() - up.z()); glVertex3f(basePointLeft.x() - dir.x(), basePointLeft.y() - dir.y(), basePointLeft.z() - dir.z()); glVertex3f(basePointLeft.x() + up.x(), basePointLeft.y() + up.y(), basePointLeft.z() + up.z()); glVertex3f(basePointLeft.x() + dir.x(), basePointLeft.y() + dir.y(), basePointLeft.z() + dir.z()); glEnd(); */ if (j == 0) { glColor4f(1.0, 0.0, 0.0, 1.0); } glColor4ubv(arrowDirColor); glBegin(GL_TRIANGLE_FAN); // top of arrow glVertex3f(basePointLeft.x() - rightHalf.x() + up.x()*2.0, basePointLeft.y() - rightHalf.y() + up.y()*2.0, basePointLeft.z() - rightHalf.z() + up.z()*2.0); glVertex3f(basePointLeft.x() + rightHalf.x(), basePointLeft.y() + rightHalf.y(), basePointLeft.z() + rightHalf.z()); glVertex3f(basePointLeft.x() - rightHalf.x() + dir.x(), basePointLeft.y() - rightHalf.y() + dir.y(), basePointLeft.z() - rightHalf.z() + dir.z()); glVertex3f(basePointLeft.x() - right.x() - rightHalf.x(), basePointLeft.y() - right.y() - rightHalf.y(), basePointLeft.z() - right.z() - rightHalf.z()); glVertex3f(basePointLeft.x() - rightHalf.x() - dir.x(), basePointLeft.y() - rightHalf.y() - dir.y(), basePointLeft.z() - rightHalf.z() - dir.z()); glVertex3f(basePointLeft.x() + rightHalf.x(), basePointLeft.y() + rightHalf.y(), basePointLeft.z() + rightHalf.z()); glEnd(); // draw arrows base glBegin(GL_QUAD_STRIP); for (int i = 0; i < 4; ++i) { glVertex3f(upperCircle[i].x() + dirHalf.x(), upperCircle[i].y() + dirHalf.y(), upperCircle[i].z() + dirHalf.z()); glVertex3f(upperCircle[i].x() - dirHalf.x(), upperCircle[i].y() - dirHalf.y(), upperCircle[i].z() - dirHalf.z()); } for (int i = 3; i >= 0; --i) { glVertex3f(lowerCircle[i].x() + dirHalf.x(), lowerCircle[i].y() + dirHalf.y(), lowerCircle[i].z() + dirHalf.z()); glVertex3f(lowerCircle[i].x() - dirHalf.x(), lowerCircle[i].y() - dirHalf.y(), lowerCircle[i].z() - dirHalf.z()); } glVertex3f(upperCircle[0].x() + dirHalf.x(), upperCircle[0].y() + dirHalf.y(), upperCircle[0].z() + dirHalf.z()); glVertex3f(upperCircle[0].x() - dirHalf.x(), upperCircle[0].y() - dirHalf.y(), upperCircle[0].z() - dirHalf.z()); glEnd(); glBegin(GL_QUAD_STRIP); for (int i = 0; i < 4; ++i) { glVertex3f(lowerCircle[i].x() + dirHalf.x(), lowerCircle[i].y() + dirHalf.y(), lowerCircle[i].z() + dirHalf.z()); glVertex3f(upperCircle[i].x() + dirHalf.x(), upperCircle[i].y() + dirHalf.y(), upperCircle[i].z() + dirHalf.z()); } for (int i = 3; i >= 0; --i) { glVertex3f(lowerCircle[i].x() - dirHalf.x(), lowerCircle[i].y() - dirHalf.y(), lowerCircle[i].z() - dirHalf.z()); glVertex3f(upperCircle[i].x() - dirHalf.x(), upperCircle[i].y() - dirHalf.y(), upperCircle[i].z() - dirHalf.z()); } glEnd(); } /* glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); glColor4f(0.0, 0.0, 0.0, 1.0); // arrow pointing upwards glBegin(GL_TRIANGLE_FAN); glVertex3f(basePointUp.x() + up.x()*2.0, basePointUp.y() + up.y()*2.0, basePointUp.z() + up.z()*2.0); glVertex3f(basePointUp.x() + dir.x(), basePointUp.y() + dir.y(), basePointUp.z() + dir.z()); glVertex3f(basePointUp.x() + right.x(), basePointUp.y() + right.y(), basePointUp.z() + right.z()); glVertex3f(basePointUp.x() - dir.x(), basePointUp.y() - dir.y(), basePointUp.z() - dir.z()); glVertex3f(basePointUp.x() - right.x(), basePointUp.y() - right.y(), basePointUp.z() - right.z()); glVertex3f(basePointUp.x() + dir.x(), basePointUp.y() + dir.y(), basePointUp.z() + dir.z()); glEnd(); // arrow pointing to the right glBegin(GL_TRIANGLE_FAN); glVertex3f(basePointRight.x() + right.x()*2.0, basePointRight.y() + right.y()*2.0, basePointRight.z() + right.z()*2.0); glVertex3f(basePointRight.x() + dir.x(), basePointRight.y() + dir.y(), basePointRight.z() + dir.z()); glVertex3f(basePointRight.x() - up.x(), basePointRight.y() - up.y(), basePointRight.z() - up.z()); glVertex3f(basePointRight.x() - dir.x(), basePointRight.y() - dir.y(), basePointRight.z() - dir.z()); glVertex3f(basePointRight.x() + up.x(), basePointRight.y() + up.y(), basePointRight.z() + up.z()); glVertex3f(basePointRight.x() + dir.x(), basePointRight.y() + dir.y(), basePointRight.z() + dir.z()); glEnd();*/ } void GLCanvas::renderSingleSensor() const { // Vector3 lookAt = Vector3(0.0f, 0.0f, 0.0f); // Vector3 lookAt = _cameraPosition + _cameraFront; // gluLookAt(_cameraPosition.x(), _cameraPosition.y(), _cameraPosition.z(), // lookAt.x() , lookAt.y() , lookAt.z(), // _cameraUp.x() , _cameraUp.y() , _cameraUp.z()); gluLookAt(0.0f, 0.0f, _cameraPosition.z(), 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f); glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); Vector3 dir = _sensorOrientation.rotate(Vector3(1.0f, 0.0f, 0.0f)); Vector3 up = 0.25 * _sensorOrientation.rotate(Vector3(0.0f, 1.0f, 0.0f)); Vector3 right = 0.5 * _sensorOrientation.rotate(Vector3(0.0f, 0.0f, 1.0f)); Vector3 frontUpRight = dir + up + right; Vector3 frontDownRight = dir - up + right; Vector3 frontUpLeft = dir + up - right; Vector3 frontDownLeft = dir - up - right; Vector3 backUpRight = -dir + up + right; Vector3 backDownRight = -dir - up + right; Vector3 backUpLeft = -dir + up - right; Vector3 backDownLeft = -dir - up - right; glBegin(GL_QUADS); glColor3f(0.8, 0.5, 0.5); glVertex3f(frontUpLeft.x(), frontUpLeft.y(), frontUpLeft.z()); glVertex3f(frontUpRight.x(), frontUpRight.y(), frontUpRight.z()); glVertex3f(frontDownRight.x(), frontDownRight.y(), frontDownRight.z()); glVertex3f(frontDownLeft.x(), frontDownLeft.y(), frontDownLeft.z()); glColor3f(0.5, 0.7, 0.5); glVertex3f(backUpRight.x(), backUpRight.y(), backUpRight.z()); glVertex3f(frontUpRight.x(), frontUpRight.y(), frontUpRight.z()); glVertex3f(frontUpLeft.x(), frontUpLeft.y(), frontUpLeft.z()); glVertex3f(backUpLeft.x(), backUpLeft.y(), backUpLeft.z()); glColor3f(0.5, 0.5, 0.7); glVertex3f(backDownRight.x(), backDownRight.y(), backDownRight.z()); glVertex3f(frontDownRight.x(), frontDownRight.y(), frontDownRight.z()); glVertex3f(frontUpRight.x(), frontUpRight.y(), frontUpRight.z()); glVertex3f(backUpRight.x(), backUpRight.y(), backUpRight.z()); glColor3f(0.7, 0.7, 0.7); glVertex3f(backUpRight.x(), backUpRight.y(), backUpRight.z()); glVertex3f(backUpLeft.x(), backUpLeft.y(), backUpLeft.z()); glVertex3f(backDownLeft.x(), backDownLeft.y(), backDownLeft.z()); glVertex3f(backDownRight.x(), backDownRight.y(), backDownRight.z()); glVertex3f(backDownLeft.x(), backDownLeft.y(), backDownLeft.z()); glVertex3f(frontDownLeft.x(), frontDownLeft.y(), frontDownLeft.z()); glVertex3f(frontDownRight.x(), frontDownRight.y(), frontDownRight.z()); glVertex3f(backDownRight.x(), backDownRight.y(), backDownRight.z()); glVertex3f(backUpLeft.x(), backUpLeft.y(), backUpLeft.z()); glVertex3f(frontUpLeft.x(), frontUpLeft.y(), frontUpLeft.z()); glVertex3f(frontDownLeft.x(), frontDownLeft.y(), frontDownLeft.z()); glVertex3f(backDownLeft.x(), backDownLeft.y(), backDownLeft.z()); glEnd(); // scale slightly to ensure the lines are visible glScalef(1.001f, 1.001f, 1.001f); glLineWidth(1.0f); glColor3f(0.0, 0.0, 0.0); glBegin(GL_LINE_STRIP); glVertex3f(backUpRight.x(), backUpRight.y(), backUpRight.z()); glVertex3f(backUpLeft.x(), backUpLeft.y(), backUpLeft.z()); glVertex3f(backDownLeft.x(), backDownLeft.y(), backDownLeft.z()); glVertex3f(backDownRight.x(), backDownRight.y(), backDownRight.z()); glVertex3f(backUpRight.x(), backUpRight.y(), backUpRight.z()); glVertex3f(frontUpRight.x(), frontUpRight.y(), frontUpRight.z()); glVertex3f(frontUpLeft.x(), frontUpLeft.y(), frontUpLeft.z()); glVertex3f(frontDownLeft.x(), frontDownLeft.y(), frontDownLeft.z()); glVertex3f(frontDownRight.x(), frontDownRight.y(), frontDownRight.z()); glVertex3f(frontUpRight.x(), frontUpRight.y(), frontUpRight.z()); glEnd(); glBegin(GL_LINES); glVertex3f(backUpLeft.x(), backUpLeft.y(), backUpLeft.z()); glVertex3f(frontUpLeft.x(), frontUpLeft.y(), frontUpLeft.z()); glVertex3f(backDownLeft.x(), backDownLeft.y(), backDownLeft.z()); glVertex3f(frontDownLeft.x(), frontDownLeft.y(), frontDownLeft.z()); glVertex3f(backDownRight.x(), backDownRight.y(), backDownRight.z()); glVertex3f(frontDownRight.x(), frontDownRight.y(), frontDownRight.z()); glEnd(); glLineWidth(2.0f); // draw global coordinate system glBegin(GL_LINES); glColor3f(1.0, 0.0, 0.0); glVertex3f(-1.5, -1.0, -1.0); glVertex3f(1.0, -1.0, -1.0); glColor3f(0.0, 1.0, 0.0); glVertex3f(-1.5, -1.0, -1.0); glVertex3f(-1.5, 1.0, -1.0); glColor3f(0.0, 0.0, 1.0); glVertex3f(-1.5, -1.0, -1.0); glVertex3f(-1.5, -1.0, 1.0); glEnd(); // draw global coordinate system // glBegin(GL_LINES); // glColor3f(1.0, 0.0, 0.0); // glVertex3f(0.0, 0.0, 0.0); // glVertex3f(1.5, 00.0, 0.0); // // glColor3f(0.0, 1.0, 0.0); // glVertex3f(0.0, 0.0, 0.0); // glVertex3f(0.0, 1.5, 0.0); // // glColor3f(0.0, 0.0, 1.0); // glVertex3f(0.0, 0.0, 0.0); // glVertex3f(0.0, 0.0, 1.5); // glEnd(); glLineWidth(1.0f); } void GLCanvas::renderSingleJoint() const { Vector3 lookAt = _cameraPosition + _cameraFront; gluLookAt(_cameraPosition.x(), _cameraPosition.y(), _cameraPosition.z(), lookAt.x() , lookAt.y() , lookAt.z(), _cameraUp.x() , _cameraUp.y() , _cameraUp.z()); glBegin(GL_LINES); glColor4f(1.0f, 0.0f, 0.0f, 1.0f); glVertex3f(0.0f, 0.0f, 0.0f); glVertex3f(1.0f, 0.0f, 0.0f); glColor4f(0.0f, 1.0f, 0.0f, 1.0f); glVertex3f(0.0f, 0.0f, 0.0f); glVertex3f(0.0f, 1.0f, 0.0f); glColor4f(0.0f, 0.0f, 1.0f, 1.0f); glVertex3f(0.0f, 0.0f, 0.0f); glVertex3f(0.0f, 0.0f, 1.0f); glEnd(); if (_constraint != nullptr) { drawJoint(*_constraint, 1.0f); } } // Initialization of all OpenGL specific parameters. void GLCanvas::InitGL() { SetCurrent(*_GLRC); glClearColor(0.0, 0.0, 0.0, 0.0); //glClearColor(1.0, 1.0, 1.0, 1.0); glEnable(GL_DEPTH_TEST); glEnable(GL_POINT_SMOOTH); glEnable(GL_BLEND); glEnable(GL_CULL_FACE); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glShadeModel(GL_SMOOTH); }
void Scene::deferredRendering(RenderTarget * target) { if(target->isEnableClipPlane ()) { glEnable(GL_CLIP_PLANE0); glClipPlane(GL_CLIP_PLANE0, target->getClipPlane()); } if(!this->spotLights.empty ()) { this->shadowPassForSpot(spotLights[0],target); } if(this->directionLight.getIntensity ()>0) { this->shadowPassDirectional (target); } geometryPass(target); if(target->isEnableClipPlane ()) { glDisable(GL_CLIP_PLANE0); } glEnable(GL_BLEND); glBlendEquation(GL_FUNC_ADD); glBlendFunc(GL_ONE, GL_ONE); target->getGBuffer ()->BindForReading(bloom_fbo1->buffer ()); lightPass(target); bloom_fbo1->BindForReading (bloom_fbo2); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); pickBright(); bloom_fbo2->BindForReading (bloom_fbo3); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); gaussianBlur_H (2); bloom_fbo3->BindForReading (NULL); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); gaussianBlur_V (2); if(target->type () == RenderTarget::TargetType::ON_SCREEN) { bloom_fbo1->BindForReading (NULL); } else { bloom_fbo1->BindForReading (target->resultBuffer ()); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); } ShaderProgram * shader =ShaderPool::getInstance ()->get("deffered_simple"); shader->use (); QMatrix4x4 m; m.setToIdentity (); m_quad->setShaderProgram (shader); auto camera =target->camera (); shader->setUniformMat4v ("g_MVP_matrix",m.data ()); shader->setUniform2Float ("g_screen_size",1024,768); shader->setUniformInteger ("g_color_map",0); shader->setUniformInteger ("g_position_map",1); shader->setUniformInteger ("g_normal_map",2); if(camera) { shader->setUniform3Float ("g_eye_position", camera->pos ().x(), camera->pos ().y(), camera->pos ().z()); } m_quad->draw (true); }
/** * Called to draw scene */ void RenderScene(void) { // Bind the FBO with multisample buffers glBindFramebuffer(GL_DRAW_FRAMEBUFFER, msFBO); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // User selected order independant transparency if (mode == USER_OIT) { // Use OIT, setup sample masks glSampleMaski(0, 0x01); glEnable(GL_SAMPLE_MASK); // Prevent depth test from culling covered surfaces glDepthFunc(GL_ALWAYS); } modelViewMatrix.push(); M3DMatrix44f mCamera; cameraFrame.GetCameraMatrix(mCamera); modelViewMatrix.MultMatrix(mCamera); modelViewMatrix.push(); modelViewMatrix.moveTo(0.0f, -0.4f, -4.0f); modelViewMatrix.rotateTo(worldAngle, 0.0, 1.0, 0.0); // Draw the background and disk to the first sample modelViewMatrix.push(); modelViewMatrix.moveTo(0.0f, 3.0f, 0.0f); modelViewMatrix.rotateTo(90.0, 1.0, 0.0, 0.0); modelViewMatrix.rotateTo(90.0, 0.0, 0.0, 1.0); glBindTexture(GL_TEXTURE_2D, textures[1]); shaderManager.useStockShader(GLT_SHADER_TEXTURE_REPLACE, transformPipeline.GetMVPMatrix(), 0); bckgrndCylBatch.draw(); modelViewMatrix.pop(); modelViewMatrix.moveTo(0.0f, -0.3f, 0.0f); modelViewMatrix.push(); modelViewMatrix.rotateTo(90.0, 1.0, 0.0, 0.0); shaderManager.useStockShader(GLT_SHADER_FLAT, transformPipeline.GetMVPMatrix(), vGrey); diskBatch.draw(); modelViewMatrix.pop(); modelViewMatrix.moveTo(0.0f, 0.1f, 0.0f); // User selected blending if (mode == USER_BLEND) { // Setup blend state glDisable(GL_DEPTH_TEST); glEnable(GL_BLEND); switch (blendMode) { case 1: glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); break; case 2: glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_DST_ALPHA); break; case 3: glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); break; case 4: glBlendFunc(GL_SRC_ALPHA, GL_ONE); break; case 5: glBlendFunc(GL_SRC_ALPHA, GL_DST_COLOR); break; case 6: glBlendFuncSeparate(GL_SRC_ALPHA, GL_DST_ALPHA, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); break; case 7: glBlendFuncSeparate(GL_SRC_COLOR, GL_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); break; default: glDisable(GL_BLEND); } } // Now draw the glass pieces DrawWorld(); modelViewMatrix.pop(); modelViewMatrix.pop(); // Clean up all state glDepthFunc(GL_LEQUAL); glDisable(GL_BLEND); glDisable(GL_SAMPLE_MASK); glSampleMaski(0, 0xffffffff); // Resolve multisample buffer projectionMatrix.push(); projectionMatrix.setMatrix(orthoMatrix); modelViewMatrix.push(); modelViewMatrix.identity(); // Setup and Clear the default framebuffer glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); glViewport(0, 0, screenWidth, screenHeight); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); if (mode == USER_OIT) SetupOITResolveProg(); else if (mode == USER_BLEND) SetupResolveProg(); // Draw a full-size quad to resolve the multisample surfaces screenQuad.draw(); modelViewMatrix.pop(); projectionMatrix.pop(); // Reset texture state glEnable(GL_DEPTH_TEST); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0); // Perform the buffer swap to display back buffer glutSwapBuffers(); glutPostRedisplay(); }
// Print the canvas contents to a bitmap: void klsMiniMap::generateImage() { //WARNING!!! Heavily platform-dependent code ahead! This only works in MS Windows because of the // DIB Section OpenGL rendering. wxSize sz = GetClientSize(); // Create a DIB section. // (The Windows wxBitmap implementation will create a DIB section for a bitmap if you set // a color depth of 24 or greater.) wxBitmap theBM( sz.GetWidth(), sz.GetHeight(), 32 ); // Get a memory hardware device context for writing to the bitmap DIB Section: wxMemoryDC myDC; myDC.SelectObject(theBM); WXHDC theHDC = myDC.GetHDC(); // The basics of setting up OpenGL to render to the bitmap are found at: // http://www.nullterminator.net/opengl32.html // http://www.codeguru.com/cpp/g-m/opengl/article.php/c5587/ PIXELFORMATDESCRIPTOR pfd; int iFormat; // set the pixel format for the DC ::ZeroMemory( &pfd, sizeof( pfd ) ); pfd.nSize = sizeof( pfd ); pfd.nVersion = 1; pfd.dwFlags = PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL | PFD_SUPPORT_GDI; pfd.iPixelType = PFD_TYPE_RGBA; pfd.cColorBits = 32; pfd.cDepthBits = 16; pfd.iLayerType = PFD_MAIN_PLANE; iFormat = ::ChoosePixelFormat( (HDC) theHDC, &pfd ); ::SetPixelFormat( (HDC) theHDC, iFormat, &pfd ); // create and enable the render context (RC) HGLRC hRC = ::wglCreateContext( (HDC) theHDC ); HGLRC oldhRC = ::wglGetCurrentContext(); HDC oldDC = ::wglGetCurrentDC(); ::wglMakeCurrent( (HDC) theHDC, hRC ); // Setup the viewport for rendering: setViewport(); // Reset the glViewport to the size of the bitmap: glViewport(0, 0, (GLint) sz.GetWidth(), (GLint) sz.GetHeight()); // Set the bitmap clear color: glClearColor (1.0, 1.0, 1.0, 0.0); glColor3b(0, 0, 0); //TODO: Check if alpha is hardware supported, and // don't enable it if not! glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND); //********************************* //Edit by Joshua Lansford 4/08/07 //The minimap could use some anti //aleasing glEnable( GL_LINE_SMOOTH ); //End of edit // Load the font texture guiText::loadFont(wxGetApp().appSettings.textFontFile); // Do the rendering here. renderMap(); // Flush the OpenGL buffer to make sure the rendering has happened: glFlush(); // Destroy the OpenGL rendering context, release the memDC, and // convert the DIB Section into a wxImage to return to the caller: ::wglMakeCurrent( oldDC, oldhRC ); //::wglMakeCurrent( NULL, NULL ); ::wglDeleteContext( hRC ); myDC.SelectObject(wxNullBitmap); mapImage = theBM.ConvertToImage(); }
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; #if SDL_VIDEO_OPENGL 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; #if SDL_VIDEO_OPENGL glDisable(GL_NORMALIZE); OPENGL_CHECK_ERRORS; #endif glDepthFunc(GL_LEQUAL); OPENGL_CHECK_ERRORS; glEnable(GL_DEPTH_TEST); OPENGL_CHECK_ERRORS; #if SDL_VIDEO_OPENGL glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); OPENGL_CHECK_ERRORS; #endif glEnable(GL_BLEND); OPENGL_CHECK_ERRORS; #if SDL_VIDEO_OPENGL glEnable(GL_ALPHA_TEST); OPENGL_CHECK_ERRORS; glMatrixMode(GL_PROJECTION); OPENGL_CHECK_ERRORS; glLoadIdentity(); OPENGL_CHECK_ERRORS; glDepthRange(-1, 1); #elif SDL_VIDEO_OPENGL_ES2 glDepthRangef(0.0f, 1.0f); #endif OPENGL_CHECK_ERRORS; }
static void beginRendering (SnowScreen *ss, CompScreen *s) { const BananaValue * option_use_blending = bananaGetOption (bananaIndex, "use_blending", -1); const BananaValue * option_use_textures = bananaGetOption (bananaIndex, "use_textures", -1); const BananaValue * option_num_snowflakes = bananaGetOption (bananaIndex, "num_snowflakes", -1); const BananaValue * option_snow_rotation = bananaGetOption (bananaIndex, "snow_rotation", -1); if (option_use_blending->b) glEnable (GL_BLEND); glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); if (ss->displayListNeedsUpdate) { setupDisplayList (ss); ss->displayListNeedsUpdate = FALSE; } glColor4f (1.0, 1.0, 1.0, 1.0); if (ss->snowTexturesLoaded && option_use_textures->b) { int j; for (j = 0; j < ss->snowTexturesLoaded; j++) { SnowFlake *snowFlake = ss->allSnowFlakes; int i, numFlakes = option_num_snowflakes->i; Bool snowRotate = option_snow_rotation->b; enableTexture (ss->s, &ss->snowTex[j].tex, COMP_TEXTURE_FILTER_GOOD); for (i = 0; i < numFlakes; i++) { if (snowFlake->tex == &ss->snowTex[j]) { glTranslatef (snowFlake->x, snowFlake->y, snowFlake->z); if (snowRotate) glRotatef (snowFlake->ra, 0, 0, 1); glCallList (ss->snowTex[j].dList); if (snowRotate) glRotatef (-snowFlake->ra, 0, 0, 1); glTranslatef (-snowFlake->x, -snowFlake->y, -snowFlake->z); } snowFlake++; } disableTexture (ss->s, &ss->snowTex[j].tex); } } else { SnowFlake *snowFlake = ss->allSnowFlakes; int i, numFlakes = option_num_snowflakes->i; for (i = 0; i < numFlakes; i++) { glTranslatef (snowFlake->x, snowFlake->y, snowFlake->z); glRotatef (snowFlake->ra, 0, 0, 1); glCallList (ss->displayList); glRotatef (-snowFlake->ra, 0, 0, 1); glTranslatef (-snowFlake->x, -snowFlake->y, -snowFlake->z); snowFlake++; } } glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); if (option_use_blending->b) { glDisable (GL_BLEND); glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA); } }
void STKMeshSceneNode::render() { irr::video::IVideoDriver* driver = irr_driver->getVideoDriver(); if (!Mesh || !driver) return; ++PassCount; updateNoGL(); updateGL(); bool isTransparent; for (u32 i = 0; i < Mesh->getMeshBufferCount(); ++i) { scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i); if (!mb) continue; video::E_MATERIAL_TYPE type = mb->getMaterial().MaterialType; video::IMaterialRenderer* rnd = driver->getMaterialRenderer(type); isTransparent = rnd->isTransparent(); break; } if ((irr_driver->getPhase() == SOLID_NORMAL_AND_DEPTH_PASS) && immediate_draw && !isTransparent) { core::matrix4 invmodel; AbsoluteTransformation.getInverse(invmodel); glDisable(GL_CULL_FACE); if (update_each_frame) updatevbo(); glUseProgram(MeshShader::ObjectPass1Shader::getInstance()->Program); // Only untextured for (unsigned i = 0; i < GLmeshes.size(); i++) { irr_driver->IncreaseObjectCount(); GLMesh &mesh = GLmeshes[i]; GLenum ptype = mesh.PrimitiveType; GLenum itype = mesh.IndexType; size_t count = mesh.IndexCount; compressTexture(mesh.textures[0], true); if (UserConfigParams::m_azdo) { if (!mesh.TextureHandles[0]) mesh.TextureHandles[0] = glGetTextureSamplerHandleARB(getTextureGLuint(mesh.textures[0]), MeshShader::TransparentFogShader::getInstance()->SamplersId[0]); if (!glIsTextureHandleResidentARB(mesh.TextureHandles[0])) glMakeTextureHandleResidentARB(mesh.TextureHandles[0]); MeshShader::ObjectPass1Shader::getInstance()->SetTextureHandles(createVector<uint64_t>(mesh.TextureHandles[0])); } else MeshShader::ObjectPass1Shader::getInstance()->SetTextureUnits(std::vector < GLuint > { getTextureGLuint(mesh.textures[0]) }); MeshShader::ObjectPass1Shader::getInstance()->setUniforms(AbsoluteTransformation, invmodel); assert(mesh.vao); glBindVertexArray(mesh.vao); glDrawElements(ptype, count, itype, 0); glBindVertexArray(0); } glEnable(GL_CULL_FACE); return; } if (irr_driver->getPhase() == SOLID_LIT_PASS && immediate_draw && !isTransparent) { core::matrix4 invmodel; AbsoluteTransformation.getInverse(invmodel); glDisable(GL_CULL_FACE); if (update_each_frame && !UserConfigParams::m_dynamic_lights) updatevbo(); glUseProgram(MeshShader::ObjectPass2Shader::getInstance()->Program); // Only untextured for (unsigned i = 0; i < GLmeshes.size(); i++) { irr_driver->IncreaseObjectCount(); GLMesh &mesh = GLmeshes[i]; GLenum ptype = mesh.PrimitiveType; GLenum itype = mesh.IndexType; size_t count = mesh.IndexCount; if (UserConfigParams::m_azdo) { GLuint64 DiffuseHandle = glGetTextureSamplerHandleARB(irr_driver->getRenderTargetTexture(RTT_DIFFUSE), MeshShader::ObjectPass2Shader::getInstance()->SamplersId[0]); if (!glIsTextureHandleResidentARB(DiffuseHandle)) glMakeTextureHandleResidentARB(DiffuseHandle); GLuint64 SpecularHandle = glGetTextureSamplerHandleARB(irr_driver->getRenderTargetTexture(RTT_SPECULAR), MeshShader::ObjectPass2Shader::getInstance()->SamplersId[1]); if (!glIsTextureHandleResidentARB(SpecularHandle)) glMakeTextureHandleResidentARB(SpecularHandle); GLuint64 SSAOHandle = glGetTextureSamplerHandleARB(irr_driver->getRenderTargetTexture(RTT_HALF1_R), MeshShader::ObjectPass2Shader::getInstance()->SamplersId[2]); if (!glIsTextureHandleResidentARB(SSAOHandle)) glMakeTextureHandleResidentARB(SSAOHandle); if (!mesh.TextureHandles[0]) mesh.TextureHandles[0] = glGetTextureSamplerHandleARB(getTextureGLuint(mesh.textures[0]), MeshShader::TransparentFogShader::getInstance()->SamplersId[0]); if (!glIsTextureHandleResidentARB(mesh.TextureHandles[0])) glMakeTextureHandleResidentARB(mesh.TextureHandles[0]); MeshShader::ObjectPass2Shader::getInstance()->SetTextureHandles(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, mesh.TextureHandles[0])); } else MeshShader::ObjectPass2Shader::getInstance()->SetTextureUnits(createVector<GLuint>( irr_driver->getRenderTargetTexture(RTT_DIFFUSE), irr_driver->getRenderTargetTexture(RTT_SPECULAR), irr_driver->getRenderTargetTexture(RTT_HALF1_R), getTextureGLuint(mesh.textures[0]), getTextureGLuint(mesh.textures[1]))); MeshShader::ObjectPass2Shader::getInstance()->setUniforms(AbsoluteTransformation, mesh.TextureMatrix); assert(mesh.vao); glBindVertexArray(mesh.vao); glDrawElements(ptype, count, itype, 0); glBindVertexArray(0); } glEnable(GL_CULL_FACE); return; } if (irr_driver->getPhase() == GLOW_PASS) { glUseProgram(MeshShader::ColorizeShader::getInstance()->Program); for (u32 i = 0; i < Mesh->getMeshBufferCount(); ++i) { scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i); if (!mb) continue; if (irr_driver->hasARB_base_instance()) glBindVertexArray(VAOManager::getInstance()->getVAO(video::EVT_STANDARD)); else glBindVertexArray(GLmeshes[i].vao); drawGlow(GLmeshes[i]); } } if (irr_driver->getPhase() == TRANSPARENT_PASS && isTransparent) { ModelViewProjectionMatrix = computeMVP(AbsoluteTransformation); if (immediate_draw) { if (update_each_frame) updatevbo(); glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); if (World::getWorld() && World::getWorld()->isFogEnabled()) { glUseProgram(MeshShader::TransparentFogShader::getInstance()->Program); for (unsigned i = 0; i < GLmeshes.size(); i++) { GLMesh &mesh = GLmeshes[i]; irr_driver->IncreaseObjectCount(); GLenum ptype = mesh.PrimitiveType; GLenum itype = mesh.IndexType; size_t count = mesh.IndexCount; const Track * const track = World::getWorld()->getTrack(); // This function is only called once per frame - thus no need for setters. const float fogmax = track->getFogMax(); const float startH = track->getFogStartHeight(); const float endH = track->getFogEndHeight(); const float start = track->getFogStart(); const float end = track->getFogEnd(); const video::SColor tmpcol = track->getFogColor(); video::SColorf col(tmpcol.getRed() / 255.0f, tmpcol.getGreen() / 255.0f, tmpcol.getBlue() / 255.0f); compressTexture(mesh.textures[0], true); if (UserConfigParams::m_azdo) { if (!mesh.TextureHandles[0]) mesh.TextureHandles[0] = glGetTextureSamplerHandleARB(getTextureGLuint(mesh.textures[0]), MeshShader::TransparentFogShader::getInstance()->SamplersId[0]); if (!glIsTextureHandleResidentARB(mesh.TextureHandles[0])) glMakeTextureHandleResidentARB(mesh.TextureHandles[0]); MeshShader::TransparentFogShader::getInstance()->SetTextureHandles(createVector<uint64_t>(mesh.TextureHandles[0])); } else MeshShader::TransparentFogShader::getInstance()->SetTextureUnits(std::vector<GLuint>{ getTextureGLuint(mesh.textures[0]) }); MeshShader::TransparentFogShader::getInstance()->setUniforms(AbsoluteTransformation, mesh.TextureMatrix, fogmax, startH, endH, start, end, col); assert(mesh.vao); glBindVertexArray(mesh.vao); glDrawElements(ptype, count, itype, 0); glBindVertexArray(0); } } else { glUseProgram(MeshShader::TransparentShader::getInstance()->Program); for (unsigned i = 0; i < GLmeshes.size(); i++) { irr_driver->IncreaseObjectCount(); GLMesh &mesh = GLmeshes[i]; GLenum ptype = mesh.PrimitiveType; GLenum itype = mesh.IndexType; size_t count = mesh.IndexCount; compressTexture(mesh.textures[0], true); if (UserConfigParams::m_azdo) { if (!mesh.TextureHandles[0]) mesh.TextureHandles[0] = glGetTextureSamplerHandleARB(getTextureGLuint(mesh.textures[0]), MeshShader::TransparentShader::getInstance()->SamplersId[0]); if (!glIsTextureHandleResidentARB(mesh.TextureHandles[0])) glMakeTextureHandleResidentARB(mesh.TextureHandles[0]); MeshShader::TransparentShader::getInstance()->SetTextureHandles(createVector<uint64_t>(mesh.TextureHandles[0])); } else MeshShader::TransparentShader::getInstance()->SetTextureUnits(std::vector<GLuint>{ getTextureGLuint(mesh.textures[0]) }); MeshShader::TransparentShader::getInstance()->setUniforms(AbsoluteTransformation, mesh.TextureMatrix); assert(mesh.vao); glBindVertexArray(mesh.vao); glDrawElements(ptype, count, itype, 0); glBindVertexArray(0); } } return; } } }
gboolean on_expose(GtkWidget *drawing, GdkEventExpose *event, gpointer _) { glClearColor(0.5, 0.5, 1.0, 1.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-1,1, -1,1, 10,-10); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslatef(0, 0, -5); glEnable(GL_COLOR_MATERIAL); glDisable(GL_TEXTURE_2D); glColor3f(1.0, 1.0, 1.0); glBegin(GL_QUADS); glVertex3f(-0.25, -0.75, 0.0); glVertex3f(-0.25, 0.75, 0.0); glVertex3f( 0.25, 0.75, 0.0); glVertex3f( 0.25, -0.75, 0.0); glEnd(); /* Textures */ glDisable(GL_COLOR_MATERIAL); glEnable(GL_TEXTURE_2D); glEnable(GL_BLEND); gdouble y = 0.875; /* Left */ glBlendFunc(GL_ONE, GL_ZERO); glBindTexture(GL_TEXTURE_2D, texl); glBegin(GL_QUADS); glTexCoord2f(0.0, y); glVertex3f(-0.75, 0.0, 0.0); glTexCoord2f(0.0, 1.0); glVertex3f(-0.75, 0.5, 0.0); glTexCoord2f(2.0, 1.0); glVertex3f( 0.75, 0.5, 0.0); glTexCoord2f(2.0, y); glVertex3f( 0.75, 0.0, 0.0); glEnd(); /* Right */ glBlendFunc(GL_ONE, GL_ONE); glBindTexture(GL_TEXTURE_2D, texr); glBegin(GL_QUADS); glTexCoord2f(-1.0, y); glVertex3f(-0.75, 0.0, 0.0); glTexCoord2f(-1.0, 1.0); glVertex3f(-0.75, 0.5, 0.0); glTexCoord2f( 1.0, 1.0); glVertex3f( 0.75, 0.5, 0.0); glTexCoord2f( 1.0, y); glVertex3f( 0.75, 0.0, 0.0); glEnd(); /* Bottom */ glBlendFunc(GL_ONE, GL_ZERO); glBindTexture(GL_TEXTURE_2D, tex); glBegin(GL_QUADS); glTexCoord2f(0.0, 0.0); glVertex3f(-0.75, -0.5, 0.0); glTexCoord2f(0.0, 1.0-y); glVertex3f(-0.75, -0.0, 0.0); glTexCoord2f(1.0, 1.0-y); glVertex3f( 0.75, -0.0, 0.0); glTexCoord2f(1.0, 0.0); glVertex3f( 0.75, -0.5, 0.0); glEnd(); /* Flush */ GdkGLDrawable *gldrawable = gdk_gl_drawable_get_current(); if (gdk_gl_drawable_is_double_buffered(gldrawable)) gdk_gl_drawable_swap_buffers(gldrawable); else glFlush(); return FALSE; }
void VR_ShowCrosshair () { vec3_t forward, up, right; vec3_t start, end, impact; float size; if( (sv_player && (int)(sv_player->v.weapon) == IT_AXE) ) return; // setup gl glDisable (GL_DEPTH_TEST); glPolygonMode (GL_FRONT_AND_BACK, GL_LINE); GL_PolygonOffset (OFFSET_SHOWTRIS); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDisable (GL_TEXTURE_2D); glDisable (GL_CULL_FACE); // calc the line and draw VectorCopy (cl.viewent.origin, start); start[2] -= cl.viewheight - 10; AngleVectors (cl.aimangles, forward, right, up); size = CLAMP (1.0, vr_crosshair_size.value, 5.0); switch((int) vr_crosshair.value) { default: case VR_CROSSHAIR_POINT: if (vr_crosshair_depth.value <= 0) { // trace to first wall VectorMA (start, 4096, forward, end); TraceLine (start, end, impact); } else { // fix crosshair to specific depth VectorMA (start, vr_crosshair_depth.value * meters_to_units, forward, impact); } glEnable(GL_POINT_SMOOTH); glColor4f (1, 0, 0, 0.5); glPointSize( size * glwidth / 1280.0f ); glBegin(GL_POINTS); glVertex3f (impact[0], impact[1], impact[2]); glEnd(); glDisable(GL_POINT_SMOOTH); break; case VR_CROSSHAIR_LINE: // trace to first entity VectorMA (start, 4096, forward, end); TraceLineToEntity (start, end, impact, sv_player); glColor4f (1, 0, 0, 0.4); glLineWidth( size * glwidth / (1280.0f) ); glBegin (GL_LINES); glVertex3f (start[0], start[1], start[2]); glVertex3f (impact[0], impact[1], impact[2]); glEnd (); break; } // cleanup gl glColor3f (1,1,1); glEnable (GL_TEXTURE_2D); glEnable (GL_CULL_FACE); glDisable(GL_BLEND); glPolygonMode (GL_FRONT_AND_BACK, GL_FILL); GL_PolygonOffset (OFFSET_NONE); glEnable (GL_DEPTH_TEST); }
void draw(const Stroke& stroke, CL_GraphicContext* gc) { CL_OpenGLState state(CL_Display::get_current_window()->get_gc()); state.set_active(); state.setup_2d(); CL_Color color = DrawerProperties::current()->get_color(); const Stroke::Dabs& dabs = stroke.get_interpolated_dabs(DrawerProperties::current()->get_spacing(), DrawerProperties::current()->get_spacing()); if (dabs.size() >= 2) { std::vector<CL_Pointf> normals; if (stroke.get_dab_count() == 2) { normals.push_back(CL_Pointf(1.0f, 1.0f)); normals.push_back(CL_Pointf(1.0f, 1.0f)); } else if (stroke.get_dab_count() >= 3) { for(Stroke::Dabs::size_type i = 0; i < dabs.size()-1; ++i) { CL_Pointf normal((dabs[i].pos.y - dabs[i+1].pos.y), -(dabs[i].pos.x - dabs[i+1].pos.x)); float length = sqrt(normal.x * normal.x + normal.y * normal.y); normal.x /= length; normal.y /= length; normals.push_back(normal); } normals.push_back(CL_Pointf(1.0f, 1.0f)); } float len = DrawerProperties::current()->get_size() * 8.0f; float len2 = DrawerProperties::current()->get_size() * 16.0f; glEnable(GL_BLEND); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); glBegin(GL_QUAD_STRIP); for(unsigned int j = 0; j < dabs.size()-2; ++j) { glColor4ub(color.get_red(), color.get_green(), color.get_blue(), color.get_alpha()); glVertex2f(dabs[j].pos.x + normals[j].x * len, dabs[j].pos.y + normals[j].y * len); glColor4ub(color.get_red(), color.get_green(), color.get_blue(), 0); glVertex2f(dabs[j].pos.x + normals[j].x * len2, dabs[j].pos.y + normals[j].y * len2); } glEnd(); glBegin(GL_QUAD_STRIP); for(unsigned int j = 0; j < dabs.size()-2; ++j) { glColor4ub(color.get_red(), color.get_green(), color.get_blue(), 0); glVertex2f(dabs[j].pos.x - normals[j].x * len2, dabs[j].pos.y - normals[j].y * len2); glColor4ub(color.get_red(), color.get_green(), color.get_blue(), color.get_alpha()); glVertex2f(dabs[j].pos.x - normals[j].x * len, dabs[j].pos.y - normals[j].y * len); } glEnd(); glBegin(GL_QUAD_STRIP); glColor4ub(color.get_red(), color.get_green(), color.get_blue(), color.get_alpha()); for(unsigned int j = 0; j < dabs.size()-2; ++j) { glVertex2f(dabs[j].pos.x + normals[j].x * len, dabs[j].pos.y + normals[j].y * len); glVertex2f(dabs[j].pos.x - normals[j].x * len, dabs[j].pos.y - normals[j].y * len); } glEnd(); } }
void SurfaceItem::render(const Map &map, const Camera &camera) { int zone = map.zone(vertices().at(0)); GLuint tex = textureId(); if (zone < 0) return; m_program->bind(); m_program->setUniformValue(m_matrixUniform, camera.viewProjectionMatrix()); QSize size = surface()->size(); m_program->setUniformValue(m_pixelSizeUniform, 5. / size.width(), 5. / size.height()); m_program->setUniformValue(m_eyeUniform, camera.viewPos()); m_program->setUniformValue(m_focusColorUniform, GLfloat(m_opacity)); m_program->setUniformValueArray(m_lightsUniform, map.lights(zone).constData(), map.lights(zone).size()); m_program->setUniformValue(m_numLightsUniform, map.lights(zone).size()); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, tex); QVector<QVector3D> v = vertices(); QVector3D va = v[0]; QVector3D vb = v[1]; QVector3D vc = v[2]; QVector3D vd = v[3]; QVector<QVector3D> vertexBuffer; vertexBuffer << va << vb << vd << vd << vb << vc; qreal y1 = 0; qreal y2 = 1; if (surface()->origin() == QWaylandSurface::OriginTopLeft) qSwap(y1, y2); QVector<QVector2D> texCoordBuffer; texCoordBuffer << QVector2D(0, y2) << QVector2D(1, y2) << QVector2D(0, y1) << QVector2D(0, y1) << QVector2D(1, y2) << QVector2D(1, y1); m_program->setUniformValue(m_normalUniform, -QVector3D::crossProduct(vb - va, vc - va).normalized()); m_program->enableAttributeArray(m_vertexAttr); m_program->setAttributeArray(m_vertexAttr, vertexBuffer.constData()); m_program->enableAttributeArray(m_texCoordAttr); m_program->setAttributeArray(m_texCoordAttr, texCoordBuffer.constData()); glEnable(GL_BLEND); glDisable(GL_CULL_FACE); glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); glDrawArrays(GL_TRIANGLES, 0, 6); glDisable(GL_BLEND); m_program->disableAttributeArray(m_texCoordAttr); m_program->disableAttributeArray(m_vertexAttr); #if 0 QOpenGLPaintDevice device(camera.viewSize()); QPainter p(&device); va = camera.viewProjectionMatrix().map(va); vb = camera.viewProjectionMatrix().map(vb); vc = camera.viewProjectionMatrix().map(vc); vd = camera.viewProjectionMatrix().map(vd); QVector3D c(camera.viewSize().width() * 0.5, camera.viewSize().height() * 0.5, 0); va = c + c * va * QVector3D(1, -1, 0); vb = c + c * vb * QVector3D(1, -1, 0); vc = c + c * vc * QVector3D(1, -1, 0); vd = c + c * vd * QVector3D(1, -1, 0); QPointF pa(va.x(), va.y()); QPointF pb(vb.x(), vb.y()); QPointF pc(vc.x(), vc.y()); QPointF pd(vd.x(), vd.y()); p.drawLine(pa, pb); p.drawLine(pb, pc); p.drawLine(pc, pd); p.drawLine(pd, pa); extern QVector3D debug; QVector3D d = camera.viewProjectionMatrix().map(debug); d = c + c * d * QVector3D(1, -1, 0); static QVector3D old; if (debug != old) old = debug; p.setPen(Qt::NoPen); p.setBrush(Qt::red); p.drawEllipse(QRectF(d.x() - 2, d.y() - 2, 4, 4)); p.end(); #endif }
void Blur_apply(){ if(multiSamples!=1 && blur==Blur_glsl_depth){ consoleLog("Blur_apply: Blur_glsl_depth can't be used with multisample, disabling\n"); blur=Blur_glsl_simple; } if(blur==Blur_none) return; float lastMatrix[16]; glGetFloatv(GL_MODELVIEW_MATRIX, lastMatrix); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); glScalef(2.f/screen->w, -2.f/screen->h, 1.f); glTranslatef(-screen->w*.5f, -screen->h*.5f, 0.f); glDisable(GL_DEPTH_TEST); glDisable(GL_FOG); glDisable(GL_LIGHTING); glDepthMask(GL_FALSE); if(blur==Blur_basic){ glColor4f(1.f, 1.f, 1.f, powf(.3f, blurdt*60.f)); glBindTexture(GL_TEXTURE_2D, tex_screen); glBegin(GL_QUADS); glTexCoord2f(0.f, (float)screen->h/sh); glVertex2i(0, 0); glTexCoord2f(0.f, 0.f); glVertex2i(0, screen->h); glTexCoord2f((float)screen->w/sw, 0.f); glVertex2i(screen->w, screen->h); glTexCoord2f((float)screen->w/sw, (float)screen->h/sh); glVertex2i(screen->w, 0); glEnd(); totalPolys+=2; glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, screen->w, screen->h); } #if GL_ARB_shader_objects else if(blur==Blur_glsl_simple){ glUseProgramObjectARB(prg_blurSimple); glUniform1iARB(glGetUniformLocationARB(prg_blurSimple, "screen"), 0); glUniform2fARB(glGetUniformLocationARB(prg_blurSimple, "texSize"), (float)screen->w/sw, (float)screen->h/sh); float imat[16]; float mat2[16]; memcpy(imat, mx_old, sizeof(imat)); inverseMatrix4(imat); glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurSimple, "curMatrix"), 1, GL_FALSE, lastMatrix); glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurSimple, "oldMatrix"), 1, GL_FALSE, mx_old); inverseMatrix4(lastMatrix); glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurSimple, "oldMatrixInverse"), 1, GL_FALSE, imat); glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurSimple, "curMatrixInverse"), 1, GL_FALSE, lastMatrix); glColor4f(1,1,1,1); glBindTexture(GL_TEXTURE_2D, tex_screen); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, screen->w, screen->h); glBegin(GL_QUADS); glTexCoord2f(-1.f, 1.f); glVertex2i(0, 0); glTexCoord2f(-1.f, -1.f); glVertex2i(0, screen->h); glTexCoord2f(1.f, -1.f); glVertex2i(screen->w, screen->h); glTexCoord2f(1.f, 1.f); glVertex2i(screen->w, 0); glEnd(); totalPolys+=2; glUseProgramObjectARB(0); } #if GL_ARB_depth_texture else if(blur==Blur_glsl_depth){ glActiveTexture(GL_TEXTURE1_ARB); glBindTexture(GL_TEXTURE_2D, tex_depth); glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, screen->w, screen->h); glActiveTexture(GL_TEXTURE0_ARB); glUseProgramObjectARB(prg_blurDepth); glUniform1iARB(glGetUniformLocationARB(prg_blurDepth, "screen"), 0); glUniform1iARB(glGetUniformLocationARB(prg_blurDepth, "depthTex"), 1); glUniform2fARB(glGetUniformLocationARB(prg_blurDepth, "texSize"), (float)screen->w/sw, (float)screen->h/sh); float imat[16]; float mat2[16]; memcpy(imat, mx_old, sizeof(imat)); inverseMatrix4(imat); glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurDepth, "curMatrix"), 1, GL_FALSE, lastMatrix); glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurDepth, "oldMatrix"), 1, GL_FALSE, mx_old); inverseMatrix4(lastMatrix); glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurDepth, "oldMatrixInverse"), 1, GL_FALSE, imat); glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurDepth, "curMatrixInverse"), 1, GL_FALSE, lastMatrix); glColor4f(1,1,1,1); glBindTexture(GL_TEXTURE_2D, tex_screen); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, screen->w, screen->h); glBegin(GL_QUADS); glTexCoord2f(-1.f, 1.f); glVertex2i(0, 0); glTexCoord2f(-1.f, -1.f); glVertex2i(0, screen->h); glTexCoord2f(1.f, -1.f); glVertex2i(screen->w, screen->h); glTexCoord2f(1.f, 1.f); glVertex2i(screen->w, 0); glEnd(); totalPolys+=2; glUseProgramObjectARB(0); } #endif #endif glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_LIGHTING); glMatrixMode(GL_PROJECTION); glPopMatrix(); glMatrixMode(GL_MODELVIEW); glPopMatrix(); glEnable(GL_DEPTH_TEST); glEnable(GL_FOG); glDepthMask(GL_TRUE); }
void vsx_widget_desktop::draw() { if (!init_run) return; // this is designed to be root, so set up things // Deal with movement around the desktop #define SGN(N) (N >= 0 ? 1 : -1) #define MAX(N, M) ((N) >= (M) ? (N) : (M)) #define MIN(N, M) ((N) <= (M) ? (N) : (M)) #define CLAMP(N, L, U) (MAX(MIN((N), (U)), (L))) //if (logo_time > animlen) { if (!interpolating) { double acc = 4, dec = 3, spd = global_key_speed; // interpolation falloff control float tt = dtime*interpolation_speed*global_interpolation_speed; if (tt > 1) { tt = 1; } if(zpd != 0.0) { double sgn = SGN(zpd); zps += dtime * acc * sgn * global_interpolation_speed; zps = CLAMP(zps, -1.2f, 1.2f); } if(zpd == 0.0) { double sgn = SGN(zps); zps -= dtime * dec * sgn * global_interpolation_speed; zps = MAX(zps * sgn, 0) * sgn; } zp += zps * fabs(zp - 1.1)* spd * dtime + zpp*(zp - 1.0f); zpp = zpp*(1-tt); if (zp > 100) {zp = 100; zps = 0;} if (zp < 1.2) {zp = 1.2; zps = 0;} if(xpd != 0.0) { double sgn = SGN(xpd); xps += dtime * acc * sgn * global_interpolation_speed; xps = CLAMP(xps, -1, 1); } if(xpd == 0.0) { double sgn = SGN(xps); xps -= dtime * dec * sgn * global_interpolation_speed; xps = MAX(xps * sgn, 0) * sgn; } xp += xps * fabs(zp - 1.1)* spd * dtime*0.6 + xpp*(zp-1.0f); xpp = xpp*(1-tt); if (xp > 10) {xp = 10; xps = 0;} if (xp < -10) {xp = -10; xps = 0;} if(ypd != 0.0) { double sgn = SGN(ypd); yps += dtime * acc * sgn * global_interpolation_speed; yps = CLAMP(yps, -1, 1); } if(ypd == 0.0) { double sgn = SGN(yps); yps -= dtime * dec * sgn * global_interpolation_speed; yps = MAX(yps * sgn, 0) * sgn; } yp += yps * fabs(zp - 1.1)* spd * dtime*0.6 + ypp*(zp-1.0f); ypp = ypp*(1-tt); if (yp > 10) {yp = 10; yps = 0;} if (yp < -10) {yp = -10; yps = 0;} // printf("xp: %f xps: %f xpd %f dt %f::",xp,xps,xpd,tt); } else { float tt = dtime*10.0f*global_interpolation_speed; if (tt > 1) { tt = 1; interpolating = false;} xp = xp*(1-tt)+camera_target.x*tt; yp = yp*(1-tt)+camera_target.y*tt; zp = zp*(1-tt)+camera_target.z*tt; if ( (round(xp*2000) == round(camera_target.x*2000)) && (round(yp*2000) == round(camera_target.y*2000)) && (round(zp*2000) == round(camera_target.z*2000)) ) interpolating = false; } glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(45,screen_x/screen_y,0.001,120.0); gluLookAt(xp,yp,zp-1.1f,xp,yp,-1.1f,0.0,1.0,0.0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); // PERFORMANCE_MODE_CHANGE // if (performance_mode) // glBlendFunc(GL_SRC_ALPHA, GL_ONE); //else glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // //return; glEnable(GL_BLEND); //glClear(GL_COLOR_BUFFER_BIT); if (!performance_mode) glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); //glEnable(GL_LINE_SMOOTH); if (!performance_mode) { glDisable(GL_DEPTH_TEST); glDepthMask(GL_FALSE); glColor4f(1,1,1,1); #ifndef VSXU_PLAYER if (!mtex.bind()) #endif glColor4f(skin_color[13].r,skin_color[13].g,skin_color[13].b,skin_color[13].a); //else glBegin(GL_QUADS); glTexCoord2f(0, 0); glVertex3f(pos.x-size.x/2,pos.y-size.y/2,-10.0f); glTexCoord2f(0, 1); glVertex3f(pos.x-size.x/2,pos.y+size.y/2,-10.0f); glTexCoord2f(1, 1); glVertex3f(pos.x+size.x/2,pos.y+size.y/2,-10.0f); glTexCoord2f(1, 0); glVertex3f(pos.x+size.x/2,pos.y-size.y/2,-10.0f); glEnd(); #ifndef VSXU_PLAYER mtex._bind(); #endif } draw_children(); }
void IrrDriver::renderGlow(video::SOverrideMaterial &overridemat, std::vector<GlowData>& glows, const core::aabbox3df& cambox, int cam) { m_scene_manager->setCurrentRendertime(scene::ESNRP_SOLID); m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_TMP1), false, false); glClearColor(0, 0, 0, 0); glClear(GL_STENCIL_BUFFER_BIT | GL_COLOR_BUFFER_BIT); const u32 glowcount = glows.size(); ColorizeProvider * const cb = (ColorizeProvider *) m_shaders->m_callbacks[ES_COLORIZE]; glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); glStencilFunc(GL_ALWAYS, 1, ~0); glEnable(GL_STENCIL_TEST); glEnable(GL_DEPTH_TEST); glDisable(GL_ALPHA_TEST); glDepthMask(GL_FALSE); glDisable(GL_BLEND); for (u32 i = 0; i < glowcount; i++) { const GlowData &dat = glows[i]; scene::ISceneNode * const cur = dat.node; // Quick box-based culling const core::aabbox3df nodebox = cur->getTransformedBoundingBox(); if (!nodebox.intersectsWithBox(cambox)) continue; cb->setColor(dat.r, dat.g, dat.b); cur->render(); } glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); glDisable(GL_STENCIL_TEST); // Cool, now we have the colors set up. Progressively minify. video::SMaterial minimat; minimat.Lighting = false; minimat.ZWriteEnable = false; minimat.ZBuffer = video::ECFN_ALWAYS; minimat.setFlag(video::EMF_TRILINEAR_FILTER, true); minimat.TextureLayer[0].TextureWrapU = minimat.TextureLayer[0].TextureWrapV = video::ETC_CLAMP_TO_EDGE; // To half m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_HALF1), false, false); m_post_processing->renderPassThrough(m_rtts->getRTT(RTT_TMP1)); // To quarter m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_QUARTER1), false, false); m_post_processing->renderPassThrough(m_rtts->getRTT(RTT_HALF1)); // Blur it m_post_processing->renderGaussian6Blur(m_rtts->getRTT(RTT_QUARTER1), m_rtts->getRTT(RTT_QUARTER2), 4.f / UserConfigParams::m_width, 4.f / UserConfigParams::m_height); glEnable(GL_BLEND); glBlendEquation(GL_FUNC_ADD); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glStencilFunc(GL_EQUAL, 0, ~0); glEnable(GL_STENCIL_TEST); m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_COLOR), false, false); m_post_processing->renderGlow(m_rtts->getRTT(RTT_QUARTER1)); glDisable(GL_STENCIL_TEST); }
void VideoViewer(const std::string& input_uri, const std::string& output_uri) { pangolin::Var<int> record_timelapse_frame_skip("viewer.record_timelapse_frame_skip", 1 ); pangolin::Var<int> end_frame("viewer.end_frame", std::numeric_limits<int>::max() ); pangolin::Var<bool> video_wait("video.wait", true); pangolin::Var<bool> video_newest("video.newest", false); // Open Video by URI pangolin::VideoRecordRepeat video(input_uri, output_uri); const size_t num_streams = video.Streams().size(); if(num_streams == 0) { pango_print_error("No video streams from device.\n"); return; } // Output details of video stream for(size_t s = 0; s < num_streams; ++s) { const pangolin::StreamInfo& si = video.Streams()[s]; std::cout << "Stream " << s << ": " << si.Width() << " x " << si.Height() << " " << si.PixFormat().format << " (pitch: " << si.Pitch() << " bytes)" << std::endl; } // Check if video supports VideoPlaybackInterface pangolin::VideoPlaybackInterface* video_playback = pangolin::FindFirstMatchingVideoInterface<pangolin::VideoPlaybackInterface>(video); const int total_frames = video_playback ? video_playback->GetTotalFrames() : std::numeric_limits<int>::max(); const int slider_size = (total_frames < std::numeric_limits<int>::max() ? 20 : 0); if( video_playback ) { if(total_frames < std::numeric_limits<int>::max() ) { std::cout << "Video length: " << total_frames << " frames" << std::endl; } end_frame = 0; } std::vector<unsigned char> buffer; buffer.resize(video.SizeBytes()+1); // Create OpenGL window - guess sensible dimensions pangolin::CreateWindowAndBind( "VideoViewer", (int)(video.Width() * num_streams), (int)(video.Height() + slider_size) ); // Assume packed OpenGL data unless otherwise specified glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glPixelStorei(GL_PACK_ALIGNMENT, 1); glEnable (GL_BLEND); glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Setup resizable views for video streams std::vector<pangolin::GlPixFormat> glfmt; std::vector<std::pair<float,float> > gloffsetscale; std::vector<size_t> strides; std::vector<pangolin::ImageViewHandler> handlers; handlers.reserve(num_streams); size_t scratch_buffer_bytes = 0; pangolin::View& container = pangolin::Display("streams"); container.SetLayout(pangolin::LayoutEqual) .SetBounds(pangolin::Attach::Pix(slider_size), 1.0, 0.0, 1.0); for(unsigned int d=0; d < num_streams; ++d) { const pangolin::StreamInfo& si = video.Streams()[d]; pangolin::View& view = pangolin::CreateDisplay().SetAspect(si.Aspect()); container.AddDisplay(view); glfmt.push_back(pangolin::GlPixFormat(si.PixFormat())); gloffsetscale.push_back(std::pair<float,float>(0.0f, 1.0f) ); if( si.PixFormat().bpp % 8 ) { pango_print_warn("Stream %i: Unable to display formats that are not a multiple of 8 bits.", d); } if( (8*si.Pitch()) % si.PixFormat().bpp ) { pango_print_warn("Stream %i: Unable to display formats whose pitch is not a whole number of pixels.", d); } if(glfmt.back().gltype == GL_DOUBLE) { scratch_buffer_bytes = std::max(scratch_buffer_bytes, sizeof(float)*si.Width() * si.Height()); } strides.push_back( (8*si.Pitch()) / si.PixFormat().bpp ); handlers.push_back( pangolin::ImageViewHandler(si.Width(), si.Height()) ); view.SetHandler(&handlers.back()); } // current frame in memory buffer and displaying. pangolin::Var<int> frame("ui.frame", -1, 0, total_frames-1 ); pangolin::Slider frame_slider("frame", frame.Ref() ); if(video_playback && total_frames < std::numeric_limits<int>::max()) { frame_slider.SetBounds(0.0, pangolin::Attach::Pix(slider_size), 0.0, 1.0); pangolin::DisplayBase().AddDisplay(frame_slider); } std::vector<unsigned char> scratch_buffer; scratch_buffer.resize(scratch_buffer_bytes); std::vector<pangolin::Image<unsigned char> > images; #ifdef CALLEE_HAS_CPP11 const int FRAME_SKIP = 30; const char show_hide_keys[] = {'1','2','3','4','5','6','7','8','9'}; const char screenshot_keys[] = {'!','"','#','$','%','^','&','*','('}; // Show/hide streams for(size_t v=0; v < container.NumChildren() && v < 9; v++) { pangolin::RegisterKeyPressCallback(show_hide_keys[v], [v,&container](){ container[v].ToggleShow(); } ); pangolin::RegisterKeyPressCallback(screenshot_keys[v], [v,&images,&video](){ if(v < images.size() && images[v].ptr) { try{ pangolin::SaveImage( images[v], video.Streams()[v].PixFormat(), pangolin::MakeUniqueFilename("capture.png") ); }catch(std::exception e){ pango_print_error("Unable to save frame: %s\n", e.what()); } } } ); } pangolin::RegisterKeyPressCallback('r', [&](){ if(!video.IsRecording()) { video.SetTimelapse( static_cast<size_t>(record_timelapse_frame_skip) ); video.Record(); pango_print_info("Started Recording.\n"); }else{ video.Stop(); pango_print_info("Finished recording.\n"); } fflush(stdout); }); pangolin::RegisterKeyPressCallback('p', [&](){ video.Play(); end_frame = std::numeric_limits<int>::max(); pango_print_info("Playing from file log.\n"); fflush(stdout); }); pangolin::RegisterKeyPressCallback('s', [&](){ video.Source(); end_frame = std::numeric_limits<int>::max(); pango_print_info("Playing from source input.\n"); fflush(stdout); }); pangolin::RegisterKeyPressCallback(' ', [&](){ end_frame = (frame < end_frame) ? frame : std::numeric_limits<int>::max(); }); pangolin::RegisterKeyPressCallback('w', [&](){ video_wait = !video_wait; if(video_wait) { pango_print_info("Gui wait's for video frame.\n"); }else{ pango_print_info("Gui doesn't wait for video frame.\n"); } }); pangolin::RegisterKeyPressCallback('d', [&](){ video_newest = !video_newest; if(video_newest) { pango_print_info("Discarding old frames.\n"); }else{ pango_print_info("Not discarding old frames.\n"); } }); pangolin::RegisterKeyPressCallback('<', [&](){ if(video_playback) { frame = video_playback->Seek(frame - FRAME_SKIP) -1; end_frame = frame + 1; }else{ pango_print_warn("Unable to skip backward."); } }); pangolin::RegisterKeyPressCallback('>', [&](){ if(video_playback) { frame = video_playback->Seek(frame + FRAME_SKIP) -1; end_frame = frame + 1; }else{ end_frame = frame + FRAME_SKIP; } }); pangolin::RegisterKeyPressCallback(',', [&](){ if(video_playback) { frame = video_playback->Seek(frame - 1) -1; end_frame = frame+1; }else{ pango_print_warn("Unable to skip backward."); } }); pangolin::RegisterKeyPressCallback('.', [&](){ // Pause at next frame end_frame = frame+1; }); pangolin::RegisterKeyPressCallback('0', [&](){ video.RecordOneFrame(); }); pangolin::RegisterKeyPressCallback('a', [&](){ // Adapt scale for(unsigned int i=0; i<images.size(); ++i) { if(container[i].HasFocus()) { pangolin::Image<unsigned char>& img = images[i]; pangolin::ImageViewHandler& ivh = handlers[i]; const bool have_selection = std::isfinite(ivh.GetSelection().Area()) && std::abs(ivh.GetSelection().Area()) >= 4; pangolin::XYRangef froi = have_selection ? ivh.GetSelection() : ivh.GetViewToRender(); gloffsetscale[i] = pangolin::GetOffsetScale(img, froi.Cast<int>(), glfmt[i]); } } }); pangolin::RegisterKeyPressCallback('g', [&](){ std::pair<float,float> os_default(0.0f, 1.0f); // Get the scale and offset from the container that has focus. for(unsigned int i=0; i<images.size(); ++i) { if(container[i].HasFocus()) { pangolin::Image<unsigned char>& img = images[i]; pangolin::ImageViewHandler& ivh = handlers[i]; const bool have_selection = std::isfinite(ivh.GetSelection().Area()) && std::abs(ivh.GetSelection().Area()) >= 4; pangolin::XYRangef froi = have_selection ? ivh.GetSelection() : ivh.GetViewToRender(); os_default = pangolin::GetOffsetScale(img, froi.Cast<int>(), glfmt[i]); break; } } // Adapt scale for all images equally // TODO : we're assuming the type of all the containers images' are the same. for(unsigned int i=0; i<images.size(); ++i) { gloffsetscale[i] = os_default; } }); #endif // CALLEE_HAS_CPP11 #ifdef DEBUGVIDEOVIEWER unsigned int delayms = 0; pangolin::RegisterKeyPressCallback('z', [&](){ // Adapt delay delayms += 1; std::cout << " Fake delay " << delayms << "ms" << std::endl; }); pangolin::RegisterKeyPressCallback('x', [&](){ // Adapt delay delayms = (delayms > 1) ? delayms-1 : 0; }); pangolin::basetime start,now; #endif // DEBUGVIDEOVIEWER // Stream and display video while(!pangolin::ShouldQuit()) { glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); glColor3f(1.0f, 1.0f, 1.0f); if(frame.GuiChanged()) { if(video_playback) { frame = video_playback->Seek(frame) -1; } end_frame = frame + 1; } #ifdef DEBUGVIDEOVIEWER boostd::this_thread::sleep_for(boostd::chrono::milliseconds(delayms)); std::cout << "-------------------------------------------------------" << std::endl; now = pangolin::TimeNow(); std::cout << " FPS: " << 1.0/pangolin::TimeDiff_s(start, now) << " artificial delay: " << delayms <<"ms"<< std::endl; std::cout << "-------------------------------------------------------" << std::endl; start = now; #endif if ( frame < end_frame ) { if( video.Grab(&buffer[0], images, video_wait, video_newest) ) { frame = frame +1; } } #ifdef DEBUGVIDEOVIEWER const pangolin::basetime end = pangolin::TimeNow(); std::cout << "Total grab time: " << 1000*pangolin::TimeDiff_s(start, end) << "ms" << std::endl; #endif glLineWidth(1.5f); glDisable(GL_DEPTH_TEST); for(unsigned int i=0; i<images.size(); ++i) { if(container[i].IsShown()) { container[i].Activate(); pangolin::Image<unsigned char>& image = images[i]; // Get texture of correct dimension / format const pangolin::GlPixFormat& fmt = glfmt[i]; pangolin::GlTexture& tex = pangolin::TextureCache::I().GlTex((GLsizei)image.w, (GLsizei)image.h, fmt.scalable_internal_format, fmt.glformat, GL_FLOAT); // Upload image data to texture tex.Bind(); if(fmt.gltype == GL_DOUBLE) { // Convert to float first, using scrath_buffer for storage pangolin::Image<float> fimage(image.w, image.h, image.w*sizeof(float), (float*)scratch_buffer.data()); ConvertPixels<float,double>( fimage, image.Reinterpret<double>() ); glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); tex.Upload(fimage.ptr,0,0, (GLsizei)fimage.w, (GLsizei)fimage.h, fmt.glformat, GL_FLOAT); }else{ glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint)strides[i]); tex.Upload(image.ptr,0,0, (GLsizei)image.w, (GLsizei)image.h, fmt.glformat, fmt.gltype); } // Render handlers[i].UpdateView(); handlers[i].glSetViewOrtho(); const std::pair<float,float> os = gloffsetscale[i]; pangolin::GlSlUtilities::OffsetAndScale(os.first, os.second); handlers[i].glRenderTexture(tex); pangolin::GlSlUtilities::UseNone(); handlers[i].glRenderOverlay(); } } glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); // leave in pixel orthographic for slider to render. pangolin::DisplayBase().ActivatePixelOrthographic(); if(video.IsRecording()) { pangolin::glRecordGraphic(pangolin::DisplayBase().v.w-14.0f, pangolin::DisplayBase().v.h-14.0f, 7.0f); } pangolin::FinishFrame(); } }
void CMiniMap::DrawForReal(bool use_geo) { SCOPED_TIMER("MiniMap::DrawForReal"); //glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glPushAttrib(GL_DEPTH_BUFFER_BIT); glDisable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glDepthMask(GL_FALSE); glDisable(GL_TEXTURE_2D); glMatrixMode(GL_MODELVIEW); if (minimized) { if (!slaveDrawMode) { DrawMinimizedButton(); } glPopAttrib(); glEnable(GL_TEXTURE_2D); return; } // draw the frameborder if (!slaveDrawMode && !globalRendering->dualScreenMode && !maximized) { glEnable(GL_BLEND); DrawFrame(); glDisable(GL_BLEND); } bool resetTextureMatrix = false; if (use_geo) { glPushMatrix(); // switch to normalized minimap coords if (globalRendering->dualScreenMode) { glViewport(xpos, ypos, width, height); glScalef(width * globalRendering->pixelX, height * globalRendering->pixelY, 1.0f); } else { glTranslatef(xpos * globalRendering->pixelX, ypos * globalRendering->pixelY, 0.0f); glScalef(width * globalRendering->pixelX, height * globalRendering->pixelY, 1.0f); } /* FIXME: fix mouse handling too and make it fully customizable, so Lua can rotate the minimap to any angle CCameraController* camController = &camHandler->GetCurrentController(); COverheadController* taCam = dynamic_cast<COverheadController*>(camController); SmoothController* smCam = dynamic_cast<SmoothController*>(camController); if ((taCam && taCam->flipped) || (smCam && smCam->flipped)) { glTranslatef(1.0f, 1.0f, 0.0f); glScalef(-1.0f, -1.0f, 1.0f); glMatrixMode(GL_TEXTURE); glPushMatrix(); glTranslatef(1.0f, 1.0f, 0.0f); glScalef(-1.0f, -1.0f, 1.0f); glMatrixMode(GL_MODELVIEW); resetTextureMatrix = true; }*/ } setSurfaceCircleFunc(DrawSurfaceCircle); setSurfaceSquareFunc(DrawSurfaceSquare); cursorIcons.Enable(false); glColor4f(0.6f, 0.6f, 0.6f, 1.0f); // don't mirror the map texture with flipped cameras glMatrixMode(GL_TEXTURE); glPushMatrix(); glLoadIdentity(); glMatrixMode(GL_MODELVIEW); // draw the map glDisable(GL_BLEND); readmap->DrawMinimap(); glEnable(GL_BLEND); glMatrixMode(GL_TEXTURE); glPopMatrix(); glMatrixMode(GL_MODELVIEW); // clip everything outside of the minimap box { const double plane0[4] = {0,-1,0,1}; const double plane1[4] = {0,1,0,0}; const double plane2[4] = {-1,0,0,1}; const double plane3[4] = {1,0,0,0}; glClipPlane(GL_CLIP_PLANE0, plane0); // clip bottom glClipPlane(GL_CLIP_PLANE1, plane1); // clip top glClipPlane(GL_CLIP_PLANE2, plane2); // clip right glClipPlane(GL_CLIP_PLANE3, plane3); // clip left glEnable(GL_CLIP_PLANE0); glEnable(GL_CLIP_PLANE1); glEnable(GL_CLIP_PLANE2); glEnable(GL_CLIP_PLANE3); } // switch to top-down map/world coords (z is twisted with y compared to the real map/world coords) glPushMatrix(); glTranslatef(0.0f, +1.0f, 0.0f); glScalef(+1.0f / (gs->mapx * SQUARE_SIZE), -1.0f / (gs->mapy * SQUARE_SIZE), 1.0f); glEnable(GL_TEXTURE_2D); glEnable(GL_ALPHA_TEST); glAlphaFunc(GL_GREATER, 0.0f); { GML_RECMUTEX_LOCK(unit); // DrawForReal const std::set<CUnit*>& units = unitDrawer->GetUnsortedUnits(); for (std::set<CUnit*>::const_iterator it = units.begin(); it != units.end(); ++it) { DrawUnit(*it); } // highlight the selected unit CUnit* unit = GetSelectUnit(GetMapPosition(mouse->lastx, mouse->lasty)); if (unit != NULL) { DrawUnitHighlight(unit); } } glDisable(GL_ALPHA_TEST); glDisable(GL_TEXTURE_2D); glPushMatrix(); glRotatef(-90.0f, +1.0f, 0.0f, 0.0f); // real 'world' coordinates glScalef(1.0f, 0.0f, 1.0f); // skip the y-coord (Lua's DrawScreen is perspective and so any z-coord in it influence the x&y, too) // draw the projectiles if (drawProjectiles) { glPointSize(1.0f); WorkaroundATIPointSizeBug(); projectileDrawer->DrawProjectilesMiniMap(); } // draw the queued commands // // NOTE: this needlessly adds to the CursorIcons list, but at least // they are not drawn (because the input receivers are drawn // after the command queues) LuaUnsyncedCtrl::DrawUnitCommandQueues(); if ((drawCommands > 0) && guihandler->GetQueueKeystate()) { selectedUnits.DrawCommands(); } lineDrawer.DrawAll(); // draw the selection shape, and some ranges if (drawCommands > 0) { guihandler->DrawMapStuff(!!drawCommands); } { GML_RECMUTEX_LOCK(sel); // DrawForReal // draw unit ranges const float radarSquare = radarhandler->radarDiv; CUnitSet& selUnits = selectedUnits.selectedUnits; for(CUnitSet::iterator si = selUnits.begin(); si != selUnits.end(); ++si) { CUnit* unit = *si; if (unit->radarRadius && !unit->beingBuilt && unit->activated) { glColor3fv(cmdColors.rangeRadar); DrawCircle(unit->pos, (unit->radarRadius * radarSquare)); } if (unit->sonarRadius && !unit->beingBuilt && unit->activated) { glColor3fv(cmdColors.rangeSonar); DrawCircle(unit->pos, (unit->sonarRadius * radarSquare)); } if (unit->jammerRadius && !unit->beingBuilt && unit->activated) { glColor3fv(cmdColors.rangeJammer); DrawCircle(unit->pos, (unit->jammerRadius * radarSquare)); } // change if someone someday create a non stockpiled interceptor const CWeapon* w = unit->stockpileWeapon; if((w != NULL) && w->weaponDef->interceptor) { if (w->numStockpiled) { glColor3fv(cmdColors.rangeInterceptorOn); } else { glColor3fv(cmdColors.rangeInterceptorOff); } DrawCircle(unit->pos, w->weaponDef->coverageRange); } } } glPopMatrix(); // revert to the 2d xform if (!minimap->maximized) { // draw the camera frustum lines cam2->GetFrustumSides(0.0f, 0.0f, 1.0f, true); cam2->ClipFrustumLines(true, -10000.0f, 400096.0f); const std::vector<CCamera::FrustumLine>& negSides = cam2->negFrustumSides; // const std::vector<CCamera::FrustumLine>& posSides = cam2->posFrustumSides; std::vector<CCamera::FrustumLine>::const_iterator fli; CVertexArray* va = GetVertexArray(); va->Initialize(); va->EnlargeArrays(negSides.size() * 2, 0, VA_SIZE_2D0); for (fli = negSides.begin(); fli != negSides.end(); ++fli) { if (fli->minz < fli->maxz) { va->AddVertex2dQ0(fli->base + (fli->dir * fli->minz), fli->minz); va->AddVertex2dQ0(fli->base + (fli->dir * fli->maxz), fli->maxz); } } glLineWidth(2.5f); glColor4f(0, 0, 0, 0.5f); va->DrawArray2d0(GL_LINES); glLineWidth(1.5f); glColor4f(1, 1, 1, 0.75f); va->DrawArray2d0(GL_LINES); glLineWidth(1.0f); } // selection box glColor4f(1.0f, 1.0f, 1.0f, 1.0f); CMouseHandler::ButtonPressEvt& bp = mouse->buttons[SDL_BUTTON_LEFT]; if (selecting && fullProxy && (bp.movement > 4)) { const float3 oldPos = GetMapPosition(bp.x, bp.y); const float3 newPos = GetMapPosition(mouse->lastx, mouse->lasty); glColor4fv(cmdColors.mouseBox); glBlendFunc((GLenum)cmdColors.MouseBoxBlendSrc(), (GLenum)cmdColors.MouseBoxBlendDst()); glLineWidth(cmdColors.MouseBoxLineWidth()); float verts[] = { oldPos.x, oldPos.z, newPos.x, oldPos.z, newPos.x, newPos.z, oldPos.x, newPos.z, }; glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(2, GL_FLOAT, 0, verts); glDrawArrays(GL_LINE_LOOP, 0, 4); glDisableClientState(GL_VERTEX_ARRAY); glLineWidth(1.0f); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); } DrawNotes(); // reset 1 if (resetTextureMatrix) { glMatrixMode(GL_TEXTURE_MATRIX); glPopMatrix(); } glMatrixMode(GL_MODELVIEW); if (use_geo) { glPopMatrix(); } // reset 2 glPopMatrix(); glPopAttrib(); glEnable(GL_TEXTURE_2D); { //! prepare ClipPlanes for Lua's DrawInMinimap Modelview matrix //! quote from glClipPlane spec: //! "When glClipPlane is called, equation is transformed by the inverse of the modelview matrix and stored in the resulting eye coordinates. //! Subsequent changes to the modelview matrix have no effect on the stored plane-equation components." //! -> we have to use the same modelview matrix when calling glClipPlane and later draw calls //! set the modelview matrix to the same as used in Lua's DrawInMinimap glPushMatrix(); glLoadIdentity(); glScalef(1.0f / width, 1.0f / height, 1.0f); const double plane0[4] = {0, -1, 0, double(height)}; const double plane1[4] = {0, 1, 0, 0}; const double plane2[4] = {-1, 0, 0, double(width)}; const double plane3[4] = {1, 0, 0, 0}; glClipPlane(GL_CLIP_PLANE0, plane0); // clip bottom glClipPlane(GL_CLIP_PLANE1, plane1); // clip top glClipPlane(GL_CLIP_PLANE2, plane2); // clip right glClipPlane(GL_CLIP_PLANE3, plane3); // clip left glPopMatrix(); } //! allow the LUA scripts to draw into the minimap eventHandler.DrawInMiniMap(); if (use_geo && globalRendering->dualScreenMode) glViewport(globalRendering->viewPosX,0,globalRendering->viewSizeX,globalRendering->viewSizeY); //FIXME: Lua modifies the matrices w/o reseting it! (quite complexe to fix because ClearMatrixStack() makes it impossible to use glPushMatrix) glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0,1,0,1); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); // disable ClipPlanes glDisable(GL_CLIP_PLANE0); glDisable(GL_CLIP_PLANE1); glDisable(GL_CLIP_PLANE2); glDisable(GL_CLIP_PLANE3); cursorIcons.Enable(true); setSurfaceCircleFunc(NULL); setSurfaceSquareFunc(NULL); }
void RobotWindow::configure() { // Especifica que a cor de fundo da janela será preta glClearColor(0.0f, 0.0f, 0.0f, 1.0f); // informações sobre a luz GLfloat luzAmbiente[4]={0.4, 0.4, 0.4, 1.0}; GLfloat luzDifusa[4]={0.8, 0.8, 0.8, 1.0}; // "cor" GLfloat luzEspecular[4]={1.0, 1.0, 1.0, 1.0}; // "brilho" GLfloat posicaoLuz[4]={4.0, 100, 4.0, 0}; // Define os parâmetros da luz de número 0 glLightfv(GL_LIGHT0, GL_AMBIENT, luzAmbiente); glLightfv(GL_LIGHT0, GL_DIFFUSE, luzDifusa); glLightfv(GL_LIGHT0, GL_SPECULAR, luzEspecular); glLightfv(GL_LIGHT0, GL_POSITION, posicaoLuz); // Capacidade de brilho do material GLfloat especularidade[4]={0.5,0.5,0.5,0.5}; GLint especMaterial = 60; // Define a refletância do material glMaterialfv(GL_FRONT, GL_SPECULAR, especularidade); // Define a concentração do brilho glMateriali(GL_FRONT, GL_SHININESS, especMaterial); // GLfloat materialColor[] = { 1.0, 1.0, 1.0, 1.0 }; glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, materialColor); // Ativa o uso da luz ambiente glLightModelfv(GL_LIGHT_MODEL_AMBIENT, luzAmbiente); // Habilita a definição da cor do material a partir da cor corrente // Usar as cores correntes para colorir os materiais perceptíveis no escuro glEnable(GL_COLOR_MATERIAL); //Habilita o uso de iluminação glEnable(GL_LIGHTING); // Declara iluminação // Habilita a luz de número 0 glEnable(GL_LIGHT0); // Usa iluminação na luz/lâmpada 0 // Habilita o depth-buffering // Faz a luz preencher o buffer de pronfundidade e não só o fundo glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); //glDepthRange(0.0f,1.0f); // Habilita o modelo de colorização de Gouraud glShadeModel(GL_SMOOTH); //glShadeModel(GL_FLAT); glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE); glEnable(GL_NORMALIZE); glEnable(GL_DITHER); //glEnable(GL_POINT_SMOOTH); //glHint(GL_POINT_SMOOTH_HINT, GL_NICEST); glEnable(GL_LINE_SMOOTH); glHint(GL_LINE_SMOOTH_HINT, GL_NICEST); glLineWidth(0.5); //glEnable(GL_POLYGON_SMOOTH); //glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST); //glDepthFunc( GL_LEQUAL ); //glClearAccum( 0.0, 0.0, 0.0, 0.0 ); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); glEnable(GL_ALPHA_TEST); glEnable(GL_BLEND); glEnable(GL_DEPTH_TEST); //glBlendFunc(GL_SRC_ALPHA, GL_DST_COLOR); //glBlendFunc(GL_ONE, GL_ONE); //glBlendFunc(GL_SRC_ALPHA_SATURATE, GL_ONE); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); //glBlendFunc(GL_ONE_MINUS_DST_ALPHA,GL_DST_ALPHA); //glDepthFunc(GL_EQUAL); //glDepthFunc(GL_GEQUAL); glEnable(GL_CULL_FACE); //glCullFace(GL_BACK); }
void glmShaderMaterial(GLMmaterial *mat) { static const float ambientLight[4] = { 0.1, 0.1, 0.1, 0.0 }; static const float diffuseLight[4] = { 0.75, 0.75, 0.75, 1.0 }; static const float specularLight[4] = { 1.0, 1.0, 1.0, 0.0 }; if (!mat->prog) { /* make shader now */ char newShader[10000]; GLuint vs, fs; const char *diffuseTex = mat->texture_kd ? "true" : "false"; const char *specularTex = mat->texture_ks ? "true" : "false"; GLint uAmbientLight, uDiffuseLight, uSpecularLight; /* replace %d with 0 or 1 */ sprintf(newShader, TexFragmentShader, diffuseTex, specularTex); if (0) printf("===== new shader =====\n%s\n============\n", newShader); vs = CompileShaderText(GL_VERTEX_SHADER, VertexShader); fs = CompileShaderText(GL_FRAGMENT_SHADER, newShader); mat->prog = LinkShaders(vs, fs); assert(mat->prog); glUseProgram(mat->prog); mat->uAmbient = glGetUniformLocation(mat->prog, "ambient"); mat->uDiffuse = glGetUniformLocation(mat->prog, "diffuse"); mat->uSpecular = glGetUniformLocation(mat->prog, "specular"); mat->uShininess = glGetUniformLocation(mat->prog, "shininess"); mat->uDiffTex = glGetUniformLocation(mat->prog, "diffTex"); mat->uSpecTex = glGetUniformLocation(mat->prog, "specTex"); uAmbientLight = glGetUniformLocation(mat->prog, "ambientLight"); uDiffuseLight = glGetUniformLocation(mat->prog, "diffuseLight"); uSpecularLight = glGetUniformLocation(mat->prog, "specularLight"); glUniform4fv(mat->uAmbient, 1, mat->ambient); glUniform4fv(mat->uDiffuse, 1, mat->diffuse); glUniform4fv(mat->uSpecular, 1, mat->specular); glUniform1f(mat->uShininess, mat->shininess); glUniform1i(mat->uDiffTex, 0); glUniform1i(mat->uSpecTex, 1); glUniform4fv(uAmbientLight, 1, ambientLight); glUniform4fv(uDiffuseLight, 1, diffuseLight); glUniform4fv(uSpecularLight, 1, specularLight); } glActiveTexture(GL_TEXTURE1); if (mat->texture_ks) glBindTexture(GL_TEXTURE_CUBE_MAP, mat->texture_ks); else glBindTexture(GL_TEXTURE_CUBE_MAP, 0); glActiveTexture(GL_TEXTURE0); if (mat->texture_kd) glBindTexture(GL_TEXTURE_2D, mat->texture_kd); else glBindTexture(GL_TEXTURE_2D, 0); if (mat->diffuse[3] < 1.0) { glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); } else { glDisable(GL_BLEND); } glUseProgram(mat->prog); }
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(); } }