TriListDynamicES2()
{
m_firstSet = true;
m_numVerts = 0;
glGenVertexArraysOES(1, &m_vertexArray);
glGenBuffers(1, &m_vertexBuffer);
}
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 );
}
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 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 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);
}
void OsmAnd::GPUAPI_OpenGLES2::glGenVertexArrays_wrapper(GLsizei n, GLuint* arrays)
{
assert(isSupported_vertex_array_object);
GL_CHECK_PRESENT(glGenVertexArraysOES);
glGenVertexArraysOES(n, arrays);
}
//----------------------------------------------------------------------------------------------------------------------
VertexArrayObject::VertexArrayObject(GLenum _mode)
{
m_allocated=false;
// first we create a vertex array Object
glGenVertexArraysOES(1, &m_id);
m_bound=false;
m_drawMode=_mode;
m_indicesCount=0;
m_indexed=false;
m_indexType = GL_UNSIGNED_BYTE;
}
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);
}
inline void gl_create_vertex_arrays(GLsizei count, GLuint *pointers)
{
#if defined(__OSX__)
glGenVertexArrays(count, pointers);
#elif defined(__IOS__) && defined(__OPENGL_30__)
glGenVertexArrays(count, pointers);
#else
glGenVertexArraysOES(count, pointers);
#endif
#if defined(DEBUG)
gl_get_error();
#endif
};
IWGRingBufferData IWGRingBufferGen(void)
{
IWGRingBufferData multiBufferData;
for (unsigned int i = 0; i < IWGMULTIBUFFER_MAX; i++) {
#ifdef IW_USE_GLVAO
glGenVertexArraysOES(1, &multiBufferData.vertexArray[i]);
#endif
glGenBuffers(1, &multiBufferData.vertexBuffer[i]);
multiBufferData.bufferSubData[i] = NULL;
multiBufferData.nVertices[i] = 0;
}
multiBufferData.currentDataUpdateBuffer = 0;
multiBufferData.currentDrawBuffer = 1 % IWGMULTIBUFFER_MAX;
return multiBufferData;
}
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);
}
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;
}
//-----------------------------------------------------------------------
GLES2VertexDeclaration::GLES2VertexDeclaration()
:
mVAO(0),
mIsInitialised(false)
{
#if GL_OES_vertex_array_object
glGenVertexArraysOES(1, &mVAO);
// LogManager::getSingleton().logMessage("Created VAO " + StringConverter::toString(mVAO));
GL_CHECK_ERROR
if (!mVAO)
{
OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
"Cannot create GL ES Vertex Array Object",
"GLES2VertexDeclaration::GLES2VertexDeclaration");
}
#endif
}
//-----------------------------------------------------------------------
GLES2VertexDeclaration::GLES2VertexDeclaration()
:
mVAO(0),
mIsInitialised(false)
{
#if OGRE_NO_GLES2_VAO_SUPPORT == 0
# if defined(GL_OES_vertex_array_object) || (OGRE_NO_GLES3_SUPPORT == 0)
OGRE_CHECK_GL_ERROR(glGenVertexArraysOES(1, &mVAO));
// LogManager::getSingleton().logMessage("Created VAO " + StringConverter::toString(mVAO));
if (!mVAO)
{
OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
"Cannot create GL ES Vertex Array Object",
"GLES2VertexDeclaration::GLES2VertexDeclaration");
}
# endif
#endif
}
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;
}
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);
}
}
bool MeshBufferOGL::update()
{
if (indexBufferDirty || vertexBufferDirty)
{
std::vector<uint8_t> localIndexData;
std::vector<uint8_t> localVertexData;
{
std::lock_guard<std::mutex> lock(dataMutex);
if (indexBufferDirty)
{
localIndexData = indexData;
switch (indexSize)
{
case 1: indexFormat = GL_UNSIGNED_BYTE; break;
case 2: indexFormat = GL_UNSIGNED_SHORT; break;
case 4: indexFormat = GL_UNSIGNED_INT; break;
default: log("Invalid size"); return false;
}
}
if (vertexBufferDirty)
{
localVertexData = vertexData;
vertexAttribs.clear();
GLuint offset = 0;
if (vertexAttributes & VERTEX_POSITION)
{
vertexAttribs.push_back({
3, GL_FLOAT, GL_FALSE,
static_cast<GLint>(vertexSize),
reinterpret_cast<const GLvoid*>(offset)
});
offset += 3 * sizeof(float);
}
if (vertexAttributes & VERTEX_COLOR)
{
vertexAttribs.push_back({
4, GL_UNSIGNED_BYTE, GL_TRUE,
static_cast<GLint>(vertexSize),
reinterpret_cast<const GLvoid*>(offset)
});
offset += 4 * sizeof(uint8_t);
}
if (vertexAttributes & VERTEX_NORMAL)
{
vertexAttribs.push_back({
3, GL_FLOAT, GL_FALSE,
static_cast<GLint>(vertexSize),
reinterpret_cast<const GLvoid*>(offset)
});
offset += 3 * sizeof(float);
}
if (vertexAttributes & VERTEX_TEXCOORD0)
{
vertexAttribs.push_back({
2, GL_FLOAT, GL_FALSE,
static_cast<GLint>(vertexSize),
reinterpret_cast<const GLvoid*>(offset)
});
offset += 2 * sizeof(float);
}
if (vertexAttributes & VERTEX_TEXCOORD1)
{
vertexAttribs.push_back({
2, GL_FLOAT, GL_FALSE,
static_cast<GLint>(vertexSize),
reinterpret_cast<const GLvoid*>(offset)
});
offset += 2 * sizeof(float);
}
if (offset != vertexSize)
{
log("Invalid vertex size");
return false;
}
}
}
if (indexBufferDirty)
{
if (!indexBufferId)
{
glGenBuffers(1, &indexBufferId);
if (RendererOGL::checkOpenGLError())
{
log("Failed to create index buffer");
return false;
}
}
if (!localIndexData.empty())
{
RendererOGL::bindElementArrayBuffer(indexBufferId);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, localIndexData.size(), localIndexData.data(),
dynamicIndexBuffer ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW);
if (RendererOGL::checkOpenGLError())
{
log("Failed to upload index data");
return false;
}
// unbind so that it gets bind again right before glDrawElements
RendererOGL::unbindElementArrayBuffer(indexBufferId);
}
indexBufferDirty = false;
}
if (vertexBufferDirty)
{
if (!vertexBufferId)
{
#if OUZEL_PLATFORM_IOS || OUZEL_PLATFORM_TVOS
glGenVertexArraysOES(1, &vertexArrayId);
#elif OUZEL_PLATFORM_ANDROID || OUZEL_PLATFORM_RASPBIAN
if (glGenVertexArraysOESEXT) glGenVertexArraysOESEXT(1, &vertexArrayId);
#else
glGenVertexArrays(1, &vertexArrayId);
#endif
if (RendererOGL::checkOpenGLError(false))
{
log("Failed to create vertex array");
vertexArrayId = 0;
}
else
{
RendererOGL::bindVertexArray(vertexArrayId);
}
glGenBuffers(1, &vertexBufferId);
if (RendererOGL::checkOpenGLError())
{
log("Failed to create vertex buffer");
return false;
}
}
if (vertexArrayId)
{
RendererOGL::bindVertexArray(vertexArrayId);
RendererOGL::bindArrayBuffer(vertexBufferId);
for (GLuint index = 0; index < 5; ++index)
{
if (index < vertexAttribs.size())
{
glEnableVertexAttribArray(index);
glVertexAttribPointer(index,
vertexAttribs[index].size,
vertexAttribs[index].type,
vertexAttribs[index].normalized,
vertexAttribs[index].stride,
vertexAttribs[index].pointer);
}
else
{
glDisableVertexAttribArray(index);
}
}
if (RendererOGL::checkOpenGLError())
{
log("Failed to update vertex attributes");
return false;
}
}
if (!localVertexData.empty())
{
RendererOGL::bindArrayBuffer(vertexBufferId);
glBufferData(GL_ARRAY_BUFFER, localVertexData.size(), localVertexData.data(),
dynamicVertexBuffer ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW);
if (RendererOGL::checkOpenGLError())
{
log("Failed to create vertex data");
return false;
}
// unbind so that it gets bind again right before glDrawElements
RendererOGL::unbindArrayBuffer(vertexBufferId);
}
vertexBufferDirty = false;
}
ready = true;
}
return true;
}
void Model::RenderFoo(StateFoo *sf, foofoo *foo, bool copy) {
if (foo->m_Texture != sf->g_lastTexture) {
sf->g_lastTexture = foo->m_Texture;
glBindTexture(GL_TEXTURE_2D, sf->g_lastTexture);
}
#ifdef HAS_VAO
if (foo->m_VertexArrayObjects[sf->m_LastBufferIndex] == 0) {
glGenVertexArraysOES(1, &foo->m_VertexArrayObjects[sf->m_LastBufferIndex]);
sf->g_lastVertexArrayObject = foo->m_VertexArrayObjects[sf->m_LastBufferIndex];
glBindVertexArrayOES(sf->g_lastVertexArrayObject);
glEnable(GL_BLEND);
glEnable(GL_TEXTURE_2D);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
sf->g_lastElementBuffer = -1;
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, foo->m_IndexBuffers[sf->m_LastBufferIndex]);
sf->g_lastInterleavedBuffer = -1;
glBindBuffer(GL_ARRAY_BUFFER, foo->m_InterleavedBuffers[sf->m_LastBufferIndex]);
glVertexPointer(3, GL_FLOAT, foo->m_Stride, (char *)NULL + (0));
glNormalPointer(GL_FLOAT, foo->m_Stride, (char *)(NULL) + (3 * sizeof(GLfloat)));
glTexCoordPointer(3, GL_FLOAT, foo->m_Stride, (char *)NULL + ((3 * sizeof(GLfloat)) + (3 * sizeof(GLfloat))));
}
if (foo->m_VertexArrayObjects[sf->m_LastBufferIndex] != sf->g_lastVertexArrayObject) {
sf->g_lastVertexArrayObject = foo->m_VertexArrayObjects[sf->m_LastBufferIndex];
glBindVertexArrayOES(sf->g_lastVertexArrayObject);
}
if (foo->m_IndexBuffers[sf->m_LastBufferIndex] != sf->g_lastElementBuffer) {
sf->g_lastElementBuffer = foo->m_IndexBuffers[sf->m_LastBufferIndex];
//TODO: figure out why this is redundant
//glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, sf->g_lastElementBuffer);
}
if (foo->m_InterleavedBuffers[sf->m_LastBufferIndex] != sf->g_lastInterleavedBuffer) {
sf->g_lastInterleavedBuffer = foo->m_InterleavedBuffers[sf->m_LastBufferIndex];
glBindBuffer(GL_ARRAY_BUFFER, sf->g_lastInterleavedBuffer);
}
#else
#ifndef USE_GLES2
if (!sf->m_EnabledStates) {
glEnable(GL_BLEND);
glEnable(GL_TEXTURE_2D);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
sf->m_EnabledStates = true;
}
if (foo->m_IndexBuffers[sf->m_LastBufferIndex] != sf->g_lastElementBuffer) {
sf->g_lastElementBuffer = foo->m_IndexBuffers[sf->m_LastBufferIndex];
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, sf->g_lastElementBuffer);
}
if (foo->m_InterleavedBuffers[sf->m_LastBufferIndex] != sf->g_lastInterleavedBuffer) {
sf->g_lastInterleavedBuffer = foo->m_InterleavedBuffers[sf->m_LastBufferIndex];
glBindBuffer(GL_ARRAY_BUFFER, sf->g_lastInterleavedBuffer);
}
glVertexPointer(3, GL_FLOAT, foo->m_Stride, (char *)NULL + (0));
glNormalPointer(GL_FLOAT, foo->m_Stride, (char *)(NULL) + (3 * sizeof(GLfloat)));
glTexCoordPointer(3, GL_FLOAT, foo->m_Stride, (char *)NULL + ((3 * sizeof(GLfloat)) + (3 * sizeof(GLfloat))));
#endif
#endif
size_t interleaved_element_buffer_size = (foo->m_NumBatched) * sizeof(GLshort);
size_t interleaved_buffer_size = (foo->m_NumBatched * foo->m_Stride);
glBufferSubData(GL_ARRAY_BUFFER, 0, interleaved_buffer_size, foo->m_ModelFoos);
glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, interleaved_element_buffer_size, foo->m_IndexFoo);
glDrawElements(GL_TRIANGLES, foo->m_NumBatched, GL_UNSIGNED_SHORT, (GLvoid*)((char*)NULL));
if (false) {
#ifndef USE_GLES2
glDisable(GL_TEXTURE_2D);
glColor4f(1.0, 1.0, 0.0, 1.0);
glPointSize(5.0);
glDrawElements(GL_POINTS, foo->m_NumBatched, GL_UNSIGNED_SHORT, (GLvoid*)((char*)NULL));
glColor4f(1.0, 1.0, 1.0, 1.0);
glEnable(GL_TEXTURE_2D);
#endif
}
sf->m_LastBufferIndex++;
if (sf->m_LastBufferIndex > (foo->m_BufferCount - 1)) {
sf->m_LastBufferIndex = 0;
}
foo->m_NumBatched = 0;
}
void Shape::CreateBuffers(const GLfloat *vertexBuffer, unsigned int vertexStride, unsigned int numVertices,
const GLushort *indexBuffer, unsigned int indexStride, unsigned int numIndices,
bool showDebugLines)
{
m_numVerts = numVertices;
m_numIndices = numIndices;
glGenVertexArraysOES(1, &m_vertexArrayObject);
glBindVertexArrayOES(m_vertexArrayObject);
glGenBuffers(1, &m_vertexBuffer);
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer);
glBufferData(GL_ARRAY_BUFFER, vertexStride * numVertices, vertexBuffer, 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));
glGenBuffers(1, &m_indexBuffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexStride * numIndices, indexBuffer, GL_STATIC_DRAW);
#if defined(DEBUG)
if(showDebugLines)
{
glBindVertexArrayOES(0);
// assume indexbuffer represents a TRIANGLES list
m_numDebugIndices = numIndices * 2;
GLushort* debugIndices = new GLushort[m_numDebugIndices];
unsigned int cur = 0;
unsigned int debugIndex = 0;
while(cur < numIndices)
{
assert((debugIndex +5) < m_numDebugIndices);
// edge 1
debugIndices[debugIndex] = indexBuffer[cur];
debugIndices[debugIndex+1] = indexBuffer[cur+1];
// edge 2
debugIndices[debugIndex+2] = indexBuffer[cur+1];
debugIndices[debugIndex+3] = indexBuffer[cur+2];
// edge 3
debugIndices[debugIndex+4] = indexBuffer[cur+2];
debugIndices[debugIndex+5] = indexBuffer[cur];
debugIndex += 6;
cur += 3;
}
if(sDebugShapeVerbose)
{
for(unsigned int i = 0; i < m_numDebugIndices; ++i)
{
std::cout << debugIndices[i] << std::endl;
}
}
glGenVertexArraysOES(1, &m_debugVAO);
glBindVertexArrayOES(m_debugVAO);
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer);
glBufferData(GL_ARRAY_BUFFER, vertexStride * numVertices, vertexBuffer, 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));
glGenBuffers(1, &m_debugIndexBuffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_debugIndexBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLushort) * m_numDebugIndices, debugIndices, GL_STATIC_DRAW);
delete [] debugIndices;
}
#endif
glBindVertexArrayOES(0);
}
VAO::VAO()
{
CHECK_FOR_GL_ERROR;
glGenVertexArraysOES(1, &_id);
CHECK_FOR_GL_ERROR;
}
/*----------------------------------------------------------------------------*\
External
\*----------------------------------------------------------------------------*/
void render_init(void)
{
char buffer[2048] = {0};
const vertex_t quad_vertices[] =
{
-0.5f, 0.5f, 0.0f, 0.0f, 0.0f, // TL
0.5f, 0.5f, 0.0f, 1.0f, 0.0f, // TR
0.5f, -0.5f, 0.0f, 1.0f, 1.0f, // BR
-0.5f, -0.5f, 0.0f, 0.0f, 1.0f, // BL
};
const vertex_t fullscreen_quad_vertices[] =
{
-1.0f, 1.0f, 0.0f, 0.0f, 0.0f, // TL
1.0f, 1.0f, 0.0f, 1.0f, 0.0f, // TR
1.0f, -1.0f, 0.0f, 1.0f, 1.0f, // BR
-1.0f, -1.0f, 0.0f, 0.0f, 1.0f, // BL
};
const uint16_t indices[] =
{
0, 1, 2,
3, 2, 0,
};
bind_location_t binds[] =
{
{ ATTRIB_POSITION, "position" },
{ ATTRIB_TEXCOORD, "tex" }
};
GLuint vertex_shader;
GLuint fragment_shader;
GLuint buffers[2] = {0};
#ifdef ANDROID
glGenBuffers( 2, &_meshes[MESH_FULLSCREEN] );
glBindBuffer( GL_ARRAY_BUFFER, _meshes[MESH_FULLSCREEN + VERTEX_BUFFER] );
glBufferData( GL_ARRAY_BUFFER, sizeof(fullscreen_quad_vertices), fullscreen_quad_vertices, GL_STATIC_DRAW );
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, _meshes[MESH_FULLSCREEN + INDEX_BUFFER] );
glBufferData( GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW );
glGenBuffers( 2, &_meshes[MESH_QUAD] );
glBindBuffer( GL_ARRAY_BUFFER, _meshes[MESH_QUAD + VERTEX_BUFFER] );
glBufferData( GL_ARRAY_BUFFER, sizeof(quad_vertices), quad_vertices, GL_STATIC_DRAW );
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _meshes[MESH_QUAD + INDEX_BUFFER] );
glBufferData( GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW );
#else
glGenVertexArraysOES(NUM_MESHES, _meshes);
glBindVertexArrayOES(_meshes[MESH_FULLSCREEN]);
glGenBuffers(2, buffers);
glBindBuffer(GL_ARRAY_BUFFER, buffers[0]);
glBufferData(GL_ARRAY_BUFFER, sizeof(fullscreen_quad_vertices), fullscreen_quad_vertices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[1]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(vertex_t), BUFFER_OFFSET(0));
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(vertex_t), BUFFER_OFFSET(12));
glBindVertexArrayOES(_meshes[MESH_QUAD]);
glGenBuffers(2, buffers);
glBindBuffer(GL_ARRAY_BUFFER, buffers[0]);
glBufferData(GL_ARRAY_BUFFER, sizeof(quad_vertices), quad_vertices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[1]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(vertex_t), BUFFER_OFFSET(0));
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(vertex_t), BUFFER_OFFSET(12));
glBindVertexArrayOES(0);
#endif
CNSLog("Loading shaders\n");
/* Create program */
if(system_load_file("assets/Shaders/Shader.vsh", buffer, sizeof(buffer))) {
CNSLog("Vertex shader load failed!\n");
return;
}
vertex_shader = render_create_shader(GL_VERTEX_SHADER, buffer);
if(system_load_file("assets/Shaders/Shader.fsh", buffer, sizeof(buffer))) {
CNSLog("Fragment shader load failed!\n");
return;
}
fragment_shader = render_create_shader(GL_FRAGMENT_SHADER, buffer);
_program = render_create_program(vertex_shader, fragment_shader, binds, 2);
_uniforms[UNIFORM_VIEWPROJECTION_MATRIX] = glGetUniformLocation(_program, "viewProjectionMatrix");
_uniforms[UNIFORM_WORLD_MATRIX] = glGetUniformLocation(_program, "worldMatrix");
_uniforms[UNIFORM_TEXTURE] = glGetUniformLocation(_program, "diffuseTexture");
_uniforms[UNIFORM_COLOR] = glGetUniformLocation(_program, "color");
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengles_OESVertexArrayObject_nglGenVertexArraysOES__IJ(JNIEnv *__env, jclass clazz, jint n, jlong arraysAddress) {
glGenVertexArraysOESPROC glGenVertexArraysOES = (glGenVertexArraysOESPROC)tlsGetFunction(799);
intptr_t arrays = (intptr_t)arraysAddress;
UNUSED_PARAM(clazz)
glGenVertexArraysOES(n, arrays);
}
unsigned int OpenglES2Device::generateVaoBuffer(){
unsigned int handle;
glGenVertexArraysOES( 1, &handle);
this->evaluateErrorsAndLog("generateVaoBuffer(1)");
return handle;
}
TriListStaticES2()
{
m_numVerts = 0;
glGenVertexArraysOES(1, &m_vertexArray);
glGenBuffers(1, &m_vertexBuffer);
}
//获取obj文件，再获取该文件的网格
void templateAppInit( int width, int height ) {
atexit( templateAppExit );
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 = 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 ]; //里面包含多个obj文件的实体
//计算顶点数据数组的总大小，以便可以分配为VBO构建GLES友好的顶点数据数组所需的内存大小
size = objmesh->n_objvertexdata * sizeof( vec3 ) * sizeof( vec3 );
vertex_array = ( unsigned char * ) malloc( size );
vertex_start = vertex_array;
//根据索引的顶点位置以及objmesh结构中包含的顶点法线构建顶点数据数组
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 );
++i;
}
//请求驱动程序为VBO创建一个新的缓冲区索引，并使其处于活动状态
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 );
//----------------------------------------------------
//为第一个objmesh三角形列表创建一个新id，并使当前索引处于活动状态
glGenBuffers( 1, &objmesh->objtrianglelist[ 0 ].vbo );
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER,
objmesh->objtrianglelist[ 0 ].vbo );
//以类似发送数组缓冲区的方式，将该索引数组发送到GPU
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 );
//创建VAO
//计算不同顶点数据之间的顶点数组跨度
unsigned char attribute;
stride = sizeof( vec3 )+
sizeof( vec3 );
//创建一个新的VAO索引，并使其保持活动状态
glGenVertexArraysOES( 1, &objmesh->vao );
glBindVertexArrayOES( objmesh->vao );
//开始构建VAO列表绑定，其中包括相关的调用来设置数组缓冲区
glBindBuffer( GL_ARRAY_BUFFER, objmesh->vbo );
//在VAO列表中包括POSITION顶点属性调用
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 ) ) );
//在关闭VAO列表之前绑定数组元素缓冲区（索引）
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER,
objmesh->objtrianglelist[ 0 ].vbo );
//停用当前的VAO，其次对前面所调用的类似数组的所有命令进行编译，然后将它们与VAO索引相关亮
glBindVertexArrayOES( 0 );
}
bool IMaterial::FrameBufferInit()
{
GLint viewport[4];
glGetIntegerv(GL_VIEWPORT, viewport);
m_fViewportWidth = viewport[2];
m_fViewportHeight = viewport[3];
glGenFramebuffers(1, &m_gFB);
glBindFramebuffer(GL_FRAMEBUFFER, m_gFB);
glGenTextures(1, &m_gMainTexFrameBuffer);
glBindTexture(GL_TEXTURE_2D, m_gMainTexFrameBuffer);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_fViewportWidth, m_fViewportHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
// glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_gMainTexFrameBuffer, 0);
glBindTexture(GL_TEXTURE_2D, 0);
glGenRenderbuffers(1, &m_gRB);
glBindRenderbuffer(GL_RENDERBUFFER, m_gRB);
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8_OES, m_fViewportWidth, m_fViewportHeight);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_gRB);
glGenRenderbuffers(1, &m_gRBDepth);
glBindRenderbuffer(GL_RENDERBUFFER, m_gRBDepth);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, m_fViewportWidth, m_fViewportHeight);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_gRBDepth);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
// glEnable(GL_DEPTH_TEST);
// glDepthFunc(GL_LESS);
// glDepthMask(GL_TRUE);
// glDepthRangef(0.0f, 1.0f);
// glClearDepthf(1.0f);
glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
__LOG("Faild to create frame buffer");
return false;
}
glGenVertexArraysOES(1, &m_gVAO);
glBindVertexArrayOES(m_gVAO);
glGenBuffers(1, &m_gVBO);
glBindBuffer(GL_ARRAY_BUFFER, m_gVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(quad), quad, GL_STATIC_DRAW);
glEnableVertexAttribArray(SAL_POSITION);
glVertexAttribPointer(SAL_POSITION, 3, GL_FLOAT, GL_FALSE, sizeof(float_t) * 5, 0);
glEnableVertexAttribArray(SAL_TEXTURE_COORD);
glVertexAttribPointer(SAL_TEXTURE_COORD, 2, GL_FLOAT, GL_FALSE, sizeof(float_t) * 5, (char*)NULL + (sizeof(float_t) * 3));
glBindVertexArrayOES(0);
glBindFramebuffer(GL_FRAMEBUFFER, Globals::GetDefaultFramebuffer());
//glBindFramebuffer(GL_FRAMEBUFFER, m_gFB);
return true;
}
// ビルド
void Figure::build() {
// LOGD("Figure::build");
// ビルド済みの場合は無視
// if (vaoName) {
// return;
// }
// Create a vertex array object (VAO)
#ifdef USE_VAO
glGenVertexArraysOES(1, &vaoName);
glBindVertexArrayOES(vaoName);
#else
vaoName = 1;
#endif
// 頂点
vboNames[VBO_VERTEX] = buildVBO(&vertices.front(),
vertices.size() * sizeof(float), GL_ARRAY_BUFFER);
enableAttribute(ATTRIB_VERTEX);
// 法線
if (!normals.empty()) {
vboNames[VBO_NORMAL] = buildVBO(&normals.front(),
normals.size() * sizeof(float), GL_ARRAY_BUFFER);
enableAttribute(ATTRIB_NORMAL);
hasNormals = true;
}
// テクスチャ
if (!textureCoords.empty()) {
vboNames[VBO_TEXCOORD] = buildVBO(&textureCoords.front(),
textureCoords.size() * sizeof(float), GL_ARRAY_BUFFER);
enableAttribute(ATTRIB_TEXCOORD);
hasTexture = true;
}
// ジョイント
if (!jointData.empty()) {
vboNames[VBO_JOINTS] = buildVBO(&jointData.front(),
jointData.size() * sizeof(float), GL_ARRAY_BUFFER);
enableAttribute(ATTRIB_JOINTS);
hasJoint = true;
}
// 頂点の番号
if (useIndex) {
std::vector<short> count;
for (int i = 0; i < vertices.size() / 3; i++) {
count.push_back(i);
}
vboNames[VBO_INDEX] = buildVBO(&count.front(), count.size() * sizeof(unsigned short), GL_ARRAY_BUFFER);
}
// インデックス
enableAttribute(ATTRIB_INDEX);
vboNames[VBO_ELEMENT] = buildVBO(&vertexIndexes.front(),
vertexIndexes.size() * sizeof(unsigned short), GL_ELEMENT_ARRAY_BUFFER);
// サイズ計算
int cnt = vertices.size()/3;
float maxx = -FLT_MAX, minx = FLT_MAX;
float maxy = -FLT_MAX, miny = FLT_MAX;
float maxz = -FLT_MAX, minz = FLT_MAX;
for (int i = 0; i < cnt; i++) {
int idx = i * 3;
float x = vertices[idx];
float y = vertices[idx+1];
float z = vertices[idx+2];
if (maxx < x) maxx = x;
if (minx > x) minx = x;
if (maxy < y) maxy = y;
if (miny > y) miny = y;
if (maxz < z) maxz = z;
if (minz > z) minz = z;
}
size.x = maxx - minx;
size.y = maxy - miny;
size.z = maxz - minz;
// LOGD("size:%f,%f,%f", size.x, size.y, size.z);
// LOGD("Figure::build:end");
}
bool CMaterialGlow::Init(SMaterialData* Data)
{
if (Data == nullptr)
return false;
// static float_t quad[30] =
// {
// -1.0f, -1.0f, 0.0f, 0.0f, 0.0f,
// 1.0f, -1.0f, 0.0f, 1.0f, 0.0f,
// 1.0f, 1.0f, 0.0f, 1.0f, 1.0f,
// -1.0f, -1.0f, 0.0f, 0.0f, 0.0f,
// 1.0f, 1.0f, 0.0f, 1.0f, 1.0f,
// -1.0f, 1.0f, 0.0f, 0.0f, 1.0f
// };
GLint viewport[4];
glGetIntegerv(GL_VIEWPORT, viewport);
m_gTextureWidth = viewport[2];
m_gTextureHeight = viewport[3];
//
// glGenTextures(1, &m_gTexture);
//
// glBindTexture(GL_TEXTURE_2D, m_gTexture);
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
//
// if (!loadBmpImage(data->TextureFileName.c_str()))
// return false;
glGenFramebuffers(1, &m_gFB);
glGenRenderbuffers(1, &m_gRB);
glGenTextures(2, m_gTexture);
glBindTexture(GL_TEXTURE_2D, m_gTexture[0]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_gTextureWidth, m_gTextureHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glBindTexture(GL_TEXTURE_2D, m_gTexture[1]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_gTextureWidth, m_gTextureHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glBindTexture(GL_TEXTURE_2D, 0);
glBindRenderbuffer(GL_RENDERBUFFER, m_gRB);
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8_OES, m_gTextureWidth, m_gTextureHeight);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
glBindFramebuffer(GL_FRAMEBUFFER, m_gFB);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_gRB);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
__LOG("Faild to create frame buffer");
return false;
}
glBindFramebuffer(GL_FRAMEBUFFER, Globals::GetDefaultFramebuffer());
glGenVertexArraysOES(1, &m_gVAO);
glBindVertexArrayOES(m_gVAO);
glGenBuffers(1, &m_gVBO);
glBindBuffer(GL_ARRAY_BUFFER, m_gVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(quad), quad, GL_STATIC_DRAW);
glEnableVertexAttribArray(SAL_POSITION);
glVertexAttribPointer(SAL_POSITION, 3, GL_FLOAT, GL_FALSE, sizeof(float_t) * 5, 0);
glEnableVertexAttribArray(SAL_TEXTURE_COORD);
glVertexAttribPointer(SAL_TEXTURE_COORD, 2, GL_FLOAT, GL_FALSE, sizeof(float_t) * 5, (char*)NULL + (sizeof(float_t) * 3));
glBindVertexArrayOES(0);
return true;
}
VaoImplEs::VaoImplEs()
{
mId = 0;
glGenVertexArraysOES( 1, &mId );
}
