/********************************************************************** * FlatShadeStripCB: **********************************************************************/ void FlatShadeStripCB::faceCB(CBvert* v, CBface* f) { // normal glNormal3dv(f->norm().data()); if (v->has_color()) { GL_COL(v->color(), alpha*v->alpha()); } // texture coords if (_do_texcoords) { if (_use_auto) { //force automatic //use spherical text coord gen glTexCoord2dv(_auto_UV->uv_from_vert(v,f).data()); } else { // the patch has a texture... try to find // appropriate texture coordinates... // use patch's TexCoordGen if possible, // otherwise use the texture coordinates stored // on the face (if any): TexCoordGen* tg = f->patch()->tex_coord_gen(); if (tg) glTexCoord2dv(tg->uv_from_vert(v,f).data()); else if (UVdata::lookup(f)) glTexCoord2dv(UVdata::get_uv(v,f).data()); } } // vertex coords glVertex3dv(v->loc().data()); }
void Triangle::render() const { bool materials_nonnull = true; for ( int i = 0; i < 3; ++i ) materials_nonnull = materials_nonnull && vertices[i].material; // this doesn't interpolate materials. Ah well. if ( materials_nonnull ) vertices[0].material->set_gl_state(); glBegin(GL_TRIANGLES); glNormal3dv( &vertices[0].normal.x ); glTexCoord2dv( &vertices[0].tex_coord.x ); glVertex3dv( &vertices[0].position.x ); glNormal3dv( &vertices[1].normal.x ); glTexCoord2dv( &vertices[1].tex_coord.x ); glVertex3dv( &vertices[1].position.x); glNormal3dv( &vertices[2].normal.x ); glTexCoord2dv( &vertices[2].tex_coord.x ); glVertex3dv( &vertices[2].position.x); glEnd(); if ( materials_nonnull ) vertices[0].material->reset_gl_state(); }
void display(void) { double polygon[][3] = { 0, 0, 0, 10, 0, 0, 10, 6, 0, 5, 10, 0, 0, 6, 0 }; double text[][2] = { 0, 0, 1.0, 0, 1.0, .6, .5, 1.0, 0, .6 }; glMatrixMode(GL_TEXTURE); glLoadIdentity(); glRotated(45, 0, 0, 1); glScaled(1.75,1.75,1.75); glMatrixMode(GL_MODELVIEW); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glBegin(GL_POLYGON); glTexCoord2dv(text[0]); glVertex3dv(polygon[0]); glTexCoord2dv(text[1]); glVertex3dv(polygon[1]); glTexCoord2dv(text[2]); glVertex3dv(polygon[2]); glTexCoord2dv(text[3]); glVertex3dv(polygon[3]); glTexCoord2dv(text[4]); glVertex3dv(polygon[4]); glEnd(); glutSwapBuffers(); }
void Mesh::render(const vec3b& color, bool texturing, bool selected) const { bool use_texture = texturing && !tex_coord.empty(); glEnable(GL_NORMALIZE); glEnable(GL_LIGHTING); if (use_texture) { glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, texture_id); } auto& mesh = *this; auto triangles = mesh.triangles; triangles << top_cover.triangles; triangles << bottom_cover.triangles; glBegin(GL_TRIANGLES); for (auto& tri : triangles) { if (selected) glColor3ub(255, 0, 0); else if (use_texture) glColor3ub(255, 255, 255); else glColor3ubv(color.coords); glNormal3dv(tri.normal.coords); if (use_texture) glTexCoord2dv(tex(tri[0]).coords); glVertex3iv(mesh[tri[0]].coords); glNormal3dv(tri.normal.coords); if (use_texture) glTexCoord2dv(tex(tri[1]).coords); glVertex3iv(mesh[tri[1]].coords); glNormal3dv(tri.normal.coords); if (use_texture) glTexCoord2dv(tex(tri[2]).coords); glVertex3iv(mesh[tri[2]].coords); } glEnd(); if (use_texture) { glDisable(GL_TEXTURE_2D); } glDisable(GL_LIGHTING); glDisable(GL_NORMALIZE); #ifndef NDEBUG if (selected && use_texture) { glLineWidth(5); glColor3d(1, 0, 0); glBegin(GL_LINE_STRIP); for(auto &e: anchor_points) glVertex2iv(e[0].coords); glEnd(); glBegin(GL_LINE_STRIP); for (auto &e: anchor_points) glVertex2iv(e[1].coords); glEnd(); glLineWidth(1); } #endif glColor3d(1, 1, 1); }
// Construct the two display lists void RenderablePicoSurface::createDisplayLists() { // Generate the lists for lighting mode _dlProgramNoVCol = compileProgramList(false); _dlProgramVcol = compileProgramList(true); // Generate the list for flat-shaded (unlit) mode _dlRegular = glGenLists(1); assert(_dlRegular != 0); // check if we run out of display lists glNewList(_dlRegular, GL_COMPILE); glBegin(GL_TRIANGLES); for (Indices::const_iterator i = _indices.begin(); i != _indices.end(); ++i) { // Get the vertex for this index ArbitraryMeshVertex& v = _vertices[*i]; // Submit attributes glNormal3dv(v.normal); glTexCoord2dv(v.texcoord); glVertex3dv(v.vertex); } glEnd(); glEndList(); }
void GeomRenderer::sendTexCoord(GLuint texCoordIndex) { assert(texCoordData.size >= 1 && texCoordData.size <= 4); switch(texCoordData.type) { case GL_SHORT: if (texCoordData.size == 1) glTexCoord1sv((const GLshort*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride)); if (texCoordData.size == 2) glTexCoord2sv((const GLshort*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride)); if (texCoordData.size == 3) glTexCoord3sv((const GLshort*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride)); if (texCoordData.size == 4) glTexCoord4sv((const GLshort*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride)); break; case GL_INT: if (texCoordData.size == 1) glTexCoord1iv((const GLint*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride)); if (texCoordData.size == 2) glTexCoord2iv((const GLint*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride)); if (texCoordData.size == 3) glTexCoord3iv((const GLint*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride)); if (texCoordData.size == 4) glTexCoord4iv((const GLint*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride)); break; case GL_FLOAT: if (texCoordData.size == 1) glTexCoord1fv((const GLfloat*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride)); if (texCoordData.size == 2) glTexCoord2fv((const GLfloat*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride)); if (texCoordData.size == 3) glTexCoord3fv((const GLfloat*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride)); if (texCoordData.size == 4) glTexCoord4fv((const GLfloat*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride)); break; case GL_DOUBLE: if (texCoordData.size == 1) glTexCoord1dv((const GLdouble*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride)); if (texCoordData.size == 2) glTexCoord2dv((const GLdouble*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride)); if (texCoordData.size == 3) glTexCoord3dv((const GLdouble*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride)); if (texCoordData.size == 4) glTexCoord4dv((const GLdouble*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride)); break; } }
static void draw(const Svg* svg) { GLenum nextPrimType, primType = GL_LINE_STRIP; const SvgLine* lIt; uint i; DENG_ASSERT_IN_MAIN_THREAD(); DENG_ASSERT_GL_CONTEXT_ACTIVE(); lIt = svg->lines; for(i = 0; i < svg->lineCount; ++i, lIt++) { if(lIt->numPoints != 2) { nextPrimType = SvgLine_IsLoop(lIt)? GL_LINE_LOOP : GL_LINE_STRIP; // Do we need to end the current primitive? if(primType == GL_LINES) { glEnd(); // 2-vertex set ends. } // A new n-vertex primitive begins. glBegin(nextPrimType); } else { // Do we need to start a new 2-vertex primitive set? if(primType != GL_LINES) { primType = GL_LINES; glBegin(GL_LINES); } } // Write the vertex data. if(lIt->head) { const SvgLinePoint* pIt = lIt->head; do { /// @todo Use TexGen? glTexCoord2dv((const GLdouble*)pIt->coords.xy); glVertex2dv((const GLdouble*)pIt->coords.xy); } while(NULL != (pIt = pIt->next) && pIt != lIt->head); } if(lIt->numPoints != 2) { glEnd(); // N-vertex primitive ends. } } if(primType == GL_LINES) { // Close any remaining open 2-vertex set. glEnd(); } }
/** Contains the vertex, normal and texture calls that draw the primitive. */ void C3dLine::draw () const { C3dPoint::draw(); glNormal3dv(m_VN1.dv()); glTexCoord2dv(m_VTex1.dv()); m_V1.vertex(); }
void Triangle::render() const { bool materials_nonnull = true; for ( int i = 0; i < 3; ++i ) materials_nonnull = materials_nonnull && vertices[i].material; // this doesn't interpolate materials. Ah well. if ( materials_nonnull ) vertices[0].material->set_gl_state(); glBegin(GL_TRIANGLES); // glBegin(GL_LINE_LOOP); glNormal3dv( &vertices[0].normal.x ); glTexCoord2dv( &vertices[0].tex_coord.x ); glVertex3dv( &vertices[0].position.x ); glNormal3dv( &vertices[1].normal.x ); glTexCoord2dv( &vertices[1].tex_coord.x ); glVertex3dv( &vertices[1].position.x); glNormal3dv( &vertices[2].normal.x ); glTexCoord2dv( &vertices[2].tex_coord.x ); glVertex3dv( &vertices[2].position.x); glEnd(); // 545 /* glBegin(GL_LINES); const Vertex * v; Vector3 p, n; for(int i=0; i<3; i++) { v = &vertices[i]; p = v->position; n = v->normal; glVertex3f(p.x, p.y, p.z); glVertex3f(p.x+n.x, p.y+n.y, p.z+n.z); } glEnd(); */ if ( materials_nonnull ) vertices[0].material->reset_gl_state(); }
/* Render us using the current color and texture state */ void CkQuadView::render(void) { #ifdef CMK_LIVEVIZ3D_CLIENT c_tex->bind(); glBegin (nCorners==4?GL_QUADS:GL_TRIANGLE_STRIP); for (int i=0;i<nCorners;i++) { glTexCoord2dv(texCoord[i]); glVertex3dv(corners[i]); } glEnd(); #endif }
// Construct the display lists void MD5Surface::createDisplayLists() { // Release old display lists first releaseDisplayLists(); // Create the list for lighting mode _lightingList = glGenLists(1); assert(_lightingList != 0); glNewList(_lightingList, GL_COMPILE); glBegin(GL_TRIANGLES); for (Indices::const_iterator i = _indices.begin(); i != _indices.end(); ++i) { // Get the vertex for this index ArbitraryMeshVertex& v = _vertices[*i]; // Submit the vertex attributes and coordinate if (GLEW_ARB_vertex_program) { // Submit the vertex attributes and coordinate glVertexAttrib2dvARB(ATTR_TEXCOORD, v.texcoord); glVertexAttrib3dvARB(ATTR_TANGENT, v.tangent); glVertexAttrib3dvARB(ATTR_BITANGENT, v.bitangent); glVertexAttrib3dvARB(ATTR_NORMAL, v.normal); } glVertex3dv(v.vertex); } glEnd(); glEndList(); // Generate the list for flat-shaded (unlit) mode _normalList = glGenLists(1); assert(_normalList != 0); glNewList(_normalList, GL_COMPILE); glBegin(GL_TRIANGLES); for (Indices::const_iterator i = _indices.begin(); i != _indices.end(); ++i) { // Get the vertex for this index ArbitraryMeshVertex& v = _vertices[*i]; // Submit attributes glNormal3dv(v.normal); glTexCoord2dv(v.texcoord); glVertex3dv(v.vertex); } glEnd(); glEndList(); }
void draw_tex_font_char( tex_font_metrics_t *tfm, char c ) { tfm_char_data_t *cd; cd = find_char_data( tfm, c ); glBegin( GL_QUADS ); { glTexCoord2dv( (scalar_t*) &cd->tex_ll ); glVertex2dv( (scalar_t*) &cd->ll ); glTexCoord2dv( (scalar_t*) &cd->tex_lr ); glVertex2dv( (scalar_t*) &cd->lr ); glTexCoord2dv( (scalar_t*) &cd->tex_ur ); glVertex2dv( (scalar_t*) &cd->ur ); glTexCoord2dv( (scalar_t*) &cd->tex_ul ); glVertex2dv( (scalar_t*) &cd->ul ); } glEnd(); glTranslatef( cd->kern_width, 0., 0. ); }
void __glXDisp_TexCoord2dv(GLbyte *pc) { #ifdef __GLX_ALIGN64 if ((unsigned long)(pc) & 7) { __GLX_MEM_COPY(pc-4, pc, 16); pc -= 4; } #endif glTexCoord2dv( (GLdouble *)(pc + 0) ); }
/* ** 箱の描画 */ void box(double x, double y, double z) { /* 頂点の座標値 */ const GLdouble vertex[][4][3] = { {{ -x, -y, -z }, { x, -y, -z }, { x, -y, z }, { -x, -y, z }}, {{ -x, -y, -z }, { -x, y, -z }, { x, y, -z }, { x, -y, -z }}, {{ x, -y, -z }, { x, y, -z }, { x, y, z }, { x, -y, z }}, {{ x, -y, z }, { x, y, z }, { -x, y, z }, { -x, -y, z }}, {{ -x, -y, z }, { -x, y, z }, { -x, y, -z }, { -x, -y, -z }}, {{ -x, y, z }, { x, y, z }, { x, y, -z }, { -x, y, -z }}, }; /* 頂点のテクスチャ座標 */ static const GLdouble texcoord[][4][2] = { {{ 0.0, 0.0 }, { 0.0, 1.0 }, { 1.0, 1.0 }, { 1.0, 0.0 }}, {{ 0.0, 0.0 }, { 0.0, 1.0 }, { 1.0, 1.0 }, { 1.0, 0.0 }}, {{ 0.0, 0.0 }, { 0.0, 1.0 }, { 1.0, 1.0 }, { 1.0, 0.0 }}, {{ 0.0, 0.0 }, { 0.0, 1.0 }, { 1.0, 1.0 }, { 1.0, 0.0 }}, {{ 0.0, 0.0 }, { 0.0, 1.0 }, { 1.0, 1.0 }, { 1.0, 0.0 }}, {{ 0.0, 0.0 }, { 0.0, 1.0 }, { 1.0, 1.0 }, { 1.0, 0.0 }}, }; /* 面の法線ベクトル */ static const GLdouble normal[][3] = { { 0.0, -1.0, 0.0 }, { 0.0, 0.0, -1.0 }, { 1.0, 0.0, 0.0 }, { 0.0, 0.0, 1.0 }, { -1.0, 0.0, 0.0 }, { 0.0, 1.0, 0.0 }, }; int i, j; /* 四角形6枚で箱を描く */ glBegin(GL_QUADS); for (j = 0; j < 6; ++j) { glNormal3dv(normal[j]); for (i = 0; i < 4; ++i) { /* テクスチャ座標の指定 */ glTexCoord2dv(texcoord[j][i]); /* 対応する頂点座標の指定 */ glVertex3dv(vertex[j][i]); } } glEnd(); }
//******** TRI STRIPS ******** virtual void faceCB(CBvert* v, CBface* f) { assert(v && f); glNormal3dv(f->norm().data()); if (v->has_color()) { GL_COL(v->color(), alpha*v->alpha()); } //pass texture coordinates to opengl glTexCoord2dv(att_function->get_attrib(v,f).data()); send_d(v,f); glVertex3dv(v->loc().data()); // vertex coordinates }
void model::render() { // default material setup glBindTexture(GL_TEXTURE_2D, 0); glPushMatrix(); setModelview(); glBegin(GL_TRIANGLES); std::list<materialAssoc>::const_iterator materialIdx = _renderMap.begin(); idx3d k = 0; for (std::list<mesh>::const_iterator i = _mesh.begin(); i != _mesh.end();) { if (materialIdx != _renderMap.end()) { if (k == (*materialIdx).startIndex) { (*materialIdx).material->setup(); materialIdx++; } } //glBegin(GL_LINE_STRIP); for (unsigned char j = 0; j < 3 && i != _mesh.end(); j++) { //glColor3dv(color[j]); glVertex3dv(&i->vertex.x); //glNormal3dv(&i->normal.x); glTexCoord2dv(&i->texture.x); i++; } //glEnd(); k++; } glEnd(); glPopMatrix(); }
inline void glTexCoord2v( const GLdouble * v ) { glTexCoord2dv( v ); }
void DrawParabolicMapWithSphere() { glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-width, width, -height, height, -100000, 100000); gluLookAt(0, 0, 1, 0, 0, 0, 0, -1, 0); glViewport(0, 0, width * 2, height * 2); glScissor(0, 0, width * 2, height * 2); glClearColor(1,1,1, 1); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); double showMapPoints[LOD+1][LOD+1][2]; double showMapTexCoords[LOD+1][LOD+1][2]; for (int i = 0; i <= LOD; i++) { float x = i * 1.0 / LOD; for (int j = 0; j <= LOD; j++) { float y = j * 1.0 / LOD; showMapPoints[i][j][0] = x * width; showMapPoints[i][j][1] = y * height; float parabolic_x, parabolic_y, parabolic_z; // float parabolic_x = ((mapped.x / (2 * (1 + mapped.z))) + 0.5) / 2; // float parabolic_y = (-mapped.y / (2 * (1 + mapped.z))) + 0.5; // float parabolic_z = (1 - parabolic_x * parabolic_x + parabolic_y * parabolic_y) / 2; if (i < LOD / 2) { parabolic_x = (2 * x - 0.5) * 2; parabolic_y = -(2 * y - 1); parabolic_z = (1 - (parabolic_x * parabolic_x + parabolic_y * parabolic_y)) / 2; } else { parabolic_x = (2 * (x - 0.5) - 0.5) * 2; parabolic_y = -(2 * y - 1); parabolic_z = -(1 - (parabolic_x * parabolic_x + parabolic_y * parabolic_y)) / 2; } // printf("para : %f, %f, %f\n",parabolic_x, parabolic_y, parabolic_z); Vector3d mapped = Vector3d(parabolic_x, parabolic_y, parabolic_z); mapped.normalize(); double sum = sqrt(mapped.x*mapped.x + mapped.y*mapped.y + pow(mapped.z+1,2)); showMapTexCoords[i][j][0] = (mapped.x/sum + 1) / 2; showMapTexCoords[i][j][1] = (-mapped.y/sum + 1) / 2; // showMapTexCoords[i][j][0] = x; // showMapTexCoords[i][j][1] = y; } } glEnable(GL_TEXTURE_2D); for (int i = 0; i < LOD; i++) { glBegin(GL_QUAD_STRIP); for (int j = 0; j < LOD; j++) { glTexCoord2dv(showMapTexCoords[i][j]); glVertex2dv(showMapPoints[i][j]); glTexCoord2dv(showMapTexCoords[i + 1][j]); glVertex2dv(showMapPoints[i + 1][j]); } glEnd(); } glDisable(GL_TEXTURE_2D); return; }
void APIENTRY glu_vertex(GLdouble *xyz) /* I - XYZ location + ST texture coordinate */ { glTexCoord2dv(xyz + 3); glVertex3dv(xyz); }
void texture2(const Point &p) { glTexCoord2dv(p.v); }
template< > inline void glTexCoord2v< Vector3r > ( const Vector3r v ) { glTexCoord2dv((double*)&v); };
///////////////////////////////////////////////////////// // Render // void GEMglTexCoord2dv :: render(GemState *state) { glTexCoord2dv (v); }
PsychError SCREENDontCopyWindow(void) { PsychRectType sourceRect, targetRect, targetRectInverted; PsychWindowRecordType *sourceWin, *targetWin; GLdouble sourceVertex[2], targetVertex[2]; double t1,t2; double sourceRectWidth, sourceRectHeight; //all sub functions should have these two lines PsychPushHelp(useString, synopsisString, seeAlsoString); if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);}; //cap the number of inputs PsychErrorExit(PsychCapNumInputArgs(5)); //The maximum number of inputs PsychErrorExit(PsychCapNumOutputArgs(0)); //The maximum number of outputs //get parameters for the source window: PsychAllocInWindowRecordArg(1, TRUE, &sourceWin); PsychCopyRect(sourceRect, sourceWin->rect); PsychCopyInRectArg(3, FALSE, sourceRect); //get paramters for the target window: PsychAllocInWindowRecordArg(2, TRUE, &targetWin); PsychCopyRect(targetRect, targetWin->rect); PsychCopyInRectArg(4, FALSE, targetRect); //Check that the windows agree in depth. They don't have to agree in format because we convert to the correct format for the target when we //create the texture. if(sourceWin->depth != targetWin->depth) PsychErrorExitMsg(PsychError_user, "Source and target windows must have the same bit depth"); //We need to unbind the source window texture from any previous target contexts if it is bound. There can be only one binding at a time. //We could augment the Psychtoolbox to support shared contexts and multiple bindings. PsychRetargetWindowToWindow(sourceWin, targetWin); //each of these next three commands makes changes only when neccessary, they can be called generously //when there is a possibility that any are necessary. //PsychGetPrecisionTimerSeconds(&t1); PsychAllocateTexture(sourceWin); PsychBindTexture(sourceWin); PsychUpdateTexture(sourceWin); //PsychGetPrecisionTimerSeconds(&t2); //mexPrintf("texture checking copywindow took %f seconds\n", t2-t1); //PsychGetPrecisionTimerSeconds(&t1); PsychGetPrecisionTimerSeconds(&t1); PsychSetGLContext(targetWin); glBindTexture(GL_TEXTURE_RECTANGLE_EXT, sourceWin->glTexture); sourceRectWidth= PsychGetWidthFromRect(sourceWin->rect); sourceRectHeight= PsychGetHeightFromRect(sourceWin->rect); glTexSubImage2D(GL_TEXTURE_RECTANGLE_EXT, 0, 0, 0, (GLsizei)sourceRectWidth, (GLsizei)sourceRectHeight, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, sourceWin->textureMemory); PsychInvertRectY(targetRectInverted, targetRect, targetWin->rect); //PsychGetPrecisionTimerSeconds(&t1); targetVertex[0]=0; targetVertex[1]=0; glBegin(GL_QUADS); glTexCoord2dv(PsychExtractQuadVertexFromRect(sourceRect, 0, sourceVertex)); glVertex2dv(targetVertex); glTexCoord2dv(PsychExtractQuadVertexFromRect(sourceRect, 1, sourceVertex)); glVertex2dv(targetVertex); glTexCoord2dv(PsychExtractQuadVertexFromRect(sourceRect, 2, sourceVertex)); glVertex2dv(targetVertex); glTexCoord2dv(PsychExtractQuadVertexFromRect(sourceRect, 3, sourceVertex)); glVertex2dv(targetVertex); glEnd(); glFinish(); //PsychGetPrecisionTimerSeconds(&t2); //mexPrintf("copywindow took %f seconds\n", t2-t1); return(PsychError_none); }
void DrawParabolicMapWithCube() { glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-width, width, -height, height, -100000, 100000); gluLookAt(0, 0, 1, 0, 0, 0, 0, -1, 0); glViewport(0, 0, width * 2, height * 2); glScissor(0, 0, width * 2, height * 2); glClearColor(1,1,1, 1); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); double showMapPoints[LOD+1][LOD+1][2]; double showMapTexCoords[LOD+1][LOD+1][2]; for (int i = 0; i <= LOD; i++) { float x = i * 1.0 / LOD; for (int j = 0; j <= LOD; j++) { float y = j * 1.0 / LOD; showMapPoints[i][j][0] = x * width; showMapPoints[i][j][1] = y * height; float parabolic_x, parabolic_y, parabolic_z; // float parabolic_x = ((mapped.x / (2 * (1 + mapped.z))) + 0.5) / 2; // float parabolic_y = (-mapped.y / (2 * (1 + mapped.z))) + 0.5; // float parabolic_z = (1 - parabolic_x * parabolic_x + parabolic_y * parabolic_y) / 2; if (i < LOD / 2) { parabolic_x = (2 * x - 0.5) * 2; parabolic_y = -(2 * y - 1); parabolic_z = (1 - (parabolic_x * parabolic_x + parabolic_y * parabolic_y)) / 2; } else { parabolic_x = (2 * (x - 0.5) - 0.5) * 2; parabolic_y = -(2 * y - 1); parabolic_z = -(1 - (parabolic_x * parabolic_x + parabolic_y * parabolic_y)) / 2; } // printf("para : %f, %f, %f\n",parabolic_x, parabolic_y, parabolic_z); Vector3d mapped = Vector3d(parabolic_x, parabolic_y, parabolic_z); mapped.normalize(); float padding_y = 1/3.0; float padding_x = 1/4.0; if (mapped.x >= std::abs(mapped.y) && mapped.x >= std::abs(mapped.z)) { // right showMapTexCoords[i][j][0] = (-mapped.z / mapped.x + 1) / 2 / 4 + padding_x * 2; showMapTexCoords[i][j][1] = (-mapped.y / mapped.x + 1) / 2 / 3 + padding_y; } else if (mapped.y >= std::abs(mapped.x) && mapped.y >= std::abs(mapped.z)) { // top showMapTexCoords[i][j][0] = (mapped.x / mapped.y + 1) / 2 / 4 + padding_x; showMapTexCoords[i][j][1] = (mapped.z / mapped.y + 1) / 2 / 3; } else if (mapped.z >= std::abs(mapped.x) && mapped.z >= std::abs(mapped.y)) { // front showMapTexCoords[i][j][0] = (mapped.x / mapped.z + 1) / 2 / 4 + padding_x; showMapTexCoords[i][j][1] = (-mapped.y / mapped.z + 1) / 2 / 3 + padding_y; } else if (mapped.x <= -std::abs(mapped.y) && mapped.x <= -std::abs(mapped.z)) { // left showMapTexCoords[i][j][0] = (-mapped.z / mapped.x + 1) / 2 / 4; showMapTexCoords[i][j][1] = (mapped.y / mapped.x + 1) / 2 / 3 + padding_y; } else if (mapped.y <= -std::abs(mapped.x) && mapped.y <= -std::abs(mapped.z)) { // bottom showMapTexCoords[i][j][0] = (-mapped.x / mapped.y + 1) / 2 / 4 + padding_x; showMapTexCoords[i][j][1] = (mapped.z / mapped.y + 1) / 2 / 3 + padding_y * 2; } else if (mapped.z <= -std::abs(mapped.x) && mapped.z <= -std::abs(mapped.y)) { // back showMapTexCoords[i][j][0] = (mapped.x / mapped.z + 1) / 2 / 4 + padding_x * 3; showMapTexCoords[i][j][1] = (mapped.y / mapped.z + 1) / 2 / 3 + padding_y; } // showMapTexCoords[i][j][0] = x; // showMapTexCoords[i][j][1] = y; } } glEnable(GL_TEXTURE_2D); for (int i = 0; i < LOD; i++) { glBegin(GL_QUAD_STRIP); for (int j = 0; j < LOD; j++) { glTexCoord2dv(showMapTexCoords[i][j]); glVertex2dv(showMapPoints[i][j]); glTexCoord2dv(showMapTexCoords[i + 1][j]); glVertex2dv(showMapPoints[i + 1][j]); } glEnd(); } glDisable(GL_TEXTURE_2D); return; }
inline void glTexCoord(Vector2d const &v) { glTexCoord2dv(v.c); }
M(void, glTexCoord2dv, jobject v) { glTexCoord2dv(BUFF(GLdouble, v)); }
/** Draw the polyhedron. */ void PolyhedronGeom::drawGL() { // No tesselation object allocated yet? Then do so once and for all... if (tess==0) { tess = gluNewTess(); if (tess==0) return; } // Set flag to 0 (i.e. no variables are present so far) tess_data_flag = 0; PrimVarAccess<vec3d> normals(*this, std::string("N"), NORMAL, 1, std::string("Nfaces")); PrimVarAccess<double> texcoords(*this, std::string("st"), FLOAT, 2, std::string("stfaces")); PrimVarAccess<vec3d> colors(*this, std::string("Cs"), COLOR, 1, std::string("Csfaces")); vec3d* N; vec3d* Cs; GLfloat glcol[4] = {0,0,0,1}; double* st; vec3d* vertsptr = verts.dataPtr(); int i,j; int nfloats=3; // Check which variables has to be passed to the vertex callback // (this is the case when mode is > 2) if (normals.mode>2) { tess_data_flag |= 0x01; nfloats += 3; } if (texcoords.mode>2) { tess_data_flag |= 0x02; nfloats += 2; } if (colors.mode>2) { tess_data_flag |= 0x04; nfloats += 3; } dataMemManager.setDataSize(nfloats*sizeof(GLdouble)); gluTessCallback(tess, GLU_TESS_BEGIN, (TessCallback)(&onTessBegin)); gluTessCallback(tess, GLU_TESS_END, (TessCallback)(&onTessEnd)); gluTessCallback(tess, GLU_TESS_VERTEX, (TessCallback)(&onTessVertex)); gluTessProperty(tess, GLU_TESS_BOUNDARY_ONLY, GL_FALSE); gluTessProperty(tess, GLU_TESS_TOLERANCE, 0); gluTessProperty(tess, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ODD); // Iterate over all polygons... for(i=0; i<getNumPolys(); i++) { dataMemManager.reset(); // No normals? Then a face normal has to be calculated... if (normals.mode==0) { vec3d Ng; computeNormal(i, Ng); glNormal3d(Ng.x, Ng.y, Ng.z); } // Process uniform variables... if (normals.onFace(N)) glNormal3d(N->x, N->y, N->z); if (texcoords.onFace(st)) glTexCoord2dv(st); if (colors.onFace(Cs)) { glcol[0] = GLfloat(Cs->x); glcol[1] = GLfloat(Cs->y); glcol[2] = GLfloat(Cs->z); glMaterialfv(GL_FRONT, GL_DIFFUSE, glcol); } gluTessBeginPolygon(tess, 0); // Iterate over all loops of polygon i... for(j=0; j<getNumLoops(i); j++) { gluTessBeginContour(tess); LoopIterator it = loopBegin(i, j); LoopIterator itend = loopEnd(i, j); vec3d* v; for( ; it!=itend; it++) { int vidx = (*it); v = vertsptr + vidx; GLdouble* data = (GLdouble*)dataMemManager.newDataPtr(); GLdouble* p = data+3; data[0] = v->x; data[1] = v->y; data[2] = v->z; if (normals.onVertex(vidx, N)) { p[0] = N->x; p[1] = N->y; p[2] = N->z; p += 3; } if (texcoords.onVertex(vidx, st)) { p[0] = st[0]; p[1] = st[1]; p += 2; } if (colors.onVertex(vidx, Cs)) { p[0] = Cs->x; p[1] = Cs->y; p[2] = Cs->z; } gluTessVertex(tess, data, data); } gluTessEndContour(tess); } gluTessEndPolygon(tess); } /* for(i=0; i<getNumPolys(); i++) { for(j=0; j<getNumLoops(i); j++) { LoopIterator it = loopBegin(i, j); LoopIterator itend = loopEnd(i, j); vec3d* v; glBegin(GL_LINE_LOOP); for( ; it!=itend; it++) { v = vertsptr + (*it); glVertex3d(v->x, v->y, v->z); } glEnd(); } }*/ }
void DrawSurface() { for (int i = 0; i <= LOD; i++) for (int j = 0; j <= LOD; j++) { // calculating reflecting vector Vector3d mapped; mapped.sub(center, eye); Vector3d n = Vector3d(surfaceNormals[i][j][0], surfaceNormals[i][j][1], surfaceNormals[i][j][2]); n.scale(-2 * n.dot(mapped)); mapped.add(n); mapped.normalize(); if (mapped.z >= 0) { float parabolic_x = ((mapped.x / (2 * (1 + mapped.z))) + 0.5) / 2; float parabolic_y = (-mapped.y / (2 * (1 + mapped.z))) + 0.5; texCoords[i][j][0] = parabolic_x; texCoords[i][j][1] = parabolic_y; } else { float parabolic_x = ((mapped.x / (2 * (1 - mapped.z))) + 0.5) / 2 + 0.5; float parabolic_y = (-mapped.y / (2 * (1 - mapped.z))) + 0.5; texCoords[i][j][0] = parabolic_x; texCoords[i][j][1] = parabolic_y; } // double sum = sqrt(mapped.x*mapped.x + mapped.y*mapped.y + pow(mapped.z+1,2)); // texCoords[i][j][0] = (mapped.x/sum + 1) / 2; // texCoords[i][j][1] = (-mapped.y/sum + 1) / 2; // float padding_y = 1/3.0; // float padding_x = 1/4.0; // if (mapped.x >= std::abs(mapped.y) && mapped.x >= std::abs(mapped.z)) { // right // texCoords[i][j][0] = (-mapped.z / mapped.x + 1) / 2 / 4 + padding_x * 2; // texCoords[i][j][1] = (-mapped.y / mapped.x + 1) / 2 / 3 + padding_y; // } else if (mapped.y >= std::abs(mapped.x) && mapped.y >= std::abs(mapped.z)) { // top // texCoords[i][j][0] = (mapped.x / mapped.y + 1) / 2 / 4 + padding_x; // texCoords[i][j][1] = (mapped.z / mapped.y + 1) / 2 / 3; // } else if (mapped.z >= std::abs(mapped.x) && mapped.z >= std::abs(mapped.y)) { // front // texCoords[i][j][0] = (mapped.x / mapped.z + 1) / 2 / 4 + padding_x; // texCoords[i][j][1] = (-mapped.y / mapped.z + 1) / 2 / 3 + padding_y; // } else if (mapped.x <= -std::abs(mapped.y) && mapped.x <= -std::abs(mapped.z)) { // left // texCoords[i][j][0] = (-mapped.z / mapped.x + 1) / 2 / 4; // texCoords[i][j][1] = (mapped.y / mapped.x + 1) / 2 / 3 + padding_y; // } else if (mapped.y <= -std::abs(mapped.x) && mapped.y <= -std::abs(mapped.z)) { // bottom // texCoords[i][j][0] = (-mapped.x / mapped.y + 1) / 2 / 4 + padding_x; // texCoords[i][j][1] = (mapped.z / mapped.y + 1) / 2 / 3 + padding_y * 2; // } else if (mapped.z <= -std::abs(mapped.x) && mapped.z <= -std::abs(mapped.y)) { // back // texCoords[i][j][0] = (mapped.x / mapped.z + 1) / 2 / 4 + padding_x * 3; // texCoords[i][j][1] = (mapped.y / mapped.z + 1) / 2 / 3 + padding_y; // } } glEnable(GL_TEXTURE_2D); for (int i = 0; i < LOD; i++) { glBegin(GL_QUAD_STRIP); for (int j = 0; j <= LOD; j++) { glTexCoord2dv(texCoords[i][j]); glVertex3dv(surfacePoints[i][j]); glTexCoord2dv(texCoords[i+1][j]); glVertex3dv(surfacePoints[i+1][j]); } glEnd(); } glDisable(GL_TEXTURE_2D); }