static void ddRenderVecs(const mat4& projview) { const ShaderInfo* shader = g_dbgdrawShader.get(); GLint posLoc = shader->m_attrs[GEOM_Pos]; GLint colorLoc = shader->m_attrs[GEOM_Color]; GLint mvpLoc = shader->m_uniforms[BIND_Mvp]; glUniformMatrix4fv(mvpLoc, 1, 0, projview.m); const ddVec* cur = g_lists.m_vecs; if(cur) { glBegin(GL_LINES); while(cur) { vec3 from = TransformPoint(cur->m_xfm, cur->m_from); vec3 to = TransformPoint(cur->m_xfm, cur->m_from + cur->m_vec); glVertexAttrib3fv(colorLoc, &cur->m_color.r); glVertexAttrib3fv(posLoc, &from.x); glVertexAttrib3fv(posLoc, &to.x); cur = cur->m_next; } glEnd(); } }
void Shader::use(bool forceReload) { static Shader *previousShader = NULL; if (this == previousShader && !forceReload) return; previousShader = this; glUseProgram(*_shaderNo); for (uint32 i = 0; i < _attributes.size(); ++i) { Graphics::VertexAttrib &attrib = _attributes[i]; if (attrib._enabled) { glEnableVertexAttribArray(i); glBindBuffer(GL_ARRAY_BUFFER, attrib._vbo); glVertexAttribPointer(i, attrib._size, attrib._type, attrib._normalized, attrib._stride, (const GLvoid *)attrib._offset); } else { glDisableVertexAttribArray(i); switch (attrib._size) { case 2: glVertexAttrib2fv(i, attrib._const); break; case 3: glVertexAttrib3fv(i, attrib._const); break; case 4: glVertexAttrib4fv(i, attrib._const); break; } } } }
void drawBumpPlate(float size, int nRepeatS, int nRepeatT) {//x-y平面 float tnt[3]; float s, t; float sz = 0.5 * size; static float p[4][3] = //z:上方向 { { sz, sz, 0.0}, {-sz, sz, 0.0}, {-sz,-sz, 0.0}, { sz,-sz, 0.0} }; s = (float)nRepeatS; t = (float)nRepeatT; GLuint tangentLoc = glGetAttribLocation(shaderProg, "tangent"); glEnable(GL_TEXTURE_2D); glBegin(GL_QUADS); tnt[0] = 1.0; tnt[1] = 0.0; tnt[2] = 0.0; glVertexAttrib3fv(tangentLoc, tnt); glNormal3f(0.0, 0.0, 1.0); //z方向の法線 //テクスチャー座標と頂点番号との対応付け glTexCoord2f(0.0, 0.0); glVertex3fv(p[2]); glTexCoord2f( s , 0.0); glVertex3fv(p[3]); glTexCoord2f( s , t ); glVertex3fv(p[0]); glTexCoord2f(0.0, t ); glVertex3fv(p[1]); glEnd(); glDisable(GL_TEXTURE_2D); }
void draw_trinagle_face(const float A[], const float B[], const float C[], float normal[3], float r = 1.0f, float g = 1.0f, float b = 1.0f) { glBegin(GL_TRIANGLES); glVertexAttrib3f(GLT_ATTRIBUTE_COLOR, r, g, b); glVertexAttrib3fv(GLT_ATTRIBUTE_NORMAL, normal); glVertex3fv(A); glVertex3fv(B); glVertex3fv(C); glEnd(); }
void floor_tr_normal(const float A[], const float B[], const float C[], float normalVector[3], float r = 1.0f, float g = 1.0f, float b = 1.0f) { glBegin(GL_TRIANGLES); glVertexAttrib3f(GLT_ATTRIBUTE_COLOR, r, g, b); glVertexAttrib3fv(GLT_ATTRIBUTE_NORMAL, normalVector); glVertex3fv(A); glVertex3fv(B); glVertex3fv(C); glEnd(); }
void GLSLProgram::SetAttributeVariable(char* name, float vals[3]) { int loc; if ((loc = GetAttributeLocation(name)) >= 0) { this->Use(); glVertexAttrib3fv(loc, vals); } };
bool ShaderManager :: SetAttributeVector ( const char * name, const Vector3D& value ) { int location = glGetAttribLocation ( Program, name ); if ( location < 0 ) return false; glVertexAttrib3fv ( location, value ); return true; }
//---------------------------------------------------- void TriangleFace(M3DVector3f a, M3DVector3f b, M3DVector3f c) { M3DVector3f normal, bMa, cMa; m3dSubtractVectors3(bMa, b, a); m3dSubtractVectors3(cMa, c, a); m3dCrossProduct3(normal, bMa, cMa); m3dNormalizeVector3(normal); glVertexAttrib3fv(GLT_ATTRIBUTE_NORMAL, normal); glVertex3fv(a); glVertex3fv(b); glVertex3fv(c); }
void Shader::SetAttribute(const char* var, float* v, int size) { int id = GetAttributeId(var); if(id >= 0) { if(size == 2) glVertexAttrib2fv(id, v); else if(size == 3) glVertexAttrib3fv(id, v); else if(size == 4) glVertexAttrib4fv(id, v); } }
void FFlatVertexBuffer::ImmRenderBuffer(unsigned int primtype, unsigned int offset, unsigned int count) { // this will only get called if we can't acquire a persistently mapped buffer. #ifndef CORE_PROFILE glBegin(primtype); for (unsigned int i = 0; i < count; i++) { glVertexAttrib2fv(VATTR_TEXCOORD, &map[offset + i].u); glVertexAttrib3fv(VATTR_VERTEX, &map[offset + i].x); } glEnd(); #endif }
//---------------------------------------------------- void drawSmoothTriangles(int n_faces, float *vertices, int *faces) { M3DVector3f normal; for (int i = 0; i < n_faces; i++) { glBegin(GL_TRIANGLES); for(int j=0;j<3;++j) { m3dCopyVector3(normal,vertices+3*faces[i*3+j]); m3dNormalizeVector3(normal); glVertexAttrib3fv(GLT_ATTRIBUTE_NORMAL, normal); glVertex3fv(vertices+3*faces[i*3+j]); } glEnd(); } }
/* * Specify a vertex to opengl with texCoords, tangent, normal and position */ void Sphere::drawVertex(int i, int j, GLuint tgLoc, GLuint tcoordsLoc) const { if (tgLoc != 0) { glVertexAttrib3fv(tgLoc, &_tangents[ 3*(j*(_vDivs+1) + i) ]); } if (tcoordsLoc != 0) { glVertexAttrib2fv(tcoordsLoc, &_texcoords[2*(j*(_vDivs+1) + i) ]); } glNormal3fv(&_normals[ 3*(j*(_vDivs+1) + i) ]); glVertex3fv(&_vertexs[ 3*(j*(_vDivs+1) + i) ]); }
static void ddRenderPoints(const mat4& projview) { const ShaderInfo* shader = g_dbgdrawShader.get(); GLint posLoc = shader->m_attrs[GEOM_Pos]; GLint colorLoc = shader->m_attrs[GEOM_Color]; GLint mvpLoc = shader->m_uniforms[BIND_Mvp]; glUniformMatrix4fv(mvpLoc, 1, 0, projview.m); const ddPoint* cur = g_lists.m_points; if(cur) { glPointSize(4.f); glBegin(GL_POINTS); while(cur) { vec3 pt = TransformPoint(cur->m_xfm, cur->m_point); glVertexAttrib3fv(colorLoc, &cur->m_color.r); glVertexAttrib3fv(posLoc, &pt.x); cur = cur->m_next; } glEnd(); } }
enum piglit_result piglit_display(void) { float color[4][4] = { {1, 0, 0, 1}, {0, 1, 0, 1}, {0, 0, 1, 1}, {1, 1, 1, 1}, }; bool pass = true; glViewport(0, 0, piglit_width, piglit_height); glClearColor(0.5, 0.5, 0.5, 0.5); glClear(GL_COLOR_BUFFER_BIT); glVertexAttrib1fv(attr, color[0]); glViewport(0, 0, piglit_width/2, piglit_height/2); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glVertexAttrib2fv(attr, color[1]); glViewport(0, piglit_height/2, piglit_width/2, piglit_height/2); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glVertexAttrib3fv(attr, color[2]); glViewport(piglit_width/2, 0, piglit_width/2, piglit_height/2); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glVertexAttrib4fv(attr, color[3]); glViewport(piglit_width/2, piglit_height/2, piglit_width/2, piglit_height/2); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); pass &= piglit_probe_rect_rgba(0, 0, piglit_width / 2, piglit_height / 2, color[0]); pass &= piglit_probe_rect_rgba(0, piglit_height / 2, piglit_width / 2, piglit_height / 2, color[1]); pass &= piglit_probe_rect_rgba(piglit_width / 2, 0, piglit_width / 2, piglit_height / 2, color[2]); pass &= piglit_probe_rect_rgba(piglit_width / 2, piglit_height / 2, piglit_width / 2, piglit_height / 2, color[3]); piglit_present_results(); return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
void AttributeVariable::set(GLfloat * fv_, int param_, int count_) { switch(param_) { case 1: { glVertexAttrib1fv(_location, fv_); } break; case 2: { glVertexAttrib2fv(_location, fv_); } break; case 3: { glVertexAttrib3fv(_location, fv_); } break; case 4: { glVertexAttrib4fv(_location, fv_); } break; default: break; } }
static void setup_generic_const_attribute (CoglContext *context, CoglPipeline *pipeline, CoglAttribute *attribute) { int name_index = attribute->name_state->name_index; int attrib_location = _cogl_pipeline_progend_glsl_get_attrib_location (pipeline, name_index); int columns; int i; if (attrib_location == -1) return; if (attribute->d.constant.boxed.type == COGL_BOXED_MATRIX) columns = attribute->d.constant.boxed.size; else columns = 1; /* Note: it's ok to access a COGL_BOXED_FLOAT as a matrix with only * one column... */ switch (attribute->d.constant.boxed.size) { case 1: GE( context, glVertexAttrib1fv (attrib_location, attribute->d.constant.boxed.v.matrix)); break; case 2: for (i = 0; i < columns; i++) GE( context, glVertexAttrib2fv (attrib_location + i, attribute->d.constant.boxed.v.matrix)); break; case 3: for (i = 0; i < columns; i++) GE( context, glVertexAttrib3fv (attrib_location + i, attribute->d.constant.boxed.v.matrix)); break; case 4: for (i = 0; i < columns; i++) GE( context, glVertexAttrib4fv (attrib_location + i, attribute->d.constant.boxed.v.matrix)); break; default: g_warn_if_reached (); } }
void Shader::use(bool forceReload) { static Shader *previousShader = nullptr; static uint32 previousNumAttributes = 0; if (this == previousShader && !forceReload) return; // The previous shader might have had more attributes. Disable any extra ones. if (_attributes.size() < previousNumAttributes) { for (uint32 i = _attributes.size(); i < previousNumAttributes; ++i) { glDisableVertexAttribArray(i); } } previousShader = this; previousNumAttributes = _attributes.size(); glUseProgram(*_shaderNo); for (uint32 i = 0; i < _attributes.size(); ++i) { Graphics::VertexAttrib &attrib = _attributes[i]; if (attrib._enabled) { glEnableVertexAttribArray(i); glBindBuffer(GL_ARRAY_BUFFER, attrib._vbo); glVertexAttribPointer(i, attrib._size, attrib._type, attrib._normalized, attrib._stride, (const GLvoid *)attrib._offset); } else { glDisableVertexAttribArray(i); switch (attrib._size) { case 2: glVertexAttrib2fv(i, attrib._const); break; case 3: glVertexAttrib3fv(i, attrib._const); break; case 4: glVertexAttrib4fv(i, attrib._const); break; } } } }
static void ddRenderSpheres(const mat4& projview) { const ShaderInfo* shader = g_dbgdrawShader.get(); GLint colorLoc = shader->m_attrs[GEOM_Color]; GLint mvpLoc = shader->m_uniforms[BIND_Mvp]; const ddSphere* cur = g_lists.m_spheres; while(cur) { // ignore scale -- debug spheres have to be spheres vec3 center = TransformPoint(cur->m_xfm, cur->m_center); mat4 model = MakeTranslation(center.x, center.y, center.z) * MakeScale(cur->m_radius, cur->m_radius, cur->m_radius); mat4 mvp = projview * model; glVertexAttrib3fv(colorLoc, &cur->m_color.r); glUniformMatrix4fv(mvpLoc, 1, 0, mvp.m); g_dbgSphereGeom->Render(*shader); cur = cur->m_next; } }
void Mesh::bindNormalObject(int _loc) { glDisableVertexAttribArray(_loc); glVertexAttrib3fv(_loc, &_normal.x); }
// 渲染 ///////////////////////////////////////////////////////////////////////////////// void OGLESRenderEngine::DoRender(RenderTechnique const & tech, RenderLayout const & rl) { uint32_t const num_instance = rl.NumInstances(); BOOST_ASSERT(num_instance != 0); OGLESShaderObjectPtr cur_shader = checked_pointer_cast<OGLESShaderObject>(tech.Pass(0)->GetShaderObject()); checked_cast<OGLESRenderLayout const *>(&rl)->Active(cur_shader); size_t const vertexCount = rl.UseIndices() ? rl.NumIndices() : rl.NumVertices(); GLenum mode; uint32_t primCount; OGLESMapping::Mapping(mode, primCount, rl); numPrimitivesJustRendered_ += num_instance * primCount; numVerticesJustRendered_ += num_instance * vertexCount; GLenum index_type = GL_UNSIGNED_SHORT; uint8_t* index_offset = nullptr; if (rl.UseIndices()) { if (EF_R16UI == rl.IndexStreamFormat()) { index_type = GL_UNSIGNED_SHORT; index_offset += rl.StartIndexLocation() * 2; } else { index_type = GL_UNSIGNED_INT; index_offset += rl.StartIndexLocation() * 4; } } uint32_t const num_passes = tech.NumPasses(); size_t const inst_format_size = rl.InstanceStreamFormat().size(); if (glloader_GLES_VERSION_3_0() && rl.InstanceStream()) { OGLESGraphicsBuffer& stream(*checked_pointer_cast<OGLESGraphicsBuffer>(rl.InstanceStream())); uint32_t const instance_size = rl.InstanceSize(); BOOST_ASSERT(num_instance * instance_size <= stream.Size()); uint8_t* elem_offset = nullptr; for (size_t i = 0; i < inst_format_size; ++ i) { vertex_element const & vs_elem = rl.InstanceStreamFormat()[i]; GLint attr = cur_shader->GetAttribLocation(vs_elem.usage, vs_elem.usage_index); if (attr != -1) { GLint const num_components = static_cast<GLint>(NumComponents(vs_elem.format)); GLenum type; GLboolean normalized; OGLESMapping::MappingVertexFormat(type, normalized, vs_elem.format); normalized = (((VEU_Diffuse == vs_elem.usage) || (VEU_Specular == vs_elem.usage)) && !IsFloatFormat(vs_elem.format)) ? GL_TRUE : normalized; GLvoid* offset = static_cast<GLvoid*>(elem_offset + rl.StartInstanceLocation() * instance_size); stream.Active(false); glVertexAttribPointer(attr, num_components, type, normalized, instance_size, offset); glEnableVertexAttribArray(attr); glVertexAttribDivisor(attr, 1); } elem_offset += vs_elem.element_size(); } if (so_rl_) { glBeginTransformFeedback(so_primitive_mode_); } if (rl.UseIndices()) { for (uint32_t i = 0; i < num_passes; ++ i) { RenderPassPtr const & pass = tech.Pass(i); pass->Bind(); if (so_rl_) { OGLESShaderObjectPtr shader = checked_pointer_cast<OGLESShaderObject>(pass->GetShaderObject()); glTransformFeedbackVaryings(shader->GLSLProgram(), static_cast<GLsizei>(so_vars_ptrs_.size()), &so_vars_ptrs_[0], GL_SEPARATE_ATTRIBS); for (uint32_t j = 0; j < so_buffs_.size(); ++ j) { glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, j, so_buffs_[j]); } } glDrawElementsInstanced(mode, static_cast<GLsizei>(rl.NumIndices()), index_type, index_offset, num_instance); pass->Unbind(); } } else { for (uint32_t i = 0; i < num_passes; ++ i) { RenderPassPtr const & pass = tech.Pass(i); pass->Bind(); if (so_rl_) { OGLESShaderObjectPtr shader = checked_pointer_cast<OGLESShaderObject>(pass->GetShaderObject()); glTransformFeedbackVaryings(shader->GLSLProgram(), static_cast<GLsizei>(so_vars_ptrs_.size()), &so_vars_ptrs_[0], GL_SEPARATE_ATTRIBS); for (uint32_t j = 0; j < so_buffs_.size(); ++ j) { glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, j, so_buffs_[j]); } } glDrawArraysInstanced(mode, rl.StartVertexLocation(), static_cast<GLsizei>(rl.NumVertices()), num_instance); pass->Unbind(); } } if (so_rl_) { glEndTransformFeedback(); } for (size_t i = 0; i < inst_format_size; ++ i) { vertex_element const & vs_elem = rl.InstanceStreamFormat()[i]; GLint attr = cur_shader->GetAttribLocation(vs_elem.usage, vs_elem.usage_index); if (attr != -1) { glDisableVertexAttribArray(attr); glVertexAttribDivisor(attr, 0); } } } else { for (uint32_t instance = rl.StartInstanceLocation(); instance < rl.StartInstanceLocation() + num_instance; ++ instance) { if (rl.InstanceStream()) { GraphicsBuffer& stream = *rl.InstanceStream(); uint32_t const instance_size = rl.InstanceSize(); BOOST_ASSERT(num_instance * instance_size <= stream.Size()); GraphicsBuffer::Mapper mapper(stream, BA_Read_Only); uint8_t const * buffer = mapper.Pointer<uint8_t>(); uint32_t elem_offset = 0; for (size_t i = 0; i < inst_format_size; ++ i) { BOOST_ASSERT(elem_offset < instance_size); vertex_element const & vs_elem = rl.InstanceStreamFormat()[i]; GLint attr = cur_shader->GetAttribLocation(vs_elem.usage, vs_elem.usage_index); if (attr != -1) { void const * addr = &buffer[instance * instance_size + elem_offset]; GLfloat const * float_addr = static_cast<GLfloat const *>(addr); GLint const num_components = static_cast<GLint>(NumComponents(vs_elem.format)); GLenum type; GLboolean normalized; OGLESMapping::MappingVertexFormat(type, normalized, vs_elem.format); normalized = (((VEU_Diffuse == vs_elem.usage) || (VEU_Specular == vs_elem.usage)) && !IsFloatFormat(vs_elem.format)) ? GL_TRUE : normalized; switch (num_components) { case 1: BOOST_ASSERT(IsFloatFormat(vs_elem.format)); glVertexAttrib1fv(attr, float_addr); break; case 2: BOOST_ASSERT(IsFloatFormat(vs_elem.format)); glVertexAttrib2fv(attr, float_addr); break; case 3: BOOST_ASSERT(IsFloatFormat(vs_elem.format)); glVertexAttrib3fv(attr, float_addr); break; case 4: if (IsFloatFormat(vs_elem.format)) { glVertexAttrib4fv(attr, float_addr); } else { GLubyte const * byte_addr = static_cast<GLubyte const *>(addr); if (normalized) { glVertexAttrib4f(attr, byte_addr[0] / 255.0f, byte_addr[1] / 255.0f, byte_addr[2] / 255.0f, byte_addr[3] / 255.0f); } else { glVertexAttrib4f(attr, byte_addr[0], byte_addr[1], byte_addr[2], byte_addr[3]); } } break; default: BOOST_ASSERT(false); break; } } elem_offset += vs_elem.element_size(); } } if (so_rl_) { glBeginTransformFeedback(so_primitive_mode_); } if (rl.UseIndices()) { for (uint32_t i = 0; i < num_passes; ++ i) { RenderPassPtr const & pass = tech.Pass(i); pass->Bind(); if (so_rl_) { OGLESShaderObjectPtr shader = checked_pointer_cast<OGLESShaderObject>(pass->GetShaderObject()); glTransformFeedbackVaryings(shader->GLSLProgram(), static_cast<GLsizei>(so_vars_ptrs_.size()), &so_vars_ptrs_[0], GL_SEPARATE_ATTRIBS); for (uint32_t j = 0; j < so_buffs_.size(); ++ j) { glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, j, so_buffs_[j]); } } glDrawElements(mode, static_cast<GLsizei>(rl.NumIndices()), index_type, index_offset); pass->Unbind(); } } else { for (uint32_t i = 0; i < num_passes; ++ i) { RenderPassPtr const & pass = tech.Pass(i); pass->Bind(); if (so_rl_) { OGLESShaderObjectPtr shader = checked_pointer_cast<OGLESShaderObject>(pass->GetShaderObject()); glTransformFeedbackVaryings(shader->GLSLProgram(), static_cast<GLsizei>(so_vars_ptrs_.size()), &so_vars_ptrs_[0], GL_SEPARATE_ATTRIBS); for (uint32_t j = 0; j < so_buffs_.size(); ++ j) { glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, j, so_buffs_[j]); } } glDrawArrays(mode, rl.StartVertexLocation(), static_cast<GLsizei>(rl.NumVertices())); pass->Unbind(); } } if (so_rl_) { glEndTransformFeedback(); } } } checked_cast<OGLESRenderLayout const *>(&rl)->Deactive(cur_shader); }
void GraphicsContext3D::vertexAttrib3fv(GC3Duint index, GC3Dfloat* array) { makeContextCurrent(); glVertexAttrib3fv(index, array); }
void render(void) { static GLint iFrames = 0; static GLfloat fps = 0.0f, DeltaT; static char cBuffer[64]; struct timeval tv; GLuint model_id; // Update timer gettimeofday(&tv, NULL); etime = (double)tv.tv_sec + tv.tv_usec / 1000000.0f; dt = etime - t0; t0 = etime; /* * Make the shadow pass * */ glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, FBO ); glPushMatrix(); //Compute light position sinE = sinf(eLit); cosE = cosf(eLit); sinA = sinf(aLit); cosA = cosf(aLit); lightPos[0] = lightRadius * cosE * sinA; lightPos[1] = lightRadius * sinE; lightPos[2] = lightRadius * cosE * cosA; lightPos[3] = 1.0f; //Set light position glLightfv(GL_LIGHT0, GL_POSITION, lightPos); //Set up camera to light location glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective( 70.0f, 1.0f, 75.0f, 350.0f ); glGetDoublev(GL_PROJECTION_MATRIX, lightProjection ); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt( lightPos[0], lightPos[1], lightPos[2], 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f ); glGetDoublev(GL_MODELVIEW_MATRIX, lightModelview ); glViewport( 0, 0, shadow_sz, shadow_sz ); glClear(GL_DEPTH_BUFFER_BIT); glEnable(GL_POLYGON_OFFSET_FILL); glShadeModel(GL_FLAT); //Rotate scene, if required glRotatef(xRot, 1.0f, 0.0f, 0.0f); glRotatef(yRot, 0.0f, 1.0f, 0.0f); //Disable shaders glUseProgramObjectARB(0); glDisable(GL_VERTEX_PROGRAM_ARB); glDisable(GL_FRAGMENT_PROGRAM_ARB); // Draw dynamic objects for (model_id = 0; model_id < NUM_MODELS; model_id++ ) { //Update the kinematic's state UpdateMD2(md2_model[model_id], dt); //Animate the MD2 models AnimateMD2(md2_model[model_id], dt); //Draw the geometry glPushMatrix(); glTranslatef( md2_model[model_id]->position.x, md2_model[model_id]->position.y, md2_model[model_id]->position.z ); glRotatef( md2_model[model_id]->rotation, 0.0f, 1.0f, 0.0f ); DrawMD2(md2_model[model_id]); glPopMatrix(); } glPopMatrix(); glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 ); /* * And now the normal pass * */ //Back to normal settings glDisable(GL_POLYGON_OFFSET_FILL); glShadeModel(GL_SMOOTH); change_size( width, height ); // Clear the window with current clearing color glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPushMatrix(); //Set up camera location and parameters setup_camera((float)dt); //Retrieve modelview matrix and invert it glGetDoublev(GL_MODELVIEW_MATRIX, cameraModelview ); FastInvert4( cameraModelview, cameraModelviewInverse ); //Set up depth texture glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, shadow_tx); //Set up texture matrix for shadow map projection glMatrixMode(GL_TEXTURE); glLoadIdentity(); glTranslatef(0.5f, 0.5f, 0.5f); glScalef(0.5f, 0.5f, 0.5f); glMultMatrixd(lightProjection); glMultMatrixd(lightModelview); glMultMatrixd(cameraModelviewInverse); glMatrixMode(GL_MODELVIEW); //Rotate scene glRotatef(xRot, 1.0f, 0.0f, 0.0f); glRotatef(yRot, 0.0f, 1.0f, 0.0f); //Re-enable shaders glEnable(GL_VERTEX_PROGRAM_ARB); glEnable(GL_FRAGMENT_PROGRAM_ARB); if (GLSLshader) glUseProgramObjectARB(progObj); else glUseProgramObjectARB(0); //Floor //Color glColor3f(0.64f, 0.63f, 0.65f); //Set textures glActiveTexture(GL_TEXTURE0); //Diffuse map glBindTexture(GL_TEXTURE_2D, texture_id[NUM_TEXTURES-2]); glActiveTexture(GL_TEXTURE1); //Normal map glBindTexture(GL_TEXTURE_2D, texture_id[NUM_TEXTURES-1]); //Set Tangent vector glVertexAttrib3fv( tangent, floorT ); //Set Binormal vector glVertexAttrib3fv( binormal, floorB ); //Set Normal vector glNormal3fv( floorN ); //Call Display List to draw glCallList(FList); // Draw dynamic objects for (model_id = 0; model_id < NUM_MODELS; model_id++ ) { //Set color glColor3f( md2_model[model_id]->color.x, md2_model[model_id]->color.y, md2_model[model_id]->color.z ); //Set texture glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, texture_id[2*model_id]); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, texture_id[2*model_id+1]); //Draw the geometry glPushMatrix(); glTranslatef( md2_model[model_id]->position.x, md2_model[model_id]->position.y, md2_model[model_id]->position.z ); glRotatef( md2_model[model_id]->rotation, 0.0f, 1.0f, 0.0f ); DrawMD2(md2_model[model_id]); glPopMatrix(); } glPopMatrix(); iFrames++; DeltaT = (GLfloat)(etime-t1); if( DeltaT >= Timed ) { fps = (GLfloat)(iFrames)/DeltaT; fps_count++; fps_mean = ((fps_count - 1.0f) * fps_mean + fps ) / fps_count; iFrames = 0; t1 = etime; sprintf(cBuffer,"FPS: %.1f Mean FPS: %.1f Poly Scale: %.1f Bias: %.1f", fps, fps_mean, scalePoly, biasPoly); } if (print_fps) { if (windowpos) { glColor3f(1.0f, 1.0f, 1.0f); glPushAttrib(GL_LIST_BIT); glListBase(fps_font - ' '); glWindowPos2i(0,2); glCallLists(strlen(cBuffer), GL_UNSIGNED_BYTE, cBuffer); glPopAttrib(); } if( iFrames == 0 ) printf("FPS: %.1f Mean FPS: %.1f\n", fps, fps_mean); } lCam = 0.0f; vCam = 0.0f; dCam = 0.0f; }
bool ShaderManager :: SetAttributeVector ( int location, const Vector3D& value ) { glVertexAttrib3fv ( location, value ); return true; }
void GLGSRender::EnableVertexData(bool indexed_draw) { static u32 offset_list[m_vertex_count]; u32 cur_offset = 0; const u32 data_offset = indexed_draw ? 0 : m_draw_array_first; for(u32 i=0; i<m_vertex_count; ++i) { offset_list[i] = cur_offset; if(!m_vertex_data[i].IsEnabled() || !m_vertex_data[i].addr) continue; const size_t item_size = m_vertex_data[i].GetTypeSize() * m_vertex_data[i].size; const size_t data_size = m_vertex_data[i].data.size() - data_offset * item_size; const u32 pos = m_vdata.size(); cur_offset += data_size; m_vdata.resize(m_vdata.size() + data_size); memcpy(&m_vdata[pos], &m_vertex_data[i].data[data_offset * item_size], data_size); } m_vao.Create(); m_vao.Bind(); checkForGlError("initializing vao"); m_vbo.Create(indexed_draw ? 2 : 1); m_vbo.Bind(0); m_vbo.SetData(&m_vdata[0], m_vdata.size()); if(indexed_draw) { m_vbo.Bind(GL_ELEMENT_ARRAY_BUFFER, 1); m_vbo.SetData(GL_ELEMENT_ARRAY_BUFFER, &m_indexed_array.m_data[0], m_indexed_array.m_data.size()); } checkForGlError("initializing vbo"); #if DUMP_VERTEX_DATA rFile dump("VertexDataArray.dump", rFile::write); #endif for(u32 i=0; i<m_vertex_count; ++i) { if(!m_vertex_data[i].IsEnabled()) continue; #if DUMP_VERTEX_DATA dump.Write(wxString::Format("VertexData[%d]:\n", i)); switch(m_vertex_data[i].type) { case CELL_GCM_VERTEX_S1: for(u32 j = 0; j<m_vertex_data[i].data.size(); j+=2) { dump.Write(wxString::Format("%d\n", *(u16*)&m_vertex_data[i].data[j])); if(!(((j+2) / 2) % m_vertex_data[i].size)) dump.Write("\n"); } break; case CELL_GCM_VERTEX_F: for(u32 j = 0; j<m_vertex_data[i].data.size(); j+=4) { dump.Write(wxString::Format("%.01f\n", *(float*)&m_vertex_data[i].data[j])); if(!(((j+4) / 4) % m_vertex_data[i].size)) dump.Write("\n"); } break; case CELL_GCM_VERTEX_SF: for(u32 j = 0; j<m_vertex_data[i].data.size(); j+=2) { dump.Write(wxString::Format("%.01f\n", *(float*)&m_vertex_data[i].data[j])); if(!(((j+2) / 2) % m_vertex_data[i].size)) dump.Write("\n"); } break; case CELL_GCM_VERTEX_UB: for(u32 j = 0; j<m_vertex_data[i].data.size(); ++j) { dump.Write(wxString::Format("%d\n", m_vertex_data[i].data[j])); if(!((j+1) % m_vertex_data[i].size)) dump.Write("\n"); } break; case CELL_GCM_VERTEX_S32K: for(u32 j = 0; j<m_vertex_data[i].data.size(); j+=2) { dump.Write(wxString::Format("%d\n", *(u16*)&m_vertex_data[i].data[j])); if(!(((j+2) / 2) % m_vertex_data[i].size)) dump.Write("\n"); } break; // case CELL_GCM_VERTEX_CMP: case CELL_GCM_VERTEX_UB256: for(u32 j = 0; j<m_vertex_data[i].data.size(); ++j) { dump.Write(wxString::Format("%d\n", m_vertex_data[i].data[j])); if(!((j+1) % m_vertex_data[i].size)) dump.Write("\n"); } break; default: ConLog.Error("Bad cv type! %d", m_vertex_data[i].type); return; } dump.Write("\n"); #endif static const u32 gl_types[] = { GL_SHORT, GL_FLOAT, GL_HALF_FLOAT, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_BYTE, }; static const bool gl_normalized[] = { true, false, false, true, false, false, }; if(m_vertex_data[i].type >= 1 && m_vertex_data[i].type <= 7) { if(!m_vertex_data[i].addr) { switch(m_vertex_data[i].type) { case CELL_GCM_VERTEX_S32K: case CELL_GCM_VERTEX_S1: switch(m_vertex_data[i].size) { case 1: glVertexAttrib1s(i, (GLshort&)m_vertex_data[i].data[0]); break; case 2: glVertexAttrib2sv(i, (GLshort*)&m_vertex_data[i].data[0]); break; case 3: glVertexAttrib3sv(i, (GLshort*)&m_vertex_data[i].data[0]); break; case 4: glVertexAttrib4sv(i, (GLshort*)&m_vertex_data[i].data[0]); break; } break; case CELL_GCM_VERTEX_F: switch(m_vertex_data[i].size) { case 1: glVertexAttrib1f(i, (GLfloat&)m_vertex_data[i].data[0]); break; case 2: glVertexAttrib2fv(i, (GLfloat*)&m_vertex_data[i].data[0]); break; case 3: glVertexAttrib3fv(i, (GLfloat*)&m_vertex_data[i].data[0]); break; case 4: glVertexAttrib4fv(i, (GLfloat*)&m_vertex_data[i].data[0]); break; } break; case CELL_GCM_VERTEX_CMP: case CELL_GCM_VERTEX_UB: glVertexAttrib4ubv(i, (GLubyte*)&m_vertex_data[i].data[0]); break; } checkForGlError("glVertexAttrib"); } else { u32 gltype = gl_types[m_vertex_data[i].type - 1]; bool normalized = gl_normalized[m_vertex_data[i].type - 1]; glEnableVertexAttribArray(i); checkForGlError("glEnableVertexAttribArray"); glVertexAttribPointer(i, m_vertex_data[i].size, gltype, normalized, 0, (void*)offset_list[i]); checkForGlError("glVertexAttribPointer"); } } } }
// shade a mesh void shade_mesh(Mesh* mesh, int time, bool wireframe, bool skinning_gpu, bool draw_normals, ShadeState* state) { // bind material kd, ks, n glUniform3fv(glGetUniformLocation(state->gl_program_id,"material_kd"), 1,&mesh->mat->kd.x); glUniform3fv(glGetUniformLocation(state->gl_program_id,"material_ks"), 1,&mesh->mat->ks.x); glUniform1f(glGetUniformLocation(state->gl_program_id,"material_n"), mesh->mat->n); glUniform1i(glGetUniformLocation(state->gl_program_id,"material_is_lines"), GL_FALSE); glUniform1i(glGetUniformLocation(state->gl_program_id,"material_double_sided"), (mesh->mat->double_sided)?GL_TRUE:GL_FALSE); // bind texture params (txt_on, sampler) _bind_texture("material_kd_txt", "material_kd_txt_on", mesh->mat->kd_txt, 0, state); _bind_texture("material_ks_txt", "material_ks_txt_on", mesh->mat->ks_txt, 1, state); _bind_texture("material_norm_txt", "material_norm_txt_on", mesh->mat->norm_txt, 2, state); // bind mesh frame - use frame_to_matrix glUniformMatrix4fv(glGetUniformLocation(state->gl_program_id,"mesh_frame"), 1,true,&frame_to_matrix(mesh->frame)[0][0]); // enable vertex attributes arrays and set up pointers to the mesh data auto vertex_pos_location = glGetAttribLocation(state->gl_program_id, "vertex_pos"); auto vertex_norm_location = glGetAttribLocation(state->gl_program_id, "vertex_norm"); auto vertex_texcoord_location = glGetAttribLocation(state->gl_program_id, "vertex_texcoord"); // YOUR CODE GOES HERE --------------------- // (only for extra credit) auto vertex_skin_bone_ids_location = glGetAttribLocation(state->gl_program_id, "vertex_skin_bone_ids"); auto vertex_skin_bone_weights_location = glGetAttribLocation(state->gl_program_id, "vertex_skin_bone_weights"); glEnableVertexAttribArray(vertex_pos_location); glVertexAttribPointer(vertex_pos_location, 3, GL_FLOAT, GL_FALSE, 0, &mesh->pos[0].x); glEnableVertexAttribArray(vertex_norm_location); glVertexAttribPointer(vertex_norm_location, 3, GL_FLOAT, GL_FALSE, 0, &mesh->norm[0].x); if(not mesh->texcoord.empty()) { glEnableVertexAttribArray(vertex_texcoord_location); glVertexAttribPointer(vertex_texcoord_location, 2, GL_FLOAT, GL_FALSE, 0, &mesh->texcoord[0].x); } else glVertexAttrib2f(vertex_texcoord_location, 0, 0); if (mesh->skinning and skinning_gpu) { // YOUR CODE GOES HERE --------------------- // (only for extra credit) glUniform1i(glGetUniformLocation(state->gl_program_id, "skin_enabled"), true); glEnableVertexAttribArray(vertex_skin_bone_ids_location); glVertexAttribPointer(vertex_skin_bone_ids_location, 4, GL_INT, GL_FALSE, 0, &mesh->skinning->bone_ids[0].x); glEnableVertexAttribArray(vertex_skin_bone_weights_location); glVertexAttribPointer(vertex_skin_bone_weights_location, 4, GL_FLOAT, GL_FALSE, 0, &mesh->skinning->bone_weights[0].x); for (int i = 0; i < 48; i++) { string name = "skin_bone_xforms["+std::to_string(i)+"]"; glUniformMatrix4fv(glGetUniformLocation(state->gl_program_id, name.c_str()), 1, GL_TRUE, &mesh->skinning->bone_xforms[time][i][0].x); } } else { glUniform1i(glGetUniformLocation(state->gl_program_id,"skin_enabled"),GL_FALSE); } // draw triangles and quads if(not wireframe) { if(mesh->triangle.size()) glDrawElements(GL_TRIANGLES, mesh->triangle.size()*3, GL_UNSIGNED_INT, &mesh->triangle[0].x); if(mesh->quad.size()) glDrawElements(GL_QUADS, mesh->quad.size()*4, GL_UNSIGNED_INT, &mesh->quad[0].x); if(mesh->point.size()) glDrawElements(GL_POINTS, mesh->point.size(), GL_UNSIGNED_INT, &mesh->point[0]); if(mesh->line.size()) glDrawElements(GL_LINES, mesh->line.size(), GL_UNSIGNED_INT, &mesh->line[0].x); for(auto segment : mesh->spline) glDrawElements(GL_LINE_STRIP, 4, GL_UNSIGNED_INT, &segment); } else { auto edges = EdgeMap(mesh->triangle, mesh->quad).edges(); glDrawElements(GL_LINES, edges.size()*2, GL_UNSIGNED_INT, &edges[0].x); } // disable vertex attribute arrays glDisableVertexAttribArray(vertex_pos_location); glDisableVertexAttribArray(vertex_norm_location); if(not mesh->texcoord.empty()) glDisableVertexAttribArray(vertex_texcoord_location); if(mesh->skinning) { // YOUR CODE GOES HERE --------------------- // (only for extra credit) glDisableVertexAttribArray(vertex_skin_bone_ids_location); glDisableVertexAttribArray(vertex_skin_bone_weights_location); } // draw normals if needed if(draw_normals) { glUniform3fv(glGetUniformLocation(state->gl_program_id,"material_kd"), 1,&zero3f.x); glUniform3fv(glGetUniformLocation(state->gl_program_id,"material_ks"), 1,&zero3f.x); glBegin(GL_LINES); for(auto i : range(mesh->pos.size())) { auto p0 = mesh->pos[i]; auto p1 = mesh->pos[i] + mesh->norm[i]*0.1; glVertexAttrib3fv(0,&p0.x); glVertexAttrib3fv(0,&p1.x); if(mesh->mat->double_sided) { auto p2 = mesh->pos[i] - mesh->norm[i]*0.1; glVertexAttrib3fv(0,&p0.x); glVertexAttrib3fv(0,&p2.x); } } glEnd(); } }
void LightShader::setNormal(const vector3f &normal) { glVertexAttrib3fv(normalLocation, (float *)&normal); }
enum piglit_result piglit_display(void) { GLvoid *datap; GLint intv[] = { 1, 1, 1, 1 }; GLfloat floatv[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat quad[] = { -1.0, 1.0, 1.0, 1.0, -1.0, -1.0, 1.0, -1.0 }; GLsizei length; GLint size; GLenum type; GLchar buffer[64]; GLuint program, vShader, fShader; int maxAttribCount; /* --- valid program needed for some of the functions --- */ fShader = glCreateShader(GL_FRAGMENT_SHADER); vShader = glCreateShader(GL_VERTEX_SHADER); glShaderSource(fShader, 1, &fShaderString, NULL); glShaderSource(vShader, 1, &vShaderString, NULL); glCompileShader(vShader); glCompileShader(fShader); program = glCreateProgram(); glAttachShader(program, vShader); glAttachShader(program, fShader); glLinkProgram(program); glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxAttribCount); /* --- tests begin here --- */ glVertexAttrib1f(maxAttribCount, floatv[0]); CHECK_GL_INVALID_VALUE; glVertexAttrib2f(maxAttribCount, floatv[0], floatv[1]); CHECK_GL_INVALID_VALUE; glVertexAttrib3f(maxAttribCount, floatv[0], floatv[1], floatv[2]); CHECK_GL_INVALID_VALUE; glVertexAttrib4f(maxAttribCount, floatv[0], floatv[1], floatv[2], floatv[3]); CHECK_GL_INVALID_VALUE; glVertexAttrib1fv(maxAttribCount, floatv); CHECK_GL_INVALID_VALUE; glVertexAttrib2fv(maxAttribCount, floatv); CHECK_GL_INVALID_VALUE; glVertexAttrib3fv(maxAttribCount, floatv); CHECK_GL_INVALID_VALUE; glVertexAttrib4fv(maxAttribCount, floatv); CHECK_GL_INVALID_VALUE; glVertexAttribPointer(maxAttribCount, 2, GL_FLOAT, GL_FALSE, 0, quad); CHECK_GL_INVALID_VALUE; glBindAttribLocation(program, maxAttribCount, "pos"); CHECK_GL_INVALID_VALUE; glEnableVertexAttribArray(maxAttribCount); CHECK_GL_INVALID_VALUE; glDisableVertexAttribArray(maxAttribCount); CHECK_GL_INVALID_VALUE; glGetVertexAttribfv(maxAttribCount, GL_CURRENT_VERTEX_ATTRIB, floatv); CHECK_GL_INVALID_VALUE; glGetVertexAttribiv(maxAttribCount, GL_CURRENT_VERTEX_ATTRIB, intv); CHECK_GL_INVALID_VALUE; glGetVertexAttribPointerv(maxAttribCount, GL_VERTEX_ATTRIB_ARRAY_POINTER, &datap); CHECK_GL_INVALID_VALUE; glGetActiveAttrib(program, maxAttribCount, 64, &length, &size, &type, buffer); CHECK_GL_INVALID_VALUE; return PIGLIT_PASS; }
void Ground::bindTangentObject(int _loc) { glDisableVertexAttribArray(_loc); glVertexAttrib3fv(_loc,(float *)&GLVector3(1.0f,0.0f,0.0f)); }
void vertex_attrib_3fv(gl::uint_t index, const gl::float_t * v) { glVertexAttrib3fv(index, v); }
void Mesh::bindTangentObject(int _loc) { glDisableVertexAttribArray(_loc); glVertexAttrib3fv(_loc,&_tangent.x); }