virtual void Set(const AmjuGL::Tris& tris) { m_numVerts = static_cast<int>(tris.size() * 3); glBindVertexArrayOES(m_vertexArray); glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(AmjuGL::Vert) * m_numVerts, &(tris[0].m_verts[0].m_x), GL_STATIC_DRAW); // This should probably go in Draw const int STRIDE = sizeof(AmjuGL::Vert); // Use lighting shader so we get the Normal attrib variable location! int vertexAttribPosition = s_currentShader->FindAttribLocation(AMJU_ES2_DEFAULT_SHADER_POSITION); int vertexAttribNormal = s_currentShader->FindAttribLocation(AMJU_ES2_DEFAULT_SHADER_NORMAL); int vertexAttribTexCoord0 = s_currentShader->FindAttribLocation(AMJU_ES2_DEFAULT_SHADER_UV); glEnableVertexAttribArray(vertexAttribPosition); glVertexAttribPointer(vertexAttribPosition, 3, GL_FLOAT, GL_FALSE, STRIDE, BUFFER_OFFSET(0)); glEnableVertexAttribArray(vertexAttribNormal); glVertexAttribPointer(vertexAttribNormal, 3, GL_FLOAT, GL_FALSE, STRIDE, BUFFER_OFFSET(12)); glEnableVertexAttribArray(vertexAttribTexCoord0); glVertexAttribPointer(vertexAttribTexCoord0, 2, GL_FLOAT, GL_FALSE, STRIDE, BUFFER_OFFSET(24)); glBindVertexArrayOES(0); }
Shape::Shape(const GLfloat* vertexData, unsigned int stride, unsigned int numVertices) : m_numVerts(numVertices) { glGenVertexArraysOES(1, &m_vertexArrayObject); glBindVertexArrayOES(m_vertexArrayObject); glGenBuffers(1, &m_vertexBuffer); glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer); glBufferData(GL_ARRAY_BUFFER, stride * numVertices, vertexData, GL_STATIC_DRAW); glEnableVertexAttribArray(VTXATTRIB_POSITION); glVertexAttribPointer(VTXATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), 0); glEnableVertexAttribArray(VTXATTRIB_NORMAL); glVertexAttribPointer(VTXATTRIB_NORMAL, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (const GLvoid *)(sizeof(float) * 3)); glBindVertexArrayOES(0); m_indexBuffer = 0; m_numIndices = 0; #if defined(DEBUG) m_numDebugIndices = 0; m_debugVAO = 0; m_debugIndexBuffer = 0; #endif }
//----------------------------------------------------------------------------// void OpenGLES2GeometryBuffer::initialiseOpenGLBuffers() { glGenVertexArraysOES(1, &d_verticesVAO); glBindVertexArrayOES(d_verticesVAO); // Generate and bind position vbo glGenBuffers(1, &d_verticesVBO); glBindBuffer(GL_ARRAY_BUFFER, d_verticesVBO); glBufferData(GL_ARRAY_BUFFER, 0, 0, GL_DYNAMIC_DRAW); d_shader->bind(); GLsizei stride = 9 * sizeof(GL_FLOAT); glVertexAttribPointer(d_shaderTexCoordLoc, 2, GL_FLOAT, GL_FALSE, stride, 0); glEnableVertexAttribArray(d_shaderTexCoordLoc); glVertexAttribPointer(d_shaderColourLoc, 4, GL_FLOAT, GL_FALSE, stride, BUFFER_OFFSET(2 * sizeof(GL_FLOAT))); glEnableVertexAttribArray(d_shaderColourLoc); glVertexAttribPointer(d_shaderPosLoc, 3, GL_FLOAT, GL_FALSE, stride, BUFFER_OFFSET(6 * sizeof(GL_FLOAT))); glEnableVertexAttribArray(d_shaderPosLoc); d_shader->unbind(); // Unbind Vertex Attribute Array (VAO) glBindVertexArrayOES(0); // Unbind array and element array buffers glBindBuffer(GL_ARRAY_BUFFER, 0); }
ScreenQuad::ScreenQuad(const std::string &_shader) { static ngl::Vec3 verts[]= { ngl::Vec3(-1.0f,-1.0f,0.0f), ngl::Vec3(1.0f,-1.0f,0.0f), ngl::Vec3(1.0f,1.0f,0.0f), ngl::Vec3(1.0f,1.0f,0.0f), ngl::Vec3(-1.0f,-1.0f,0.0f), ngl::Vec3(-1.0f,1.0f,0.0f) }; static ngl::Vec2 uv[]= { ngl::Vec2(0.0f,0.0f), ngl::Vec2(1.0f,0.0f), ngl::Vec2(1.0f,1.0f), ngl::Vec2(1.0f,1.0f), ngl::Vec2(0.0f,0.0f), ngl::Vec2(0.0f,1.0f) }; m_shader=_shader; glGenVertexArraysOES(1,&m_vao); glBindVertexArrayOES(m_vao); GLuint vbo[2]; glGenBuffers(2,vbo); glBindBuffer(GL_ARRAY_BUFFER,vbo[0]); glBufferData(GL_ARRAY_BUFFER,6*sizeof(ngl::Vec3),&verts[0].m_x,GL_STATIC_DRAW); glVertexAttribPointer(0, // atrib 0 3, // with x,y,z GL_FLOAT, // what type GL_FALSE, // normalize? 0, // stride 0 // start ptr ); glEnableVertexAttribArray(0); glBindBuffer(GL_ARRAY_BUFFER,vbo[1]); glBufferData(GL_ARRAY_BUFFER,6*sizeof(ngl::Vec2),&uv[0].m_x,GL_STATIC_DRAW); glVertexAttribPointer(1, // atrib 0 2, // with x,y,z GL_FLOAT, // what type GL_FALSE, // normalize? 0, // stride 0 // start ptr ); glEnableVertexAttribArray(1); glBindVertexArrayOES(0); }
CGRVertexBufferGLES::~CGRVertexBufferGLES() { glBindVertexArrayOES(mVAO); glDeleteVertexArraysOES(1, &mVAO); glBindBuffer(GL_ARRAY_BUFFER, 0); glDeleteBuffers(1, &mVBO); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArrayOES(0); }
void ScreenQuad::draw() { ngl::ShaderLib *shader = ngl::ShaderLib::instance(); shader->use(m_shader); glBindVertexArrayOES(m_vao); glDrawArrays(GL_TRIANGLES,0,6); glBindVertexArrayOES(0); }
void templateAppInit(int width, int height) { GFX_start(); glViewport(0.0f, 0.0f, width, height); GFX_set_matrix_mode(PROJECTION_MATRIX); GFX_load_identity(); GFX_set_perspective(45.0f, (float)width / (float)height, 0.1f, 100.0f, 0.0f); program = PROGRAM_create((char *)"default", VERTEX_SHADER, FRAGMENT_SHADER, 1, DEBUG_SHADERS, NULL, program_draw_callback); obj = OBJ_load(OBJ_FILE, 1); unsigned char *vertex_array = NULL, *vertex_start = NULL; unsigned int i = 0, index = 0, stride = 0, size = 0; objmesh = &obj->objmesh[0]; size = objmesh->n_objvertexdata * sizeof(vec3) * sizeof(vec3) * sizeof(vec2); vertex_array = (unsigned char *)malloc(size); vertex_start = vertex_array; while (i != objmesh->n_objvertexdata) { index = objmesh->objvertexdata[i].vertex_index; memcpy(vertex_array, &obj->indexed_vertex[index], sizeof(vec3)); vertex_array += sizeof(vec3); memcpy(vertex_array, &obj->indexed_normal[index], sizeof(vec3)); vertex_array += sizeof(vec3); memcpy(vertex_array, &obj->indexed_uv[objmesh->objvertexdata[i].uv_index], sizeof(vec2)); vertex_array += sizeof(vec2); ++i; } glGenBuffers(1, &objmesh->vbo); glBindBuffer(GL_ARRAY_BUFFER, objmesh->vbo); glBufferData(GL_ARRAY_BUFFER, size, vertex_start, GL_STATIC_DRAW); free(vertex_start); glBindBuffer(GL_ARRAY_BUFFER, 0); glGenBuffers(1, &objmesh->objtrianglelist[0].vbo); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, objmesh->objtrianglelist[0].vbo); glBufferData(GL_ELEMENT_ARRAY_BUFFER, objmesh->objtrianglelist[0].n_indice_array * sizeof(unsigned short), objmesh->objtrianglelist[0].indice_array, GL_STATIC_DRAW); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); unsigned char attribute; stride = sizeof(vec3) + sizeof(vec3) + sizeof(vec2); glGenVertexArraysOES(1, &objmesh->vao); glBindVertexArrayOES(objmesh->vao); glBindBuffer(GL_ARRAY_BUFFER, objmesh->vbo); attribute = PROGRAM_get_vertex_attrib_location(program, (char *)"POSITION"); glEnableVertexAttribArray(attribute); glVertexAttribPointer(attribute, 3, GL_FLOAT, GL_FALSE, stride, (void *)NULL); attribute = PROGRAM_get_vertex_attrib_location(program, (char *)"NORMAL"); glEnableVertexAttribArray(attribute); glVertexAttribPointer(attribute, 3, GL_FLOAT, GL_FALSE, stride, BUFFER_OFFSET(sizeof(vec3))); attribute = PROGRAM_get_vertex_attrib_location(program, (char *)"TEXCOORD0"); glEnableVertexAttribArray(attribute); glVertexAttribPointer(attribute, 2, GL_FLOAT, GL_FALSE, stride, BUFFER_OFFSET(sizeof(vec3) + sizeof(vec3))); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, objmesh->objtrianglelist[0].vbo); glBindVertexArrayOES(0); texture = TEXTURE_create(obj->objmaterial[0].map_diffuse, obj->objmaterial[0].map_diffuse, 1, TEXTURE_MIPMAP, TEXTURE_FILTER_2X, 0.0f); }
void nbMesh::draw() { if (visible && distance) { if (vao) { glLogVerbose("glBindVertexArrayOES : vao"); glBindVertexArrayOES(vao); } else { setAttributePointer(); } if (material) { material->draw(); } glLogVerbose("glBindBuffer : GL_ELEMENT_ARRAY_BUFFER"); glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, vboVertexIndex); glLogVerbose("glDrawElements"); glDrawElements(mode, (int)vertexIndexList.size(), GL_UNSIGNED_SHORT, ( void * )NULL ); } }
void generateVaoInfoFromModelData(SSGModelData *data, GLuint *vaoIndex, GLuint *vboIndex, GLuint *nVerts) { if(!data) { return; } GLuint vao,vbo; glGenVertexArraysOES(1,&vao); glBindVertexArrayOES(vao); glGenBuffers(1,&vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, data->arraySize,data->vertexArray, GL_STATIC_DRAW); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 32, (char*)NULL + 0); glEnableVertexAttribArray(1); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 32, (char*)NULL + 12); glEnableVertexAttribArray(2); glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 32, (char*)NULL + 24); *nVerts = data->arrayRows; *vaoIndex = vao; *vboIndex = vbo; }
void templateAppDraw( void ) { glClearColor( 0.5f, 0.5f, 0.5f, 1.0f ); glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT ); GFX_set_matrix_mode( MODELVIEW_MATRIX ); GFX_load_identity(); { vec3 e = { 0.0f, -4.0f, 0.0f }, c = { 0.0f, 0.0f, 0.0f }, u = { 0.0f, 0.0f, 1.0f }; GFX_look_at( &e, &c, &u ); } glBindVertexArrayOES( objmesh->vao ); if( auto_rotate ) rot_angle.z += 2.0f; GFX_rotate( rot_angle.x, 1.0f, 0.0f, 0.0f ); GFX_rotate( rot_angle.z, 0.0f, 0.0f, 1.0f ); PROGRAM_draw( program ); glDrawElements( GL_TRIANGLES, objmesh->objtrianglelist[ 0 ].n_indice_array, GL_UNSIGNED_SHORT, ( void * )NULL ); }
void IWCubeControllerSetupVBOs(IWCubeControllerData *cubeController, const IWGShaderProgramData *shaderProgram) { glUseProgram(shaderProgram->programID); // Fill buffers for (unsigned int i = 0; i < IWGMULTIBUFFER_MAX; i++) { cubeController->triangleRingBuffer.nVertices[i] = cubeController->triangleDataBufferSize / 10; IWGRingBufferBind(&cubeController->triangleRingBuffer, i); glBufferData(GL_ARRAY_BUFFER, cubeController->triangleDataBufferSize * sizeof(GLfloat), cubeController->triangleDataBufferStart, GL_DYNAMIC_DRAW); IWGShaderProgramEnableVertexAtrribArrays(shaderProgram, 10); glEnableVertexAttribArray(shaderProgram->vertexSlot); // glVertexAttribPointer(shaderProgram->vertexSlot, 3, GL_FLOAT, GL_FALSE, // 10 * sizeof(GLfloat), BUFFER_OFFSET(0)); // glEnableVertexAttribArray(shaderProgram->colorSlot); // glVertexAttribPointer(shaderProgram->colorSlot, 4, GL_FLOAT, GL_FALSE, // 10 * sizeof(GLfloat), BUFFER_OFFSET(3 * sizeof(GLfloat))); // glEnableVertexAttribArray(shaderProgram->normalSlot); // glVertexAttribPointer(shaderProgram->normalSlot, 3, GL_FLOAT, GL_FALSE, // 10 * sizeof(GLfloat), BUFFER_OFFSET(7 * sizeof(GLfloat))); } #ifdef IW_USE_GLVAO glBindVertexArrayOES(0); #endif }
void templateAppDraw( void ) { glClearColor( 0.5f, 0.5f, 0.5f, -1.0f ); glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT ); GFX_set_matrix_mode( MODELVIEW_MATRIX ); //创建一个关键矩阵,并在Y轴上设置一个向后的偏移量,以便能够看到模型 GFX_load_identity(); { vec3 e = { 0.0f, -4.0f, 0.0f }, c = { 0.0f, 0.0f, 0.0f }, u = { 0.0f, 0.0f, 1.0f }; GFX_look_at( &e, &c, &u ); } //绑定VAO glBindVertexArrayOES( objmesh->vao ); if (auto_rotate) rot_angle.z += 2.0f; GFX_rotate(rot_angle.x, 1.0f, 0.0f, 0.0f); GFX_rotate(rot_angle.z, 0.0f, 0.0f, 1.0f); //设置绘制的着色器程序(自动使用glUseProgram绑定到着色器程序,然后发送program_draw_callback中执行指针,调用该函数) PROGRAM_draw( program ); //绘图语句 glDrawElements( GL_TRIANGLES, objmesh->objtrianglelist[ 0 ].n_indice_array, GL_UNSIGNED_SHORT, ( void * )NULL ); }
EXTERN_C_ENTER JNIEXPORT void JNICALL Java_org_lwjgl_opengles_OESVertexArrayObject_glBindVertexArrayOES(JNIEnv *__env, jclass clazz, jint array) { glBindVertexArrayOESPROC glBindVertexArrayOES = (glBindVertexArrayOESPROC)tlsGetFunction(797); UNUSED_PARAM(clazz) glBindVertexArrayOES(array); }
void IWScorePresenterRender(IWScorePresenterData *scorePresenter, const IWGShaderProgramData* shaderProgram) { glUseProgram(shaderProgram->programID); IWGRingBufferBindCurrentDrawBuffer(&scorePresenter->multiBuffer); #ifndef IW_USE_GLVAO if (shaderProgram) { IWGShaderProgramEnableVertexAtrribArrays(shaderProgram, 9); } else { printf("ERROR IWScorePresenterRender: shaderProgram == NULL\n"); return; } #endif glDrawArrays(GL_TRIANGLES, 0, scorePresenter->multiBuffer.nVertices[scorePresenter->multiBuffer.currentDrawBuffer]); #ifdef IW_USE_GLVAO glBindVertexArrayOES(0); #endif IWGRingBufferSwitchBuffer(&scorePresenter->multiBuffer); return; }
void VaoImplEs::reassignImpl( Context *newContext ) { if( newContext == mCtx ) return; mCtx = newContext; // generate glGenVertexArraysOES( 1, &mId ); // assign glBindVertexArrayOES( mId ); // instantiate the VAO using the layout auto oldBuffer = mCtx->getBufferBinding( GL_ARRAY_BUFFER ); for( auto attribIt = mLayout.mVertexAttribs.begin(); attribIt != mLayout.mVertexAttribs.end(); ++attribIt ) { if( attribIt->second.mEnabled ) { glEnableVertexAttribArray( attribIt->first ); glBindBuffer( GL_ARRAY_BUFFER, attribIt->second.mArrayBufferBinding ); if( attribIt->second.mPointerType == Vao::VertexAttrib::FLOAT ) glVertexAttribPointer( attribIt->first, attribIt->second.mSize, attribIt->second.mType, attribIt->second.mNormalized, attribIt->second.mStride, attribIt->second.mPointer ); else CI_LOG_E( "Attempt to use integer AttribPointer on ES 2. Ignoring." ); } } glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, mLayout.mElementArrayBufferBinding ); // we need to bind this directly to prevent the gl::Context's caching from subverting our restoration of the old GL_ARRAY_BUFFER glBindBuffer( GL_ARRAY_BUFFER, oldBuffer ); }
virtual void Draw() { glActiveTexture(GL_TEXTURE0); s_currentShader->Begin(); if (s_currentShader == s_defaultShader) { // TODO only change these when necessary. // TODO Check for using default shader or a different one GLKMatrix4& projectionMatrix = s_matrices[AmjuGL::AMJU_PROJECTION_MATRIX]; GLKMatrix4& modelViewMatrix = s_matrices[AmjuGL::AMJU_MODELVIEW_MATRIX]; // Moldelview * projection matrix for world transforms GLKMatrix4 modelViewProjectionMatrix = GLKMatrix4Multiply(projectionMatrix, modelViewMatrix); s_currentShader->Set(AMJU_ES2_DEFAULT_SHADER_MODELVIEWPROJECTION_MATRIX, modelViewProjectionMatrix.m); s_currentShader->Set(AMJU_ES2_DEFAULT_SHADER_MODELVIEW_MATRIX, modelViewMatrix.m); if (s_lightingEnabled || s_tt == AmjuGL::AMJU_TEXTURE_SPHERE_MAP) { // Inverse transpose of modelview matrix to rotate normals GLKMatrix3 normalMatrix = GLKMatrix3InvertAndTranspose(GLKMatrix4GetMatrix3(modelViewMatrix), NULL); s_currentShader->SetMatrix3x3(AMJU_ES2_DEFAULT_SHADER_NORMAL_MATRIX, normalMatrix.m); } s_currentShader->Set(AMJU_ES2_DEFAULT_SHADER_TEXTURE, (AmjuGL::TextureHandle)0); s_currentShader->Set(AMJU_ES2_DEFAULT_SHADER_COLOUR, s_colour); s_currentShader->Set(AMJU_ES2_DEFAULT_SHADER_USE_LIGHTING, (float)(s_lightingEnabled ? 0 : 1)); s_currentShader->SetInt(AMJU_ES2_DEFAULT_SHADER_USE_SPHEREMAP, (int)s_tt); s_currentShader->Set(AMJU_ES2_DEFAULT_SHADER_LIGHT_DIR, s_lightPos); s_currentShader->Set(AMJU_ES2_DEFAULT_SHADER_EYE_POS, s_eyePos); } glBindVertexArrayOES(m_vertexArray); glDrawArrays(GL_TRIANGLES, 0, m_numVerts); }
void nbMesh::buildVao() { glLog("glGenVertexArraysOES : vao"); glGenVertexArraysOES( 1, &vao ); glLog("glBindVertexArrayOES : vao"); glBindVertexArrayOES(vao); setAttributePointer( ); glLog("glBindBuffer : GL_ELEMENT_ARRAY_BUFFER"); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboVertexIndex); glLog("glBindVertexArrayOES : 0"); glBindVertexArrayOES(0); }
void OsmAnd::GPUAPI_OpenGLES2::glBindVertexArray_wrapper(GLuint array) { assert(isSupported_vertex_array_object); GL_CHECK_PRESENT(glBindVertexArrayOES); glBindVertexArrayOES(array); }
void IWGRingBufferBind(IWGRingBufferData *multiBufferData, unsigned int buffer) { #ifdef IW_USE_GLVAO glBindVertexArrayOES(multiBufferData->vertexArray[buffer]); #endif glBindBuffer(GL_ARRAY_BUFFER, multiBufferData->vertexBuffer[buffer]); return; }
//----------------------------------------------------------------------- void GLES2VertexDeclaration::bind(void) { #if GL_OES_vertex_array_object // LogManager::getSingleton().logMessage("Binding VAO " + StringConverter::toString(mVAO)); glBindVertexArrayOES(mVAO); GL_CHECK_ERROR #endif }
void XGraphicsOpenGL::FillRect( float x, float y, float w, float h, XCOLOR color ) { CHECK_GL_ERROR(); if( w == 0 || h == 0 ) return; if( w < 0 ) { w = -w; // w는 부호 바꿈 x -= w; // 좌측 좌표를 -w만큼 이동시켜주고 } if( h < 0 ) { h = -h; y -= h; } if( x > GetViewportRight() || y > GetViewportBottom() ) return; if( x + w < 0 || y + h < 0 ) return; GLfloat r, g, b, a; r = XCOLOR_RGB_R(color) / 255.0f; g = XCOLOR_RGB_G(color) / 255.0f; b = XCOLOR_RGB_B(color) / 255.0f; a = XCOLOR_RGB_A(color) / 255.0f; // width-1이 맞나? 안하는게 맞나? GLfloat pos[8] = { 0, h, w, h, 0, 0, w, 0 }; GLfloat col[16] = { r,g,b,a, r,g,b,a, r,g,b,a, r,g,b,a }; MATRIX mMVP; MATRIX mModel; MatrixTranslation( mModel, x, y, 0 ); MatrixMultiply( mMVP, mModel, XE::x_mViewProjection ); GetpColorShader()->SetShader( mMVP, 1.0f, 1.0f, 1.0f, 1.0f ); glEnable(GL_BLEND); #ifdef _XVAO glBindVertexArrayOES( 0 ); #endif glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glEnableVertexAttribArray( XE::ATTRIB_POS ); glVertexAttribPointer( XE::ATTRIB_POS, 2, GL_FLOAT, GL_FALSE, 0, pos); // glDisableVertexAttribArray( XE::ATTRIB_TEXTURE ); glEnableVertexAttribArray( XE::ATTRIB_COLOR ); glVertexAttribPointer( XE::ATTRIB_COLOR, 4, GL_FLOAT, GL_FALSE, 0, col); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); CHECK_GL_ERROR(); // glEnable( GL_TEXTURE_2D ); }
//----------------------------------------------------------------------- void GLES2VertexDeclaration::bind(void) { #if OGRE_NO_GLES2_VAO_SUPPORT == 0 # if defined(GL_OES_vertex_array_object) || (OGRE_NO_GLES3_SUPPORT == 0) // LogManager::getSingleton().logMessage("Binding VAO " + StringConverter::toString(mVAO)); OGRE_CHECK_GL_ERROR(glBindVertexArrayOES(mVAO)); # endif #endif }
GLuint ShapeVAOs::square() { if (this->_square == 0) { std::vector<float> square = Geometry::rectangle(0.0, 0.0, 1.0, 1.0); glGenVertexArraysOES(1, &this->_square); glBindVertexArrayOES(this->_square); GLuint buffer; glGenBuffers(1, &buffer); glBindBuffer(GL_ARRAY_BUFFER, buffer); glBufferData(GL_ARRAY_BUFFER, sizeof(float)*square.size(), &square[0], GL_STATIC_DRAW); glEnableVertexAttribArray(ShaderProgramAttributePosition); glVertexAttribPointer(ShaderProgramAttributePosition, 2, GL_FLOAT, GL_FALSE, 2*sizeof(float), 0); glDisableVertexAttribArray(ShaderProgramAttributeColor); glVertexAttrib4f(ShaderProgramAttributeColor, 1.0, 1.0, 1.0, 1.0); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArrayOES(0); } return this->_square; }
void OpenGL3StateChangeWrapper::bindVertexArray(GLuint vertexArray) { if(vertexArray != d_vertexArrayObject) { glBindVertexArrayOES(vertexArray); d_vertexArrayObject = vertexArray; } }
void XGraphicsOpenGL::DrawRect( float x, float y, float w, float h, XCOLOR color ) { CHECK_GL_ERROR(); if( w < 0 ) { x += w; w = -w; } if( h < 0 ) { y += h; h = -h; } // if( x > GetScreenWidth() || y > GetScreenHeight() ) if( x > GetViewportRight() || y > GetViewportBottom() ) return; if( w < 0 || h < 0 ) return; GLfloat r, g, b, a; r = XCOLOR_RGB_R(color) / 255.0f; g = XCOLOR_RGB_G(color) / 255.0f; b = XCOLOR_RGB_B(color) / 255.0f; a = XCOLOR_RGB_A(color) / 255.0f; // if( a != 255 ) glEnable(GL_BLEND); // 이거 자주불러주면 부하걸릴거 같다. 외부에서 블럭단위로 셋하게 하자. // width-1이 맞나? 안하는게 맞나? // GLfloat pos[8] = { 0, h, w, h, 0, 0, w, 0 }; GLfloat pos[10] = { 0, 0, w, 0, w, h, 0, h, 0, 0 }; GLfloat col[20] = { r,g,b,a, r,g,b,a, r,g,b,a, r,g,b,a, r,g,b,a }; MATRIX mModel; MATRIX mMVP; MatrixTranslation( mModel, x, y, 0 ); MatrixMultiply( mMVP, mModel, XE::x_mViewProjection ); GetpColorShader()->SetShader( mMVP, 1.0f, 1.0f, 1.0f, 1.0f ); // GetpColorShader()->SetMatrixModel( mModel ); glLineWidth( GetLineWidth() ); // glDisable( GL_TEXTURE_2D ); glBindBuffer(GL_ARRAY_BUFFER, 0); glEnableVertexAttribArray( XE::ATTRIB_POS ); glVertexAttribPointer( XE::ATTRIB_POS, 2, GL_FLOAT, GL_FALSE, 0, pos); glEnableVertexAttribArray( XE::ATTRIB_COLOR ); glVertexAttribPointer( XE::ATTRIB_COLOR, 4, GL_FLOAT, GL_FALSE, 0, col); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); #ifdef _XVAO glBindVertexArrayOES( 0 ); #endif glDrawArrays(GL_LINE_STRIP, 0, 5); // glEnable( GL_TEXTURE_2D ); CHECK_GL_ERROR(); }
virtual void Set(const AmjuGL::Tris& tris) { if (m_firstSet) { m_firstSet = false; m_numVerts = static_cast<int>(tris.size() * 3); glBindVertexArrayOES(m_vertexArray); glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(AmjuGL::Vert) * m_numVerts, &(tris[0].m_verts[0].m_x), GL_DYNAMIC_DRAW); // This should probably go in Draw const int STRIDE = sizeof(AmjuGL::Vert); int vertexAttribPosition = s_defaultShader->FindAttribLocation(AMJU_ES2_DEFAULT_SHADER_POSITION); int vertexAttribNormal = s_defaultShader->FindAttribLocation(AMJU_ES2_DEFAULT_SHADER_NORMAL); int vertexAttribTexCoord0 = s_defaultShader->FindAttribLocation(AMJU_ES2_DEFAULT_SHADER_UV); glEnableVertexAttribArray(vertexAttribPosition); glVertexAttribPointer(vertexAttribPosition, 3, GL_FLOAT, GL_FALSE, STRIDE, BUFFER_OFFSET(0)); glEnableVertexAttribArray(vertexAttribNormal); glVertexAttribPointer(vertexAttribNormal, 3, GL_FLOAT, GL_FALSE, STRIDE, BUFFER_OFFSET(12)); glEnableVertexAttribArray(vertexAttribTexCoord0); glVertexAttribPointer(vertexAttribTexCoord0, 2, GL_FLOAT, GL_FALSE, STRIDE, BUFFER_OFFSET(24)); glBindVertexArrayOES(0); } else { // Must have same number of tris, right? Assert(tris.size() * 3 == m_numVerts); glBindVertexArrayOES(m_vertexArray); glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer); glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(AmjuGL::Vert) * m_numVerts, &(tris[0].m_verts[0].m_x)); } }
void VaoImplEs::bindImpl( Context *context ) { if( context && ( context != mCtx ) ) { CI_LOG_W( "VAO bound against different context from allocation. Reassigning context." ); reassignImpl( context ); } glBindVertexArrayOES( mId ); if( context ) { context->reflectBufferBinding( GL_ELEMENT_ARRAY_BUFFER, mLayout.mElementArrayBufferBinding ); mLayout.mCachedArrayBufferBinding = context->getBufferBinding( GL_ARRAY_BUFFER ); } }
void CGRVertexBufferGLES::_allocate(U32 size) { // We really only need to do something if there are VBOs if (mUseVBOs) { // Generate VBO and upload vertex data to GPU glGenBuffers(1, &mVBO); glBindBuffer(GL_ARRAY_BUFFER, mVBO); glBufferData(GL_ARRAY_BUFFER, size, mVertexArray, GL_STATIC_DRAW); // Generate a vertex array object to quickly bind and configure the buffer glGenVertexArraysOES(1, &mVAO); glBindVertexArrayOES(mVAO); glBindBuffer(GL_ARRAY_BUFFER, mVBO); for (std::vector<BindInfo>::iterator it = mBindInfos.begin(); it != mBindInfos.end(); it++) { glVertexAttribPointer((*it).bindLoc, (*it).compCount, GL_FLOAT, GL_FALSE, (*it).stride, (GLvoid*)(*it).offset); glEnableVertexAttribArray((*it).bindLoc); } glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArrayOES(0); } }
void VertexBufferObject::init(const PolygonMesh *polygonMesh) { m_polgonMesh = polygonMesh; glGenVertexArraysOES(1, &m_vertexArray); glBindVertexArrayOES(m_vertexArray); glGenBuffers(1, &m_vertexBuffer); glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer); glBufferData(GL_ARRAY_BUFFER, polygonMesh->vertSize(), polygonMesh->getRawVerts(), GL_STATIC_DRAW); glEnableVertexAttribArray(VBOVertexAttrib::VertexAttribPosition); glVertexAttribPointer(VBOVertexAttrib::VertexAttribPosition, 3, GL_FLOAT, GL_FALSE, 24, BUFFER_OFFSET(0)); glEnableVertexAttribArray(VBOVertexAttrib::VertexAttribNormal); glVertexAttribPointer(VBOVertexAttrib::VertexAttribNormal, 3, GL_FLOAT, GL_FALSE, 24, BUFFER_OFFSET(12)); glBindVertexArrayOES(m_vertexArray); glGenBuffers(1, &m_indexBuffer); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffer); glBufferData(GL_ELEMENT_ARRAY_BUFFER, polygonMesh->triMemSize(), polygonMesh->getTris(), GL_STATIC_DRAW); m_numIndices = polygonMesh->numTris()*3; }
inline void gl_bind_vertex_array(GLuint array) { #if defined(__OSX__) glBindVertexArray(array); #elif defined(__IOS__) && defined(__OPENGL_30__) glBindVertexArray(array); #else glBindVertexArrayOES(array); #endif #if defined(DEBUG) gl_get_error(); #endif };