void display(void) { static char s[256], t[32]; static char* p; static int frames = 0; glClearColor(1.0, 1.0, 1.0, 1.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPushMatrix(); glTranslatef(pan_x, pan_y, 0.0); gltbMatrix(); if(!start) { #if 0 // glmDraw() performance test if (material_mode == 0) { if (facet_normal) glmDraw(model, GLM_FLAT); else glmDraw(model, GLM_SMOOTH); } else if (material_mode == 1) { if (facet_normal) glmDraw(model, GLM_FLAT | GLM_COLOR); else glmDraw(model, GLM_SMOOTH | GLM_COLOR); } else if (material_mode == 2) { if (facet_normal) glmDraw(model, GLM_FLAT | GLM_MATERIAL); else glmDraw(model, GLM_SMOOTH | GLM_MATERIAL); } #else glCallList(model_list); #endif glDisable(GL_LIGHTING); if (bounding_box) { glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND); glEnable(GL_CULL_FACE); glColor4f(1.0, 0.0, 0.0, 0.25); glutSolidCube(2.0); glDisable(GL_BLEND); } } else { //glDisable(GL_LIGHTING); newDrawMechanism(); glEnable(GL_LIGHTING); } glPopMatrix(); if (stats) { /* XXX - this could be done a _whole lot_ faster... */ int height = glutGet(GLUT_WINDOW_HEIGHT); glColor3ub(0, 0, 0); sprintf(s, "%s\n%d vertices\n%d triangles\n%d normals\n" "%d texcoords\n%d groups\n%d materials", model->pathname, model->numvertices, model->numtriangles, model->numnormals, model->numtexcoords, model->numgroups, model->nummaterials); shadowtext(5, height-(5+18*1), s); } /* spit out frame rate. */ frames++; if (frames > NUM_FRAMES) { sprintf(t, "%g fps", frames/elapsed()); frames = 0; } if (performance) { shadowtext(5, 5, t); } glutSwapBuffers(); glEnable(GL_LIGHTING); }
//desenha um quadrado de lado quadsize e normal x=1, y=2, z=3 void quad(int normal,int size,int texture, int teste) { GLint i,j; float med_dim=(float)floor_dim/2; if(texture ==1) /*se for para aplicar textura*/ { glEnable(GL_TEXTURE_2D); if(level==0) { glBindTexture(GL_TEXTURE_2D,tex[0]); } else if(level == 1) { glBindTexture(GL_TEXTURE_2D,tex[2]); } else { glBindTexture(GL_TEXTURE_2D,tex[4]); } glPushMatrix(); glBegin(GL_QUADS); for (int i=0;i<floor_dim*floorsize;i++)//preenche para z maior { for (int j=0;j<floor_dim*floorsize;j++)//preenche para x maior { glNormal3f(0,1,0); glTexCoord2f((float)j/floor_dim,(float)i/floor_dim); glVertex3d((float)j/med_dim,0,(float)i/med_dim); glTexCoord2f((float)(j+1)/floor_dim,(float)i/floor_dim); glVertex3d((float)(j+1)/med_dim,0,(float)i/med_dim); glTexCoord2f((float)(j+1)/floor_dim,(float)(i+1)/floor_dim); glVertex3d((float)(j+1)/med_dim,0,(float)(i+1)/med_dim); glTexCoord2f((float)j/floor_dim,(float)(i+1)/floor_dim); glVertex3d((float)j/med_dim,0,(float)(i+1)/med_dim); if(teste==2 && j==31) break; } if(teste==1 && i==31) break; } glEnd(); glPopMatrix(); glDisable(GL_TEXTURE_2D); } else { glBegin(GL_QUADS); for (i=0;i<floor_dim*multiplier;i++) { for (j=0;j<floor_dim*multiplier;j++) { switch(normal) { case 1: glNormal3f(1, 0, 0); // definição da normal ao polígono break; case 2: glNormal3f(0, 1, 0); // definição da normal ao polígono break; case 3: glNormal3f(0, 0, 1); // definição da normal ao polígono break; } glVertex3d((float)j/med_dim,0,(float)i/med_dim); //r[0] glVertex3d((float)(j+1)/med_dim,0,(float)i/med_dim); // r[1] glVertex3d((float)(j+1)/med_dim,0,(float)(i+1)/med_dim); glVertex3d((float)j/med_dim,0,(float)(i+1)/med_dim); } } glEnd(); } }
void reflection(){ glPushMatrix(); //glRotatef(-90,1,0,0); quad(2,1,1,0); glPopMatrix(); //REFLEXÃO //1. Activa o uso do stencil buffer glEnable(GL_STENCIL_TEST); //2. Nao escreve no color buffer - desativar glColorMask(GL_FALSE, GL_FALSE,GL_FALSE, GL_FALSE); //3. Torna inactivo o teste de profundidade glDisable(GL_DEPTH_TEST); //4. Coloca a 1 todos os pixels no stencil buffer que representam o chão. A combinaçao desenhaChao + StencilFunc + StencilOp e que me da a mascara. A area de desenho, que vai ser colocada 1, e dada pelo desenhaChao. glStencilFunc(GL_ALWAYS, 1, 1); glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); //5. Desenhar o quadrado drawEdges(); //6. Activa a escrita de cor glColorMask(1, 1, 1, 1); //7. Activa o teste de profundidade glEnable(GL_DEPTH_TEST); //8. O stencil test passa apenas quando o pixel tem o valor 1 no stencil buffer glStencilFunc(GL_EQUAL, 1, 1); //9. Stencil buffer read-only glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); //10. Desenha o objecto com a reflexão onde stencil buffer é 1 //para z=0 e z=10 glPushMatrix(); glTranslatef(0, 0, -0.001); glRotatef(-90,1,0,0); glScalef(1,-1,1); quad(2,1,1,1); glPopMatrix(); glPushMatrix(); glTranslatef(0, 2, 10.001); glRotatef(90,1,0,0); glScalef(1,-1,1); quad(2,1,1,1); glPopMatrix(); //---------------------------- //para x=0 e x=10 glPushMatrix(); glTranslatef(-0.001, 0,0); glRotatef(90,0,0,1); glScalef(1,-1,1); quad(2,1,1,2); glPopMatrix(); glPushMatrix(); glTranslatef(10.001, 2,0); glRotatef(270,0,0,1); glScalef(1,-1,1); quad(2,1,1,2); glPopMatrix(); //11. Desactiva a utilização do stencil buffer glDisable(GL_STENCIL_TEST); // isto aplica a textura ao chao Blending glEnable(GL_BLEND); glColor4f(1, 1, 1, 0.3); drawEdges(); glDisable(GL_BLEND); }
// static void LLTracker::renderBeacon(LLVector3d pos_global, const LLColor4& color, LLHUDText* hud_textp, const std::string& label ) { sCheesyBeacon = gSavedSettings.getBOOL("CheesyBeacon"); LLVector3d to_vec = pos_global - gAgent.getCameraPositionGlobal(); F32 dist = (F32)to_vec.magVec(); F32 color_frac = 1.f; if (dist > 0.99f * LLViewerCamera::getInstance()->getFar()) { color_frac = 0.4f; // pos_global = gAgent.getCameraPositionGlobal() + 0.99f*(LLViewerCamera::getInstance()->getFar()/dist)*to_vec; } else { color_frac = 1.f - 0.6f*(dist/LLViewerCamera::getInstance()->getFar()); } LLColor4 fogged_color = color_frac * color + (1 - color_frac)*gSky.getFogColor(); F32 FADE_DIST = 3.f; fogged_color.mV[3] = llmax(0.2f, llmin(0.5f,(dist-FADE_DIST)/FADE_DIST)); LLVector3 pos_agent = gAgent.getPosAgentFromGlobal(pos_global); LLGLSTracker gls_tracker; // default+ CULL_FACE + LIGHTING + GL_BLEND + GL_ALPHA_TEST gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE); LLGLDisable cull_face(GL_CULL_FACE); LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glTranslatef(pos_agent.mV[0], pos_agent.mV[1], pos_agent.mV[2]); draw_shockwave(1024.f, gRenderStartTime.getElapsedTimeF32(), 32, fogged_color); gGL.color4fv(fogged_color.mV); const U32 BEACON_VERTS = 256; const F32 step = 1024.0f/BEACON_VERTS; LLVector3 x_axis = LLViewerCamera::getInstance()->getLeftAxis(); F32 t = gRenderStartTime.getElapsedTimeF32(); F32 dr = dist/LLViewerCamera::getInstance()->getFar(); for (U32 i = 0; i < BEACON_VERTS; i++) { F32 x = x_axis.mV[0]; F32 y = x_axis.mV[1]; F32 z = i * step; F32 z_next = (i+1)*step; F32 a = pulse_func(t, z); F32 an = pulse_func(t, z_next); LLColor4 c_col = fogged_color + LLColor4(a,a,a,a); LLColor4 col_next = fogged_color + LLColor4(an,an,an,an); LLColor4 col_edge = fogged_color * LLColor4(a,a,a,0.0f); LLColor4 col_edge_next = fogged_color * LLColor4(an,an,an,0.0f); a *= 2.f; a += 1.0f+dr; an *= 2.f; an += 1.0f+dr; gGL.begin(LLRender::TRIANGLE_STRIP); gGL.color4fv(col_edge.mV); gGL.vertex3f(-x*a, -y*a, z); gGL.color4fv(col_edge_next.mV); gGL.vertex3f(-x*an, -y*an, z_next); gGL.color4fv(c_col.mV); gGL.vertex3f(0, 0, z); gGL.color4fv(col_next.mV); gGL.vertex3f(0, 0, z_next); gGL.color4fv(col_edge.mV); gGL.vertex3f(x*a,y*a,z); gGL.color4fv(col_edge_next.mV); gGL.vertex3f(x*an,y*an,z_next); gGL.end(); } //gCylinder.render(1000); glPopMatrix(); std::string text; text = llformat( "%.0f m", to_vec.magVec()); LLWString wstr; wstr += utf8str_to_wstring(label); wstr += '\n'; wstr += utf8str_to_wstring(text); hud_textp->setFont(LLFontGL::getFontSansSerif()); hud_textp->setZCompare(FALSE); hud_textp->setColor(LLColor4(1.f, 1.f, 1.f, llmax(0.2f, llmin(1.f,(dist-FADE_DIST)/FADE_DIST)))); hud_textp->setString(wstr); hud_textp->setVertAlignment(LLHUDText::ALIGN_VERT_CENTER); hud_textp->setPositionAgent(pos_agent); }
void drawExplosion(Particles_system *partSys){ //glDisable(GL_LIGHTING); glPushAttrib(GL_ALL_ATTRIB_BITS); glPushMatrix(); glEnable(GL_LIGHT0); glEnable(GL_LIGHT1); glEnable(GL_LIGHT2); glEnable(GL_BLEND); // abilita blending (superficie traslucida) glBlendFunc(GL_SRC_ALPHA,GL_ONE); // tipo di blending glDisable(GL_CULL_FACE); // disiabilita il taglio delle superfici nascoste glEnable(GL_COLOR_MATERIAL); // abilita il materiale glEnable(GL_TEXTURE_2D); // attiviamo texture glColorMaterial(GL_FRONT, GL_EMISSION); // tipo di materiale //glTranslatef(partSys->pos.x,partSys->pos.y,partSys->pos.z); // ci spostiamo nella posizione della navicella GLfloat lifeRate, moveRate; Particle* part; GLfloat *x,*y,*z; GLboolean allOff=true; for (int i=0;i<MAX_PARTICLES;i++) { part= &(partSys->particle[i]); if(part->active) { allOff=false; x=&(part->pos.x); y=&(part->pos.y); z=&(part->pos.z); // disegnamo la particella glColor4f(part->color[0],part->color[1],part->color[2],part->life); glBindTexture(GL_TEXTURE_2D, g_textureArray[4]); /* glBegin(GL_TRIANGLE_STRIP); // Costruisco un quadrato da una striscia di triangoli glTexCoord3d(1,0,1); glVertex3f(*x+0.05f,*y-0.05f,*z); // inferiore destro glTexCoord3d(0,0,1); glVertex3f(*x-0.05f,*y-0.05f,*z); // inferiore sinistro glTexCoord3d(1,1,1); glVertex3f(*x+0.05f,*y+0.05f,*z); // superiore destro glTexCoord3d(0,1,1); glVertex3f(*x-0.05f,*y+0.05f,*z); // superiore sinistro glEnd(); */ glBegin(GL_TRIANGLE_STRIP); // Costruisco un quadrato da una striscia di triangoli glTexCoord3d(1,0,1); glVertex3f(*x+0.1f,*y-0.1f,*z+0.1f); // inferiore destro glTexCoord3d(0,0,1); glVertex3f(*x-0.1f,*y-0.1f,*z-0.1f); // inferiore sinistro glTexCoord3d(1,1,1); glVertex3f(*x+0.1f,*y+0.1f,*z-0.1f); // superiore destro glTexCoord3d(0,1,1); glVertex3f(*x-0.1f,*y+0.1f,*z+0.1f); // superiore sinistro glEnd(); if(!freezeExpl){ // muoviamo la particella lifeRate = (0.5*dtime)/40; moveRate = pow(dtime,2)/2500; *x +=part->dir.x*moveRate; // muoviamo la particella su X utilizzando anche il framerate *y +=part->dir.y*moveRate; // muoviamo la particella su Y utilizzando anche il framerate *z +=part->dir.z*moveRate; // muoviamo la particella su X utilizzando anche il framerate part->fade=(float)dtime/10000000 + (rand()%100)/1000.0f; part->life-=part->fade; // Riduciamo la vita della particella } //printf("X: %f\tY: %f\tZ: %f, moverate: %f\n", *x,*y,*z, moveRate);fflush(stdout); //printf("\tX: %f\tY: %f\tZ: %f\n", part->pos.x,part->pos.y,part->pos.z);fflush(stdout); // se e' tanto distante dal punto di esplosione non la visualizziamo piu' if(distance(partSys->pos,part->pos)>120){ part->active=false; } } } // se nessuna particella e' attiva disattiviamo il sistema di particelle if(allOff) partSys->active=false; glDisable(GL_COLOR_MATERIAL); // disabilita il materiale glDisable(GL_TEXTURE_2D); glEnable(GL_CULL_FACE); // abilita il taglio delle superfici nascoste glDisable(GL_BLEND); // disabilita blending glDisable(GL_LIGHT2); glDisable(GL_LIGHT1); glDisable(GL_LIGHT0); glPopMatrix(); glPopAttrib(); //glEnable(GL_LIGHTING); }
// OpenGL2 Render function. // (this used to be set in io.RenderDrawListsFn and called by ImGui::Render(), but you can now call this directly from your main loop) // Note that this implementation is little overcomplicated because we are saving/setting up/restoring every OpenGL state explicitly, in order to be able to run within any OpenGL engine that doesn't do so. void ImGui_ImplSdlGL2_RenderDrawData(ImDrawData* draw_data) { // Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates) ImGuiIO& io = ImGui::GetIO(); int fb_width = (int)(io.DisplaySize.x * io.DisplayFramebufferScale.x); int fb_height = (int)(io.DisplaySize.y * io.DisplayFramebufferScale.y); if (fb_width == 0 || fb_height == 0) return; draw_data->ScaleClipRects(io.DisplayFramebufferScale); // We are using the OpenGL fixed pipeline to make the example code simpler to read! // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, vertex/texcoord/color pointers, polygon fill. GLint last_texture; glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture); GLint last_polygon_mode[2]; glGetIntegerv(GL_POLYGON_MODE, last_polygon_mode); GLint last_viewport[4]; glGetIntegerv(GL_VIEWPORT, last_viewport); GLint last_scissor_box[4]; glGetIntegerv(GL_SCISSOR_BOX, last_scissor_box); glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_TRANSFORM_BIT); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_CULL_FACE); glDisable(GL_DEPTH_TEST); glEnable(GL_SCISSOR_TEST); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnableClientState(GL_COLOR_ARRAY); glEnable(GL_TEXTURE_2D); glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); //glUseProgram(0); // You may want this if using this code in an OpenGL 3+ context where shaders may be bound // Setup viewport, orthographic projection matrix glViewport(0, 0, (GLsizei)fb_width, (GLsizei)fb_height); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glOrtho(0.0f, io.DisplaySize.x, io.DisplaySize.y, 0.0f, -1.0f, +1.0f); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); // Render command lists for (int n = 0; n < draw_data->CmdListsCount; n++) { const ImDrawList* cmd_list = draw_data->CmdLists[n]; const ImDrawVert* vtx_buffer = cmd_list->VtxBuffer.Data; const ImDrawIdx* idx_buffer = cmd_list->IdxBuffer.Data; glVertexPointer(2, GL_FLOAT, sizeof(ImDrawVert), (const GLvoid*)((const char*)vtx_buffer + IM_OFFSETOF(ImDrawVert, pos))); glTexCoordPointer(2, GL_FLOAT, sizeof(ImDrawVert), (const GLvoid*)((const char*)vtx_buffer + IM_OFFSETOF(ImDrawVert, uv))); glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(ImDrawVert), (const GLvoid*)((const char*)vtx_buffer + IM_OFFSETOF(ImDrawVert, col))); for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++) { const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i]; if (pcmd->UserCallback) { pcmd->UserCallback(cmd_list, pcmd); } else { glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId); glScissor((int)pcmd->ClipRect.x, (int)(fb_height - pcmd->ClipRect.w), (int)(pcmd->ClipRect.z - pcmd->ClipRect.x), (int)(pcmd->ClipRect.w - pcmd->ClipRect.y)); glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, idx_buffer); } idx_buffer += pcmd->ElemCount; } } // Restore modified state glDisableClientState(GL_COLOR_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); glBindTexture(GL_TEXTURE_2D, (GLuint)last_texture); glMatrixMode(GL_MODELVIEW); glPopMatrix(); glMatrixMode(GL_PROJECTION); glPopMatrix(); glPopAttrib(); glPolygonMode(GL_FRONT, (GLenum)last_polygon_mode[0]); glPolygonMode(GL_BACK, (GLenum)last_polygon_mode[1]); glViewport(last_viewport[0], last_viewport[1], (GLsizei)last_viewport[2], (GLsizei)last_viewport[3]); glScissor(last_scissor_box[0], last_scissor_box[1], (GLsizei)last_scissor_box[2], (GLsizei)last_scissor_box[3]); }
void SkyBox::draw(float x,float y,float z) { //Turn our world a bit, but first push the matrixes so others won't get into a strange position :P glPushMatrix(); glPushAttrib(GL_ENABLE_BIT); //Disable the depth test so we can draw this in infinity glDepthMask(false); glDisable(GL_DEPTH_TEST); glDisable(GL_LIGHTING); glDisable(GL_BLEND); glTranslatef(0.0f, y, 0.0f); //Draw some nice _large_ sky (the 100.0f scale might seem a bit large, but you have to prepare for odd camera settings too) glEnable(GL_TEXTURE_2D); glScalef(100.0f, 100.0f, 100.0f); glColor4f(1.0f, 1.0f, 1.0f, 1.0f); const float cz = -0.0f; const float cx = 1.0f; const float r = 1.0f; // FRONT Side glBindTexture(GL_TEXTURE_2D,textures[0]); glBegin(GL_QUADS); glTexCoord2f(cx, cz); glVertex3f( -r, r, r); glTexCoord2f(cz, cz); glVertex3f( r, r, r); glTexCoord2f(cz, cx); glVertex3f( r, -r, r); glTexCoord2f(cx, cx); glVertex3f( -r, -r, r); glEnd(); // BACK side glBindTexture(GL_TEXTURE_2D,textures[2]); glBegin(GL_QUADS); glTexCoord2f(cx, cz); glVertex3f( r, r, -r); glTexCoord2f(cz, cz); glVertex3f( -r, r, -r); glTexCoord2f(cz, cx); glVertex3f( -r, -r, -r); glTexCoord2f(cx, cx); glVertex3f( r, -r, -r); glEnd(); // Left side glBindTexture(GL_TEXTURE_2D,textures[3]); glBegin(GL_QUADS); glTexCoord2f(cx,cz); glVertex3f( -r, r, -r); glTexCoord2f(cz,cz); glVertex3f( -r, r, r); glTexCoord2f(cz,cx); glVertex3f( -r, -r, r); glTexCoord2f(cx,cx); glVertex3f( -r, -r, -r); glEnd(); // Right side glBindTexture(GL_TEXTURE_2D,textures[1]); glBegin(GL_QUADS); glTexCoord2f(cx, cz); glVertex3f( r, r, r); glTexCoord2f(cz, cz); glVertex3f( r, r, -r); glTexCoord2f(cz, cx); glVertex3f( r, -r, -r); glTexCoord2f(cx, cx); glVertex3f( r, -r, r); glEnd(); // Up side glBindTexture(GL_TEXTURE_2D,textures[4]); glBegin(GL_QUADS); glTexCoord2f(cx, cz); glVertex3f( -r, r, -r); glTexCoord2f(cz, cz); glVertex3f( r, r, -r); glTexCoord2f(cz, cx); glVertex3f( r, r, r); glTexCoord2f(cx, cx); glVertex3f( -r, r, r); glEnd(); // Down side glBindTexture(GL_TEXTURE_2D,textures[5]); glBegin(GL_QUADS); glTexCoord2f(cx, cz); glVertex3f( -r, -r, r); glTexCoord2f(cz, cz); glVertex3f( r, -r, r); glTexCoord2f(cz, cx); glVertex3f( r, -r, -r); glTexCoord2f(cx, cx); glVertex3f( -r, -r, -r); glEnd(); //Back to where we were glDepthMask(true); glPopAttrib(); glPopMatrix(); }
bool Application::processEvent(GHOST_IEvent* event) { GHOST_IWindow* window = event->getWindow(); bool handled = true; switch (event->getType()) { /* case GHOST_kEventUnknown: break; case GHOST_kEventCursorButton: std::cout << "GHOST_kEventCursorButton"; break; case GHOST_kEventCursorMove: std::cout << "GHOST_kEventCursorMove"; break; */ case GHOST_kEventWheel: { GHOST_TEventWheelData* wheelData = (GHOST_TEventWheelData*) event->getData(); if (wheelData->z > 0) { view_rotz += 5.f; } else { view_rotz -= 5.f; } } break; case GHOST_kEventKeyUp: break; case GHOST_kEventKeyDown: { GHOST_TEventKeyData* keyData = (GHOST_TEventKeyData*) event->getData(); switch (keyData->key) { case GHOST_kKeyC: { int cursor = m_cursor; cursor++; if (cursor >= GHOST_kStandardCursorNumCursors) { cursor = GHOST_kStandardCursorFirstCursor; } m_cursor = (GHOST_TStandardCursor)cursor; window->setCursorShape(m_cursor); } break; case GHOST_kKeyE: { int x = 200, y= 200; m_system->setCursorPosition(x,y); break; } case GHOST_kKeyF: if (!m_system->getFullScreen()) { // Begin fullscreen mode GHOST_DisplaySetting setting; setting.bpp = 16; setting.frequency = 50; setting.xPixels = 640; setting.yPixels = 480; m_system->beginFullScreen(setting, &m_fullScreenWindow, false /* stereo flag */); } else { m_system->endFullScreen(); m_fullScreenWindow = 0; } break; case GHOST_kKeyH: window->setCursorVisibility(!window->getCursorVisibility()); break; case GHOST_kKeyM: { bool down = false; m_system->getModifierKeyState(GHOST_kModifierKeyLeftShift,down); if (down) { std::cout << "left shift down\n"; } m_system->getModifierKeyState(GHOST_kModifierKeyRightShift,down); if (down) { std::cout << "right shift down\n"; } m_system->getModifierKeyState(GHOST_kModifierKeyLeftAlt,down); if (down) { std::cout << "left Alt down\n"; } m_system->getModifierKeyState(GHOST_kModifierKeyRightAlt,down); if (down) { std::cout << "right Alt down\n"; } m_system->getModifierKeyState(GHOST_kModifierKeyLeftControl,down); if (down) { std::cout << "left control down\n"; } m_system->getModifierKeyState(GHOST_kModifierKeyRightControl,down); if (down) { std::cout << "right control down\n"; } } break; case GHOST_kKeyQ: if (m_system->getFullScreen()) { m_system->endFullScreen(); m_fullScreenWindow = 0; } m_exitRequested = true; break; case GHOST_kKeyS: // toggle mono and stereo if(stereo) stereo = false; else stereo = true; break; case GHOST_kKeyT: if (!m_testTimer) { m_testTimer = m_system->installTimer(0, 1000, testTimerProc); } else { m_system->removeTimer(m_testTimer); m_testTimer = 0; } break; case GHOST_kKeyW: if (m_mainWindow) { STR_String title; m_mainWindow->getTitle(title); title += "-"; m_mainWindow->setTitle(title); } break; default: break; } } break; case GHOST_kEventWindowClose: { GHOST_IWindow* window2 = event->getWindow(); if (window2 == m_mainWindow) { m_exitRequested = true; } else { m_system->disposeWindow(window2); } } break; case GHOST_kEventWindowActivate: handled = false; break; case GHOST_kEventWindowDeactivate: handled = false; break; case GHOST_kEventWindowUpdate: { GHOST_IWindow* window2 = event->getWindow(); if(!m_system->validWindow(window2)) break; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); if(stereo) { View(window2, stereo, LEFT_EYE); glPushMatrix(); RenderCamera(); RenderScene(); glPopMatrix(); View(window2, stereo, RIGHT_EYE); glPushMatrix(); RenderCamera(); RenderScene(); glPopMatrix(); } else { View(window2, stereo); glPushMatrix(); RenderCamera(); RenderScene(); glPopMatrix(); } window2->swapBuffers(); } break; default: handled = false; break; } return handled; }
bool MapDraw::drawAnt(Creature* a, bool animate) { // top-right - white tm->nextTexture(1); // ant dead? if (a->getHP() <= 0) material( 15,10,10 ); else material(3,3,3); // exit early if not visible. if (! isVisible(a->getX(), a->getY())) return false; // find X/Y location by finding offset from center. // Then add the offset for smoothly moving between 2 squares. //TODO: Why do I need to add 1 to a->getX() ?!? float x = (positionX(a->getX()+1)*MODEL_SCALE) + (a->getOffsetX()*MODEL_SCALE_INCREMENT); float y = (positionY(a->getY())*MODEL_SCALE) + (a->getOffsetY()*MODEL_SCALE_INCREMENT); if (!animate) { StaticDraw::drawRect(x, y, MODEL_SCALE*0.2, MODEL_SCALE*.4, MODEL_SCALE*0.9, tm); return true; } // draw at x, y. // slightly off the background to get rid of overlaping. glPushMatrix(); // if X has no influence, facing right or left. // convert facing direction to measurement of 90 degrees ((-20:20) * 2.25). // (angle is -32768 to 32767) float xInfluence = ((a->getFacingX() * 2.25f)); // default facing up. float yInfluence = ((a->getFacingY() * 2.25f)); float rotation = 0; // this nonsense sets the ants rotation to face the direction its walking. // TODO: figure out how to convert this to glRotatef32i. // pointing top-left if (( a->getFacingX() <= 0 ) && (a->getFacingY() >= 0)) rotation = (-315) - (yInfluence+xInfluence); // pointing down-left else if (( a->getFacingX() <= 0 ) && (a->getFacingY() <= 0)) rotation = (-225) - (yInfluence-xInfluence); // pointing top-right else if (( a->getFacingX() > 0 ) && (a->getFacingY() >= 0)) rotation = (-45) + (yInfluence-xInfluence); // pointing down-right else if (( a->getFacingX() > 0 ) && (a->getFacingY() <= 0)) rotation = (-135) + (yInfluence+xInfluence); // translate to the center point. glTranslatef(x, y, 0.01); // rotate so the ant faces in the correct direction. glRotatef( rotation , 0, 0, 1); if (a->getType() == ANT_WORKER) drawWorker( a->getCarrying() ); else if (a->getType() == ANT_QUEEN) drawQueen( a->getCarrying() ); // queens don't carry anything, but whatev. glPopMatrix(1); return true; }
//////////////////////////////////////////////////////////////////////// /// /// @fn void Modele3D::appliquerMateriau( const aiMaterial* materiau ) /// /// Cette fonction applique un matériau 'assimp' à l'état OpenGL /// courant (puisque certains meshes peuvent en dépendre). Le code est /// chaotique; rassurons-nous cette fonction ne fait qu'effectuer /// des appels OpenGL selon l'état de la structure interne du matériau /// 'assimp' ainsi que quelques calculs. /// /// @param[in] materiau : matériau 'assimp' à appliquer /// /// @return Aucune. /// //////////////////////////////////////////////////////////////////////// void Modele3D::appliquerMateriau(const aiMaterial* materiau) { // Obtenir la texture du matériau int indexTexture = 0; aiString nomFichier = ""; glMatrixMode(GL_TEXTURE); glPushMatrix(); if (materiau->GetTexture(aiTextureType_DIFFUSE, indexTexture, &nomFichier) == AI_SUCCESS) { // Activer le texturage OpenGL et lier la texture appropriée glEnable ( GL_TEXTURE_2D); GLuint* idTexture = mapTextures_[nomFichier.data]; glScalef(1.0,-1.0,1.0); glBindTexture(GL_TEXTURE_2D, *idTexture); } else { // Désactiver le texturage OpenGL puisque cet objet n'a aucune texture glDisable ( GL_TEXTURE_2D); } glMatrixMode(GL_MODELVIEW); // Autres paramètres à appliquer... (couleurs) float c[4]; GLenum fill_mode; int ret1, ret2; struct aiColor4D diffuse; struct aiColor4D specular; struct aiColor4D ambient; struct aiColor4D emission; float shininess, strength; int two_sided; int wireframe; unsigned int max; // changé pour: unsigned assignerFloat4(c, 0.8f, 0.8f, 0.8f, 1.0f); //assignerFloat4(c, 1.0f, 1.0f, 1.0f, 1.0f); if (aiGetMaterialColor(materiau, AI_MATKEY_COLOR_DIFFUSE, &diffuse) == AI_SUCCESS) couleurVersFloat4(&diffuse, c); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, c); assignerFloat4(c, 0.0f, 0.0f, 0.0f, 1.0f); if(AI_SUCCESS == aiGetMaterialColor(materiau, AI_MATKEY_COLOR_SPECULAR, &specular)) couleurVersFloat4(&specular, c); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, c); assignerFloat4(c, 0.2f, 0.2f, 0.2f, 1.0f); if(AI_SUCCESS == aiGetMaterialColor(materiau, AI_MATKEY_COLOR_AMBIENT, &ambient)) couleurVersFloat4(&ambient, c); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, c); assignerFloat4(c, 0.0f, 0.0f, 0.0f, 1.0f); if(AI_SUCCESS == aiGetMaterialColor(materiau, AI_MATKEY_COLOR_EMISSIVE, &emission)) couleurVersFloat4(&emission, c); glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, c); max = 1; ret1 = aiGetMaterialFloatArray(materiau, AI_MATKEY_SHININESS, &shininess, &max); max = 1; ret2 = aiGetMaterialFloatArray(materiau, AI_MATKEY_SHININESS_STRENGTH, &strength, &max); if((ret1 == AI_SUCCESS) && (ret2 == AI_SUCCESS)) glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess * strength); else { glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 0.0f); assignerFloat4(c, 0.0f, 0.0f, 0.0f, 0.0f); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, c); } max = 1; if(AI_SUCCESS == aiGetMaterialIntegerArray(materiau, AI_MATKEY_ENABLE_WIREFRAME, &wireframe, &max)) fill_mode = wireframe ? GL_LINE : GL_FILL; else fill_mode = GL_FILL; glPolygonMode(GL_FRONT_AND_BACK, fill_mode); max = 1; if((AI_SUCCESS == aiGetMaterialIntegerArray(materiau, AI_MATKEY_TWOSIDED, &two_sided, &max)) && two_sided) glEnable(GL_CULL_FACE); else glDisable(GL_CULL_FACE); }
//////////////////////////////////////////////////////////////////////// /// /// @fn void Modele3D::dessinerNoeud( const aiScene* scene, /// const aiNode* noeud, /// bool avecTexture) /// /// Cette fonction dessine un noeud donné de la scène 'assimp'. Le /// rendu est récursif; cette fonction sera donc appelée en boucle pour /// les noeuds-enfants. /// /// Cette fonction procède également à l'application des matériaux, /// textures et des matrices OpenGL. /// /// @param[in] scene : objet scène 'assimp' /// @param[in] noeud : objet noeud 'assimp' /// @param[in] avecTexture : dit si la texture de l'objet doit etre dessinee /// /// @return Aucune. /// //////////////////////////////////////////////////////////////////////// void Modele3D::dessinerNoeud(const aiScene* scene, const aiNode* noeud, bool avecTexture) { // Matrice de transformation //aiMatrix4x4 m = noeud->mTransformation; //m.Scaling(aiVector3D(facteurAgrandissement_[VX],facteurAgrandissement_[VY],facteurAgrandissement_[VZ]), m); //m.Transpose(); glPushMatrix(); //glMultMatrixf((float*)&m); for (unsigned int i=0; i<noeud->mNumMeshes; i++) { const aiMesh* mesh = scene->mMeshes[noeud->mMeshes[i]]; // Appliquer le matériau pour le mesh courant if(avecTexture) { appliquerMateriau(scene->mMaterials[mesh->mMaterialIndex]); //glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, c); // Pas besoin de ce check /*if(mesh->mNormals == NULL) { glDisable(GL_LIGHTING); } else { //glEnable(GL_LIGHTING); }*/ if(mesh->mColors[0] != NULL) { glEnable(GL_COLOR_MATERIAL); } else { glDisable(GL_COLOR_MATERIAL); } } else { glDisable(GL_LIGHTING); glColor3f(0, 1, 0); //glEnable(GL_COLOR_LOGIC_OP); //glLogicOp(GL_XOR); } // Effectuer le rendu de chaque face for (unsigned int j=0; j<mesh->mNumFaces; j++) { const aiFace* face = &mesh->mFaces[j]; GLenum modeRendu; switch (face->mNumIndices) { case 1: modeRendu = GL_POINTS; break; case 2: modeRendu = GL_LINES; break; case 3: modeRendu = GL_TRIANGLES; break; default: modeRendu = GL_POLYGON; break; } // Effectuer le rendu de la face glBegin(modeRendu); for (unsigned int k=0; k<face->mNumIndices; k++) { int indexVertex = face->mIndices[k]; // get group index for current index // Le mesh possède-t-il une couleur ? if(mesh->mColors[0] != NULL) appliquerCouleur4f(&mesh->mColors[0][indexVertex]); // Normales pour applications des textures if(mesh->mNormals != NULL) { if(mesh->HasTextureCoords(0)) { glTexCoord2f(mesh->mTextureCoords[0][indexVertex].x, 1 - mesh->mTextureCoords[0][indexVertex].y); } else { //glDisable(GL_TEXTURE_2D); // Il faut la laisser commente sinon le shader ou qqch du genre crash } } glNormal3fv(&mesh->mNormals[indexVertex].x); glVertex3fv(&mesh->mVertices[indexVertex].x); } glEnd(); } if(avecTexture) { glMatrixMode(GL_TEXTURE); glPopMatrix(); } else { //glDisable(GL_COLOR_LOGIC_OP); } glMatrixMode(GL_MODELVIEW); } // Rendu récursif des enfants for (unsigned int i=0; i<noeud->mNumChildren; i++) { dessinerNoeud(scene, noeud->mChildren[i], avecTexture); } glPopMatrix(); }
static void draw_ico( void ) { GLuint list; list = glGenLists( 1 ); glNewList( list, GL_COMPILE ); TRIANGLE(1.5,seno,edgedivisions,(3*SQRT3+SQRT15)/12); glEndList(); glPushMatrix(); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[0]); glCallList(list); glPushMatrix(); glRotatef(180,0,0,1); glRotatef(-icoangle,1,0,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[1]); glCallList(list); glPushMatrix(); glRotatef(180,0,1,0); glRotatef(-180+icoangle,0.5,SQRT3/2,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[2]); glCallList(list); glPopMatrix(); glRotatef(180,0,1,0); glRotatef(-180+icoangle,0.5,-SQRT3/2,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[3]); glCallList(list); glPopMatrix(); glPushMatrix(); glRotatef(180,0,1,0); glRotatef(-180+icoangle,0.5,SQRT3/2,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[4]); glCallList(list); glPushMatrix(); glRotatef(180,0,1,0); glRotatef(-180+icoangle,0.5,SQRT3/2,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[5]); glCallList(list); glPopMatrix(); glRotatef(180,0,0,1); glRotatef(-icoangle,1,0,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[6]); glCallList(list); glPopMatrix(); glRotatef(180,0,1,0); glRotatef(-180+icoangle,0.5,-SQRT3/2,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[7]); glCallList(list); glPushMatrix(); glRotatef(180,0,1,0); glRotatef(-180+icoangle,0.5,-SQRT3/2,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[8]); glCallList(list); glPopMatrix(); glRotatef(180,0,0,1); glRotatef(-icoangle,1,0,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[9]); glCallList(list); glPopMatrix(); glRotatef(180,1,0,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[10]); glCallList(list); glPushMatrix(); glRotatef(180,0,0,1); glRotatef(-icoangle,1,0,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[11]); glCallList(list); glPushMatrix(); glRotatef(180,0,1,0); glRotatef(-180+icoangle,0.5,SQRT3/2,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[12]); glCallList(list); glPopMatrix(); glRotatef(180,0,1,0); glRotatef(-180+icoangle,0.5,-SQRT3/2,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[13]); glCallList(list); glPopMatrix(); glPushMatrix(); glRotatef(180,0,1,0); glRotatef(-180+icoangle,0.5,SQRT3/2,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[14]); glCallList(list); glPushMatrix(); glRotatef(180,0,1,0); glRotatef(-180+icoangle,0.5,SQRT3/2,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[15]); glCallList(list); glPopMatrix(); glRotatef(180,0,0,1); glRotatef(-icoangle,1,0,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[16]); glCallList(list); glPopMatrix(); glRotatef(180,0,1,0); glRotatef(-180+icoangle,0.5,-SQRT3/2,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[17]); glCallList(list); glPushMatrix(); glRotatef(180,0,1,0); glRotatef(-180+icoangle,0.5,-SQRT3/2,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[18]); glCallList(list); glPopMatrix(); glRotatef(180,0,0,1); glRotatef(-icoangle,1,0,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[19]); glCallList(list); glDeleteLists(list,1); }
static void draw_dodeca( void ) { GLuint list; #define TAU ((SQRT5+1)/2) list = glGenLists( 1 ); glNewList( list, GL_COMPILE ); PENTAGON(1,seno,edgedivisions,sqr(TAU) * sqrt((TAU+2)/5) / 2); glEndList(); glPushMatrix(); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[0]); glCallList(list); glRotatef(180,0,0,1); glPushMatrix(); glRotatef(-dodecaangle,1,0,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[1]); glCallList(list); glPopMatrix(); glPushMatrix(); glRotatef(-dodecaangle,cos72,sin72,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[2]); glCallList(list); glPopMatrix(); glPushMatrix(); glRotatef(-dodecaangle,cos72,-sin72,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[3]); glCallList(list); glPopMatrix(); glPushMatrix(); glRotatef(dodecaangle,cos36,-sin36,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[4]); glCallList(list); glPopMatrix(); glRotatef(dodecaangle,cos36,sin36,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[5]); glCallList(list); glPopMatrix(); glRotatef(180,1,0,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[6]); glCallList(list); glRotatef(180,0,0,1); glPushMatrix(); glRotatef(-dodecaangle,1,0,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[7]); glCallList(list); glPopMatrix(); glPushMatrix(); glRotatef(-dodecaangle,cos72,sin72,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[8]); glCallList(list); glPopMatrix(); glPushMatrix(); glRotatef(-dodecaangle,cos72,-sin72,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[9]); glCallList(list); glPopMatrix(); glPushMatrix(); glRotatef(dodecaangle,cos36,-sin36,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[10]); glCallList(list); glPopMatrix(); glRotatef(dodecaangle,cos36,sin36,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[11]); glCallList(list); glDeleteLists(list,1); }
void geode::frustum_draw(Matrix4 c, bool status) { getBounds(c); drawWireFrame(c, status); float m[16], p[16]; glGetFloatv(GL_PROJECTION_MATRIX, p); glGetFloatv(GL_MODELVIEW_MATRIX, m); glPushMatrix(); glLoadMatrixf(p); glMultMatrixf(m); glGetFloatv(GL_MODELVIEW_MATRIX, m); glPopMatrix(); Matrix4 m2w = Matrix4( m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7], m[8], m[9], m[10], m[11], m[12], m[13], m[14], m[15]); Vector4 NEARP = Vector4( m2w.get(2, 0) + m2w.get(3, 0), m2w.get(2, 1) + m2w.get(3, 1), m2w.get(2, 2) + m2w.get(3, 2), m2w.get(2, 3) + m2w.get(3, 3)); Vector4 FARP = Vector4( -m2w.get(2, 0) + m2w.get(3, 0), -m2w.get(2, 1) + m2w.get(3, 1), -m2w.get(2, 2) + m2w.get(3, 2), -m2w.get(2, 3) + m2w.get(3, 3)); Vector4 BOTTOM = Vector4( m2w.get(1, 0) + m2w.get(3, 0), m2w.get(1, 1) + m2w.get(3, 1), m2w.get(1, 2) + m2w.get(3, 2), m2w.get(1, 3) + m2w.get(3, 3)); Vector4 TOP = Vector4( -m2w.get(1, 0) + m2w.get(3, 0), -m2w.get(1, 1) + m2w.get(3, 1), -m2w.get(1, 2) + m2w.get(3, 2), -m2w.get(1, 3) + m2w.get(3, 3)); Vector4 LEFT = Vector4( m2w.get(0, 0) + m2w.get(3, 0), m2w.get(0, 1) + m2w.get(3, 1), m2w.get(0, 2) + m2w.get(3, 2), m2w.get(0, 3) + m2w.get(3, 3)); Vector4 RIGHT = Vector4( -m2w.get(0, 0) + m2w.get(3, 0), -m2w.get(0, 1) + m2w.get(3, 1), -m2w.get(0, 2) + m2w.get(3, 2), -m2w.get(0, 3) + m2w.get(3, 3)); NEARP.normalize(); FARP.normalize(); BOTTOM.normalize(); TOP.normalize(); LEFT.normalize(); RIGHT.normalize(); float distance; int count = 0; Vector4 bounding = { boundingBox.x, boundingBox.y, boundingBox.z, 1 }; bounding = m2w.multiply(bounding); bounding.normalize(); Vector4 plane[6] = { NEARP, FARP, BOTTOM, TOP, LEFT, RIGHT }; for (int i = 0; i < 6; i++) { distance = plane[i][0] * bounding.x + plane[i][1] * bounding.y + plane[i][2] * bounding.z + plane[i][3]; if (distance < -radius) { break; } else { count++; } } if (count == 6) { render(c); } }
/** * draw() * * Draw to the screen. */ void draw() { //set background color to black glClearColor(0.0, 0.0, 0.0, 0.0); //clear info from last draw glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //switch to the drawing perspective glMatrixMode(GL_MODELVIEW); glLoadIdentity(); //rotate and translate the scene to simulate camera movement glRotatef(camera_pitch, 1.0, 0.0, 0.0); glRotatef(camera_yaw, 0.0, 1.0, 0.0); glRotatef(camera_roll, 0.0, 0.0, 1.0); glTranslatef(camera_x, camera_y, camera_z); //initiate camera position and angle gluLookAt (0.0, 5.0, -35.0, //camera position 0.0, 5.0, 0.0, //look-at point 0.0, 1.0, 0.0); //up direction //draw light #1 and its light stand object if (draw_light1) { //turn on light #1 glEnable(GL_LIGHT0); //draw light #1 effect GLfloat diff_light[] = {light1_red, light1_green, light1_blue, 1.0}; GLfloat l_position[] = {light1_x, 1 + light1_height + 2*sinf(PI/18), light1_z, 1.0f}; glLightfv (GL_LIGHT0, GL_DIFFUSE, diff_light); glLightfv (GL_LIGHT0, GL_POSITION, l_position); //draw light #1 stand base and head glPushMatrix(); light_position(light1_x, light1_z); light_angle(light1_x, light1_z); glCallList(light_base_id); glPushMatrix(); glTranslatef(0.0, light1_height, 0.0); glCallList(light_head_id); glPopMatrix(); glPopMatrix(); //light #1 stand pole glPushMatrix(); light_position(light1_x, light1_z); glTranslatef(0.0f, light1_height + 2*sinf(PI/18), 0.0); glRotatef(90.0f, 1.0f, 0.0f, 0.0f); glColor3f(0.2, 0.2, 0.2); GLUquadricObj * light_stand; light_stand = gluNewQuadric(); gluQuadricDrawStyle(light_stand, GLU_FILL); gluCylinder(light_stand, 0.05f, 0.05f, light1_height, 8, 8); glEnd(); glPopMatrix(); } //draw light #2 and its light stand object if (draw_light2) { //turn on light #2 glEnable(GL_LIGHT1); //draw light #2 effect GLfloat diff_light[] = {light2_red, light2_green, light2_blue, 1.0}; GLfloat l_position[] = {light2_x, 1 + light2_height + 2*sinf(PI/18), light2_z, 1.0f}; glLightfv (GL_LIGHT1, GL_DIFFUSE, diff_light); glLightfv (GL_LIGHT1, GL_POSITION, l_position); //draw light #2 stand base and head glPushMatrix(); light_position(light2_x, light2_z); light_angle(light2_x, light2_z); glCallList(light_base_id); glPushMatrix(); glTranslatef(0.0, light2_height, 0.0); glCallList(light_head_id); glPopMatrix(); glPopMatrix(); //light #2 stand pole glPushMatrix(); light_position(light2_x, light2_z); glTranslatef(0.0f, light2_height + 2*sinf(PI/18), 0.0); glRotatef(90.0f, 1.0f, 0.0f, 0.0f); glColor3f(0.2, 0.2, 0.2); GLUquadricObj * light_stand; light_stand = gluNewQuadric(); gluQuadricDrawStyle(light_stand, GLU_FILL); gluCylinder(light_stand, 0.05f, 0.05f, light2_height, 8, 8); glEnd(); glPopMatrix(); } //draw light #3 and its light stand object if (draw_light3) { //turn on light #3 glEnable(GL_LIGHT2); //draw light #3 effect GLfloat diff_light[] = {light3_red, light3_green, light3_blue, 1.0}; GLfloat l_position[] = {light3_x, 6.0 + 2*sinf(PI/18), light3_z, 1.0f}; glLightfv (GL_LIGHT2, GL_DIFFUSE, diff_light); glLightfv (GL_LIGHT2, GL_POSITION, l_position); //draw light #3 stand base and head glPushMatrix(); light_position(light3_x, light3_z); light_angle(light3_x, light3_z); glCallList(light_base_id); glPushMatrix(); glTranslatef(0.0, light3_height, 0.0); glCallList(light_head_id); glPopMatrix(); glPopMatrix(); //light #3 stand pole glPushMatrix(); light_position(light3_x, light3_z); glTranslatef(0.0f, light3_height + 2*sinf(PI/18), 0.0); glRotatef(90.0f, 1.0f, 0.0f, 0.0f); glColor3f(0.2, 0.2, 0.2); GLUquadricObj * light_stand; light_stand = gluNewQuadric(); gluQuadricDrawStyle(light_stand, GLU_FILL); gluCylinder(light_stand, 0.05f, 0.05f, light3_height, 8, 8); glEnd(); glPopMatrix(); } //draw the grid lines if (draw_grid) { glBegin (GL_LINES); glColor3f(0.5f, 0.5f, 0.5f); for (int i = -10; i <= 10; ++i) { //floor glVertex3f(i, 0, -10); glVertex3f(i, 0, 10); glVertex3f(10, 0, i); glVertex3f(-10, 0, i); //back wall glVertex3f(i, 0, 10); glVertex3f(i, 10, 10); //left wall glVertex3f(10, 0, i); glVertex3f(10, 10, i); //right wall glVertex3f(-10, 0, i); glVertex3f(-10, 10, i); } for (int i = 0; i <= 10; ++i) { //back wall glVertex3f(10, i, 10); glVertex3f(-10, i, 10); //left wall glVertex3f(10, i, -10); glVertex3f(10, i, 10); //right wall glVertex3f(-10, i, -10); glVertex3f(-10, i, 10); } glEnd(); //GL_LINES for grid } //DRAW PERSON 1 (GREEN) if (draw_person1) { glPushMatrix(); //set the postition and orientation of person 1 glTranslatef(person1_x, 0.0f, person1_z); glRotatef(person1_xrot, 1.0f, 0.0f, 0.0f); glRotatef(person1_zrot, 0.0f, 0.0f, 1.0f); glRotatef(person1_yrot, 0.0f, 1.0f, 0.0f); glScalef(0.7f, 0.7f, 0.55f); //head for person 1 glPushMatrix(); glColor3f(1.0f, .9f, .6f); glCallList(head_list_id); //call the head display list glPopMatrix(); //body for person 1 glPushMatrix(); glColor3f(0.0f, 0.8f, 0.0f); glCallList(body_list_id); //call the body display list glPopMatrix(); glPopMatrix(); } //DRAW PERSON 2 (RED) if (draw_person2) { glPushMatrix(); //set the postition and orientation of person 2 glTranslatef(person2_x, 0.0f, person2_z); glRotatef(person2_xrot, 1.0f, 0.0f, 0.0f); glRotatef(person2_zrot, 0.0f, 0.0f, 1.0f); glRotatef(person2_yrot, 0.0f, 1.0f, 0.0f); glScalef(0.8f, 0.8f, 0.65f); //head for person 2 glPushMatrix(); glColor3f(0.9f, 0.7f, 0.6f); glCallList(head_list_id); glPopMatrix(); //body for person 2 glPushMatrix(); glColor3f(0.7f, 0.0f, 0.1f); glCallList(body_list_id); glPopMatrix(); glPopMatrix(); } //DRAW PERSON 3 (BLUE) if (draw_person3) { glPushMatrix(); //set the postition and orientation of person 3 glTranslatef(person3_x, 0.0f, person3_z); glRotatef(person3_xrot, 1.0f, 0.0f, 0.0f); glRotatef(person3_zrot, 0.0f, 0.0f, 1.0f); glRotatef(person3_yrot, 0.0f, 1.0f, 0.0f); glScalef(0.7f, 0.65f, 0.6f); //head for person 3 glPushMatrix(); glColor3f(0.9f, 0.9f, 0.8f); glCallList(head_list_id); glPopMatrix(); //body for person 3 glPushMatrix(); glColor3f(0.1f, 0.0f, 0.9f); glCallList(body_list_id); glPopMatrix(); glPopMatrix(); } //DRAW PERSON 4 (YELLOW) if (draw_person4) { glPushMatrix(); //set the postition and orientation of person 4 glTranslatef(person4_x, 0.0f, person4_z); glRotatef(person4_xrot, 1.0f, 0.0f, 0.0f); glRotatef(person4_zrot, 0.0f, 0.0f, 1.0f); glRotatef(person4_yrot, 0.0f, 1.0f, 0.0f); glScalef(0.75f, 0.85f, 0.65f); //head for person 4 glPushMatrix(); glColor3f(0.5f, 0.5f, 0.2f); glCallList(head_list_id); glPopMatrix(); //body for person 4 glPushMatrix(); glColor3f(0.9f, 0.9f, 0.0f); glCallList(body_list_id); glPopMatrix(); glPopMatrix(); } //swap the current window with the buffered window glutSwapBuffers(); }
void draw(HyperspaceSaverSettings *inSettings){ if(inSettings->first){ if(inSettings->dUseTunnels){ // only tunnels use caustic textures glDisable(GL_FOG); // Caustic textures can only be created after rendering context has been created // because they have to be drawn and then read back from the framebuffer. #ifdef WIN32 if(doingPreview) // super fast for Windows previewer inSettings->theCausticTextures = new causticTextures(8, inSettings->numAnimTexFrames, 32, 32, 1.0f, 0.01f, 10.0f); else // normal #endif inSettings->theCausticTextures = new causticTextures(8, inSettings->numAnimTexFrames, 100, 256, 1.0f, 0.01f, 20.0f); glEnable(GL_FOG); } if(inSettings->dShaders){ #ifdef WIN32 if(doingPreview) // super fast for Windows previewer inSettings->theWNCM = new wavyNormalCubeMaps(inSettings->numAnimTexFrames, 32); else // normal #endif inSettings->theWNCM = new wavyNormalCubeMaps(inSettings->numAnimTexFrames, 128); } glViewport(inSettings->viewport[0], inSettings->viewport[1], inSettings->viewport[2], inSettings->viewport[3]); inSettings->first = 0; } // Variables for printing text static float computeTime = 0.0f; static float drawTime = 0.0f; //static rsTimer computeTimer, drawTimer; // start compute time timer //computeTimer.tick(); glMatrixMode(GL_MODELVIEW); // Camera movements static float camHeading[3] = {0.0f, 0.0f, 0.0f}; // current, target, and last static int changeCamHeading = 1; static float camHeadingChangeTime[2] = {20.0f, 0.0f}; // total, elapsed static float camRoll[3] = {0.0f, 0.0f, 0.0f}; // current, target, and last static int changeCamRoll = 1; static float camRollChangeTime[2] = {1.0f, 0.0f}; // total, elapsed camHeadingChangeTime[1] += inSettings->frameTime; if(camHeadingChangeTime[1] >= camHeadingChangeTime[0]){ // Choose new direction camHeadingChangeTime[0] = rsRandf(15.0f) + 5.0f; camHeadingChangeTime[1] = 0.0f; camHeading[2] = camHeading[1]; // last = target if(changeCamHeading){ // face forward most of the time if(rsRandi(6)) camHeading[1] = 0.0f; // face backward the rest of the time else if(rsRandi(2)) camHeading[1] = RS_PI; else camHeading[1] = -RS_PI; changeCamHeading = 0; } else changeCamHeading = 1; } float t = camHeadingChangeTime[1] / camHeadingChangeTime[0]; t = 0.5f * (1.0f - cosf(RS_PI * t)); camHeading[0] = camHeading[1] * t + camHeading[2] * (1.0f - t); camRollChangeTime[1] += inSettings->frameTime; if(camRollChangeTime[1] >= camRollChangeTime[0]){ // Choose new roll angle camRollChangeTime[0] = rsRandf(5.0f) + 10.0f; camRollChangeTime[1] = 0.0f; camRoll[2] = camRoll[1]; // last = target if(changeCamRoll){ camRoll[1] = rsRandf(RS_PIx2*2) - RS_PIx2; changeCamRoll = 0; } else changeCamRoll = 1; } t = camRollChangeTime[1] / camRollChangeTime[0]; t = 0.5f * (1.0f - cosf(RS_PI * t)); camRoll[0] = camRoll[1] * t + camRoll[2] * (1.0f - t); static float pathDir[3] = {0.0f, 0.0f, -1.0f}; inSettings->thePath->moveAlongPath(float(inSettings->dSpeed) * inSettings->frameTime * 0.04f); inSettings->thePath->update(inSettings->frameTime); inSettings->thePath->getPoint(inSettings->dDepth + 2, inSettings->thePath->step, inSettings->camPos); inSettings->thePath->getBaseDirection(inSettings->dDepth + 2, inSettings->thePath->step, pathDir); float pathAngle = atan2f(-pathDir[0], -pathDir[2]); glLoadIdentity(); glRotatef((pathAngle + camHeading[0]) * RS_RAD2DEG, 0, 1, 0); glRotatef(camRoll[0] * RS_RAD2DEG, 0, 0, 1); glGetFloatv(GL_MODELVIEW_MATRIX, inSettings->billboardMat); glLoadIdentity(); glRotatef(-camRoll[0] * RS_RAD2DEG, 0, 0, 1); glRotatef((-pathAngle - camHeading[0]) * RS_RAD2DEG, 0, 1, 0); glTranslatef(inSettings->camPos[0]*-1, inSettings->camPos[1]*-1, inSettings->camPos[2]*-1); glGetDoublev(GL_MODELVIEW_MATRIX, inSettings->modelMat); inSettings->unroll = camRoll[0] * RS_RAD2DEG; if(inSettings->dUseGoo){ // calculate diagonal fov float diagFov = 0.5f * float(inSettings->dFov) / RS_RAD2DEG; diagFov = tanf(diagFov); diagFov = sqrtf(diagFov * diagFov + (diagFov * inSettings->aspectRatio * diagFov * inSettings->aspectRatio)); diagFov = 2.0f * atanf(diagFov); inSettings->theGoo->update(inSettings->camPos[0], inSettings->camPos[2], pathAngle + camHeading[0], diagFov, inSettings); } // measure compute time //computeTime += computeTimer.tick(); // start draw time timer //drawTimer.tick(); // clear glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); // draw stars glCullFace(GL_BACK); glEnable(GL_CULL_FACE); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glBlendFunc(GL_SRC_ALPHA, GL_ONE); glEnable(GL_BLEND); glEnable(GL_TEXTURE_2D); glActiveTextureARB(GL_TEXTURE2_ARB); glBindTexture(GL_TEXTURE_2D, NULL); glActiveTextureARB(GL_TEXTURE1_ARB); glBindTexture(GL_TEXTURE_2D, NULL); glActiveTextureARB(GL_TEXTURE0_ARB); glBindTexture(GL_TEXTURE_2D, inSettings->flaretex[0]); static float temppos[2]; for(int i=0; i<inSettings->dStars; i++){ temppos[0] = inSettings->stars[i]->pos[0] - inSettings->camPos[0]; temppos[1] = inSettings->stars[i]->pos[2] - inSettings->camPos[2]; if(temppos[0] > inSettings->depth){ inSettings->stars[i]->pos[0] -= inSettings->depth * 2.0f; inSettings->stars[i]->lastPos[0] -= inSettings->depth * 2.0f; } if(temppos[0] < inSettings->depth*-1){ inSettings->stars[i]->pos[0] += inSettings->depth * 2.0f; inSettings->stars[i]->lastPos[0] += inSettings->depth * 2.0f; } if(temppos[1] > inSettings->depth){ inSettings->stars[i]->pos[2] -= inSettings->depth * 2.0f; inSettings->stars[i]->lastPos[2] -= inSettings->depth * 2.0f; } if(temppos[1] < inSettings->depth*-1){ inSettings->stars[i]->pos[2] += inSettings->depth * 2.0f; inSettings->stars[i]->lastPos[2] += inSettings->depth * 2.0f; } inSettings->stars[i]->draw(inSettings->camPos, inSettings->unroll, inSettings->modelMat, inSettings->projMat, inSettings->viewport); } glDisable(GL_CULL_FACE); // pick animated texture frame static float textureTime = 0.0f; textureTime += inSettings->frameTime; // loop frames every 2 seconds const float texFrameTime(2.0f / float(inSettings->numAnimTexFrames)); while(textureTime > texFrameTime){ textureTime -= texFrameTime; inSettings->whichTexture ++; } while(inSettings->whichTexture >= inSettings->numAnimTexFrames) inSettings->whichTexture -= inSettings->numAnimTexFrames; // alpha component gets normalmap lerp value const float lerp = textureTime / texFrameTime; // draw goo if(inSettings->dUseGoo){ // calculate color static float goo_rgb_phase[3] = {-0.1f, -0.1f, -0.1f}; static float goo_rgb_speed[3] = {rsRandf(0.02f) + 0.02f, rsRandf(0.02f) + 0.02f, rsRandf(0.02f) + 0.02f}; float goo_rgb[4]; for(int i=0; i<3; i++){ goo_rgb_phase[i] += goo_rgb_speed[i] * inSettings->frameTime; if(goo_rgb_phase[i] >= RS_PIx2) goo_rgb_phase[i] -= RS_PIx2; goo_rgb[i] = sinf(goo_rgb_phase[i]); if(goo_rgb[i] < 0.0f) goo_rgb[i] = 0.0f; } // setup textures if(inSettings->dShaders){ goo_rgb[3] = lerp; glDisable(GL_TEXTURE_2D); glEnable(GL_TEXTURE_CUBE_MAP_ARB); glActiveTextureARB(GL_TEXTURE2_ARB); glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, inSettings->nebulatex); glActiveTextureARB(GL_TEXTURE1_ARB); glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, inSettings->theWNCM->texture[(inSettings->whichTexture + 1) % inSettings->numAnimTexFrames]); glActiveTextureARB(GL_TEXTURE0_ARB); glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, inSettings->theWNCM->texture[inSettings->whichTexture]); glUseProgramObjectARB(gooProgram); } else{ goo_rgb[3] = 1.0f; glBindTexture(GL_TEXTURE_2D, inSettings->nebulatex); glEnable(GL_TEXTURE_2D); glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); } // draw it glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glBlendFunc(GL_SRC_ALPHA, GL_ONE); glEnable(GL_BLEND); glColor4fv(goo_rgb); inSettings->theGoo->draw(); if(inSettings->dShaders){ glDisable(GL_TEXTURE_CUBE_MAP_ARB); glUseProgramObjectARB(0); } else{ glDisable(GL_TEXTURE_GEN_S); glDisable(GL_TEXTURE_GEN_T); } } // update starburst static float starBurstTime = 300.0f; // burst after 5 minutes starBurstTime -= inSettings->frameTime; if(starBurstTime <= 0.0f){ float pos[] = {inSettings->camPos[0] + (pathDir[0] * inSettings->depth * (0.5f + rsRandf(0.5f))), rsRandf(2.0f) - 1.0f, inSettings->camPos[2] + (pathDir[2] * inSettings->depth * (0.5f + rsRandf(0.5f)))}; inSettings->theStarBurst->restart(pos); // it won't actually restart unless it's ready to starBurstTime = rsRandf(240.0f) + 60.0f; // burst again within 1-5 minutes } if(inSettings->dShaders) inSettings->theStarBurst->draw(lerp, inSettings); else inSettings->theStarBurst->draw(inSettings); // draw tunnel if(inSettings->dUseTunnels){ inSettings->theTunnel->make(inSettings->frameTime, inSettings->dShaders); glCullFace(GL_BACK); glEnable(GL_CULL_FACE); glEnable(GL_TEXTURE_2D); if(inSettings->dShaders){ glActiveTextureARB(GL_TEXTURE1_ARB); glBindTexture(GL_TEXTURE_2D, inSettings->theCausticTextures->caustictex[(inSettings->whichTexture + 1) % inSettings->numAnimTexFrames]); glActiveTextureARB(GL_TEXTURE0_ARB); glBindTexture(GL_TEXTURE_2D, inSettings->theCausticTextures->caustictex[inSettings->whichTexture]); glUseProgramObjectARB(tunnelProgram); inSettings->theTunnel->draw(lerp); glUseProgramObjectARB(0); } else{ glBindTexture(GL_TEXTURE_2D, inSettings->theCausticTextures->caustictex[inSettings->whichTexture]); inSettings->theTunnel->draw(); } glDisable(GL_CULL_FACE); } // draw sun with lens flare glDisable(GL_FOG); float flarepos[3] = {0.0f, 2.0f, 0.0f}; glBindTexture(GL_TEXTURE_2D, inSettings->flaretex[0]); inSettings->sunStar->draw(inSettings->camPos, inSettings->unroll, inSettings->modelMat, inSettings->projMat, inSettings->viewport); float diff[3] = {flarepos[0] - inSettings->camPos[0], flarepos[1] - inSettings->camPos[1], flarepos[2] - inSettings->camPos[2]}; float alpha = 0.5f - 0.005f * sqrtf(diff[0] * diff[0] + diff[1] * diff[1] + diff[2] * diff[2]); if(alpha > 0.0f) flare(flarepos, 1.0f, 1.0f, 1.0f, alpha, inSettings); glEnable(GL_FOG); // measure draw time //drawTime += drawTimer.tick(); // write text static float totalTime = 0.0f; totalTime += inSettings->frameTime; static std::vector<std::string> strvec; static int frames = 0; ++frames; if(frames == 60){ strvec.clear(); std::string str1 = " FPS = " + to_string(60.0f / totalTime); strvec.push_back(str1); std::string str2 = "compute time = " + to_string(computeTime / 60.0f); strvec.push_back(str2); std::string str3 = " draw time = " + to_string(drawTime / 60.0f); strvec.push_back(str3); totalTime = 0.0f; computeTime = 0.0f; drawTime = 0.0f; frames = 0; } if(inSettings->kStatistics){ glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glOrtho(0.0f, 50.0f * inSettings->aspectRatio, 0.0f, 50.0f, -1.0f, 1.0f); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); glTranslatef(1.0f, 48.0f, 0.0f); glColor3f(1.0f, 0.6f, 0.0f); inSettings->textwriter->draw(strvec); glPopMatrix(); glMatrixMode(GL_PROJECTION); glPopMatrix(); } #ifdef WIN32 wglSwapLayerBuffers(hdc, WGL_SWAP_MAIN_PLANE); #endif #ifdef RS_XSCREENSAVER glXSwapBuffers(xdisplay, xwindow); #endif }
/** * body() * * Creates a display list for the body of a person. */ void body() { GLfloat fan_angle; //angle for a triangle fan int sections = 40; //number of triangles in a triangle fan //generate a display list for a body body_list_id = glGenLists(1); //compile the new display list glNewList(body_list_id, GL_COMPILE); glPushMatrix(); glTranslatef(0.0f, 5.05f, 0.0f); glRotatef(90, 1.0, 0.0, 0.0); //create a torso with a cylinder glPushMatrix(); GLUquadricObj * torso; torso = gluNewQuadric(); gluQuadricDrawStyle(torso, GLU_FILL); gluCylinder(torso, 1.0f, 1.0f, 2.25f, 25, 25); glPopMatrix(); //triangle fan for top of body glPushMatrix(); glRotatef(180.0, 0.0, 1.0, 0.0); glBegin(GL_TRIANGLE_FAN); glNormal3f(0.0f, 0.0f, 1.0f); glVertex3f(0.0f, 0.0f, 0.0f); for(int i = 0; i <= sections; ++i) { fan_angle = (GLfloat) i * 2 * PI / sections; glVertex3f(cosf(fan_angle), sinf(fan_angle), 0.0f); } glEnd(); glPopMatrix(); //triangle fan for bottom of torso glPushMatrix(); glTranslatef(0.0, 0.0, 2.25); glBegin(GL_TRIANGLE_FAN); glNormal3f(0.0f, 0.0f, 1.0f); glVertex3f(0.0f, 0.0f, 0.0f); for(int i = 0; i <= sections; ++i) { fan_angle = (GLfloat) i * 2 * PI / sections; glVertex3f(cosf(fan_angle), sinf(fan_angle), 0.0f); } glEnd(); glPopMatrix(); //arm 1 glPushMatrix(); glTranslatef(1.25f, 0.0f, 0.0f); GLUquadricObj * arm1; arm1 = gluNewQuadric(); gluQuadricDrawStyle(arm1, GLU_FILL); gluCylinder(arm1, 0.25f, 0.25f, 2.5f, 12, 12); glPopMatrix(); //triangle fan for top of arm 1 glPushMatrix(); glTranslatef(1.25, 0.0, 0.0); glRotatef(180.0, 0.0, 1.0, 0.0); glBegin(GL_TRIANGLE_FAN); glNormal3f(0.0f, 0.0f, 1.0f); glVertex3f(0.0f, 0.0f, 0.0f); sections = 12; for(int i = 0; i <= sections; ++i) { fan_angle = (GLfloat) i * 2 * PI / sections; glVertex3f(0.25*cosf(fan_angle), 0.25*sinf(fan_angle), 0.0f); } glEnd(); glPopMatrix(); //triangle fan for bottom of arm 1 glPushMatrix(); glTranslatef(1.25, 0.0, 2.5); glBegin(GL_TRIANGLE_FAN); glNormal3f(0.0f, 0.0f, 1.0f); glVertex3f(0.0f, 0.0f, 0.0f); sections = 12; for(int i = 0; i <= sections; ++i) { fan_angle = (GLfloat) i * 2 * PI / sections; glVertex3f(0.25*cosf(fan_angle), 0.25*sinf(fan_angle), 0.0f); } glEnd(); glPopMatrix(); //arm 2 glPushMatrix(); glTranslatef(-1.25f, 0.0f, 0.0f); GLUquadricObj * arm2; arm2 = gluNewQuadric(); gluQuadricDrawStyle(arm2, GLU_FILL); gluCylinder(arm2, 0.25f, 0.25f, 2.5f, 12, 12); glPopMatrix(); //triangle fan for top of arm 2 glPushMatrix(); glTranslatef(-1.25, 0.0, 0.0); glRotatef(180.0, 0.0, 1.0, 0.0); glBegin(GL_TRIANGLE_FAN); glNormal3f(0.0f, 0.0f, 1.0f); glVertex3f(0.0f, 0.0f, 0.0f); sections = 12; for(int i = 0; i <= sections; ++i) { fan_angle = (GLfloat) i * 2 * PI / sections; glVertex3f(0.25*cosf(fan_angle), 0.25*sinf(fan_angle), 0.0f); } glEnd(); glPopMatrix(); //triangle fan for bottom of arm 2 glPushMatrix(); glTranslatef(-1.25, 0.0, 2.5); glBegin(GL_TRIANGLE_FAN); glNormal3f(0.0f, 0.0f, 1.0f); glVertex3f(0.0f, 0.0f, 0.0f); sections = 12; for(int i = 0; i <= sections; ++i) { fan_angle = (GLfloat) i * 2 * PI / sections; glVertex3f(0.25*cosf(fan_angle), 0.25*sinf(fan_angle), 0.0f); } glEnd(); glPopMatrix(); //leg 1 glPushMatrix(); glTranslatef(0.5f, 0.0f, 2.25f); GLUquadricObj * leg1; leg1 = gluNewQuadric(); gluQuadricDrawStyle(leg1, GLU_FILL); gluCylinder(leg1, 0.5f, 0.2f, 2.8f, 12, 12); glPopMatrix(); //triangle fan for bottom of leg 1 glPushMatrix(); glTranslatef(0.5, 0.0, 5.05); glBegin(GL_TRIANGLE_FAN); glNormal3f(0.0f, 0.0f, 1.0f); glVertex3f(0.0f, 0.0f, 0.0f); sections = 12; for(int i = 0; i <= sections; ++i) { fan_angle = (GLfloat) i * 2 * PI / sections; glVertex3f(0.2*cosf(fan_angle), 0.2*sinf(fan_angle), 0.0f); } glEnd(); glPopMatrix(); //leg 2 glPushMatrix(); glTranslatef(-0.5f, 0.0f, 2.25f); GLUquadricObj * leg2; leg2 = gluNewQuadric(); gluQuadricDrawStyle(leg2, GLU_FILL); gluCylinder(leg2, 0.5f, 0.2f, 2.8f, 12, 12); glPopMatrix(); //triangle fan for bottom of leg 2 glPushMatrix(); glTranslatef(-0.5, 0.0, 5.05); glBegin(GL_TRIANGLE_FAN); glNormal3f(0.0f, 0.0f, 1.0f); glVertex3f(0.0f, 0.0f, 0.0f); sections = 12; for(int i = 0; i <= sections; ++i) { fan_angle = (GLfloat) i * 2 * PI / sections; glVertex3f(0.2*cosf(fan_angle), 0.2*sinf(fan_angle), 0.0f); } glEnd(); glPopMatrix(); glPopMatrix(); glEndList(); }
void draw_scene() { static float ang_self = 0.0; /*Define the angle of self-rotate */ static float angle = 0.0; glLightfv(GL_LIGHT4, GL_POSITION, lit4_position); glLightfv(GL_LIGHT4, GL_SPOT_DIRECTION, lit4_direction); glLightfv(GL_LIGHT5, GL_POSITION, lit5_position); glLightfv(GL_LIGHT5, GL_SPOT_DIRECTION, lit5_direction); glLightfv(GL_LIGHT1, GL_POSITION, lit1_position); /*fixed position---*/ glDisable(GL_TEXTURE_2D); draw_floor(); glMatrixMode(GL_TEXTURE); glLoadIdentity(); glTranslatef(0.0, 0.0, 0.0); glMatrixMode(GL_MODELVIEW); draw_slope(); draw_axes(); draw_object(); /*-------Draw the billboard ----*/ glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glBindTexture(GL_TEXTURE_2D, textName[2]); glEnable(GL_TEXTURE_2D); draw_billboard(5.0*4.0, -3.0*4.0, 5.0, 8.0); draw_billboard(6.0*4.0, -5.0*4.0, 5.0, 8.0); draw_billboard(3.0*4.0, -6.0*4.0, 5.0, 8.0); draw_billboard(2.0*4.0, -7.0*4.0, 5.0, 8.0); draw_billboard(7.0*4.0, -2.0*4.0, 5.0, 8.0); glDisable(GL_TEXTURE_2D); /*-------Draw the car body which is a cube----*/ glTranslatef(position[0], position[1], position[2]); glRotatef(-up_ang, 1.0, 0.0, 0.0); glRotatef(self_ang, 0.0, 1.0, 0.0); glPushMatrix(); /* Save M1 coord. sys */ draw_cube(); glPopMatrix(); /* Get M1 back */ /*-------Draw the front wheels -----*/ glColor3f(1.0, 0.0, 0.0); glPushMatrix(); /* Save M1 coord. sys */ glTranslatef(-4.0, 0.0, 3.0); /* Go to left wheel position */ glutSolidTorus(0.5, /* inner radius */ 1.0, /* outer radius */ 24, /* divided into 18 segments */ 12); /* 12 rings */ glPopMatrix(); glPushMatrix(); /* Save M1 coord. sys */ glTranslatef(-4.0, 0.0, -3.0);/* Go to right wheel position */ glutSolidTorus(0.5, /* inner radius */ 1.0, /* outer radius */ 24, /* divided into 18 segments */ 12); /* 12 rings */ glPopMatrix(); /*------Draw back wheels ----*/ glColor3f(1.0, 0.4, 0.0); glPushMatrix(); /* Save M1 coord. sys */ glTranslatef(6.0, 0.0, 0.0); /* Go to left wheel position */ glutSolidTorus(0.5, /* inner radius */ 1.0, /* outer radius */ 24, /* divided into 18 segments */ 12); /* 12 rings */ glPopMatrix(); glColor3f(1.0, 0.4, 0.4); glPushMatrix(); /* Save M1 coord. sys */ glTranslatef(0.0, 1.5, 7.5); /* Go to left wheel position */ glRotatef(-90.0, 1.0, 0.0, 0.0); glutSolidTorus(0.5, /* inner radius */ 3.0, /* outer radius */ 24, /* divided into 18 segments */ 12); /* 12 rings */ glPopMatrix(); glColor3f(1.0, 0.4, 0.4); glPushMatrix(); /* Save M1 coord. sys */ glTranslatef(0.0, 1.5, -7.5); /* Go to left wheel position */ glRotatef(-90.0, 1.0, 0.0, 0.0); glutSolidTorus(0.5, /* inner radius */ 3.0, /* outer radius */ 24, /* divided into 18 segments */ 12); /* 12 rings */ glPopMatrix(); glColor3f(1.0, 1.0, 1.0); glPushMatrix(); glTranslatef(0.0, 1.5, 7.5); glRotatef(bld_ang, 0.0, 1.0, 0.0); draw_blade();/* draw the first blade */ glRotatef(120, 0.0, 1.0, 0.0); draw_blade();/* draw the first blade */ glRotatef(120, 0.0, 1.0, 0.0); draw_blade();/* draw the first blade */ glPopMatrix(); glColor3f(1.0, 1.0, 1.0); glPushMatrix(); glTranslatef(0.0, 1.5, -7.5); glRotatef(bld_ang, 0.0, 1.0, 0.0); draw_blade(); glRotatef(120, 0.0, 1.0, 0.0); draw_blade(); glRotatef(120, 0.0, 1.0, 0.0); draw_blade(); glPopMatrix(); }
void Display(void) { // バッファのクリア glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); // カラーバッファとZバッファの消去 (ステンシルバッファ使うときは、別途(GL_STENCIL_BUFFER_BIT)指定する必要あり) // 座標変換 (ワールド変換 -> ビュー座標変換(カメラ) -> 射影変換 -> クリッピング) // NOTE : なぜか 通常の順序とは逆に、Viewport変換 -> 射影変換 -> モデルビュー変換の順に設定する. // OpenGL的には、カレント変換行列の生成を行っているが、逆からかけていくことによって作られたカレント行列に、モデル行列をかけるだけで、描画位置が決まるようになる. glViewport(0, 0, WindowWidth, WindowHeight); // 射影変換の際に必要な情報 glMatrixMode(GL_PROJECTION); //行列モードの設定(GL_PROJECTION : 透視変換行列の設定、GL_MODELVIEW:モデルビュー変換行列) glLoadIdentity(); // カレント行列の初期化 gluPerspective(30.0, (double)WindowWidth/(double)WindowHeight, 0.1, 1000.0); // 透視投影の視体積 // ビュー変換に必要な情報 (毎loopでカメラを動かしているイメージ) ViewPointY += ( -50.0 - ViewPointY) * 0.001; gluLookAt( 0.0, ViewPointY , ViewPointZ, // 視点の位置x,y,z; 0.0, ViewPointY+200 , 0.0, // 視界の中心位置の参照点座標x,y,z 0.0, 0.0, 1.0 ); //視界の上方向のベクトルx,y,z //モデルビュー変換行列の設定-------------------------- glMatrixMode(GL_MODELVIEW);//行列モードの設定(GL_PROJECTION : 透視変換行列の設定、GL_MODELVIEW:モデルビュー変換行列) glLoadIdentity();//行列の初期化 // 陰影ON--------------------- glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); // 光源0を利用 // -------------------------- // NOTE : 光源を利用する際は、glColor3dが無効になるので、オブジェクトの色は`glMaterialfv(適用する面, 光源の種類, 反射する色)`で指定する /* * 複数のオブジェクトを描画する際は、Initializeで作成したカレント行列を元に描画する必要があるので、オブジェクトの描画ごとにカレント行列をPushして、描画おわり次第Popする. */ // 球 glPushMatrix(); // カレント行列をスタックに保存しておく (popされるまでのカレント行列への変更を無視できる) glMaterialfv(GL_FRONT, GL_AMBIENT, ms_ruby.ambient); glMaterialfv(GL_FRONT, GL_DIFFUSE, ms_ruby.diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, ms_ruby.specular); glMaterialfv(GL_FRONT, GL_SHININESS, &ms_ruby.shininess); glTranslated(0.0, 10.0, 20.0); // 平行移動値の設定 (OpenGL内部では、カレント行列に平行移動行列を乗算して、カレント行列を更新している) glutSolidSphere(4.0, 20, 20); glPopMatrix(); // 立方体 glPushMatrix(); glMaterialfv(GL_FRONT, GL_DIFFUSE, green); glTranslated(-20.0, 0.0, 20.0); glutSolidCube(10.0); // 引数: 一辺の長さ glPopMatrix(); // 円錐 glPushMatrix(); glMaterialfv(GL_FRONT, GL_DIFFUSE, blue); glTranslated(20.0, 100.0, 0.0); glutSolidCone(5.0, 10.0, 20, 20); // 引数: (半径、高さ、Z軸まわりの分割数、Z軸に沿った分割数) glPopMatrix(); // 直方体 // NOTE 「GLUT」に関数が与えられている球(glutSolidSphere)や立方体(glutSolidCube)の場合には、 // 物体の「表」「裏」の情報に与えたれているが、任意の物体を自前で定義した場合には、各面に対して法線ベクトルを定義する必要がある glPushMatrix(); glMaterialfv(GL_FRONT, GL_AMBIENT, ms_jade.ambient); glMaterialfv(GL_FRONT, GL_DIFFUSE, ms_jade.diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, ms_jade.specular); glMaterialfv(GL_FRONT, GL_SHININESS, &ms_jade.shininess); glTranslated(30.0, 50.0, 0.0); // 平行移動値の設定 glBegin(GL_QUADS); for (int j = 0; j < 6; j++) { glNormal3dv(normal[j]); //法線ベクトルの指定 for (int i = 0; i < 4; i++) { glVertex3dv(vertex[face[j][i]]); } } glEnd(); glPopMatrix(); //陰影OFF----------------------------- glDisable(GL_LIGHTING); //----------------------------------- glPushMatrix(); Ground(); glPopMatrix(); glutSwapBuffers(); // glutInitDisplayModel(GLUT_DOUBLE)でダブルバッファリングを可にしているので必要 }
void Robot::draw() const { // Retrieve the current (interpolated) pose of the robot. Pose pose = getPose(); // You can set the robot to be whatever color you like. // By default it is white. glPushMatrix(); glMatrixMode(GL_MODELVIEW); //BODY glColor4d(1, 1, 1, 1); glTranslatef(pose.x_, pose.y_,pose.z_); glRotatef(pose.angles_[BODY_ANGLE], 0, 0, 1); drawCuboid(BODY_X,BODY_LEN,BODY_Z); //HEAD glPushMatrix(); glTranslatef(0,BODY_LEN/2,0); glRotatef(pose.angles_[HEAD_ANGLE], 0, 0, 1); glTranslatef(0,.3,0); drawCuboid(.6,.6,.6); glPopMatrix(); // ARMS!! //Right glPushMatrix(); glTranslatef(0, BODY_LEN/2.0, BODY_Z/2.0 + UARM_WIDTH/2.0); //Move to shoulder joint from center of body drawArm(pose, RIGHT_SHOULDER, RIGHT_ELBOW); glPopMatrix(); //Left glPushMatrix(); glTranslatef(0, BODY_LEN/2.0, - (BODY_Z/2.0 + UARM_WIDTH/2.0)); //Move to shoulder joint from center of body drawArm(pose, LEFT_SHOULDER, LEFT_ELBOW); glPopMatrix(); //LEGS //RIGHT glPushMatrix(); glTranslatef(0, -1, .25); drawLeg(pose, RIGHT_HIP, RIGHT_KNEE, RIGHT_ANKLE); glPopMatrix(); //LEFT glPushMatrix(); glTranslatef(0, -1, -.25); drawLeg(pose, LEFT_HIP, LEFT_KNEE, LEFT_ANKLE); glPopMatrix(); //WINGS //RIGHT glPushMatrix(); glTranslatef(-BODY_X/2.0,BODY_LEN/2.0 -.2,BODY_Z/2.0 - .2); drawWing(pose, RIGHT_WING_MID_Y, RIGHT_WING_Y, RIGHT_WING_Z); glPopMatrix(); //LEFT glPushMatrix(); glTranslatef(-BODY_X/2.0,BODY_LEN/2.0 -.2, -BODY_Z/2.0 + .2); drawWing(pose, LEFT_WING_MID_Y, LEFT_WING_Y, LEFT_WING_Z); glPopMatrix(); //Body matrix glPopMatrix(); }
void drawSphere (void) { /* This sphere is going to be rotated around the *current axis*. This is because the model was first rotated and then translated. */ glPushMatrix (); glRotatef (rotate, axis[0], axis[1], axis[2]); glTranslatef (-15.0, 10.0, 5.0); glColor3f (1.0, 0.0, 0.0); glutWireSphere (5.0, 6.0, 6.0); glPopMatrix (); /* This sphere is going to be rotated around the its own center. This is because the model was first translated and then rotated. */ glPushMatrix (); glTranslatef (5.0, 10.0, 0.0); glRotatef (rotate, axis[0], axis[1], axis[2]); glColor3f (0.0, 1.0, 0.0); glutWireSphere (2.0, 6.0, 6.0); glPopMatrix (); }
//------------------------------------------------------------------------------ // globeBall() - draw the globe given specific input parameters //------------------------------------------------------------------------------ void Eadi3DPage::globeBall(LCreal pitch, LCreal roll, LCreal pitchCmd, LCreal rollCmd, bool psValid, bool rcValid, bool landMode) { static LCreal fdPscV1[2] = {-0.5833f, 0.0f}; static LCreal fdPscV2[2] = {0.5833f, 0.0f}; static LCreal fdBscV1[2] = {0.0f, -0.5833f}; static LCreal fdBscV2[2] = {0.0f, 0.5833f}; glLineWidth(1.0); glPushMatrix(); glRotated(GLdouble(roll), 0.0, 0.0, 1.0); lcColor3v(GROUND); eadiObjs.irisgl.circf(0., 0., 1.625); lcColor3v(SKY); eadiObjs.irisgl.arcf(0., 0., 1.625, 0, 180.0); glPopMatrix(); glPushMatrix(); glRotated(GLdouble(roll), 0.0, 0.0, 1.0); glRotated(GLdouble(pitch), 1.0, 0.0, 0.0); glPushMatrix(); if (pitch >= 0.0) lcColor3v(SKY); else lcColor3v(GROUND); glRotated(90.0, 1.0, 0.0, 0.0); /* arcf(0.,0.,radius,180.0,0); */ eadiObjs.irisgl.circf(0., 0., float(radius)); glPopMatrix(); eadiObjs.drawObj(Eadi3DObjects::GLOBE); glPopMatrix(); glLineWidth(1.0); lcColor3v(BLACK); eadiObjs.irisgl.washerf(0., 0., 1.625, 2.0); glLineWidth(2.0); lcColor3v(WHITE); eadiObjs.irisgl.circ(0., 0., 1.625); glPushMatrix(); /* ground pointer */ glRotated(GLdouble(roll), 0.0, 0.0, 1.0); glTranslated(0.0, -1.625, 0.0); eadiObjs.drawObj(Eadi3DObjects::GROUND_POINTER_2); glPopMatrix(); lcColor3v(BLACK); /* lcColor3v(WHITE); * temp */ glLineWidth(4.0); eadiObjs.drawObj(Eadi3DObjects::AC_REF); /* aircraft reference symbol */ glLineWidth(2.0); if (landMode) { if (psValid) { LCreal x = static_cast<LCreal>(pitchCmd / 30.0 * 1.625); /* pitch fd command */ glPushMatrix(); glTranslated(0.0, static_cast<GLdouble>(x), 0.0); glBegin(GL_LINES); lcVertex2v(fdPscV1); lcVertex2v(fdPscV2); glEnd(); glPopMatrix(); } if (rcValid) { LCreal x = static_cast<LCreal>(rollCmd / 30.0 * 1.625); /* roll fd command */ glPushMatrix(); glTranslated(static_cast<GLdouble>(x), 0.0, 0.0); glBegin(GL_LINES); lcVertex2v(fdBscV1); lcVertex2v(fdBscV2); glEnd(); glPopMatrix(); } } glLineWidth(1.0); }
void L_ParticleEffect::draw(int x_shift, int y_shift, float x_size_mod, float y_size_mod) { if (particle_list.size() == 0) return; //LogMsg("particles: %d", particle_list.size()); std::list<L_Particle*>::iterator iter = particle_list.begin(); #ifndef RT_USE_POINT_SPRITES //OPTIMIZE: naive way to draw them with separate blits for normal GL mode or android code g_globalBatcher.Flush(); while( iter != particle_list.end() ) { (*iter)->draw(x_shift, y_shift, x_size_mod, y_size_mod); iter++; } g_globalBatcher.Flush(RenderBatcher::FLUSH_SETUP); glBlendFunc( GL_SRC_ALPHA, GL_ONE); //custom render mode change g_globalBatcher.Flush(RenderBatcher::FLUSH_RENDER); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); //undo custom render mode change g_globalBatcher.Flush(RenderBatcher::FLUSH_UNSETUP); #else SurfaceAnim *pSurf = NULL; int count = 0; glPushMatrix(); glTranslatef(x_shift, y_shift, 0); while( iter != particle_list.end() ) { if (count >= L_ParticleMem::pointSpriteArraySize) { //reached the max of the buffer size.. dump now RenderPointSprites(pSurf, 0, count); count = 0; } if (pSurf != (*iter)->surface) { if (pSurf != NULL) { //uh oh... we can't handle 2 textures with our batching process. We need to sort the textures.. well, //I don't feel like making that happen so let's just render what we've got so far before changing it RenderPointSprites(pSurf, 0, count); count = 0; } pSurf = (*iter)->surface; } L_ParticleMem::pointSpriteArray[count].vPos.x = (*iter)->x_pos; L_ParticleMem::pointSpriteArray[count].vPos.y = (*iter)->y_pos; L_ParticleMem::pointSpriteArray[count].size = pSurf->GetRawTextureWidth()*(*iter)->get_size(); L_ParticleMem::pointSpriteArray[count].color = *(uint32*)&(*iter)->current_color; count++; iter++; } RenderPointSprites(pSurf, 0, count); glPopMatrix(); #endif }
//------------------------------------------------------------------------------ // windows() - //------------------------------------------------------------------------------ void Eadi3DPage::windows(LCreal cas, LCreal alt, LCreal aoa, LCreal mach, LCreal vvi, const char* airSpeedType, LCreal gload) { LCreal a = cas; if (a > 9999.) a = 9999.; if (a < 0.) a = 0.; int airC[4]; airC[0] = static_cast<int>(a) / 1000; a -= static_cast<LCreal>(airC[0] * 1000); airC[1] = static_cast<int>(a) / 100; a -= static_cast<LCreal>(airC[1] * 100); airC[2] = static_cast<int>(a) / 10; a -= static_cast<LCreal>(airC[2] * 10); airC[3] = static_cast<int>(a); for (int i = 0, j = 1; (i < 3) & j; i++) { if (airC[i] == 0) airC[i] = -1; else j = 0; } a = alt; if (a > 99999.) a = 99999.; if (a < 0.) a = 0.; int altC[5]; altC[0] = static_cast<int>(a) / 10000; a -= static_cast<LCreal>(altC[0] * 10000); altC[1] = static_cast<int>(a) / 1000; a -= static_cast<LCreal>(altC[1] * 1000); altC[2] = static_cast<int>(a) / 100; a -= static_cast<LCreal>(altC[2] * 100); altC[3] = static_cast<int>(a) / 10; a -= static_cast<LCreal>(altC[3] * 10); altC[4] = static_cast<int>(a); for (int i = 0, j = 1; (i < 4) & j; i++) { if (altC[i] == 0) altC[i] = -1; else j = 0; } a = static_cast<LCreal>(aoa * 10.0); int aoaC[4]; if (a < 0) { a = -a; aoaC[0] = Eadi3DObjects::PUNC05; } else aoaC[0] = -1; if (a > 999.) a = 999.; aoaC[1] = static_cast<int>(a) / 100; a -= static_cast<LCreal>(aoaC[1] * 100); aoaC[2] = static_cast<int>(a) / 10; a -= static_cast<LCreal>(aoaC[2] * 10); aoaC[3] = static_cast<int>(a); for (int i = 1, j = 1; (i < 3) & j; i++) { if (aoaC[i] == 0) { if (aoaC[i - 1] == Eadi3DObjects::PUNC05) { aoaC[i - 1] = -1; aoaC[i] = Eadi3DObjects::PUNC05; } else aoaC[i] = -1; } else j = 0; } a = static_cast<LCreal>(mach * 100.0); int machC[3]; if (a < 0) { a = 0.0; } if (a > 999.) { a = 999.; } machC[0] = static_cast<int>(a) / 100; a -= static_cast<LCreal>(machC[0] * 100); machC[1] = static_cast<int>(a) / 10; a -= static_cast<LCreal>(machC[1] * 10); machC[2] = static_cast<int>(a); a = static_cast<LCreal>(gload * 10.0); int gloadC[2]; if (a < 0) a = 0.0; if (a > 99.) a = 99.; gloadC[0] = static_cast<int>(a) / 10; a -= static_cast<LCreal>(gloadC[0] * 10); gloadC[1] = static_cast<int>(a); a = vvi; int vviC[5]; if (a < 0) { a = -a; vviC[0] = Eadi3DObjects::PUNC05; } else vviC[0] = -1; if (a > 9999.) a = 9999.; vviC[1] = static_cast<int>(a) / 1000; a -= static_cast<LCreal>(vviC[1] * 1000); vviC[2] = static_cast<int>(a) / 100; a -= static_cast<LCreal>(vviC[2] * 100); vviC[3] = static_cast<int>(a) / 10; a -= static_cast<LCreal>(vviC[3] * 10); vviC[4] = static_cast<int>(a); for (int i = 1, j = 1; (i < 4) & j; i++) { if (vviC[i] == 0) { if (vviC[i - 1] == Eadi3DObjects::PUNC05) { vviC[i - 1] = -1; vviC[i] = Eadi3DObjects::PUNC05; } else vviC[i] = -1; } else j = 0; } lcColor3v(WHITE); glLineWidth(2.0); /* cas */ glPushMatrix(); glTranslated(-2.4375, 1.59375, 0.); if (airSpeedType != 0) { if (airSpeedType[0] == 'T') eadiObjs.drawObj(Eadi3DObjects::FONT_T); else if (airSpeedType[0] == 'G') eadiObjs.drawObj(Eadi3DObjects::FONT_G); else eadiObjs.drawObj(Eadi3DObjects::FONT_C); } glPopMatrix(); glPushMatrix(); glTranslated(-2.4375, 1.59375, 0.0); glTranslated(0.2404, 0.0, 0.0); if (airC[0] != -1) eadiObjs.drawObj((Eadi3DObjects::EadiObj) airC[0]); glTranslated(0.16, 0.0, 0.0); if (airC[1] != -1) eadiObjs.drawObj((Eadi3DObjects::EadiObj) airC[1]); glTranslated(0.16, 0.0, 0.0); if (airC[2] != -1) eadiObjs.drawObj((Eadi3DObjects::EadiObj) airC[2]); glTranslated(0.16, 0.0, 0.0); eadiObjs.drawObj((Eadi3DObjects::EadiObj) airC[3]); glPopMatrix(); /* alt */ glPushMatrix(); glTranslated(1.3625, 1.59375, 0.0); glTranslated(0.2404, 0.0, 0.0); if (altC[0] != -1) eadiObjs.drawObj((Eadi3DObjects::EadiObj) altC[0]); glTranslated(0.16, 0.0, 0.0); if (altC[1] != -1) eadiObjs.drawObj((Eadi3DObjects::EadiObj) altC[1]); glTranslated(0.16, 0.03125, 0.0); glScaled(.666667, .666667, 1.0); if (altC[2] != -1) eadiObjs.drawObj((Eadi3DObjects::EadiObj) altC[2]); glTranslated(0.16, 0.0, 0.0); if (altC[3] != -1) eadiObjs.drawObj((Eadi3DObjects::EadiObj) altC[3]); glTranslated(0.16, 0.0, 0.0); eadiObjs.drawObj((Eadi3DObjects::EadiObj) altC[4]); glPopMatrix(); /* aoa */ glPushMatrix(); glTranslated(-2.3000, 1.34375, 0.0); glTranslated(0.1900, 0.03125, 0.0); glScaled(.666667, .666667, 1.0); if (aoaC[0] != -1) eadiObjs.drawObj((Eadi3DObjects::EadiObj) aoaC[0]); glTranslated(0.16, 0.0, 0.0); if (aoaC[1] != -1) eadiObjs.drawObj((Eadi3DObjects::EadiObj) aoaC[1]); glTranslated(0.16, 0.0, 0.0); if (aoaC[2] != -1) eadiObjs.drawObj((Eadi3DObjects::EadiObj) aoaC[2]); glTranslated(0.16, 0.0, 0.0); eadiObjs.drawObj(Eadi3DObjects::PUNC06); glTranslated(0.16, 0.0, 0.0); eadiObjs.drawObj((Eadi3DObjects::EadiObj) aoaC[3]); glPopMatrix(); /* mach */ glPushMatrix(); glTranslated(-2.3000, 1.09375, 0.0); glTranslated(0.2800, 0.03125, 0.0); glScaled(.666667, .666667, 1.0); eadiObjs.drawObj((Eadi3DObjects::EadiObj) machC[0]); glTranslated(0.16, 0.0, 0.0); eadiObjs.drawObj(Eadi3DObjects::PUNC06); glTranslated(0.16, 0.0, 0.0); eadiObjs.drawObj((Eadi3DObjects::EadiObj) machC[1]); glTranslated(0.16, 0.0, 0.0); eadiObjs.drawObj((Eadi3DObjects::EadiObj) machC[2]); glPopMatrix(); /* G */ glPushMatrix(); glTranslated(-2.3000, 0.84375, 0.0); glTranslated(0.3600, 0.03125, 0.0); glScaled(.666667, .666667, 1.0); eadiObjs.drawObj((Eadi3DObjects::EadiObj) gloadC[0]); glTranslated(0.16, 0.0, 0.0); eadiObjs.drawObj(Eadi3DObjects::PUNC06); glTranslated(0.16, 0.0, 0.0); eadiObjs.drawObj((Eadi3DObjects::EadiObj) gloadC[1]); glPopMatrix(); /* vvi */ glPushMatrix(); glTranslated(1.3625, 1.34375, 0.0); glTranslated(0.1607, 0.0, 0.0); glTranslated(0.1900, 0.03125, 0.0); glScaled(.666667, .666667, 1.0); if (vviC[0] != -1) eadiObjs.drawObj((Eadi3DObjects::EadiObj) vviC[0]); glTranslated(0.16, 0.0, 0.0); if (vviC[1] != -1) eadiObjs.drawObj((Eadi3DObjects::EadiObj) vviC[1]); glTranslated(0.16, 0.0, 0.0); if (vviC[2] != -1) eadiObjs.drawObj((Eadi3DObjects::EadiObj) vviC[2]); glTranslated(0.16, 0.0, 0.0); if (vviC[3] != -1) eadiObjs.drawObj((Eadi3DObjects::EadiObj) vviC[3]); glTranslated(0.16, 0.0, 0.0); eadiObjs.drawObj((Eadi3DObjects::EadiObj) vviC[4]); glPopMatrix(); glLineWidth(1.0); }
// Funciones a definir desde Effect.h void FXritmo::perFrame(float time) { float t = time * 0.001f; float fftbass=miMusic.getFFTBass(); glClearColor(0.925,0,0.549,1); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_PROJECTION); glPushMatrix(); cam.toOGL(); cam.SetPos(0,0,-6); cam.SetLook(0,-1,-0.1); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); float xt=2; // xtremo float z_depth=float(-0.0121); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); glPointSize(10); glColor3f(1,1,1); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); float valy; int numV,j; Point p; static float pulso=0; int row=miMusic.getRow(); if((row==0) || (row==1) || (row==8) || (row==9) || (row==16) || (row==17) || (row==24) || (row==25)) { valy=4; } else { valy=0; } if(valy>0) { pulso=valy; } else { if(pulso>0) { pulso=pulso-pulso*pulso*0.05; } } numV=unaEsfera.getNumVertex(); for(j=0; j<numV; j++) { p.x = 2*sin(t*0.5 + j); p.y = fftbass*5 + 2*cos(t*0.5+j); p.z = 2*(sin(p.y)) + fftbass; p.w = unaEsfera.getVertex(j).w; unaEsfera.setVertex(j,p); } glTranslatef(0,0,pulso*0.6); glRotatef(t*10 ,1,1,1); unaEsfera.perFrame(t); glBlendFunc(GL_SRC_ALPHA_SATURATE, GL_ONE); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); glScalef(3,3,3); glRotatef(t,1,0,0); unCubo.setPolyAlpha(0.3); unCubo.perFrame(t); glPopMatrix(); glDisable(GL_BLEND); glMatrixMode(GL_MODELVIEW); glPopMatrix(); glMatrixMode(GL_MODELVIEW); glPopMatrix(); glMatrixMode(GL_PROJECTION); glPopMatrix(); for(int i=1; i<6; i++) { fxmotionblur->perFrame(t); } fxmotionblur->postprepareFrame(); glEnable(GL_TEXTURE_2D); glEnable(GL_BLEND); xt=1.01;//10-0.05*_row; // xtremos miDemo->ponOrtopedico(4,4); float al=fmod(t,2),dp=0,dpy=-1; // desplazamiento glColor4f(1,1,1,pulso); glBindTexture(GL_TEXTURE_2D, this->layerTitle.texID); glBegin(GL_QUADS); glNormal3f( 0.0f, 0.0f, 1.0f); glTexCoord2f(0, 0); glVertex3f(-xt*2+dp,-xt+dpy,z_depth); glTexCoord2f(1,0); glVertex3f(xt*2+dp,-xt+dpy, z_depth); glTexCoord2f(1,1); glVertex3f(xt*2+dp,xt+dpy, z_depth); glTexCoord2f(0,1); glVertex3f(-xt*2+dp,xt+dpy,z_depth); glEnd(); glDisable(GL_TEXTURE_2D); miDemo->quitaOrtopedico(); }
//------------------------------------------------------------------------------ // heading() - //------------------------------------------------------------------------------ void Eadi3DPage::heading(LCreal hdg, LCreal hdgCmd) { static LCreal baseLineV1[2] = {-1.6f, 2.1875f}; /* base line */ static LCreal baseLineV2[2] = {1.6f, 2.1875f}; static LCreal refTicV1[2] = {0.0f, 2.1875f}; /* reference tic */ static LCreal refTicV2[2] = {0.0f, 2.125f}; glLineWidth(2.0); lcColor3v(BLACK); glRectf(-1.6f, 2.125f, 1.6f, 2.5f); lcColor3v(WHITE); if (hdg < 0.0) hdg += 360.0; LCreal x = static_cast<LCreal>(hdg / 10.0); int i = static_cast<int>(x); x = static_cast<LCreal>(i) - x; int ihu[4]; int ihl[4]; for (int j = 0; j < 4; j++) { int ih = i + j - 1; if (ih <= 0) ih += 36; if (ih > 36) ih -= 36; ihu[j] = ih / 10; ihl[j] = ih - ihu[j] * 10; } glPushMatrix(); glBegin(GL_LINES); lcVertex2v(baseLineV1); lcVertex2v(baseLineV2); glEnd(); glTranslated(GLdouble(x), 0.0, 0.0); eadiObjs.drawObj(Eadi3DObjects::HEADING_SCALE); for (i = 0, x = -1.; i < 4; i++, x++) { glPushMatrix(); glTranslated(GLdouble(x), 2.28, 0.0); glPushMatrix(); glTranslated(-0.137142857, 0.0, 0.0); eadiObjs.drawObj((Eadi3DObjects::EadiObj) ihu[i]); glPopMatrix(); glTranslated(0.03, 0.0, 0.0); eadiObjs.drawObj((Eadi3DObjects::EadiObj) ihl[i]); glPopMatrix(); } glPopMatrix(); glLineWidth(4.0); glBegin(GL_LINES); lcVertex2v(refTicV1); lcVertex2v(refTicV2); glEnd(); glLineWidth(2.0); x = static_cast<LCreal>(hdgCmd / 10.0); lcColor3v(GREEN); glPushMatrix(); glTranslated(static_cast<GLdouble>(x), 2.1875, 0.0); eadiObjs.drawObj(Eadi3DObjects::UP_CARET); glPopMatrix(); glLineWidth(2.0); lcColor3v(BLACK); glRectf(1.6f, 2.125f, 3.3f, 2.5f); glRectf(-3.3f, 2.125f, -1.6f, 2.5f); glLineWidth(1.0); }
void draw_troncos(GLint k,GLint level) { if(level ==0) { glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D,tex[1]); } else if(level ==1) { glEnable(GL_TEXTURE_2D); glColor4f(GRAY2); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); // blending + textura glBindTexture(GL_TEXTURE_2D,tex[3]); } else { if(ascendente == 1) { if(lvl3_colors[k][3]<0.5) { lvl3_colors[k][3]+=0.0005; } else { lvl3_colors[k][3]+=0.001; } if(lvl3_colors[k][3]>1.0) { ascendente = 0; } } else { lvl3_colors[k][3]-=0.001; if(lvl3_colors[k][3]<0.0) { ascendente = 1; } } glEnable(GL_BLEND); glColor4f(lvl3_colors[k][0],lvl3_colors[k][1],lvl3_colors[k][2],lvl3_colors[k][3]); } glPushMatrix(); /*desenho do cilindro*/ glTranslatef(levels[level].troncoPos[k][0],levels[level].troncoPos[k][1],levels[level].troncoPos[k][2]); glRotatef (levels[level].troncoRot[k][0],levels[level].troncoRot[k][1],levels[level].troncoRot[k][2],levels[level].troncoRot[k][3]); GLUquadricObj* y = gluNewQuadric( ); gluQuadricDrawStyle(y, GLU_FILL); gluQuadricNormals(y, GLU_SMOOTH); gluQuadricTexture(y,GL_TRUE); gluCylinder(y,levels[level].troncoDim[k][0],levels[level].troncoDim[k][1],levels[level].troncoDim[k][2],32,32); /*desenho dos discos que tapam a extremidades do cilindro*/ gluDisk(y, 0.0, levels[level].diskRadius[k], 32, 32); glTranslatef(0,0,levels[level].troncoDim[k][2]); gluDisk(y, 0.0, levels[level].diskRadius[k], 32, 32); gluDeleteQuadric(y); glPopMatrix(); glDisable(GL_TEXTURE_2D); glDisable(GL_BLEND); }
static void DrawFire(ModeInfo * mi) { int j; firestruct *fs = &fire[MI_SCREEN(mi)]; Bool wire = MI_IS_WIREFRAME(mi); mi->polygon_count = 0; if (do_wander && !fs->button_down_p) { GLfloat x, y, z; # define SINOID(SCALE,SIZE) \ ((((1 + sin((fs->frame * (SCALE)) / 2 * M_PI)) / 2.0) * (SIZE)) - (SIZE)/2) x = SINOID(0.031, 0.85); y = SINOID(0.017, 0.25); z = SINOID(0.023, 0.85); fs->frame++; fs->obs[0] = x + DEF_OBS[0]; fs->obs[1] = y + DEF_OBS[1]; fs->obs[2] = z + DEF_OBS[2]; fs->dir[1] = y; fs->dir[2] = z; } glEnable(GL_DEPTH_TEST); if (fs->fog) glEnable(GL_FOG); else glDisable(GL_FOG); glDepthMask(GL_TRUE); glClearColor(0.5, 0.5, 0.8, 1.0); /* sky in the distance */ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPushMatrix(); calcposobs(fs); gltrackball_rotate (fs->trackball); gluLookAt(fs->obs[0], fs->obs[1], fs->obs[2], fs->obs[0] + fs->dir[0], fs->obs[1] + fs->dir[1], fs->obs[2] + fs->dir[2], 0.0, 1.0, 0.0); glEnable(GL_TEXTURE_2D); /* draw ground using the computed texture */ if (do_texture) { glColor4f(1.0,1.0,1.0,1.0); /* white to get texture in it's true color */ #ifdef HAVE_GLBINDTEXTURE glBindTexture(GL_TEXTURE_2D, fs->groundid); #endif /* HAVE_GLBINDTEXTURE */ } else glColor4f(0.54, 0.27, 0.07, 1.0); /* untextured ground color */ glBegin(GL_QUADS); glTexCoord2fv(qt[0]); glVertex3fv(q[0]); glTexCoord2fv(qt[1]); glVertex3fv(q[1]); glTexCoord2fv(qt[2]); glVertex3fv(q[2]); glTexCoord2fv(qt[3]); glVertex3fv(q[3]); mi->polygon_count++; glEnd(); glAlphaFunc(GL_GEQUAL, 0.9); if (fs->num_trees) { /* here do_texture IS True - and color used is white */ glEnable(GL_ALPHA_TEST); #ifdef HAVE_GLBINDTEXTURE glBindTexture(GL_TEXTURE_2D,fs->treeid); #endif /* HAVE_GLBINDTEXTURE */ for(j=0;j<fs->num_trees;j++) mi->polygon_count += drawtree(fs->treepos[j].x ,fs->treepos[j].y ,fs->treepos[j].z ); glDisable(GL_ALPHA_TEST); } glDisable(GL_TEXTURE_2D); glDepthMask(GL_FALSE); if (fs->shadows) { /* draw shadows with black color */ glBegin(wire ? GL_LINE_STRIP : GL_TRIANGLES); for (j = 0; j < fs->np; j++) { glColor4f(black[0], black[1], black[2], fs->p[j].c[0][3]); glVertex3f(fs->p[j].p[0][0], 0.1, fs->p[j].p[0][2]); glColor4f(black[0], black[1], black[2], fs->p[j].c[1][3]); glVertex3f(fs->p[j].p[1][0], 0.1, fs->p[j].p[1][2]); glColor4f(black[0], black[1], black[2], fs->p[j].c[2][3]); glVertex3f(fs->p[j].p[2][0], 0.1, fs->p[j].p[2][2]); mi->polygon_count++; } glEnd(); } glBegin(wire ? GL_LINE_STRIP : GL_TRIANGLES); for (j = 0; j < fs->np; j++) { /* draw particles: colors are computed in setpart */ glColor4fv(fs->p[j].c[0]); glVertex3fv(fs->p[j].p[0]); glColor4fv(fs->p[j].c[1]); glVertex3fv(fs->p[j].p[1]); glColor4fv(fs->p[j].c[2]); glVertex3fv(fs->p[j].p[2]); mi->polygon_count++; setpart(fs, &fs->p[j]); } glEnd(); /* draw rain particles if no fire particles */ if (!fs->np) { float timeused = gettimerain(); glDisable(GL_TEXTURE_2D); glShadeModel(GL_SMOOTH); glBegin(GL_LINES); for (j = 0; j < NUMPART; j++) { glColor4f(0.7f,0.95f,1.0f,0.0f); glVertex3fv(fs->r[j].oldpos); glColor4f(0.3f,0.7f,1.0f,1.0f); glVertex3fv(fs->r[j].pos); setpartrain(fs, &fs->r[j],timeused); mi->polygon_count++; } glEnd(); glShadeModel(GL_FLAT); } glDisable(GL_TEXTURE_2D); glDisable(GL_ALPHA_TEST); glDisable(GL_DEPTH_TEST); glDisable(GL_FOG); /* manage framerate display */ if (MI_IS_FPS(mi)) do_fps (mi); glPopMatrix(); }
// `使用OpenGL來繪圖` void RenderFrameOpenGL(void) { // `清除畫面` glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glEnable(GL_DEPTH_TEST); // `設定要用陣列的方式傳入頂點位置跟顏色` glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_COLOR_ARRAY); // `計算出一個可以轉換到鏡頭座標系的矩陣` Matrix4x4 view_matrix = GutMatrixLookAtRH(g_eye, g_lookat, g_up); Matrix4x4 world_view_matrix; glMatrixMode(GL_MODELVIEW); // `載入鏡頭轉換矩陣` glLoadMatrixf( (float *) &view_matrix ); glPushMatrix(); // `把目前的矩陣存到stack里` // `太陽, 套入滑鼠的旋轉控制.` glRotatef(FastMath::RadianToDegree(g_fRotate_X), 1.0f, 0.0f, 0.0f); glRotatef(FastMath::RadianToDegree(g_fRotate_Y), 0.0f, 1.0f, 0.0f); glVertexPointer(3, GL_FLOAT, sizeof(Vertex_VC), g_pSunVertices); glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Vertex_VC), g_pSunVertices[0].m_RGBA); glDrawElements(GL_TRIANGLES, g_iNumSphereIndices, GL_UNSIGNED_SHORT, g_pSphereIndices); // `水星` glPushMatrix(); // `把目前的矩陣存到stack里` float mercury_rotate_y = 360.0f * (g_simulation_days / days_a_year_mercury); glRotatef(mercury_rotate_y, 0.0f, 1.0f, 0.0f); glTranslatef(mercury_to_sun_distance, 0.0f, 0.0f); glVertexPointer(3, GL_FLOAT, sizeof(Vertex_VC), g_pMoonVertices); glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Vertex_VC), g_pMoonVertices[0].m_RGBA); glDrawElements(GL_TRIANGLES, g_iNumSphereIndices, GL_UNSIGNED_SHORT, g_pSphereIndices); // `從stack里pop出一個矩陣, 并套用到目前所指定要操作的矩陣`GL_MODELVIEW glPopMatrix(); // `金星` glPushMatrix(); // `把目前的矩陣存到stack里` float venus_rotate_y = 360.0f * (g_simulation_days / days_a_year_venus); glRotatef(venus_rotate_y, 0.0f, 1.0f, 0.0f); glTranslatef(venus_to_sun_distance, 0.0f, 0.0f); glVertexPointer(3, GL_FLOAT, sizeof(Vertex_VC), g_pMoonVertices); glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Vertex_VC), g_pMoonVertices[0].m_RGBA); glDrawElements(GL_TRIANGLES, g_iNumSphereIndices, GL_UNSIGNED_SHORT, g_pSphereIndices); // `從stack里pop出一個矩陣, 并套用到目前所指定要操作的矩陣`GL_MODELVIEW glPopMatrix(); // `地球` glPushMatrix();// `把目前的矩陣存到stack里` float earth_rotate_y = 360.0f * (g_simulation_days / days_a_year); glRotatef(earth_rotate_y, 0.0f, 1.0f, 0.0f); glTranslatef(earth_to_sun_distance, 0.0f, 0.0f); glVertexPointer(3, GL_FLOAT, sizeof(Vertex_VC), g_pEarthVertices); glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Vertex_VC), g_pEarthVertices[0].m_RGBA); glDrawElements(GL_TRIANGLES, g_iNumSphereIndices, GL_UNSIGNED_SHORT, g_pSphereIndices); // `月球` float moon_rotate_y = 360.0f * (g_simulation_days / days_a_month); glRotatef(moon_rotate_y, 0.0f, 1.0f, 0.0f); glTranslatef(moon_to_earth_distance, 0.0f, 0.0f); glVertexPointer(3, GL_FLOAT, sizeof(Vertex_VC), g_pMoonVertices); glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Vertex_VC), g_pMoonVertices[0].m_RGBA); glDrawElements(GL_TRIANGLES, g_iNumSphereIndices, GL_UNSIGNED_SHORT, g_pSphereIndices); // `從stack里pop出一個矩陣, 并套用到目前所指定要操作的矩陣GL_MODELVIEW` glPopMatrix(); glPopMatrix(); // `把背景backbuffer的畫面呈現出來` GutSwapBuffersOpenGL(); }
// Draws the FBO texture for 3DTV. void ApplicationOverlay::displayOverlayTexture3DTV(Camera& whichCamera, float aspectRatio, float fov) { if (_alpha == 0.0f) { return; } Application* application = Application::getInstance(); MyAvatar* myAvatar = application->getAvatar(); const glm::vec3& viewMatrixTranslation = application->getViewMatrixTranslation(); glActiveTexture(GL_TEXTURE0); glEnable(GL_BLEND); glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_ONE); _overlays.bindTexture(); glEnable(GL_DEPTH_TEST); glDisable(GL_LIGHTING); glEnable(GL_TEXTURE_2D); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); // Transform to world space glm::quat rotation = whichCamera.getRotation(); glm::vec3 axis2 = glm::axis(rotation); glRotatef(-glm::degrees(glm::angle(rotation)), axis2.x, axis2.y, axis2.z); glTranslatef(viewMatrixTranslation.x, viewMatrixTranslation.y, viewMatrixTranslation.z); // Translate to the front of the camera glm::vec3 pos = whichCamera.getPosition(); glm::quat rot = myAvatar->getOrientation(); glm::vec3 axis = glm::axis(rot); glTranslatef(pos.x, pos.y, pos.z); glRotatef(glm::degrees(glm::angle(rot)), axis.x, axis.y, axis.z); glColor4f(1.0f, 1.0f, 1.0f, _alpha); //Render const GLfloat distance = 1.0f; const GLfloat halfQuadHeight = distance * tan(fov); const GLfloat halfQuadWidth = halfQuadHeight * aspectRatio; const GLfloat quadWidth = halfQuadWidth * 2.0f; const GLfloat quadHeight = halfQuadHeight * 2.0f; GLfloat x = -halfQuadWidth; GLfloat y = -halfQuadHeight; glDisable(GL_DEPTH_TEST); glBegin(GL_QUADS); glTexCoord2f(0.0f, 1.0f); glVertex3f(x, y + quadHeight, -distance); glTexCoord2f(1.0f, 1.0f); glVertex3f(x + quadWidth, y + quadHeight, -distance); glTexCoord2f(1.0f, 0.0f); glVertex3f(x + quadWidth, y, -distance); glTexCoord2f(0.0f, 0.0f); glVertex3f(x, y, -distance); glEnd(); if (_crosshairTexture == 0) { _crosshairTexture = Application::getInstance()->getGLWidget()->bindTexture(QImage(Application::resourcesPath() + "images/sixense-reticle.png")); } //draw the mouse pointer glBindTexture(GL_TEXTURE_2D, _crosshairTexture); const float reticleSize = 40.0f / application->getGLWidget()->width() * quadWidth; x -= reticleSize / 2.0f; y += reticleSize / 2.0f; const float mouseX = (application->getMouseX() / (float)application->getGLWidget()->width()) * quadWidth; const float mouseY = (1.0 - (application->getMouseY() / (float)application->getGLWidget()->height())) * quadHeight; glBegin(GL_QUADS); glColor3f(RETICLE_COLOR[0], RETICLE_COLOR[1], RETICLE_COLOR[2]); glTexCoord2d(0.0f, 0.0f); glVertex3f(x + mouseX, y + mouseY, -distance); glTexCoord2d(1.0f, 0.0f); glVertex3f(x + mouseX + reticleSize, y + mouseY, -distance); glTexCoord2d(1.0f, 1.0f); glVertex3f(x + mouseX + reticleSize, y + mouseY - reticleSize, -distance); glTexCoord2d(0.0f, 1.0f); glVertex3f(x + mouseX, y + mouseY - reticleSize, -distance); glEnd(); glEnable(GL_DEPTH_TEST); glPopMatrix(); glDepthMask(GL_TRUE); glBindTexture(GL_TEXTURE_2D, 0); glDisable(GL_TEXTURE_2D); glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_ONE); glEnable(GL_LIGHTING); glColor4f(1.0f, 1.0f, 1.0f, 1.0f); }