/* * Draws the plant. */ void drawPlant(int i,float scale,float radscale,int string) { char *ptr = lsystem[string]; char ch[] = { '\0','\0' }; GLfloat c1[] = { 0.6549f,0.4901f,0.2392f }; /* light brown */ GLfloat c2[] = { 0.3607f,0.2510f,0.2000f }; /* dark brown */ GLfloat c3[] = { 0.1373f,0.5568f,0.1373f }; /* forest green */ if(i==0) return; PushMatrix(); while(*ptr != '\0') { switch(*ptr) { case 'F': Rotate(tilt/10000,0.0,0.0,1.0); /* tilt very very slightly */ LoadMatrix(); if(do_growth && floor(growth)==i) { draw_branch(LENGTH*scale*(growth-1),RADIUS*radscale,BASE_TRI,c1,c2); Translate(0.0,LENGTH*scale*(growth-1),0.0); } else { draw_branch(LENGTH*scale,RADIUS*radscale,BASE_TRI,c1,c2); Translate(0.0,LENGTH*scale,0.0); } break; case '[': PushMatrix(); break; case ']': PopMatrix(); break; case 'L': if(do_growth && floor(growth)==i) draw_leaf(4*(growth-1)*scale,1*(growth-1)*scale,25,c3); else draw_leaf(4*scale,1*scale,25,c3); break; case 'R': Rotate(yrotate,0.0,1.0,0.0); break; case 'T': Rotate(tilt,0.0,0.0,1.0); break; default: if(isdigit(*ptr)) { ch[0] = *ptr; drawPlant(i-1,scale*SCALE,radscale*RADSCALE,atoi(ch)); } break; } ptr++; } PopMatrix(); }
void Device_OpenGL::Draw2DTextureFullViewport(Texture* texture) { DisableDepthTest(); PushMatrix(); SetIdentityMatrix(); UnbindVBO(VBO::VBO_TARGET_ARRAY_BUFFER); //------------------------------------------- float x = Screen::GetInstance()->GetRatio(); float y = 1.0f; float z = -1.0f; float vertices[30] = { -x, y, z, 0.0f, 1.0f, -x, -y, z, 0.0f, 0.0f, x, -y, z, 1.0f, 0.0f, -x, y, z, 0.0f, 1.0f, x, -y, z, 1.0f, 0.0f, x, y, z, 1.0f, 1.0f }; SetAttributePointer(ATTRIBUTE_FLOAT3_POSITION, vertices, sizeof(float) * 5); SetAttributePointer(ATTRIBUTE_FLOAT2_TEXCOORD_DIFFUSE, vertices + 3, sizeof(float) * 5); Device_Base::GetInstance()->UpdateVertexAttribPointer(); Device_Base::GetInstance()->SetUniformTexture(UNIFORM_TEXTURE_DIFFUSE, texture); Device_Base::GetInstance()->SetUniformMatrix(UNIFORM_MATRIX_MODEL, Device_Base::GetInstance()->GetMatrixWorld()); Device_Base::GetInstance()->SetUniformMatrix(UNIFORM_MATRIX_PROJECTION, m_MatrixProjection2DLogical); Device_Base::GetInstance()->DrawArray(Device_Base::PRIMITIVE_TRIANGLE_LIST, 0, 6); //------------------------------------------- EnableDepthTest(); PopMatrix(); }
/** * \param type bit 0: render OSD, bit 1: render EOSD */ static void do_render_osd(int type) { if (((type & 1) && osdtexCnt > 0) || ((type & 2) && eosdDispList)) { // set special rendering parameters if (!scaled_osd) { MatrixMode(GL_PROJECTION); PushMatrix(); LoadIdentity(); Ortho(0, vo_dwidth, vo_dheight, 0, -1, 1); } Enable(GL_BLEND); if ((type & 2) && eosdDispList) { BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); CallList(eosdDispList); } if ((type & 1) && osdtexCnt > 0) { Color4ub((osd_color >> 16) & 0xff, (osd_color >> 8) & 0xff, osd_color & 0xff, 0xff - (osd_color >> 24)); // draw OSD #ifndef FAST_OSD BlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_ALPHA); CallLists(osdtexCnt, GL_UNSIGNED_INT, osdaDispList); #endif BlendFunc(GL_SRC_ALPHA, GL_ONE); CallLists(osdtexCnt, GL_UNSIGNED_INT, osdDispList); } // set rendering parameters back to defaults Disable(GL_BLEND); if (!scaled_osd) PopMatrix(); BindTexture(gl_target, 0); }
void GL2HudRenderer::render() { if (client->getStateId() != Client::StateId::PLAYING) return; const Character &character = client->getLocalCharacter(); if (!character.isValid()) return; GL(Enable(GL_TEXTURE_2D)); vec2f texs[4]; GL2TextureManager::Entry tex_entry = renderer->getTextureManager()->get(client->getLocalCharacter().getBlock()); GL2TextureManager::getTextureCoords(tex_entry.index, tex_entry.type, texs); GL(BindTexture(GL_TEXTURE_2D, tex_entry.tex)); GL(Color4f(1.0f, 1.0f, 1.0f, 1.0f)); GL(PushMatrix()); float d = (client->getGraphics()->getWidth() < client->getGraphics()->getHeight() ? client->getGraphics()->getWidth() : client->getGraphics()->getHeight()) * 0.05f; GL(Translatef(-client->getGraphics()->getDrawWidth() * 0.48f, -client->getGraphics()->getDrawHeight() * 0.48f, 0)); glBegin(GL_QUADS); glTexCoord2f(texs[0][0], texs[0][1]); glVertex2f(0, 0); glTexCoord2f(texs[1][0], texs[1][1]); glVertex2f(d, 0); glTexCoord2f(texs[2][0], texs[2][1]); glVertex2f(d, d); glTexCoord2f(texs[3][0], texs[3][1]); glVertex2f(0, d); glEnd(); LOG_OPENGL_ERROR; GL(PopMatrix()); }
void VideoEngine::PushState() { // Push current modelview transformation glMatrixMode(GL_MODELVIEW); PushMatrix(); _context_stack.push(_current_context); }
void dSceneRender::DrawArrow (int segments, dFloat radius, dFloat heigh, const dVector& stemColor, const dVector& tipColor) { dMatrix matrix (dGetIdentityMatrix()); matrix.m_posit.m_x = heigh / 2.0f; PushMatrix(matrix); SetColor(stemColor); DrawCylinder(segments, radius, heigh); dFloat tipLength = heigh / 3.0f; matrix.m_posit.m_x = (heigh + tipLength) / 2.0f; PushMatrix(matrix); SetColor(tipColor); DrawCone(segments, radius * 2.0f, tipLength); PopMatrix(); PopMatrix(); }
//-- Cube --------------------------------------------------------------------- // //----------------------------------------------------------------------------- void Renderer::Cube( float nx, float ny, float nz, float x, float y, float z ) { // 4-------5 // /| /| // 0-------1 | // | 7-----|-6 // |/ |/ // 3-------2 PushMatrix(); Translate( ( nx + x ) * 0.5f, ( ny + y ) * 0.5f, ( nz + z ) * 0.5f ); DiffuseUVCubeVertexShader* pShader = NULL; if ( g_envMapSet ) { pShader = &DiffuseUVEnvCubeVertexShader::StaticType; } else { pShader = &DiffuseUVCubeVertexShader::StaticType; } CommitTransforms( pShader ); CommitTextureState(); PopMatrix(); D3DXVECTOR4 vScale( ( x - nx ) * 0.5f, ( y - ny ) * 0.5f, ( z - nz ) * 0.5f, 1.0f ); pShader->SetScale( &vScale ); pShader->SetColour( &g_fColour ); m_pD3DDevice->SetVertexShader( pShader->GetVertexShader() ); m_pD3DDevice->SetVertexDeclaration( g_pPosNormalColUVDeclaration ); m_pD3DDevice->SetStreamSource( 0, g_pCubeVbuffer, 0, sizeof( PosColNormalUVVertex ) ); m_pD3DDevice->SetIndices( g_pCubeIbuffer ); m_pD3DDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0, 0, 24, 0, 12 ); m_pD3DDevice->SetStreamSource( 0, NULL, 0, sizeof( PosColNormalUVVertex ) ); m_pD3DDevice->SetIndices( NULL ); } // Cube
void GL2ChunkRenderer::renderChunk(vec3i64 chunkCoords) { auto it = renderInfos.find(chunkCoords); if (it == renderInfos.end() || it->second.dl == 0) return; Character &character = client->getLocalCharacter(); vec3i64 cd = chunkCoords - character.getChunkPos(); GL(PushMatrix()); GL(Translatef(cd[0] * (float) Chunk::WIDTH, cd[1] * (float) Chunk::WIDTH, cd[2] * (float) Chunk::WIDTH)) GL(CallList(it->second.dl)); GL(PopMatrix()); }
int draw(Display *display,int num, int mouseX, int mouseY) { double angle1, angle2; double dx,dy; double tx,ty; double cosa, sina; double x,y,x2,y2; x = pupils[num]; y = pupils[num+1]; x2 = eyes[num]; y2 = eyes[num+1]; DrawEllipse(display, (int)eyes[num], (int)eyes[num+1], EYE_W, EYE_H); PushStyle(display); Fill1i(display, 0); dx = (double)mouseX - x; dy = (double)mouseY - y; angle1 = atan2(dy,dx); cosa = cos(angle1); sina = sin(angle1); tx = mouseX - cosa * EYE_RAD; ty = mouseY - sina * EYE_RAD; dx = tx - x2; dy = ty - y2; angle2 = atan2(dy,dx); cosa = cos(angle2); sina = sin(angle2); x = x2 + cosa * EYE_RAD; y = y2 + sina * EYE_RAD; PushMatrix(display); Translate2f(display,x, y); Rotate(display, angle1); DrawEllipse(display, EYE_RAD, 0, PUPIL_W, PUPIL_W); PopMatrix(display); pupils[num] = x; pupils[num+1] = y; PopStyle(display); return 0; }
static int render(struct Cube* This, HTEXTURE* ptex) { int imap[6][4] = { {2, 3, 1, 0}, {3, 7, 0, 4}, {2, 6, 3, 7}, {0, 4, 1, 5}, {1, 5, 2, 6}, {7, 6, 4, 5}, }; int f, it; FPOINT3D pt[4]; for (f = 0; f < 6; ++f) { if (This->face[f].visable) { int bObjSet = 0; for (it = 0; it < 4; ++it) { memcpy(&pt[it], &This->pos[imap[f][it]], sizeof(VECTOR3D)); pt[it].color = 0xFFFFFFFF; } PushMatrix(); if (This->rotate_x != 0.0f) { ObjectRotate(This->rotate_x, 1.0f, 0.0f, 0.0f); bObjSet = 1; } if (This->rotate_y != 0.0f) { ObjectRotate(This->rotate_y, 0.0f, -1.0f, 0.0f); bObjSet = 1; } if (This->rotate_z != 0.0f) { ObjectRotate(This->rotate_z, 0.0f, 0.0f, -1.0f); bObjSet = 1; } This->face[f].render(&This->face[f], ptex, pt); PopMatrix(); } } return 0 ; }
void TextEngineRenderer::DrawRectangle(glm::vec2 center, glm::vec2 dimensions) { PushMatrix(); matrix_stack.back() *= glm::scale(glm::translate(glm::mat4(1), glm::vec3(center, 0.0f)), glm::vec3(dimensions, 1)); face_program.Use(); face_program.Uniforms({ {u8"projection", &projection}, {u8"model_view", &matrix_stack.back()} }); face_program.Uniforms({ {u8"color", fill} }); rectangle_array.Bind(); glDrawArrays(unit_square.element_type, 0, unit_square.element_count); CHECK_STATE(!glGetError()); PopMatrix(); }
void nuiGLPainter::ApplyTexture(const nuiRenderState& rState, bool ForceApply) { // if ((rState.mTexturing && !rState.mpTexture) || (!rState.mTexturing && rState.mpTexture)) // { // printf("bleh!\n"); // char* bleh = NULL; // bleh[0] = 0; // } // 2D Textures: std::map<nuiTexture*, TextureInfo>::const_iterator it = mTextures.find(rState.mpTexture); bool uptodate = (it == mTextures.end()) ? false : ( !it->second.mReload && it->second.mTexture >= 0 ); if (ForceApply || (mState.mpTexture != rState.mpTexture) || (mState.mpTexture && !uptodate)) { GLenum intarget = 0; GLenum outtarget = 0; if (mState.mpTexture) { outtarget = GetTextureTarget(mState.mpTexture->IsPowerOfTwo()); //mState.mpTexture->UnapplyGL(this); #TODO Un apply the texture nuiCheckForGLErrors(); mState.mpTexture->Release(); nuiCheckForGLErrors(); } //NGL_OUT(_T("Change texture to 0x%x (%ls)\n"), rState.mpTexture, rState.mpTexture?rState.mpTexture->GetSource().GetChars() : nglString::Empty.GetChars()); mState.mpTexture = rState.mpTexture ; if (mState.mpTexture) { intarget = GetTextureTarget(mState.mpTexture->IsPowerOfTwo()); mState.mpTexture->Acquire(); nuiSurface* pSurface = mState.mpTexture->GetSurface(); if (pSurface) { std::map<nuiSurface*, FramebufferInfo>::const_iterator it = mFramebuffers.find(pSurface); bool create = (it == mFramebuffers.end()) ? true : false; if (create || pSurface->IsDirty()) { PushClipping(); nuiRenderState s(mState);// PushState(); PushProjectionMatrix(); PushMatrix(); #ifdef _OPENGL_ES_ if (mpSurfaceStack.empty()) { // mDefaultFramebuffer = 0; // mDefaultRenderbuffer = 0; glGetIntegerv(GL_FRAMEBUFFER_BINDING_NUI, &mDefaultFramebuffer); glGetIntegerv(GL_RENDERBUFFER_BINDING_NUI, (GLint *) &mDefaultRenderbuffer); } #endif PushSurface(); SetState(nuiRenderState()); ResetClipRect(); mClip.Set(0, 0, pSurface->GetWidth(), pSurface->GetHeight()); LoadMatrix(nglMatrixf()); NGL_ASSERT(pSurface); SetSurface(pSurface); //Set2DProjectionMatrix(nuiRect(0.0f, 0.0f, pSurface->GetWidth(), pSurface->GetHeight())); nuiMatrix m; m.Translate(-1.0f, 1.0f, 0.0f); m.Scale(2.0f / pSurface->GetWidth(), -2.0f / pSurface->GetHeight(), 1.0f); LoadProjectionMatrix(nuiRect(pSurface->GetWidth(), pSurface->GetHeight()), m); // clear the surface with transparent black: // nuiRenderState s2(mState);// PushState(); // mState.mClearColor = nuiColor(0.0f, 0.0f, 0.0f, 0.0f); SetState(mState); // ClearColor(); // SetState(s2); ////////////////////////////// nuiDrawContext Ctx(nuiRect(pSurface->GetWidth(), pSurface->GetHeight())); Ctx.SetPainter(this); pSurface->Realize(&Ctx); Ctx.SetPainter(NULL); ////////////////////////////// PopSurface(); PopMatrix(); PopProjectionMatrix(); //PopState(); SetState(s); PopClipping(); } } UploadTexture(mState.mpTexture); nuiCheckForGLErrors(); } //NGL_OUT(_T("Change texture type from 0x%x to 0x%x\n"), outtarget, intarget); mTextureTarget = intarget; if (intarget != outtarget) { // Texture Target has changed if (outtarget) { glDisable(outtarget); nuiCheckForGLErrors(); } //NGL_OUT(_T("disable outtarget\n")); if (intarget && mState.mTexturing && mState.mpTexture) { mState.mTexturing = rState.mTexturing; //NGL_OUT(_T("enable intarget\n")); glEnable(intarget); nuiCheckForGLErrors(); } } else { // Texture Target have not changed if (mState.mTexturing != rState.mTexturing) // Have texture on/off changed? { // Should enable or disable texturing mState.mTexturing = rState.mTexturing; if (mState.mTexturing) { glEnable(mTextureTarget); nuiCheckForGLErrors(); } else { glDisable(mTextureTarget); nuiCheckForGLErrors(); } } } } if (ForceApply || (mState.mTexturing != rState.mTexturing)) { // Texture have not changed, but texturing may have been enabled / disabled mState.mTexturing = rState.mTexturing; if (mState.mpTexture) { if (mTextureTarget && mState.mTexturing) { //NGL_OUT(_T("Enable 0x%x\n"), mTextureTarget); glEnable(mTextureTarget); nuiCheckForGLErrors(); } else { //NGL_OUT(_T("Disable 0x%x\n"), mTextureTarget); glDisable(mTextureTarget); nuiCheckForGLErrors(); } } else { if (mTextureTarget) { //NGL_OUT(_T("Disable 0x%x\n"), mTextureTarget); glDisable(mTextureTarget); } nuiCheckForGLErrors(); } } }
void TextEngineRenderer::Render() { GameState ¤t_state = updater.GetCurrentState(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); PushMatrix(); matrix_stack.back() *= glm::scale(glm::mat4(1), glm::vec3(glm::vec2(current_state.zoom * 0.1f), 1.0f)); matrix_stack.back() *= glm::translate(glm::mat4(1), glm::vec3(-current_state.camera_position, 0)); const glm::vec2 position = glm::vec2(current_state.player_body->GetPosition().x, current_state.player_body->GetPosition().y); fill = glm::vec4(0.0f, 0.5f, 0.3f, 0.5f); for (const auto &area : scene.areas) { if (area->invisible) { continue; } if (Shape::kAxisAlignedBoundingBox == area->shape) { DrawAxisAlignedBoundingBox(area->aabb); } else { DrawCircle(area->aabb.center(), area->aabb.radius()); } } fill = glm::vec4(1.0f, 0.0f, 0.0f, 0.5f); for (const auto &object : scene.objects) { if (object->invisible) { continue; } if (Shape::kAxisAlignedBoundingBox == object->shape) { DrawAxisAlignedBoundingBox(object->aabb); } else { DrawCircle(object->aabb.center(), object->aabb.radius()); } } const glm::mat4 normalized_to_reversed = glm::scale(glm::mat4(), glm::vec3(1.0f, -1.0f, 1.0f)); const glm::mat4 reversed_to_offset = glm::translate(glm::mat4(), glm::vec3(glm::vec2(1.0f), 0.0f)); const glm::mat4 offset_to_screen = glm::scale(glm::mat4(), glm::vec3(glm::vec2(0.5f), 1.0f)); const glm::mat4 screen_to_window = glm::scale(glm::mat4(), glm::vec3(width, height, 1.0f)); const glm::mat4 transform = (screen_to_window * offset_to_screen * reversed_to_offset * normalized_to_reversed * model_view * projection * matrix_stack.back()); const glm::mat4 transform2 = (screen_to_window * offset_to_screen * reversed_to_offset * model_view * projection * matrix_stack.back()); const auto inverse = glm::inverse(transform2); const glm::vec4 homogeneous = transform * glm::vec4(position, 0.0f, 1.0f); const glm::vec2 transformed = homogeneous.xy() / homogeneous.w; fill = glm::vec4(0.5f, 0.5f, 0.6f, 1.0f); PushMatrix(); matrix_stack.back() *= glm::translate(glm::mat4(1), glm::vec3(position, 0)); matrix_stack.back() *= glm::rotate(glm::mat4(1), current_state.player_body->GetAngle(), glm::vec3(0, 0, 1)); DrawRectangle(glm::vec2(0), glm::vec2(0.25f, 0.5f)); PopMatrix(); PopMatrix(); if (edit) { MaybeRebuildAttenuationShader(); if (current_state.selected_item) { attenuation3_program.Use(); attenuation3_program.Uniforms({ {u8"model_view_inverse", &inverse} }); const auto isaabb3 = Shape::kAxisAlignedBoundingBox == current_state.selected_item->shape; glUniform1i(attenuation3_program.GetUniformLocation(u8"selected_isaabb"), isaabb3); if (Shape::kAxisAlignedBoundingBox == current_state.selected_item->shape) { attenuation3_program.Uniforms({ {u8"selected_minimum_or_center", current_state.selected_item->aabb.minimum}, {u8"selected_maximum_or_radius", current_state.selected_item->aabb.maximum}, }); CHECK_STATE(!glGetError()); } else { attenuation3_program.Uniforms({ {u8"selected_minimum_or_center", current_state.selected_item->aabb.center()}, {u8"selected_maximum_or_radius", glm::vec2(current_state.selected_item->aabb.radius())}, }); CHECK_STATE(!glGetError()); } const auto attenuation3_coefficients = glm::vec3( current_state.selected_item->base_attenuation, current_state.selected_item->linear_attenuation, current_state.selected_item->quadratic_attenuation); attenuation3_program.Uniforms({ {u8"selected_attenuation", attenuation3_coefficients}, }); const auto color3 = glm::vec4(0, 0, 0, 0.125); attenuation3_program.Uniforms({ {u8"color", color3} }); attenuation_array.Bind(); glDrawArrays(attenuation.element_type, 0, attenuation.element_count); CHECK_STATE(!glGetError()); attenuation_program.Use(); attenuation_program.Uniforms({ {u8"model_view_inverse", &inverse} }); const auto isaabb = Shape::kAxisAlignedBoundingBox == current_state.selected_item->shape; glUniform1i(attenuation_program.GetUniformLocation(u8"selected_isaabb"), isaabb); if (Shape::kAxisAlignedBoundingBox == current_state.selected_item->shape) { attenuation_program.Uniforms({ {u8"selected_minimum_or_center", current_state.selected_item->aabb.minimum}, {u8"selected_maximum_or_radius", current_state.selected_item->aabb.maximum}, }); CHECK_STATE(!glGetError()); } else { attenuation_program.Uniforms({ {u8"selected_minimum_or_center", current_state.selected_item->aabb.center()}, {u8"selected_maximum_or_radius", glm::vec2(current_state.selected_item->aabb.radius())}, }); CHECK_STATE(!glGetError()); } const auto attenuation_coefficients = glm::vec3( current_state.selected_item->base_attenuation, current_state.selected_item->linear_attenuation, current_state.selected_item->quadratic_attenuation); attenuation_program.Uniforms({ {u8"selected_attenuation", attenuation_coefficients}, }); const auto color = glm::vec4(0, 0, 0, 0.5); attenuation_program.Uniforms({ {u8"color", color} }); attenuation_array.Bind(); glDrawArrays(attenuation.element_type, 0, attenuation.element_count); CHECK_STATE(!glGetError()); } } const auto mouse_position = 2.0f * mouse.get_cursor_position(); unsigned char mouse_buttons = 0; if (mouse.IsButtonDown(GLFW_MOUSE_BUTTON_1)) { mouse_buttons |= IMGUI_MBUT_LEFT; } if (mouse.IsButtonDown(GLFW_MOUSE_BUTTON_2)) { mouse_buttons |= IMGUI_MBUT_RIGHT; } if (edit) { imguiBeginFrame(mouse_position.x, height - mouse_position.y, mouse_buttons, 0); for (auto &area : scene.areas) { const glm::vec4 homogeneous = transform * glm::vec4(area->aabb.minimum.x, area->aabb.maximum.y, 0.0f, 1.0f); const glm::vec2 transformed = homogeneous.xy() / homogeneous.w; imguiDrawText(transformed.x, height - transformed.y, IMGUI_ALIGN_LEFT, area->name.c_str(), imguiRGBA(0, 0, 0)); } for (auto &object : scene.objects) { const glm::vec4 homogeneous = transform * glm::vec4(object->aabb.minimum.x, object->aabb.maximum.y, 0.0f, 1.0f); const glm::vec2 transformed = homogeneous.xy() / homogeneous.w; imguiDrawText(transformed.x, height - transformed.y, IMGUI_ALIGN_LEFT, object->name.c_str(), imguiRGBA(0, 0, 0)); } if (current_state.selected_item) { std::ostringstream name, constant, linear, quadratic; name << current_state.selected_item->name; imguiDrawText(10, height - 50, IMGUI_ALIGN_LEFT, name.str().c_str(), imguiRGBA(0, 0, 0)); constant << "c: " << current_state.selected_item->base_attenuation; imguiDrawText(10, height - 75, IMGUI_ALIGN_LEFT, constant.str().c_str(), imguiRGBA(0, 0, 0)); linear << "l: " << current_state.selected_item->linear_attenuation; imguiDrawText(10, height - 100, IMGUI_ALIGN_LEFT, linear.str().c_str(), imguiRGBA(0, 0, 0)); quadratic << "q: " << current_state.selected_item->quadratic_attenuation << std::endl; imguiDrawText(10, height - 125, IMGUI_ALIGN_LEFT, quadratic.str().c_str(), imguiRGBA(0, 0, 0)); } imguiEndFrame(); } imguiRenderGLDraw(width, height); }