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
};
