void Renderable::Render()
{
BindBuffer(GL_ARRAY_BUFFER, __shader->vertexBuffer, _mesh->VertexData(), 3, GL_DYNAMIC_DRAW, __shader->vertex);
BindBuffer(GL_ARRAY_BUFFER, __shader->normalBuffer, _mesh->NormalData(), 3, GL_DYNAMIC_DRAW, __shader->normal);
BindBuffer(GL_ARRAY_BUFFER, __shader->colorBuffer, *_colorData, 4, GL_STATIC_DRAW, __shader->color);
BindBuffer(GL_ELEMENT_ARRAY_BUFFER, __shader->indexBuffer, _mesh->IndexData(), 1, GL_STATIC_DRAW, -1);
glDrawElements(_mesh->DrawMode(), _mesh->IndexData().size(), GL_UNSIGNED_INT, NULL);
}
int
rb_vertex_attrib_array
(struct rb_vertex_array* array,
struct rb_buffer* buffer,
int count,
const struct rb_buffer_attrib* attrib)
{
intptr_t offset = 0;
int i = 0;
int err = 0;
if(!array
|| !buffer
|| !attrib
|| count < 0
|| buffer->target != GL_ARRAY_BUFFER)
goto error;
OGL(BindVertexArray(array->name));
OGL(BindBuffer(buffer->target, buffer->name));
for(i=0; i < count; ++i) {
if(attrib[i].type == RB_UNKNOWN_TYPE) {
OGL(BindBuffer
(buffer->target,
array->ctxt->state_cache.buffer_binding[buffer->binding]));
goto error;
}
offset = attrib[i].offset;
OGL(EnableVertexAttribArray(attrib[i].index));
OGL(VertexAttribPointer
(attrib[i].index,
ogl3_attrib_nb_components(attrib[i].type),
GL_FLOAT,
GL_FALSE,
attrib[i].stride,
(void*)offset));
}
OGL(BindVertexArray(array->ctxt->state_cache.vertex_array_binding));
OGL(BindBuffer
(buffer->target, array->ctxt->state_cache.buffer_binding[buffer->binding]));
exit:
return err;
error:
err = -1;
goto exit;
}
int
rb_vertex_index_array(struct rb_vertex_array* array, struct rb_buffer* buffer)
{
if(!array || (buffer && buffer->target != GL_ELEMENT_ARRAY_BUFFER))
return -1;
OGL(BindVertexArray(array->name));
OGL(BindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer ? buffer->name : 0));
OGL(BindVertexArray(array->ctxt->state_cache.vertex_array_binding));
OGL(BindBuffer
(GL_ELEMENT_ARRAY_BUFFER,
array->ctxt->state_cache.buffer_binding[RB_OGL3_BIND_INDEX_BUFFER]));
return 0;
}
//-----------------------------------------------------------------------
void GraphicsContextGL4::DrawIndexedInstanced(
std::size_t indexCount,
std::size_t instanceCount)
{
ApplyPipelineState();
// Bind index buffer
POMDOG_ASSERT(indexBuffer);
auto indexBufferGL = dynamic_cast<IndexBufferGL4*>(indexBuffer->NativeIndexBuffer());
POMDOG_ASSERT(indexBufferGL != nullptr);
indexBufferGL->BindBuffer();
// Draw
POMDOG_ASSERT(indexCount > 0);
POMDOG_ASSERT(indexCount <= indexBuffer->IndexCount());
POMDOG_ASSERT(instanceCount > 0);
POMDOG_ASSERT(instanceCount < static_cast<decltype(instanceCount)>(std::numeric_limits<GLsizei>::max()));
glDrawElementsInstanced(
primitiveTopology.value,
static_cast<GLsizei>(indexCount),
ToIndexElementType(indexBuffer->ElementSize()),
nullptr,
static_cast<GLsizei>(instanceCount));
POMDOG_CHECK_ERROR_GL4("glDrawElementsInstanced");
}
static uint32_t setup_quad_index_buffer(const GrGLInterface* gl) {
static const int kMaxQuads = 1;//1 << 12; // max possible: (1 << 14) - 1;
GR_STATIC_ASSERT(4 * kMaxQuads <= 65535);
static const uint16_t kPattern[] = { 0, 1, 2, 0, 2, 3 };
static const int kPatternSize = 6;
static const int kVertCount = 4;
static const int kIndicesCount = kPatternSize * kMaxQuads;
int size = kPatternSize * kMaxQuads * sizeof(uint16_t);
uint16_t* data = SkNEW_ARRAY(uint16_t, kMaxQuads * kPatternSize);
for (int i = 0; i < kMaxQuads; ++i) {
int baseIdx = i * kPatternSize;
uint16_t baseVert = (uint16_t)(i * kVertCount);
for (int j = 0; j < kPatternSize; ++j) {
data[baseIdx+j] = baseVert + kPattern[j];
}
}
GrGLuint quadIBO;
GR_GL_CALL(gl, GenBuffers(1, &quadIBO));
GR_GL_CALL(gl, BindBuffer(GR_GL_ELEMENT_ARRAY_BUFFER, quadIBO));
GR_GL_CALL(gl, BufferData(GR_GL_ELEMENT_ARRAY_BUFFER, size, data, GR_GL_STATIC_DRAW));
SkDELETE_ARRAY(data);
return kIndicesCount;
}
void GLCpuPosInstancedArraysBench::setupSingleVbo(const GrGLInterface* gl,
const SkMatrix* viewMatrices) {
// Constants for our various shader programs
Vertex vertices[kVerticesPerTri * kNumTri];
for (uint32_t i = 0; i < kNumTri; i++) {
Vertex* v = &vertices[i * kVerticesPerTri];
v[0].fPositions.set(-1.0f, -1.0f);
v[1].fPositions.set( 1.0f, -1.0f);
v[2].fPositions.set( 1.0f, 1.0f);
SkPoint* position = reinterpret_cast<SkPoint*>(v);
viewMatrices[i].mapPointsWithStride(position, sizeof(Vertex), kVerticesPerTri);
// set colors
float color = i == kNumTri - 1 ? 1.0f : 0.0f;
for (uint32_t j = 0; j < kVerticesPerTri; j++) {
uint32_t offset = 0;
v->fColors[offset++] = color; v->fColors[offset++] = 0.0f; v->fColors[offset++] = 0.0f;
v++;
}
}
GrGLuint vbo;
// setup VBO
GR_GL_CALL(gl, GenBuffers(1, &vbo));
GR_GL_CALL(gl, BindBuffer(GR_GL_ARRAY_BUFFER, vbo));
GR_GL_CALL(gl, EnableVertexAttribArray(0));
GR_GL_CALL(gl, EnableVertexAttribArray(1));
GR_GL_CALL(gl, VertexAttribPointer(0, 2, GR_GL_FLOAT, GR_GL_FALSE, sizeof(Vertex),
(GrGLvoid*)0));
GR_GL_CALL(gl, VertexAttribPointer(1, 3, GR_GL_FLOAT, GR_GL_FALSE, sizeof(Vertex),
(GrGLvoid*)(sizeof(SkPoint))));
GR_GL_CALL(gl, BufferData(GR_GL_ARRAY_BUFFER, sizeof(vertices), vertices, GR_GL_STATIC_DRAW));
fBuffers.push_back(vbo);
}
int
rb_ogl3_bind_buffer
(struct rb_context* ctxt,
struct rb_buffer* buffer,
enum rb_ogl3_buffer_target target)
{
GLenum current_name = 0;
GLenum name = 0;
int err = 0;
if(!ctxt || (buffer && (buffer->binding != target)))
goto error;
current_name = ctxt->state_cache.buffer_binding[target];
name = buffer ? buffer->name : 0;
if(current_name != name) {
OGL(BindBuffer(rb_to_ogl3_buffer_target(target), name));
ctxt->state_cache.buffer_binding[target] = name;
}
exit:
return err;
error:
err = -1;
goto exit;
}
void GLVec4ScalarBench::teardown(const GrGLInterface* gl) {
GR_GL_CALL(gl, BindBuffer(GR_GL_ARRAY_BUFFER, 0));
GR_GL_CALL(gl, BindTexture(GR_GL_TEXTURE_2D, 0));
GR_GL_CALL(gl, BindFramebuffer(GR_GL_FRAMEBUFFER, 0));
GR_GL_CALL(gl, DeleteTextures(1, &fFboTextureId));
GR_GL_CALL(gl, DeleteProgram(fProgram));
GR_GL_CALL(gl, DeleteBuffers(1, &fVboId));
}
void GL3CharacterRenderer::buildHead() {
GL(GenVertexArrays(1, &headVao));
GL(GenBuffers(1, &headVbo));
GL(BindVertexArray(headVao));
GL(BindBuffer(GL_ARRAY_BUFFER, headVbo));
GL(VertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 40, 0));
GL(VertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 40, (void *) 12));
GL(VertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, 40, (void *) 24));
GL(EnableVertexAttribArray(0));
GL(EnableVertexAttribArray(1));
GL(EnableVertexAttribArray(2));
GL(BindVertexArray(0));
VertexData vertexData[36];
int vertexIndices[6] = {0, 1, 2, 0, 2, 3};
int index = 0;
for (int d = 0; d < 6; d++) {
vec3f normal(0.0);
normal[d % 3] = DIRS[d][d % 3];
vec3f vertices[4];
for (int i = 0; i < 4; i++) {
vertices[i] = vec3f(
(DIR_QUAD_CORNER_CYCLES_3D[d][i][0] - 0.5f) * HEAD_SIZE[0],
(DIR_QUAD_CORNER_CYCLES_3D[d][i][1] - 0.5f) * HEAD_SIZE[1],
(DIR_QUAD_CORNER_CYCLES_3D[d][i][2] - 0.5f) * HEAD_SIZE[2] + HEAD_Z_OFFSET
) * (1.0f / RESOLUTION);
}
for (int j = 0; j < 6; j++) {
vertexData[index].xyz[0] = vertices[vertexIndices[j]][0];
vertexData[index].xyz[1] = vertices[vertexIndices[j]][1];
vertexData[index].xyz[2] = vertices[vertexIndices[j]][2];
vertexData[index].nxyz[0] = normal[0];
vertexData[index].nxyz[1] = normal[1];
vertexData[index].nxyz[2] = normal[2];
vertexData[index].rgba[0] = CHARACTER_COLOR[0];
vertexData[index].rgba[1] = CHARACTER_COLOR[1];
vertexData[index].rgba[2] = CHARACTER_COLOR[2];
vertexData[index].rgba[3] = 1.0f;
index++;
}
}
GL(BufferData(GL_ARRAY_BUFFER, sizeof(vertexData), vertexData, GL_STATIC_DRAW));
GL(BindBuffer(GL_ARRAY_BUFFER, 0));
}
static void SetAttributeFormat( const VertexAttribute* pAttr, unsigned int numAttr, unsigned int v_offset)
{
GLenum type = GL_FLOAT;
unsigned int currentVBO = GetCurrentBuffer(GL_ARRAY_BUFFER_BINDING);
unsigned int i;
TransferAndDraw();
if(vtx.n_vertices != 0){
printf("ermergerd");
}
BindVAO();
for(i=0;i<10;i++)glDisableVertexAttribArray(i);
for(i=0; i<numAttr; i++)
{
if(pAttr[i].vbo != 0)
BindBuffer(GL_ARRAY_BUFFER, pAttr[i].vbo);
glEnableVertexAttribArray(pAttr[i].idx);
glVertexAttribDivisor(pAttr[i].idx, pAttr[i].divisor);
switch(pAttr[i].type)
{
default:
case STREAM_FLOAT:
case STREAM_UCHAR:
glVertexAttribPointer(pAttr[i].idx, pAttr[i].size, enumToGLAttribType[ pAttr[i].type ], pAttr[i].normalized, pAttr[i].stride, BUFFER_OFFSET(v_offset + pAttr[i].offset));
break;
case STREAM_CHAR:
case STREAM_SHORT:
case STREAM_INT:
glVertexAttribIPointer(pAttr[i].idx, pAttr[i].size, enumToGLAttribType[ pAttr[i].type ], pAttr[i].stride, BUFFER_OFFSET(v_offset + pAttr[i].offset));
break;
}
if(pAttr[i].vbo != 0)
BindBuffer(GL_ARRAY_BUFFER, currentVBO);
}
UnbindVAO();
}
void GLCpuPosInstancedArraysBench::teardown(const GrGLInterface* gl) {
GR_GL_CALL(gl, BindBuffer(GR_GL_ARRAY_BUFFER, 0));
GR_GL_CALL(gl, BindVertexArray(0));
GR_GL_CALL(gl, BindTexture(GR_GL_TEXTURE_2D, 0));
GR_GL_CALL(gl, BindFramebuffer(GR_GL_FRAMEBUFFER, 0));
GR_GL_CALL(gl, DeleteTextures(1, &fTexture));
GR_GL_CALL(gl, DeleteProgram(fProgram));
GR_GL_CALL(gl, DeleteBuffers(fBuffers.count(), fBuffers.begin()));
GR_GL_CALL(gl, DeleteVertexArrays(1, &fVAO));
fBuffers.reset();
}
void GLCpuPosInstancedArraysBench::setupInstanceVbo(const GrGLInterface* gl,
const SkMatrix* viewMatrices) {
// We draw all of the instances at a single place because we aren't allowed to have per vertex
// per instance attributes
SkPoint positions[kVerticesPerTri];
positions[0].set(-1.0f, -1.0f);
positions[1].set( 1.0f, -1.0f);
positions[2].set( 1.0f, 1.0f);
viewMatrices[0].mapPointsWithStride(positions, sizeof(SkPoint), kVerticesPerTri);
// setup colors so we can detect we are actually drawing instances(the last triangle will be
// a different color)
GrGLfloat colors[kVerticesPerTri * kNumTri];
for (uint32_t i = 0; i < kNumTri; i++) {
// set colors
uint32_t offset = i * kVerticesPerTri;
float color = i == kNumTri - 1 ? 1.0f : 0.0f;
colors[offset++] = color; colors[offset++] = 0.0f; colors[offset++] = 0.0f;
}
GrGLuint posVBO;
// setup position VBO
GR_GL_CALL(gl, GenBuffers(1, &posVBO));
GR_GL_CALL(gl, BindBuffer(GR_GL_ARRAY_BUFFER, posVBO));
GR_GL_CALL(gl, BufferData(GR_GL_ARRAY_BUFFER, sizeof(positions), positions, GR_GL_STATIC_DRAW));
GR_GL_CALL(gl, EnableVertexAttribArray(0));
GR_GL_CALL(gl, VertexAttribPointer(0, 2, GR_GL_FLOAT, GR_GL_FALSE, 2 * sizeof(GrGLfloat),
(GrGLvoid*)0));
// setup color VBO
GrGLuint instanceVBO;
GR_GL_CALL(gl, GenBuffers(1, &instanceVBO));
GR_GL_CALL(gl, BindBuffer(GR_GL_ARRAY_BUFFER, instanceVBO));
GR_GL_CALL(gl, BufferData(GR_GL_ARRAY_BUFFER, sizeof(colors), colors, GR_GL_STATIC_DRAW));
GR_GL_CALL(gl, EnableVertexAttribArray(1));
GR_GL_CALL(gl, VertexAttribPointer(1, 3, GR_GL_FLOAT, GR_GL_FALSE, 3 * sizeof(GrGLfloat),
(GrGLvoid*)0));
GR_GL_CALL(gl, VertexAttribDivisor(1, 1));
fBuffers.push_back(posVBO);
fBuffers.push_back(instanceVBO);
}
GrGLAttribArrayState* GrGLVertexArray::bindWithIndexBuffer(const GrGLIndexBuffer* buffer) {
GrGLAttribArrayState* state = this->bind();
if (NULL != state && NULL != buffer) {
GrGLuint bufferID = buffer->bufferID();
if (!fIndexBufferIDIsValid || bufferID != fIndexBufferID) {
GL_CALL(BindBuffer(GR_GL_ELEMENT_ARRAY_BUFFER, bufferID));
fIndexBufferIDIsValid = true;
fIndexBufferID = bufferID;
}
}
return state;
}
void GLCpuPosInstancedArraysBench::setupDoubleVbo(const GrGLInterface* gl,
const SkMatrix* viewMatrices) {
// Constants for our various shader programs
SkPoint positions[kVerticesPerTri * kNumTri];
GrGLfloat colors[kVerticesPerTri * kNumTri * 3];
for (uint32_t i = 0; i < kNumTri; i++) {
SkPoint* position = &positions[i * kVerticesPerTri];
position[0].set(-1.0f, -1.0f);
position[1].set( 1.0f, -1.0f);
position[2].set( 1.0f, 1.0f);
viewMatrices[i].mapPointsWithStride(position, sizeof(SkPoint), kVerticesPerTri);
// set colors
float color = i == kNumTri - 1 ? 1.0f : 0.0f;
uint32_t offset = i * kVerticesPerTri * 3;
for (uint32_t j = 0; j < kVerticesPerTri; j++) {
colors[offset++] = color; colors[offset++] = 0.0f; colors[offset++] = 0.0f;
}
}
GrGLuint posVBO, colorVBO;
// setup position VBO
GR_GL_CALL(gl, GenBuffers(1, &posVBO));
GR_GL_CALL(gl, BindBuffer(GR_GL_ARRAY_BUFFER, posVBO));
GR_GL_CALL(gl, EnableVertexAttribArray(0));
GR_GL_CALL(gl, VertexAttribPointer(0, 2, GR_GL_FLOAT, GR_GL_FALSE, 2 * sizeof(GrGLfloat),
(GrGLvoid*)0));
GR_GL_CALL(gl, BufferData(GR_GL_ARRAY_BUFFER, sizeof(positions), positions, GR_GL_STATIC_DRAW));
// setup color VBO
GR_GL_CALL(gl, GenBuffers(1, &colorVBO));
GR_GL_CALL(gl, BindBuffer(GR_GL_ARRAY_BUFFER, colorVBO));
GR_GL_CALL(gl, EnableVertexAttribArray(1));
GR_GL_CALL(gl, VertexAttribPointer(1, 3, GR_GL_FLOAT, GR_GL_FALSE, 3 * sizeof(GrGLfloat),
(GrGLvoid*)0));
GR_GL_CALL(gl, BufferData(GR_GL_ARRAY_BUFFER, sizeof(colors), colors, GR_GL_STATIC_DRAW));
fBuffers.push_back(posVBO);
fBuffers.push_back(colorVBO);
}
/*******************************************************************************
*
* Private functions.
*
******************************************************************************/
int
rb_ogl3_create_buffer
(struct rb_context* ctxt,
const struct rb_ogl3_buffer_desc* desc,
const void* init_data,
struct rb_buffer** out_buffer)
{
struct rb_buffer* buffer = NULL;
if(!ctxt
|| !desc
|| !out_buffer
|| (desc->target == RB_OGL3_NB_BUFFER_TARGETS)
|| (desc->usage == RB_USAGE_IMMUTABLE && init_data == NULL))
return -1;
buffer = MEM_ALLOC(ctxt->allocator, sizeof(struct rb_buffer));
if(!buffer)
return -1;
ref_init(&buffer->ref);
RB(context_ref_get(ctxt));
buffer->ctxt = ctxt;
buffer->target = rb_to_ogl3_buffer_target(desc->target);
buffer->usage = rb_to_ogl3_usage(desc->usage);
buffer->size = (GLsizei)desc->size;
buffer->binding = desc->target;
OGL(GenBuffers(1, &buffer->name));
OGL(BindBuffer(buffer->target, buffer->name));
OGL(BufferData(buffer->target, buffer->size, init_data, buffer->usage));
OGL(BindBuffer
(buffer->target,
ctxt->state_cache.buffer_binding[buffer->binding]));
*out_buffer = buffer;
return 0;
}
void Model::Draw(const Matrix4f& transform) const
{
if (_vbuffer == 0)
return;
auto video = _context->GetModule<Video>();
if (!video->BindBuffer(_vbuffer, Vertex3::DECLARE.size, Vertex3::DECLARE.types, Vertex3::DECLARE.count))
return;
glPushMatrix();
glMultMatrixf(transform.GetData());
video->BindTexture(_texture);
if (_ibuffer && video->BindBuffer(_ibuffer, 0, 0, 0))
{
video->DrawIndexedPrimitives(_topology, _icount, VALUE_USHORT);
video->UnbindBuffer(_ibuffer, 0, 0);
}
else video->DrawPrimitives(_topology, _vcount, 0);
glPopMatrix();
video->UnbindBuffer(_vbuffer, Vertex3::DECLARE.types, Vertex3::DECLARE.count);
}
//ray tracing
void CPURayTracer::RayTrace()
{
//reset the timer
m_Timer.Reset();
//start the timer
m_Timer.Start();
//bind the buffer
BindBuffer();
for( int j = m_iImageHeight - 1 ; j > -1 ; j-- )
{
for( int i = 0 ; i < m_iImageWidth; i++ )
{
//current index
int currentIndex = j * m_iImageWidth + i;
//current ray
_float4 dir , ori;
//generate a ray for current pixel
GenerateRay( i , j , &ori , &dir );
//copy the image
m_pImageBackBuffer[ currentIndex ] = Trace( ori , dir );
//copy the image
m_pImageBuffer[ currentIndex ] = RGB_FLOAT4( m_pImageBackBuffer[ currentIndex ] );
//update current pixel number
m_iCurrentPixelNum++;
if( m_bForceStop )
break;
}
if( m_bForceStop )
break;
}
//clear the noise
ClearNoise( m_pImageBackBuffer );
//end the timer
m_Timer.Stop();
m_ElapsedTime = (int)m_Timer.GetElapsedTime();
}
static void
release_buffer(struct ref* ref)
{
struct rb_buffer* buffer = NULL;
struct rb_context* ctxt = NULL;
ASSERT(ref);
buffer = CONTAINER_OF(ref, struct rb_buffer, ref);
ctxt = buffer->ctxt;
if(buffer->name == ctxt->state_cache.buffer_binding[buffer->binding])
OGL(BindBuffer(buffer->target, 0));
OGL(DeleteBuffers(1, &buffer->name));
MEM_FREE(ctxt->allocator, buffer);
RB(context_ref_put(ctxt));
}
CMemoryBuffer CHardwareTextureBuffer::LockSource(size_t offset, size_t length, THardwareBufferLock opt)
{
nova::byte *mapper = NULL;
CMemoryBuffer result;
if((offset + length) > mSize)
throw NOVA_EXP("HardwareVertexBuffer::LockSource(): Calling length and size very large..", BAD_OPERATION);
BindBuffer();
GLenum method;
if(mUsage == GL_PIXEL_UNPACK_BUFFER_ARB)
{
// Note that glMapBufferARB() causes sync issue.
// If GPU is working with this buffer, glMapBufferARB() will wait(stall)
// until GPU to finish its job. To avoid waiting (idle), you can call
// first glBufferDataARB() with NULL pointer before glMapBufferARB().
// If you do that, the previous data in PBO will be discarded and
// glMapBufferARB() returns a new allocated pointer immediately
// even if GPU is still working with the previous data.
glBufferDataARB(mUsage, mSize, 0, GL_STREAM_DRAW_ARB);
method = GL_WRITE_ONLY_ARB;
}
else
method = GL_READ_ONLY_ARB;
if((mapper = static_cast<nova::byte *>(glMapBufferARB(mUsage, method))) != NULL)
{
mapper += offset;
CMemoryBuffer res(mapper, length);
result = res;
}
else
{
UnbindBuffer();
throw NOVA_EXP("HardwareVertexBuffer::LockSource(): Can not map v-buffer memory..", BAD_OPERATION);
}
//UnbindBuffer();
return result;
}
//---------------------------------------------------------------------------------------------------------
handle IndicesBufferResourceGL::_DoCreateBuffer( uint datasize, uint typesize, const void* dataptr, BufferObjectStatus::MemoryUseage use )
{
handle h;
glGenBuffers(1, &h);
CHECK_ERROR_RENDER;
BindBuffer();
switch( use )
{
case BufferObjectStatus::MU_STATIC:
glBufferData(GL_ELEMENT_ARRAY_BUFFER, datasize*typesize, dataptr, GL_STATIC_DRAW);
break;
case BufferObjectStatus::MU_DYNAMIC:
glBufferData(GL_ELEMENT_ARRAY_BUFFER, datasize*typesize, dataptr, GL_DYNAMIC_DRAW);
break;
}
CHECK_ERROR_RENDER;
return h;
}
void GLInstancedArraysBench::onPerCanvasPostDraw(SkCanvas* canvas) {
// This bench exclusively tests GL calls directly
const GrGLContext* ctx = get_gl_context(canvas);
if (!ctx) {
return;
}
const GrGLInterface* gl = ctx->interface();
// teardown
GR_GL_CALL(gl, BindBuffer(GR_GL_ARRAY_BUFFER, 0));
GR_GL_CALL(gl, BindVertexArray(0));
GR_GL_CALL(gl, BindTexture(GR_GL_TEXTURE_2D, 0));
GR_GL_CALL(gl, BindFramebuffer(GR_GL_FRAMEBUFFER, 0));
GR_GL_CALL(gl, DeleteTextures(1, &fTexture));
this->teardown(gl);
}
Buffer::Buffer(GraphicsDevice* graphicsDevice,BufferType bufferType, BufferUsage bufferUsage,
unsigned int elementSize, unsigned int numberOfElements,
GLvoid* bufferData): _graphicsDevice(graphicsDevice),
_bufferType(bufferType), _bufferUsage(bufferUsage),
_buffer(0), _stride(0),
_elementSize(elementSize), _numberOfElements(numberOfElements)
{
//Generate the buffer
_graphicsDevice->GenerateBuffers(1, &_buffer);
//Bind the buffer to the context
BindBuffer();
//Set the buffer data
_graphicsDevice->SetBufferData(_bufferType, (_elementSize * _numberOfElements), bufferData, _bufferUsage);
//Unbind the buffer
UnbindBuffer();
}
void GLVec4ScalarBench::setupSingleVbo(const GrGLInterface* gl, const SkMatrix* viewMatrices) {
// triangles drawn will alternate between the top-right half of the screen and the bottom-left
// half of the screen
Vertex vertices[kVerticesPerTri * kNumTriPerDraw];
for (uint32_t i = 0; i < kNumTriPerDraw; i++) {
Vertex* v = &vertices[i * kVerticesPerTri];
if (i % 2 == 0) {
v[0].fPositions.set(-1.0f, -1.0f);
v[1].fPositions.set( 1.0f, -1.0f);
v[2].fPositions.set( 1.0f, 1.0f);
} else {
v[0].fPositions.set(-1.0f, -1.0f);
v[1].fPositions.set( 1.0f, 1.0f);
v[2].fPositions.set( -1.0f, 1.0f);
}
SkPoint* position = reinterpret_cast<SkPoint*>(v);
viewMatrices[i].mapPointsWithStride(position, sizeof(Vertex), kVerticesPerTri);
GrGLfloat color[3] = {1.0f, 0.0f, 1.0f};
for (uint32_t j = 0; j < kVerticesPerTri; j++) {
v->fColors[0] = color[0];
v->fColors[1] = color[1];
v->fColors[2] = color[2];
v++;
}
}
GR_GL_CALL(gl, GenBuffers(1, &fVboId));
GR_GL_CALL(gl, BindBuffer(GR_GL_ARRAY_BUFFER, fVboId));
GR_GL_CALL(gl, EnableVertexAttribArray(0));
GR_GL_CALL(gl, EnableVertexAttribArray(1));
GR_GL_CALL(gl, VertexAttribPointer(0, 2, GR_GL_FLOAT, GR_GL_FALSE, sizeof(Vertex),
(GrGLvoid*)0));
GR_GL_CALL(gl, VertexAttribPointer(1, 3, GR_GL_FLOAT, GR_GL_FALSE, sizeof(Vertex),
(GrGLvoid*)(sizeof(SkPoint))));
GR_GL_CALL(gl, BufferData(GR_GL_ARRAY_BUFFER, sizeof(vertices), vertices, GR_GL_STATIC_DRAW));
}
////////////// Index buffer implementation ////////////////////////////////////
CHardwareTextureBuffer::CHardwareTextureBuffer(size_t size, THardwareBufferLock opt)
{
if(mBufID > 0)
{
if(!CRenderSystem::GetSingelton().CheckCapabilities(BASIC_CATEGORY, CAP_PBO))
throw NOVA_EXP("CHardwareTextureBuffer: You card do not support pbo extention..", BAD_OPERATION);
if(size == 0)
throw NOVA_EXP("CHardwareTextureBuffer(): You trying to create v-buffer with zero length..", BAD_OPERATION);
BindBuffer();
GLuint usage;
switch(opt)
{
case HWB_DYNAMIC:
usage = GL_STREAM_READ_ARB;
mUsage = GL_PIXEL_PACK_BUFFER_ARB;
break;
default:
usage = GL_STREAM_DRAW_ARB;
mUsage = GL_PIXEL_UNPACK_BUFFER_ARB;
break;
}
// Preparing pixel buffer
glBufferDataARB(mUsage, size, 0, usage);
mReady = true;
mSize = size;
UnbindBuffer();
}
else
throw NOVA_EXP("CHardwareTextureBuffer(): v-buffer id not created..", BAD_OPERATION);
}
void GLGpuPosInstancedArraysBench::setup(const GrGLInterface* gl) {
setup_framebuffer(gl, kScreenWidth, kScreenHeight);
// compile and use shaders
GrGLint shaderProgram = compile_shader(gl, gpu_vertex_shader, fragment_shader);
// translations
int index = 0;
GrGLfloat viewMatrices[fNumQuads * fSkMatrixNumCells];
setup_matrices(fNumQuads, [&index, &viewMatrices](const SkMatrix& m) {
GrGLGetMatrix<3>(&viewMatrices[index], m);
index += fSkMatrixNumCells;
});
// Constants for our various shader programs
GrGLfloat quad_vertices[] = {
// Positions // Colors
-1.0f, 1.0f, 1.0f, 0.0f, 0.0f,
1.0f, -1.0f, 0.0f, 1.0f, 0.0f,
-1.0f, -1.0f, 0.0f, 0.0f, 1.0f,
-1.0f, 1.0f, 1.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
};
// update vertex data
GrGLuint quadVAO, quadVBO;
GR_GL_CALL(gl, GenVertexArrays(1, &quadVAO));
GR_GL_CALL(gl, GenBuffers(1, &quadVBO));
GR_GL_CALL(gl, BindVertexArray(quadVAO));
GR_GL_CALL(gl, BindBuffer(GR_GL_ARRAY_BUFFER, quadVBO));
GR_GL_CALL(gl, EnableVertexAttribArray(0));
GR_GL_CALL(gl, VertexAttribPointer(0, 2, GR_GL_FLOAT, GR_GL_FALSE, 5 * sizeof(GrGLfloat), (GrGLvoid*)0));
GR_GL_CALL(gl, EnableVertexAttribArray(1));
GR_GL_CALL(gl, VertexAttribPointer(1, 3, GR_GL_FLOAT, GR_GL_FALSE, 5 * sizeof(GrGLfloat), (GrGLvoid*)(2 * sizeof(GrGLfloat))));
GR_GL_CALL(gl, BufferData(GR_GL_ARRAY_BUFFER, sizeof(quad_vertices), quad_vertices, GR_GL_STATIC_DRAW));
// Also set instance data
GrGLuint instanceVBO;
GR_GL_CALL(gl, GenBuffers(1, &instanceVBO));
GR_GL_CALL(gl, BindBuffer(GR_GL_ARRAY_BUFFER, instanceVBO));
GR_GL_CALL(gl, BufferData(GR_GL_ARRAY_BUFFER, sizeof(GrGLfloat) * fSkMatrixNumCells * fNumQuads,
&viewMatrices[0], GR_GL_STATIC_DRAW));
GR_GL_CALL(gl, EnableVertexAttribArray(2));
GR_GL_CALL(gl, EnableVertexAttribArray(3));
GR_GL_CALL(gl, EnableVertexAttribArray(4));
GR_GL_CALL(gl, VertexAttribPointer(2, 3, GR_GL_FLOAT, GR_GL_FALSE, 9 * sizeof(GrGLfloat), (GrGLvoid*)0));
GR_GL_CALL(gl, VertexAttribPointer(3, 3, GR_GL_FLOAT, GR_GL_FALSE, 9 * sizeof(GrGLfloat), (GrGLvoid*)(3 * sizeof(GrGLfloat))));
GR_GL_CALL(gl, VertexAttribPointer(4, 3, GR_GL_FLOAT, GR_GL_FALSE, 9 * sizeof(GrGLfloat), (GrGLvoid*)(6 * sizeof(GrGLfloat))));
GR_GL_CALL(gl, VertexAttribDivisor(2, 1));
GR_GL_CALL(gl, VertexAttribDivisor(3, 1));
GR_GL_CALL(gl, VertexAttribDivisor(4, 1));
// draw
GR_GL_CALL(gl, ClearColor(0.03f, 0.03f, 0.03f, 1.0f));
GR_GL_CALL(gl, Clear(GR_GL_COLOR_BUFFER_BIT));
// set us up to draw
GR_GL_CALL(gl, UseProgram(shaderProgram));
GR_GL_CALL(gl, BindVertexArray(quadVAO));
}
void GLInstancedRendering::onBeginFlush(GrResourceProvider* rp) {
// Count what there is to draw.
BatchList::Iter iter;
iter.init(this->trackedBatches(), BatchList::Iter::kHead_IterStart);
int numGLInstances = 0;
int numGLDrawCmds = 0;
while (Batch* b = iter.get()) {
GLBatch* batch = static_cast<GLBatch*>(b);
iter.next();
numGLInstances += batch->fNumDraws;
numGLDrawCmds += batch->numGLCommands();
}
if (!numGLDrawCmds) {
return;
}
SkASSERT(numGLInstances);
// Lazily create a vertex array object.
if (!fVertexArrayID) {
GL_CALL(GenVertexArrays(1, &fVertexArrayID));
if (!fVertexArrayID) {
return;
}
this->glGpu()->bindVertexArray(fVertexArrayID);
// Attach our index buffer to the vertex array.
SkASSERT(!this->indexBuffer()->isCPUBacked());
GL_CALL(BindBuffer(GR_GL_ELEMENT_ARRAY_BUFFER,
static_cast<const GrGLBuffer*>(this->indexBuffer())->bufferID()));
// Set up the non-instanced attribs.
this->glGpu()->bindBuffer(kVertex_GrBufferType, this->vertexBuffer());
GL_CALL(EnableVertexAttribArray((int)Attrib::kShapeCoords));
GL_CALL(VertexAttribPointer((int)Attrib::kShapeCoords, 2, GR_GL_FLOAT, GR_GL_FALSE,
sizeof(ShapeVertex), (void*) offsetof(ShapeVertex, fX)));
GL_CALL(EnableVertexAttribArray((int)Attrib::kVertexAttrs));
GL_CALL(VertexAttribIPointer((int)Attrib::kVertexAttrs, 1, GR_GL_INT, sizeof(ShapeVertex),
(void*) offsetof(ShapeVertex, fAttrs)));
SkASSERT(SK_InvalidUniqueID == fInstanceAttribsBufferUniqueId);
}
// Create and map instance and draw-indirect buffers.
SkASSERT(!fInstanceBuffer);
fInstanceBuffer.reset(
rp->createBuffer(sizeof(Instance) * numGLInstances, kVertex_GrBufferType,
kDynamic_GrAccessPattern,
GrResourceProvider::kNoPendingIO_Flag |
GrResourceProvider::kRequireGpuMemory_Flag));
if (!fInstanceBuffer) {
return;
}
SkASSERT(!fDrawIndirectBuffer);
fDrawIndirectBuffer.reset(
rp->createBuffer(sizeof(GrGLDrawElementsIndirectCommand) * numGLDrawCmds,
kDrawIndirect_GrBufferType, kDynamic_GrAccessPattern,
GrResourceProvider::kNoPendingIO_Flag |
GrResourceProvider::kRequireGpuMemory_Flag));
if (!fDrawIndirectBuffer) {
return;
}
Instance* glMappedInstances = static_cast<Instance*>(fInstanceBuffer->map());
int glInstancesIdx = 0;
auto* glMappedCmds = static_cast<GrGLDrawElementsIndirectCommand*>(fDrawIndirectBuffer->map());
int glDrawCmdsIdx = 0;
bool baseInstanceSupport = this->glGpu()->glCaps().baseInstanceSupport();
if (GR_GL_LOG_INSTANCED_BATCHES || !baseInstanceSupport) {
fGLDrawCmdsInfo.reset(numGLDrawCmds);
}
// Generate the instance and draw-indirect buffer contents based on the tracked batches.
iter.init(this->trackedBatches(), BatchList::Iter::kHead_IterStart);
while (Batch* b = iter.get()) {
GLBatch* batch = static_cast<GLBatch*>(b);
iter.next();
batch->fEmulatedBaseInstance = baseInstanceSupport ? 0 : glInstancesIdx;
batch->fGLDrawCmdsIdx = glDrawCmdsIdx;
const Batch::Draw* draw = batch->fHeadDraw;
SkASSERT(draw);
do {
int instanceCount = 0;
IndexRange geometry = draw->fGeometry;
SkASSERT(!geometry.isEmpty());
do {
glMappedInstances[glInstancesIdx + instanceCount++] = draw->fInstance;
draw = draw->fNext;
} while (draw && draw->fGeometry == geometry);
GrGLDrawElementsIndirectCommand& glCmd = glMappedCmds[glDrawCmdsIdx];
glCmd.fCount = geometry.fCount;
glCmd.fInstanceCount = instanceCount;
glCmd.fFirstIndex = geometry.fStart;
glCmd.fBaseVertex = 0;
glCmd.fBaseInstance = baseInstanceSupport ? glInstancesIdx : 0;
if (GR_GL_LOG_INSTANCED_BATCHES || !baseInstanceSupport) {
fGLDrawCmdsInfo[glDrawCmdsIdx].fInstanceCount = instanceCount;
#if GR_GL_LOG_INSTANCED_BATCHES
fGLDrawCmdsInfo[glDrawCmdsIdx].fGeometry = geometry;
#endif
}
glInstancesIdx += instanceCount;
++glDrawCmdsIdx;
} while (draw);
}
SkASSERT(glDrawCmdsIdx == numGLDrawCmds);
fDrawIndirectBuffer->unmap();
SkASSERT(glInstancesIdx == numGLInstances);
fInstanceBuffer->unmap();
}
void
vsDisplayList::AppendOp(vsDisplayList::op * o)
{
OpCode type = o->type;
switch( type )
{
case OpCode_SetColor:
SetColor( o->data.GetColor() );
break;
case OpCode_SetColors:
SetColors( (vsColor*)o->data.p, o->data.GetUInt() );
break;
case OpCode_SetColorsBuffer:
SetColorsBuffer( (vsRenderBuffer*)o->data.p );
break;
case OpCode_VertexArray:
VertexArray( (vsVector3D *)o->data.p, o->data.GetUInt() );
break;
case OpCode_NormalArray:
NormalArray( (vsVector3D *)o->data.p, o->data.GetUInt() );
break;
case OpCode_TexelArray:
TexelArray( (vsVector2D *)o->data.p, o->data.GetUInt() );
break;
case OpCode_ColorArray:
ColorArray( (vsColor *)o->data.p, o->data.GetUInt() );
break;
case OpCode_VertexBuffer:
VertexBuffer( (vsRenderBuffer *)o->data.p );
break;
case OpCode_TexelBuffer:
TexelBuffer( (vsRenderBuffer *)o->data.p );
break;
case OpCode_ColorBuffer:
ColorBuffer( (vsRenderBuffer *)o->data.p );
break;
case OpCode_BindBuffer:
BindBuffer( (vsRenderBuffer *)o->data.p );
break;
case OpCode_UnbindBuffer:
UnbindBuffer( (vsRenderBuffer *)o->data.p );
break;
case OpCode_ClearVertexArray:
ClearVertexArray();
break;
case OpCode_ClearNormalArray:
ClearNormalArray();
break;
case OpCode_ClearTexelArray:
ClearTexelArray();
break;
case OpCode_ClearColorArray:
ClearColorArray();
break;
case OpCode_ClearArrays:
ClearArrays();
break;
case OpCode_LineListArray:
LineListArray( (int *)o->data.p, o->data.GetUInt() );
break;
case OpCode_LineStripArray:
LineStripArray( (int *)o->data.p, o->data.GetUInt() );
break;
case OpCode_TriangleListArray:
TriangleListArray( (int *)o->data.p, o->data.GetUInt() );
break;
case OpCode_TriangleStripArray:
TriangleStripArray( (int *)o->data.p, o->data.GetUInt() );
break;
case OpCode_PointsArray:
PointsArray( (int *)o->data.p, o->data.GetUInt() );
break;
case OpCode_LineListBuffer:
LineListBuffer( (vsRenderBuffer *)o->data.p );
break;
case OpCode_LineStripBuffer:
LineStripBuffer( (vsRenderBuffer *)o->data.p );
break;
case OpCode_TriangleStripBuffer:
TriangleStripBuffer( (vsRenderBuffer *)o->data.p );
break;
case OpCode_TriangleFanArray:
TriangleFanArray( (int *)o->data.p, o->data.GetUInt() );
break;
case OpCode_PushTransform:
PushTransform( o->data.GetTransform() );
break;
case OpCode_SetCameraTransform:
SetCameraTransform( o->data.GetTransform() );
break;
case OpCode_SetMatrix4x4:
SetMatrix4x4( o->data.GetMatrix4x4() );
break;
case OpCode_PushMatrix4x4:
PushMatrix4x4( o->data.GetMatrix4x4() );
break;
case OpCode_SetMatrices4x4:
SetMatrices4x4( (vsMatrix4x4*)o->data.p, o->data.i );
break;
case OpCode_SetMatrices4x4Buffer:
SetMatrices4x4Buffer( (vsRenderBuffer*)o->data.p );
break;
case OpCode_SetWorldToViewMatrix4x4:
SetWorldToViewMatrix4x4( o->data.GetMatrix4x4() );
break;
case OpCode_Set3DProjection:
Set3DProjection( o->data.fov, o->data.nearPlane, o->data.farPlane );
break;
case OpCode_SetProjectionMatrix4x4:
SetProjectionMatrix4x4( o->data.GetMatrix4x4() );
break;
case OpCode_PopTransform:
PopTransform();
break;
case OpCode_EnableStencil:
EnableStencil();
break;
case OpCode_DisableStencil:
DisableStencil();
break;
case OpCode_EnableScissor:
EnableScissor( o->data.GetBox2D() );
break;
case OpCode_DisableScissor:
DisableScissor();
break;
case OpCode_ClearStencil:
ClearStencil();
break;
case OpCode_SetViewport:
SetViewport( o->data.GetBox2D() );
break;
case OpCode_ClearViewport:
ClearViewport();
break;
case OpCode_Debug:
Debug( o->data.GetString() );
break;
default:
break;
}
}
//---------------------------------------------------------------------------------------------------------
void IndicesBufferResourceGL::_DoChangeData( handle h, uint offset, uint datasize, uint typesize, const void* dataptr )
{
BindBuffer();
glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, offset, datasize*typesize, dataptr);
CHECK_ERROR_RENDER;
}
void GrGLIndexBuffer::bind() const {
GL_CALL(BindBuffer(GR_GL_ELEMENT_ARRAY_BUFFER, fBufferID));
GPUGL->notifyIndexBufferBind(this);
}
void GrGLVertexBuffer::bind() const {
GL_CALL(BindBuffer(GR_GL_ARRAY_BUFFER, fBufferID));
GPUGL->notifyVertexBufferBind(this);
}
