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