static void br_opengl_draw_tooltip(duc_graph *g, double x, double y, char *text) { struct opengl_backend_data *bd = g->backend_data; double w, h; text_size(g, text, &w, &h, FONT_SIZE_TOOLTIP); GLfloat vVertices[] = { x - g->cx - w - 10, y - g->cy - h - 15, x - g->cx , y - g->cy - h - 15, x - g->cx , y - g->cy , x - g->cx - w - 10, y - g->cy , }; glVertexAttribPointer(bd->loc_pos, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), &vVertices[0]); glDisableVertexAttribArray(bd->loc_color); glDisableVertexAttribArray(bd->loc_texture); glVertexAttrib4f(bd->loc_color, 1, 1, 1, 0); GLushort indices[] = { 0, 1, 2, 0, 2, 3 }; glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices); glVertexAttrib4f(bd->loc_color, 0, 0, 0, 0); glDrawArrays(GL_LINE_LOOP, 0, 4); draw_text(g, x - w - 5, y - h - 5, FONT_SIZE_TOOLTIP, text); }
GeomProgram::GeomProgram () : vertex_shader ("../Common/Shaders/Geom-Vertex.glsl", GL_VERTEX_SHADER), fragment_shader ("../Common/Shaders/Geom-Fragment.glsl", GL_FRAGMENT_SHADER) { program.add_shader (vertex_shader); program.add_shader (fragment_shader); program.fix_attrib ("attrib_position", attrib_position); //program.fix_attrib ("attrib_normal", attrib_normal); program.fix_attrib ("attrib_tcoords", attrib_tcoords); program.fix_attrib ("attrib_colour", attrib_colour); program.link (); program.use (); u32 tex_diffuse = program.link_uniform ("tex_diffuse"); glUniform1i (tex_diffuse, texunit_diffuse); glVertexAttrib4f (attrib_colour, 1.0f, 1.0f, 1.0f, 1.0f); check_gl ("glVertexAttrib4f"); program.done (); /*world_to_clip = program.link_uniform ("world_to_clip"); world_to_eye = program.link_uniform ("world_to_eye"); model_to_world = program.link_uniform ("model_to_world");*/ model_to_clip = program.link_uniform ("model_to_clip"); }
SubCanvas::SubCanvas(Canvas &canvas, RasterPoint _offset, PixelSize _size) :relative(_offset) { assert(canvas.offset == OpenGL::translate); offset = canvas.offset + _offset; /* sub canvas bottom right limits can't be outside "parent" canvas. */ size.cx = std::min<PixelScalar>(_size.cx, canvas.GetSize().cx - _offset.x) ; size.cy = std::min<PixelScalar>(_size.cy, canvas.GetSize().cy - _offset.y) ; if (relative.x != 0 || relative.y != 0) { OpenGL::translate += _offset; #ifdef USE_GLSL glVertexAttrib4f(OpenGL::Attribute::TRANSLATE, OpenGL::translate.x, OpenGL::translate.y, 0, 0); #else glPushMatrix(); #ifdef HAVE_GLES glTranslatex((GLfixed)relative.x << 16, (GLfixed)relative.y << 16, 0); #else glTranslatef(relative.x, relative.y, 0); #endif #endif /* !USE_GLSL */ } if ((relative.x + size.cx < canvas.GetSize().cx) || (relative.y + size.cy < canvas.GetSize().cy)) { /* Enable Clipping */ push_scissor = std::make_unique<GLPushScissor>(); scissor = std::make_unique<GLCanvasScissor>(*this); } }
bool atomic_counters_draw_point(GLuint prog, unsigned buf_size, const uint32_t *buf) { GLuint vao; /* Initialize the atomic counter buffer. */ glBufferData(GL_ATOMIC_COUNTER_BUFFER, buf_size * sizeof(uint32_t), buf, GL_STATIC_DRAW); /* Link and set the current shader program. */ atomic_counters_link(prog); glUseProgram(prog); /* Draw. */ glClearColor(0.5, 0.5, 0.5, 0.5); glClear(GL_COLOR_BUFFER_BIT); glGenVertexArrays(1, &vao); glBindVertexArray(vao); glVertexAttrib4f(0, 0, 0, 0, 1); glDrawArrays(GL_POINTS, 0, 1); glDeleteVertexArrays(1, &vao); return piglit_check_gl_error(GL_NO_ERROR); }
/*! \brief Sets the value of a vertex attribute, if no attribute array is bound. This function only sets the state if it has been updated. */ inline void setAttribute(GLuint idx, GLfloat x = 0, GLfloat y = 0, GLfloat z = 0, GLfloat w = 0) { if (idx >= _vertexAttributeState.size()) M_throw() << "Attribute index out of range"; if (idx == 0) M_throw() << "Cannot set the value of the 0th vertex attribute."; std::array<GLfloat, 4> newval = {{x,y,z,w}}; #ifdef MAGNET_DEBUG std::array<GLfloat, 4> oldval; glGetVertexAttribfv(idx, GL_CURRENT_VERTEX_ATTRIB, &oldval[0]); detail::errorCheck(); if (oldval != _vertexAttributeState[idx].current_value) M_throw() << "Vertex attribute state changed without using the GL context!"; #endif if (newval == _vertexAttributeState[idx].current_value) return; _vertexAttributeState[idx].current_value = newval; glVertexAttrib4f(idx, newval[0], newval[1], newval[2], newval[3]); detail::errorCheck(); }
void OpenGL::useVertexAttribArrays(uint32 arraybits) { uint32 diff = arraybits ^ state.enabledAttribArrays; if (diff == 0) return; // Max 32 attributes. As of when this was written, no GL driver exposes more // than 32. Lets hope that doesn't change... for (uint32 i = 0; i < 32; i++) { uint32 bit = 1 << i; if (diff & bit) { if (arraybits & bit) glEnableVertexAttribArray(i); else glDisableVertexAttribArray(i); } } state.enabledAttribArrays = arraybits; // glDisableVertexAttribArray will make the constant value for a vertex // attribute undefined. We rely on the per-vertex color attribute being // white when no per-vertex color is used, so we set it here. // FIXME: Is there a better place to do this? if ((diff & ATTRIBFLAG_COLOR) && !(arraybits & ATTRIBFLAG_COLOR)) glVertexAttrib4f(ATTRIB_COLOR, 1.0f, 1.0f, 1.0f, 1.0f); }
void RenderingEngine::render(const vector<Visual>& visuals) const { glClearColor(0.0f, 0.0f, 0.0f, 1); glClear(GL_COLOR_BUFFER_BIT); vector<Visual>::const_iterator visual = visuals.begin(); for (int visualIndex = 0; visual != visuals.end(); ++visual, ++visualIndex) { // Set the viewport transform. ivec2 size = visual->viewportSize; ivec2 lowerLeft = visual->lowerLeft; glViewport(lowerLeft.x, lowerLeft.y, size.x, size.y); // Set the model-view transform. mat4 rotation = visual->orientation.toMatrix(); mat4 modelview = rotation * _translation; glUniformMatrix4fv(_modelviewUniform, 1, 0, modelview.pointer()); // Set the projection transform. float h = 4.0f * size.y / size.x; mat4 projectionMatrix = mat4::frustum(-2, 2, -h / 2, h / 2, 5, 10); glUniformMatrix4fv(_projectionUniform, 1, 0, projectionMatrix.pointer()); // Set the color. vec3 color = visual->color; glVertexAttrib4f(_colorSlot, color.x, color.y, color.z, 1); // Draw the wireframe. const Drawable& drawable = _drawables[visualIndex]; glBindBuffer(GL_ARRAY_BUFFER, drawable.vertexBuffer); glVertexAttribPointer(_positionSlot, 3, GL_FLOAT, GL_FALSE, sizeof(vec3), 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, drawable.indexBuffer); glDrawElements(GL_LINES, drawable.indexCount, GL_UNSIGNED_SHORT, 0); } }
void SQPrimitives::drawCubeGeometry(const QVector4D &color) { // Tell OpenGL which VBOs to use glBindBuffer(GL_ARRAY_BUFFER, _vboIds[0]); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _vboIds[1]); // Offset for position quintptr offset = 0; // Tell OpenGL programmable pipeline how to locate vertex position data int vertexLocation = _program->attributeLocation("a_position"); _program->enableAttributeArray(vertexLocation); glVertexAttribPointer(vertexLocation, 3, GL_FLOAT, GL_FALSE, sizeof(VertexData), (const void *)offset); // Offset for texture coordinate offset += sizeof(QVector3D); // Tell OpenGL programmable pipeline how to locate vertex texture coordinate data int texcoordLocation = _program->attributeLocation("a_texcoord"); _program->enableAttributeArray(texcoordLocation); glVertexAttribPointer(texcoordLocation, 2, GL_FLOAT, GL_FALSE, sizeof(VertexData), (const void *)offset); int colorLocation = _program->attributeLocation("a_color"); glVertexAttrib4f(colorLocation, color.x(), color.y(), color.z(), color.w()); // Draw cube geometry using indices from VBO 1 glDrawElements(GL_TRIANGLE_STRIP, 34, GL_UNSIGNED_SHORT, 0); }
// -------------------------------------------------------------------------------------------------------------------- void UntexturedObjectsGLTexCoord::Render(const std::vector<Matrix>& _transforms) { // Program Vec3 dir = { -0.5f, -1, 1 }; Vec3 at = { 0, 0, 0 }; Vec3 up = { 0, 0, 1 }; dir = normalize(dir); Vec3 eye = at - 250 * dir; Matrix view = matrix_look_at(eye, at, up); Matrix view_proj = mProj * view; glUseProgram(m_prog); glUniformMatrix4fv(mUniformLocation.ViewProjection, 1, GL_TRUE, &view_proj.x.x); // Input Layout glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ib); glBindBuffer(GL_ARRAY_BUFFER, m_vb); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(UntexturedObjectsProblem::Vertex), (void*)offsetof(UntexturedObjectsProblem::Vertex, pos)); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(UntexturedObjectsProblem::Vertex), (void*)offsetof(UntexturedObjectsProblem::Vertex, color)); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); // Rasterizer State glEnable(GL_CULL_FACE); glCullFace(GL_FRONT); glDisable(GL_SCISSOR_TEST); // Blend State glDisable(GL_BLEND); glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); // Depth Stencil State glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); for (auto it = _transforms.begin(); it != _transforms.end(); ++it) { const Matrix* m = &*it; glVertexAttrib4f(2, m->x.x, m->x.y, m->x.z, m->x.w); glVertexAttrib4f(3, m->y.x, m->y.y, m->y.z, m->y.w); glVertexAttrib4f(4, m->z.x, m->z.y, m->z.z, m->z.w); glVertexAttrib4f(5, m->w.x, m->w.y, m->w.z, m->w.w); glDrawElements(GL_TRIANGLES, mIndexCount, GL_UNSIGNED_SHORT, nullptr); } }
void BufferCanvas::Commit(Canvas &other) { assert(IsDefined()); assert(active); assert(GetWidth() == other.GetWidth()); assert(GetHeight() == other.GetHeight()); if (frame_buffer != nullptr) { assert(OpenGL::translate.x == 0); assert(OpenGL::translate.y == 0); frame_buffer->Unbind(); /* restore the old viewport */ assert(OpenGL::translate == RasterPoint(0, 0)); #ifdef HAVE_GLES /* there's no glPopAttrib() on GL/ES; emulate it */ glViewport(old_viewport[0], old_viewport[1], old_viewport[2], old_viewport[3]); #else glPopAttrib(); #endif #ifdef USE_GLSL OpenGL::projection_matrix = old_projection_matrix; OpenGL::UpdateShaderProjectionMatrix(); #else glMatrixMode(GL_PROJECTION); glPopMatrix(); glMatrixMode(GL_MODELVIEW); glPopMatrix(); #endif OpenGL::translate = old_translate; OpenGL::viewport_size = old_size; #ifdef USE_GLSL glVertexAttrib4f(OpenGL::Attribute::TRANSLATE, OpenGL::translate.x, OpenGL::translate.y, 0, 0); #endif #ifdef SOFTWARE_ROTATE_DISPLAY OpenGL::display_orientation = old_orientation; #endif /* copy frame buffer to screen */ CopyTo(other); } else { assert(offset == other.offset); /* copy screen to texture */ CopyToTexture(*texture, GetRect()); } active = false; }
void RenderFigure() { glCullFace(GL_CW); LoadModelViewProjectionMatrixToShader(); glVertexAttrib4f(GLT_ATTRIBUTE_COLOR, 0.75f, 0.f, 0.f, 1.0f); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,faces_buffer); glDrawElements(GL_TRIANGLES,3*n_faces,GL_UNSIGNED_INT,0); }
void color_light_shader::setup_gl_attribs_val() const noexcept { glVertexAttrib4f( static_cast<GLuint>(shader_attrib_location::vertex), 0, 0, 0, 1); glVertexAttrib4f( static_cast<GLuint>(shader_attrib_location::transformation) + 0, 1, 0, 0, 0); glVertexAttrib4f( static_cast<GLuint>(shader_attrib_location::transformation) + 1, 0, 1, 0, 0); glVertexAttrib4f( static_cast<GLuint>(shader_attrib_location::transformation) + 2, 0, 0, 1, 0); glVertexAttrib4f( static_cast<GLuint>(shader_attrib_location::transformation) + 3, 0, 0, 0, 1); }
static void br_opengl_draw_section(duc_graph *g, double a1, double a2, double r1, double r2, double R, double G, double B, double L) { struct opengl_backend_data *bd = g->backend_data; int i; a1 *= M_PI * 2; a2 *= M_PI * 2; int ss = (int)((a2 - a1) * r2 / 10 + 2); GLfloat vs_fill[ss * 2][6]; GLfloat vs_line[ss * 2][2]; double da = (a2-a1) / (ss-1); for(i=0; i<ss; i++) { double x1, y1, x2, y2; x1 = r1 * sin(a1 + da * i); y1 = -r1 * cos(a1 + da * i); x2 = r2 * sin(a1 + da * i); y2 = -r2 * cos(a1 + da * i); vs_fill[i*2 + 0][0] = x1; vs_fill[i*2 + 0][1] = y1; vs_fill[i*2 + 0][2] = R * (g->gradient ? 0.7 : 1.0); vs_fill[i*2 + 0][3] = G * (g->gradient ? 0.7 : 1.0); vs_fill[i*2 + 0][4] = B * (g->gradient ? 0.7 : 1.0); vs_fill[i*2 + 0][5] = 0; vs_fill[i*2 + 1][0] = x2; vs_fill[i*2 + 1][1] = y2; vs_fill[i*2 + 1][2] = R; vs_fill[i*2 + 1][3] = G; vs_fill[i*2 + 1][4] = B; vs_fill[i*2 + 1][5] = 0; vs_line[i][0] = x1; vs_line[i][1] = y1; vs_line[2*ss-i-1][0] = x2; vs_line[2*ss-i-1][1] = y2; } glDisable(GL_TEXTURE_2D); if(R != 1.0 || G != 1.0 || B != 1.0) { glEnableVertexAttribArray(bd->loc_pos); glEnableVertexAttribArray(bd->loc_color); glVertexAttribPointer(bd->loc_pos, 2, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), &vs_fill[0][0]); glVertexAttribPointer(bd->loc_color, 4, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), &vs_fill[0][2]); glDrawArrays(GL_TRIANGLE_STRIP, 0, ss*2); } if(L != 0.0) { glLineWidth(0.8); glDisableVertexAttribArray(bd->loc_color); glVertexAttrib4f(bd->loc_color, L, L, L, 0); glVertexAttribPointer(bd->loc_pos, 2, GL_FLOAT, GL_FALSE, 0, vs_line); glDrawArrays(GL_LINE_LOOP, 0, ss*2); } }
void OpenGL::InitShaders() { DeinitShaders(); solid_shader = CompileProgram(solid_vertex_shader, solid_fragment_shader); solid_shader->BindAttribLocation(Attribute::TRANSLATE, "translate"); solid_shader->BindAttribLocation(Attribute::POSITION, "position"); solid_shader->BindAttribLocation(Attribute::COLOR, "color"); LinkProgram(*solid_shader); solid_projection = solid_shader->GetUniformLocation("projection"); solid_modelview = solid_shader->GetUniformLocation("modelview"); solid_shader->Use(); glUniformMatrix4fv(solid_modelview, 1, GL_FALSE, glm::value_ptr(glm::mat4())); texture_shader = CompileProgram(texture_vertex_shader, texture_fragment_shader); texture_shader->BindAttribLocation(Attribute::TRANSLATE, "translate"); texture_shader->BindAttribLocation(Attribute::POSITION, "position"); texture_shader->BindAttribLocation(Attribute::TEXCOORD, "texcoord"); LinkProgram(*texture_shader); texture_projection = texture_shader->GetUniformLocation("projection"); texture_texture = texture_shader->GetUniformLocation("texture"); texture_shader->Use(); glUniform1i(texture_texture, 0); invert_shader = CompileProgram(invert_vertex_shader, invert_fragment_shader); invert_shader->BindAttribLocation(Attribute::TRANSLATE, "translate"); invert_shader->BindAttribLocation(Attribute::POSITION, "position"); invert_shader->BindAttribLocation(Attribute::TEXCOORD, "texcoord"); LinkProgram(*invert_shader); invert_projection = invert_shader->GetUniformLocation("projection"); invert_texture = invert_shader->GetUniformLocation("texture"); invert_shader->Use(); glUniform1i(invert_texture, 0); alpha_shader = CompileProgram(alpha_vertex_shader, alpha_fragment_shader); alpha_shader->BindAttribLocation(Attribute::TRANSLATE, "translate"); alpha_shader->BindAttribLocation(Attribute::POSITION, "position"); alpha_shader->BindAttribLocation(Attribute::TEXCOORD, "texcoord"); alpha_shader->BindAttribLocation(Attribute::COLOR, "color"); LinkProgram(*alpha_shader); alpha_projection = alpha_shader->GetUniformLocation("projection"); alpha_texture = alpha_shader->GetUniformLocation("texture"); alpha_shader->Use(); glUniform1i(alpha_texture, 0); glVertexAttrib4f(Attribute::TRANSLATE, 0, 0, 0, 0); }
void GLESDebugDraw::DrawParticles(const b2Vec2 *centers_old, float32 radius, const b2ParticleColor *colors, int32 count) { /* // normally this is how we'd enable them on desktop OpenGL, // but for some reason this is not applying textures, so we use alpha instead glEnable(GL_POINT_SPRITE); glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE); */ const float particle_size_multiplier = 8; // no falloff const float global_alpha = 0.35f; // instead of texture mShaderProgram->setUniformLocationWith1f(mPointSizeLocation, radius * mRatio * particle_size_multiplier); GL::blendFunc(GL_SRC_ALPHA, GL_ONE); b2Vec2 *centers = (b2Vec2 *) alloca(sizeof(b2Vec2) * count); for(int i=0; i<count; i++) { centers[i].x = centers_old[i].x *mRatio; centers[i].y = centers_old[i].y *mRatio; } glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, centers); glVertexAttrib4f(GLProgram::VERTEX_ATTRIB_TEX_COORDS, 0, 0, 1, 1); if (0 /*colors*/) { // hack to render with proper alpha on desktop for Testbed b2ParticleColor * mcolors = const_cast<b2ParticleColor *>(colors); for (int i = 0; i < count; i++) { mcolors[i].a = static_cast<uint8>(global_alpha * 255); } glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, &colors[0].r); } else { glVertexAttrib4f(GLProgram::VERTEX_ATTRIB_COLOR, 1, 1, 1, global_alpha); mShaderProgram->setUniformLocationWith4f(mColorLocation, 1, 1, 1, global_alpha); } glDrawArrays(GL_POINTS, 0, count); CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,count); }
void RasterizerCanvasGLES2::_draw_polygon(const int *p_indices, int p_index_count, int p_vertex_count, const Vector2 *p_vertices, const Vector2 *p_uvs, const Color *p_colors, bool p_singlecolor) { glBindBuffer(GL_ARRAY_BUFFER, data.polygon_buffer); uint32_t buffer_ofs = 0; glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(Vector2) * p_vertex_count, p_vertices); glEnableVertexAttribArray(VS::ARRAY_VERTEX); glVertexAttribPointer(VS::ARRAY_VERTEX, 2, GL_FLOAT, GL_FALSE, sizeof(Vector2), NULL); buffer_ofs += sizeof(Vector2) * p_vertex_count; if (p_singlecolor) { glDisableVertexAttribArray(VS::ARRAY_COLOR); Color m = *p_colors; glVertexAttrib4f(VS::ARRAY_COLOR, m.r, m.g, m.b, m.a); } else if (!p_colors) { glDisableVertexAttribArray(VS::ARRAY_COLOR); glVertexAttrib4f(VS::ARRAY_COLOR, 1, 1, 1, 1); } else { glBufferSubData(GL_ARRAY_BUFFER, buffer_ofs, sizeof(Color) * p_vertex_count, p_colors); glEnableVertexAttribArray(VS::ARRAY_COLOR); glVertexAttribPointer(VS::ARRAY_COLOR, 4, GL_FLOAT, GL_FALSE, sizeof(Color), ((uint8_t *)0) + buffer_ofs); buffer_ofs += sizeof(Color) * p_vertex_count; } if (p_uvs) { glBufferSubData(GL_ARRAY_BUFFER, buffer_ofs, sizeof(Vector2) * p_vertex_count, p_uvs); glEnableVertexAttribArray(VS::ARRAY_TEX_UV); glVertexAttribPointer(VS::ARRAY_TEX_UV, 2, GL_FLOAT, GL_FALSE, sizeof(Vector2), ((uint8_t *)0) + buffer_ofs); buffer_ofs += sizeof(Vector2) * p_vertex_count; } else { glDisableVertexAttribArray(VS::ARRAY_TEX_UV); } glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, data.polygon_index_buffer); glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, sizeof(int) * p_index_count, p_indices); glDrawElements(GL_TRIANGLES, p_index_count, GL_UNSIGNED_INT, 0); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); }
void THFrame::DrawTexture(const THVector2& p,const THVector2& center,const THVector2& size,const THRot2& rot,const THTexture *tex) { glBindTexture(GL_TEXTURE_2D,tex->image->textureID); glVertexAttrib2fv(THDefaultProgram.rotationHandler,(const GLfloat*)&rot); glVertexAttrib2fv(THDefaultProgram.scaleHandler,(const GLfloat*)&size); glVertexAttrib2fv(THDefaultProgram.positionHandler,(const GLfloat*)&p); glVertexAttrib4f(THDefaultProgram.textureHandler,tex->position.x,tex->position.y,tex->size.x,tex->size.y); glVertexAttrib2fv(THDefaultProgram.centerHandler,(const GLfloat*)¢er); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); }
void GLSLProgram<real>::SetupDefautState() { // Set default attributes glVertexAttrib3f( 0, 0.0, 0.0, 0.0 ); glVertexAttrib3f( 1, 1.0, 0.0, 0.0 ); glVertexAttrib3f( 2, 0.0, 0.0, 0.0 ); glVertexAttrib4f( 3, 1.0, 1.0, 1.0, 1.0 ); // No wireframe glPolygonMode( GL_FRONT_AND_BACK, GL_FILL ); }
void RenderSystem::setAttributeValue( int slot, float a, float b, float c, float d ) { glVertexAttrib4f( slot, a, b, c, d ); CROSS_GL_ASSERT(); }
void RenderingEngine::Render(const vector<Visual>& visuals) const { glClearColor(0.5f, 0.5f, 0.5f, 1); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); vector<Visual>::const_iterator visual = visuals.begin(); for (int visualIndex = 0; visual != visuals.end(); ++visual, ++visualIndex) { // Set the viewport transform. ivec2 size = visual->ViewportSize; ivec2 lowerLeft = visual->LowerLeft; glViewport(lowerLeft.x, lowerLeft.y, size.x, size.y); // Set the light position. vec4 lightPosition(0.25, 0.25, 1, 0); glUniform3fv(m_uniforms.LightPosition, 1, lightPosition.Pointer()); // Set the model-view transform. mat4 rotation = visual->Orientation.ToMatrix(); mat4 modelview = rotation * m_translation; glUniformMatrix4fv(m_uniforms.Modelview, 1, 0, modelview.Pointer()); // Set the normal matrix. // It's orthogonal, so its Inverse-Transpose is itself! mat3 normalMatrix = modelview.ToMat3(); glUniformMatrix3fv(m_uniforms.NormalMatrix, 1, 0, normalMatrix.Pointer()); // Set the projection transform. float h = 4.0f * size.y / size.x; mat4 projectionMatrix = mat4::Frustum(-2, 2, -h / 2, h / 2, 5, 10); glUniformMatrix4fv(m_uniforms.Projection, 1, 0, projectionMatrix.Pointer()); // Set the diffuse color. vec3 color = visual->Color * 0.75f; glVertexAttrib4f(m_attributes.Diffuse, color.x, color.y, color.z, 1); // Draw the surface. int stride = sizeof(vec3) + sizeof(vec3) + sizeof(vec2); const GLvoid* normalOffset = (const GLvoid*) sizeof(vec3); const GLvoid* texCoordOffset = (const GLvoid*) (2 * sizeof(vec3)); GLint position = m_attributes.Position; GLint normal = m_attributes.Normal; GLint texCoord = m_attributes.TextureCoord; const Drawable& drawable = m_drawables[visualIndex]; glBindBuffer(GL_ARRAY_BUFFER, drawable.VertexBuffer); glVertexAttribPointer(position, 3, GL_FLOAT, GL_FALSE, stride, 0); glVertexAttribPointer(normal, 3, GL_FLOAT, GL_FALSE, stride, normalOffset); glVertexAttribPointer(texCoord, 2, GL_FLOAT, GL_FALSE, stride, texCoordOffset); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, drawable.IndexBuffer); glDrawElements(GL_TRIANGLES, drawable.IndexCount, GL_UNSIGNED_SHORT, 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); }
void RenderPlane(float size) { glFrontFace(GL_CCW); glBegin(GL_QUADS); glVertexAttrib4f(GLT_ATTRIBUTE_COLOR, 0.75f, 0.75f, 0.75f, 1.0f); glVertex3f(-size, size, 0.0f); glVertex3f(-size, -size, 0.0f); glVertex3f(size, -size, 0.0f); glVertex3f(size, size, 0.0f); glEnd(); }
void Target_draw() { Matrix projectionMatrix; float ratio; float stringWidth; char indexString[32]; glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClear(GL_COLOR_BUFFER_BIT); ratio = (float) viewportWidth / viewportHeight; projectionMatrix = Matrix_ortho(Matrix_identity(), -ratio, ratio, -1.0f, 1.0f, -1.0f, 1.0f); if (GLGraphics_getOpenGLAPIVersion() == GL_API_VERSION_ES2) { glUniformMatrix4fv(matrixUniform, 1, GL_FALSE, projectionMatrix.m); glUniform1i(textureUniform, 0); glVertexAttrib4f(2, 1.0f, 1.0f, 1.0f, 1.0f); } else { glMatrixMode(GL_PROJECTION); glLoadMatrixf(projectionMatrix.m); glColor4f(1.0f, 1.0f, 1.0f, 1.0f); } stringWidth = font->measureString(font, "Hello, world!", 13); font->drawString(font, "Hello, world!", 13, 0.1f, stringWidth * -0.05f, 0.0f, 0.0f); stringWidth = font->measureString(font, freeformText, strlen(freeformText)); font->drawString(font, freeformText, strlen(freeformText), 0.0625f, stringWidth * -0.03125f, -0.0625f, 0.0f); if (GLGraphics_getOpenGLAPIVersion() == GL_API_VERSION_ES2) { glVertexAttrib4f(2, 0.875f, 0.875f, 0.5f, 1.0f); } else { glColor4f(0.875f, 0.875f, 0.5f, 1.0f); } snprintf(indexString, 32, "%u, %s", (unsigned int) lastIndexAtWidth, lastLeadingEdge ? "true" : "false"); stringWidth = font->measureString(font, indexString, strlen(indexString)); font->drawString(font, indexString, strlen(indexString), 0.05f, stringWidth * -0.025f, 0.1f, 0.0f); }
void Renderer10::Render() const { glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); // Configure blending glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Red Quad mat4 modelview; glVertexAttrib4f(m_attribColor, 1.0f, 0.0f, 0.0f, 1.0f); glUniformMatrix4fv(m_uniformModelview, 1, GL_FALSE, modelview.Pointer()); DrawQuad(); // Green Quad modelview = modelview.Translate(-0.5f, -0.5f, 0.0f); glVertexAttrib4f(m_attribColor, 0.0f, 1.0f, 0.0f, 0.5f); glUniformMatrix4fv(m_uniformModelview, 1, GL_FALSE, modelview.Pointer()); DrawQuad(); }
static void draw_text(duc_graph *g, double _x, double _y, double size, char *text) { struct opengl_backend_data *bd = g->backend_data; double x = _x - g->cx; double y = _y - g->cy - size * bd->font_scale * STB_SOMEFONT_LINE_SPACING; glDisableVertexAttribArray(bd->loc_color); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); char *p1 = text; char *p2 = text; while(*p2) { while(*p2 && *p2 != '\n' && *p2 != '\r') { p2++; } glVertexAttrib4f(bd->loc_color, 1, 1, 1, 0); draw_text_line(g, x-1, y+0, size, p1, p2-p1); draw_text_line(g, x+1, y-0, size, p1, p2-p1); draw_text_line(g, x-0, y+1, size, p1, p2-p1); draw_text_line(g, x+0, y-1, size, p1, p2-p1); glVertexAttrib4f(bd->loc_color, 0, 0, 0, 0); draw_text_line(g, x+0, y, size, p1, p2-p1); if(!*p2) break; y += size * bd->font_scale * STB_SOMEFONT_LINE_SPACING * 1.5; x = _x - g->cx; p2 ++; p1 = p2; } glBlendFunc(GL_ONE, GL_ZERO); }
void RasterizerCanvasGLES2::_draw_generic(GLuint p_primitive, int p_vertex_count, const Vector2 *p_vertices, const Vector2 *p_uvs, const Color *p_colors, bool p_singlecolor) { glBindBuffer(GL_ARRAY_BUFFER, data.polygon_buffer); uint32_t buffer_ofs = 0; glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(Vector2) * p_vertex_count, p_vertices); glEnableVertexAttribArray(VS::ARRAY_VERTEX); glVertexAttribPointer(VS::ARRAY_VERTEX, 2, GL_FLOAT, GL_FALSE, sizeof(Vector2), (uint8_t *)0); buffer_ofs += sizeof(Vector2) * p_vertex_count; if (p_singlecolor) { glDisableVertexAttribArray(VS::ARRAY_COLOR); Color m = *p_colors; glVertexAttrib4f(VS::ARRAY_COLOR, m.r, m.g, m.b, m.a); } else if (!p_colors) { glDisableVertexAttribArray(VS::ARRAY_COLOR); glVertexAttrib4f(VS::ARRAY_COLOR, 1, 1, 1, 1); } else { glBufferSubData(GL_ARRAY_BUFFER, buffer_ofs, sizeof(Color) * p_vertex_count, p_colors); glEnableVertexAttribArray(VS::ARRAY_COLOR); glVertexAttribPointer(VS::ARRAY_COLOR, 4, GL_FLOAT, GL_FALSE, sizeof(Color), ((uint8_t *)0) + buffer_ofs); buffer_ofs += sizeof(Color) * p_vertex_count; } if (p_uvs) { glBufferSubData(GL_ARRAY_BUFFER, buffer_ofs, sizeof(Vector2) * p_vertex_count, p_uvs); glEnableVertexAttribArray(VS::ARRAY_TEX_UV); glVertexAttribPointer(VS::ARRAY_TEX_UV, 2, GL_FLOAT, GL_FALSE, sizeof(Vector2), ((uint8_t *)0) + buffer_ofs); } else { glDisableVertexAttribArray(VS::ARRAY_TEX_UV); } glDrawArrays(p_primitive, 0, p_vertex_count); glBindBuffer(GL_ARRAY_BUFFER, 0); }
SubCanvas::~SubCanvas() { assert(offset == OpenGL::translate); if (relative.x != 0 || relative.y != 0) { OpenGL::translate -= relative; #ifdef USE_GLSL glVertexAttrib4f(OpenGL::Attribute::TRANSLATE, OpenGL::translate.x, OpenGL::translate.y, 0, 0); #else glPopMatrix(); #endif } }
/*! \brief Initializes the OpenGL context and state tracking. */ inline void init() { _frameCounter = 0; _context = getCurrentContextKey(); std::cout << "GL-Context " << _context << ": Created a new OpenGL context" << std::endl; //////////Capability testing ///////////////////////////// //Check for errors before running glew detail::errorCheck(); //We must set this true as glew uses deprecated code //(glGetString) for testing for extensions glewExperimental=true; if (glewInit() != GLEW_OK) M_throw() << "GL-Context " << _context << "Failed to initialise GLEW!"; //Suppress GL errors generated by glew, by fetching and //discarding the last GL error; glGetError(); std::cout << "GL-Context " << _context << ": OpenGL version " << detail::glGet<GL_MAJOR_VERSION>() << "." << detail::glGet<GL_MINOR_VERSION>() << std::endl; #ifdef MAGNET_DEBUG if (testExtension("GL_ARB_debug_output")) { glDebugMessageCallbackARB(&Context::DebugCallback, NULL); glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB); } #endif ///////Variable initialisation /////////////////////////// _viewPortState = detail::glGet<GL_VIEWPORT>(); _vertexAttributeState.resize(detail::glGet<GL_MAX_VERTEX_ATTRIBS>()); for (GLuint i(1); i < _vertexAttributeState.size(); ++i) { glVertexAttrib4f(i, 0,0,0,1); detail::errorCheck(); } color(0,1,1,1); resetInstanceTransform(); //Bind the dummy VAO object (so hacky) glGenVertexArrays(1, &_dummyVAO); detail::errorCheck(); glBindVertexArray(_dummyVAO); detail::errorCheck(); }
void VBOSphere::render() { if (vertexVBO == -1) { prepareVBO(); } glPushMatrix(); setMatrix(); #ifdef OPENGL_ES1 glColor4f(objectColor.r, objectColor.g, objectColor.b, objectColor.a); glDisableClientState(GL_COLOR_ARRAY); #else glDisableVertexAttribArray(shaderVertexColor); glVertexAttrib4f(shaderVertexColor, objectColor.r, objectColor.g, objectColor.b, objectColor.a); #endif glBindBuffer(GL_ARRAY_BUFFER, vertexVBO); #ifdef OPENGL_ES1 glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(3, GL_FLOAT, 0, 0); #else glEnableVertexAttribArray(shaderVertexPosition); glVertexAttribPointer(shaderVertexPosition, 3, GL_FLOAT, GL_FALSE, 0, 0); #endif glBindBuffer(GL_ARRAY_BUFFER, vertexNormalVBO); #ifdef OPENGL_ES1 glEnableClientState(GL_NORMAL_ARRAY); glNormalPointer(GL_FLOAT, 0, 0); #else glEnableVertexAttribArray(shaderVertexNormal); glVertexAttribPointer(shaderVertexNormal, 3, GL_FLOAT, GL_FALSE, 0, 0); #endif glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, faceVBO); glDrawElements(GL_TRIANGLES, faceCount * 3, GL_UNSIGNED_SHORT, 0); #ifdef OPENGL_ES1 glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); #endif glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glPopMatrix(); }
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; }