void Mesh::draw(Colour col, int x)
{
glPushMatrix();
glTranslatef(mPos.x, mPos.y, mPos.z);
glRotatef(mRot.x, 1, 0, 0);
glRotatef(mRot.y, 0, 1, 0);
glRotatef(mRot.z, 0, 0, 1);
if (x & VOXELS) drawVoxels(Colour(0,0xFF,0));
if (x & SOLID) drawTriangles(col, false);
if (x & WIRE) drawTriangles(Colour(0,0,0), true);
if (x & NORMALS) drawNormals(col);
if (x & AABB) drawAABB(Colour(0xA5, 0x2A, 0x2A), x&HIER);
if (x & SPHERE) drawSphere(Colour(0xA5, 0x2A, 0x2A), x&HIER);
if (x & TBOXES) drawTriangleBoxes(Colour(0xFF,0,0));
glPopMatrix();
}
//--------------------------------------------------------------
void ofApp::draw(){
ofBackground(0, 0, 0);
ofSetColor(255, 255, 255);
ofTranslate(-center.x + ofGetWidth()/2 - 20*left, -center.y + ofGetHeight()/2 - 20*up, zoom*20);
ofRotate(ofMap(ofGetMouseX(), 0, ofGetScreenWidth(), 0, 360), center.x,center.y,center.z);
glPointSize(3);
mesh.drawVertices();
if(showNormals){
drawNormals(mesh);
}
}
void Skinning::draw()
{
gl::clear( Color( 1.0f, 1.0f, 1.0f ) );
mCam.lookAt( gConfigScene.eye, Vec3f::zero() );
mCam.setPerspective( 60, getWindowAspectRatio(), 0.01, 500 );
gl::setMatrices( mCam );
glEnable(GL_LIGHT0);
GLfloat pos[] = {0.0, 2.0, 15.0, 1.0};
GLfloat diff[] = {1.0, 1.0, 1.0, 1.0};
glLightfv(GL_LIGHT0, GL_POSITION, pos);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diff);
mShaderPhong.bind();
mShaderPhong.uniform("shininess",128.0f);
mShaderPhong.uniform("tex",0);
drawGeometry();
mShaderPhong.unbind();
glDisable(GL_LIGHT0);
if (mDrawNormals)
drawNormals();
// Params
if (mShowParams){
params::InterfaceGl::draw();
}
}
void Viewer::cb_redraw()
{
// Draw the faces with SSAO and everything else
if (m_useSSAO && m_drawFaces)
{
CGoGNGLuint SSAOTexture = computeSSAO();
// Get and draw only SSAO results
if (m_displayOnlySSAO)
Utils::TextureSticker::StickTextureOnWholeScreen(SSAOTexture);
// Use SSAO results with regular rendering
else
{
// Render color and depth
m_finalRenderFbo->Bind();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
{
// Simply render faces color and depth
drawFaces();
}
m_finalRenderFbo->Unbind();
// Merge color and SSAO
m_colorAndSSAOMergeFbo->Bind();
glClear(GL_COLOR_BUFFER_BIT);
{
// Send textures to multiply shader
m_multTexturesShader->bind();
m_multTexturesShader->setTexture1Unit(GL_TEXTURE0);
m_multTexturesShader->activeTexture1(m_finalRenderFbo->GetColorTexId(0));
m_multTexturesShader->setTexture2Unit(GL_TEXTURE1);
m_multTexturesShader->activeTexture2(SSAOTexture);
m_multTexturesShader->unbind();
// Multiply textures together
Utils::TextureSticker::DrawFullscreenQuadWithShader(m_multTexturesShader);
}
m_colorAndSSAOMergeFbo->Unbind();
// Get and draw color texture from merged SSAO and color Fbo into final render Fbo (we need to use the depth information to display everything else)
m_finalRenderFbo->Bind();
glClear(GL_COLOR_BUFFER_BIT);
{
// Simply stick result texture on screen
Utils::TextureSticker::StickTextureOnWholeScreen(m_colorAndSSAOMergeFbo->GetColorTexId(0));
// Now that we have depth *and* SSAO information, display everything else
if(m_drawVertices)
drawVertices();
if(m_drawEdges)
drawEdges();
if(m_drawTopo)
drawTopo();
if(m_drawNormals)
drawNormals();
}
m_finalRenderFbo->Unbind();
// Stick final render in main framebuffer
Utils::TextureSticker::StickTextureOnWholeScreen(m_finalRenderFbo->GetColorTexId(0));
}
}
// Draw everything without SSAO
else
{
if (m_drawFaces)
drawFaces();
if(m_drawVertices)
drawVertices();
if(m_drawEdges)
drawEdges();
if(m_drawTopo)
drawTopo();
if(m_drawNormals)
drawNormals();
}
// Check for OpenGL errors
GLenum glError = glGetError();
if (glError != GL_NO_ERROR)
std::cout << "GL error : " << gluErrorString(glError) << std::endl;
}
void drawModel (pScene sc) {
pMesh mesh;
pTransform view;
pClip clip;
ubyte sstatic;
/* default */
mesh = cv.mesh[sc->idmesh];
view = sc->view;
clip = sc->clip;
if (ddebug) printf("\n-- redraw scene %d, mesh %d\n", sc->idwin, sc->idmesh);
glDisable(GL_LIGHTING);
/* draw clipping plane */
if (clip->active & C_ON) {
drawClip(sc, clip, mesh, 0);
glClipPlane(GL_CLIP_PLANE0, clip->eqn);
glEnable(GL_CLIP_PLANE0);
} else {
glDisable(GL_CLIP_PLANE0);
}
/* draw object if static scene */
sstatic = view->mstate > 0 && clip->cliptr->mstate > 0;
if (sstatic || sc->type & S_FOLLOW) {
displayScene(sc, sc->mode, 0);
if (sc->item & S_NUMP || sc->item & S_NUMF) listNum(sc, mesh);
/* draw normals */
if (sc->type & S_NORMAL) {
if (!sc->nlist) sc->nlist = drawNormals(mesh, sc);
glCallList(sc->nlist);
}
/* draw data */
if (sstatic) displayData(sc, mesh);
} else if (!(sc->item & S_BOX)) {
drawBox(sc, mesh, 0);
}
/* draw ridges, corners, etc. */
if ((sc->item & S_GEOM) && sc->glist) {
glDisable(GL_LIGHTING);
if (!mesh->ne)
glPointSize(1);
else
glPointSize(5);
glDisable(GL_COLOR_MATERIAL);
glCallList(sc->glist);
}
glDisable(GL_CLIP_PLANE0);
if (clip->active & C_EDIT || sc->item & S_BOX)
drawBox(sc, mesh, 0);
if (sc->item & S_AXIS)
drawAxis(sc, mesh->dim);
if ((mesh->dim == 3 || sc->mode & S_ALTITUDE) && sc->item & S_GRID)
drawBase(sc, mesh);
if (sc->cube->active & C_ON)
drawCube(sc, mesh);
sstatic |= tiling;
if (sstatic && clip->active & C_ON && clip->active & C_VOL)
displayScene(sc, sc->mode, 1);
if (sc->picklist && !(sc->isotyp & S_PARTICLE)) {
glEnable(GL_LIGHTING);
glEnable(GL_COLOR_MATERIAL);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glDisable(GL_POLYGON_OFFSET_FILL);
glCallList(sc->picklist);
glEnable(GL_POLYGON_OFFSET_FILL);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glDisable(GL_COLOR_MATERIAL);
glDisable(GL_LIGHTING);
}
/* show path, if any */
if (sc->type & S_PATH && sc->path.tlist)
glCallList(sc->path.tlist);
}
//------------------------------------------------------------------------------
void
display() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glViewport(0, 0, g_width, g_height);
double aspect = g_width/(double)g_height;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0, aspect, g_size*0.001f, g_size+g_dolly);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(-g_pan[0], -g_pan[1], -g_dolly);
glRotatef(g_rotate[1], 1, 0, 0);
glRotatef(g_rotate[0], 0, 1, 0);
glTranslatef(-g_center[0], -g_center[1], -g_center[2]);
glUseProgram(g_program);
{
// shader uniform setting
GLint position = glGetUniformLocation(g_program, "lightSource[0].position");
GLint ambient = glGetUniformLocation(g_program, "lightSource[0].ambient");
GLint diffuse = glGetUniformLocation(g_program, "lightSource[0].diffuse");
GLint specular = glGetUniformLocation(g_program, "lightSource[0].specular");
glProgramUniform4f(g_program, position, 0, 0.2f, 1, 0);
glProgramUniform4f(g_program, ambient, 0.4f, 0.4f, 0.4f, 1.0f);
glProgramUniform4f(g_program, diffuse, 0.3f, 0.3f, 0.3f, 1.0f);
glProgramUniform4f(g_program, specular, 0.2f, 0.2f, 0.2f, 1.0f);
GLint otcMatrix = glGetUniformLocation(g_program, "objectToClipMatrix");
GLint oteMatrix = glGetUniformLocation(g_program, "objectToEyeMatrix");
GLfloat modelView[16], proj[16], mvp[16];
glGetFloatv(GL_MODELVIEW_MATRIX, modelView);
glGetFloatv(GL_PROJECTION_MATRIX, proj);
multMatrix(mvp, modelView, proj);
glProgramUniformMatrix4fv(g_program, otcMatrix, 1, false, mvp);
glProgramUniformMatrix4fv(g_program, oteMatrix, 1, false, modelView);
}
GLuint bVertex = g_vertexBuffer->GetGpuBuffer();
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glBindBuffer(GL_ARRAY_BUFFER, bVertex);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof (GLfloat) * 6, 0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof (GLfloat) * 6, (float*)12);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_elementArrayBuffer->GetGlBuffer());
glPolygonMode(GL_FRONT_AND_BACK, g_wire==0 ? GL_LINE : GL_FILL);
// glPatchParameteri(GL_PATCH_VERTICES, 4);
// glDrawElements(GL_PATCHES, g_numIndices, GL_UNSIGNED_INT, 0);
glDrawElements(GL_LINES_ADJACENCY, g_elementArrayBuffer->GetNumIndices(), GL_UNSIGNED_INT, 0);
glUseProgram(0);
if (g_drawNormals)
drawNormals();
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
if (g_ptexDebug)
drawPtexLayout(g_ptexDebug-1);
glColor3f(1, 1, 1);
drawFmtString(10, 10, "LEVEL = %d", g_level);
drawFmtString(10, 30, "# of Vertices = %d", g_osdmesh->GetFarMesh()->GetNumVertices());
drawFmtString(10, 50, "KERNEL = %s", getKernelName(g_kernel));
drawFmtString(10, 70, "CPU TIME = %.3f ms", g_cpuTime);
drawFmtString(10, 90, "GPU TIME = %.3f ms", g_gpuTime);
g_fpsTimer.Stop();
drawFmtString(10, 110, "FPS = %3.1f", 1.0/g_fpsTimer.GetElapsed());
g_fpsTimer.Start();
drawFmtString(10, 130, "SUBDIVISION = %s", g_scheme==0 ? "CATMARK" : "BILINEAR");
drawString(10, g_height-10, "a: ambient occlusion on/off");
drawString(10, g_height-30, "c: color on/off");
drawString(10, g_height-50, "d: displacement on/off");
drawString(10, g_height-70, "e: show normal vector");
drawString(10, g_height-90, "f: fit frame");
drawString(10, g_height-110, "w: toggle wireframe");
drawString(10, g_height-130, "m: toggle vertex moving");
drawString(10, g_height-150, "s: bilinear / catmark");
drawString(10, g_height-170, "1-7: subdivision level");
glFinish();
glutSwapBuffers();
}
void display() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
/* camera transform */
glTranslatef(0, 0, -camera.zoom);
glRotatef(camera.rot.x, 1, 0, 0);
glRotatef(camera.rot.y, 0, 1, 0);
drawAxes(0.5);
/* set the light position */
if(options[OPT_LIGHTING]) {
glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
glMaterialfv(GL_FRONT, GL_AMBIENT, ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, specular);
glMaterialf(GL_FRONT, GL_SHININESS, shininess);
glEnable(GL_LIGHTING);
} else {
glDisable(GL_LIGHTING);
}
if(options[OPT_SMOOTH_SHADE])
glShadeModel(GL_SMOOTH);
else
glShadeModel(GL_FLAT);
if(options[OPT_DRAW_NORMALS])
drawNormals();
if(options[OPT_SHADER]) {
glUseProgram(currentShader);
if (currentShader != 0 && (loc = glGetUniformLocation(currentShader, "GeomGen")) != -1)
glUniform1i(loc, options[OPT_SHADER_GEN]);
}
if(options[OPT_WIREFRAME])
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
else
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
if(options[OPT_BUMP_MAP]) {
glUseProgram(bumpShader);
if (bumpShader != 0 && (loc = glGetUniformLocation(bumpShader, "LightPosition")) != -1)
glUniform3fv(loc, 1, lightPos);
if (bumpShader != 0 && (loc = glGetUniformLocation(bumpShader, "SurfaceColor")) != -1)
glUniform3f(loc, 1.0, 0.0, 0.0);
if (bumpShader != 0 && (loc = glGetUniformLocation(bumpShader, "BumpDensity")) != -1)
glUniform1f(loc, 4);
if (bumpShader != 0 && (loc = glGetUniformLocation(bumpShader, "BumpSize")) != -1)
glUniform1f(loc, 0.15);
if (bumpShader != 0 && (loc = glGetUniformLocation(bumpShader, "SpecularFactor")) != -1)
glUniform1f(loc, 0.5);
if (bumpShader != 0 && (loc = glGetUniformLocation(bumpShader, "R")) != -1)
glUniform1f(loc, R);
if (bumpShader != 0 && (loc = glGetUniformLocation(bumpShader, "r")) != -1)
glUniform1f(loc, r);
if (bumpShader != 0 && (loc = glGetUniformLocation(bumpShader, "Time")) != -1) {
double tt = 1.0;
if(options[OPT_ANIM]) {
double ipart, fpart;
fpart = modf(thisTime * 0.001f, &ipart);
if((int)ipart % 2 == 0)
// using slightly less fpart smoothes animation
tt = 1.1 - fpart;
else
tt = fpart;
}
glUniform1f(loc, tt);
}
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, geom_uv);
glDrawElements(GL_QUAD_STRIP, n_geom_indices, GL_UNSIGNED_INT, geom_indices);
glDisableClientState(GL_VERTEX_ARRAY);
} else if(options[OPT_SHADER_GEN]) {
/* pass in radii as uniforms */
if (currentShader != 0 && (loc = glGetUniformLocation(currentShader, "R")) != -1)
glUniform1f(loc, R);
if (currentShader != 0 && (loc = glGetUniformLocation(currentShader, "r")) != -1)
glUniform1f(loc, r);
if (currentShader != 0 && (loc = glGetUniformLocation(currentShader, "GenMode")) != -1)
glUniform1i(loc, gMode);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, geom_uv);
glDrawElements(GL_QUAD_STRIP, n_geom_indices, GL_UNSIGNED_INT, geom_indices);
glDisableClientState(GL_VERTEX_ARRAY);
} else {
if(options[OPT_IMMEDIATE]) {
drawImmediate();
} else {
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, 0, geom_norms);
if(options[OPT_VBO])
drawVBO();
else
drawVertexArray();
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
}
}
/* Render the hud */
glDisable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(0, 1, 0, 1, -1, 1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glUseProgram(0);
glDisable(GL_LIGHTING);
glTranslatef(0.0, 0.0, -0.5);
drawHud();
glEnable(GL_LIGHTING);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glEnable(GL_DEPTH_TEST);
glutSwapBuffers();
int err;
if ((err = glGetError()) != GL_NO_ERROR)
fprintf(stderr, "%s\n", gluErrorString(err));
}
//------------------------------------------------------------------------------
void
display() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glViewport(0, 0, g_width, g_height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glDisable(GL_LIGHTING);
glColor3f(1, 1, 1);
glBegin(GL_QUADS);
glColor3f(1, 1, 1);
glVertex3f(-1, -1, 1);
glVertex3f( 1, -1, 1);
glVertex3f( 1, 1, 1);
glVertex3f(-1, 1, 1);
glEnd();
double aspect = g_width/(double)g_height;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0, aspect, 0.01, 500.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(-g_pan[0], -g_pan[1], -g_dolly);
glRotatef(g_rotate[1], 1, 0, 0);
glRotatef(g_rotate[0], 0, 1, 0);
glTranslatef(-g_center[0], -g_center[1], -g_center[2]);
glRotatef(-90, 1, 0, 0); // z-up model
GLuint bVertex = g_vertexBuffer->GetGpuBuffer();
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glBindBuffer(GL_ARRAY_BUFFER, bVertex);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof (GLfloat) * 6, 0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof (GLfloat) * 6, (float*)12);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_elementArrayBuffer->GetGlBuffer());
GLenum primType = GL_LINES_ADJACENCY;
if (g_scheme == kLoop) {
primType = GL_TRIANGLES;
bindProgram(g_triFillProgram);
} else {
bindProgram(g_quadFillProgram);
}
if (g_wire > 0) {
glDrawElements(primType, g_elementArrayBuffer->GetNumIndices(), GL_UNSIGNED_INT, NULL);
}
if (g_wire == 0 || g_wire == 2) {
GLuint lineProgram = g_scheme == kLoop ? g_triLineProgram : g_quadLineProgram;
bindProgram(lineProgram);
GLuint fragColor = glGetUniformLocation(lineProgram, "fragColor");
if (g_wire == 2) {
glProgramUniform4f(lineProgram, fragColor, 0, 0, 0.5, 1);
} else {
glProgramUniform4f(lineProgram, fragColor, 1, 1, 1, 1);
}
glDrawElements(primType, g_elementArrayBuffer->GetNumIndices(), GL_UNSIGNED_INT, NULL);
}
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
glUseProgram(0);
if (g_drawNormals)
drawNormals();
if (g_drawCoarseMesh)
drawCoarseMesh(g_drawCoarseMesh);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glDisableClientState(GL_VERTEX_ARRAY);
if (g_drawHUD) {
glColor3f(1, 1, 1);
drawString(10, 10, "LEVEL = %d", g_level);
drawString(10, 30, "# of Vertices = %d", g_osdmesh->GetFarMesh()->GetNumVertices());
drawString(10, 50, "KERNEL = %s", getKernelName(g_kernel));
drawString(10, 70, "CPU TIME = %.3f ms", g_cpuTime);
drawString(10, 90, "GPU TIME = %.3f ms", g_gpuTime);
drawString(10, 110, "SUBDIVISION = %s", g_scheme==kBilinear ? "BILINEAR" : (g_scheme == kLoop ? "LOOP" : "CATMARK"));
drawString(10, g_height-30, "w: toggle wireframe");
drawString(10, g_height-50, "e: display normal vector");
drawString(10, g_height-70, "m: toggle vertex deforming");
drawString(10, g_height-90, "h: display control cage");
drawString(10, g_height-110, "n/p: change model");
drawString(10, g_height-130, "1-7: subdivision level");
drawString(10, g_height-150, "space: freeze/unfreeze time");
}
glFinish();
glutSwapBuffers();
}
void operator () (GFace *f)
{
if(!f->getVisibility()) {
if(f->getCompound()) {
if(!f->getCompound()->getVisibility()) return;
}
else
return;
}
bool select = (_ctx->render_mode == drawContext::GMSH_SELECT &&
f->model() == GModel::current());
if(select) {
glPushName(2);
glPushName(f->tag());
}
drawArrays(_ctx, f, f->va_lines, GL_LINES,
CTX::instance()->mesh.light && CTX::instance()->mesh.lightLines,
CTX::instance()->mesh.surfacesFaces, CTX::instance()->color.mesh.line);
drawArrays(_ctx, f, f->va_triangles, GL_TRIANGLES, CTX::instance()->mesh.light);
if(CTX::instance()->mesh.surfacesNum) {
if(CTX::instance()->mesh.triangles)
drawElementLabels(_ctx, f, f->triangles, CTX::instance()->mesh.surfacesFaces,
CTX::instance()->color.mesh.line);
if(CTX::instance()->mesh.quadrangles)
drawElementLabels(_ctx, f, f->quadrangles, CTX::instance()->mesh.surfacesFaces,
CTX::instance()->color.mesh.line);
drawElementLabels(_ctx, f, f->polygons, CTX::instance()->mesh.surfacesFaces,
CTX::instance()->color.mesh.line);
}
if(CTX::instance()->mesh.points || CTX::instance()->mesh.pointsNum){
if(f->getAllElementsVisible())
drawVerticesPerEntity(_ctx, f);
else{
if(CTX::instance()->mesh.triangles)
drawVerticesPerElement(_ctx, f, f->triangles);
if(CTX::instance()->mesh.quadrangles)
drawVerticesPerElement(_ctx, f, f->quadrangles);
drawVerticesPerElement(_ctx, f, f->polygons);
}
}
if(CTX::instance()->mesh.normals) {
if(CTX::instance()->mesh.triangles) drawNormals(_ctx, f->triangles);
if(CTX::instance()->mesh.quadrangles) drawNormals(_ctx, f->quadrangles);
drawNormals(_ctx, f->polygons);
}
if(CTX::instance()->mesh.dual) {
if(CTX::instance()->mesh.triangles) drawBarycentricDual(f->triangles);
if(CTX::instance()->mesh.quadrangles) drawBarycentricDual(f->quadrangles);
drawBarycentricDual(f->polygons);
}
else if(CTX::instance()->mesh.voronoi) {
if(CTX::instance()->mesh.triangles) drawVoronoiDual(f->triangles);
}
if(select) {
glPopName();
glPopName();
}
}
void outPut::drawTerrain(bool reinit)
{
static bool lastwfStatus(!_reg.WIREFRAME);
if(lastwfStatus != _reg.WIREFRAME)
{
if(_reg.WIREFRAME)
{
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glLineWidth(1);
}
else
{
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}}
lastwfStatus = _reg.WIREFRAME;
static bool init(true);
static VA terrain;
static GLuint buf_pos, buf_norm, buf_cost, buf_index;
unsigned int nbVertices = _dimensions.x*_dimensions.y;
unsigned int nbIndex = (_dimensions.x-1)*(_dimensions.y-1)*6;
//nbIndex = nbVertices;
/*Chaque vertex est associé à une maille qui 'coûte' 6 indices en mémoire :
_
|\| -> deux triangles, avec 3 indices par triangle. On enlève une ligne et une colonne parce que ceux sur les côtés n'entrainent pas une maille.
+-
*/
if(init || reinit)
{
gen_verticesMap();
drawNormals(true);
glDeleteBuffers(1,&buf_pos);
glDeleteBuffers(1,&buf_norm);
glDeleteBuffers(1,&buf_cost);
glDeleteBuffers(1,&buf_index);
delete terrain.verticesA;
delete terrain.normalsA;
delete terrain.costsA;
delete terrain.indexA;
terrain.verticesA = new float[nbVertices*P_SIZE];
terrain.normalsA = new float[nbVertices*N_SIZE];
terrain.costsA = new int[nbVertices*C_SIZE];
terrain.indexA = new unsigned int[nbIndex];
///Remplissage des tableaux de sommets et de coûts
for(unsigned int i = 0; i < _dimensions.x; i++)
{
for(unsigned int j = 0; j < _dimensions.y; j++)
{
coords3d<float> vertex(0,0,0), normal(0,0,0);
vertex = getVertex<float>(i,j);
normal = _scene3d.normalMap[i][j];
int vertexPos = (i*_dimensions.y+j);
terrain.verticesA[vertexPos*P_SIZE] = vertex.x;
terrain.verticesA[vertexPos*P_SIZE+1] = vertex.y;
terrain.verticesA[vertexPos*P_SIZE+2] = vertex.z;
terrain.normalsA[vertexPos*P_SIZE] = normal.x;
terrain.normalsA[vertexPos*P_SIZE+1] = normal.y;
terrain.normalsA[vertexPos*P_SIZE+2] = normal.z;
terrain.costsA[vertexPos*C_SIZE] = -1;
}
}
///Remplissage de l'index
for(unsigned int i = 0; i < _dimensions.x-1; i++)
{
for(unsigned int j = 0; j < _dimensions.y-1; j++)
{
terrain.indexA[((i*(_dimensions.y-1))+j)*6] = i*_dimensions.y+j;
terrain.indexA[((i*(_dimensions.y-1))+j)*6+2] = i*_dimensions.y+j+1;
terrain.indexA[((i*(_dimensions.y-1))+j)*6+1] = (i+1)*_dimensions.y+j;
terrain.indexA[((i*(_dimensions.y-1))+j)*6+3] = i*_dimensions.y+j+1;
terrain.indexA[((i*(_dimensions.y-1))+j)*6+4] = (i+1)*_dimensions.y+j;
terrain.indexA[((i*(_dimensions.y-1))+j)*6+5] = (i+1)*_dimensions.y+j+1;
//cout << "\nindice max : " << ((i*(_dimensions.y-1))+j)*6+5 << " / " << nbIndex;
}
}
/* creation de nos VBO+IBO */
glGenBuffers(1, &buf_pos);
glGenBuffers(1, &buf_cost);
glGenBuffers(1, &buf_norm);
glGenBuffers(1, &buf_index);
/* construction du VBO de positions */
glBindBuffer(GL_ARRAY_BUFFER, buf_pos);
glBufferData(GL_ARRAY_BUFFER, (nbVertices*P_SIZE*sizeof *terrain.verticesA),
NULL, GL_STREAM_DRAW);
glBufferSubData(GL_ARRAY_BUFFER, 0, (nbVertices*P_SIZE*sizeof
*terrain.verticesA), terrain.verticesA);
/* construction du VBO de normales */
glBindBuffer(GL_ARRAY_BUFFER, buf_norm);
glBufferData(GL_ARRAY_BUFFER, (nbVertices*N_SIZE*sizeof *terrain.normalsA),
NULL, GL_STREAM_DRAW);
glBufferSubData(GL_ARRAY_BUFFER, 0, (nbVertices*N_SIZE*sizeof
*terrain.normalsA), terrain.normalsA);
/* construction du VBO de coûts */
glBindBuffer(GL_ARRAY_BUFFER, buf_cost);
glBufferData(GL_ARRAY_BUFFER, (nbVertices*C_SIZE*sizeof *terrain.costsA),
NULL, GL_STREAM_DRAW);
glBufferSubData(GL_ARRAY_BUFFER, 0, (nbVertices*C_SIZE*sizeof
*terrain.costsA), terrain.costsA);
/* construction du IBO */
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buf_index);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, nbIndex * sizeof *terrain.indexA,
NULL, GL_STREAM_DRAW);
glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, nbIndex * sizeof
*terrain.indexA, terrain.indexA);
//On debind les VBO+IBO
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
_maxValue = 1;
// cout<<"\n(re)initialisation de l'affichage du terrain reussie\n";
init = false;
_valueChanges.clear();
}
drawAxis();
glBindBuffer(GL_ARRAY_BUFFER, buf_cost);
for(unsigned int i = 0; i < _valueChanges.size(); ++i)
{
int newCost = _valueChanges[i].value;
//newCost = 2;
//std::cout << newCost << "/" << _maxValue << std::endl;
glBufferSubData(GL_ARRAY_BUFFER, (_valueChanges[i].x*_dimensions.y + _valueChanges[i].y)*(sizeof newCost)*C_SIZE, (sizeof
newCost), &newCost);
//terrain.costsA[_valueChanges[i].x*_dimensions.y + _valueChanges[i].y] = newCost;
}
/*
glBufferSubData(GL_ARRAY_BUFFER, 0, (nbVertices*C_SIZE*sizeof
*terrain.costsA), terrain.costsA);*/
catchError("application de changements de couleur");
_valueChanges.clear();
glEnable(GL_DEPTH_TEST);
if(_reg.DRAW_NORMALS)
drawNormals();
glUseProgram(_sLight.getProgramID());
//Envoi des uniforms
glUniform1i(uid_maxCost, _maxValue);
catchError("Envoi de la valeur max");
glUniform3f(uid_defaultColor, _reg.UNIFORM_COLOR[0],_reg.UNIFORM_COLOR[1],_reg.UNIFORM_COLOR[2]);
/* specification du buffer des positions de sommets */
glEnableVertexAttribArray(aID_position);
glBindBuffer(GL_ARRAY_BUFFER, buf_pos);
glVertexAttribPointer(aID_position, P_SIZE , GL_FLOAT, 0, 0, BUFFER_OFFSET(0) );
/* specification du buffer des normales de sommets */
glEnableVertexAttribArray(aID_normal);
glBindBuffer(GL_ARRAY_BUFFER, buf_norm);
glVertexAttribPointer(aID_normal, N_SIZE , GL_FLOAT, 0, 0, BUFFER_OFFSET(0) );
/* specification du buffer des coûts de sommets */
glEnableVertexAttribArray(aID_cost);
glBindBuffer(GL_ARRAY_BUFFER, buf_cost);
glVertexAttribIPointer(aID_cost, C_SIZE, GL_INT, 0, BUFFER_OFFSET(0));
/*Spécification de l'index*/
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buf_index);
glEnableClientState(GL_VERTEX_ARRAY);
glDrawElements(GL_TRIANGLES, nbIndex, GL_UNSIGNED_INT, BUFFER_OFFSET(0));
glDisableVertexAttribArray(aID_position);
glDisableVertexAttribArray(aID_normal);
glDisableVertexAttribArray(aID_cost);
//On debind les VBO+IBO
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDisableVertexAttribArray(aID_position);
glDisableVertexAttribArray(aID_normal);
glDisableVertexAttribArray(aID_cost);
glUseProgram(0);
}
