bool OGLRender::RenderFillRect(uint32 dwColor, float depth) { float a = (dwColor>>24)/255.0f; float r = ((dwColor>>16)&0xFF)/255.0f; float g = ((dwColor>>8)&0xFF)/255.0f; float b = (dwColor&0xFF)/255.0f; glViewportWrapper(0, windowSetting.statusBarHeightToUse, windowSetting.uDisplayWidth, windowSetting.uDisplayHeight); OPENGL_CHECK_ERRORS; GLboolean cullface = glIsEnabled(GL_CULL_FACE); glDisable(GL_CULL_FACE); OPENGL_CHECK_ERRORS; #if SDL_VIDEO_OPENGL glBegin(GL_TRIANGLE_FAN); glColor4f(r,g,b,a); glVertex4f(m_fillRectVtx[0].x, m_fillRectVtx[1].y, depth, 1); glVertex4f(m_fillRectVtx[1].x, m_fillRectVtx[1].y, depth, 1); glVertex4f(m_fillRectVtx[1].x, m_fillRectVtx[0].y, depth, 1); glVertex4f(m_fillRectVtx[0].x, m_fillRectVtx[0].y, depth, 1); glEnd(); OPENGL_CHECK_ERRORS; #elif SDL_VIDEO_OPENGL_ES2 GLfloat colour[] = { r,g,b,a, r,g,b,a, r,g,b,a, r,g,b,a}; float w = windowSetting.uDisplayWidth / 2.0f, h = windowSetting.uDisplayHeight / 2.0f, inv = 1.0f; GLfloat vertices[] = { -inv + m_fillRectVtx[0].x / w, inv - m_fillRectVtx[1].y / h, depth, 1, -inv + m_fillRectVtx[1].x / w, inv - m_fillRectVtx[1].y / h, depth, 1, -inv + m_fillRectVtx[1].x / w, inv - m_fillRectVtx[0].y / h, depth, 1, -inv + m_fillRectVtx[0].x / w, inv - m_fillRectVtx[0].y / h, depth, 1 }; glVertexAttribPointer(VS_COLOR, 4, GL_FLOAT,GL_FALSE, 0, &colour ); glVertexAttribPointer(VS_POSITION,4,GL_FLOAT,GL_FALSE,0,&vertices); glDisableVertexAttribArray(VS_TEXCOORD0); OPENGL_CHECK_ERRORS; glDrawArrays(GL_TRIANGLE_FAN,0,4); OPENGL_CHECK_ERRORS; //Restore old pointers glVertexAttribPointer(VS_COLOR, 4, GL_UNSIGNED_BYTE,GL_TRUE, sizeof(uint8)*4, &(g_oglVtxColors[0][0]) ); glVertexAttribPointer(VS_POSITION,4,GL_FLOAT,GL_FALSE,sizeof(float)*5,&(g_vtxProjected5[0][0])); glEnableVertexAttribArray(VS_TEXCOORD0); #endif if( cullface ) glEnable(GL_CULL_FACE); OPENGL_CHECK_ERRORS; return true; }
void Keyframe::setKeyframes(SharkBone *bone, glm::vec3 dir, float angle) { MatStack.pushMatrix(); MatStack.rotate(angle, dir); glm::mat4 curr = MatStack.getMatrix(); /* set bone matrix here make funcs for get head/tail vec4 move the rest of this to sharkmesh? Put the matrix stack in sharkmesh...but send it here push from this func, pop from sharkmesh? need to be able to push the current bone...not just bones in order */ glm::vec4 head = curr * glm::vec4(bone->headPoint - glm::vec3(0, 0, 0), 1); glm::vec4 tail = curr * glm::vec4(bone->tailPoint - glm::vec3(0, 0, 0), 1); safe_glUniformMatrix4fv(h_uModelMatrix, glm::value_ptr(MatStack.modelViewMatrix)); glVertex4f(head.x, head.y, head.z, head.w); glVertex4f(tail.x, tail.y, tail.z, tail.w); vector<SharkBone *>::iterator ic; vector<SharkBone *> bones = bone->gBones(); MatStack.popMatrix(); for(ic = bones.begin(); ic != bones.end(); ic++) { setKeyframes((*ic), dir, angle); } }
DWORD ShaderPlugin::ProcessOpenGL(ProcessOpenGLStruct *pGL) { m_shader.BindShader(); for (auto& p : m_parameters) { m_extensions.glUniform1fARB(p.UniformLocation, p.GetScaledValue()); } if (!m_HostSupportsSetTime) { update_time(&m_time, m_startTime); } m_extensions.glUniform1fARB(m_timeLocation, m_time); m_extensions.glUniform3fvARB(m_resolutionLocation, 3, m_resolution); glBegin(GL_QUADS); //m_extensions.glMultiTexCoord2f(GL_TEXTURE0, 0, 0); glVertex4f(-1, -1, 0, 1); //m_extensions.glMultiTexCoord2f(GL_TEXTURE0, 0, m_resolution[1]); glVertex4f(-1, 1, 0, 1); //m_extensions.glMultiTexCoord2f(GL_TEXTURE0, m_resolution[0], m_resolution[1]); glVertex4f(1, 1, 0, 1); //m_extensions.glMultiTexCoord2f(GL_TEXTURE0, m_resolution[0], 0); glVertex4f(1, -1, 0, 1); glEnd(); m_shader.UnbindShader(); return FF_SUCCESS; }
bool OGLRender::RenderFillRect(uint32 dwColor, float depth) { float a = (dwColor>>24)/255.0f; float r = ((dwColor>>16)&0xFF)/255.0f; float g = ((dwColor>>8)&0xFF)/255.0f; float b = (dwColor&0xFF)/255.0f; glViewportWrapper(0, windowSetting.statusBarHeightToUse, windowSetting.uDisplayWidth, windowSetting.uDisplayHeight); OPENGL_CHECK_ERRORS; GLboolean cullface = glIsEnabled(GL_CULL_FACE); glDisable(GL_CULL_FACE); OPENGL_CHECK_ERRORS; glBegin(GL_TRIANGLE_FAN); glColor4f(r,g,b,a); glVertex4f(m_fillRectVtx[0].x, m_fillRectVtx[1].y, depth, 1); glVertex4f(m_fillRectVtx[1].x, m_fillRectVtx[1].y, depth, 1); glVertex4f(m_fillRectVtx[1].x, m_fillRectVtx[0].y, depth, 1); glVertex4f(m_fillRectVtx[0].x, m_fillRectVtx[0].y, depth, 1); glEnd(); OPENGL_CHECK_ERRORS; if( cullface ) glEnable(GL_CULL_FACE); OPENGL_CHECK_ERRORS; return true; }
void InfinitePlaneMesh::render() { glBegin(GL_QUADS); glVertex4f(1, 0, 1, 0.00001); glVertex4f(-1, 0, 1, 0.00001); glVertex4f(-1, 0, -1, 0.00001); glVertex4f(1, 0, -1, 0.00001); glEnd(); }
void SHADOW_MODEL::DrawInfiniteShadowVolume(VECTOR3D lightPosition, bool drawCaps) { glBegin(GL_QUADS); { for(unsigned int i=0; i<numTriangles; ++i) { //if this face does not face the light, continue if(!isFacingLight[i]) continue; //Loop through edges on this face for(int j=0; j<3; ++j) { //Draw the shadow volume "edge" if this is a silhouette edge if(isSilhouetteEdge[i*3+j]) { VECTOR3D vertex1=vertices[indices[i*3+j]].position; VECTOR3D vertex2=vertices[indices[i*3+(j+1)%3]].position; glVertex3fv(vertex2); glVertex3fv(vertex1); glVertex4f( vertex1.x-lightPosition.x, vertex1.y-lightPosition.y, vertex1.z-lightPosition.z, 0.0f); glVertex4f( vertex2.x-lightPosition.x, vertex2.y-lightPosition.y, vertex2.z-lightPosition.z, 0.0f); } } } } glEnd(); //Draw caps if required if(drawCaps) { glBegin(GL_TRIANGLES); { for(unsigned int i=0; i<numTriangles; ++i) { for(int j=0; j<3; ++j) { VECTOR3D vertex=vertices[indices[i*3+j]].position; if(isFacingLight[i]) glVertex3fv(vertex); else glVertex4f( vertex.x-lightPosition.x, vertex.y-lightPosition.y, vertex.z-lightPosition.z, 0.0f); } } } glEnd(); } }
void Face::draw(int renderMode) { glBegin(renderMode); glVertex4f(facepoint0->x, facepoint0->y, facepoint0->z, facepoint0->w); glVertex4f(facepoint1->x, facepoint1->y, facepoint1->z, facepoint1->w); glVertex4f(facepoint2->x, facepoint2->y, facepoint2->z, facepoint2->w); glVertex4f(facepoint3->x, facepoint3->y, facepoint3->z, facepoint3->w); glEnd(); }
void DrawCircle(float sx, float sy, float radius, float*color) { glColor3fv(color); // set the circle color InitCircleVertices(radius); glBegin(GL_TRIANGLE_FAN); glVertex4f(sx, sy, 0, 1); for (int i = 0; i < nvertices; ++i) glVertex4f(sx + vertices[i][0], sy + vertices[i][1], 0, 1); // glVertex4f(sx + mx - 1, sy + my - 1, 0, 1); glEnd(); }
void PsychGLVertex4f(PsychWindowRecordType *windowRecord, float x, float y, float z, float w) { // Classic OpenGL? Use glEnd() and be done: if (PsychIsGLClassic(windowRecord)) { glVertex4f(x,y,z,w); return; } // Make sure we don't overflow our internal static vertex array bufer: if (gl_buffer_index > PSYCH_MAX_IMMSIM_VERTEX_COMPONENTS - 12) { printf("PTB-ERROR: Overflow of internal immediate mode rendering buffer! Limit of %i components reached.\n", PSYCH_MAX_IMMSIM_VERTEX_COMPONENTS); printf("PTB-ERROR: You must reduce the workload, or your stimulus image will be damaged. Likely culprit is Screen('Fill/FrameOval') with too high level of detail!\n\n"); return; } // Store (x,y,z,w) vertex pos first: gl_buffer[gl_buffer_index++] = x; gl_buffer[gl_buffer_index++] = y; gl_buffer[gl_buffer_index++] = z; gl_buffer[gl_buffer_index++] = w; // Then current color (r,g,b,a): gl_buffer[gl_buffer_index++] = (float) currentColor[0]; gl_buffer[gl_buffer_index++] = (float) currentColor[1]; gl_buffer[gl_buffer_index++] = (float) currentColor[2]; gl_buffer[gl_buffer_index++] = (float) currentColor[3]; // Then current texture coordinates (s,t,u,v): gl_buffer[gl_buffer_index++] = currentTexCoord[0]; gl_buffer[gl_buffer_index++] = currentTexCoord[1]; gl_buffer[gl_buffer_index++] = currentTexCoord[2]; gl_buffer[gl_buffer_index++] = currentTexCoord[3]; return; }
static bool test_without_glproxy(void) { glBegin(GL_TRIANGLES); { /* Hit a base entrypoint that won't call gl_version() */ glVertex4f(0, 0, 0, 0); /* Hit an entrypoint that will call probably call gl_version() */ glMultiTexCoord3f(GL_TEXTURE0, 0.0, 0.0, 0.0); /* Hit an entrypoint that will probably call * glproxy_conservative_has_extension(); */ if (has_argb2101010) { glTexCoordP3ui(GL_UNSIGNED_INT_2_10_10_10_REV, 0); } } glEnd(); /* We can't make any assertions about error presence this time * around. This test is just trying to catch segfaults. */ return true; }
void glVertex4fv( const F32 * pv ) { AssertFatal( (beginEndMode >= 0), "glVertex3fv(): called outside glBegin/glEnd"); glVertex4f( pv[0], pv[1], pv[2], pv[3] ); int glError; glError = TEST_FOR_OPENGL_ERRORS }
void glVertex2i( GLint x, GLint y) { AssertFatal( (beginEndMode >= 0), "glVertex2i(): called outside glBegin/glEnd"); glVertex4f( GLfloat(x), GLfloat(y), 0.0f, 1.0f ); int glError; glError = TEST_FOR_OPENGL_ERRORS }
void glVertex3f( GLfloat x, GLfloat y, GLfloat z ) { AssertFatal( (beginEndMode >= 0), "glVertex3f(): called outside glBegin/glEnd"); glVertex4f( x, y, z, 1.0f ); int glError; glError = TEST_FOR_OPENGL_ERRORS }
/* * Display the scene */ void display() { // Clear the image glClear(GL_COLOR_BUFFER_BIT); // Reset previous transforms glLoadIdentity(); // Set view angle glRotated(ph,1,0,0); glRotated(th,0,1,0); // Draw 1 pixel points - Randomly generated colors glColor3ub( rand()%255, rand()%255, rand()%255 ); glPointSize(1); glBegin(GL_LINE_STRIP); int i; /* Coordinates */ double x = 1; double y = 1; double z = 1; /* Time step */ double dt = 0.001; for (i=0;i<50000;i++) { double dx = s*(y-x); double dy = x*(r-z)-y; double dz = x*y - b*z; x += dt*dx; y += dt*dy; z += dt*dz; glVertex4f(x*0.03,y*0.03,z*0.03,w); } glEnd(); // Draw axes in white glColor3f(1,1,1); glBegin(GL_LINES); glVertex3d(0,0,0); glVertex3d(1,0,0); glVertex3d(0,0,0); glVertex3d(0,1,0); glVertex3d(0,0,0); glVertex3d(0,0,1); glEnd(); // Label axes glRasterPos3d(1,0,0); Print("X"); glRasterPos3d(0,1,0); Print("Y"); glRasterPos3d(0,0,1); Print("Z"); // Display parameters glWindowPos2i(5,5); Print("View Angle=%d,%d; s = %f; b = %f; r = %f",th,ph,s,b,r); // Sanity check ErrCheck("display"); // Flush and swap glFlush(); glutSwapBuffers(); }
void GenerateShadowVolume(const Occluder * pOcc, const float olight[4]) { unsigned int edgeOrder[2]; unsigned int i, numEdges = pOcc->handle->edges->len; for (i = 0; i < numEdges; i++) { winged_edge *we = &g_array_index(pOcc->handle->edges, winged_edge, i); float f0 = sqdDist(pOcc->handle->planes, we->w[0], olight); float f1; if (we->w[1] >= 0) f1 = sqdDist(pOcc->handle->planes, we->w[1], olight); else { if (we->w[1] == TOP_EDGE && f0 < 0) continue; f1 = -f0; } if (f0 >= 0 && f1 < 0) { edgeOrder[0] = we->e[1]; edgeOrder[1] = we->e[0]; } else if (f1 >= 0 && f0 < 0) { edgeOrder[0] = we->e[0]; edgeOrder[1] = we->e[1]; } else { continue; } { position *pn0 = &g_array_index(pOcc->handle->points, position, edgeOrder[0]); position *pn1 = &g_array_index(pOcc->handle->points, position, edgeOrder[1]); /* local segment */ glVertex3f(pn0->x, pn0->y, pn0->z); glVertex3f(pn1->x, pn1->y, pn1->z); /* segment projected to infinity (NB. w == 0) */ glVertex4f(pn1->x * olight[3] - olight[0], pn1->y * olight[3] - olight[1], pn1->z * olight[3] - olight[2], 0.f); glVertex4f(pn0->x * olight[3] - olight[0], pn0->y * olight[3] - olight[1], pn0->z * olight[3] - olight[2], 0.f); } } }
void RenderFunction(void) { glClear(GL_COLOR_BUFFER_BIT); glPointSize(20.0); glBegin(GL_POINTS); // primul varf glColor4f( 1.0f, 0.0f, 0.0f, 1.0f); glVertex4f(-0.8f, -0.8f, 0.0f, 1.0f); // al doilea varf glColor4f(0.0f, 1.0f, 0.0f, 1.0f); glVertex4f(0.0f, 0.8f, 0.0f, 1.0f); // al treilea varf glColor4f(0.0f, 0.0f, 1.0f, 1.0f); glVertex4f(0.8f, -0.8f, 0.0f, 1.0f); glEnd( ); glFlush ( ); }
FX_ENTRY void FX_CALL grDrawPoint( const void *pt ) { float *x = (float*)pt + xy_off/sizeof(float); float *y = (float*)pt + xy_off/sizeof(float) + 1; float *z = (float*)pt + z_off/sizeof(float); float *q = (float*)pt + q_off/sizeof(float); unsigned char *pargb = (unsigned char*)pt + pargb_off; float *s0 = (float*)pt + st0_off/sizeof(float); float *t0 = (float*)pt + st0_off/sizeof(float) + 1; float *s1 = (float*)pt + st1_off/sizeof(float); float *t1 = (float*)pt + st1_off/sizeof(float) + 1; float *fog = (float*)pt + fog_ext_off/sizeof(float); LOG("grDrawPoint()\r\n"); if(nvidia_viewport_hack && !render_to_texture) { glViewport(0, viewport_offset, viewport_width, viewport_height); nvidia_viewport_hack = 0; } reloadTexture(); if(need_to_compile) compile_shader(); glBegin(GL_POINTS); if (nbTextureUnits > 2) { if (st0_en) glMultiTexCoord2fARB(GL_TEXTURE1_ARB, *s0 / *q / (float)tex1_width, ytex(0, *t0 / *q / (float)tex1_height)); if (st1_en) glMultiTexCoord2fARB(GL_TEXTURE0_ARB, *s1 / *q / (float)tex0_width, ytex(1, *t1 / *q / (float)tex0_height)); } else { if (st0_en) glTexCoord2f(*s0 / *q / (float)tex0_width, ytex(0, *t0 / *q / (float)tex0_height)); } if (pargb_en) glColor4f(pargb[2]/255.0f, pargb[1]/255.0f, pargb[0]/255.0f, pargb[3]/255.0f); if (fog_enabled && fog_coord_support) { if(!fog_ext_en || fog_enabled != 2) glSecondaryColor3f((1.0f / *q) / 255.0f, 0.0f, 0.0f); else glSecondaryColor3f((1.0f / *fog) / 255.0f, 0.0f, 0.0f); } glVertex4f((*x - (float)widtho) / (float)(width/2) / *q, -(*y - (float)heighto) / (float)(height/2) / *q, ZCALC(*z ,*q), 1.0f / *q); glEnd(); }
void FGLPoint::InternDraw(bool standalone){ if(standalone){ glBegin(GL_POINTS); } glVertex4f(this->GetX(), this->GetY(), this->GetZ(), this->GetW()); if(standalone){ glEnd(); } }
/** 描画 */ void CRenderer::Render() { wglMakeCurrent(m_hdc, m_hglrc); glClearColor(0.0f, 0.5f, 1.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); glBegin(GL_TRIANGLE_STRIP); glColor4f(0xE0, 0xE0, 0x60, 0xff); // 適当な黄色 glVertex4f(-0.5f, -0.5f, 0.0f, 1.0f); glVertex4f(-0.5f, 0.5f, 0.0f, 1.0f); glVertex4f( 0.5f, -0.5f, 0.0f, 1.0f); glVertex4f( 0.5f, 0.3f, 0.0f, 1.0f); glEnd(); glFlush(); SwapBuffers(m_hdc); wglMakeCurrent(NULL, NULL); }
void CMesh::Draw(MATRIX4D &M) { for (unsigned long i = 0; i < m_Indices.size(); i += 3) { for (unsigned long j = 0; j < 3; j++) { VECTOR4D &C = m_Vertices[m_Indices[i + j]].Color; VECTOR4D &Tex = m_Vertices[m_Indices[i + j]].TexCoord; VECTOR4D V = M * m_Vertices[m_Indices[i + j]].Position; glColor4f(C.r, C.g, C.b, C.a); glTexCoord2f(Tex.x, Tex.y); glVertex4f(V.x, V.y, V.z, V.w); } } }
void draw_special_sphere(int tess) { float r = 1.0, r1, r2, z1, z2; float theta, phi; int nlon = tess, nlat = tess; int i, j; glBegin(GL_TRIANGLE_FAN); theta = M_PI * 1.0 / nlat; r2 = r * sin(theta); z2 = r * cos(theta); glNormal3f(0.0, 0.0, 1.0); glVertex4f(0.0, 0.0, r * r, r); for (j = 0, phi = 0.0; j <= nlon; j++, phi = 2 * M_PI * j / nlon) { glNormal3f(r2 * cos(phi), r2 * sin(phi), z2); glVertex4f(r2 * cos(phi) * z2, r2 * sin(phi) * z2, z2 * z2, z2); /* top */ } glEnd(); for (i = 2; i < nlat; i++) { theta = M_PI * i / nlat; r1 = r * sin(M_PI * (i - 1) / nlat); z1 = r * cos(M_PI * (i - 1) / nlat); r2 = r * sin(theta); z2 = r * cos(theta); if (fabs(z1) < 0.01 || fabs(z2) < 0.01) break; glBegin(GL_QUAD_STRIP); for (j = 0, phi = 0; j <= nlat; j++, phi = 2 * M_PI * j / nlon) { glNormal3f(r1 * cos(phi), r1 * sin(phi), z1); glVertex4f(r1 * cos(phi) * z1, r1 * sin(phi) * z1, z1 * z1, z1); glNormal3f(r2 * cos(phi), r2 * sin(phi), z2); glVertex4f(r2 * cos(phi) * z2, r2 * sin(phi) * z2, z2 * z2, z2); } glEnd(); } }
/*TODO: add bottom and top face triangles*/ void draw_cube_brute() { draw_triangle(vertices_cube_brute, 4,5,1,BLUE); draw_triangle(vertices_cube_brute, 0,4,1,BLUE); draw_triangle(vertices_cube_brute, 5,6,2,CYAN); draw_triangle(vertices_cube_brute, 1,5,2,CYAN); draw_triangle(vertices_cube_brute, 3,2,6,YELLOW); draw_triangle(vertices_cube_brute, 7,3,6,YELLOW); draw_triangle(vertices_cube_brute, 0,3,7,MAGENTA); draw_triangle(vertices_cube_brute, 4,0,7,MAGENTA); draw_triangle(vertices_cube_brute, 1,2,3,WHITE); draw_triangle(vertices_cube_brute, 7,6,5,WHITE); //manually calculate the normals for the cube if(draw_norms){ glBegin(GL_LINES); { glVertex4f(1,1,-1,1); glVertex4f(1+1/sqrt(3),1+1/sqrt(3),-1-1/sqrt(3),1); glVertex4f(1,-1,-1,1); glVertex4f(1+1/sqrt(3),-1-1/sqrt(3),-1-1/sqrt(3),1); glVertex4d(1,-1,1,1); glVertex4f(1+1/sqrt(3),-1-1/sqrt(3),1+1/sqrt(3),1); glVertex4d(-1,-1,1,1); glVertex4f(-1-1/sqrt(3),-1-1/sqrt(3),1+1/sqrt(3),1); glVertex4d(-1,1,1,1); glVertex4f(-1-1/sqrt(3),1+1/sqrt(3),1+1/sqrt(3),1); glVertex4d(-1,1,-1,1); glVertex4f(-1-1/sqrt(3),1+1/sqrt(3),-1-1/sqrt(3),1); glVertex4d(-1,-1,-1,1); glVertex4f(-1-1/sqrt(3),-1-1/sqrt(3),-1-1/sqrt(3),1); glVertex4d(1,1,1,1); glVertex4f(1+1/sqrt(3),1+1/sqrt(3),1+1/sqrt(3),1); } glEnd(); } }
void Floor::draw(MatrixStack &mViewStack) { // save previous modelview matrix mViewStack.push(); // Draw axes // y coord offset by 0.01 to stop the lines from fighting each other glLineWidth(3.0f); glBegin(GL_LINES); // x glColor4f(1.0f, 0.0f, 0.0f, 1.0f); glVertex4f(60.0f, 0.01f, 60.0f, 1.0f); glVertex4f(120.0f, 0.01f, 60.0f, 1.0f); // y glColor4f(0.0f, 1.0f, 0.0f, 1.0f); glVertex4f(60.0f, 0.0f, 60.0f, 1.0f); glVertex4f(60.0f, 60.0f, 60.0f, 1.0f); // z glColor4f(0.0f, 0.0f, 1.0f, 1.0f); glVertex4f(60.0f, 0.01f, 60.0f, 1.0f); glVertex4f(60.0f, 0.01f, 120.0f, 1.0f); glEnd(); // Draw floor grid glLineWidth(1.0f); for (int i = 0; i < GRID_SIZE - 1; i++) { glBegin(GL_LINE_LOOP); glColor4f(0.6f, 0.6f, 0.6f, 1.0f); for (int j = 0; j < GRID_SIZE - 1; j++) { glVertex4f(grid[i][j].x, 0.0f, grid[i][j].z, 1.0f); glVertex4f(grid[i+1][j].x, 0.0f, grid[i+1][j].z, 1.0f); glVertex4f(grid[i+1][j+1].x, 0.0f, grid[i+1][j+1].z, 1.0f); glVertex4f(grid[i][j+1].x, 0.0f, grid[i][j+1].z, 1.0f); } glEnd(); } // restore previous modelview matrix mViewStack.pop(); }
GLvoid glVertex3f(GLfloat x, GLfloat y, GLfloat z) { if (vt_possize > 3){ glVertex4f(x, y, z, 1.0); } else { vt_possize = 3; vt_current->x = x; vt_current->y = y; vt_current->z = z; vt_vbuffer[vt_count++] = vt_current[0]; } }
void recursion( float startX, float startY, float startZ, float startW) { glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER,0,streamoutBufffer[0]); glBeginTransformFeedback(GL_POINTS); glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, outputQuery); glPointSize(1); glBegin(GL_POINTS); glVertex4f(startX, startY, startZ, startW); glEnd(); glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN); glEndTransformFeedback(); GLint outPointCount = 0; GLint succ = 0; while(!succ) glGetQueryObjectiv(outputQuery, GL_QUERY_RESULT_AVAILABLE, &succ); glGetQueryObjectiv(outputQuery, GL_QUERY_RESULT, &outPointCount); //std::cout << "points written: " << outPointCount << std::endl; succ = 0; glEnableClientState(GL_VERTEX_ARRAY); int bb = 0; while(outPointCount > 0) { glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER,0,streamoutBufffer[(bb+1)%2]); glBeginTransformFeedback(GL_POINTS); glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, outputQuery); glBindBufferARB(GL_ARRAY_BUFFER_ARB, streamoutBufffer[bb]); glVertexPointer(4,GL_FLOAT,0,NULL); glDrawArrays(GL_POINTS, 0, outPointCount); glEndTransformFeedback(); glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN); while(!succ) glGetQueryObjectiv(outputQuery, GL_QUERY_RESULT_AVAILABLE, &succ); glGetQueryObjectiv(outputQuery, GL_QUERY_RESULT, &outPointCount); succ = 0; bb = (bb + 1) % 2; } glDisableClientState(GL_VERTEX_ARRAY); }
// draw the pool ball! void PoolBall::render(glm::dmat4 &parent_model) { glm::dmat4 model = parent_model * glm::translate(glm::dmat4(1.0), glm::dvec3(x, diameter/2, z)) * rotation * glm::scale(glm::dmat4(1.0), glm::dvec3(diameter/2)); mesh.render(tex, model); #if 0 glUseProgram(0); glErrorCheck(); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glMultMatrixd(&view[0][0]); glMultMatrixd(&parent_model[0][0]); glMatrixMode(GL_PROJECTION); //glLoadIdentity(); extern double wide_view[]; //gluLookAt(eye[0], eye[1], eye[2], wide_view[3], wide_view[4], wide_view[5], 0, 1, 0); glLoadMatrixd(&perspective[0][0]); glEnable(GL_DEPTH_TEST); glBegin(GL_LINES); #if 0 glVertex4f(x, 0, z, 1.0f); glVertex4f(light_position[0], light_position[1], light_position[2], 1.0f); #endif #if 0 for (int i = 0; i < vertices.size(); ++i) { glVertex3f(vertices[i][0], vertices[i][1], vertices[i][2]); glVertex3f(vertices[i][0] + normals[i][0], vertices[i][1] + normals[i][1], vertices[i][2] + normals[i][2]); } #endif glEnd(); glErrorCheck(); #endif glDisable(GL_TEXTURE_2D); }
static void setup_legacy_const_attribute (CoglContext *ctx, CoglPipeline *pipeline, CoglAttribute *attribute) { #ifdef COGL_PIPELINE_PROGEND_GLSL if (attribute->name_state->name_id == COGL_ATTRIBUTE_NAME_ID_CUSTOM_ARRAY) { if (ctx->driver != COGL_DRIVER_GLES1) setup_generic_const_attribute (ctx, pipeline, attribute); } else #endif { float vector[4] = { 0, 0, 0, 1 }; float *boxed = attribute->d.constant.boxed.v.float_value; int n_components = attribute->d.constant.boxed.size; int i; for (i = 0; i < n_components; i++) vector[i] = boxed[i]; switch (attribute->name_state->name_id) { case COGL_ATTRIBUTE_NAME_ID_COLOR_ARRAY: GE (ctx, glColor4f (vector[0], vector[1], vector[2], vector[3])); break; case COGL_ATTRIBUTE_NAME_ID_NORMAL_ARRAY: GE (ctx, glNormal3f (vector[0], vector[1], vector[2])); break; case COGL_ATTRIBUTE_NAME_ID_TEXTURE_COORD_ARRAY: { int layer_number = attribute->name_state->layer_number; CoglPipelineLayer *layer = _cogl_pipeline_get_layer (pipeline, layer_number); int unit = _cogl_pipeline_layer_get_unit_index (layer); GE (ctx, glClientActiveTexture (GL_TEXTURE0 + unit)); GE (ctx, glMultiTexCoord4f (vector[0], vector[1], vector[2], vector[3])); break; } case COGL_ATTRIBUTE_NAME_ID_POSITION_ARRAY: GE (ctx, glVertex4f (vector[0], vector[1], vector[2], vector[3])); break; default: g_warn_if_reached (); } } }
static void vert(float theta, float phi) { float r = 0.75f; float x, y, z, nx, ny, nz; nx = sin(DTOR * theta) * cos(DTOR * phi); ny = sin(DTOR * phi); nz = cos(DTOR * theta) * cos(DTOR * phi); glNormal3f(nx, ny, nz); x = r * sin(DTOR * theta) * cos(DTOR * phi); y = r * sin(DTOR * phi); z = r * cos(DTOR * theta) * cos(DTOR * phi); glVertex4f(x, y, z, 1.0); }
void CMesh::Draw(const MATRIX4D &M) { for (unsigned int i = 0; i < m_Indexes.size(); i += 3) { for (int j = 0; j < 3; ++j) { auto &C = m_Vertexes[m_Indexes[i + j]].Color; glColor4f(C.r, C.g, C.b, C.a); auto &T = m_Vertexes[m_Indexes[i + j]].TexCoord; glTexCoord2f(T.x, T.y); VECTOR4D V = M * m_Vertexes[m_Indexes[i + j]].Position; glVertex4f(V.x, V.y, V.z, V.w); } } }
static void renderSlices( const SliceClipper& sliceClipper ) { int numberOfSlices = static_cast<int>( 3.6 / sliceClipper.sliceDistance ); for( int s = 0; s < numberOfSlices; ++s ) { glBegin( GL_POLYGON ); for( int i = 0; i < 6; ++i ) { eq::Vector3f pos = sliceClipper.getPosition( i, numberOfSlices-1-s ); glVertex4f( pos.x(), pos.y(), pos.z(), 1.0 ); } glEnd(); } }