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);
}
