void Mesh::renderTriangles() { glVertexPointer(3, GL_FLOAT, 0, this->m_pVerts); glEnableClientState(GL_VERTEX_ARRAY); glNormalPointer(GL_FLOAT, sizeof(t_TangentSpace), this->m_pTangentSpace->normal); glEnableClientState(GL_NORMAL_ARRAY); glTexCoordPointer(2, GL_FLOAT, 0, this->m_pTexVerts); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glVertexAttribPointerARB(BINORMAL_ARRAY, 3, GL_FLOAT, GL_FALSE, sizeof(t_TangentSpace), this->m_pTangentSpace->binormal); glEnableVertexAttribArrayARB(BINORMAL_ARRAY); glVertexAttribPointerARB(TANGENT_ARRAY, 3, GL_FLOAT, GL_FALSE, sizeof(t_TangentSpace), this->m_pTangentSpace->tangent); glEnableVertexAttribArrayARB(TANGENT_ARRAY); glDrawElements(GL_TRIANGLES, this->m_NumFaces * 3, GL_UNSIGNED_INT, this->m_pVertIndex); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableVertexAttribArrayARB(BINORMAL_ARRAY); glDisableVertexAttribArrayARB(TANGENT_ARRAY); }
void GPU_buffer_unbind(void) { int i; if(GLStates & GPU_BUFFER_VERTEX_STATE) glDisableClientState(GL_VERTEX_ARRAY); if(GLStates & GPU_BUFFER_NORMAL_STATE) glDisableClientState(GL_NORMAL_ARRAY); if(GLStates & GPU_BUFFER_TEXCOORD_STATE) glDisableClientState(GL_TEXTURE_COORD_ARRAY); if(GLStates & GPU_BUFFER_COLOR_STATE) glDisableClientState(GL_COLOR_ARRAY); if(GLStates & GPU_BUFFER_ELEMENT_STATE) { if(useVBOs) { glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0); } } GLStates &= !(GPU_BUFFER_VERTEX_STATE | GPU_BUFFER_NORMAL_STATE | GPU_BUFFER_TEXCOORD_STATE | GPU_BUFFER_COLOR_STATE | GPU_BUFFER_ELEMENT_STATE); for(i = 0; i < MAX_GPU_ATTRIB_DATA; i++) { if(attribData[i].index != -1) { glDisableVertexAttribArrayARB(attribData[i].index); } else break; } if(useVBOs) glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); }
void CShadersManager::DisableTangents (void) { if((this->Program == ParallaxMappingSPT) || (this->Program == NormalMappingSPT)) { int tanloc = glGetAttribLocationARB(this->Programs[this->Program].GetHandle(), "Tangent"); glDisableVertexAttribArrayARB(tanloc); } }
inline void VL_glDisableVertexAttribArray( GLuint index ) { if (glDisableVertexAttribArray) glDisableVertexAttribArray(index); else if (glDisableVertexAttribArrayARB) glDisableVertexAttribArrayARB(index); else VL_UNSUPPORTED_FUNC(); }
void GPU_shader_unbind_instancing_attrib(GPUShader *shader) { int posloc = GPU_shader_get_attribute(shader, GPU_builtin_name(GPU_INSTANCING_POSITION_ATTRIB)); int matloc = GPU_shader_get_attribute(shader, GPU_builtin_name(GPU_INSTANCING_MATRIX_ATTRIB)); // Matrix if (matloc != -1) { glDisableVertexAttribArrayARB(matloc); glDisableVertexAttribArrayARB(matloc + 1); glDisableVertexAttribArrayARB(matloc + 2); glVertexAttribDivisorARB(matloc, 0); glVertexAttribDivisorARB(matloc + 1, 0); glVertexAttribDivisorARB(matloc + 2, 0); } // Position if (posloc != -1) { glDisableVertexAttribArrayARB(posloc); glVertexAttribDivisorARB(posloc, 0); } }
void VertexBuffer::Unbind() { this->_renderer.bindedVertexBuffer = nullptr; GLCHECK(glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0)); auto program = dynamic_cast<Program*>(&this->_renderer.GetCurrentProgram()); if (program == nullptr) { for (auto it = this->_attributes, itEnd = this->_attributes + this->_nbAttrib; it != itEnd; ++it) GLCHECK(glDisableVertexAttribArrayARB(GetVertexAttributeIndex(it->location))); } else { for (auto it = this->_attributes, itEnd = this->_attributes + this->_nbAttrib; it != itEnd; ++it) GLCHECK(glDisableVertexAttribArray(program->GetAttributeIndex(it->location))); } }
void VertexArrayNoVao::disableOpenGLVertexAttribArrays() { // No previous bound OpenGL element array buffer restore, there's not really a point in it // Loop through all attributes // -> We're using "glBindAttribLocationARB()" when linking the program so we have known attribute locations (the vertex array can't know about the program) GLuint attributeLocation = 0; const Renderer::VertexAttribute *attributeEnd = mAttributes + mNumberOfAttributes; for (const Renderer::VertexAttribute *attribute = mAttributes; attribute < attributeEnd; ++attribute, ++attributeLocation) { // Disable OpenGL vertex attribute array glDisableVertexAttribArrayARB(attributeLocation); // Per-instance instead of per-vertex requires "GL_ARB_instanced_arrays" if (attribute->instancesPerElement > 0 && mIsGL_ARB_instanced_arrays) { glVertexAttribDivisorARB(attributeLocation, 0); } } }
static void render(struct glpal_ctx *ctx, GLuint draw_tex) {DEBUG_CHECK_GL_ERR; static const float verts[] = { 0, 0 , -1, -1, 1, 0 , 1, -1, 0, 1 , -1, 1, 1, 1 , 1, 1 }; struct priv_ctx *priv = (struct priv_ctx *)ctx; glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS); glUseProgramObjectARB(priv->prog); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, draw_tex); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_1D, priv->tex[priv->cnt]); glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, 256, 0, GL_BGRA, GL_UNSIGNED_BYTE, pal_ctx_get_active(priv->pal)); priv->cnt = (priv->cnt+1)%2; glBindTexture(GL_TEXTURE_1D, priv->tex[priv->cnt]); glEnableVertexAttribArrayARB(0); glVertexAttribPointerARB(0, 4, GL_FLOAT, GL_FALSE, sizeof(float)*4, verts); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glUseProgramObjectARB(0); glDisableVertexAttribArrayARB(0); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_1D, 0); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, 0); glPopClientAttrib(); DEBUG_CHECK_GL_ERR; }
void GPU_interleaved_attrib_setup(GPUBuffer *buffer, GPUAttrib data[], int numdata) { int i; int elementsize; intptr_t offset = 0; for(i = 0; i < MAX_GPU_ATTRIB_DATA; i++) { if(attribData[i].index != -1) { glDisableVertexAttribArrayARB(attribData[i].index); } else break; } elementsize = GPU_attrib_element_size(data, numdata); if(useVBOs) { glBindBufferARB(GL_ARRAY_BUFFER_ARB, buffer->id); for(i = 0; i < numdata; i++) { glEnableVertexAttribArrayARB(data[i].index); glVertexAttribPointerARB(data[i].index, data[i].size, data[i].type, GL_FALSE, elementsize, (void *)offset); offset += data[i].size*GPU_typesize(data[i].type); attribData[i].index = data[i].index; attribData[i].size = data[i].size; attribData[i].type = data[i].type; } attribData[numdata].index = -1; } else { for(i = 0; i < numdata; i++) { glEnableVertexAttribArrayARB(data[i].index); glVertexAttribPointerARB(data[i].index, data[i].size, data[i].type, GL_FALSE, elementsize, (char *)buffer->pointer + offset); offset += data[i].size*GPU_typesize(data[i].type); } } }
static void render(struct glpal_ctx *ctx, GLuint draw_tex) {DEBUG_CHECK_GL_ERR; static const float verts[] = { 0, 0 , -1, -1, 1, 0 , 1, -1, 0, 1 , -1, 1, 1, 1 , 1, 1 }; struct priv_ctx *priv = (struct priv_ctx *)ctx; glPushAttrib(GL_TEXTURE_BIT); glUseProgramObjectARB(priv->prog); glUniform1fARB(priv->palpos_loc, priv->palpos/255.0f); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, draw_tex); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_1D, priv->pal_tex[priv->curpal]); glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_1D, priv->pal_tex[priv->nextpal]); glEnableVertexAttribArrayARB(0); glVertexAttribPointerARB(0, 4, GL_FLOAT, GL_FALSE, sizeof(float)*4, verts); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glUseProgramObjectARB(0); glDisableVertexAttribArrayARB(0); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_1D, 0); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, 0); glPopAttrib(); DEBUG_CHECK_GL_ERR; }
/** Test drawing with GL_ARB_vertex_program */ static GLboolean test_arbvp_arrays(void) { /* Use legacy vertex array/attribute */ static const char *legacyVertProgramText = "!!ARBvp1.0 \n" "ATTRIB iPos = vertex.position;\n" "OUTPUT oPos = result.position;\n" "PARAM mvp[4] = { state.matrix.mvp };\n" "DP4 oPos.x, mvp[0], iPos;\n" "DP4 oPos.y, mvp[1], iPos;\n" "DP4 oPos.z, mvp[2], iPos;\n" "DP4 oPos.w, mvp[3], iPos;\n" "MOV result.color, vertex.color;\n" "END"; /* Use generic vertex array/attribute[0] */ static const char *generic0VertProgramText = "!!ARBvp1.0 \n" "ATTRIB iPos = vertex.attrib[0];\n" "OUTPUT oPos = result.position;\n" "PARAM mvp[4] = { state.matrix.mvp };\n" "DP4 oPos.x, mvp[0], iPos;\n" "DP4 oPos.y, mvp[1], iPos;\n" "DP4 oPos.z, mvp[2], iPos;\n" "DP4 oPos.w, mvp[3], iPos;\n" "MOV result.color, vertex.color;\n" "END"; /* Use generic vertex array/attribute[6] */ static const char *generic6VertProgramText = "!!ARBvp1.0 \n" "ATTRIB iPos = vertex.attrib[6];\n" "OUTPUT oPos = result.position;\n" "PARAM mvp[4] = { state.matrix.mvp };\n" "DP4 oPos.x, mvp[0], iPos;\n" "DP4 oPos.y, mvp[1], iPos;\n" "DP4 oPos.z, mvp[2], iPos;\n" "DP4 oPos.w, mvp[3], iPos;\n" "MOV result.color, vertex.color;\n" "END"; static const char *fragProgramText = "!!ARBfp1.0 \n" "MOV result.color, fragment.color;\n" "END"; static const GLfloat expected[4] = {0.5, 0.0, 0.5, 1.0}; GLuint buf; GLboolean p, pass = GL_TRUE; GLuint vertProg, fragProg; buf = setup_vbo(); glBindBufferARB(GL_ARRAY_BUFFER_ARB, buf); fragProg = piglit_compile_program(GL_FRAGMENT_PROGRAM_ARB, fragProgramText); glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, fragProg); glEnable(GL_FRAGMENT_PROGRAM_ARB); glEnable(GL_VERTEX_PROGRAM_ARB); /* * Draw with pos in conventional arrays. */ { vertProg = piglit_compile_program(GL_VERTEX_PROGRAM_ARB, legacyVertProgramText); glBindProgramARB(GL_VERTEX_PROGRAM_ARB, vertProg); glVertexPointer(2, GL_FLOAT, 2 * sizeof(GLfloat), (void *) 0); glColorPointer(3, GL_FLOAT, 3 * sizeof(GLfloat), (void *) (8 * sizeof(GLfloat))); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_COLOR_ARRAY); glClear(GL_COLOR_BUFFER_BIT); glDrawArrays(GL_QUADS, 0, 4); p = piglit_probe_pixel_rgba(piglit_width/2, piglit_height/2, expected); piglit_present_results(); if (!p) { printf("%s: failed when drawing with ", TestName); printf("ARB VP and conventional vertex arrays\n"); pass = GL_FALSE; } glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_COLOR_ARRAY); glDeleteProgramsARB(1, &vertProg); } /* * Draw with pos in generic array[0]. */ { GLuint attrib = 0; vertProg = piglit_compile_program(GL_VERTEX_PROGRAM_ARB, generic0VertProgramText); glBindProgramARB(GL_VERTEX_PROGRAM_ARB, vertProg); glVertexAttribPointerARB(attrib, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), (void *) 0); glColorPointer(3, GL_FLOAT, 3 * sizeof(GLfloat), (void *) (8 * sizeof(GLfloat))); glEnableVertexAttribArrayARB(attrib); glEnableClientState(GL_COLOR_ARRAY); glClear(GL_COLOR_BUFFER_BIT); glDrawArrays(GL_QUADS, 0, 4); p = piglit_probe_pixel_rgba(piglit_width/2, piglit_height/2, expected); piglit_present_results(); if (!p) { printf("%s: failed when drawing with ", TestName); printf("ARB VP and generic vertex array[%u]\n", attrib); pass = GL_FALSE; } glDisableVertexAttribArrayARB(attrib); glDisableClientState(GL_COLOR_ARRAY); glDeleteProgramsARB(1, &vertProg); } /* * Draw with pos in generic array[6]. */ { GLuint attrib = 6; vertProg = piglit_compile_program(GL_VERTEX_PROGRAM_ARB, generic6VertProgramText); glBindProgramARB(GL_VERTEX_PROGRAM_ARB, vertProg); glVertexAttribPointerARB(attrib, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), (void *) 0); glColorPointer(3, GL_FLOAT, 3 * sizeof(GLfloat), (void *) (8 * sizeof(GLfloat))); glEnableVertexAttribArrayARB(attrib); glEnableClientState(GL_COLOR_ARRAY); glClear(GL_COLOR_BUFFER_BIT); glDrawArrays(GL_QUADS, 0, 4); p = piglit_probe_pixel_rgba(piglit_width/2, piglit_height/2, expected); piglit_present_results(); if (!p) { printf("%s: failed when drawing with ", TestName); printf("ARB VP and generic vertex array[%u]\n", attrib); pass = GL_FALSE; } glDisableVertexAttribArrayARB(attrib); glDisableClientState(GL_COLOR_ARRAY); glDeleteProgramsARB(1, &vertProg); } glDisable(GL_FRAGMENT_PROGRAM_ARB); glDisable(GL_VERTEX_PROGRAM_ARB); glDeleteProgramsARB(1, &fragProg); glDeleteBuffersARB(1, &buf); return pass; }
/** Test drawing with GLSL shaders */ static GLboolean test_glsl_arrays(void) { static const char *vertShaderText = "attribute vec4 color, pos; \n" "varying vec4 colorVar; \n" "void main() \n" "{ \n" " colorVar = color; \n" " gl_Position = gl_ModelViewProjectionMatrix * pos; \n" "} \n"; static const char *fragShaderText = "varying vec4 colorVar; \n" "void main() \n" "{ \n" " gl_FragColor = colorVar; \n" "} \n"; static const GLfloat expected[4] = {0.5, 0.0, 0.5, 1.0}; GLuint buf; GLboolean p, pass = GL_TRUE; GLint posAttrib, colorAttrib; GLuint vertShader, fragShader, program; buf = setup_vbo(); glBindBufferARB(GL_ARRAY_BUFFER_ARB, buf); vertShader = piglit_compile_shader_text(GL_VERTEX_SHADER, vertShaderText); fragShader = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fragShaderText); program = piglit_link_simple_program(vertShader, fragShader); glUseProgram(program); /* * Draw with compiler-assigned attribute locations */ { posAttrib = glGetAttribLocation(program, "pos"); colorAttrib = glGetAttribLocation(program, "color"); if (0) printf("%s: GLSL posAttrib = %d colorAttrib = %d\n", TestName, posAttrib, colorAttrib); glVertexAttribPointerARB(posAttrib, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), (void *) 0); glVertexAttribPointerARB(colorAttrib, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (void *) (8 * sizeof(GLfloat))); glEnableVertexAttribArrayARB(posAttrib); glEnableVertexAttribArrayARB(colorAttrib); glClear(GL_COLOR_BUFFER_BIT); glDrawArrays(GL_QUADS, 0, 4); p = piglit_probe_pixel_rgba(piglit_width/2, piglit_height/2, expected); piglit_present_results(); if (!p) { printf("%s: failed when drawing with ", TestName); printf("compiler-assigned attribute locations\n"); pass = GL_FALSE; } glDisableVertexAttribArrayARB(posAttrib); glDisableVertexAttribArrayARB(colorAttrib); } /* * Draw with user-defined attribute bindings, not using 0. */ { posAttrib = 5; colorAttrib = 7; glBindAttribLocation(program, posAttrib, "pos"); glBindAttribLocation(program, colorAttrib, "color"); glLinkProgram(program); glVertexAttribPointerARB(posAttrib, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), (void *) 0); glVertexAttribPointerARB(colorAttrib, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (void *) (8 * sizeof(GLfloat))); glEnableVertexAttribArrayARB(posAttrib); glEnableVertexAttribArrayARB(colorAttrib); glClear(GL_COLOR_BUFFER_BIT); glDrawArrays(GL_QUADS, 0, 4); p = piglit_probe_pixel_rgba(piglit_width/2, piglit_height/2, expected); piglit_present_results(); if (!p) { printf("%s: failed when drawing with ", TestName); printf("user-assigned attribute locations\n"); pass = GL_FALSE; } glDisableVertexAttribArrayARB(posAttrib); glDisableVertexAttribArrayARB(colorAttrib); } glDeleteShader(vertShader); glDeleteProgram(program); glDeleteBuffersARB(1, &buf); return pass; }
/* * Render all states in the ShaderCache along with their renderables. This * is where the actual OpenGL rendering starts. */ void OpenGLRenderSystem::render(RenderStateFlags globalstate, const Matrix4& modelview, const Matrix4& projection, const Vector3& viewer) { glPushAttrib(GL_ALL_ATTRIB_BITS); // Set the projection and modelview matrices glMatrixMode(GL_PROJECTION); glLoadMatrixd(projection); glMatrixMode(GL_MODELVIEW); glLoadMatrixd(modelview); // global settings that are not set in renderstates glFrontFace(GL_CW); glCullFace(GL_BACK); glPolygonOffset(-1, 1); // Set polygon stipple pattern from constant glPolygonStipple(POLYGON_STIPPLE_PATTERN); glEnableClientState(GL_VERTEX_ARRAY); glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE); if (GLEW_VERSION_1_3) { glActiveTexture(GL_TEXTURE0); glClientActiveTexture(GL_TEXTURE0); } if (GLEW_ARB_shader_objects) { glUseProgramObjectARB(0); glDisableVertexAttribArrayARB(c_attr_TexCoord0); glDisableVertexAttribArrayARB(c_attr_Tangent); glDisableVertexAttribArrayARB(c_attr_Binormal); } if (globalstate & RENDER_TEXTURE_2D) { glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); } // Construct default OpenGL state OpenGLState current; // Set up initial GL state. This MUST MATCH the defaults in the OpenGLState // object, otherwise required state changes may not occur. glLineStipple(current.m_linestipple_factor, current.m_linestipple_pattern); glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); glDisable(GL_LIGHTING); glDisable(GL_TEXTURE_2D); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_COLOR_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); glDisable(GL_BLEND); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_CULL_FACE); glShadeModel(GL_FLAT); glDisable(GL_DEPTH_TEST); // RENDER_DEPTHWRITE defaults to 0 glDepthMask(GL_FALSE); // RENDER_MASKCOLOUR defaults to 0 glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glDisable(GL_ALPHA_TEST); glDisable(GL_LINE_STIPPLE); glDisable(GL_POLYGON_STIPPLE); glDisable(GL_POLYGON_OFFSET_LINE); glDisable(GL_POLYGON_OFFSET_FILL); // greebo: otherwise tiny gap lines between brushes are visible glBindTexture(GL_TEXTURE_2D, 0); glColor4f(1,1,1,1); glDepthFunc(current.getDepthFunc()); glAlphaFunc(GL_ALWAYS, 0); glLineWidth(1); glPointSize(1); glHint(GL_FOG_HINT, GL_NICEST); glDisable(GL_FOG); #if 0 std::size_t count = 0 ; for (OpenGLStates::iterator i = _state_sorted.begin(); i != _state_sorted.end(); ++i) { // Render the OpenGLShaderPass if (!i->second->empty()) { count++; } } rMessage() << "R1 " << count << " of " << _state_sorted.size() << "\n"; std::size_t curObject = 0; #endif // Iterate over the sorted mapping between OpenGLStates and their // OpenGLShaderPasses (containing the renderable geometry), and render the // contents of each bucket. Each pass is passed a reference to the "current" // state, which it can change. for (OpenGLStates::iterator i = _state_sorted.begin(); i != _state_sorted.end(); ++i) { // Render the OpenGLShaderPass if (!i->second->empty()) { #if 0 rMessage() << curObject << " " << (*i->second); curObject++; #endif i->second->render(current, globalstate, viewer, _time); } } glPopAttrib(); }
void Doom3Model::glRenderAction(GLContextData& contextData,Doom3MaterialManager::RenderContext& mmRc) const { /* Get the context data item: */ DataItem* dataItem=contextData.retrieveDataItem<DataItem>(this); /* Get the index of the tangent vector vertex attribute: */ GLint tangentAttributeIndexS=materialManager.getTangentAttributeIndex(mmRc,0); GLint tangentAttributeIndexT=materialManager.getTangentAttributeIndex(mmRc,1); /* Enable the appropriate vertex arrays: */ glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); if(tangentAttributeIndexS>=0) glEnableVertexAttribArrayARB(tangentAttributeIndexS); if(tangentAttributeIndexT>=0) glEnableVertexAttribArrayARB(tangentAttributeIndexT); glEnableClientState(GL_VERTEX_ARRAY); /* Install the vertex and index arrays: */ const Vertex* vertexPtr; const GLuint* indexPtr; if(dataItem->hasVertexBufferExtension) { /* Bind the model's vertex buffer: */ glBindBufferARB(GL_ARRAY_BUFFER_ARB,dataItem->vertexBufferId); vertexPtr=0; /* Bind the mesh's index buffer: */ glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB,dataItem->indexBufferId); indexPtr=0; } else { vertexPtr=&vertices[0]; indexPtr=&vertexIndices[0]; } glTexCoordPointer(2,sizeof(Vertex),vertexPtr->texCoord.getComponents()); glNormalPointer(sizeof(Vertex),vertexPtr->normal.getComponents()); if(tangentAttributeIndexS>=0) glVertexAttribPointerARB(tangentAttributeIndexS,3,GL_FALSE,sizeof(Vertex),vertexPtr->tangents[0].getComponents()); if(tangentAttributeIndexT>=0) glVertexAttribPointerARB(tangentAttributeIndexT,3,GL_FALSE,sizeof(Vertex),vertexPtr->tangents[1].getComponents()); glVertexPointer(3,sizeof(Vertex),vertexPtr->position.getComponents()); /* Render all surfaces: */ for(std::vector<Surface>::const_iterator sIt=surfaces.begin();sIt!=surfaces.end();++sIt) { /* Install the mesh's material and check whether to render this mesh: */ if(materialManager.setMaterial(mmRc,sIt->material)) { /* Render the surface: */ glDrawElements(GL_TRIANGLES,sIt->numVertexIndices,GL_UNSIGNED_INT,indexPtr); } /* Go to the next surface's vertex indices: */ indexPtr+=sIt->numVertexIndices; } if(dataItem->hasVertexBufferExtension) { /* Unbind all buffers: */ glBindBufferARB(GL_ARRAY_BUFFER_ARB,0); glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB,0); } /* Disable the appropriate vertex arrays: */ glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); if(tangentAttributeIndexS>=0) glDisableVertexAttribArrayARB(tangentAttributeIndexS); if(tangentAttributeIndexT>=0) glDisableVertexAttribArrayARB(tangentAttributeIndexT); glDisableClientState(GL_VERTEX_ARRAY); }
void Viewer::renderModel() { glBindProgramARB( GL_VERTEX_PROGRAM_ARB, m_vertexProgramId ); glEnableVertexAttribArrayARB(0); glEnableVertexAttribArrayARB(1); glEnableVertexAttribArrayARB(2); glEnableVertexAttribArrayARB(3); glEnableVertexAttribArrayARB(8); glEnable(GL_TEXTURE_2D); // set global OpenGL states glEnable(GL_DEPTH_TEST); glShadeModel(GL_SMOOTH); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_VERTEX_PROGRAM_ARB); glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_bufferObject[0]); glVertexAttribPointerARB(0, 3 , GL_FLOAT, false, 0, NULL); glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_bufferObject[1]); glVertexAttribPointerARB(1, 4 , GL_FLOAT, false, 0, NULL); glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_bufferObject[2]); glVertexAttribPointerARB(2, 3 , GL_FLOAT, false, 0, NULL); glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_bufferObject[3]); glVertexAttribPointerARB(3, 4 , GL_FLOAT, false, 0, NULL); glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_bufferObject[4]); glVertexAttribPointerARB(8, 2 , GL_FLOAT, false, 0, NULL); glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, m_bufferObject[5]); int hardwareMeshId; for(hardwareMeshId=0;hardwareMeshId<m_calHardwareModel->getHardwareMeshCount() ; hardwareMeshId++) { m_calHardwareModel->selectHardwareMesh(hardwareMeshId); unsigned char meshColor[4]; float materialColor[4]; // set the material ambient color m_calHardwareModel->getAmbientColor(&meshColor[0]); materialColor[0] = meshColor[0] / 255.0f; materialColor[1] = meshColor[1] / 255.0f; materialColor[2] = meshColor[2] / 255.0f; materialColor[3] = meshColor[3] / 255.0f; glMaterialfv(GL_FRONT, GL_AMBIENT, materialColor); // set the material diffuse color m_calHardwareModel->getDiffuseColor(&meshColor[0]); materialColor[0] = meshColor[0] / 255.0f; materialColor[1] = meshColor[1] / 255.0f; materialColor[2] = meshColor[2] / 255.0f; materialColor[3] = meshColor[3] / 255.0f; glMaterialfv(GL_FRONT, GL_DIFFUSE, materialColor); // set the material specular color m_calHardwareModel->getSpecularColor(&meshColor[0]); materialColor[0] = meshColor[0] / 255.0f; materialColor[1] = meshColor[1] / 255.0f; materialColor[2] = meshColor[2] / 255.0f; materialColor[3] = meshColor[3] / 255.0f; glMaterialfv(GL_FRONT, GL_SPECULAR, materialColor); // set the material shininess factor float shininess; shininess = 50.0f; //m_calHardwareModel->getShininess(); glMaterialfv(GL_FRONT, GL_SHININESS, &shininess); int boneId; for(boneId = 0; boneId < m_calHardwareModel->getBoneCount(); boneId++) { CalQuaternion rotationBoneSpace = m_calHardwareModel->getRotationBoneSpace(boneId, m_calModel->getSkeleton()); CalVector translationBoneSpace = m_calHardwareModel->getTranslationBoneSpace(boneId, m_calModel->getSkeleton()); CalMatrix rotationMatrix = rotationBoneSpace; float transformation[12]; transformation[0]=rotationMatrix.dxdx;transformation[1]=rotationMatrix.dxdy;transformation[2]=rotationMatrix.dxdz;transformation[3]=translationBoneSpace.x; transformation[4]=rotationMatrix.dydx;transformation[5]=rotationMatrix.dydy;transformation[6]=rotationMatrix.dydz;transformation[7]=translationBoneSpace.y; transformation[8]=rotationMatrix.dzdx;transformation[9]=rotationMatrix.dzdy;transformation[10]=rotationMatrix.dzdz;transformation[11]=translationBoneSpace.z; glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB,boneId*3,&transformation[0]); glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB,boneId*3+1,&transformation[4]); glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB,boneId*3+2,&transformation[8]); // set the texture id we stored in the map user data glBindTexture(GL_TEXTURE_2D, (GLuint)(size_t)m_calHardwareModel->getMapUserData(0)); } if(sizeof(CalIndex)==2) glDrawElements(GL_TRIANGLES, m_calHardwareModel->getFaceCount() * 3, GL_UNSIGNED_SHORT, (((CalIndex *)NULL)+ m_calHardwareModel->getStartIndex())); else glDrawElements(GL_TRIANGLES, m_calHardwareModel->getFaceCount() * 3, GL_UNSIGNED_INT, (((CalIndex *)NULL)+ m_calHardwareModel->getStartIndex())); } // clear vertex array state glDisableVertexAttribArrayARB(0); glDisableVertexAttribArrayARB(1); glDisableVertexAttribArrayARB(2); glDisableVertexAttribArrayARB(3); glDisableVertexAttribArrayARB(8); glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0); // clear light glDisable(GL_LIGHTING); glDisable(GL_LIGHT0); glDisable(GL_DEPTH_TEST); glDisable(GL_VERTEX_PROGRAM_ARB); glBindProgramARB( GL_VERTEX_PROGRAM_ARB, 0 ); }
static void va_render () { 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); glEnable (GL_COLOR_ARRAY); break; case S: glSecondaryColorPointerEXT (4, GL_FLOAT, 0, att->data); glEnable (GL_SECONDARY_COLOR_ARRAY_EXT); break; case N: glNormalPointer (GL_FLOAT, 0, att->data); glEnable (GL_NORMAL_ARRAY); break; case V: glVertexPointer (4, GL_FLOAT, 0, att->data); glEnable (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); glEnable (GL_TEXTURE_COORD_ARRAY); break; case F: glFogCoordPointerEXT (GL_FLOAT, 0, att->data); glEnable (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: glDisable (GL_COLOR_ARRAY); break; case S: glDisable (GL_SECONDARY_COLOR_ARRAY_EXT); break; case N: glDisable (GL_NORMAL_ARRAY); break; case V: glDisable (GL_VERTEX_ARRAY); break; case T: glClientActiveTextureARB (GL_TEXTURE0_ARB + att->index); glDisable (GL_TEXTURE_COORD_ARRAY); break; case F: glDisable (GL_FOG_COORDINATE_ARRAY_EXT); break; case A: glDisableVertexAttribArrayARB (att->index); break; default: assert (0); } } }
/** Test legacy/fixed-function vertex array drawing */ static GLboolean test_fixedfunc_arrays(void) { static const GLfloat expected[4] = {0.5, 0.0, 0.5, 1.0}; static const GLfloat black[4] = {0.0, 0.0, 0.0, 0.0}; GLuint buf; GLboolean p,pass = GL_TRUE; buf = setup_vbo(); glBindBufferARB(GL_ARRAY_BUFFER_ARB, buf); /* * Draw with conventional arrays. */ { glVertexPointer(2, GL_FLOAT, 2 * sizeof(GLfloat), (void *) 0); glColorPointer(3, GL_FLOAT, 3 * sizeof(GLfloat), (void *) (8 * sizeof(GLfloat))); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_COLOR_ARRAY); glClear(GL_COLOR_BUFFER_BIT); glDrawArrays(GL_QUADS, 0, 4); p = piglit_probe_pixel_rgba(piglit_width/2, piglit_height/2, expected); piglit_present_results(); if (!p) { printf("%s: failed when drawing with ", TestName); printf("conventional vertex arrays\n"); pass = GL_FALSE; } glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_COLOR_ARRAY); } /* * Draw with generic array[0]=position * XXX this should only work when the driver aliases conventional * vertex attributes with the generic attributes (as w/ NVIDIA). * XXX check for that and enable this code some day. */ if (0) { GLuint attrib = 0; glVertexAttribPointerARB(attrib, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), (void *) 0); glColorPointer(3, GL_FLOAT, 3 * sizeof(GLfloat), (void *) (8 * sizeof(GLfloat))); glEnableVertexAttribArrayARB(attrib); glEnableClientState(GL_COLOR_ARRAY); glClear(GL_COLOR_BUFFER_BIT); glDrawArrays(GL_QUADS, 0, 4); p = piglit_probe_pixel_rgba(piglit_width/2, piglit_height/2, expected); piglit_present_results(); if (!p) { printf("%s: failed when drawing with ", TestName); printf("generic array [%u]\n", attrib); pass = GL_FALSE; } glDisableVertexAttribArrayARB(attrib); glDisableClientState(GL_COLOR_ARRAY); } /* * Draw without GL_VERTEX or GENERIC[0] array set (should NOT draw) */ { GLuint attrib = 3; glVertexAttribPointerARB(attrib, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), (void *) 0); glColorPointer(3, GL_FLOAT, 3 * sizeof(GLfloat), (void *) (8 * sizeof(GLfloat))); glEnableVertexAttribArrayARB(attrib); glEnableClientState(GL_COLOR_ARRAY); glClear(GL_COLOR_BUFFER_BIT); glDrawArrays(GL_QUADS, 0, 4); p = piglit_probe_pixel_rgba(piglit_width/2, piglit_height/2, black); piglit_present_results(); if (!p) { printf("%s: failed when drawing with ", TestName); printf("generic array [%u]\n", attrib); pass = GL_FALSE; } glDisableVertexAttribArrayARB(attrib); glDisableClientState(GL_COLOR_ARRAY); } piglit_present_results(); glDeleteBuffersARB(1, &buf); return pass; }
//static void LLVertexBuffer::setupClientArrays(U32 data_mask) { /*if (LLGLImmediate::sStarted) { llerrs << "Cannot use LLGLImmediate and LLVertexBuffer simultaneously!" << llendl; }*/ if (sLastMask != data_mask) { U32 mask[] = { MAP_VERTEX, MAP_NORMAL, MAP_TEXCOORD0, MAP_COLOR, }; GLenum array[] = { GL_VERTEX_ARRAY, GL_NORMAL_ARRAY, GL_TEXTURE_COORD_ARRAY, GL_COLOR_ARRAY, }; BOOL error = FALSE; for (U32 i = 0; i < 4; ++i) { if (sLastMask & mask[i]) { //was enabled if (!(data_mask & mask[i]) && i > 0) { //needs to be disabled glDisableClientState(array[i]); } else if (gDebugGL) { //needs to be enabled, make sure it was (DEBUG TEMPORARY) if (i > 0 && !glIsEnabled(array[i])) { if (gDebugSession) { error = TRUE; gFailLog << "Bad client state! " << array[i] << " disabled." << std::endl; } else { llerrs << "Bad client state! " << array[i] << " disabled." << llendl; } } } } else { //was disabled if (data_mask & mask[i] && i > 0) { //needs to be enabled glEnableClientState(array[i]); } else if (gDebugGL && i > 0 && glIsEnabled(array[i])) { //needs to be disabled, make sure it was (DEBUG TEMPORARY) if (gDebugSession) { error = TRUE; gFailLog << "Bad client state! " << array[i] << " enabled." << std::endl; } else { llerrs << "Bad client state! " << array[i] << " enabled." << llendl; } } } } if (error) { ll_fail("LLVertexBuffer::setupClientArrays failed"); } U32 map_tc[] = { MAP_TEXCOORD1, MAP_TEXCOORD2, MAP_TEXCOORD3 }; for (U32 i = 0; i < 3; i++) { if (sLastMask & map_tc[i]) { if (!(data_mask & map_tc[i])) { glClientActiveTextureARB(GL_TEXTURE1_ARB+i); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glClientActiveTextureARB(GL_TEXTURE0_ARB); } } else if (data_mask & map_tc[i]) { glClientActiveTextureARB(GL_TEXTURE1_ARB+i); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glClientActiveTextureARB(GL_TEXTURE0_ARB); } } if (sLastMask & MAP_BINORMAL) { if (!(data_mask & MAP_BINORMAL)) { glClientActiveTextureARB(GL_TEXTURE2_ARB); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glClientActiveTextureARB(GL_TEXTURE0_ARB); } } else if (data_mask & MAP_BINORMAL) { glClientActiveTextureARB(GL_TEXTURE2_ARB); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glClientActiveTextureARB(GL_TEXTURE0_ARB); } if (sLastMask & MAP_WEIGHT4) { if (sWeight4Loc < 0) { llerrs << "Weighting disabled but vertex buffer still bound!" << llendl; } if (!(data_mask & MAP_WEIGHT4)) { //disable 4-component skin weight glDisableVertexAttribArrayARB(sWeight4Loc); } } else if (data_mask & MAP_WEIGHT4) { if (sWeight4Loc >= 0) { //enable 4-component skin weight glEnableVertexAttribArrayARB(sWeight4Loc); } } sLastMask = data_mask; } }
//opengl scene, params: input texture (not the output mixer->texture) static void gst_gl_mosaic_callback (gpointer stuff) { GstGLMosaic *mosaic = GST_GL_MOSAIC (stuff); static GLfloat xrot = 0; static GLfloat yrot = 0; static GLfloat zrot = 0; GLint attr_position_loc = 0; GLint attr_texture_loc = 0; const GLfloat matrix[] = { 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f }; const GLushort indices[] = { 0, 1, 2, 0, 2, 3 }; guint count = 0; gboolean do_next = TRUE; gst_gl_shader_use (NULL); glBindTexture (GL_TEXTURE_RECTANGLE_ARB, 0); glDisable (GL_TEXTURE_RECTANGLE_ARB); glEnable (GL_DEPTH_TEST); glClearColor (0.0, 0.0, 0.0, 0.0); glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); gst_gl_shader_use (mosaic->shader); attr_position_loc = gst_gl_shader_get_attribute_location (mosaic->shader, "a_position"); attr_texture_loc = gst_gl_shader_get_attribute_location (mosaic->shader, "a_texCoord"); while (do_next && count < mosaic->input_gl_buffers->len && count < 6) { GstGLBuffer *gl_in_buffer = g_ptr_array_index (mosaic->input_gl_buffers, count); if (gl_in_buffer && gl_in_buffer->texture) { GLuint texture = gl_in_buffer->texture; GLfloat width = (GLfloat) gl_in_buffer->width; GLfloat height = (GLfloat) gl_in_buffer->height; const GLfloat v_vertices[] = { //front face 1.0f, 1.0f, -1.0f, width, 0.0f, 1.0f, -1.0f, -1.0f, width, height, -1.0f, -1.0f, -1.0f, 0.0f, height, -1.0f, 1.0f, -1.0f, 0.0f, 0.0f, //right face 1.0f, 1.0f, 1.0f, width, 0.0f, 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, -1.0f, -1.0f, 0.0f, height, 1.0f, 1.0f, -1.0f, width, height, //left face -1.0f, 1.0f, 1.0f, width, 0.0f, -1.0f, 1.0f, -1.0f, width, height, -1.0f, -1.0f, -1.0f, 0.0f, height, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, //top face 1.0f, -1.0f, 1.0f, width, 0.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, -1.0f, -1.0f, -1.0f, 0.0f, height, 1.0f, -1.0f, -1.0f, width, height, //bottom face 1.0f, 1.0f, 1.0f, width, 0.0f, 1.0f, 1.0f, -1.0f, width, height, -1.0f, 1.0f, -1.0f, 0.0f, height, -1.0f, 1.0f, 1.0f, 0.0f, 0.0f, //back face 1.0f, 1.0f, 1.0f, width, 0.0f, -1.0f, 1.0f, 1.0f, 0.0f, 0.0f, -1.0f, -1.0f, 1.0f, 0.0f, height, 1.0f, -1.0f, 1.0f, width, height }; glVertexAttribPointerARB (attr_position_loc, 3, GL_FLOAT, GL_FALSE, 5 * sizeof (GLfloat), &v_vertices[5 * 4 * count]); glVertexAttribPointerARB (attr_texture_loc, 2, GL_FLOAT, GL_FALSE, 5 * sizeof (GLfloat), &v_vertices[5 * 4 * count + 3]); glEnableVertexAttribArrayARB (attr_position_loc); glEnableVertexAttribArrayARB (attr_texture_loc); glActiveTextureARB (GL_TEXTURE0_ARB); glBindTexture (GL_TEXTURE_RECTANGLE_ARB, texture); gst_gl_shader_set_uniform_1i (mosaic->shader, "s_texture", 0); gst_gl_shader_set_uniform_1f (mosaic->shader, "xrot_degree", xrot); gst_gl_shader_set_uniform_1f (mosaic->shader, "yrot_degree", yrot); gst_gl_shader_set_uniform_1f (mosaic->shader, "zrot_degree", zrot); gst_gl_shader_set_uniform_matrix_4fv (mosaic->shader, "u_matrix", 1, GL_FALSE, matrix); glDrawElements (GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices); ++count; } else { do_next = FALSE; } } glDisableVertexAttribArrayARB (attr_position_loc); glDisableVertexAttribArrayARB (attr_texture_loc); glBindTexture (GL_TEXTURE_RECTANGLE_ARB, 0); glDisable (GL_DEPTH_TEST); gst_gl_shader_use (NULL); xrot += 0.6f; yrot += 0.4f; zrot += 0.8f; }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglDisableVertexAttribArrayARB(JNIEnv *env, jclass clazz, jint index, jlong function_pointer) { glDisableVertexAttribArrayARBPROC glDisableVertexAttribArrayARB = (glDisableVertexAttribArrayARBPROC)((intptr_t)function_pointer); glDisableVertexAttribArrayARB(index); }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_glDisableVertexAttribArrayARB(JNIEnv *__env, jclass clazz, jint index) { glDisableVertexAttribArrayARBPROC glDisableVertexAttribArrayARB = (glDisableVertexAttribArrayARBPROC)tlsGetFunction(1433); UNUSED_PARAM(clazz) glDisableVertexAttribArrayARB(index); }
void RAS_VAOpenGLRasterizer::EnableTextures(bool enable) { TexCoGen *texco, *attrib; int unit, texco_num, attrib_num; /* we cache last texcoords and attribs to ensure we disable the ones that * were actually last set */ if(enable) { texco = m_texco; texco_num = m_texco_num; attrib = m_attrib; attrib_num = m_attrib_num; memcpy(m_last_texco, m_texco, sizeof(TexCoGen)*m_texco_num); m_last_texco_num = m_texco_num; memcpy(m_last_attrib, m_attrib, sizeof(TexCoGen)*m_attrib_num); m_last_attrib_num = m_attrib_num; } else { texco = m_last_texco; texco_num = m_last_texco_num; attrib = m_last_attrib; attrib_num = m_last_attrib_num; } if(GLEW_ARB_multitexture) { for(unit=0; unit<texco_num; unit++) { glClientActiveTextureARB(GL_TEXTURE0_ARB+unit); switch(texco[unit]) { case RAS_TEXCO_ORCO: case RAS_TEXCO_GLOB: case RAS_TEXCO_UV1: case RAS_TEXCO_NORM: case RAS_TEXTANGENT: case RAS_TEXCO_UV2: if(enable) glEnableClientState(GL_TEXTURE_COORD_ARRAY); else glDisableClientState(GL_TEXTURE_COORD_ARRAY); break; default: glDisableClientState(GL_TEXTURE_COORD_ARRAY); break; } } glClientActiveTextureARB(GL_TEXTURE0_ARB); } else { if(texco_num) { if(enable) glEnableClientState(GL_TEXTURE_COORD_ARRAY); else glDisableClientState(GL_TEXTURE_COORD_ARRAY); } } if(GLEW_ARB_vertex_program) { for(unit=0; unit<attrib_num; unit++) { switch(attrib[unit]) { case RAS_TEXCO_ORCO: case RAS_TEXCO_GLOB: case RAS_TEXCO_UV1: case RAS_TEXCO_NORM: case RAS_TEXTANGENT: case RAS_TEXCO_UV2: case RAS_TEXCO_VCOL: if(enable) glEnableVertexAttribArrayARB(unit); else glDisableVertexAttribArrayARB(unit); break; default: glDisableVertexAttribArrayARB(unit); break; } } } if(!enable) { m_last_texco_num = 0; m_last_attrib_num = 0; } }
/* ============= RB_ARB2_CreateDrawInteractions ============= */ void RB_ARB2_CreateDrawInteractions( const drawSurf_t *surf ) { #if !defined(GL_ES_VERSION_2_0) if ( !surf ) { return; } // perform setup here that will be constant for all interactions GL_State( GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE | GLS_DEPTHMASK | backEnd.depthFunc ); // bind the vertex program if ( r_testARBProgram.GetBool() ) { glBindProgramARB( GL_VERTEX_PROGRAM_ARB, VPROG_TEST ); glBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, FPROG_TEST ); } else { glBindProgramARB( GL_VERTEX_PROGRAM_ARB, VPROG_INTERACTION ); glBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, FPROG_INTERACTION ); } glEnable(GL_VERTEX_PROGRAM_ARB); glEnable(GL_FRAGMENT_PROGRAM_ARB); // enable the vertex arrays glEnableVertexAttribArrayARB( 8 ); glEnableVertexAttribArrayARB( 9 ); glEnableVertexAttribArrayARB( 10 ); glEnableVertexAttribArrayARB( 11 ); glEnableClientState( GL_COLOR_ARRAY ); // texture 0 is the normalization cube map for the vector towards the light GL_SelectTextureNoClient( 0 ); if ( backEnd.vLight->lightShader->IsAmbientLight() ) { globalImages->ambientNormalMap->Bind(); } else { globalImages->normalCubeMapImage->Bind(); } // texture 6 is the specular lookup table GL_SelectTextureNoClient( 6 ); if ( r_testARBProgram.GetBool() ) { globalImages->specular2DTableImage->Bind(); // variable specularity in alpha channel } else { globalImages->specularTableImage->Bind(); } for ( ; surf ; surf=surf->nextOnLight ) { // perform setup here that will not change over multiple interaction passes // set the vertex pointers idDrawVert *ac = (idDrawVert *)vertexCache.Position( surf->geo->ambientCache ); glColorPointer( 4, GL_UNSIGNED_BYTE, sizeof( idDrawVert ), ac->color ); glVertexAttribPointerARB( 11, 3, GL_FLOAT, false, sizeof( idDrawVert ), ac->normal.ToFloatPtr() ); glVertexAttribPointerARB( 10, 3, GL_FLOAT, false, sizeof( idDrawVert ), ac->tangents[1].ToFloatPtr() ); glVertexAttribPointerARB( 9, 3, GL_FLOAT, false, sizeof( idDrawVert ), ac->tangents[0].ToFloatPtr() ); glVertexAttribPointerARB( 8, 2, GL_FLOAT, false, sizeof( idDrawVert ), ac->st.ToFloatPtr() ); glVertexPointer( 3, GL_FLOAT, sizeof( idDrawVert ), ac->xyz.ToFloatPtr() ); // this may cause RB_ARB2_DrawInteraction to be exacuted multiple // times with different colors and images if the surface or light have multiple layers RB_CreateSingleDrawInteractions( surf, RB_ARB2_DrawInteraction ); } glDisableVertexAttribArrayARB( 8 ); glDisableVertexAttribArrayARB( 9 ); glDisableVertexAttribArrayARB( 10 ); glDisableVertexAttribArrayARB( 11 ); glDisableClientState( GL_COLOR_ARRAY ); // disable features GL_SelectTextureNoClient( 6 ); globalImages->BindNull(); GL_SelectTextureNoClient( 5 ); globalImages->BindNull(); GL_SelectTextureNoClient( 4 ); globalImages->BindNull(); GL_SelectTextureNoClient( 3 ); globalImages->BindNull(); GL_SelectTextureNoClient( 2 ); globalImages->BindNull(); GL_SelectTextureNoClient( 1 ); globalImages->BindNull(); backEnd.glState.currenttmu = -1; GL_SelectTexture( 0 ); glDisable(GL_VERTEX_PROGRAM_ARB); glDisable(GL_FRAGMENT_PROGRAM_ARB); #endif }
void VBO::Draw(int texco_num, RAS_IRasterizer::TexCoGen* texco, int attrib_num, RAS_IRasterizer::TexCoGen* attrib, int *attrib_layer) { int unit; // Bind buffers glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, this->ibo); glBindBufferARB(GL_ARRAY_BUFFER_ARB, this->vbo_id); // Vertexes glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(3, GL_FLOAT, this->stride, this->vertex_offset); // Normals glEnableClientState(GL_NORMAL_ARRAY); glNormalPointer(GL_FLOAT, this->stride, this->normal_offset); // Colors glEnableClientState(GL_COLOR_ARRAY); glColorPointer(4, GL_UNSIGNED_BYTE, this->stride, this->color_offset); for (unit = 0; unit < texco_num; ++unit) { glClientActiveTexture(GL_TEXTURE0_ARB + unit); switch (texco[unit]) { case RAS_IRasterizer::RAS_TEXCO_ORCO: case RAS_IRasterizer::RAS_TEXCO_GLOB: glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(3, GL_FLOAT, this->stride, this->vertex_offset); break; case RAS_IRasterizer::RAS_TEXCO_UV: glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(2, GL_FLOAT, this->stride, (void*)((intptr_t)this->uv_offset+(sizeof(GLfloat)*2*unit))); break; case RAS_IRasterizer::RAS_TEXCO_NORM: glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(3, GL_FLOAT, this->stride, this->normal_offset); break; case RAS_IRasterizer::RAS_TEXTANGENT: glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(4, GL_FLOAT, this->stride, this->tangent_offset); break; default: break; } } glClientActiveTextureARB(GL_TEXTURE0_ARB); if (GLEW_ARB_vertex_program) { for (unit = 0; unit < attrib_num; ++unit) { switch (attrib[unit]) { case RAS_IRasterizer::RAS_TEXCO_ORCO: case RAS_IRasterizer::RAS_TEXCO_GLOB: glVertexAttribPointerARB(unit, 3, GL_FLOAT, GL_FALSE, this->stride, this->vertex_offset); glEnableVertexAttribArrayARB(unit); break; case RAS_IRasterizer::RAS_TEXCO_UV: glVertexAttribPointerARB(unit, 2, GL_FLOAT, GL_FALSE, this->stride, (void*)((intptr_t)this->uv_offset+attrib_layer[unit]*sizeof(GLfloat)*2)); glEnableVertexAttribArrayARB(unit); break; case RAS_IRasterizer::RAS_TEXCO_NORM: glVertexAttribPointerARB(unit, 2, GL_FLOAT, GL_FALSE, stride, this->normal_offset); glEnableVertexAttribArrayARB(unit); break; case RAS_IRasterizer::RAS_TEXTANGENT: glVertexAttribPointerARB(unit, 4, GL_FLOAT, GL_FALSE, this->stride, this->tangent_offset); glEnableVertexAttribArrayARB(unit); break; case RAS_IRasterizer::RAS_TEXCO_VCOL: glVertexAttribPointerARB(unit, 4, GL_UNSIGNED_BYTE, GL_TRUE, this->stride, this->color_offset); glEnableVertexAttribArrayARB(unit); default: break; } } } glDrawElements(this->mode, this->indices, GL_UNSIGNED_SHORT, 0); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); glDisableClientState(GL_COLOR_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); if (GLEW_ARB_vertex_program) { for (int i = 0; i < attrib_num; ++i) glDisableVertexAttribArrayARB(i); } glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0); }
//-------------------------------------------------------------- void ofxVBO::draw() { //fbo.begin(); // Rotate around and center glPushMatrix(); glTranslatef(0, 0, 0); //glTranslatef(-25,-50,0); shader.setShaderActive(true); // Turn on the Shader // Turn on depths if(bDepthTest) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST); // Get the attribute and bind it GLint pixel_loc = glGetAttribLocationARB(shader.shader, "particleSize"); glVertexAttribPointerARB(pixel_loc, 1, GL_FLOAT, false, 0, pointSizes); glBindAttribLocationARB(shader.shader, pixel_loc, "particleSize"); // printf("Size Location: %i\n", pixel_loc); // Enable Sprites and texture replace glEnable(GL_POINT_SPRITE); glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE); glEnable(GL_VERTEX_PROGRAM_POINT_SIZE); // Enable Vertex Points glEnableClientState(GL_VERTEX_ARRAY); // Enable Vertex glEnableClientState(GL_COLOR_ARRAY); // Enable Color // Color glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo[0]); // Bind the color VBO glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, NUM_PARTICLES * 4 * sizeof(float), color); glColorPointer(4, GL_FLOAT, 0, 0); // Pnts glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo[1]); // Bind the pnts VBO glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, NUM_PARTICLES * 3 * sizeof(float), pnts); glVertexPointer(3, GL_FLOAT, 0, 0); // Enable the PixelSize Attribute glEnableVertexAttribArrayARB(pixel_loc); ofEnableAlphaBlending(); // Additive Blending //glEnable(GL_BLEND); //glBlendFunc(GL_SRC_ALPHA, GL_ONE); // shader.setUniformVariable3f("theColor", 1.0, 1.0, 0.0); // Set Shader to Yellow texture.bind(); glDrawArrays(GL_POINTS, 0, NUM_PARTICLES); // Draw Just Points texture.unbind(); //shader.setUniformVariable3f("theColor", 1.0, 1.0, 1.0); // Set Shader to White ofSetColor(255, 255, 255); //glDrawArrays(GL_LINES, 0, NUM_PARTICLES); // Draw Lines ofDisableAlphaBlending(); // Clean up glDisable(GL_POINT_SPRITE); glDisableClientState(GL_COLOR_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); glDisableVertexAttribArrayARB(pixel_loc); // bind other buffer glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); shader.setShaderActive(false); glPopMatrix(); if(bDepthTest) glDisable(GL_DEPTH_TEST); else glEnable(GL_DEPTH_TEST); //fbo.end(); //fbo.draw(0,0,ofGetWidth(),ofGetHeight()); }