void drawOBJMesh(struct OBJ_Model * obj) { glPushAttrib(GL_ALL_ATTRIB_BITS); //We dont want the attributes we use here to poison the rest of the drawing if (obj == 0 ) { fprintf(stderr,"drawOBJMesh called with unloaded object \n"); return; } long unsigned int i,j; glDisable(GL_CULL_FACE); if (checkOpenGLError(__FILE__, __LINE__)) { fprintf(stderr,"Initial Error while @ drawOBJMesh\n"); } //for every group for(i=0; i<obj->numGroups; i++) { if (obj->matList!=0) { //We might not have a material with our object! //if there is a bmp file to load the texture from, in the mtl file if( obj->matList[obj->groups[i].material].hasTex ) { if( obj->matList[obj->groups[i].material].ldText>0) { glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, obj->matList[ obj->groups[i].material].ldText); } } else { /*glDisable(GL_TEXTURE_2D);*/ } if (checkOpenGLError(__FILE__, __LINE__)) { fprintf(stderr,"Error before setting up material @ drawOBJMesh\n"); } GLenum faces=GL_FRONT;//GL_FRONT_AND_BACK; glMaterialfv(faces, GL_AMBIENT, obj->matList[ obj->groups[i].material].ambient); glMaterialfv(faces, GL_DIFFUSE, obj->matList[ obj->groups[i].material].diffuse); glMaterialfv(faces, GL_SPECULAR, obj->matList[ obj->groups[i].material].specular); if (checkOpenGLError(__FILE__, __LINE__)) { fprintf(stderr,"Error after setting up material for specularity @ drawOBJMesh\n"); } #if DISABLE_SHININESS glMaterialf(faces, GL_SHININESS, 0.0 ); #else glMaterialfv(faces, GL_SHININESS, obj->matList[ obj->groups[i].material].shine); #endif if (checkOpenGLError(__FILE__, __LINE__)) { fprintf(stderr,"Error after setting up material for shininess @ drawOBJMesh\n"); } //if the group has texture coordinates if( ( obj->groups[i].hasTex) ==0 ) { InitAutoTex(); } else { glDisable(GL_TEXTURE_GEN_S); glDisable(GL_TEXTURE_GEN_T); } if (checkOpenGLError(__FILE__, __LINE__)) { fprintf(stderr,"Error after setting up material @ drawOBJMesh\n"); } } else { //No Matterials , No Textures glDisable(GL_TEXTURE_GEN_S); glDisable(GL_TEXTURE_GEN_T); glDisable(GL_TEXTURE_2D); } if (checkOpenGLError(__FILE__, __LINE__)) { fprintf(stderr,"Error before starting drawing triangles @ drawOBJMesh\n"); } doOBJDrawCallsForGroup(obj,i); if (checkOpenGLError(__FILE__, __LINE__)) { fprintf(stderr,"Initial Error after drawing triangles @ drawOBJMesh\n"); } }//FOR I glPopAttrib(); }
void RenderingEngine::Initialize(const vector<ISurface*>& surfaces) { vector<ISurface*>::const_iterator surface; for (surface = surfaces.begin(); surface != surfaces.end(); ++surface) { // Create the VBO for the vertices. vector<float> vertices; (*surface)->GenerateVertices(vertices, VertexFlagsNormals); GLuint vertexBuffer; glGenBuffers(1, &vertexBuffer); glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer); glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(vertices[0]), &vertices[0], GL_STATIC_DRAW); // Create a new VBO for the indices if needed. int indexCount = (*surface)->GetLineIndexCount(); GLint indexBuffer; if (!m_drawable.empty() && indexCount == m_drawables[0].IndexCount) { indexBuffer = m_drawables[0].IndexBuffer; } else { vector<GLushort> indices(indexCount); (*sourface)->GenerateLineIndices(indices); glGenBuffers(1, &indexbuffer); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer); glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexCount * sizeof(GLushort), &indices[0], GL_STATIC_DRAW); } Drawable drawalbe = { vertexBuffer, indexBuffer, indexCount }; m_drawables.push_back(drawable); } // 프레임 버퍼 객체를 생성한다. // GLuint framebuffer; // glGenFramebuffersOES(1, &framebuffer); // glBindFramebufferOES(GL_FRAMEBUFFER_OES, framebuffer); // glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, // GL_COLOR_ATTACHMENT0_OES, // GL_RENDERBUFFER_OES, // m_colorRenderbuffer); // glBindRenderbufferOES(GL_RENDERBUFFER_OES, m_colorRenderbuffer); // 여러 GL상태를 설정한다. glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_DEPTH_TEST); // 물체 속성을 설정한다. vec4 specular(0.5f, 0.5f, 0.5f, 1); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular.Pointer()); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 50.0f); m_translation = mat4::Translate(0, 0, -7); }
void Arena::GraphicsSetup() { // Vertices #define VERTCOUNT 1538 float bbverts[VERTCOUNT][3] = #include "../model/cube.verts" ; // Generate vertex colors float bbvertcolor[VERTCOUNT][3]; for (int i = 0; i < VERTCOUNT; ++i) { bbvertcolor[i][0] = .6; bbvertcolor[i][1] = .6; bbvertcolor[i][2] = .6; } // Faces (Quads) #define FACECOUNT 1536 int bbfaces[FACECOUNT][4] = #include "../model/cube.faces" ; // Setup Display List for Bounding Box BB_DL = glGenLists(1); // Fill display list glNewList(BB_DL, GL_COMPILE); glColor3f(.6, .6, .6); // Material float _Ambient[4] = {.25f, .25f, .25f, 1.0f}; float _Diffuse[4] = {.4f, .4f, .4f, 1.0f}; float _Specular[4] = {0.774597f, 0.774597f, 0.774597f, 1}; float _Shininess = 76.8f; glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, _Ambient); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, _Diffuse); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, _Specular); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, _Shininess); /* // LIGHTS GLfloat ambientcolor[] = {.6, .6, .6, 1}; glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientcolor); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE); glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_FALSE); glEnable(GL_LIGHTING); glEnable(GL_COLOR_MATERIAL); GLfloat light0pos[4]; GLfloat light0dif[4]; GLfloat light1pos[4]; GLfloat light1dif[4]; GLfloat light2pos[4]; GLfloat light2dif[4]; GLfloat light3pos[4]; GLfloat light3dif[4]; glEnable(GL_LIGHT0); light0pos[0] = 0; light0pos[1] = 0; light0pos[2] = 1; light0pos[3] = 1; light0dif[0] = .3; light0dif[1] = .15; light0dif[2] = .15; light0dif[3] = 1; glLightfv(GL_LIGHT0, GL_DIFFUSE, light0dif); glEnable(GL_LIGHT1); light1pos[0] = 5; light1pos[1] = -2; light1pos[2] = 8; light1pos[3] = 1; light1dif[0] = .3; light1dif[1] = .8; light1dif[2] = .1; light1dif[3] = 1; glLightfv(GL_LIGHT1, GL_DIFFUSE, light1dif); glEnable(GL_LIGHT2); light2pos[0] = -2; light2pos[1] = 10; light2pos[2] = -1; light2pos[3] = 1; light2dif[0] = .3; light2dif[1] = .2; light2dif[2] = 1; light2dif[3] = 1; glLightfv(GL_LIGHT2, GL_DIFFUSE, light2dif); glEnable(GL_LIGHT3); light3pos[0] = -140; light3pos[1] = -110; light3pos[2] = 70; light3pos[3] = 1; light3dif[0] = .3; light3dif[1] = 0; light3dif[2] = 0; light3dif[3] = 1; glLightfv(GL_LIGHT3, GL_DIFFUSE, light3dif); // \LIGHTS */ glBegin(GL_QUADS); for (int f = 0; f < FACECOUNT; f++) { // face for (int p = 0; p < 4; p++) { // point on face (quad) // Randomize Color glColor3f(bbvertcolor[bbfaces[f][p]-1][0], bbvertcolor[bbfaces[f][p]-1][1], bbvertcolor[bbfaces[f][p]-1][2]); // Draw Vertex glVertex3f( bbverts[bbfaces[f][p]-1][0] , bbverts[bbfaces[f][p]-1][1] , bbverts[bbfaces[f][p]-1][2] ); // std::cout << "f: " << f << "\tp: " << p << "\n"; // std::cout << // "\tx: " << bbverts[bbfaces[f][p-1]][0] << // "\ty: " << bbverts[bbfaces[f][p-1]][1] << // "\ty: " << bbverts[bbfaces[f][p-1]][2] << // "\n"; } } glEnd(); glColor3f(.6, .6, .6); glBegin(GL_QUADS); glVertex3f(0, 0, 0); glVertex3f(0, .1, 0); glVertex3f(.1, .1, 0); glVertex3f(.1, 0, 0); glEnd(); glEndList(); #undef VERTCOUNT #undef FACECOUNT BB_COMPILED = true; }
//transforms the objects way of creation to materials void GameObject::material(GLfloat amb[4], GLfloat diffuse[4], GLfloat specular[4], GLfloat shine[4]){ glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, amb); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, *shine); };
/* The main drawing function. */ void DrawGLScene(void) { glMatrixMode(GL_MODELVIEW); // clear all the buffers - gives OpenGL full control // OpenSG doesn't clear the background because of the PassiveBackground object glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // set the model transformation glMatrixMode(GL_MODELVIEW); glLoadIdentity(); // set camera position from mouse movement glTranslatef(0.0f, 0.0f, -m_distance); glRotatef(m_tiltAngle, 1.0f, 0.0f, 0.0f); glRotatef(m_twistAngle, 0.0f, 0.0f, 1.0f); //glTranslatef(0.0f, 0.0f, -90.0f); glPushMatrix(); // OpenSG will overwrite OSG::Real32 proj_matrix[16], model_matrix[16]; glGetFloatv(GL_PROJECTION_MATRIX, proj_matrix); glGetFloatv(GL_MODELVIEW_MATRIX, model_matrix); // retrieve OpenGL's matrices OSG::Matrix proj, model; proj.setValue(proj_matrix); model.setValue(model_matrix); newcam->setProjectionMatrix(proj); // transform the world just like the OpenGL content // necessary since OpenSG's modelview transforms start from the unity matrix. newcam->setModelviewMatrix(model); // setup an initial transformation OSG::Matrix m1; OSG::Quaternion q1; // mind that the VRML base coordinate system has different meanings for X, Y, Z, hence the rotation for 90 degrees. // this, together with the MatrixCamera code above hooks OpenSG to OpenGL ! m1.setIdentity(); q1.setValueAsAxisDeg(1, 0, 0., 90); // rotation m1.setRotate(q1); trans->setMatrix(m1); OSG::commitChanges(); // redraw the OpenSG window content - the calls are a bit after one's own taste pwin->render(mgr->getRenderAction()); //pwin->frameInit(); //pwin->frameExit(); //mgr->redraw(); glMatrixMode(GL_MODELVIEW); glPopMatrix(); //################ START FOR OPENGL STUFF // light attributes const GLfloat light_ambient[] = { 0.3f, 0.3f, 0.3f, 1.0f }; const GLfloat light_diffuse[] = { 0.52f, 0.5f, 0.5f, 1.0f }; const GLfloat light_specular[] = { 0.1f, 0.1f, 0.1f, 1.0f }; // setup the light attributes glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse); glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular); glEnable(GL_LIGHT0); glEnable(GL_LIGHTING); // set the light position GLfloat lightPosition[] = { 0.0f, -10.0f, 10.0f, 0.0f }; glLightfv(GL_LIGHT0, GL_POSITION, lightPosition); glEnable(GL_NORMALIZE); glDisable(GL_NORMALIZE); //glDisable(GL_BLEND); glEnable(GL_LIGHTING); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, texture[0]); // choose the texture to use. GLfloat TableDiffuse[] = { 0.3f, 0.0f, 1.0f, 0.5f }; GLfloat TableSpecular[] = { 0.6f, 0.0f, 0.8f, 0.5f }; glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, TableDiffuse); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, TableSpecular); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 0.4f); glEnable(GL_BLEND); gluPartialDisk(quadric,0,12.0f,32,16, 0, 360); // A Disk Like The One Before #if 1 glDisable(GL_TEXTURE_2D); glDisable(GL_LIGHTING); // X axis on table glColor3f(1,0,0); glBegin(GL_LINES); glVertex3f(0,0,0.1f); glVertex3f(120,0,0.1f); glEnd(); // Y axis on table glColor3f(0,1,0); glBegin(GL_LINES); glVertex3f(0,0,0.1f); glVertex3f(0,120,0.1f); glEnd(); glEnable(GL_LIGHTING); #endif glDisable(GL_TEXTURE_2D); glDisable(GL_BLEND); glDisable(GL_LIGHTING); // render the cursor renderCursor(); // swap the front- and back-buffer glutSwapBuffers(); }
/* Loads heightmap & draws seabed */ void drawSeabed(Seabed *terrain) { static float diffuse[] = {0.93, 0.91, 0.80, 1.0}; static float ambient[] = {0.93, 0.91, 0.80, 1.0}; static float specular[] = {1, 1, 1, 1}; static float shininess = 100.0f; int width, height, i, j, index; float x, y, z, x2, z2, u, v; float scale, scaleY, sizeW, sizeH; Image *image = terrain->image; Vec3f A,B,C,AB,AC,n; width = image->width; height = image->height; /* scales : -0.5 < x,z, < 05 */ sizeW = 1.0/(float)width; sizeH = 1.0/(float)height; /* Scales to match water grid */ scale = terrain->scale; scaleY = terrain->height; /* Applying material */ glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambient); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess); /* Draws seabed */ glEnable(GL_TEXTURE_2D); glEnable(GL_BLEND); glBindTexture(GL_TEXTURE_2D, terrain->tex); for(i=0; i<width-1; i++) { glBegin(GL_TRIANGLE_STRIP); for(j=0; j<height; j++) { x = (j*sizeH-0.5)*scale; z = (i*sizeW-0.5)*scale; index = (j*width + i) * image->channels; y = (scaleY * image->data[index]/255.0f) - terrain->displacement; /* Calculating texturing coordinates */ u = x/100; v = z/100; if(u<0) { u *= -1; } if(v<0) { v *= -1; } /* Calculating normals */ A = newVec3f(x, y, z); /* This pos */ x2 = ((j+1)*sizeH-0.5)*scale; index = ((j+1) * image->width + i) * image->channels; B = newVec3f(x2, image->data[index]/255.0f, z); /* x direction */ z2 = ((i+1)*sizeW-0.5)*scale; index = (j * image->width + (i+1)) * image->channels; C = newVec3f(x, image->data[index]/255.0f, z2); /* z direction */ AB = newVec3f(B.x-A.x, B.y-A.y, B.z-A.z); AC = newVec3f(C.x-A.x, B.y-A.y, B.z-A.z); float magAB = sqrt(pow(AB.x,2) + pow(AB.y,2) + pow(AB.z,2)); float magAC = sqrt(pow(AC.x,2) + pow(AC.y,2) + pow(AC.z,2)); float scalar = AB.x*AC.x + AB.y*AC.y + AB.z*AC.z; float theta = acos(scalar/(magAB*magAC)); if(theta > 0) { /* Cross product */ n = newVec3f(AC.y*AB.z-AC.z*AB.y, AC.z*AB.x-AC.x*AB.z, AC.x*AB.y-AC.y*AB.x); } else { /* Cross product */ n = newVec3f(AB.y*AC.z-AB.z*AC.y, AB.z*AC.x-AB.x*AC.z, AB.x*AC.y-AB.y*AC.x); } /* Noramlizing */ float mag = sqrt(pow(n.x,2) + pow(n.y,2) + pow(n.z,2)); n.x = n.x/mag; n.y = n.y/mag; n.z = n.z/mag; /* COORDINATES */ glNormal3f(n.x, n.y, n.z); glTexCoord2f(u,v); glVertex3f(x, y, z); index = (j*width + (i+1)) * image->channels; y = (scaleY * image->data[index]/255.0f) - terrain->displacement; /* Incrementing z & updating v texture coordinate */ z = z+sizeW*scale; v = z/100; if(v<0) { v *= -1; } /* COORDINATES */ glNormal3f(n.x, n.y, n.z); glTexCoord2f(u,v); glVertex3f(x, y, z); } glEnd(); } }
void apply_material(const aiMaterial *mtl) { float c[4]; GLenum fill_mode; int ret1, ret2; aiColor4D diffuse; aiColor4D specular; aiColor4D ambient; aiColor4D emission; float shininess, strength; int two_sided; int wireframe; unsigned int max; // changed: to unsigned int texIndex = 0; aiString texPath; //contains filename of texture { aiString path; // filename int texFound = mtl->GetTexture(aiTextureType_DIFFUSE, 0, &path); char * filename_unix = replace(path.data, '\\', "/"); } if(AI_SUCCESS == mtl->GetTexture(aiTextureType_DIFFUSE, texIndex, &texPath)) { //bind texture char * filename_unix = replace(texPath.data, '\\', "/"); unsigned int texId = *textureIdMap[hash(filename_unix)]; glBindTexture(GL_TEXTURE_2D, texId); } set_float4(c, 0.8f, 0.8f, 0.8f, 1.0f); if(AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_DIFFUSE, &diffuse)) color4_to_float4(&diffuse, c); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, c); set_float4(c, 0.2f, 0.2f, 0.2f, 1.0f); if(AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_SPECULAR, &specular)) color4_to_float4(&specular, c); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, c); set_float4(c, 0.2f, 0.2f, 0.2f, 1.0f); if(AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_AMBIENT, &ambient)) color4_to_float4(&ambient, c); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, c); set_float4(c, 0.0f, 0.0f, 0.0f, 1.0f); if(AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_EMISSIVE, &emission)) color4_to_float4(&emission, c); glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, c); max = 1; ret1 = aiGetMaterialFloatArray(mtl, AI_MATKEY_SHININESS, &shininess, &max); max = 1; ret2 = aiGetMaterialFloatArray(mtl, 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); set_float4(c, 0.0f, 0.0f, 0.0f, 0.0f); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, c); } max = 1; if(AI_SUCCESS == aiGetMaterialIntegerArray(mtl, 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(mtl, AI_MATKEY_TWOSIDED, &two_sided, &max)) && two_sided) glEnable(GL_CULL_FACE); else glDisable(GL_CULL_FACE); glDisable(GL_CULL_FACE); /////////////// }
static void Init( void ) { static const char *fragProgramText = "!!FP1.0\n" "DECLARE Diffuse; \n" "DECLARE Specular; \n" "DECLARE LightPos; \n" "# Compute normalized LightPos, put it in R0\n" "DP3 R0.x, LightPos, LightPos;\n" "RSQ R0.y, R0.x;\n" "MUL R0, LightPos, R0.y;\n" "# Compute normalized normal, put it in R1\n" "DP3 R1, f[TEX0], f[TEX0]; \n" "RSQ R1.y, R1.x;\n" "MUL R1, f[TEX0], R1.y;\n" "# Compute dot product of light direction and normal vector\n" "DP3_SAT R2, R0, R1;" "MUL R3, Diffuse, R2; # diffuse attenuation\n" "POW R4, R2.x, {20.0}.x; # specular exponent\n" "MUL R5, Specular, R4; # specular attenuation\n" "ADD o[COLR], R3, R5; # add diffuse and specular colors\n" "END \n" ; static const char *vertProgramText = "!!VP1.0\n" "# typical modelview/projection transform\n" "DP4 o[HPOS].x, c[0], v[OPOS] ;\n" "DP4 o[HPOS].y, c[1], v[OPOS] ;\n" "DP4 o[HPOS].z, c[2], v[OPOS] ;\n" "DP4 o[HPOS].w, c[3], v[OPOS] ;\n" "# transform normal by inv transpose of modelview, put in tex0\n" "DP3 o[TEX0].x, c[4], v[NRML] ;\n" "DP3 o[TEX0].y, c[5], v[NRML] ;\n" "DP3 o[TEX0].z, c[6], v[NRML] ;\n" "DP3 o[TEX0].w, c[7], v[NRML] ;\n" "END\n"; ; if (!glutExtensionSupported("GL_NV_vertex_program")) { printf("Sorry, this demo requires GL_NV_vertex_program\n"); exit(1); } if (!glutExtensionSupported("GL_NV_fragment_program")) { printf("Sorry, this demo requires GL_NV_fragment_program\n"); exit(1); } glGenProgramsNV(1, &FragProg); assert(FragProg > 0); glGenProgramsNV(1, &VertProg); assert(VertProg > 0); /* * Fragment program */ glLoadProgramNV(GL_FRAGMENT_PROGRAM_NV, FragProg, strlen(fragProgramText), (const GLubyte *) fragProgramText); assert(glIsProgramNV(FragProg)); glBindProgramNV(GL_FRAGMENT_PROGRAM_NV, FragProg); NAMED_PARAMETER4FV(FragProg, "Diffuse", Diffuse); NAMED_PARAMETER4FV(FragProg, "Specular", Specular); /* * Vertex program */ glLoadProgramNV(GL_VERTEX_PROGRAM_NV, VertProg, strlen(vertProgramText), (const GLubyte *) vertProgramText); assert(glIsProgramNV(VertProg)); glBindProgramNV(GL_VERTEX_PROGRAM_NV, VertProg); glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 0, GL_MODELVIEW_PROJECTION_NV, GL_IDENTITY_NV); glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 4, GL_MODELVIEW, GL_INVERSE_TRANSPOSE_NV); /* * Misc init */ glClearColor(0.3, 0.3, 0.3, 0.0); glEnable(GL_DEPTH_TEST); glEnable(GL_LIGHT0); glEnable(GL_LIGHTING); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, Diffuse); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, Specular); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 20.0); printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); printf("Press p to toggle between per-pixel and per-vertex lighting\n"); }
void ShaderScene::draw(void) { Shader *shader = Manager<Shader>::getInstance().get("MyShader"); shader->apply(); static int timer = 0; //バーテックスシェーダのunform変数angleに値をセット int timerIdx = glGetUniformLocation(shader->getVertexId(), "timer"); glUniform1i(timerIdx, timer++); timer %= 360; //Light *light = Manager<Light>::getInstance().get("MyLight"); //light->apply(); //ライトの設定 Vector4<GLfloat> position = Vector4<GLfloat>(0.0f, 0.0f, 5.0f, 1.0f);//光源の座標 Vector4<GLfloat> ambient = Vector4<GLfloat>(1.0f, 0.3f, 0.3f, 1.0f);//環境光 Vector4<GLfloat> diffuse = Vector4<GLfloat>(1.0f, 1.0f, 1.0f, 1.0f);//拡散光 Vector4<GLfloat> specular = Vector4<GLfloat>(1.0f, 1.0f, 1.0f, 1.0f);//鏡面光 Vector4<GLfloat> target = Vector4<GLfloat>(0.0f, 0.0f, 0.0f, 1.0f);//ターゲット float shininess = 100.0f; glLightfv(GL_LIGHT0, GL_AMBIENT, ambient.v); //シアン glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse.v); //イエロー glLightfv(GL_LIGHT0, GL_SPECULAR, specular.v); //マゼンタ glLightfv(GL_LIGHT0, GL_POSITION, position.v); //Vector4<GLfloat> material_ambient = Vector4<GLfloat>(1.0f, 0.3f, 0.3f, 1.0f);//環境光 //Vector4<GLfloat> material_diffuse = Vector4<GLfloat>(1.0f, 1.0f, 0.0f, 1.0f);//拡散光 //Vector4<GLfloat> material_specular = Vector4<GLfloat>(1.0f, 0.0f, 1.0f, 1.0f);//鏡面光 //float material_shininess = 1.0f; Vector4<GLfloat> material_ambient = Vector4<GLfloat>(1.0f, 1.0f, 1.0f, 1.0f);//環境光 Vector4<GLfloat> material_diffuse = Vector4<GLfloat>(0.6f, 0.1f, 0.1f, 1.0f);//拡散光 Vector4<GLfloat> material_specular = Vector4<GLfloat>(0.3f, 0.3f, 0.3f, 1.0f);//鏡面光 float material_shininess = 100.0f; glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, material_ambient.v); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, material_diffuse.v); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, material_specular.v); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, material_shininess); Surface *surface = Manager<Surface>::getInstance().get("MySurface"); surface->bindTexture(shader->getFragmentId()); //glBindTexture(GL_TEXTURE_2D, 0); //glColor3f(1.0f,0.0f,0.0f); float positions[4][3] ={ {-1.0f, -1.0f, 0.0f}, { 1.0f, -1.0f, 0.0f}, {-1.0f, 1.0f, 0.0f}, { 1.0f, 1.0f, 0.0f}, }; static int r = 0; r %= 360; //glRotatef(r++, 0, 1, 0); glPushMatrix(); glBegin(GL_TRIANGLES); glNormal3f(0.0f, 0.0f, 1.0f); glTexCoord2d(0.0, 0.0); glVertex3fv(positions[0]); glTexCoord2d(1.0, 0.0); glVertex3fv(positions[1]); glTexCoord2d(0.0, 1.0); glVertex3fv(positions[2]); glNormal3f(0.0f, 0.0f, 1.0f); glTexCoord2d(1.0, 0.0); glVertex3fv(positions[1]); glTexCoord2d(1.0, 1.0); glVertex3fv(positions[3]); glTexCoord2d(0.0, 1.0); glVertex3fv(positions[2]); glEnd(); glPopMatrix(); //glutSolidSphere(1,100,100); //glDisable(GL_TEXTURE_GEN_S); //glDisable(GL_TEXTURE_GEN_T); shader->disable(); //surface->draw(Vector2<int>(0,0)); }
// This function is taken from the examples coming with assimp void OpenGLRenderInterface::applyMaterial(const struct aiMaterial *mtl) { float c[4]; GLenum fill_mode; int ret1; aiColor4D diffuse; aiColor4D specular; aiColor4D ambient; aiColor4D emission; float shininess, strength; int two_sided; int wireframe; unsigned int max; set_float4(c, 0.8f, 0.8f, 0.8f, 1.0f); if(AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_DIFFUSE, &diffuse)) color4_to_float4(&diffuse, c); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, c); set_float4(c, 0.0f, 0.0f, 0.0f, 1.0f); if(AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_SPECULAR, &specular)) color4_to_float4(&specular, c); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, c); set_float4(c, 0.2f, 0.2f, 0.2f, 1.0f); if(AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_AMBIENT, &ambient)) color4_to_float4(&ambient, c); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, c); set_float4(c, 0.0f, 0.0f, 0.0f, 1.0f); if(AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_EMISSIVE, &emission)) color4_to_float4(&emission, c); glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, c); max = 1; ret1 = aiGetMaterialFloatArray(mtl, AI_MATKEY_SHININESS, &shininess, &max); if(ret1 == AI_SUCCESS) { max = 1; const int ret2 = aiGetMaterialFloatArray(mtl, AI_MATKEY_SHININESS_STRENGTH, &strength, &max); if(ret2 == AI_SUCCESS) glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess * strength); else glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess); } else { glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 0.0f); set_float4(c, 0.0f, 0.0f, 0.0f, 0.0f); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, c); } max = 1; if(AI_SUCCESS == aiGetMaterialIntegerArray(mtl, 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(mtl, AI_MATKEY_TWOSIDED, &two_sided, &max)) && two_sided) glEnable(GL_CULL_FACE); else glDisable(GL_CULL_FACE); }
void setMaterial(int mode) { static GLubyte *texPixels; int texWidth = 128; int texHeight = 128; GLfloat matZero[4] = {0.00, 0.00, 0.00, 1.00}; GLfloat matOne[4] = {1.00, 1.00, 1.00, 1.00}; GLfloat matEm[4] = {0.00, 0.00, 0.00, 1.00}; GLfloat matAmb[4] = {0.01, 0.01, 0.01, 1.00}; GLfloat matDiff[4] = {0.02, 0.20, 0.16, 1.00}; GLfloat matSpec[4] = {0.50, 0.50, 0.50, 1.00}; GLfloat matShine = 20.00; if ((mode == MAT_ALL) || (mode == MAT_NO_SPECULAR)) { glMaterialfv(GL_FRONT, GL_EMISSION, matEm); glMaterialfv(GL_FRONT, GL_AMBIENT, matAmb); glMaterialfv(GL_FRONT, GL_DIFFUSE, matDiff); } else { glMaterialfv(GL_FRONT, GL_EMISSION, matZero); glMaterialfv(GL_FRONT, GL_AMBIENT, matZero); glMaterialfv(GL_FRONT, GL_DIFFUSE, matZero); } if ((mode == MAT_ALL) || (mode == MAT_SPECULAR_ONLY)) { glMaterialfv(GL_FRONT, GL_SPECULAR, matSpec); glMaterialf(GL_FRONT, GL_SHININESS, matShine); } else { glMaterialfv(GL_FRONT, GL_SPECULAR, matZero); glMaterialf(GL_FRONT, GL_SHININESS, 1); } if (mode == MAT_SPECULAR_TEXTURE_ONLY) { if (texPixels == NULL) { return; } glMaterialfv(GL_FRONT, GL_SPECULAR, matOne); glMaterialf(GL_FRONT, GL_SHININESS, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); gluBuild2DMipmaps(GL_TEXTURE_2D, 4, texWidth, texHeight, GL_RGBA, GL_UNSIGNED_BYTE, texPixels); } if (mode == MAT_GEN_SPECULAR_TEXTURE) { if (texPixels == NULL) { texPixels = (GLubyte *) malloc(texWidth * texHeight * 4 * sizeof(GLubyte)); if (texPixels == NULL) { return; } } glPushAttrib(GL_ALL_ATTRIB_BITS); glClearColor(0.0, 0.0, 0.0, 1.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); setMaterial(MAT_SPECULAR_ONLY); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glOrtho(-1, 1, -1, 1, 1, 3); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); glTranslatef(0, 0, -2); glPushMatrix(); glRotatef(lightRotY, 0, 1, 0); glRotatef(lightRotX, 1, 0, 0); setLight(); glPopMatrix(); glEnable(GL_DEPTH_TEST); glEnable(GL_LIGHTING); glViewport(0, 0, 128, 128); glClearColor(.25, .25, .25, .25); glClear(GL_COLOR_BUFFER_BIT); drawSphere(128, 128, 1.0); glMatrixMode(GL_PROJECTION); glPopMatrix(); glMatrixMode(GL_MODELVIEW); glPopMatrix(); glReadPixels(0, 0, texWidth, texHeight, GL_RGBA, GL_UNSIGNED_BYTE, texPixels); glPopAttrib(); } }
inline void glMaterial( const GLenum & face, const GLenum & pname, const GLfloat & param ) { glMaterialf( face, pname, param ); }
void MarillModel::enableShade(){ GLfloat mat_specular[]={1.0, 1.0, 1.0, 1.0}; GLfloat mat_diffuse[]={1.0, 1.0, 1.0, 1.0}; GLfloat mat_ambient[]={1.0, 1.0, 1.0, 1.0}; GLfloat mat_shininess={100.0}; GLfloat light_ambient[]={0.0, 0.0, 0.0, 1.0}; GLfloat light_diffuse[]={1.0, 1.0, 1.0, 1.0}; GLfloat light_specular[]={1.0, 1.0, 1.0, 1.0}; GLfloat light_position[]={10.0, 10.0, 10.0, 0.0}; glLightfv(GL_LIGHT0, GL_POSITION, light_position); glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse); glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular); glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialf(GL_FRONT, GL_SHININESS, mat_shininess); glShadeModel(GL_SMOOTH); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glDepthFunc(GL_LEQUAL); /* allocate quadrics with filled drawing style */ hM=gluNewQuadric(); gluQuadricDrawStyle(h, GLU_FILL); nM=gluNewQuadric(); gluQuadricDrawStyle(n, GLU_FILL); tM=gluNewQuadric(); gluQuadricDrawStyle(t, GLU_FILL); jpM=gluNewQuadric(); gluQuadricDrawStyle(jp, GLU_FILL); luaM=gluNewQuadric(); gluQuadricDrawStyle(lua, GLU_FILL); llaM=gluNewQuadric(); gluQuadricDrawStyle(lla, GLU_FILL); lhndM=gluNewQuadric(); gluQuadricDrawStyle(lhnd, GLU_FILL); rhndM=gluNewQuadric(); gluQuadricDrawStyle(rhnd, GLU_FILL); rftM=gluNewQuadric(); gluQuadricDrawStyle(rft, GLU_FILL); lftM=gluNewQuadric(); gluQuadricDrawStyle(lft, GLU_FILL); ruaM=gluNewQuadric(); gluQuadricDrawStyle(rua, GLU_FILL); rlaM=gluNewQuadric(); gluQuadricDrawStyle(rla, GLU_FILL); lulM=gluNewQuadric(); gluQuadricDrawStyle(lul, GLU_FILL); lllM=gluNewQuadric(); gluQuadricDrawStyle(lll, GLU_FILL); rulM=gluNewQuadric(); gluQuadricDrawStyle(rul, GLU_FILL); rllM=gluNewQuadric(); gluQuadricDrawStyle(rll, GLU_FILL); }
int compileOBJList(struct OBJ_Model * obj) { /* create or replace a display list with : void glNewList( GLuint list, GLenum mode ) void glEndList( void ) where: list Specifies the display-list name. mode Specifies the compilation mode, which can be GL_COMPILE or GL_COMPILE_AND_EXECUTE. Display lists are groups of GL commands that have been stored for subsequent execution. Display lists are created with glNewList. All subsequent commands are placed in the display list, in the order issued, until glEndList is called. glNewList has two arguments. The first argument, list, is a positive integer that becomes the unique name for the display list. Names can be created and reserved with glGenLists */ glPushAttrib(GL_ALL_ATTRIB_BITS); long unsigned int i,j; //generate an empty display list, and save its id in dispList obj->dispList=glGenLists(1); glNewList(obj->dispList,GL_COMPILE); for(i=0; i<obj->numGroups; i++) { if (obj->matList!=0) { //We might not have a material with our object! if( obj->matList[ obj->groups[i].material].hasTex) { if( obj->matList[ obj->groups[i].material].ldText>0) { glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, obj->matList[ obj->groups[i].material].ldText); } } else { //glDisable(GL_TEXTURE_2D); } glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, obj->matList[ obj->groups[i].material].ambient); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, obj->matList[ obj->groups[i].material].diffuse); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, obj->matList[ obj->groups[i].material].specular); #if DISABLE_SHININESS glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 0.0 ); #else glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, obj->matList[ obj->groups[i].material].shine); #endif if( ( obj->groups[i].hasTex) ==0 ) { InitAutoTex(); } else { glDisable(GL_TEXTURE_GEN_S); glDisable(GL_TEXTURE_GEN_T); } } else { //No Matterials , No Textures glDisable(GL_TEXTURE_GEN_S); glDisable(GL_TEXTURE_GEN_T); glDisable(GL_TEXTURE_2D); } doOBJDrawCallsForGroup(obj,i); }//FOR I glEndList(); glPopAttrib(); return 1; }
bool ModelRenderPass::init(Model *m) { // May aswell check that we're going to render the geoset before doing all this crap. if (m->showGeosets[geoset]) { // COLOUR // Get the colour and transparency and check that we should even render ocol = Vec4D(1.0f, 1.0f, 1.0f, m->trans); ecol = Vec4D(0.0f, 0.0f, 0.0f, 0.0f); //if (m->trans == 1.0f) // return false; // emissive colors if (color!=-1 && m->colors[color].color.uses(0)) { Vec3D c = m->colors[color].color.getValue(0,m->animtime); if (m->colors[color].opacity.uses(m->anim)) { float o = m->colors[color].opacity.getValue(m->anim,m->animtime); ocol.w = o; } if (unlit) { ocol.x = c.x; ocol.y = c.y; ocol.z = c.z; } else { ocol.x = ocol.y = ocol.z = 0; } ecol = Vec4D(c, ocol.w); glMaterialfv(GL_FRONT, GL_EMISSION, ecol); } // opacity if (opacity!=-1) { if (m->transparency[opacity].trans.uses(0)) ocol.w *= m->transparency[opacity].trans.getValue(0, m->animtime); } // exit and return false before affecting the opengl render state if (!((ocol.w > 0) && (color==-1 || ecol.w > 0))) return false; // TEXTURE // bind to our texture GLuint bindtex = 0; if (m->specialTextures[tex]==-1) bindtex = m->textures[tex]; else bindtex = m->replaceTextures[m->specialTextures[tex]]; glBindTexture(GL_TEXTURE_2D, bindtex); // -- // TODO: Add proper support for multi-texturing. // blend mode switch (blendmode) { case BM_OPAQUE: // 0 break; case BM_TRANSPARENT: // 1 glEnable(GL_ALPHA_TEST); glAlphaFunc(GL_GEQUAL,0.7f); break; case BM_ALPHA_BLEND: // 2 glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); break; case BM_ADDITIVE: // 3 glEnable(GL_BLEND); glBlendFunc(GL_SRC_COLOR, GL_ONE); break; case BM_ADDITIVE_ALPHA: // 4 glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE); break; case BM_MODULATE: // 5 glEnable(GL_BLEND); glBlendFunc(GL_DST_COLOR, GL_SRC_COLOR); break; case BM_MODULATE2: // 6 glEnable(GL_BLEND); glBlendFunc(GL_DST_COLOR,GL_SRC_COLOR); break; default: gLog("Error: Unknown blendmode: %d\n", blendmode); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); } //if (cull) // glEnable(GL_CULL_FACE); // Texture wrapping around the geometry if (swrap) glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT); if (twrap) glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT); // no writing to the depth buffer. if (noZWrite) glDepthMask(GL_FALSE); if (unlit) { glDisable(GL_LIGHTING); // unfogged = unlit? glDisable(GL_FOG); } // Environmental mapping, material, and effects if (useEnvMap) { // Turn on the 'reflection' shine, using 18.0f as that is what WoW uses based on the reverse engineering // This is now set in InitGL(); - no need to call it every render. glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 18.0f); // env mapping glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); const GLint maptype = GL_SPHERE_MAP; //const GLint maptype = GL_REFLECTION_MAP_ARB; glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, maptype); glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, maptype); } if (texanim!=-1) { glMatrixMode(GL_TEXTURE); glPushMatrix(); m->texAnims[texanim].setup(texanim); } // color glColor4fv(ocol); //glMaterialfv(GL_FRONT, GL_SPECULAR, ocol); // don't use lighting on the surface if (unlit) glDisable(GL_LIGHTING); if (blendmode<=1 && ocol.w<1.0f) glEnable(GL_BLEND); return true; } return false; }
void Car::draw() { glPushMatrix(); GameObject::draw(); glRotated(_movementDirection, 0, 0, 1); glPushMatrix(); glTranslated(0, 0, 0.05); //---------------------------------------------------- // Chassis principal //---------------------------------------------------- /* Apply the material */ glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, MATERIAL_BODY_AMB); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MATERIAL_BODY_DIFF); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, MATERIAL_BODY_SPEC); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, MATERIAL_BODY_SHININESS); glColor3f(1, 0, 0); glBegin(GL_QUAD_STRIP); glNormal3d(0, -0.196116135, -0.980580676); glVertex3d(0.35, -0.25, 0); glNormal3d(0, 0.196116135, -0.980580676); glVertex3d(0.35, 0.25, 0); glNormal3d(0.705345616, -0.070534562, -0.705345616); glVertex3d(0.5, -0.20, 0.05); glNormal3d(0.705345616, 0.070534562, -0.705345616); glVertex3d(0.5, 0.20, 0.05); glNormal3d(0.705345616, -0.070534562, 0.705345616); glVertex3d(0.5, -0.20, 0.11); glNormal3d(0.705345616, 0.070534562, 0.705345616); glVertex3d(0.5, 0.20, 0.11); glNormal3d(0.19245009, -0.19245009, 0.962250449); glVertex3d(0.35, -0.25, 0.15); glNormal3d(0.19245009, 0.19245009, 0.962250449); glVertex3d(0.35, 0.25, 0.15); glNormal3d(-0.282216261, -0.188144174, 0.940720868); glVertex3d(0, -0.20, 0.15); glNormal3d(-0.282216261, 0.188144174, 0.940720868); glVertex3d(0, 0.20, 0.15); glNormal3d(0, -0.099503719, 0.99503719); glVertex3d(-0.4, -0.10, 0.05); glNormal3d(0, 0.099503719, 0.99503719); glVertex3d(-0.4, 0.10, 0.05); glEnd(); //---------------------------------------------------- // Chassis lateral //---------------------------------------------------- _drawSide(1); _drawSide(-1); //---------------------------------------------------- // Aileron Frontal //---------------------------------------------------- glColor3f(1, 0, 0); glBegin(GL_QUADS); glVertex3d(-0.4, 0.30, 0.05); glVertex3d(-0.55, 0.25, 0.05); glVertex3d(-0.55, 0.25, 0.00); glVertex3d(-0.4, 0.30, 0.0); glEnd(); glBegin(GL_QUADS); glVertex3d(-0.4, -0.30, 0.0); glVertex3d(-0.55, -0.25, 0.00); glVertex3d(-0.55, -0.25, 0.05); glVertex3d(-0.4, -0.30, 0.05); glEnd(); // Starts at the bottom-front side glBegin(GL_QUAD_STRIP); glNormal3d(-0.707106781, 0, -0.707106781); glVertex3d(-0.55, -0.25, 0.00); glNormal3d(-0.707106781, 0, -0.707106781); glVertex3d(-0.55, 0.25, 0.00); glNormal3d(-0.622799155, -0.077849894, 0.778498944); glVertex3d(-0.55, -0.25, 0.05); glNormal3d(-0.622799155, 0.077849894, 0.778498944); glVertex3d(-0.55, 0.25, 0.05); glNormal3d(0, 0, 1); glVertex3d(-0.4, -0.30, 0.05); glNormal3d(0, 0, 1); glVertex3d(-0.4, 0.30, 0.05); glNormal3d(-0.707106781, 0, -0.707106781); glVertex3d(-0.4, -0.30, 0.0); glNormal3d(-0.707106781, 0, -0.707106781); glVertex3d(-0.4, 0.30, 0.05); glEnd(); //---------------------------------------------------- // Cockpit //---------------------------------------------------- /* Apply cockpit material */ glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, MATERIAL_COCKPIT_AMB); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MATERIAL_COCKPIT_DIFF); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, MATERIAL_COCKPIT_SPEC); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, MATERIAL_COCKPIT_SHININESS); glColor3f(0, .5, 1); _drawCockpit(1); _drawCockpit(-1); //---------------------------------------------------- // Rodas //---------------------------------------------------- // Apply wheel material glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, MATERIAL_WHEEL_AMB); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MATERIAL_WHEEL_DIFF); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, MATERIAL_WHEEL_SPEC); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, MATERIAL_WHEEL_SHININESS); glColor3f(0, 0, 0); glPushMatrix(); // Rodas dianteiras _drawWheel(-.2, .275, .1); _drawWheel(-.2, -.275, .1); // Rodas traseiras _drawWheel(.45, .325, .1); _drawWheel(.45, -.325, .1); glPopMatrix(); glPopMatrix(); };
void G308_Geometry::RenderGeometry() { glCallList(m_glGeomListEyes); /* glColor3f(1.0f,0.0f,0.0f); glTexCoordPointer(3, GL_FLOAT, sizeof(GLfloat)*8, (float*)(sizeof(GLfloat)*5)); glNormalPointer(GL_FLOAT, sizeof(GLfloat)*8, (float*)(sizeof(GLfloat)*3)); glVertexPointer(3, GL_FLOAT, sizeof(GLfloat)*8, NULL); // Bind the indices of vertices and draw triangle strip glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexVBOID); glDrawElements(GL_TRIANGLES, m_nNumPolygon*3, GL_UNSIGNED_INT, NULL); //sizeof(GLuint)*m_nNumPolygon*3 */ // 1rst attribute buffer : vertices glEnableClientState(GL_NORMAL_ARRAY); glEnableClientState(GL_VERTEX_ARRAY); glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexbuffer); glVertexPointer(3, GL_FLOAT, sizeof(GLfloat)*6, 0); glNormalPointer(GL_FLOAT, sizeof(GLfloat)*6, (float*)(sizeof(GLfloat)*3)); /*glVertexAttribPointer( 0, // attribute 0. No particular reason for 0, but must match the layout in the shader. 3, // size GL_FLOAT, // type GL_FALSE, // normalized? 0, // stride (void*)0 // array buffer offset );*/ //float colorAmbt[4] = { 0.53125, 0.53125, 0.53125, 1.0 }; float colorAmbt[4] = { 0.1, 0.1, 0.1, 1.0 }; //float colorDiff[4] = { 0.3775, 0.3775, 0.3775, 1.0 }; //float colorSpec[4] = { 0.5, 0.5, 0.5, 1.0 }; float colorDiff[4] = { 0.24, 0.16, 0.09, 1.0 }; float colorSpec[4] = { 0.1, 0.1, 0.1, 1.0 }; float colorEmis[4] = { 0.0, 0.0, 0.0, 1.0 }; glMaterialfv(GL_FRONT, GL_AMBIENT, colorAmbt); glMaterialfv(GL_FRONT, GL_DIFFUSE, colorDiff); glMaterialfv(GL_FRONT, GL_SPECULAR, colorSpec); glMaterialfv(GL_FRONT, GL_EMISSION, colorEmis); glMaterialf(GL_FRONT, GL_SHININESS, 0.2*20); glColor4fv(colorDiff); glPushMatrix(); glTranslatef(pivot.x,pivot.y,pivot.z); //glDrawElements(GL_TRIANGLES, m_nNumPolygon*6, GL_UNSIGNED_INT, NULL); // Starting from vertex 0; 3 vertices total -> 1 triangle glDrawElements(GL_TRIANGLES, m_nNumPolygon_Head*3, GL_UNSIGNED_INT, NULL); // Starting from vertex 0; 3 vertices total -> 1 triangle glPopMatrix(); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); // draw control points glColor4f(0.7,0,0,1); glMaterialfv(GL_FRONT, GL_AMBIENT, colorAmbt); if (showCtrl) { glPushMatrix(); glTranslatef(pivot.x,pivot.y,pivot.z); for (int i=0; i<cp_num; i++) { glPushMatrix(); glPushName(cp_numbers[i]); glTranslatef(m_pDisplaced[cp_numbers[i]].x+controlPointDisplacementX[i], m_pDisplaced[cp_numbers[i]].y+controlPointDisplacementY[i], m_pDisplaced[cp_numbers[i]].z+controlPointDisplacementZ[i]); glutSolidSphere(0.003, 100, 100); //if (cp_numbers[i]==17784) glutSolidSphere(0.01, 100, 100); //glutSolidSphere(distances[cp_numbers[i]-EYES]*0.003, 100, 100); glPopName(); glPopMatrix(); } glPopMatrix(); } /* glPushMatrix(); glTranslatef(pivot.x,pivot.y,pivot.z); for (int i=EYES; i<numVert; i++) { glPushMatrix(); glTranslatef(m_pVertexArray[i].x,m_pVertexArray[i].y,m_pVertexArray[i].z); glutSolidSphere(distances[i-EYES]*0.003, 100, 100); glPopMatrix(); } glPopMatrix(); */ /* glPushMatrix(); glColor3f(1.0,0.0,0.0); glTranslatef(0.052729, 0.099127, 0.107657); glutSolidSphere(0.001, 100, 100); glPopMatrix(); glPushMatrix(); glColor3f(1.0,0.0,0.0); glTranslatef(0.000515, 0.093231, 0.115924 ); glutSolidSphere(0.001, 100, 100); glPopMatrix(); glPushMatrix(); glColor3f(1.0,0.0,0.0); glTranslatef(0.026212, 0.098129, 0.115766); glutSolidSphere(0.001, 100, 100); glPopMatrix();*/ // printf(" %d ", sel_vrt); if (sel_vrt!=-1) { /* glPushMatrix(); glColor3f(1.0,0.0,0.0); if (sel_cnt==1) glTranslatef(m_pVertexArray[m_pTriangles[sel_vrt].v1].x+pivot.x, m_pVertexArray[m_pTriangles[sel_vrt].v1].y+pivot.y, m_pVertexArray[m_pTriangles[sel_vrt].v1].z+pivot.z); else if (sel_cnt==2) glTranslatef(m_pVertexArray[m_pTriangles[sel_vrt].v2].x+pivot.x, m_pVertexArray[m_pTriangles[sel_vrt].v2].y+pivot.y, m_pVertexArray[m_pTriangles[sel_vrt].v2].z+pivot.z); else if (sel_cnt==3) glTranslatef(m_pVertexArray[m_pTriangles[sel_vrt].v3].x+pivot.x, m_pVertexArray[m_pTriangles[sel_vrt].v3].y+pivot.y, m_pVertexArray[m_pTriangles[sel_vrt].v3].z+pivot.z); glutSolidSphere(0.002, 100, 100); glPopMatrix(); */ //printf (" %d ( %f %f %f ) ", sel_vrt, m_pVertexArray[m_pTriangles[sel_vrt].v1].x, m_pVertexArray[m_pTriangles[sel_vrt].v1].y, m_pVertexArray[m_pTriangles[sel_vrt].v1].z); int vrt1=m_pTriangles[sel_vrt].v1, vrt2=m_pTriangles[sel_vrt].v2, vrt3=m_pTriangles[sel_vrt].v3; glPushMatrix(); double rad = 0.005; double hgt = 0.01; double scl = 0.005; // how far is dragger from the surface int cp; for (int i=0; i<cp_num; i++) if (cp_numbers[i]==sel_vrt) cp=i; glTranslatef(m_pDisplaced[sel_vrt].x+scl*m_pNormalArray[sel_vrt].x+controlPointDisplacementX[cp]+pivot.x, m_pDisplaced[sel_vrt].y+scl*m_pNormalArray[sel_vrt].y+controlPointDisplacementY[cp]+pivot.y, m_pDisplaced[sel_vrt].z+scl*m_pNormalArray[sel_vrt].z+controlPointDisplacementZ[cp]+pivot.z); // NEW /* if (sel_cnt==1) glTranslatef(m_pDisplaced[vrt1].x+scl*m_pNormalArray[vrt1].x+pivot.x, m_pDisplaced[vrt1].y+scl*m_pNormalArray[vrt1].y+pivot.y, m_pDisplaced[vrt1].z+scl*m_pNormalArray[vrt1].z+pivot.z); else if (sel_cnt==2) glTranslatef(m_pDisplaced[vrt2].x+scl*m_pNormalArray[vrt2].x+pivot.x, m_pDisplaced[vrt2].y+scl*m_pNormalArray[vrt2].y+pivot.y, m_pDisplaced[vrt2].z+scl*m_pNormalArray[vrt2].z+pivot.z); else if (sel_cnt==3) glTranslatef(m_pDisplaced[vrt3].x+scl*m_pNormalArray[vrt3].x+pivot.x, m_pDisplaced[vrt3].y+scl*m_pNormalArray[vrt3].y+pivot.y, m_pDisplaced[vrt3].z+scl*m_pNormalArray[vrt3].z+pivot.z); */ GLUquadric* q = gluNewQuadric(); gluQuadricNormals(q, GLU_SMOOTH); glPushMatrix(); // Z-axis glPushName(-4); glColor3f(0,0,0.5); gluCylinder(q,rad/2,rad/2,hgt,100,100); glTranslatef(0,0,hgt); glutSolidCone(rad, rad, 100, 100); glPopName(); glPopMatrix(); glPushMatrix(); // Y-axis glPushName(-3); glColor3f(0,0.5,0); glRotatef(-90,1,0,0); gluCylinder(q,rad/2,rad/2,hgt,100,100); glTranslatef(0,0,hgt); glutSolidCone(rad, rad, 100, 100); glPopName(); glPopMatrix(); glPushMatrix(); // X-axis glPushName(-2); glColor3f(0.5,0,0); glRotatef(90,0,1,0); gluCylinder(q,rad/2,rad/2,hgt,100,100); glTranslatef(0,0,hgt); glutSolidCone(rad, rad, 100, 100); glPopName(); glPopMatrix(); gluDeleteQuadric(q); glPopMatrix(); } }
//int traceRenderEntity = 0; static void RenderEntityF(entity_t* entity) { // printf("RenderEntityF Player1=%p\n",players[0].entity.material); // printf("RenderEntityF Player2=%p\n",players[1].entity.material); glPushMatrix(); //if (traceRenderEntity) { //entity->matrix[13] = 110; // printf("[RenderEntityF] entity id=%d\n",entity->uid); // printf("[RenderEntityF] entity pos=[%.2f,%.2f,%.2f,%.2f]\n",entity->matrix[12],entity->matrix[13],entity->matrix[14],entity->matrix[15]); //matrix_print(entity->matrix); } glMultMatrixf(entity->matrix); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, entity->material->shininess); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, entity->material->specularColor); SetTextureF(entity->material->textures[TEXTURE_DIFFUSE].textureId); //Disabling blending for now /* if (entity->material->hasAlpha ) { if (!renderer.isBlending) { renderer.isBlending = 1; glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); STATS_AddBlendingSwitch(); } } else { if (renderer.isBlending) { renderer.isBlending = 0; glDisable(GL_BLEND); STATS_AddBlendingSwitch(); } } */ if (entity->model->memLocation == MD5_MEMLOC_VRAM) { glBindBuffer(GL_ARRAY_BUFFER, entity->model->vboId); glVertexPointer (3, GL_FLOAT, sizeof(vertex_t), (char *)NULL + VERTEX_T_DELTA_TO_POS); glNormalPointer(GL_SHORT, sizeof(vertex_t), (char *)NULL + VERTEX_T_DELTA_TO_NORMAL); glTexCoordPointer (2, GL_SHORT, sizeof(vertex_t), (char *)NULL + VERTEX_T_DELTA_TO_TEXT); } else { glTexCoordPointer (2, GL_SHORT, sizeof(vertex_t), entity->model->vertexArray->text); glVertexPointer (3, GL_FLOAT, sizeof(vertex_t), entity->model->vertexArray->pos); glNormalPointer(GL_SHORT, sizeof(vertex_t), entity->model->vertexArray->normal); } if (entity->usage == ENT_PARTIAL_DRAW) { glDrawElements (GL_TRIANGLES, entity->numIndices, GL_UNSIGNED_SHORT, entity->indices); //glDrawArrays(GL_TRIANGLES,0,3); //glDrawElements (GL_TRIANGLES, 0, GL_UNSIGNED_SHORT, entity->indices); STATS_AddTriangles(entity->numIndices/3); } else { glDrawElements (GL_TRIANGLES, entity->model->numIndices, GL_UNSIGNED_SHORT, entity->model->indices); //glDrawArrays(GL_TRIANGLES,0,3); //glDrawElements (GL_TRIANGLES, 0, GL_UNSIGNED_SHORT, entity->model->indices); STATS_AddTriangles(entity->model->numIndices/3); } //RenderNormalsF(entity->model); glPopMatrix(); }
ENTRYPOINT void init_glblur (ModeInfo *mi) { glblur_configuration *bp; int wire = MI_IS_WIREFRAME(mi); MI_INIT (mi, bps); bp = &bps[MI_SCREEN(mi)]; bp->glx_context = init_GL(mi); reshape_glblur (mi, MI_WIDTH(mi), MI_HEIGHT(mi)); clear_gl_error(); /* WTF? sometimes "invalid op" from glViewport! */ if (!wire) { GLfloat gamb[4]= {0.2, 0.2, 0.2, 1.0}; GLfloat pos[4] = {0.0, 5.0, 10.0, 1.0}; GLfloat amb[4] = {0.2, 0.2, 0.2, 1.0}; GLfloat dif[4] = {0.3, 0.3, 0.3, 1.0}; GLfloat spc[4] = {0.8, 0.8, 0.8, 1.0}; GLfloat shiny = 128; glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); glEnable(GL_NORMALIZE); glShadeModel(GL_SMOOTH); glLightModelfv (GL_LIGHT_MODEL_AMBIENT, gamb); glLightfv(GL_LIGHT0, GL_POSITION, pos); glLightfv(GL_LIGHT0, GL_AMBIENT, amb); glLightfv(GL_LIGHT0, GL_DIFFUSE, dif); glLightfv(GL_LIGHT0, GL_SPECULAR, spc); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glMaterialf(GL_FRONT, GL_SHININESS, shiny); } { Bool spinx=False, spiny=False, spinz=False; double spin_speed = 0.9; double wander_speed = 0.06; char *s = do_spin; while (*s) { if (*s == 'x' || *s == 'X') spinx = True; else if (*s == 'y' || *s == 'Y') spiny = True; else if (*s == 'z' || *s == 'Z') spinz = True; else if (*s == '0') ; else { fprintf (stderr, "%s: spin must contain only the characters X, Y, or Z (not \"%s\")\n", progname, do_spin); exit (1); } s++; } bp->rot = make_rotator (spinx ? spin_speed : 0, spiny ? spin_speed : 0, spinz ? spin_speed : 0, 1.0, do_wander ? wander_speed : 0, False); bp->trackball = gltrackball_init (True); } if (blursize < 0) blursize = 0; if (blursize > 200) blursize = 200; bp->ncolors = 128; bp->colors0 = (XColor *) calloc(bp->ncolors, sizeof(XColor)); bp->colors1 = (XColor *) calloc(bp->ncolors, sizeof(XColor)); bp->colors2 = (XColor *) calloc(bp->ncolors, sizeof(XColor)); bp->colors3 = (XColor *) calloc(bp->ncolors, sizeof(XColor)); make_smooth_colormap (0, 0, 0, bp->colors0, &bp->ncolors, False, 0, False); make_smooth_colormap (0, 0, 0, bp->colors1, &bp->ncolors, False, 0, False); make_smooth_colormap (0, 0, 0, bp->colors2, &bp->ncolors, False, 0, False); make_smooth_colormap (0, 0, 0, bp->colors3, &bp->ncolors, False, 0, False); bp->ccolor = 0; bp->obj_dlist0 = glGenLists (1); bp->obj_dlist1 = glGenLists (1); bp->obj_dlist2 = glGenLists (1); bp->obj_dlist3 = glGenLists (1); bp->scene_dlist1 = glGenLists (1); bp->scene_dlist2 = glGenLists (1); init_texture (mi); generate_object (mi); }
void renderSphere(int sphere) { // weißes Licht GLfloat param0[] = { 1.0, 1.0, 1.0, 1.0 }; // rotes Licht GLfloat param1[] = { 0.9, 0.0, 0.0, 1.0 }; // grünes Licht GLfloat param2[] = { 0.0, 0.9, 0.0, 1.0 }; GLfloat mat[3]; // Materialkonstanten für Messing mat[0] = 0.33; mat[1] = 0.22; mat[2] = 0.3; glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mat); mat[0] = 0.78; mat[1] = 0.57; mat[2] = 0.11; glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat); mat[0] = 0.99; mat[1] = 0.94; mat[2] = 0.81; glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 27.9); if (sphere == 0) { // Setzen der Farbe der 0.Lichtquelle glLightfv(GL_LIGHT0, GL_DIFFUSE, param0); // Setzen der Farbe der 1.Lichtquelle glLightfv(GL_LIGHT1, GL_DIFFUSE, param0); glPushMatrix(); glTranslatef(-3.5, 0, -40); // Messing-Kugel mit weißem Licht glutSolidSphere(3.0, 50, 50); glPopMatrix(); } else { glPushMatrix(); // Setzen der Farbe der 0.Lichtquelle glLightfv(GL_LIGHT0, GL_DIFFUSE, param1); // Setzen der Farbe der 1.Lichtquelle glLightfv(GL_LIGHT1, GL_DIFFUSE, param2); glTranslatef(3.5, 0, -40); // Messing-Kugel mit farbigem Licht glutSolidSphere(3.0, 50, 50); glPopMatrix(); } }
void ccOctree::RenderOctreeAs( CC_OCTREE_DISPLAY_TYPE octreeDisplayType, CCLib::DgmOctree* theOctree, unsigned char level, ccGenericPointCloud* theAssociatedCloud, int &octreeGLListID, bool updateOctreeGLDisplay) { if (!theOctree || !theAssociatedCloud) return; glPushAttrib(GL_LIGHTING_BIT); if (octreeDisplayType==WIRE) { //cet affichage demande trop de memoire pour le stocker sous forme de liste OpenGL //donc on doit le generer dynamiquement glDisable(GL_LIGHTING); //au cas où la lumiere soit allumee glColor3ubv(ccColor::green); theOctree->executeFunctionForAllCellsAtLevel(level,&DrawCellAsABox,NULL); } else { glDrawParams glParams; theAssociatedCloud->getDrawingParameters(glParams); if (glParams.showNorms) { //DGM: Strangely, when Qt::renderPixmap is called, the OpenGL version is sometimes 1.0! glEnable((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2 ? GL_RESCALE_NORMAL : GL_NORMALIZE)); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, CC_DEFAULT_CLOUD_AMBIENT_COLOR ); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, CC_DEFAULT_CLOUD_SPECULAR_COLOR ); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, CC_DEFAULT_CLOUD_DIFFUSE_COLOR ); glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, CC_DEFAULT_CLOUD_EMISSION_COLOR ); glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, CC_DEFAULT_CLOUD_SHININESS); glEnable(GL_LIGHTING); glEnable(GL_COLOR_MATERIAL); glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE); } if (!glParams.showColors) glColor3ubv(ccColor::white); if (updateOctreeGLDisplay || octreeGLListID<0) { if (octreeGLListID<0) octreeGLListID = glGenLists(1); else if (glIsList(octreeGLListID)) glDeleteLists(octreeGLListID,1); glNewList(octreeGLListID,GL_COMPILE); if (octreeDisplayType == MEAN_POINTS) { void* additionalParameters[2] = { (void*)&glParams, (void*)theAssociatedCloud, }; glBegin(GL_POINTS); theOctree->executeFunctionForAllCellsAtLevel(level,&DrawCellAsAPoint,additionalParameters,0,"Render octree"); glEnd(); } else { //by default we use a box as primitive PointCoordinateType cs = theOctree->getCellSize(level); CCVector3 dims(cs,cs,cs); ccBox box(dims); box.showColors(glParams.showColors || glParams.showSF); box.showNormals(glParams.showNorms); //trick: replace all normal indexes so that they point on the first one { if (box.arePerTriangleNormalsEnabled()) for (unsigned i=0;i<box.size();++i) box.setTriangleNormalIndexes(i,0,0,0); } //fake context CC_DRAW_CONTEXT context; context.flags = CC_DRAW_3D | CC_DRAW_FOREGROUND| CC_LIGHT_ENABLED; context._win = 0; void* additionalParameters[4] = { (void*)&glParams, (void*)theAssociatedCloud, (void*)&box, (void*)&context }; theOctree->executeFunctionForAllCellsAtLevel(level,&DrawCellAsAPrimitive,additionalParameters,0); } glEndList(); } glCallList(octreeGLListID); if (glParams.showNorms) { glDisable(GL_COLOR_MATERIAL); glDisable((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2 ? GL_RESCALE_NORMAL : GL_NORMALIZE)); glDisable(GL_LIGHTING); } } glPopAttrib(); }
int GLshape::doCompile(bool isWireFrameMode) { if (isWireFrameMode){ if (m_wireFrameList) glDeleteLists(m_wireFrameList, 1); }else{ if (m_shadingList) glDeleteLists(m_shadingList, 1); } //std::cout << "doCompile" << std::endl; int list = glGenLists(1); glNewList(list, GL_COMPILE); if (m_solid){ glEnable(GL_CULL_FACE); }else{ glDisable(GL_CULL_FACE); } double scale[3]; for (int i=0; i<3; i++){ scale[i] = sqrt(m_trans[i]*m_trans[i] +m_trans[i+4]*m_trans[i+4] +m_trans[i+8]*m_trans[i+8]); } bool drawTexture = false; if (!isWireFrameMode && m_texture && !m_highlight){ drawTexture = true; glGenTextures(1, &m_textureId); glBindTexture(GL_TEXTURE_2D, m_textureId); if (m_texture->repeatS){ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); }else{ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); } if (m_texture->repeatT){ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); }else{ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); } int format; if (m_texture->numComponents == 3){ format = GL_RGB; }else if (m_texture->numComponents == 4){ format = GL_RGBA; } glPixelStorei(GL_UNPACK_ALIGNMENT, 1); gluBuild2DMipmaps(GL_TEXTURE_2D, 3, m_texture->width, m_texture->height, format, GL_UNSIGNED_BYTE, &m_texture->image[0]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glEnable(GL_TEXTURE_2D); } if (!isWireFrameMode) glBegin(GL_TRIANGLES); if (m_highlight){ float red[] = {1,0,0,1}; glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, red); }else{ glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, m_diffuse); //glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, m_specular); glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, m_shininess); } for(size_t j=0; j < m_triangles.size(); ++j){ if (isWireFrameMode) glBegin(GL_LINE_LOOP); if (!m_normalPerVertex){ int p; if (m_normalIndices.size() == 0){ p = j; }else{ p = m_normalIndices[j]; } if (p < m_normals.size()){ const Eigen::Vector3f &n = m_normals[p]; glNormal3f(scale[0]*n[0], scale[1]*n[1], scale[2]*n[2]); } } for(int k=0; k < 3; ++k){ long vertexIndex = m_triangles[j][k]; if (m_normalPerVertex){ int p; if (m_normalIndices.size() == 0){ p = vertexIndex; }else{ p = m_normalIndices[j*3+k]; } const Eigen::Vector3f &n = m_normals[p]; glNormal3f(scale[0]*n[0], scale[1]*n[1], scale[2]*n[2]); } if (drawTexture){ int texCoordIndex = m_textureCoordIndices[j*3+k]; glTexCoord2d(m_textureCoordinates[texCoordIndex][0], -m_textureCoordinates[texCoordIndex][1]); } glVertex3fv(m_vertices[vertexIndex].data()); } if (isWireFrameMode) glEnd(); // GL_LINE_LOOP } if (!isWireFrameMode) glEnd(); // GL_TRIANGLES if (drawTexture) glDisable(GL_TEXTURE_2D); // point cloud if (!m_triangles.size()&&m_vertices.size()){ glPointSize(3); glDisable(GL_LIGHTING); glBegin(GL_POINTS); for (size_t i=0; i<m_vertices.size(); i++){ if (m_colors.size()>=m_vertices.size()) glColor3fv(m_colors[i].data()); glVertex3fv(m_vertices[i].data()); } glEnd(); glEnable(GL_LIGHTING); } glEndList(); return list; }
GLint makebclockhousing(void){ GLuint dlistindex; GLUquadricObj * pole; int iterator; GLuint banklistindex; GLuint connectlistindex; GLuint secconnectlistindex; GLfloat steel_ambient[] = {0.19225, 0.19225, 0.19225, 1.0}; GLfloat steel_diffuse[] = {0.50754, 0.50754, 0.50754, 1.0}; GLfloat steel_specular[] = {0.508273, 0.508273, 0.508273, 1.0}; GLfloat steel_emission[] = {0.0, 0.0, 0.0, 1.0}; GLfloat steel_shininess = 0.4; banklistindex = makebankdlist(); connectlistindex = makeconnectdlist(); secconnectlistindex = makesecconnectdlist(); pole = gluNewQuadric(); gluQuadricCallback(pole, GLU_ERROR, (_GLUfuncptr)errorCallback); gluQuadricDrawStyle(pole, GLU_FILL); gluQuadricNormals(pole, GLU_SMOOTH); dlistindex = glGenLists(1); glNewList(dlistindex, GL_COMPILE); glMaterialfv(GL_FRONT, GL_AMBIENT, steel_ambient); glMaterialfv(GL_FRONT, GL_DIFFUSE, steel_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, steel_specular); glMaterialfv(GL_FRONT, GL_EMISSION, steel_emission); glMaterialf(GL_FRONT, GL_SHININESS, steel_shininess * 128.0); /* draw banks, including seconds */ glPushMatrix(); glTranslatef(0.0, -10., 0.); for (iterator = 0; iterator < 4; iterator++) { glCallList(banklistindex); glTranslatef(0.0, 5.0, 0.); } glTranslatef(0.0, 0., -1.0); gluCylinder(pole, 2.5, 2.5, 2, 24, 16); glTranslatef( 0.0, 0.0, 2.0); gluDisk(pole, 0, 2.5, 24, 16); glPopMatrix(); /* draw connectors */ glPushMatrix(); glTranslatef(0., -7.5, 0.); for (iterator = 0; iterator < 3; iterator++) { glPushMatrix(); glTranslatef(-4.5, 0., 0.); glCallList(connectlistindex); glPopMatrix(); glPushMatrix(); glTranslatef(4.5, 0., 0.); glCallList(connectlistindex); glPopMatrix(); glTranslatef(0., 5.0, 0.); } glTranslatef(0., -0.15, 0.); glCallList(secconnectlistindex); glPopMatrix(); /* draw pole */ glPushMatrix(); glRotatef(90.0, 1.0, 0.0, 0.0); glTranslatef(0.0, 0.0, 12.0); gluCylinder(pole, 0.75, 0.75, 20, 16, 12); glPopMatrix(); glEndList(); handleGLerrors("makebclockhousing"); return dlistindex; }
static void material(int type) { GLfloat ambient[] = {.19225f, .19225f, .19225f, 1.0f}; GLfloat diffuse[] = {.50754f, .50754f, .50754f, 1.0f}; GLfloat specular[] = {.508273f, .508273f, .508273f, 1.0f}; switch (type) { case MATTE: glEnable(GL_LIGHT0); glDisable(GL_LIGHT1); glDisable(GL_LIGHT2); glEnable(GL_LIGHTING); lighting = 1; glDisable(GL_TEXTURE_2D); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambient); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, zero); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 0.0); break; case RUBBER: glEnable(GL_LIGHT0); glDisable(GL_LIGHT1); glDisable(GL_LIGHT2); glEnable(GL_LIGHTING); lighting = 1; glDisable(GL_TEXTURE_2D); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambient); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 51.2f); break; case TWOTONE: glDisable(GL_LIGHT0); glEnable(GL_LIGHT1); glEnable(GL_LIGHT2); glEnable(GL_LIGHTING); lighting = 1; glDisable(GL_TEXTURE_2D); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambient); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, zero); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 0.0); break; case METAL: glDisable(GL_LIGHT0); glDisable(GL_LIGHT1); glDisable(GL_LIGHT2); glDisable(GL_LIGHTING); lighting = 0; glColor4f(1.f, 1.f, 1.f, 1.f); glEnable(GL_TEXTURE_2D); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, one); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, one); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, zero); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 0.0); break; } show_texture = 0; CHECK_ERROR("material"); }
void MGLContext::setMaterialShininess(float shininess){ glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess); }
void draw_cube(double radius) { GLfloat matspec[4] = { 0.5, 0.5, 0.5, 0.0 }; glPushMatrix(); glScaled(radius, radius, radius); glMaterialfv(GL_FRONT, GL_SPECULAR, matspec); glMaterialf(GL_FRONT, GL_SHININESS, 64.0); glBegin(GL_POLYGON); glColor3fv(lightblu_col); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, lightblu_col); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, lightblu_col); glNormal3f(0.0, 0.0, -1.0); glVertex3f(1.0, 1.0, -1.0); glVertex3f(1.0, -1.0, -1.0); glVertex3f(-1.0, -1.0, -1.0); glVertex3f(-1.0, 1.0, -1.0); glEnd(); glBegin(GL_POLYGON); glColor3fv(blu_col); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, blu_col); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, blu_col); glNormal3f(0.0, 0.0, 1.0); glVertex3f(-1.0, 1.0, 1.0); glVertex3f(-1.0, -1.0, 1.0); glVertex3f(1.0, -1.0, 1.0); glVertex3f(1.0, 1.0, 1.0); glEnd(); glBegin(GL_POLYGON); glColor3fv(yel_col); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, yel_col); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, yel_col); glNormal3f(0.0, -1.0, 0.0); glVertex3f(1.0, -1.0, 1.0); glVertex3f(-1.0, -1.0, 1.0); glVertex3f(-1.0, -1.0, -1.0); glVertex3f(1.0, -1.0, -1.0); glEnd(); glBegin(GL_POLYGON); glColor3fv(grn_col); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, grn_col); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, grn_col); glNormal3f(0.0, 1.0, 0.0); glVertex3f(1.0, 1.0, 1.0); glVertex3f(1.0, 1.0, -1.0); glVertex3f(-1.0, 1.0, -1.0); glVertex3f(-1.0, 1.0, 1.0); glEnd(); glBegin(GL_POLYGON); glColor3fv(pur_col); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, pur_col); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, pur_col); glNormal3f(-1.0, 0.0, 0.0); glVertex3f(-1.0, 1.0, 1.0); glVertex3f(-1.0, 1.0, -1.0); glVertex3f(-1.0, -1.0, -1.0); glVertex3f(-1.0, -1.0, 1.0); glEnd(); glBegin(GL_POLYGON); glColor3fv(red_col); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, red_col); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, red_col); glNormal3f(1.0, 0.0, 0.0); glVertex3f(1.0, -1.0, 1.0); glVertex3f(1.0, -1.0, -1.0); glVertex3f(1.0, 1.0, -1.0); glVertex3f(1.0, 1.0, 1.0); glEnd(); glPopMatrix(); }
void keyboard(unsigned char key, int x, int y) { switch (key) { case 'r': ambientMaterial[0]=ambientMaterial[1]=ambientMaterial[2]=0.0; glMaterialfv(GL_FRONT, GL_AMBIENT, ambientMaterial); diffuseMaterial[0]=diffuseMaterial[1]=diffuseMaterial [2]=0.0; glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuseMaterial); specularMaterial[0]=specularMaterial[1]=specularMaterial[2]=0.0; glMaterialfv(GL_FRONT, GL_EMISSION, emissionMaterial); shininessMaterial=0.0; glMaterialf(GL_FRONT, GL_SHININESS, shininessMaterial); emissionMaterial[0]=emissionMaterial[1]=emissionMaterial[2]=0.0; glMaterialfv(GL_FRONT, GL_EMISSION, emissionMaterial); glutPostRedisplay(); break; case 'a': incrementMaterial(ambientMaterial, 0.1); glMaterialfv(GL_FRONT, GL_AMBIENT, ambientMaterial); glutPostRedisplay(); break; case 'A': incrementMaterial(ambientMaterial, -0.1); glMaterialfv(GL_FRONT, GL_AMBIENT, ambientMaterial); glutPostRedisplay(); break; case 'd': incrementMaterial(diffuseMaterial, 0.1); glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuseMaterial); glutPostRedisplay(); break; case 'D': incrementMaterial(diffuseMaterial, -0.1); glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuseMaterial); glutPostRedisplay(); break; case 's': incrementMaterial(specularMaterial, 0.1); /*specularMaterial[0]=specularMaterial[1]=0.0;*/ glMaterialfv(GL_FRONT, GL_SPECULAR, specularMaterial); glutPostRedisplay(); break; case 'S': incrementMaterial(specularMaterial, -0.1); /*specularMaterial[0]=specularMaterial[1]=0.0;*/ glMaterialfv(GL_FRONT, GL_SPECULAR, specularMaterial); glutPostRedisplay(); break; case 'b': shininessMaterial +=2.0; if (shininessMaterial>128.0) shininessMaterial=128.0; glMaterialf(GL_FRONT, GL_SHININESS, shininessMaterial); glutPostRedisplay(); break; case 'B': shininessMaterial -=2.0; if (shininessMaterial<0.0) shininessMaterial=0.0; glMaterialf(GL_FRONT, GL_SHININESS, shininessMaterial); glutPostRedisplay(); break; case 'e': incrementMaterial(emissionMaterial, 0.1); glMaterialfv(GL_FRONT, GL_EMISSION, emissionMaterial); glutPostRedisplay(); break; case 'E': incrementMaterial(emissionMaterial, -0.1); glMaterialfv(GL_FRONT, GL_EMISSION, emissionMaterial); glutPostRedisplay(); break; case 27: exit(0); break; } }
void display(void) { static GLfloat angle = 0.0; static GLfloat theta = 0.0; static GLfloat thetaP = 0.0; GLfloat tanamb[] = { 0.2, 0.15, 0.1, 1.0 }; GLfloat tandiff[] = { 0.4, 0.3, 0.2, 1.0 }; GLfloat seaamb[] = { 0.0, 0.0, 0.2, 1.0 }; GLfloat seadiff[] = { 0.0, 0.0, 0.8, 1.0 }; GLfloat seaspec[] = { 0.5, 0.5, 1.0, 1.0 }; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glColor3f(1.0, 1.0, 1.0); glLoadIdentity(); /* clear the matrix */ /* viewing transformation */ if (rotateLeft) { angle += 1; } else if (rotateRight) { angle -= 1; } else if (rotateUp) { centerZ += 0.01; } else if (rotateDown) { centerZ -= 0.01; } gluLookAt(eyePosX, eyePosY, eyePosZ, centerX, centerY, centerZ, upX, upY, upZ); glRotatef(angle, xAxis, yAxis, zAxis); glTranslatef(translateX, translateY, translateZ); /* modeling transformation */ glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, tanamb); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, tandiff); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, tandiff); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 10.0); mountain(0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0); mountain(1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, seaamb); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, seadiff); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, seaspec); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 10.0); glNormal3f(0.0, 0.0, 1.0); glBegin(GL_QUADS); glVertex3f(0.0, 0.0, sealevel); glVertex3f(1.0, 0.0, sealevel); glVertex3f(1.0, 1.0, sealevel); glVertex3f(0.0, 1.0, sealevel); glEnd(); glutSwapBuffers(); glFlush(); glutPostRedisplay(); }
void sModelMaterial_OpenGL::Submit(sModelVertexChunk_OpenGL *pVChunk) { glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, &m_Emissive[0]); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, &m_Ambient[0]); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, &m_Diffuse[0]); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &m_Specular[0]); glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, m_fShininess); if ( m_bCullFace ) { glEnable(GL_CULL_FACE); } else { glDisable(GL_CULL_FACE); } if ( m_bBlend ) { glEnable(GL_BLEND); glBlendFunc(m_SrcBlend, m_DestBlend); } else { glDisable(GL_BLEND); } static GLuint texblend[] = { GL_MODULATE, GL_MODULATE, GL_ADD }; int num_textures = 0; for ( int t=0; t<MAX_NUM_TEXTURES; t++ ) { GLuint stage = GL_TEXTURE0_ARB + t; int m = m_MapChannel[t]; if ( m < -2 ) break; glActiveTexture(stage); glClientActiveTexture(stage); if ( m_Textures[t] > 0 ) { glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, m_Textures[t]); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, texblend[t]); num_textures++; } else { //glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, texblend[t]); //glBindTexture(GL_TEXTURE_2D, 0); glDisable(GL_TEXTURE_2D); } if ( m >=0 ) { glDisable(GL_TEXTURE_GEN_S); glDisable(GL_TEXTURE_GEN_T); glDisable(GL_TEXTURE_GEN_R); glDisable(GL_TEXTURE_GEN_Q); if ( pVChunk ) { sVertexDecl *pVertexDecl = &pVChunk->m_VertexDecl; if ( m_Textures[t] && pVertexDecl->m_iTexcoordOffset[m] >= 0 ) { glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(pVertexDecl->m_iNumTexcoordElements[m], GL_FLOAT, pVertexDecl->m_iVertexSize, (GLvoid *) pVertexDecl->m_iTexcoordOffset[m]); } else { glDisableClientState(GL_TEXTURE_COORD_ARRAY); } } else { glDisableClientState(GL_TEXTURE_COORD_ARRAY); } } else { switch(m) { case -1: // sphere map glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); glDisable(GL_TEXTURE_GEN_R); glDisable(GL_TEXTURE_GEN_Q); // 自動產生spheremap貼圖座標 glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); break; case -2: // cube map // S/T/R分別代表貼圖座標的X/Y/Z軸 glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); glEnable(GL_TEXTURE_GEN_R); glDisable(GL_TEXTURE_GEN_Q); // 以光線的反射向量來做為貼圖座標 glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP); glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP); glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP); default: // 由外部控制 break; } } } glActiveTexture(GL_TEXTURE0_ARB); glClientActiveTexture(GL_TEXTURE0_ARB); }
//------------------------------------------------------------------------------ /// Registered OpenGL Display Callback Function void display(void) { // recompute the camera projection in case it was moved scene.camera.project(); glMatrixMode( GL_PROJECTION ); glLoadIdentity( ); glLoadMatrixd( scene.camera.projection.arrayOpenGL() ); // now process the scene glMatrixMode( GL_MODELVIEW ); glLoadIdentity( ); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); Matrix4 scaling_matrix, transform; if( arrow->scale != Vector3( 1.0, 1.0, 1.0 ) ) { scaling_matrix = Matrix4::scalingMatrix( arrow->scale.x(), arrow->scale.y(), arrow->scale.z() ); } for( unsigned int i = 0; i < arrow->geometryCount(); i++ ) { Geometry* g = arrow->geometry( i ); Mesh* m = static_cast<Mesh*>(g); glPushMatrix(); m->pose.transformByQuaternion(); transform = scaling_matrix * m->pose.transform; draw( m, transform ); glPopMatrix(); } // draw normals glLineWidth( 1 ); Material material; glMaterialfv(GL_FRONT, GL_AMBIENT, (GLfloat*)material.ambient.arrayOpenGL()); glMaterialfv(GL_FRONT, GL_DIFFUSE, (GLfloat*)material.diffuse.arrayOpenGL()); glMaterialfv(GL_FRONT, GL_SPECULAR, (GLfloat*)material.specular.arrayOpenGL()); glMaterialfv(GL_FRONT, GL_EMISSION, (GLfloat*)material.emissive.arrayOpenGL()); glMaterialf(GL_FRONT, GL_SHININESS, (GLfloat)material.shininess); for( unsigned int j = 0; j < arrow->geometryCount(); j++ ) { Geometry* g = arrow->geometry( j ); Mesh* m = static_cast<Mesh*>(g); m->pose.transformByQuaternion(); transform = scaling_matrix * m->pose.transform; glLoadMatrixd( transform.arrayOpenGL() ); glBegin(GL_LINES); for( unsigned int i = 0; i < m->vertexCount(); i++ ) { Vertex* v = m->vertex( i ); Vector3 pt1 = Vector3( v->position.x(), v->position.y(), v->position.z() ); Vector3 pt2 = pt1 + v->normal; glVertex3d( pt1.x(), pt1.y(), pt1.z() ); glVertex3d( pt2.x(), pt2.y(), pt2.z() ); } glEnd(); } glutSwapBuffers(); if( GENERATE_MOVIE ) { sprintf( filename, "%s_%.04d.tif",filetitle.c_str(), frame_id ); printf( "%s\n", filename ); Utilities::writetiff( filename, "movie", 0, 0, Width, Height, COMPRESSION_NONE ); } }