void Device::draw_pixels(device_memory& rgba, int y, int w, int h, int dx, int dy, int width, int height, bool transparent, const DeviceDrawParams &draw_params) { pixels_copy_from(rgba, y, w, h); if(transparent) { glEnable(GL_BLEND); glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); } glColor3f(1.0f, 1.0f, 1.0f); if(rgba.data_type == TYPE_HALF) { /* for multi devices, this assumes the inefficient method that we allocate * all pixels on the device even though we only render to a subset */ GLhalf *data_pointer = (GLhalf*)rgba.data_pointer; float vbuffer[16], *basep; float *vp = NULL; data_pointer += 4*y*w; /* draw half float texture, GLSL shader for display transform assumed to be bound */ GLuint texid; glGenTextures(1, &texid); glBindTexture(GL_TEXTURE_2D, texid); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F_ARB, w, h, 0, GL_RGBA, GL_HALF_FLOAT, data_pointer); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glEnable(GL_TEXTURE_2D); if(draw_params.bind_display_space_shader_cb) { draw_params.bind_display_space_shader_cb(); } if(GLEW_VERSION_1_5) { if(!vertex_buffer) glGenBuffers(1, &vertex_buffer); glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer); /* invalidate old contents - avoids stalling if buffer is still waiting in queue to be rendered */ glBufferData(GL_ARRAY_BUFFER, 16 * sizeof(float), NULL, GL_STREAM_DRAW); vp = (float *)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY); basep = NULL; } else { basep = vbuffer; vp = vbuffer; } if(vp) { /* texture coordinate - vertex pair */ vp[0] = 0.0f; vp[1] = 0.0f; vp[2] = dx; vp[3] = dy; vp[4] = 1.0f; vp[5] = 0.0f; vp[6] = (float)width + dx; vp[7] = dy; vp[8] = 1.0f; vp[9] = 1.0f; vp[10] = (float)width + dx; vp[11] = (float)height + dy; vp[12] = 0.0f; vp[13] = 1.0f; vp[14] = dx; vp[15] = (float)height + dy; if(vertex_buffer) glUnmapBuffer(GL_ARRAY_BUFFER); } glTexCoordPointer(2, GL_FLOAT, 4 * sizeof(float), basep); glVertexPointer(2, GL_FLOAT, 4 * sizeof(float), ((char *)basep) + 2 * sizeof(float)); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); if(vertex_buffer) { glBindBuffer(GL_ARRAY_BUFFER, 0); } if(draw_params.unbind_display_space_shader_cb) { draw_params.unbind_display_space_shader_cb(); } glBindTexture(GL_TEXTURE_2D, 0); glDisable(GL_TEXTURE_2D); glDeleteTextures(1, &texid); } else { /* fallback for old graphics cards that don't support GLSL, half float, * and non-power-of-two textures */ glPixelZoom((float)width/(float)w, (float)height/(float)h); glRasterPos2f(dx, dy); uint8_t *pixels = (uint8_t*)rgba.data_pointer; pixels += 4*y*w; glDrawPixels(w, h, GL_RGBA, GL_UNSIGNED_BYTE, pixels); glRasterPos2f(0.0f, 0.0f); glPixelZoom(1.0f, 1.0f); } if(transparent) glDisable(GL_BLEND); }
void SS3OPiece::DrawForList() const { if (!hasGeometryData) return; vboAttributes.Bind(GL_ARRAY_BUFFER); glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(3, GL_FLOAT, sizeof(SS3OVertex), vboAttributes.GetPtr(offsetof(SS3OVertex, pos))); glEnableClientState(GL_NORMAL_ARRAY); glNormalPointer(GL_FLOAT, sizeof(SS3OVertex), vboAttributes.GetPtr(offsetof(SS3OVertex, normal))); glClientActiveTexture(GL_TEXTURE0); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(2, GL_FLOAT, sizeof(SS3OVertex), vboAttributes.GetPtr(offsetof(SS3OVertex, texCoord))); glClientActiveTexture(GL_TEXTURE1); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(2, GL_FLOAT, sizeof(SS3OVertex), vboAttributes.GetPtr(offsetof(SS3OVertex, texCoord))); glClientActiveTexture(GL_TEXTURE5); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(3, GL_FLOAT, sizeof(SS3OVertex), vboAttributes.GetPtr(offsetof(SS3OVertex, sTangent))); glClientActiveTexture(GL_TEXTURE6); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(3, GL_FLOAT, sizeof(SS3OVertex), vboAttributes.GetPtr(offsetof(SS3OVertex, tTangent))); vboAttributes.Unbind(); vboIndices.Bind(GL_ELEMENT_ARRAY_BUFFER); switch (primType) { case S3O_PRIMTYPE_TRIANGLES: { glDrawRangeElements(GL_TRIANGLES, 0, vertices.size() - 1, vertexDrawIndices.size(), GL_UNSIGNED_INT, vboIndices.GetPtr()); } break; case S3O_PRIMTYPE_TRIANGLE_STRIP: { #ifdef GLEW_NV_primitive_restart if (globalRendering->supportRestartPrimitive) { // this is not compiled into display lists, but executed immediately glPrimitiveRestartIndexNV(-1U); glEnableClientState(GL_PRIMITIVE_RESTART_NV); } #endif glDrawRangeElements(GL_TRIANGLE_STRIP, 0, vertices.size() - 1, vertexDrawIndices.size(), GL_UNSIGNED_INT, vboIndices.GetPtr()); #ifdef GLEW_NV_primitive_restart if (globalRendering->supportRestartPrimitive) { glDisableClientState(GL_PRIMITIVE_RESTART_NV); } #endif } break; case S3O_PRIMTYPE_QUADS: { glDrawRangeElements(GL_QUADS, 0, vertices.size() - 1, vertexDrawIndices.size(), GL_UNSIGNED_INT, vboIndices.GetPtr()); } break; } vboIndices.Unbind(); glClientActiveTexture(GL_TEXTURE6); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glClientActiveTexture(GL_TEXTURE5); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glClientActiveTexture(GL_TEXTURE1); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glClientActiveTexture(GL_TEXTURE0); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); }
// DRAW A TEXTURE INTO THE THE SHARED TEXTURE VIA AN FBO bool spoutGLDXinterop::DrawToSharedTexture(GLuint TextureID, GLuint TextureTarget, unsigned int width, unsigned int height, float max_x, float max_y, float aspect, bool bInvert, GLuint HostFBO) { if(m_hInteropDevice == NULL || m_hInteropObject == NULL) { return false; } if(width != (unsigned int)m_TextureInfo.width || height != (unsigned int)m_TextureInfo.height) { return false; } // Wait for access to the texture if(spoutdx.CheckAccess(m_hAccessMutex, g_pSharedTexture)) { if(LockInteropObject(m_hInteropDevice, &m_hInteropObject) == S_OK) { // Draw the input texture into the shared texture via an fbo // Bind our fbo glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo); glFramebufferTexture2DEXT(GL_READ_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_glTexture, 0); glBindTexture(GL_TEXTURE_2D, m_glTexture); glColor4f(1.f, 1.f, 1.f, 1.f); glEnable(TextureTarget); glBindTexture(TextureTarget, TextureID); GLfloat tc[4][2] = {0}; if(bInvert) { tc[0][0] = 0.0; tc[0][1] = max_y; tc[1][0] = 0.0; tc[1][1] = 0.0; tc[2][0] = max_x; tc[2][1] = 0.0; tc[3][0] = max_x; tc[3][1] = max_y; } else { tc[0][0] = 0.0; tc[0][1] = 0.0; tc[1][0] = 0.0; tc[1][1] = max_y; tc[2][0] = max_x; tc[2][1] = max_y; tc[3][0] = max_x; tc[3][1] = 0.0; } GLfloat verts[] = { -aspect, -1.0, // bottom left -aspect, 1.0, // top left aspect, 1.0, // top right aspect, -1.0 }; // bottom right glEnableClientState( GL_TEXTURE_COORD_ARRAY ); glTexCoordPointer(2, GL_FLOAT, 0, tc ); glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(2, GL_FLOAT, 0, verts ); glDrawArrays( GL_TRIANGLE_FAN, 0, 4 ); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glBindTexture(TextureTarget, 0); glDisable(TextureTarget); glBindTexture(GL_TEXTURE_2D, 0); // restore the previous fbo - default is 0 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, HostFBO); UnlockInteropObject(m_hInteropDevice, &m_hInteropObject); } } spoutdx.AllowAccess(m_hAccessMutex, g_pSharedTexture); // Allow access to the texture return true; }
void FGAPIENTRY glutSolidConex(GLfixed base, GLfixed height, GLint slices, GLint stacks) { GLint i, j; float twopi, nx, ny, nz; static GLfixed* v, *n; static GLfixed parms[4]; GLfixed* p, *q; float basef = _FIXED2FLOAT(base); float heightf = _FIXED2FLOAT(height); if (v) { if (parms[0] != base || parms[1] != height || parms[2] != slices || parms[3] != stacks) { free(v); free(n); n = v = 0; glVertexPointer(3, GL_FIXED, 0, 0); glNormalPointer(GL_FIXED, 0, 0); } } if ((!v) && (height != 0)) { float phi = (float)atan(basef/heightf); float cphi = (float)cos(phi); float sphi= (float)sin(phi); parms[0] = base; parms[1] = height; parms[2] = (GLfixed)slices; parms[3] = (GLfixed)stacks; p = v = (GLfixed*)malloc(stacks*(slices+1)*2*3*sizeof *v); q = n = (GLfixed*)malloc(stacks*(slices+1)*2*3*sizeof *n); twopi = 2.0f * ((float)PI_); for (i = 0; i < stacks; i++) { float r = basef * (1.f - (float) i / stacks); float r1 = basef * (1.f - (float) (i + 1.f) / stacks); float z = heightf * i /stacks; float z1 = heightf * (1.f + i) / stacks; for (j = 0; j <= slices; j++) { float theta = j == slices ? 0.f : (float) j / slices * twopi; float ctheta = (float)cos(theta); float stheta = (float)sin(theta); nx = ctheta; ny = stheta; nz = sphi; *p++ = _FLOAT2FIXED(r1 * nx); *p++ = _FLOAT2FIXED(r1 * ny); *p++ = _FLOAT2FIXED(z1); *q++ = _FLOAT2FIXED(nx * cphi); *q++ = _FLOAT2FIXED(ny * cphi); *q++ = _FLOAT2FIXED(nz); *p++ = _FLOAT2FIXED(r * nx); *p++ = _FLOAT2FIXED(r * ny); *p++ = _FLOAT2FIXED(z); *q++ = _FLOAT2FIXED(nx * cphi); *q++ = _FLOAT2FIXED(ny * cphi); *q++ = _FLOAT2FIXED(nz); } } } glVertexPointer(3, GL_FIXED, 0, v); glNormalPointer(GL_FIXED, 0, n); glEnableClientState (GL_VERTEX_ARRAY); glEnableClientState (GL_NORMAL_ARRAY); for(i = 0; i < stacks; i++) glDrawArrays(GL_TRIANGLE_STRIP, i*(slices+1)*2, (slices+1)*2); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); }
void FGAPIENTRY glutSolidCubex(GLfixed size) { static GLfixed v[108]; // 108 = 6*18 static const int cubev[108] = { -1, -1, 1, /* front */ 1, -1, 1, -1, 1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1, -1, 1, -1, /* back */ 1, -1, -1, -1, -1, -1, -1, 1, -1, 1, 1, -1, 1, -1, -1, -1, -1, -1, /* left */ -1, -1, 1, -1, 1, -1, -1, -1, 1, -1, 1, 1, -1, 1, -1, 1, -1, 1, /* right */ 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1, -1, 1, 1, 1, -1, 1, 1, /* top */ 1, 1, 1, -1, 1, -1, 1, 1, 1, 1, 1, -1, -1, 1, -1, -1, -1, -1, /* bottom */ 1, -1, -1, -1, -1, 1, 1, -1, -1, 1, -1, 1, -1, -1, 1, }; static const GLfixed cuben[108] = { 0, 0, F1, /* front */ 0, 0, F1, 0, 0, F1, 0, 0, F1, 0, 0, F1, 0, 0, F1, 0, 0, FM1, /* back */ 0, 0, FM1, 0, 0, FM1, 0, 0, FM1, 0, 0, FM1, 0, 0, FM1, FM1, 0, 0, /* left */ FM1, 0, 0, FM1, 0, 0, FM1, 0, 0, FM1, 0, 0, FM1, 0, 0, F1, 0, 0, /* right */ F1, 0, 0, F1, 0, 0, F1, 0, 0, F1, 0, 0, F1, 0, 0, 0, F1, 0, /* top */ 0, F1, 0, 0, F1, 0, 0, F1, 0, 0, F1, 0, 0, F1, 0, 0, FM1, 0, /* bottom */ 0, FM1, 0, 0, FM1, 0, 0, FM1, 0, 0, FM1, 0, 0, FM1, 0, }; int i; size /= 2; for(i = 0; i < 108; i++) v[i] = cubev[i] * size; glVertexPointer(3, GL_FIXED, 0, v); glNormalPointer(GL_FIXED, 0, cuben); glEnableClientState (GL_VERTEX_ARRAY); glEnableClientState (GL_NORMAL_ARRAY); glDrawArrays(GL_TRIANGLES, 0, 36); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); }
void RenderFXSpritesF(void) { int i,j; /* glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glColor4f(1.0f, 1.0f, 1.0f, 0.5f); SetTextureF(smokeTexture.textureId); if (numSmokeIndices != 0) { glVertexPointer( 2, GL_SHORT, sizeof(xf_colorless_sprite_t), smokeVertices->pos); glTexCoordPointer(2, GL_SHORT, sizeof(xf_colorless_sprite_t), smokeVertices->text); //glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(xf_sprite_t), smokeVertices->color); glDrawElements (GL_TRIANGLES, numSmokeIndices, GL_UNSIGNED_SHORT,smokeIndices); STATS_AddTriangles(numSmokeIndices/3); } glColor4f(1.0f, 1.0f, 1.0f, 1.0f); */ glBlendFunc(GL_SRC_ALPHA, GL_ONE); SetTextureF(smokeTexture.textureId); if (numSmokeIndices != 0) { glVertexPointer( 2, GL_SHORT, sizeof(xf_colorless_sprite_t), smokeVertices->pos); glTexCoordPointer(2, GL_SHORT, sizeof(xf_colorless_sprite_t), smokeVertices->text); //glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(xf_sprite_t), smokeVertices->color); glDrawElements (GL_TRIANGLES, numSmokeIndices, GL_UNSIGNED_SHORT,smokeIndices); STATS_AddTriangles(numSmokeIndices/3); } SetTextureF(ghostTexture.textureId); for(i=0 ; i <numPlayers ; i++) { /* if (i==0) glColor4f(0.8f, 0.8f, 1.0f, 0.9f); else { glColor4f(1.0f, 0.4f, 0.4f, 0.9f); } */ for (j=0; j< GHOSTS_NUM; j++) { if (players[i].ghosts[j].timeCounter >= GHOST_TTL_MS) continue; //vertices = &players[i].ghosts[j].wayPoints[players[i].ghosts[j].startVertexArray]; glVertexPointer( 2, GL_SHORT, sizeof(xf_colorless_sprite_t), players[i].ghosts[j].wayPoints[players[i].ghosts[j].startVertexArray].pos); glTexCoordPointer(2, GL_SHORT, sizeof(xf_colorless_sprite_t), players[i].ghosts[j].wayPoints[players[i].ghosts[j].startVertexArray].text); //glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(xf_sprite_t), vertices->color); glDrawArrays(GL_TRIANGLE_STRIP, 0, players[i].ghosts[j].lengthVertexArray); STATS_AddTriangles((players[i].ghosts[j].lengthVertexArray/2)); } } glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnableClientState(GL_COLOR_ARRAY); glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); //Render all particules if (numParticulesIndices != 0) { SetTextureF(bulletConfig.bulletTexture.textureId); glVertexPointer( 2, GL_SHORT, sizeof(xf_sprite_t), particuleVertices->pos); glTexCoordPointer(2, GL_SHORT, sizeof(xf_sprite_t), particuleVertices->text); glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(xf_sprite_t), particuleVertices->color); glDrawElements (GL_TRIANGLES, numParticulesIndices, GL_UNSIGNED_SHORT,particuleIndices); STATS_AddTriangles(numParticulesIndices/3); } //Render all explosions if (numExplosionIndices != 0) { SetTextureF(explosionTexture.textureId); glVertexPointer( 2, GL_SHORT, sizeof(xf_sprite_t), explosionVertices->pos); glTexCoordPointer(2, GL_SHORT, sizeof(xf_sprite_t), explosionVertices->text); //printf("REMOVE COLOR INDICES EXPLOSIONS RenderFXSpritesF !!!! \n"); glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(xf_sprite_t), explosionVertices->color); glDrawElements (GL_TRIANGLES, numExplosionIndices, GL_UNSIGNED_SHORT,explosionIndices); STATS_AddTriangles(numExplosionIndices/3); } //Render enemy FXs SetTextureF(bulletConfig.bulletTexture.textureId); glVertexPointer( 2, GL_SHORT, sizeof(xf_sprite_t), enFxLib.ss_vertices[0].pos); glTexCoordPointer(2, GL_SHORT, sizeof(xf_sprite_t), enFxLib.ss_vertices[0].text); glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(xf_sprite_t), enFxLib.ss_vertices[0].color); glDrawElements (GL_TRIANGLES, enFxLib.num_indices, GL_UNSIGNED_SHORT,enFxLib.indices); STATS_AddTriangles(enFxLib.num_indices/3); //printf("enFxLib.num_indices=%d\n",enFxLib.num_indices); #ifdef RENDER_COLL_BOXEX RenderCollisionBoxes(); #endif //glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glDisableClientState(GL_COLOR_ARRAY); }
void Waveform::Draw(RenderContext &context) { //if (samples > 2048) samples = 2048; if (additive) glBlendFunc(GL_SRC_ALPHA, GL_ONE); else glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); if (thick) { glLineWidth(context.texsize <= 512 ? 2 : 2*context.texsize/512); glPointSize(context.texsize <= 512 ? 2 : 2*context.texsize/512); } else glPointSize(context.texsize <= 512 ? 1 : context.texsize/512); float *value1 = new float[samples]; float *value2 = new float[samples]; context.beatDetect->pcm->getPCM( value1, samples, 0, spectrum, smoothing, 0); context.beatDetect->pcm->getPCM( value2, samples, 1, spectrum, smoothing, 0); // printf("%f\n",pcmL[0]); float mult= scaling*( spectrum ? 0.015f :1.0f); std::transform(&value1[0],&value1[samples],&value1[0],std::bind2nd(std::multiplies<float>(),mult)); std::transform(&value2[0],&value2[samples],&value2[0],std::bind2nd(std::multiplies<float>(),mult)); WaveformContext waveContext(samples, context.beatDetect); for(int x=0;x< samples;x++) { waveContext.sample = x/(float)(samples - 1); waveContext.sample_int = x; waveContext.left = value1[x]; waveContext.right = value2[x]; points[x] = PerPoint(points[x],waveContext); } floatQuad *colors = new float[samples][4]; floatPair *p = new float[samples][2]; for(int x=0;x< samples;x++) { colors[x][0] = points[x].r; colors[x][1] = points[x].g; colors[x][2] = points[x].b; colors[x][3] = points[x].a * masterAlpha; p[x][0] = points[x].x; p[x][1] = -(points[x].y-1); } glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_COLOR_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glVertexPointer(2,GL_FLOAT,0,p); glColorPointer(4,GL_FLOAT,0,colors); if (dots) glDrawArrays(GL_POINTS,0,samples); else glDrawArrays(GL_LINE_STRIP,0,samples); glPointSize(context.texsize < 512 ? 1 : context.texsize/512); glLineWidth(context.texsize < 512 ? 1 : context.texsize/512); #ifndef USE_GLES1 glDisable(GL_LINE_STIPPLE); #endif glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // glPopMatrix(); delete[] colors; delete[] p; delete[] value1; delete[] value2; }
baiscobj::~baiscobj() { for(int i=0;i<16;i++) glDeleteTextures(1, &g_cactus[i]); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); }
void Model::DrawModel(bool drawWithNormals, bool drawWithTexture) { // Performs rotation of model glRotatef(ModelRotation.x, 1, 0, 0); glRotatef(ModelRotation.y, 0, 1, 0); glRotatef(ModelRotation.z, 0, 0, 1); // Scales model if necessary glScalef(ModelScale.x,ModelScale.y,ModelScale.z); // Translates model glTranslatef(ModelPosition.x, ModelPosition.y, ModelPosition.z); // activate and specify pointer to vertex array glEnableClientState(GL_VERTEX_ARRAY); vector<float>& vertices = m_modelReader->GetVertices(); glVertexPointer(3, GL_FLOAT, 0, &vertices[0]); // pointer to normal array if (drawWithNormals) { glEnableClientState(GL_NORMAL_ARRAY); vector<float>&normals = m_modelReader->GetNormals(); glNormalPointer(GL_FLOAT, 0, &normals[0]); } if (drawWithTexture) { glEnable(GL_TEXTURE_2D); vector<float>& textureCoordinates = m_modelReader->GetTextureCoordinates(); glBindTexture(GL_TEXTURE_2D, m_textureID); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(2, GL_FLOAT, 0, &textureCoordinates[0]); } // draw the shape... glDrawArrays(GL_TRIANGLES, 0, (unsigned int)vertices.size() / 3); // deactivate vertex arrays after drawing glDisableClientState(GL_VERTEX_ARRAY); if (drawWithNormals) { // deactivate glDisableClientState(GL_NORMAL_ARRAY); } if (drawWithTexture) { glBindTexture(GL_TEXTURE_2D, NULL); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisable(GL_TEXTURE_2D); } }
void initFixedRenderer(renderer_t* renderer) { GLenum err; char *extensionsList ; //Log_Printf("[initFixedRenderer] has a nnnasty hack"); renderer->type = GL_11_RENDERER ; //renderer->supportBumpMapping = 0; renderer->props = 0; renderer->Set3D = Set3DF; renderer->StopRendition = StopRenditionF; renderer->SetTexture = SetTextureF; renderer->RenderEntities = RenderEntitiesF; renderer->UpLoadTextureToGpu = UpLoadTextureToGPUF; renderer->UpLoadEntityToGPU = UpLoadEntityToGPUF; renderer->Set2D = Set2DF; renderer->RenderPlayersBullets = RenderPlayersBulletsF ; renderer->RenderString = RenderStringF; renderer->GetColorBuffer = GetColorBufferF; renderer->RenderFXSprites = RenderFXSpritesF; renderer->DrawControls = DrawControlsF; renderer->FreeGPUTexture = FreeGPUTextureF; renderer->FreeGPUBuffer = FreeGPUBufferF; renderer->UploadVerticesToGPU = UploadVerticesToGPUF; renderer->StartCleanFrame = StartCleanFrameF; renderer->RenderColorlessSprites = RenderColorlessSpritesF; renderer->FadeScreen = FadeScreenF; renderer->SetMaterialTextureBlending = SetMaterialTextureBlendingF; renderer->SetTransparency = SetTransparencyF; renderer->IsTextureCompressionSupported = IsTextureCompressionSupportedF; renderer->RefreshViewPort = RefreshViewPortF; glViewport(renderer->viewPortDimensions[VP_X], renderer->viewPortDimensions[VP_Y], renderer->viewPortDimensions[VP_WIDTH], renderer->viewPortDimensions[VP_HEIGHT]); glEnable(GL_TEXTURE_2D); glDisable(GL_ALPHA_TEST); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glEnableClientState (GL_VERTEX_ARRAY); glEnableClientState (GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_COLOR_ARRAY); glClearColor(0, 0, 0,1.0f); glColor4f(1.0f, 1.0f, 1.0f,1.0f); glMatrixMode(GL_TEXTURE); glLoadMatrixf(textureMatrix); //We need to check what texture compression method is supported. extensionsList = (char *) glGetString(GL_EXTENSIONS); if (strstr(extensionsList,"GL_IMG_texture_compression_pvrtc")) supportedCompressionFormatF |= TEXTURE_FORMAT_PVRTC ; err = glGetError(); if (err != GL_NO_ERROR) Log_Printf("Error initing 1.1: glError: 0x%04X", err); }
inline void buffer<T>::unbind() const { glEnableClientState( m_state ); glBindBuffer( m_target, 0); glDisableClientState( m_state ); }
void CpuClipmapRenderer::renderBlock( const GeometryClipmapLevel& level, const GeometryClipmapLevel* coarserLevel, const ClipmapRenderParameters& renderParameters, const Color3f& debugColor ) { TerrainLevelRenderData& renderData = levels_[ level.index ]; if( renderData.indices.size() <= 0 ) { return; } // enable the texture: // todo: enable the texture of the next coarser level too, so we can blend between both if( renderData.texture != NULL ) { //renderData.texture->activate( renderParameters.renderAction ); } Pnt2i transitionSize; //transitionSize[ 0 ] = std::min( ( levelSampleCount_ / 10 ) * level.sampleDistance[ 0 ], level.minTransitionSize[ 0 ] ); //transitionSize[ 1 ] = std::min( ( levelSampleCount_ / 10 ) * level.sampleDistance[ 1 ], level.minTransitionSize[ 1 ] ); const int levelSampleSpacing = level.sampleSpacing; transitionSize[ 0 ] = levelSampleSpacing * level.heightmap.size / 10; transitionSize[ 1 ] = levelSampleSpacing * level.heightmap.size / 10; // min and max are the first,last point inside the renderregion: Pnt2f activeRegionMin = Pnt2f( level.sampleOrigin ); Pnt2f activeRegionMax = Pnt2f( componentAdd( level.sampleOrigin, Pnt2i( level.getSampleCoverage(), level.getSampleCoverage() ) ) ); Pnt2f worldTransitionSize = Pnt2f( transitionSize ); //Point2f activeRegionCenter = samplePosToWorldPos( level.outerRenderBounds.getTopLeft() + level.outerRenderBounds.getSize() / 2 ); //Point2f localViewerPos( worldViewerPosition_[ 0 ], worldViewerPosition_.z ); //Pnt2i viewerSamplePos = worldPosToSamplePos( localViewerPos ); //Point2f baseLocalViewerPos = samplePosToWorldPos( viewerSamplePos ); //localViewerPos -= baseLocalViewerPos; #ifdef OLD_GEOCLIP //beginEditCP( terrainShader_ ); terrainShader_.setUniform( "transitionWidth", Vec2f( worldTransitionSize ) ); terrainShader_.setUniform( "activeRegionMin", Vec2f( activeRegionMin ) ); terrainShader_.setUniform( "activeRegionMax", Vec2f( activeRegionMax ) ); //terrainShader_->setUniform( "activeRegionCenter", activeRegionCenter ); terrainShader_.setUniform( "localViewerPos", Vec3f( viewerPosition_ ) ); terrainShader_.setUniform( "baseColor0", colorToVector( debugColor ) ); //endEditCP( terrainShader_ ); #else _pTerrainShader->addUniformVariable( "transitionWidth", Vec2f( worldTransitionSize ) ); _pTerrainShader->addUniformVariable( "activeRegionMin", Vec2f( activeRegionMin ) ); _pTerrainShader->addUniformVariable( "activeRegionMax", Vec2f( activeRegionMax ) ); //terrainShader_->setUniform( "activeRegionCenter", activeRegionCenter ); _pTerrainShader->addUniformVariable( "localViewerPos", Vec3f( viewerPosition_ ) ); #ifdef NOTUSED _pTerrainShader->setUniformParameter( "baseColor0", colorToVector( debugColor ) ); #endif #endif if( coarserLevel ) { #ifdef OLD_GEOCLIP terrainShader_.setUniform( "baseColor1", colorToVector( getDebugColor( coarserLevel->index ) ) ); #else #ifdef NOTUSED _pTerrainShader->setUniformParameter( "baseColor1", colorToVector( getDebugColor( coarserLevel->index ) ) ); #endif #endif } else { #ifdef OLD_GEOCLIP terrainShader_.setUniform( "baseColor1", colorToVector( debugColor ) ); #else #ifdef NOTUSED _pTerrainShader->setUniformParameter( "baseColor1", colorToVector( debugColor ) ); #endif #endif } //terrainShader_->updateParameters( drawAction->getWindow(), terrainShader_->getParameters() ); if( renderParameters.useVboExtension && useVertexBufferObjects_ ) { renderData.vertexBuffer.activate(); char* base = 0; glVertexPointer( 4, GL_FLOAT, sizeof( OpenGLTerrainVertex ), base ); glEnableClientState( GL_VERTEX_ARRAY ); glTexCoordPointer( 2, GL_FLOAT, sizeof( OpenGLTerrainVertex ), base + sizeof( Pnt4f ) ); glEnableClientState( GL_TEXTURE_COORD_ARRAY ); glDrawElements( GL_TRIANGLES, GLsizei(renderData.indices.size()), GL_UNSIGNED_SHORT, &renderData.indices[ 0 ] ); renderData.vertexBuffer.deactivate(); } else { glVertexPointer( 4, GL_FLOAT, sizeof( OpenGLTerrainVertex ), &renderData.vertices[ 0 ].pos ); glEnableClientState( GL_VERTEX_ARRAY ); glTexCoordPointer( 2, GL_FLOAT, sizeof( OpenGLTerrainVertex ), &renderData.vertices[ 0 ].uv ); glEnableClientState( GL_TEXTURE_COORD_ARRAY ); glDrawElements( GL_TRIANGLES, GLsizei(renderData.indices.size()), GL_UNSIGNED_SHORT, &renderData.indices[ 0 ] ); } glDisableClientState( GL_TEXTURE_COORD_ARRAY ); glDisableClientState( GL_NORMAL_ARRAY ); glDisableClientState( GL_VERTEX_ARRAY ); stats_.drawnBlockCount++; stats_.drawnTriangleCount += int(renderData.indices.size()) / 3; stats_.transformedVertexCount += int(renderData.vertices.size()); if( renderData.texture != NULL ) { //renderData.texture->deactivate( renderParameters.renderAction ); } }
void glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer) { __GLFBcontext *gc = __glFBGetCurrentContext(); GLboolean tEnable = GL_FALSE, cEnable = GL_FALSE, nEnable = GL_FALSE; GLenum tType = GL_FLOAT, nType = GL_FLOAT, vType = GL_FLOAT; GLenum cType = GL_FALSE; GLint tSize = 0, cSize = 0, nSize = 3, vSize; int cOffset = 0, nOffset = 0, vOffset = 0; GLint trueStride, size; switch (format) { case GL_V2F: vSize = 2; size = __glFBTypeSize(vType) * vSize; break; case GL_V3F: vSize = 3; size = __glFBTypeSize(vType) * vSize; break; case GL_C4UB_V2F: cEnable = GL_TRUE; cSize = 4; cType = GL_UNSIGNED_BYTE; vSize = 2; vOffset = __glFBTypeSize(cType) * cSize; size = vOffset + __glFBTypeSize(vType) * vSize; break; case GL_C4UB_V3F: cEnable = GL_TRUE; cSize = 4; cType = GL_UNSIGNED_BYTE; vSize = 3; vOffset = __glFBTypeSize(vType) * cSize; size = vOffset + __glFBTypeSize(vType) * vSize; break; case GL_C3F_V3F: cEnable = GL_TRUE; cSize = 3; cType = GL_FLOAT; vSize = 3; vOffset = __glFBTypeSize(cType) * cSize; size = vOffset + __glFBTypeSize(vType) * vSize; break; case GL_N3F_V3F: nEnable = GL_TRUE; vSize = 3; vOffset = __glFBTypeSize(nType) * nSize; size = vOffset + __glFBTypeSize(vType) * vSize; break; case GL_C4F_N3F_V3F: cEnable = GL_TRUE; cSize = 4; cType = GL_FLOAT; nEnable = GL_TRUE; nOffset = __glFBTypeSize(cType) * cSize; vSize = 3; vOffset = nOffset + __glFBTypeSize(nType) * nSize; size = vOffset + __glFBTypeSize(vType) * vSize; break; case GL_T2F_V3F: tEnable = GL_TRUE; tSize = 2; vSize = 3; vOffset = __glFBTypeSize(tType) * tSize; size = vOffset + __glFBTypeSize(vType) * vSize; break; case GL_T4F_V4F: tEnable = GL_TRUE; tSize = 4; vSize = 4; vOffset = __glFBTypeSize(tType) * tSize; size = vOffset + __glFBTypeSize(vType) * vSize; break; case GL_T2F_C4UB_V3F: tEnable = GL_TRUE; tSize = 2; cEnable = GL_TRUE; cSize = 4; cType = GL_UNSIGNED_BYTE; cOffset = __glFBTypeSize(tType) * tSize; vSize = 3; vOffset = cOffset + __glFBTypeSize(cType) * cSize; size = vOffset + __glFBTypeSize(vType) * vSize; break; case GL_T2F_C3F_V3F: tEnable = GL_TRUE; tSize = 2; cEnable = GL_TRUE; cSize = 3; cType = GL_FLOAT; cOffset = __glFBTypeSize(tType) * tSize; vSize = 3; vOffset = cOffset + __glFBTypeSize(cType) * cSize; size = vOffset + __glFBTypeSize(vType) * vSize; break; case GL_T2F_N3F_V3F: tEnable = GL_TRUE; tSize = 2; nEnable = GL_TRUE; nOffset = __glFBTypeSize(tType) * tSize; vSize = 3; vOffset = nOffset + __glFBTypeSize(nType) * nSize; size = vOffset + __glFBTypeSize(vType) * vSize; break; case GL_T2F_C4F_N3F_V3F: tEnable = GL_TRUE; tSize = 2; cEnable = GL_TRUE; cSize = 4; cType = GL_FLOAT; cOffset = __glFBTypeSize(tType) * tSize; nEnable = GL_TRUE; nOffset = cOffset + __glFBTypeSize(cType) * cSize; vSize = 3; vOffset = nOffset + __glFBTypeSize(nType) * nSize; size = vOffset + __glFBTypeSize(vType) * vSize; break; case GL_T4F_C4F_N3F_V4F: tEnable = GL_TRUE; tSize = 4; cEnable = GL_TRUE; cSize = 4; cType = GL_FLOAT; cOffset = __glFBTypeSize(tType) * tSize; nEnable = GL_TRUE; nOffset = cOffset + __glFBTypeSize(cType) * cSize; vSize = 4; vOffset = nOffset + __glFBTypeSize(nType) * nSize; size = vOffset + __glFBTypeSize(vType) * vSize; break; default: __glFBSetError(gc, GL_INVALID_ENUM); return; } trueStride = (stride == 0) ? size : stride; glDisableClientState(GL_EDGE_FLAG_ARRAY); glDisableClientState(GL_INDEX_ARRAY); if (tEnable) { glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(tSize, tType, trueStride, (const char *)pointer); } else { glDisableClientState(GL_TEXTURE_COORD_ARRAY); } if (cEnable) { glEnableClientState(GL_COLOR_ARRAY); glColorPointer(cSize, cType, trueStride, (const char *)pointer+cOffset); } else { glDisableClientState(GL_COLOR_ARRAY); } if (nEnable) { glEnableClientState(GL_NORMAL_ARRAY); glNormalPointer(nType, trueStride, (const char *)pointer+nOffset); } else { glDisableClientState(GL_NORMAL_ARRAY); } glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(vSize, vType, trueStride, (const char *)pointer+vOffset); }
PsychError SCREENDrawDots(void) { PsychWindowRecordType *windowRecord; int whiteValue, m,n,p,mc,nc,pc,idot_type; int i, nrpoints, nrsize; boolean isArgThere, usecolorvector, isdoublecolors, isuint8colors; double *xy, *size, *center, *dot_type, *colors; unsigned char *bytecolors; GLfloat pointsizerange[2]; double convfactor; // All sub functions should have these two lines PsychPushHelp(useString, synopsisString,seeAlsoString); if(PsychIsGiveHelp()) { PsychGiveHelp(); return(PsychError_none); }; // Check for superfluous arguments PsychErrorExit(PsychCapNumInputArgs(6)); //The maximum number of inputs PsychErrorExit(PsychCapNumOutputArgs(0)); //The maximum number of outputs // Get the window record from the window record argument and get info from the window record PsychAllocInWindowRecordArg(1, kPsychArgRequired, &windowRecord); // Query, allocate and copy in all vectors... nrpoints = 2; nrsize = 0; colors = NULL; bytecolors = NULL; PsychPrepareRenderBatch(windowRecord, 2, &nrpoints, &xy, 4, &nc, &mc, &colors, &bytecolors, 3, &nrsize, &size); isdoublecolors = (colors) ? TRUE:FALSE; isuint8colors = (bytecolors) ? TRUE:FALSE; usecolorvector = (nc>1) ? TRUE:FALSE; // Get center argument isArgThere = PsychIsArgPresent(PsychArgIn, 5); if(!isArgThere) { center = (double *) PsychMallocTemp(2 * sizeof(double)); center[0] = 0; center[1] = 0; } else { PsychAllocInDoubleMatArg(5, TRUE, &m, &n, &p, ¢er); if(p!=1 || n!=2 || m!=1) PsychErrorExitMsg(PsychError_user, "center must be a 1-by-2 vector"); } // Get dot_type argument isArgThere = PsychIsArgPresent(PsychArgIn, 6); if(!isArgThere) { idot_type = 0; } else { PsychAllocInDoubleMatArg(6, TRUE, &m, &n, &p, &dot_type); if(p!=1 || n!=1 || m!=1 || (dot_type[0]<0 || dot_type[0]>2)) PsychErrorExitMsg(PsychError_user, "dot_type must be 0, 1 or 2"); idot_type = (int) dot_type[0]; } // Child-protection: Alpha blending needs to be enabled for smoothing to work: if (idot_type>0 && windowRecord->actualEnableBlending!=TRUE) { PsychErrorExitMsg(PsychError_user, "Point smoothing doesn't work with alpha-blending disabled! See Screen('BlendFunction') on how to enable it."); } // Turn on antialiasing to draw circles if(idot_type) { glEnable(GL_POINT_SMOOTH); glGetFloatv(GL_POINT_SIZE_RANGE, (GLfloat*) &pointsizerange); // A dot type of 2 requests for highest quality point smoothing: glHint(GL_POINT_SMOOTH_HINT, (idot_type>1) ? GL_NICEST : GL_DONT_CARE); } else { #ifndef GL_ALIASED_POINT_SIZE_RANGE #define GL_ALIASED_POINT_SIZE_RANGE 0x846D #endif glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, (GLfloat*) &pointsizerange); } // Set size of a single dot: if (size[0] > pointsizerange[1] || size[0] < pointsizerange[0]) { printf("PTB-ERROR: You requested a point size of %f units, which is not in the range (%f to %f) supported by your graphics hardware.\n", size[0], pointsizerange[0], pointsizerange[1]); PsychErrorExitMsg(PsychError_user, "Unsupported point size requested in Screen('DrawDots')."); } // Setup initial common point size for all points: glPointSize(size[0]); // Setup modelview matrix to perform translation by 'center': glMatrixMode(GL_MODELVIEW); // Make a backup copy of the matrix: glPushMatrix(); // Apply a global translation of (center(x,y)) pixels to all following points: glTranslated(center[0], center[1], 0); // Render the array of 2D-Points - Efficient version: // This command sequence allows fast processing of whole arrays // of vertices (or points, in this case). It saves the call overhead // associated with the original implementation below and is potentially // optimized in specific OpenGL implementations. // Pass a pointer to the start of the point-coordinate array: glVertexPointer(2, GL_DOUBLE, 0, &xy[0]); // Enable fast rendering of arrays: glEnableClientState(GL_VERTEX_ARRAY); if (usecolorvector) { if (isdoublecolors) glColorPointer(mc, GL_DOUBLE, 0, colors); if (isuint8colors) glColorPointer(mc, GL_UNSIGNED_BYTE, 0, bytecolors); glEnableClientState(GL_COLOR_ARRAY); } // Render all n points, starting at point 0, render them as POINTS: if (nrsize==1) { // One common point size for all dots provided. Good! This is very efficiently // done with one single render-call: glDrawArrays(GL_POINTS, 0, nrpoints); } else { // Different size for each dot provided: We have to do One GL - call per dot. // This is *pretty inefficient* and should be reimplemented in the future via // Point-Sprite extensions, cleverly used display lists or via vertex-shaders... // For now we do it the stupid way: for (i=0; i<nrpoints; i++) { if (size[i] > pointsizerange[1] || size[i] < pointsizerange[0]) { printf("PTB-ERROR: You requested a point size of %f units, which is not in the range (%f to %f) supported by your graphics hardware.\n", size[i], pointsizerange[0], pointsizerange[1]); PsychErrorExitMsg(PsychError_user, "Unsupported point size requested in Screen('DrawDots')."); } // Setup point size for this point: glPointSize(size[i]); // Render point: glDrawArrays(GL_POINTS, i, 1); } } // Disable fast rendering of arrays: glDisableClientState(GL_VERTEX_ARRAY); if (usecolorvector) glDisableClientState(GL_COLOR_ARRAY); // Restore old matrix from backup copy, undoing the global translation: glPopMatrix(); // turn off antialiasing again if(idot_type) glDisable(GL_POINT_SMOOTH); // Reset pointsize to 1.0 glPointSize(1); // Mark end of drawing op. This is needed for single buffered drawing: PsychFlushGL(windowRecord); //All psychfunctions require this. return(PsychError_none); }
void CloudsVisualSystemCities::generateCube(float sizeX, float sizeY, float sizeZ) { ofPushMatrix(); glEnableClientState(GL_NORMAL_ARRAY); glEnableClientState(GL_VERTEX_ARRAY); if(ofGetStyle().bFill) { GLfloat vertices[] = { +sizeX,-sizeY,+sizeZ, +sizeX,-sizeY,-sizeZ, +sizeX,+sizeY,-sizeZ, +sizeX,+sizeY,+sizeZ, +sizeX,+sizeY,+sizeZ, +sizeX,+sizeY,-sizeZ, -sizeX,+sizeY,-sizeZ, -sizeX,+sizeY,+sizeZ, +sizeX,+sizeY,+sizeZ, -sizeX,+sizeY,+sizeZ, -sizeX,-sizeY,+sizeZ, +sizeX,-sizeY,+sizeZ, -sizeX,-sizeY,+sizeZ, -sizeX,+sizeY,+sizeZ, -sizeX,+sizeY,-sizeZ, -sizeX,-sizeY,-sizeZ, -sizeX,-sizeY,+sizeZ, -sizeX,-sizeY,-sizeZ, +sizeX,-sizeY,-sizeZ, +sizeX,-sizeY,+sizeZ, -sizeX,-sizeY,-sizeZ, -sizeX,+sizeY,-sizeZ, +sizeX,+sizeY,-sizeZ, +sizeX,-sizeY,-sizeZ }; glVertexPointer(3, GL_FLOAT, 0, vertices); static GLfloat normals[] = { +1,0,0, +1,0,0, +1,0,0, +1,0,0, 0,+1,0, 0,+1,0, 0,+1,0, 0,+1,0, 0,0,-1, 0,0,-1, 0,0,-1, 0,0,-1, -1,0,0, -1,0,0, -1,0,0, -1,0,0, 0,-1,0, 0,-1,0, 0,-1,0, 0,-1,0, 0,0,+1, 0,0,+1, 0,0,+1, 0,0,+1 }; glNormalPointer(GL_FLOAT, 0, normals); glEnableClientState(GL_TEXTURE_COORD_ARRAY); static GLfloat tex[] = { 1,0, 0,0, 0,1, 1,1, 1,1, 1,0, 0,0, 0,1, 0,1, 1,1, 1,0, 0,0, 0,0, 0,1, 1,1, 1,0, 0,0, 0,1, 1,1, 1,0, 0,0, 0,1, 1,1, 1,0 }; glTexCoordPointer(2, GL_FLOAT, 0, tex); GLubyte indices[] = { 0,1,2, // right top left 0,2,3, // right bottom right 4,5,6, // bottom top right 4,6,7, // bottom bottom left 8,9,10, // back bottom right 8,10,11, // back top left 12,13,14, // left bottom right 12,14,15, // left top left 16,17,18, // ... etc 16,18,19, 20,21,22, 20,22,23 }; glDrawElements(GL_TRIANGLES, 3 * 6 * 2, GL_UNSIGNED_BYTE, indices); glDisableClientState(GL_TEXTURE_COORD_ARRAY); } else { GLfloat vertices[] = { +sizeX,+sizeY,+sizeZ, +sizeX,+sizeY,-sizeZ, +sizeX,-sizeY,+sizeZ, +sizeX,-sizeY,-sizeZ, -sizeX,+sizeY,+sizeZ, -sizeX,+sizeY,-sizeZ, -sizeX,-sizeY,+sizeZ, -sizeX,-sizeY,-sizeZ }; glVertexPointer(3, GL_FLOAT, 0, vertices); static float n = sqrtf(3); static GLfloat normals[] = { +n,+n,+n, +n,+n,-n, +n,-n,+n, +n,-n,-n, -n,+n,+n, -n,+n,-n, -n,-n,+n, -n,-n,-n }; glNormalPointer(GL_FLOAT, 0, normals); static GLubyte indices[] = { 0,1, 1,3, 3,2, 2,0, 4,5, 5,7, 7,6, 6,4, 0,4, 5,1, 7,3, 6,2 }; glDrawElements(GL_LINES, 4 * 2 * 3, GL_UNSIGNED_BYTE, indices); } glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); ofPopMatrix(); }
//-***************************************************************************** void MeshDrwHelper::draw( const DrawContext & iCtx ) const { // Bail if invalid. if ( !m_valid || m_triangles.size() < 1 || !m_meshP ) { return; } const V3f *points = m_meshP->get(); const V3f *normals = NULL; if ( m_meshN && ( m_meshN->size() == m_meshP->size() ) ) { normals = m_meshN->get(); } else if ( m_customN.size() == m_meshP->size() ) { normals = &(m_customN.front()); } #ifndef SIMPLE_ABC_VIEWER_NO_GL_CLIENT_STATE //#if 0 { GL_NOISY( glEnableClientState( GL_VERTEX_ARRAY ) ); if ( normals ) { GL_NOISY( glEnableClientState( GL_NORMAL_ARRAY ) ); GL_NOISY( glNormalPointer( GL_FLOAT, 0, ( const GLvoid * )normals ) ); } GL_NOISY( glVertexPointer( 3, GL_FLOAT, 0, ( const GLvoid * )points ) ); GL_NOISY( glDrawElements( GL_TRIANGLES, ( GLsizei )m_triangles.size() * 3, GL_UNSIGNED_INT, ( const GLvoid * )&(m_triangles[0]) ) ); if ( normals ) { GL_NOISY( glDisableClientState( GL_NORMAL_ARRAY ) ); } GL_NOISY( glDisableClientState( GL_VERTEX_ARRAY ) ); } #else glBegin( GL_TRIANGLES ); for ( size_t i = 0; i < m_triangles.size(); ++i ) { const Tri &tri = m_triangles[i]; const V3f &vertA = points[tri[0]]; const V3f &vertB = points[tri[1]]; const V3f &vertC = points[tri[2]]; if ( normals ) { const V3f &normA = normals[tri[0]]; glNormal3fv( ( const GLfloat * )&normA ); glVertex3fv( ( const GLfloat * )&vertA ); const V3f &normB = normals[tri[1]]; glNormal3fv( ( const GLfloat * )&normB ); glVertex3fv( ( const GLfloat * )&vertB ); const V3f &normC = normals[tri[2]]; glNormal3fv( ( const GLfloat * )&normC ); glVertex3fv( ( const GLfloat * )&vertC ); } else { V3f AB = vertB - vertA; V3f AC = vertC - vertA; V3f N = AB.cross( AC ); if ( N.length() > 1.0e-4f ) { N.normalize(); glNormal3fv( ( const GLfloat * )&N ); } glVertex3fv( ( const GLfloat * )&vertA ); glVertex3fv( ( const GLfloat * )&vertB ); glVertex3fv( ( const GLfloat * )&vertC ); } } glEnd(); #endif }
void RenderCollisionBoxes(void) { int i,j; enemy_t* enemy; xf_colorless_sprite_t* enemyBullet; float alpha = 0.3; glDisable(GL_TEXTURE_2D); glDisable(GL_LIGHTING); glDisableClientState (GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_COLOR_ARRAY); glDisable(GL_CULL_FACE); glBlendFunc(GL_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND); glColor4f(1, 1, 1, alpha); //PLAYER for (i=0; i < numPlayers; i++) { collisionBoxes[1] = players[i].ss_boudaries[UP]; collisionBoxes[0] = players[i].ss_boudaries[LEFT]; collisionBoxes[3] = players[i].ss_boudaries[DOWN]; collisionBoxes[2] = players[i].ss_boudaries[LEFT]; collisionBoxes[5] = players[i].ss_boudaries[DOWN]; collisionBoxes[4] = players[i].ss_boudaries[RIGHT]; collisionBoxes[7] = players[i].ss_boudaries[UP]; collisionBoxes[6] = players[i].ss_boudaries[RIGHT]; glVertexPointer (2, GL_SHORT,0,collisionBoxes); glDrawElements (GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, collisionBoxesIndices); } //ENEMIES glColor4f(1, 0, 0, alpha); enemy = ENE_GetFirstEnemy(); while (enemy != NULL) { collisionBoxes[1] = enemy->ss_boudaries[UP]; collisionBoxes[0] = enemy->ss_boudaries[LEFT]; collisionBoxes[3] = enemy->ss_boudaries[DOWN]; collisionBoxes[2] = enemy->ss_boudaries[LEFT]; collisionBoxes[5] = enemy->ss_boudaries[DOWN]; collisionBoxes[4] = enemy->ss_boudaries[RIGHT]; collisionBoxes[7] = enemy->ss_boudaries[UP]; collisionBoxes[6] = enemy->ss_boudaries[RIGHT]; glVertexPointer (2, GL_SHORT,0,collisionBoxes); glDrawElements (GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, collisionBoxesIndices); enemy = enemy->next; } //PLAYER BULLETS glColor4f(0, 0, 1, alpha); for (i=0; i < numPlayers; i++) { for (j=0; j < MAX_PLAYER_BULLETS; j++) { if (players[i].bullets[j].expirationTime < simulationTime) continue; collisionBoxes[1] = players[i].bullets[j].ss_boudaries[UP]; collisionBoxes[0] = players[i].bullets[j].ss_boudaries[LEFT]; collisionBoxes[3] = players[i].bullets[j].ss_boudaries[DOWN]; collisionBoxes[2] = players[i].bullets[j].ss_boudaries[LEFT]; collisionBoxes[5] = players[i].bullets[j].ss_boudaries[DOWN]; collisionBoxes[4] = players[i].bullets[j].ss_boudaries[RIGHT]; collisionBoxes[7] = players[i].bullets[j].ss_boudaries[UP]; collisionBoxes[6] = players[i].bullets[j].ss_boudaries[RIGHT]; glVertexPointer (2, GL_SHORT,0,collisionBoxes); glDrawElements (GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, collisionBoxesIndices); } } //ENEMY BULLETS glColor4f(1, 0, 1, alpha); enemyBullet = partLib.ss_vertices; i = 0; while( i < partLib.numParticules) { collisionBoxes[0] = enemyBullet->pos[X]; collisionBoxes[1] = enemyBullet->pos[Y]; collisionBoxes[2] = enemyBullet->pos[X]; collisionBoxes[3] = enemyBullet[1].pos[Y]; collisionBoxes[4] = enemyBullet[2].pos[X]; collisionBoxes[5] = enemyBullet[1].pos[Y]; collisionBoxes[6] = enemyBullet[2].pos[X]; collisionBoxes[7] = enemyBullet->pos[Y]; glVertexPointer (2, GL_SHORT,0,collisionBoxes); glDrawElements (GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, collisionBoxesIndices); enemyBullet+=4; i++; } //glDisable(GL_BLEND); glBlendFunc(GL_ALPHA, GL_ONE); glEnableClientState(GL_COLOR_ARRAY); glEnableClientState (GL_TEXTURE_COORD_ARRAY); glEnable(GL_TEXTURE_2D); glColor4f(1, 1, 1, 1); if (light.enabled) glEnable(GL_LIGHTING); }
// This is the main rendering function that you have to implement and provide to ImGui (via setting up 'RenderDrawListsFn' in the ImGuiIO structure) // If text or lines are blurry when integrating ImGui in your engine: // - in your Render function, try translating your projection matrix by (0.5f,0.5f) or (0.375f,0.375f) void ImGui_ImplGlfw_RenderDrawLists(ImDrawData* draw_data) { // Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates) ImGuiIO& io = ImGui::GetIO(); int fb_width = (int)(io.DisplaySize.x * io.DisplayFramebufferScale.x); int fb_height = (int)(io.DisplaySize.y * io.DisplayFramebufferScale.y); if (fb_width == 0 || fb_height == 0) return; draw_data->ScaleClipRects(io.DisplayFramebufferScale); // We are using the OpenGL fixed pipeline to make the example code simpler to read! // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, vertex/texcoord/color pointers. GLint last_texture; glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture); GLint last_viewport[4]; glGetIntegerv(GL_VIEWPORT, last_viewport); glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_TRANSFORM_BIT); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_CULL_FACE); glDisable(GL_DEPTH_TEST); glEnable(GL_SCISSOR_TEST); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnableClientState(GL_COLOR_ARRAY); glEnable(GL_TEXTURE_2D); //glUseProgram(0); // You may want this if using this code in an OpenGL 3+ context // Setup viewport, orthographic projection matrix glViewport(0, 0, (GLsizei)fb_width, (GLsizei)fb_height); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glOrtho(0.0f, io.DisplaySize.x, io.DisplaySize.y, 0.0f, -1.0f, +1.0f); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); // Render command lists #define OFFSETOF(TYPE, ELEMENT) ((size_t)&(((TYPE *)0)->ELEMENT)) for (int n = 0; n < draw_data->CmdListsCount; n++) { const ImDrawList* cmd_list = draw_data->CmdLists[n]; const unsigned char* vtx_buffer = (const unsigned char*)&cmd_list->VtxBuffer.front(); const ImDrawIdx* idx_buffer = &cmd_list->IdxBuffer.front(); glVertexPointer(2, GL_FLOAT, sizeof(ImDrawVert), (void*)(vtx_buffer + OFFSETOF(ImDrawVert, pos))); glTexCoordPointer(2, GL_FLOAT, sizeof(ImDrawVert), (void*)(vtx_buffer + OFFSETOF(ImDrawVert, uv))); glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(ImDrawVert), (void*)(vtx_buffer + OFFSETOF(ImDrawVert, col))); for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.size(); cmd_i++) { const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i]; if (pcmd->UserCallback) { pcmd->UserCallback(cmd_list, pcmd); } else { glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId); glScissor((int)pcmd->ClipRect.x, (int)(fb_height - pcmd->ClipRect.w), (int)(pcmd->ClipRect.z - pcmd->ClipRect.x), (int)(pcmd->ClipRect.w - pcmd->ClipRect.y)); glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, idx_buffer); } idx_buffer += pcmd->ElemCount; } } #undef OFFSETOF // Restore modified state glDisableClientState(GL_COLOR_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); glBindTexture(GL_TEXTURE_2D, (GLuint)last_texture); glMatrixMode(GL_MODELVIEW); glPopMatrix(); glMatrixMode(GL_PROJECTION); glPopMatrix(); glPopAttrib(); glViewport(last_viewport[0], last_viewport[1], (GLsizei)last_viewport[2], (GLsizei)last_viewport[3]); }
void initFixedRenderer(renderer_t* renderer) { GLenum err; //printf("[initFixedRenderer] has a nnnasty hack"); renderer->type = GL_11_RENDERER ; //renderer->supportBumpMapping = 0; renderer->props = 0; renderer->Set3D = Set3DF; renderer->StopRendition = StopRenditionF; renderer->SetTexture = SetTextureF; renderer->RenderEntities = RenderEntitiesF; renderer->UpLoadTextureToGpu = UpLoadTextureToGPUF; renderer->UpLoadEntityToGPU = UpLoadEntityToGPUF; renderer->Set2D = Set2DF; renderer->RenderPlayersBullets = RenderPlayersBulletsF ; renderer->RenderString = RenderStringF; renderer->GetColorBuffer = GetColorBufferF; renderer->RenderFXSprites = RenderFXSpritesF; renderer->DrawControls = DrawControlsF; renderer->FreeGPUTexture = FreeGPUTextureF; renderer->FreeGPUBuffer = FreeGPUBufferF; renderer->UploadVerticesToGPU = UploadVerticesToGPUF; renderer->StartCleanFrame = StartCleanFrameF; renderer->RenderColorlessSprites = RenderColorlessSpritesF; renderer->FadeScreen = FadeScreenF; renderer->SetMaterialTextureBlending = SetMaterialTextureBlendingF; renderer->SetTransparency = SetTransparencyF; glViewport(renderer->viewPortDimensions[VP_X], renderer->viewPortDimensions[VP_Y], renderer->viewPortDimensions[VP_WIDTH], renderer->viewPortDimensions[VP_HEIGHT]); glEnable(GL_TEXTURE_2D); glDisable(GL_ALPHA_TEST); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glEnableClientState (GL_VERTEX_ARRAY); glEnableClientState (GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_COLOR_ARRAY); glClearColor(0, 0, 0,1.0f); glColor4f(1.0f, 1.0f, 1.0f,1.0f); glMatrixMode(GL_TEXTURE); glLoadMatrixf(textureMatrix); err = glGetError(); if (err != GL_NO_ERROR) printf("Error initing 1.1: glError: 0x%04X", err); }
void deferred_renderer_render_animated(animated_object* ao) { if (ao->skeleton->num_bones > MAX_BONES) { error("animated object skeleton has too many bones (over %i)", MAX_BONES); } matrix_4x4 r_world_matrix = m44_world( ao->position, ao->scale, ao->rotation ); m44_to_array(r_world_matrix, WORLD_MATRIX); skeleton_gen_transforms(ao->pose); for(int i = 0; i < ao->skeleton->num_bones; i++) { matrix_4x4 base, ani; base = ao->skeleton->inv_transforms[i]; ani = ao->pose->transforms[i]; bone_matrices[i] = m44_mul_m44(ani, base); m44_to_array(bone_matrices[i], bone_matrix_data + (i * 4 * 4)); } renderable* r = ao->renderable; for(int i = 0; i < r->num_surfaces; i++) { renderable_surface* s = r->surfaces[i]; if(s->is_rigged) { GLuint program_animated_handle = shader_program_handle(PROGRAM_ANIMATED); glUseProgram(program_animated_handle); deferred_renderer_use_material(s->base, PROGRAM_ANIMATED); GLint bone_world_matrices_u = glGetUniformLocation(program_animated_handle, "bone_world_matrices"); glUniformMatrix4fv(bone_world_matrices_u, ao->skeleton->num_bones, GL_FALSE, bone_matrix_data); GLint bone_count_u = glGetUniformLocation(program_animated_handle, "bone_count"); glUniform1i(bone_count_u, ao->skeleton->num_bones); GLsizei stride = sizeof(float) * 24; glBindBuffer(GL_ARRAY_BUFFER, s->vertex_vbo); glVertexPointer(3, GL_FLOAT, stride, (void*)0); glEnableClientState(GL_VERTEX_ARRAY); glVertexAttribPointer(NORMAL, 3, GL_FLOAT, GL_FALSE, stride, (void*)(sizeof(float) * 3)); glEnableVertexAttribArray(NORMAL); glVertexAttribPointer(TANGENT, 3, GL_FLOAT, GL_FALSE, stride, (void*)(sizeof(float) * 6)); glEnableVertexAttribArray(TANGENT); glVertexAttribPointer(BINORMAL, 3, GL_FLOAT, GL_FALSE, stride, (void*)(sizeof(float) * 9)); glEnableVertexAttribArray(BINORMAL); glTexCoordPointer(2, GL_FLOAT, stride, (void*)(sizeof(float) * 12)); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glVertexAttribPointer(BONE_INDICIES, 3, GL_FLOAT, GL_FALSE, stride, (void*)(sizeof(float) * 18)); glEnableVertexAttribArray(BONE_INDICIES); glVertexAttribPointer(BONE_WEIGHTS, 3, GL_FLOAT, GL_FALSE, stride, (void*)(sizeof(float) * 21)); glEnableVertexAttribArray(BONE_WEIGHTS); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, s->triangle_vbo); glDrawElements(GL_TRIANGLES, s->num_triangles * 3, GL_UNSIGNED_INT, (void*)0); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableVertexAttribArray(NORMAL); glDisableVertexAttribArray(TANGENT); glDisableVertexAttribArray(BINORMAL); glDisableVertexAttribArray(BONE_INDICIES); glDisableVertexAttribArray(BONE_WEIGHTS); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0); glUseProgram(0); } else { error("Animated object is not rigged!"); } } }
void CCharShape::DrawShadowSphere (TMatrix mat) { double theta, phi, d_theta, d_phi, eps, twopi; double x, y, z; int div = param.tux_shadow_sphere_divisions; TVector3 pt, nml; eps = 1e-15; twopi = M_PI * 2.0; d_theta = d_phi = M_PI / div; GLfloat* vtx = (GLfloat*) alloca(3*2*(div+4)*sizeof(GLfloat)); GLfloat* nrm = (GLfloat*) alloca(3*2*(div+4)*sizeof(GLfloat)); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); glVertexPointer(3, GL_FLOAT, 0, vtx); glNormalPointer(GL_FLOAT, 0, nrm); for (phi = 0.0; phi + eps < M_PI; phi += d_phi) { double cos_theta, sin_theta; double sin_phi, cos_phi; double sin_phi_d_phi, cos_phi_d_phi; int num_vertices = 0; GLfloat *pvtx = vtx; GLfloat *pnrm = nrm; sin_phi = sin (phi); cos_phi = cos (phi); sin_phi_d_phi = sin (phi + d_phi); cos_phi_d_phi = cos (phi + d_phi); if (phi <= eps) { BuildShadowVertex (0., 0., 1., mat, &pt, &nml); *pnrm++ = nml.x; *pnrm++ = nml.y; *pnrm++ = nml.z; *pvtx++ = pt.x; *pvtx++ = pt.y; *pvtx++ = pt.z; num_vertices++; for (theta = 0.0; theta + eps < twopi; theta += d_theta) { sin_theta = sin (theta); cos_theta = cos (theta); x = cos_theta * sin_phi_d_phi; y = sin_theta * sin_phi_d_phi; z = cos_phi_d_phi; BuildShadowVertex (x, y, z, mat, &pt, &nml); *pnrm++ = nml.x; *pnrm++ = nml.y; *pnrm++ = nml.z; *pvtx++ = pt.x; *pvtx++ = pt.y; *pvtx++ = pt.z; num_vertices++; } x = sin_phi_d_phi; y = 0.0; z = cos_phi_d_phi; BuildShadowVertex (x, y, z, mat, &pt, &nml); *pnrm++ = nml.x; *pnrm++ = nml.y; *pnrm++ = nml.z; *pvtx++ = pt.x; *pvtx++ = pt.y; *pvtx++ = pt.z; num_vertices++; glDrawArrays(GL_TRIANGLE_FAN, 0, num_vertices); } else if (phi + d_phi + eps >= M_PI) { BuildShadowVertex (0., 0., -1., mat, &pt, &nml); *pnrm++ = nml.x; *pnrm++ = nml.y; *pnrm++ = nml.z; *pvtx++ = pt.x; *pvtx++ = pt.y; *pvtx++ = pt.z; num_vertices++; for (theta = twopi; theta - eps > 0; theta -= d_theta) { sin_theta = sin (theta); cos_theta = cos (theta); x = cos_theta * sin_phi; y = sin_theta * sin_phi; z = cos_phi; BuildShadowVertex (x, y, z, mat, &pt, &nml); *pnrm++ = nml.x; *pnrm++ = nml.y; *pnrm++ = nml.z; *pvtx++ = pt.x; *pvtx++ = pt.y; *pvtx++ = pt.z; num_vertices++; } x = sin_phi; y = 0.0; z = cos_phi; BuildShadowVertex (x, y, z, mat, &pt, &nml); *pnrm++ = nml.x; *pnrm++ = nml.y; *pnrm++ = nml.z; *pvtx++ = pt.x; *pvtx++ = pt.y; *pvtx++ = pt.z; num_vertices++; glDrawArrays(GL_TRIANGLE_FAN, 0, num_vertices); } else { for (theta = 0.0; theta + eps < twopi; theta += d_theta) { sin_theta = sin (theta); cos_theta = cos (theta); x = cos_theta * sin_phi; y = sin_theta * sin_phi; z = cos_phi; BuildShadowVertex (x, y, z, mat, &pt, &nml); *pnrm++ = nml.x; *pnrm++ = nml.y; *pnrm++ = nml.z; *pvtx++ = pt.x; *pvtx++ = pt.y; *pvtx++ = pt.z; num_vertices++; x = cos_theta * sin_phi_d_phi; y = sin_theta * sin_phi_d_phi; z = cos_phi_d_phi; BuildShadowVertex (x, y, z, mat, &pt, &nml); *pnrm++ = nml.x; *pnrm++ = nml.y; *pnrm++ = nml.z; *pvtx++ = pt.x; *pvtx++ = pt.y; *pvtx++ = pt.z; num_vertices++; } x = sin_phi; y = 0.0; z = cos_phi; BuildShadowVertex (x, y, z, mat, &pt, &nml); *pnrm++ = nml.x; *pnrm++ = nml.y; *pnrm++ = nml.z; *pvtx++ = pt.x; *pvtx++ = pt.y; *pvtx++ = pt.z; num_vertices++; x = sin_phi_d_phi; y = 0.0; z = cos_phi_d_phi; BuildShadowVertex (x, y, z, mat, &pt, &nml); *pnrm++ = nml.x; *pnrm++ = nml.y; *pnrm++ = nml.z; *pvtx++ = pt.x; *pvtx++ = pt.y; *pvtx++ = pt.z; num_vertices++; glDrawArrays(GL_TRIANGLE_STRIP, 0, num_vertices); } } glDisableClientState(GL_NORMAL_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); }
static void va_render (void) { GLint i; for (i = 0; i < sizeof (attribs) / sizeof (*attribs); i++) { struct ATTRIB_DATA *att = &attribs[i]; switch (att->dispatch) { case C: glColorPointer (4, GL_FLOAT, 0, att->data); glEnableClientState (GL_COLOR_ARRAY); break; case S: glSecondaryColorPointerEXT (4, GL_FLOAT, 0, att->data); glEnableClientState (GL_SECONDARY_COLOR_ARRAY_EXT); break; case N: glNormalPointer (GL_FLOAT, 0, att->data); glEnableClientState (GL_NORMAL_ARRAY); break; case V: glVertexPointer (4, GL_FLOAT, 0, att->data); glEnableClientState (GL_VERTEX_ARRAY); break; case T: assert (att->index >= 0 && att->index < 8); glClientActiveTextureARB (GL_TEXTURE0_ARB + att->index); glTexCoordPointer (4, GL_FLOAT, 0, att->data); glEnableClientState (GL_TEXTURE_COORD_ARRAY); break; case F: glFogCoordPointerEXT (GL_FLOAT, 0, att->data); glEnableClientState (GL_FOG_COORDINATE_ARRAY_EXT); break; case A: assert (att->index > 0 && att->index < 16); glVertexAttribPointerARB (att->index, 4, GL_FLOAT, GL_FALSE, 0, att->data); glEnableVertexAttribArrayARB (att->index); break; default: assert (0); } } glDrawArrays (GL_POINTS, 0, 1); for (i = 0; i < sizeof (attribs) / sizeof (*attribs); i++) { struct ATTRIB_DATA *att = &attribs[i]; switch (att->dispatch) { case C: glDisableClientState (GL_COLOR_ARRAY); break; case S: glDisableClientState (GL_SECONDARY_COLOR_ARRAY_EXT); break; case N: glDisableClientState (GL_NORMAL_ARRAY); break; case V: glDisableClientState (GL_VERTEX_ARRAY); break; case T: glClientActiveTextureARB (GL_TEXTURE0_ARB + att->index); glDisableClientState (GL_TEXTURE_COORD_ARRAY); break; case F: glDisableClientState (GL_FOG_COORDINATE_ARRAY_EXT); break; case A: glDisableVertexAttribArrayARB (att->index); break; default: assert (0); } } }
void FGAPIENTRY glutSolidTorusx(GLfixed ir, GLfixed or, GLint sides, GLint rings) { GLint i, j, k, triangles; float s, t, x, y, z, twopi, nx, ny, nz; float sin_s, cos_s, cos_t, sin_t, twopi_s, twopi_t; float twopi_sides, twopi_rings; static GLfixed* v, *n; static GLfixed parms[4]; float irf, orf; GLfixed *p, *q; if (v) { if (parms[0] != ir || parms[1] != or || parms[2] != sides || parms[3] != rings) { free(v); free(n); n = v = 0; glVertexPointer(3, GL_FIXED, 0, 0); glNormalPointer(GL_FIXED, 0, 0); } } if (!v) { irf = _FIXED2FLOAT(ir); orf = _FIXED2FLOAT(or); parms[0] = ir; parms[1] = or; parms[2] = (GLfixed)sides; parms[3] = (GLfixed)rings; p = v = (GLfixed*)malloc(sides*(rings+1)*2*3*sizeof *v); q = n = (GLfixed*)malloc(sides*(rings+1)*2*3*sizeof *n); twopi = 2.0f * (float)PI_; twopi_sides = twopi / sides; twopi_rings = twopi / rings; for (i = 0; i < sides; i++) { for (j = 0; j <= rings; j++) { for (k = 1; k >= 0; k--) { s = (i + k) % sides + 0.5f; t = (float)( j % rings); twopi_s = s * twopi_sides; twopi_t = t * twopi_rings; cos_s = (float)cos(twopi_s); sin_s = (float)sin(twopi_s); cos_t = (float)cos(twopi_t); sin_t = (float)sin(twopi_t); x = (orf + irf * cos_s) * cos_t; y = (orf + irf * cos_s) * sin_t; z = irf * sin_s; *p++ = _FLOAT2FIXED(x); *p++ = _FLOAT2FIXED(y); *p++ = _FLOAT2FIXED(z); nx = cos_s * cos_t; ny = cos_s * sin_t; nz = sin_s; *q++ = _FLOAT2FIXED(nx); *q++ = _FLOAT2FIXED(ny); *q++ = _FLOAT2FIXED(nz); } } } } glVertexPointer(3, GL_FIXED, 0, v); glNormalPointer(GL_FIXED, 0, n); glEnableClientState (GL_VERTEX_ARRAY); glEnableClientState (GL_NORMAL_ARRAY); triangles = (rings + 1) * 2; for(i = 0; i < sides; i++) glDrawArrays(GL_TRIANGLE_STRIP, triangles * i, triangles); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); }
void ofApp::drawScene(int iCameraDraw){ nodeSwarm.draw(); nodeGrid.draw(); ////////////////////////////////// // DRAW EASYCAM FRUSTUM PREVIEW ////////////////////////////////// // // This code draws our camera in // the scene (reddy/pink lines) // // The pyramid-like shape defined // by the cameras view is called // a 'frustum'. // // Often we refer to the volume // which can be seen by the // camera as 'the view frustum'. // //let's not draw the camera //if we're looking through it if (iCameraDraw != 0) { ofPushStyle(); //in 'camera space' this frustum //is defined by a box with bounds //-1->1 in each axis // //to convert from camera to world //space, we multiply by the inverse //matrix of the camera // //by applying this transformation //our box in camera space is //transformed into a frustum in //world space. ofMatrix4x4 inverseCameraMatrix; //the camera's matricies are dependant on //the aspect ratio of the viewport //so we must send the viewport if it's not //the same as fullscreen // //watch the aspect ratio of preview camera inverseCameraMatrix.makeInvertOf(camEasyCam.getModelViewProjectionMatrix( (iMainCamera == 0 ? viewMain : viewGrid[0]) )); // By default, we can say // 'we are drawing in world space' // // The camera matrix performs // world->camera // // The inverse camera matrix performs // camera->world // // Our box is in camera space, if we // want to draw that into world space // we have to apply the camera->world // transformation. // ofPushMatrix(); glMultMatrixf(inverseCameraMatrix.getPtr()); ofSetColor(255, 100, 100); ////////////////////// // DRAW WIREFRAME BOX // // xy plane at z=-1 in camera sapce // (small rectangle at camera position) // GLfloat vertices1[] = { -1.0f, -1.0f, -1.0f, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f, -1.0f, 1.0f, -1.0f, -1.0f }; glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(3, GL_FLOAT, 0, vertices1); glDrawArrays(GL_LINE_LOOP, 0, 4); glDisableClientState(GL_VERTEX_ARRAY); // xy plane at z=1 in camera space // (generally invisible because so far away) // GLfloat vertices2[] = { -1.0f, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f, 1.0f}; glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(3, GL_FLOAT, 0, vertices2); glDrawArrays(GL_LINE_LOOP, 0, 4); glDisableClientState(GL_VERTEX_ARRAY); // connecting lines between above 2 planes // (these are the long lines) // GLfloat vertices3[] = { -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -1.0f, -1.0f, 1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, 1.0f }; glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(3, GL_FLOAT, 0, vertices3); glDrawArrays(GL_LINE_LOOP, 0, 8); glDisableClientState(GL_VERTEX_ARRAY); // ////////////////////// ofPopStyle(); ofPopMatrix(); } // ////////////////////////////////// ////////////////////////////////// // DRAW RAY ////////////////////////////////// // //draw if we've got camEasyCam selected //and we're not looking through it if (iMainCamera == 0 && iCameraDraw != 0) { ofPushStyle(); ofSetColor(100, 100, 255); ofDrawLine(ray[0], ray[1]); ofPopStyle(); } // ////////////////////////////////// }
void FGAPIENTRY glutWireCubex(GLfixed size) { static GLfixed v[72]; static const int cubev[72] = // 72 = 3*6*4 { -1, -1, 1, /* front */ 1, -1, 1, 1, 1, 1, -1, 1, 1, -1, 1, -1, /* back */ 1, 1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, /* left */ -1, -1, 1, -1, 1, 1, -1, 1, -1, 1, -1, 1, /* right */ 1, -1, -1, 1, 1, -1, 1, 1, 1, -1, 1, 1, /* top */ 1, 1, 1, 1, 1, -1, -1, 1, -1, -1, -1, -1, /* bottom */ 1, -1, -1, 1, -1, 1, -1, -1, 1, }; static const float cuben[72] = { 0, 0, F1, /* front */ 0, 0, F1, 0, 0, F1, 0, 0, F1, 0, 0, FM1, /* back */ 0, 0, FM1, 0, 0, FM1, 0, 0, FM1, FM1, 0, 0, /* left */ FM1, 0, 0, FM1, 0, 0, FM1, 0, 0, F1, 0, 0, /* right */ F1, 0, 0, F1, 0, 0, F1, 0, 0, 0, F1, 0, /* top */ 0, F1, 0, 0, F1, 0, 0, F1, 0, 0, FM1, 0, /* bottom */ 0, FM1, 0, 0, FM1, 0, 0, FM1, 0, }; int i; size /= 2; for(i = 0; i < 72; i++) v[i] = cubev[i] * size; glVertexPointer(3, GL_FIXED, 0, v); glNormalPointer(GL_FIXED, 0, cuben); glEnableClientState (GL_VERTEX_ARRAY); glEnableClientState (GL_NORMAL_ARRAY); for(i = 0; i < 6; i++) glDrawArrays(GL_LINE_LOOP, 4*i, 4); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); }
void render_scene() { /* material properties for objects in scene */ static GLfloat wall_mat[4]={1.0f, 1.0f, 1.0f, 1.0f}; static GLfloat disk_mat[4]={0.5f, 0.5f, 1.0f, 1.0f}; GLfloat texcoords[4][2]; GLfloat vertices[4][3]; glShadeModel(GL_SMOOTH); glVertexPointer(3, GL_FLOAT, 0, vertices); glTexCoordPointer(2, GL_FLOAT, 0, texcoords); /* Enable vertices and texcoords arrays */ glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glGetError(); glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); /* Note: wall verticies are ordered so they are all front facing this lets me do back face culling to speed things up. */ glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, wall_mat); /* floor */ glEnable(GL_TEXTURE_2D); glNormal3f(0.f, 1.f, 0.f); /* Fill texture coordinates and vertices arrays */ texcoords[0][0]=0; texcoords[0][1]=0; vertices[0][0]=-100.f; vertices[0][1]=-100.f; vertices[0][2]=-320.f; texcoords[1][0]=1; texcoords[1][1]=0; vertices[1][0]=100.f; vertices[1][1]=-100.f; vertices[1][2]=-320.f; texcoords[3][0]=1; texcoords[3][1]=1; vertices[3][0]=100.f; vertices[3][1]=-100.f; vertices[3][2]=-520.f; texcoords[2][0]=0; texcoords[2][1]=1; vertices[2][0]=-100.f; vertices[2][1]=-100.f; vertices[2][2]=-520.f; glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glDisable(GL_TEXTURE_2D); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); /* walls */ glEnableClientState(GL_VERTEX_ARRAY); glNormal3f(1.f, 0.f, 0.f); vertices[0][0]=-100.f; vertices[0][1]=-100.f; vertices[0][2]=-320.f; vertices[1][0]=-100.f; vertices[1][1]=-100.f; vertices[1][2]=-520.f; vertices[3][0]=-100.f; vertices[3][1]=100.f; vertices[3][2]=-520.f; vertices[2][0]=-100.f; vertices[2][1]=100.f; vertices[2][2]=-320.f; glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glNormal3f(-1.f, 0.f, 0.f); vertices[0][0]=100.f; vertices[0][1]=-100.f; vertices[0][2]=-320.f; vertices[1][0]=100.f; vertices[1][1]=100.f; vertices[1][2]=-320.f; vertices[3][0]=100.f; vertices[3][1]=100.f; vertices[3][2]=-520.f; vertices[2][0]=100.f; vertices[2][1]=-100.f; vertices[2][2]=-520.f; glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glNormal3f(0.f, -1.f, 0.f); vertices[0][0]=-100.f; vertices[0][1]=100.f; vertices[0][2]=-320.f; vertices[1][0]=-100.f; vertices[1][1]=100.f; vertices[1][2]=-520.f; vertices[3][0]=100.f; vertices[3][1]=100.f; vertices[3][2]=-520.f; vertices[2][0]=100.f; vertices[2][1]=100.f; vertices[2][2]=-320.f; glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glNormal3f(0.f, 0.f, 1.f); vertices[0][0]=-100.f; vertices[0][1]=-100.f; vertices[0][2]=-520.f; vertices[1][0]=100.f; vertices[1][1]=-100.f; vertices[1][2]=-520.f; vertices[3][0]=100.f; vertices[3][1]=100.f; vertices[3][2]=-520.f; vertices[2][0]=-100.f; vertices[2][1]=100.f; vertices[2][2]=-520.f; glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glDisableClientState(GL_VERTEX_ARRAY); /* Draw disk */ glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, disk_mat); glPushMatrix(); glTranslatef(-50.f, 0.0f, -400.f); glRotatef(-90.f, 1.f, 0.f, 0.f); glRotatef(rotate, 1.f, 0.0f, 0.0f); gluDisk(disk_fill, 5.0f, 24.0f, 30, 1); glPopMatrix(); glPushMatrix(); glTranslatef(0.0f, 0.0f, -400.f); glRotatef(-90.f, 1.f, 0.f, 0.f); glRotatef(rotate, 1.f, 0.0f, 0.0f); gluDisk(disk_point, 5.0f, 24.0f, 60, 5); glPopMatrix(); glPushMatrix(); glTranslatef(50.f, 0.f, -400.f); glRotatef(-90.f, 1.f, 0.f, 0.f); glRotatef(rotate, 1.f, 0.0f, 0.0f); gluDisk(disk_line, 5.0f, 24.0f, 40, 5); glPopMatrix(); glPushMatrix(); glTranslatef(0.0f, 50.0f, -400.f); glRotatef(-90.f, 1.f, 0.f, 0.f); glRotatef(rotate, 1.f, 0.0f, 0.0f); gluDisk(disk_silh, 5.0f, 24.0f, 40, 5); glPopMatrix(); /* Draw flat shaded disk */ glShadeModel(GL_FLAT); glPushMatrix(); glTranslatef(-50.f, 50.0f, -400.f); glRotatef(-90.f, 1.f, 0.f, 0.f); glRotatef(rotate, 1.f, 0.0f, 0.0f); gluDisk(disk_fill_flat, 5.0f, 24.0f, 30, 1); glPopMatrix(); /* Draw textured disk */ glEnable(GL_TEXTURE_2D); glShadeModel(GL_SMOOTH); glPushMatrix(); glTranslatef(-50.f, -50.0f, -400.f); glRotatef(-90.f, 1.f, 0.f, 0.f); glRotatef(rotate, 1.f, 0.0f, 0.0f); gluDisk(disk_fill_texture, 5.0f, 24.0f, 30, 1); glPopMatrix(); glPushMatrix(); glTranslatef(0.f, -50.0f, -400.f); glRotatef(-90.f, 1.f, 0.f, 0.f); glRotatef(rotate, 1.f, 0.0f, 0.0f); gluDisk(disk_fill_texture, 0.0f, 24.0f, 30, 1); glPopMatrix(); rotate+=1.0f; if (glGetError()) { printf("Oops! I screwed up my OpenGL ES calls somewhere\n"); } }
void drawGLScene(AndroidContext *rc) { #ifdef DROID_EXTREME_LOGS LOG( ANDROID_LOG_VERBOSE, TAG, "drawGLScene : start"); #endif /* DROID_EXTREME_LOGS */ GLfloat vertices[4][3]; GLfloat texcoord[4][2]; // int i, j; float rgba[4]; #ifdef GLES_FRAMEBUFFER_TEST glBindFramebufferOES(GL_FRAMEBUFFER_OES, 0); #endif // Reset states rgba[0] = rgba[1] = rgba[2] = 0.f; rgba[0] = 1.f; glColor4f(1.f, 1.f, 1.f, 1.f); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, rgba); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, rgba); glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, rgba); glDisable(GL_CULL_FACE | GL_NORMALIZE | GL_LIGHTING | GL_BLEND | GL_FOG | GL_COLOR_MATERIAL | GL_TEXTURE_2D); /* Clear The Screen And The Depth Buffer */ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //glEnable(GL_BLEND); //glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_TEXTURE_2D); glBindTexture( GL_TEXTURE_2D, rc->texID); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); // for ( i = 0; i < rc->height/2; i++ ) // for ( j = 0; j < rc->width; j++ ) // rc->texData[ i*rc->width*NBPP + j*NBPP + 3] = 200; // memset(rc->texData, 255, 4 * rc->width * rc->height ); #ifndef GLES_FRAMEBUFFER_TEST glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, rc->tex_width, rc->tex_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, rc->texData ); #endif if ( rc->draw_texture ) { int cropRect[4] = {0,rc->height,rc->width,-rc->height}; glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, cropRect); glDrawTexsOES(0, 0, 0, rc->width, rc->height); } else { /* Enable VERTEX array */ glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); /* Setup pointer to VERTEX array */ glVertexPointer(3, GL_FLOAT, 0, vertices); glTexCoordPointer(2, GL_FLOAT, 0, texcoord); /* Move Left 1.5 Units And Into The Screen 6.0 */ glLoadIdentity(); //glTranslatef(0.0f, 0.0f, -3.3f); //glTranslatef(0.0f, 0.0f, -2.3f); /* Top Right Of The Quad */ vertices[0][0]=rc->tex_width; vertices[0][1]=rc->tex_height; vertices[0][2]=0.0f; texcoord[0][0]=1.f; texcoord[0][1]=0.f; /* Top Left Of The Quad */ vertices[1][0]=0.f; vertices[1][1]=rc->tex_height; vertices[1][2]=0.0f; texcoord[1][0]=0.f; texcoord[1][1]=0.f; /* Bottom Left Of The Quad */ vertices[2][0]=rc->tex_width; vertices[2][1]=0.f; vertices[2][2]=0.0f; texcoord[2][0]=1.f; texcoord[2][1]=1.f; /* Bottom Right Of The Quad */ vertices[3][0]=0.f; vertices[3][1]=0.f; vertices[3][2]=0.0f; texcoord[3][0]=0.f; texcoord[3][1]=1.f; /* Drawing using triangle strips, draw triangles using 4 vertices */ glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); /* Disable vertex array */ glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); } glDisable(GL_TEXTURE_2D); /* Flush all drawings */ glFinish(); #ifdef GLES_FRAMEBUFFER_TEST glBindFramebufferOES(GL_FRAMEBUFFER_OES, rc->framebuff); #endif #ifdef DROID_EXTREME_LOGS LOG( ANDROID_LOG_VERBOSE, TAG, "drawGLScene : end"); #endif /* DROID_EXTREME_LOGS */ }
void __glXDisp_DrawArrays(GLbyte * pc) { __GLXdispatchDrawArraysHeader *hdr = (__GLXdispatchDrawArraysHeader *) pc; __GLXdispatchDrawArraysComponentHeader *compHeader; GLint numVertexes = hdr->numVertexes; GLint numComponents = hdr->numComponents; GLenum primType = hdr->primType; GLint stride = 0; int i; pc += sizeof(__GLXdispatchDrawArraysHeader); compHeader = (__GLXdispatchDrawArraysComponentHeader *) pc; /* compute stride (same for all component arrays) */ for (i = 0; i < numComponents; i++) { GLenum datatype = compHeader[i].datatype; GLint numVals = compHeader[i].numVals; stride += __GLX_PAD(numVals * __glXTypeSize(datatype)); } pc += numComponents * sizeof(__GLXdispatchDrawArraysComponentHeader); /* set up component arrays */ for (i = 0; i < numComponents; i++) { GLenum datatype = compHeader[i].datatype; GLint numVals = compHeader[i].numVals; GLenum component = compHeader[i].component; switch (component) { case GL_VERTEX_ARRAY: glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(numVals, datatype, stride, pc); break; case GL_NORMAL_ARRAY: glEnableClientState(GL_NORMAL_ARRAY); glNormalPointer(datatype, stride, pc); break; case GL_COLOR_ARRAY: glEnableClientState(GL_COLOR_ARRAY); glColorPointer(numVals, datatype, stride, pc); break; case GL_INDEX_ARRAY: glEnableClientState(GL_INDEX_ARRAY); glIndexPointer(datatype, stride, pc); break; case GL_TEXTURE_COORD_ARRAY: glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(numVals, datatype, stride, pc); break; case GL_EDGE_FLAG_ARRAY: glEnableClientState(GL_EDGE_FLAG_ARRAY); glEdgeFlagPointer(stride, (const GLboolean *) pc); break; case GL_SECONDARY_COLOR_ARRAY: { PFNGLSECONDARYCOLORPOINTERPROC SecondaryColorPointerEXT = __glGetProcAddress("glSecondaryColorPointerEXT"); glEnableClientState(GL_SECONDARY_COLOR_ARRAY); SecondaryColorPointerEXT(numVals, datatype, stride, pc); break; } case GL_FOG_COORD_ARRAY: { PFNGLFOGCOORDPOINTERPROC FogCoordPointerEXT = __glGetProcAddress("glFogCoordPointerEXT"); glEnableClientState(GL_FOG_COORD_ARRAY); FogCoordPointerEXT(datatype, stride, pc); break; } default: break; } pc += __GLX_PAD(numVals * __glXTypeSize(datatype)); } glDrawArrays(primType, 0, numVertexes); /* turn off anything we might have turned on */ glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); glDisableClientState(GL_COLOR_ARRAY); glDisableClientState(GL_INDEX_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_EDGE_FLAG_ARRAY); glDisableClientState(GL_SECONDARY_COLOR_ARRAY); glDisableClientState(GL_FOG_COORD_ARRAY); }
bool Object::draw() { if(!alive) { return false; } if(!visible) { return true; } if( this->alphaColor < 255) { glEnable (GL_BLEND); glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); } //Nouveau Repere glPushMatrix(); //scaling / Translation / rotations de l'objet glTranslated(transX,transY,transZ); glRotated(rotateX,1,0,0); glRotated(rotateY,0,1,0); glRotated(rotateZ,0,0,1); glScalef( xScale, yScale, zScale ); glEnable(GL_ALPHA_TEST); glAlphaFunc(GL_GREATER, 0.0f); //La couleur Ambiante de l'objet est mise au BLANC ( sinon vert par defaut) glColor4ub(255,255,255,this->alphaColor); //Texture a appliquer glBindTexture(GL_TEXTURE_2D,this->noTexture); //donne le tableau des points glVertexPointer( 3, GL_FLOAT, 0, this->data->point ); //on prepare le traçage des points glEnableClientState( GL_VERTEX_ARRAY ); //donne le tableau des textures glTexCoordPointer(2, GL_FLOAT, 0, this->data->texture); //Prepare la pose de la texture glEnableClientState(GL_TEXTURE_COORD_ARRAY); glDrawElements( GL_TRIANGLES, this->data->nbIndice , GL_UNSIGNED_INT, data->indice ); //on arrete le traçage glDisableClientState( GL_VERTEX_ARRAY ); //on arrete le traçage de texture glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisable(GL_ALPHA_TEST); //Nouveau Repere detruit glPopMatrix(); return true; }
void GLWall::RenderWall(int textured) { gl_RenderState.Apply(); gl_RenderState.ApplyLightIndex(dynlightindex); #ifdef NO_VBO bool nosplit = !!(textured&RWF_NOSPLIT); bool split = (gl_seamless && !nosplit && seg->sidedef != NULL && !(seg->sidedef->Flags & WALLF_POLYOBJ) && !(flags & GLWF_NOSPLIT)); #if 1 // A bit quicker due to batching, still not very fast.. glBegin(GL_TRIANGLE_FAN); // lower left corner if (textured&1) glTexCoord2f(tcs[0].u,tcs[0].v); glVertex3f(glseg.x1,zbottom[0],glseg.y1); //if (split && glseg.fracleft==0) SplitLeftEdge(tcs); // upper left corner if (textured&1) glTexCoord2f(tcs[1].u,tcs[1].v); glVertex3f(glseg.x1,ztop[0],glseg.y1); //if (split && !(flags & GLWF_NOSPLITUPPER)) SplitUpperEdge(tcs); // color for right side //if (color2) glColor4fv(color2); // upper right corner if (textured&1) glTexCoord2f(tcs[2].u,tcs[2].v); glVertex3f(glseg.x2,ztop[1],glseg.y2); //if (split && glseg.fracright==1) SplitRightEdge(tcs); // lower right corner if (textured&1) glTexCoord2f(tcs[3].u,tcs[3].v); glVertex3f(glseg.x2,zbottom[1],glseg.y2); //if (split && !(flags & GLWF_NOSPLITLOWER)) SplitLowerEdge(tcs); glEnd(); vertexcount+=4; #else static FFlatVertex vtx[100]; // Yes this is static. It's only used once, and I think it's faster as the address doesn't keep changing FFlatVertex *ptr = &vtx[0]; ptr->Set(glseg.x1, zbottom[0], glseg.y1, tcs[LOLFT].u, tcs[LOLFT].v); ptr++; if (split && glseg.fracleft == 0) SplitLeftEdge(ptr); ptr->Set(glseg.x1, ztop[0], glseg.y1, tcs[UPLFT].u, tcs[UPLFT].v); ptr++; if (split && !(flags & GLWF_NOSPLITUPPER)) SplitUpperEdge(ptr); ptr->Set(glseg.x2, ztop[1], glseg.y2, tcs[UPRGT].u, tcs[UPRGT].v); ptr++; if (split && glseg.fracright == 1) SplitRightEdge(ptr); ptr->Set(glseg.x2, zbottom[1], glseg.y2, tcs[LORGT].u, tcs[LORGT].v); ptr++; if (split && !(flags & GLWF_NOSPLITLOWER)) SplitLowerEdge(ptr); // We can workout how many from the difference in pointers vertcount = (ptr - &vtx[0]); glTexCoordPointer(2,GL_FLOAT, sizeof(FFlatVertex),&vtx[0].u); glVertexPointer (3,GL_FLOAT, sizeof(FFlatVertex),&vtx[0].x); glEnableClientState (GL_VERTEX_ARRAY); glEnableClientState (GL_TEXTURE_COORD_ARRAY); glDisableClientState (GL_COLOR_ARRAY); glBindBuffer (GL_ARRAY_BUFFER, 0); // NO VBO glDrawArrays (GL_TRIANGLE_FAN, 0, vertcount); vertexcount += vertcount; #endif #else if (gl.buffermethod != BM_DEFERRED) { MakeVertices(!!(textured&RWF_NOSPLIT)); } else if (vertcount == 0) { // This should never happen but in case it actually does, use the quad drawer as fallback (without edge splitting.) // This way it at least gets drawn. FQuadDrawer qd; qd.Set(0, glseg.x1, zbottom[0], glseg.y1, tcs[LOLFT].u, tcs[LOLFT].v); qd.Set(1, glseg.x1, ztop[0], glseg.y1, tcs[UPLFT].u, tcs[UPLFT].v); qd.Set(2, glseg.x2, ztop[1], glseg.y2, tcs[UPRGT].u, tcs[UPRGT].v); qd.Set(3, glseg.x2, zbottom[1], glseg.y2, tcs[LORGT].u, tcs[LORGT].v); qd.Render(GL_TRIANGLE_FAN); vertexcount += 4; return; } GLRenderer->mVBO->RenderArray(GL_TRIANGLE_FAN, vertindex, vertcount); vertexcount += vertcount; #endif }