void Renderer::drawTilemap(M4x4<float> view_mat, M4x4<float> projection_mat)
{
// activate entity shader
glUseProgram(entity_program_id);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, gamestate->tilemap->texture.identifier);
glUniformMatrix4fv(view_loc, 1, GL_FALSE, &view_mat[0][0]);
glUniformMatrix4fv(projection_loc, 1, GL_FALSE, &projection_mat[0][0]);
glVertexAttrib2f(
texture_size_loc,
gamestate->tilemap->texture.bitmap.size.x,
gamestate->tilemap->texture.bitmap.size.y
);
for (int i=0; i<gamestate->tilemap->dimensions.x; i++)
{
for (int j=0; j<gamestate->tilemap->dimensions.y; j++)
{
TileIdentifier tile_id = *gamestate->tilemap->tile({i, j});
int tile_x = (tile_id % gamestate->tilemap->atlas_dimensions.x) * TILE_SIZE_PX;
int tile_y = (tile_id / gamestate->tilemap->atlas_dimensions.x) * TILE_SIZE_PX;
M4x4<float> model_mat = M4x4<float>::translate((i + 0.5) * 2, (gamestate->tilemap->dimensions.y - (j + 0.5)) * 2, 0);
glUniformMatrix4fv(model_loc, 1, GL_FALSE, &model_mat[0][0]);
glVertexAttrib2f(sprite_size_loc, TILE_SIZE_PX, TILE_SIZE_PX);
glVertexAttrib2f(sprite_offset_loc, tile_x, tile_y);
glDrawElements(GL_TRIANGLES, num_indicies, GL_UNSIGNED_INT, NULL);
}
}
glBindTexture(GL_TEXTURE_2D, 0);
}
void THFrame::DrawImage(const THVector2& p,const THVector2& size,const THImage& img)
{
glBindTexture(GL_TEXTURE_2D,img.textureID);
glVertexAttrib2f(THDefaultProgram.rotationHandler,1.0f,0.0f);
glVertexAttrib4f(THDefaultProgram.textureHandler,0.0f,0.0f,1.0f,1.0f);
glVertexAttrib2f(THDefaultProgram.centerHandler,0.0f,0.0f);
glVertexAttrib2fv(THDefaultProgram.scaleHandler,(const GLfloat*)&size);
glVertexAttrib2fv(THDefaultProgram.positionHandler,(const GLfloat*)&p);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
////////////////////////////////////////////////////////////////////////////////
// Utility drawing functions
static void menu_DrawColoredQuad(float x, float y, float w, float h, float border,
const Color& color, const Color& borderColor)
{
glUseProgram(g_menuShader->m_program);
glUniformMatrix4fv(g_menuShader->m_uniforms[BIND_Mvp], 1, 0, g_screen.m_proj.m);
GLint locPos = g_menuShader->m_attrs[GEOM_Pos];
GLint locColor = g_menuShader->m_uniforms[BIND_Color];
if(border > 0.f)
{
glUniform3fv(locColor, 1, &borderColor.r);
glBegin(GL_TRIANGLE_STRIP);
glVertexAttrib2f(locPos, x, y);
glVertexAttrib2f(locPos, x, y+h);
glVertexAttrib2f(locPos, x+w, y);
glVertexAttrib2f(locPos, x+w, y+h);
glEnd();
x+=border;
w-=2.f*border;
y+=border;
h-=2.f*border;
}
glUniform3fv(locColor, 1, &color.r);
glBegin(GL_TRIANGLE_STRIP);
glVertexAttrib2f(locPos, x, y);
glVertexAttrib2f(locPos, x, y+h);
glVertexAttrib2f(locPos, x+w, y);
glVertexAttrib2f(locPos, x+w, y+h);
glEnd();
checkGlError("menu_DrawColoredQuad");
}
void Renderer::drawEntities(M4x4<float> view_mat, M4x4<float> projection_mat)
{
// activate entity shader
glUseProgram(entity_program_id);
glEnable(GL_BLEND);
glActiveTexture(GL_TEXTURE0);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glUniformMatrix4fv(view_loc, 1, GL_FALSE, &view_mat[0][0]);
glUniformMatrix4fv(projection_loc, 1, GL_FALSE, &projection_mat[0][0]);
std::sort(this->entity_factory_->entities.begin(), this->entity_factory_->entities.end(), [](const Entity* a, const Entity* b) -> bool
{
PositionComponent* a_pc = a->get<PositionComponent>();
PositionComponent* b_pc = b->get<PositionComponent>();
return a_pc->position.y > b_pc->position.y;
});
for (Entity *entity : this->entity_factory_->entities)
{
PositionComponent *position = entity->get<PositionComponent>();
GraphicsComponent *graphics = entity->get<GraphicsComponent>();
M4x4<float> model_translate_mat = M4x4<float>::translate(position->position.x, position->position.y, 0);
glVertexAttrib2f(sprite_offset_loc, 0.f, 0.f);
for (Texture texture : graphics->textures)
{
Vf2 model_scale = texture.bitmap.size / (unsigned int)PIXELS_PER_METER;
M4x4<float> model_mat = model_translate_mat * M4x4<float>::scale(model_scale.x, model_scale.y, 0);
glBindTexture(GL_TEXTURE_2D, texture.identifier);
glUniformMatrix4fv(model_loc, 1, GL_FALSE, &model_mat[0][0]);
glVertexAttrib2f(texture_size_loc, texture.bitmap.size.x, texture.bitmap.size.y);
glVertexAttrib2f(sprite_size_loc, texture.bitmap.size.x, texture.bitmap.size.y);
glDrawElements(GL_TRIANGLES, num_indicies, GL_UNSIGNED_INT, NULL);
}
}
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_BLEND);
}
void DynamicMarchingTetrahedra::renderMesh(GLContext * gl, GLContext::Program * prog) {
prog->use();
glVertexAttrib3f(prog->getAttribLoc("normalAttrib"), 0.0f, 0.0f, 0.0f);
//glVertexAttrib4f(prog->getAttribLoc("vcolorAttrib"), 1.0f, 1.0f, 1.0f, 1.0f);
glVertexAttrib2f(prog->getAttribLoc("texCoordAttrib"), 0.0f, 0.0f);
gl->setUniform(prog->getUniformLoc("diffuseUniform"), Vec4f(0.6, 0.7, 0.9));
gl->setUniform(prog->getUniformLoc("specularUniform"), Vec3f(0.5f, 0.3, 0.6));
gl->setUniform(prog->getUniformLoc("glossiness"), 10.0f);
gl->setUniform(prog->getUniformLoc("useDiffuseTexture"), false);
gl->setUniform(prog->getUniformLoc("useNormalMap"), false);
gl->setUniform(prog->getUniformLoc("useSpecularMap"), false);
gl->setUniform(prog->getUniformLoc("ssaoMask"), 0.0f);
glBindBuffer(GL_ARRAY_BUFFER, m_buffers[DMT_Buffer_Types::MESH_BUFFER]);
glEnableVertexAttribArray(0); // position
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(DMT_TriangleUnit), 0);
glEnableVertexAttribArray(1); // position
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(DMT_TriangleUnit), (GLvoid*)((char*)NULL + sizeof(float) * 8));
//::printf("%d\n", m_numTriangles);
if (0<m_numTriangles)glDrawArrays(GL_TRIANGLES, 0, m_numTriangles);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
void DynamicMarchingTetrahedra::renderMeshCheap(GLContext * gl, GLContext::Program * prog) {
prog->use();
glVertexAttrib3f(prog->getAttribLoc("normalAttrib"), 0.0f, 0.0f, 0.0f);
//glVertexAttrib4f(prog->getAttribLoc("vcolorAttrib"), 1.0f, 1.0f, 1.0f, 1.0f);
glVertexAttrib2f(prog->getAttribLoc("texCoordAttrib"), 0.0f, 0.0f);
glBindBuffer(GL_ARRAY_BUFFER, m_buffers[DMT_Buffer_Types::MESH_BUFFER]);
glEnableVertexAttribArray(0); // position
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(DMT_TriangleUnit), 0);
glEnableVertexAttribArray(1); // position
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(DMT_TriangleUnit), (GLvoid*)((char*)NULL + sizeof(float) * 8));
if (0<m_numTriangles)glDrawArrays(GL_TRIANGLES, 0, m_numTriangles);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
// shade a mesh
void shade_mesh(Mesh* mesh, int time, bool wireframe, bool skinning_gpu, bool draw_normals, ShadeState* state) {
// bind material kd, ks, n
glUniform3fv(glGetUniformLocation(state->gl_program_id,"material_kd"),
1,&mesh->mat->kd.x);
glUniform3fv(glGetUniformLocation(state->gl_program_id,"material_ks"),
1,&mesh->mat->ks.x);
glUniform1f(glGetUniformLocation(state->gl_program_id,"material_n"),
mesh->mat->n);
glUniform1i(glGetUniformLocation(state->gl_program_id,"material_is_lines"),
GL_FALSE);
glUniform1i(glGetUniformLocation(state->gl_program_id,"material_double_sided"),
(mesh->mat->double_sided)?GL_TRUE:GL_FALSE);
// bind texture params (txt_on, sampler)
_bind_texture("material_kd_txt", "material_kd_txt_on", mesh->mat->kd_txt, 0, state);
_bind_texture("material_ks_txt", "material_ks_txt_on", mesh->mat->ks_txt, 1, state);
_bind_texture("material_norm_txt", "material_norm_txt_on", mesh->mat->norm_txt, 2, state);
// bind mesh frame - use frame_to_matrix
glUniformMatrix4fv(glGetUniformLocation(state->gl_program_id,"mesh_frame"),
1,true,&frame_to_matrix(mesh->frame)[0][0]);
// enable vertex attributes arrays and set up pointers to the mesh data
auto vertex_pos_location = glGetAttribLocation(state->gl_program_id, "vertex_pos");
auto vertex_norm_location = glGetAttribLocation(state->gl_program_id, "vertex_norm");
auto vertex_texcoord_location = glGetAttribLocation(state->gl_program_id, "vertex_texcoord");
// YOUR CODE GOES HERE ---------------------
// (only for extra credit)
auto vertex_skin_bone_ids_location = glGetAttribLocation(state->gl_program_id, "vertex_skin_bone_ids");
auto vertex_skin_bone_weights_location = glGetAttribLocation(state->gl_program_id, "vertex_skin_bone_weights");
glEnableVertexAttribArray(vertex_pos_location);
glVertexAttribPointer(vertex_pos_location, 3, GL_FLOAT, GL_FALSE, 0, &mesh->pos[0].x);
glEnableVertexAttribArray(vertex_norm_location);
glVertexAttribPointer(vertex_norm_location, 3, GL_FLOAT, GL_FALSE, 0, &mesh->norm[0].x);
if(not mesh->texcoord.empty()) {
glEnableVertexAttribArray(vertex_texcoord_location);
glVertexAttribPointer(vertex_texcoord_location, 2, GL_FLOAT, GL_FALSE, 0, &mesh->texcoord[0].x);
}
else glVertexAttrib2f(vertex_texcoord_location, 0, 0);
if (mesh->skinning and skinning_gpu) {
// YOUR CODE GOES HERE ---------------------
// (only for extra credit)
glUniform1i(glGetUniformLocation(state->gl_program_id, "skin_enabled"), true);
glEnableVertexAttribArray(vertex_skin_bone_ids_location);
glVertexAttribPointer(vertex_skin_bone_ids_location, 4, GL_INT, GL_FALSE, 0, &mesh->skinning->bone_ids[0].x);
glEnableVertexAttribArray(vertex_skin_bone_weights_location);
glVertexAttribPointer(vertex_skin_bone_weights_location, 4, GL_FLOAT, GL_FALSE, 0, &mesh->skinning->bone_weights[0].x);
for (int i = 0; i < 48; i++) {
string name = "skin_bone_xforms["+std::to_string(i)+"]";
glUniformMatrix4fv(glGetUniformLocation(state->gl_program_id, name.c_str()), 1, GL_TRUE, &mesh->skinning->bone_xforms[time][i][0].x);
}
} else {
glUniform1i(glGetUniformLocation(state->gl_program_id,"skin_enabled"),GL_FALSE);
}
// draw triangles and quads
if(not wireframe) {
if(mesh->triangle.size()) glDrawElements(GL_TRIANGLES, mesh->triangle.size()*3, GL_UNSIGNED_INT, &mesh->triangle[0].x);
if(mesh->quad.size()) glDrawElements(GL_QUADS, mesh->quad.size()*4, GL_UNSIGNED_INT, &mesh->quad[0].x);
if(mesh->point.size()) glDrawElements(GL_POINTS, mesh->point.size(), GL_UNSIGNED_INT, &mesh->point[0]);
if(mesh->line.size()) glDrawElements(GL_LINES, mesh->line.size(), GL_UNSIGNED_INT, &mesh->line[0].x);
for(auto segment : mesh->spline) glDrawElements(GL_LINE_STRIP, 4, GL_UNSIGNED_INT, &segment);
} else {
auto edges = EdgeMap(mesh->triangle, mesh->quad).edges();
glDrawElements(GL_LINES, edges.size()*2, GL_UNSIGNED_INT, &edges[0].x);
}
// disable vertex attribute arrays
glDisableVertexAttribArray(vertex_pos_location);
glDisableVertexAttribArray(vertex_norm_location);
if(not mesh->texcoord.empty()) glDisableVertexAttribArray(vertex_texcoord_location);
if(mesh->skinning) {
// YOUR CODE GOES HERE ---------------------
// (only for extra credit)
glDisableVertexAttribArray(vertex_skin_bone_ids_location);
glDisableVertexAttribArray(vertex_skin_bone_weights_location);
}
// draw normals if needed
if(draw_normals) {
glUniform3fv(glGetUniformLocation(state->gl_program_id,"material_kd"),
1,&zero3f.x);
glUniform3fv(glGetUniformLocation(state->gl_program_id,"material_ks"),
1,&zero3f.x);
glBegin(GL_LINES);
for(auto i : range(mesh->pos.size())) {
auto p0 = mesh->pos[i];
auto p1 = mesh->pos[i] + mesh->norm[i]*0.1;
glVertexAttrib3fv(0,&p0.x);
glVertexAttrib3fv(0,&p1.x);
if(mesh->mat->double_sided) {
auto p2 = mesh->pos[i] - mesh->norm[i]*0.1;
glVertexAttrib3fv(0,&p0.x);
glVertexAttrib3fv(0,&p2.x);
}
}
glEnd();
}
}
void Skybox::draw()
{
glPushMatrix();
shader->Bind();
texture->Bind(0);
float size = 1;
glBegin(GL_QUADS);
// for each face, define a normal (first) the a
// 0 3 2 1
glNormal3f(0.0, 0.0, 1.0);
glVertexAttrib2f(texcoord0, 0, 0);
glVertex3f((size / 2), -(size / 2), -(size / 2));
glVertexAttrib2f(texcoord0, 1, 0);
glVertex3f((size / 2), (size / 2), -(size / 2));
glVertexAttrib2f(texcoord0, 1, 1);
glVertex3f(-(size / 2), (size / 2), -(size / 2));
glVertexAttrib2f(texcoord0, 0, 1);
glVertex3f(-(size / 2), -(size / 2), -(size / 2));
// 0 4 7 3
glNormal3f(0.0, 1.0, 0.0);
glVertexAttrib2f(texcoord0, 0, 0);
glVertex3f((size / 2), -(size / 2), -(size / 2));
glVertexAttrib2f(texcoord0, 1, 0);
glVertex3f((size / 2), -(size / 2), (size / 2));
glVertexAttrib2f(texcoord0, 1, 1);
glVertex3f(-(size / 2), -(size / 2), (size / 2));
glVertexAttrib2f(texcoord0, 0, 1);
glVertex3f(-(size / 2), -(size / 2), -(size / 2));
// 1 5 4 0
glNormal3f(-1.0, 0.0, 0.0);
glVertexAttrib2f(texcoord0, 0, 0);
glVertex3f((size / 2), (size / 2), -(size / 2));
glVertexAttrib2f(texcoord0, 1, 0);
glVertex3f((size / 2), (size / 2), (size / 2));
glVertexAttrib2f(texcoord0, 1, 1);
glVertex3f((size / 2), -(size / 2), (size / 2));
glVertexAttrib2f(texcoord0, 0, 1);
glVertex3f((size / 2), -(size / 2), -(size / 2));
// 2 6 5 1
glNormal3f(0.0, -1.0, 0.0);
glVertexAttrib2f(texcoord0, 0, 0);
glVertex3f(-(size / 2), (size / 2), -(size / 2));
glVertexAttrib2f(texcoord0, 1, 0);
glVertex3f(-(size / 2), (size / 2), (size / 2));
glVertexAttrib2f(texcoord0, 1, 1);
glVertex3f((size / 2), (size / 2), (size / 2));
glVertexAttrib2f(texcoord0, 0, 1);
glVertex3f((size / 2), (size / 2), -(size / 2));
// 3 7 6 2
glNormal3f(1.0, 0.0, 0.0);
glVertexAttrib2f(texcoord0, 0, 0);
glVertex3f(-(size / 2), -(size / 2), -(size / 2));
glVertexAttrib2f(texcoord0, 1, 0);
glVertex3f(-(size / 2), -(size / 2), (size / 2));
glVertexAttrib2f(texcoord0, 1, 1);
glVertex3f(-(size / 2), (size / 2), (size / 2));
glVertexAttrib2f(texcoord0, 0, 1);
glVertex3f(-(size / 2), (size / 2), -(size / 2));
// 4 5 6 7
glNormal3f(0.0, 0.0, -1.0);
glVertexAttrib2f(texcoord0, 0, 0);
glVertex3f((size / 2), -(size / 2), (size / 2));
glVertexAttrib2f(texcoord0, 1, 0);
glVertex3f((size / 2), (size / 2), (size / 2));
glVertexAttrib2f(texcoord0, 1, 1);
glVertex3f(-(size / 2), (size / 2), (size / 2));
glVertexAttrib2f(texcoord0, 0, 1);
glVertex3f(-(size / 2), -(size / 2), (size / 2));
glEnd();
glPopMatrix();
glUseProgram(0);
}
uintptr_t processFn(struct fnargs* args, char* parg) {
uintptr_t ret = 0;
switch (args->fn) {
case glfnUNDEFINED:
abort(); // bad glfn
break;
case glfnActiveTexture:
glActiveTexture((GLenum)args->a0);
break;
case glfnAttachShader:
glAttachShader((GLint)args->a0, (GLint)args->a1);
break;
case glfnBindAttribLocation:
glBindAttribLocation((GLint)args->a0, (GLint)args->a1, (GLchar*)args->a2);
break;
case glfnBindBuffer:
glBindBuffer((GLenum)args->a0, (GLuint)args->a1);
break;
case glfnBindFramebuffer:
glBindFramebuffer((GLenum)args->a0, (GLint)args->a1);
break;
case glfnBindRenderbuffer:
glBindRenderbuffer((GLenum)args->a0, (GLint)args->a1);
break;
case glfnBindTexture:
glBindTexture((GLenum)args->a0, (GLint)args->a1);
break;
case glfnBlendColor:
glBlendColor(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3);
break;
case glfnBlendEquation:
glBlendEquation((GLenum)args->a0);
break;
case glfnBlendEquationSeparate:
glBlendEquationSeparate((GLenum)args->a0, (GLenum)args->a1);
break;
case glfnBlendFunc:
glBlendFunc((GLenum)args->a0, (GLenum)args->a1);
break;
case glfnBlendFuncSeparate:
glBlendFuncSeparate((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLenum)args->a3);
break;
case glfnBufferData:
glBufferData((GLenum)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg, (GLenum)args->a2);
break;
case glfnBufferSubData:
glBufferSubData((GLenum)args->a0, (GLint)args->a1, (GLsizeiptr)args->a2, (GLvoid*)parg);
break;
case glfnCheckFramebufferStatus:
ret = glCheckFramebufferStatus((GLenum)args->a0);
break;
case glfnClear:
glClear((GLenum)args->a0);
break;
case glfnClearColor:
glClearColor(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3);
break;
case glfnClearDepthf:
glClearDepthf(*(GLfloat*)&args->a0);
break;
case glfnClearStencil:
glClearStencil((GLint)args->a0);
break;
case glfnColorMask:
glColorMask((GLboolean)args->a0, (GLboolean)args->a1, (GLboolean)args->a2, (GLboolean)args->a3);
break;
case glfnCompileShader:
glCompileShader((GLint)args->a0);
break;
case glfnCompressedTexImage2D:
glCompressedTexImage2D((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLsizeiptr)args->a6, (GLvoid*)parg);
break;
case glfnCompressedTexSubImage2D:
glCompressedTexSubImage2D((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLenum)args->a6, (GLsizeiptr)args->a7, (GLvoid*)parg);
break;
case glfnCopyTexImage2D:
glCopyTexImage2D((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLint)args->a6, (GLint)args->a7);
break;
case glfnCopyTexSubImage2D:
glCopyTexSubImage2D((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLint)args->a6, (GLint)args->a7);
break;
case glfnCreateProgram:
ret = glCreateProgram();
break;
case glfnCreateShader:
ret = glCreateShader((GLenum)args->a0);
break;
case glfnCullFace:
glCullFace((GLenum)args->a0);
break;
case glfnDeleteBuffer:
glDeleteBuffers(1, (const GLuint*)(&args->a0));
break;
case glfnDeleteFramebuffer:
glDeleteFramebuffers(1, (const GLuint*)(&args->a0));
break;
case glfnDeleteProgram:
glDeleteProgram((GLint)args->a0);
break;
case glfnDeleteRenderbuffer:
glDeleteRenderbuffers(1, (const GLuint*)(&args->a0));
break;
case glfnDeleteShader:
glDeleteShader((GLint)args->a0);
break;
case glfnDeleteTexture:
glDeleteTextures(1, (const GLuint*)(&args->a0));
break;
case glfnDepthFunc:
glDepthFunc((GLenum)args->a0);
break;
case glfnDepthMask:
glDepthMask((GLboolean)args->a0);
break;
case glfnDepthRangef:
glDepthRangef(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1);
break;
case glfnDetachShader:
glDetachShader((GLint)args->a0, (GLint)args->a1);
break;
case glfnDisable:
glDisable((GLenum)args->a0);
break;
case glfnDisableVertexAttribArray:
glDisableVertexAttribArray((GLint)args->a0);
break;
case glfnDrawArrays:
glDrawArrays((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2);
break;
case glfnDrawElements:
glDrawElements((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (void*)args->a3);
break;
case glfnEnable:
glEnable((GLenum)args->a0);
break;
case glfnEnableVertexAttribArray:
glEnableVertexAttribArray((GLint)args->a0);
break;
case glfnFinish:
glFinish();
break;
case glfnFlush:
glFlush();
break;
case glfnFramebufferRenderbuffer:
glFramebufferRenderbuffer((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint)args->a3);
break;
case glfnFramebufferTexture2D:
glFramebufferTexture2D((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4);
break;
case glfnFrontFace:
glFrontFace((GLenum)args->a0);
break;
case glfnGenBuffer:
glGenBuffers(1, (GLuint*)&ret);
break;
case glfnGenFramebuffer:
glGenFramebuffers(1, (GLuint*)&ret);
break;
case glfnGenRenderbuffer:
glGenRenderbuffers(1, (GLuint*)&ret);
break;
case glfnGenTexture:
glGenTextures(1, (GLuint*)&ret);
break;
case glfnGenerateMipmap:
glGenerateMipmap((GLenum)args->a0);
break;
case glfnGetActiveAttrib:
glGetActiveAttrib(
(GLuint)args->a0,
(GLuint)args->a1,
(GLsizei)args->a2,
NULL,
(GLint*)&ret,
(GLenum*)args->a3,
(GLchar*)parg);
break;
case glfnGetActiveUniform:
glGetActiveUniform(
(GLuint)args->a0,
(GLuint)args->a1,
(GLsizei)args->a2,
NULL,
(GLint*)&ret,
(GLenum*)args->a3,
(GLchar*)parg);
break;
case glfnGetAttachedShaders:
glGetAttachedShaders((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)&ret, (GLuint*)parg);
break;
case glfnGetAttribLocation:
ret = glGetAttribLocation((GLint)args->a0, (GLchar*)args->a1);
break;
case glfnGetBooleanv:
glGetBooleanv((GLenum)args->a0, (GLboolean*)parg);
break;
case glfnGetBufferParameteri:
glGetBufferParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)&ret);
break;
case glfnGetFloatv:
glGetFloatv((GLenum)args->a0, (GLfloat*)parg);
break;
case glfnGetIntegerv:
glGetIntegerv((GLenum)args->a0, (GLint*)parg);
break;
case glfnGetError:
ret = glGetError();
break;
case glfnGetFramebufferAttachmentParameteriv:
glGetFramebufferAttachmentParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint*)&ret);
break;
case glfnGetProgramiv:
glGetProgramiv((GLint)args->a0, (GLenum)args->a1, (GLint*)&ret);
break;
case glfnGetProgramInfoLog:
glGetProgramInfoLog((GLuint)args->a0, (GLsizei)args->a1, 0, (GLchar*)parg);
break;
case glfnGetRenderbufferParameteriv:
glGetRenderbufferParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)&ret);
break;
case glfnGetShaderiv:
glGetShaderiv((GLint)args->a0, (GLenum)args->a1, (GLint*)&ret);
break;
case glfnGetShaderInfoLog:
glGetShaderInfoLog((GLuint)args->a0, (GLsizei)args->a1, 0, (GLchar*)parg);
break;
case glfnGetShaderPrecisionFormat:
glGetShaderPrecisionFormat((GLenum)args->a0, (GLenum)args->a1, (GLint*)parg, &((GLint*)parg)[2]);
break;
case glfnGetShaderSource:
glGetShaderSource((GLuint)args->a0, (GLsizei)args->a1, 0, (GLchar*)parg);
break;
case glfnGetString:
ret = (uintptr_t)glGetString((GLenum)args->a0);
break;
case glfnGetTexParameterfv:
glGetTexParameterfv((GLenum)args->a0, (GLenum)args->a1, (GLfloat*)parg);
break;
case glfnGetTexParameteriv:
glGetTexParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)parg);
break;
case glfnGetUniformfv:
glGetUniformfv((GLuint)args->a0, (GLint)args->a1, (GLfloat*)parg);
break;
case glfnGetUniformiv:
glGetUniformiv((GLuint)args->a0, (GLint)args->a1, (GLint*)parg);
break;
case glfnGetUniformLocation:
ret = glGetUniformLocation((GLint)args->a0, (GLchar*)args->a1);
break;
case glfnGetVertexAttribfv:
glGetVertexAttribfv((GLuint)args->a0, (GLenum)args->a1, (GLfloat*)parg);
break;
case glfnGetVertexAttribiv:
glGetVertexAttribiv((GLuint)args->a0, (GLenum)args->a1, (GLint*)parg);
break;
case glfnHint:
glHint((GLenum)args->a0, (GLenum)args->a1);
break;
case glfnIsBuffer:
ret = glIsBuffer((GLint)args->a0);
break;
case glfnIsEnabled:
ret = glIsEnabled((GLenum)args->a0);
break;
case glfnIsFramebuffer:
ret = glIsFramebuffer((GLint)args->a0);
break;
case glfnIsProgram:
ret = glIsProgram((GLint)args->a0);
break;
case glfnIsRenderbuffer:
ret = glIsRenderbuffer((GLint)args->a0);
break;
case glfnIsShader:
ret = glIsShader((GLint)args->a0);
break;
case glfnIsTexture:
ret = glIsTexture((GLint)args->a0);
break;
case glfnLineWidth:
glLineWidth(*(GLfloat*)&args->a0);
break;
case glfnLinkProgram:
glLinkProgram((GLint)args->a0);
break;
case glfnPixelStorei:
glPixelStorei((GLenum)args->a0, (GLint)args->a1);
break;
case glfnPolygonOffset:
glPolygonOffset(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1);
break;
case glfnReadPixels:
glReadPixels((GLint)args->a0, (GLint)args->a1, (GLsizei)args->a2, (GLsizei)args->a3, (GLenum)args->a4, (GLenum)args->a5, (void*)parg);
break;
case glfnReleaseShaderCompiler:
glReleaseShaderCompiler();
break;
case glfnRenderbufferStorage:
glRenderbufferStorage((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2, (GLint)args->a3);
break;
case glfnSampleCoverage:
glSampleCoverage(*(GLfloat*)&args->a0, (GLboolean)args->a1);
break;
case glfnScissor:
glScissor((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3);
break;
case glfnShaderSource:
#if defined(os_ios) || defined(os_osx)
glShaderSource((GLuint)args->a0, (GLsizei)args->a1, (const GLchar *const *)args->a2, NULL);
#else
glShaderSource((GLuint)args->a0, (GLsizei)args->a1, (const GLchar **)args->a2, NULL);
#endif
break;
case glfnStencilFunc:
glStencilFunc((GLenum)args->a0, (GLint)args->a1, (GLuint)args->a2);
break;
case glfnStencilFuncSeparate:
glStencilFuncSeparate((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2, (GLuint)args->a3);
break;
case glfnStencilMask:
glStencilMask((GLuint)args->a0);
break;
case glfnStencilMaskSeparate:
glStencilMaskSeparate((GLenum)args->a0, (GLuint)args->a1);
break;
case glfnStencilOp:
glStencilOp((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2);
break;
case glfnStencilOpSeparate:
glStencilOpSeparate((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLenum)args->a3);
break;
case glfnTexImage2D:
glTexImage2D(
(GLenum)args->a0,
(GLint)args->a1,
(GLint)args->a2,
(GLsizei)args->a3,
(GLsizei)args->a4,
0, // border
(GLenum)args->a5,
(GLenum)args->a6,
(const GLvoid*)parg);
break;
case glfnTexSubImage2D:
glTexSubImage2D(
(GLenum)args->a0,
(GLint)args->a1,
(GLint)args->a2,
(GLint)args->a3,
(GLsizei)args->a4,
(GLsizei)args->a5,
(GLenum)args->a6,
(GLenum)args->a7,
(const GLvoid*)parg);
break;
case glfnTexParameterf:
glTexParameterf((GLenum)args->a0, (GLenum)args->a1, *(GLfloat*)&args->a2);
break;
case glfnTexParameterfv:
glTexParameterfv((GLenum)args->a0, (GLenum)args->a1, (GLfloat*)parg);
break;
case glfnTexParameteri:
glTexParameteri((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2);
break;
case glfnTexParameteriv:
glTexParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)parg);
break;
case glfnUniform1f:
glUniform1f((GLint)args->a0, *(GLfloat*)&args->a1);
break;
case glfnUniform1fv:
glUniform1fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg);
break;
case glfnUniform1i:
glUniform1i((GLint)args->a0, (GLint)args->a1);
break;
case glfnUniform1iv:
glUniform1iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg);
break;
case glfnUniform2f:
glUniform2f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2);
break;
case glfnUniform2fv:
glUniform2fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg);
break;
case glfnUniform2i:
glUniform2i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2);
break;
case glfnUniform2iv:
glUniform2iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg);
break;
case glfnUniform3f:
glUniform3f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3);
break;
case glfnUniform3fv:
glUniform3fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg);
break;
case glfnUniform3i:
glUniform3i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3);
break;
case glfnUniform3iv:
glUniform3iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg);
break;
case glfnUniform4f:
glUniform4f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3, *(GLfloat*)&args->a4);
break;
case glfnUniform4fv:
glUniform4fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg);
break;
case glfnUniform4i:
glUniform4i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4);
break;
case glfnUniform4iv:
glUniform4iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg);
break;
case glfnUniformMatrix2fv:
glUniformMatrix2fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)parg);
break;
case glfnUniformMatrix3fv:
glUniformMatrix3fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)parg);
break;
case glfnUniformMatrix4fv:
glUniformMatrix4fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)parg);
break;
case glfnUseProgram:
glUseProgram((GLint)args->a0);
break;
case glfnValidateProgram:
glValidateProgram((GLint)args->a0);
break;
case glfnVertexAttrib1f:
glVertexAttrib1f((GLint)args->a0, *(GLfloat*)&args->a1);
break;
case glfnVertexAttrib1fv:
glVertexAttrib1fv((GLint)args->a0, (GLfloat*)parg);
break;
case glfnVertexAttrib2f:
glVertexAttrib2f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2);
break;
case glfnVertexAttrib2fv:
glVertexAttrib2fv((GLint)args->a0, (GLfloat*)parg);
break;
case glfnVertexAttrib3f:
glVertexAttrib3f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3);
break;
case glfnVertexAttrib3fv:
glVertexAttrib3fv((GLint)args->a0, (GLfloat*)parg);
break;
case glfnVertexAttrib4f:
glVertexAttrib4f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3, *(GLfloat*)&args->a4);
break;
case glfnVertexAttrib4fv:
glVertexAttrib4fv((GLint)args->a0, (GLfloat*)parg);
break;
case glfnVertexAttribPointer:
glVertexAttribPointer((GLuint)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLboolean)args->a3, (GLsizei)args->a4, (const GLvoid*)args->a5);
break;
case glfnViewport:
glViewport((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3);
break;
}
return ret;
}
enum piglit_result piglit_display(void)
{
GLvoid *datap;
GLint intv[] = { 1, 1, 1, 1 };
GLfloat floatv[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat quad[] = { -1.0, 1.0, 1.0, 1.0, -1.0, -1.0, 1.0, -1.0 };
GLsizei length;
GLint size;
GLenum type;
GLchar buffer[64];
GLuint program, vShader, fShader;
int maxAttribCount;
/* --- valid program needed for some of the functions --- */
fShader = glCreateShader(GL_FRAGMENT_SHADER);
vShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(fShader, 1, &fShaderString, NULL);
glShaderSource(vShader, 1, &vShaderString, NULL);
glCompileShader(vShader);
glCompileShader(fShader);
program = glCreateProgram();
glAttachShader(program, vShader);
glAttachShader(program, fShader);
glLinkProgram(program);
glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxAttribCount);
/* --- tests begin here --- */
glVertexAttrib1f(maxAttribCount, floatv[0]);
CHECK_GL_INVALID_VALUE;
glVertexAttrib2f(maxAttribCount, floatv[0], floatv[1]);
CHECK_GL_INVALID_VALUE;
glVertexAttrib3f(maxAttribCount, floatv[0], floatv[1], floatv[2]);
CHECK_GL_INVALID_VALUE;
glVertexAttrib4f(maxAttribCount, floatv[0], floatv[1], floatv[2],
floatv[3]);
CHECK_GL_INVALID_VALUE;
glVertexAttrib1fv(maxAttribCount, floatv);
CHECK_GL_INVALID_VALUE;
glVertexAttrib2fv(maxAttribCount, floatv);
CHECK_GL_INVALID_VALUE;
glVertexAttrib3fv(maxAttribCount, floatv);
CHECK_GL_INVALID_VALUE;
glVertexAttrib4fv(maxAttribCount, floatv);
CHECK_GL_INVALID_VALUE;
glVertexAttribPointer(maxAttribCount, 2, GL_FLOAT, GL_FALSE, 0, quad);
CHECK_GL_INVALID_VALUE;
glBindAttribLocation(program, maxAttribCount, "pos");
CHECK_GL_INVALID_VALUE;
glEnableVertexAttribArray(maxAttribCount);
CHECK_GL_INVALID_VALUE;
glDisableVertexAttribArray(maxAttribCount);
CHECK_GL_INVALID_VALUE;
glGetVertexAttribfv(maxAttribCount, GL_CURRENT_VERTEX_ATTRIB, floatv);
CHECK_GL_INVALID_VALUE;
glGetVertexAttribiv(maxAttribCount, GL_CURRENT_VERTEX_ATTRIB, intv);
CHECK_GL_INVALID_VALUE;
glGetVertexAttribPointerv(maxAttribCount, GL_VERTEX_ATTRIB_ARRAY_POINTER, &datap);
CHECK_GL_INVALID_VALUE;
glGetActiveAttrib(program, maxAttribCount, 64, &length, &size, &type, buffer);
CHECK_GL_INVALID_VALUE;
return PIGLIT_PASS;
}
void ShaderProgram::sendVertexAttrib2f(GLint location, GLfloat v0, GLfloat v1)
{
bind();
glVertexAttrib2f(location, v0, v1);
unbind();
}
void Scene::RenderQuaxolChunk(Camera* pCamera, Shader* pShader) {
if(!m_pQuaxolChunk) return;
WasGLErrorPlusPrint();
pShader->StartUsing();
pShader->SetCameraParams(pCamera);
Mat4f worldMatrix;
worldMatrix.storeIdentity();
pShader->SetOrientation(&worldMatrix);
WasGLErrorPlusPrint();
if (m_pQuaxolAtlas) {
GLint hTex0 = pShader->getUniform("texDiffuse0");
if (hTex0 != -1) {
glActiveTexture(GL_TEXTURE0);
WasGLErrorPlusPrint();
glBindTexture(GL_TEXTURE_2D, m_pQuaxolAtlas->GetTextureID());
//WasGLErrorPlusPrint();
// glUniform1i(hTex0, 0);
}
}
GLint hTexCoord = glGetAttribLocation(pShader->getProgramId(), "vertCoord");
//GLint hTexCoord = pShader->getAttrib("vertCoord");
static Vec4f zero(0,0,0,0);
pShader->SetPosition(&zero);
GLuint colorHandle = pShader->GetColorHandle();
glBegin(GL_TRIANGLES);
// TODO: use vbo, as we have already done the work to put things into
// a nice format.
IndexList& indices = m_pQuaxolChunk->m_indices;
VecList& verts = m_pQuaxolChunk->m_verts;
QVertList& packVerts = m_pQuaxolChunk->m_packVerts;
int numTris = (int)indices.size() / 3;
int currentIndex = 0;
for (int tri = 0; tri < numTris; ++tri) {
const QuaxolVert& vA = packVerts[indices[currentIndex]];
const Vec4f& a = verts[indices[currentIndex++]];
const QuaxolVert& vB = packVerts[indices[currentIndex]];
const Vec4f& b = verts[indices[currentIndex++]];
const QuaxolVert& vC = packVerts[indices[currentIndex]];
const Vec4f& c = verts[indices[currentIndex++]];
if (colorHandle != -1) {
float minW = (std::min)(a.w, (std::min)(b.w, c.w));
int colorIndex = ((int)abs(minW)) % m_colorArray.size();
glVertexAttrib4fv(colorHandle, m_colorArray[colorIndex].raw());
}
if (hTexCoord != -1) {
const float invTexSteps = 1.0f / 16.0f;
int firstTriOffset = tri % 2;
glVertexAttrib2f(hTexCoord,
(float)((vA._uvInd % 8) + 0) * invTexSteps,
(float)((vA._uvInd / 8) + firstTriOffset) * invTexSteps);
glVertex4fv(a.raw());
glVertexAttrib2f(hTexCoord,
(float)((vB._uvInd % 8) + 1) * invTexSteps,
(float)((vB._uvInd / 8) + 0) * invTexSteps);
glVertex4fv(b.raw());
glVertexAttrib2f(hTexCoord,
(float)((vC._uvInd % 8) + firstTriOffset) * invTexSteps,
(float)((vC._uvInd / 8) + 1) * invTexSteps);
glVertex4fv(c.raw());
} else {
glVertex4fv(a.raw());
glVertex4fv(b.raw());
glVertex4fv(c.raw());
}
}
glEnd();
pShader->StopUsing();
}
void vertex_attrib_2f(gl::uint_t index, gl::float_t x, gl::float_t y) {
glVertexAttrib2f(index, x, y);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglVertexAttrib2f(JNIEnv *env, jclass clazz, jint index, jfloat x, jfloat y, jlong function_pointer) {
glVertexAttrib2fPROC glVertexAttrib2f = (glVertexAttrib2fPROC)((intptr_t)function_pointer);
glVertexAttrib2f(index, x, y);
}
void Shader::SetAttribute(const char* var, float v0, float v1)
{
int id = GetAttributeId(var);
if(id >= 0)
glVertexAttrib2f(id, v0, v1);
}
void GlShaderProgram::setAttributeVec2Float(const std::string &variableName, const float f1, const float f2) {
GLint loc = getAttributeVariableLocation(variableName);
glVertexAttrib2f(loc, f1, f2);
}
void AttributeVariable::set(GLfloat f0_, GLfloat f1_)
{
glVertexAttrib2f(_location, f0_, f1_);
}
// 2{f,d,s,fv,dv,sv}
void shader_gl3::attribute(const char* name, const float& arg1, const float& arg2) const {
A2E_CHECK_ATTRIBUTE_EXISTENCE(name);
A2E_CHECK_ATTRIBUTE_TYPE(name, GL_FLOAT_VEC2);
glVertexAttrib2f(A2E_SHADER_GET_ATTRIBUTE_POSITION(name), arg1, arg2);
}
void TriMesh::initializeVertexGL(const char * vertArrayName, const std::vector<unsigned int>& elementInds,
const char * positionAttrName, const char * normAttrName,
const char * colorAttrName, const char* texCoordAttrName)
{
unsigned int vertexShaderId = shaderId(vertArrayName);
if (!vertexShaderId) {
return;
}
// create VBA VBO for rendering ...
GLuint vertexArray;
glGenVertexArrays(1, &vertexArray);
glBindVertexArray(vertexArray);
// store this vertex array id
setVAO(vertArrayName, vertexArray);
// Buffer for element indices
GlBuffer elementBuffer;
elementBuffer.bind(GL_ELEMENT_ARRAY_BUFFER);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, elementInds.size()*sizeof(unsigned int), &elementInds[0], GL_STATIC_DRAW);
// Position attribute
GlBuffer positionBuffer;
positionBuffer.bind(GL_ARRAY_BUFFER);
glBufferData(GL_ARRAY_BUFFER, m_verts.size() * sizeof(float), &m_verts[0], GL_STATIC_DRAW);
GLuint positionAttribute = glGetAttribLocation(vertexShaderId, positionAttrName);
glVertexAttribPointer(positionAttribute, 3, GL_FLOAT, GL_FALSE, sizeof(float) * (3), (const GLvoid *) 0);
glEnableVertexAttribArray(positionAttribute);
// Normal attribute
GlBuffer normalBuffer;
normalBuffer.bind(GL_ARRAY_BUFFER);
glBufferData(GL_ARRAY_BUFFER, m_normals.size() * sizeof(float), &m_normals[0], GL_STATIC_DRAW);
GLuint normalAttribute = glGetAttribLocation(vertexShaderId, normAttrName);
glVertexAttribPointer(normalAttribute, 3, GL_FLOAT, GL_FALSE, sizeof(float) * (3), (const GLvoid *) 0);
glEnableVertexAttribArray(normalAttribute);
// Color attribute
GlBuffer colorBuffer;
colorBuffer.bind(GL_ARRAY_BUFFER);
if (!m_colors.empty())
{
glBufferData(GL_ARRAY_BUFFER, m_colors.size() * sizeof(float), &m_colors[0], GL_STATIC_DRAW);
}
else
{
std::vector<float> tmp_colors(m_verts.size(), 1.0f);
glBufferData(GL_ARRAY_BUFFER, tmp_colors.size() * sizeof(float), &tmp_colors[0], GL_STATIC_DRAW);
}
GLuint colorAttribute = glGetAttribLocation(vertexShaderId, colorAttrName);
glVertexAttribPointer(colorAttribute, 3, GL_FLOAT, GL_FALSE, sizeof(float) * (3), (const GLvoid *) 0);
glEnableVertexAttribArray(colorAttribute);
// Texture coordinate
GLint texcoordsLocation = glGetAttribLocation(vertexShaderId, texCoordAttrName);
GlBuffer texcoordBuffer;
if (texcoordsLocation != -1)
{
if (m_texcoords.empty())
{
glDisableVertexAttribArray(texcoordsLocation);
glVertexAttrib2f(texcoordsLocation, 0, 0);
}
else
{
texcoordBuffer.bind(GL_ARRAY_BUFFER);
glBufferData(GL_ARRAY_BUFFER, m_texcoords.size() * sizeof(float), &m_texcoords[0], GL_STATIC_DRAW);
glVertexAttribPointer(texcoordsLocation, 2, GL_FLOAT, GL_FALSE, sizeof(float) * (2), (const GLvoid *) 0);
glEnableVertexAttribArray(texcoordsLocation);
}
}
glBindVertexArray(0);
}
void GraphicsContext3D::vertexAttrib2f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1)
{
makeContextCurrent();
glVertexAttrib2f(index, v0, v1);
}
// 2 components
void ShaderProgram::setAttribute(GLint index, GLfloat v1, GLfloat v2)
{
glVertexAttrib2f(index, v1, v2);
}
//--------------------------------------------------------------
void ofShader::setAttribute2f(GLint location, float v1, float v2) const{
if(bLoaded)
glVertexAttrib2f(location, v1, v2);
}
void PShader::setAttribute(std::string name, GLfloat v0, GLfloat v1) {
glVertexAttrib2f(glGetAttribLocation(glProgram, name.c_str()), v0, v1);
}
