void RenderManager::render(const QString& object_name, bool wireframe) { for (auto it = objects[object_name].begin(); it != objects[object_name].end(); ++it) { GLuint texId = it.key(); // vaoを作成 it->createVAO(); if (texId > 0) { // テクスチャなら、バインドする glBindTexture(GL_TEXTURE_2D, texId); glUniform1i(glGetUniformLocation(program, "textureEnabled"), 1); glUniform1i(glGetUniformLocation(program, "tex0"), 0); } else { glUniform1i(glGetUniformLocation(program, "textureEnabled"), 0); } if (wireframe) { glUniform1i(glGetUniformLocation(program, "wireframeEnalbed"), 1); } else { glUniform1i(glGetUniformLocation(program, "wireframeEnalbed"), 0); } // 描画 glBindVertexArray(it->vao); glDrawArrays(GL_TRIANGLES, 0, it->vertices.size()); glBindVertexArray(0); } }
void SceneRenderer::renderModel(GeoModel3D model) { GLuint vaoID; GLuint sampler_loc = 4; std::vector<GLModel3DData> modelData = model.retrieveMeshes(); for (std::vector<GLModel3DData>::iterator m = modelData.begin(); m != modelData.end(); m++) { try { vaoID = object_vao_map.at(m->getMeshID()); } catch (std::out_of_range ex) { // if errors here ensure to create VAOs createVAO(model); vaoID = object_vao_map.at(m->getMeshID()); } glBindVertexArray(vaoID); // Bind our Vertex Array Object glActiveTexture(GL_TEXTURE0); shader->BindAttribLocation(sampler_loc, "texture1"); glBindTexture(GL_TEXTURE_2D, m->texture); tinyobj::mesh_t mesh = m->getMeshData(); glDrawElements(GL_TRIANGLES, mesh.indices.size(), GL_UNSIGNED_INT, 0); } }
void VAOManager::regenerateInstancedVAO() { cleanInstanceVAOs(); enum video::E_VERTEX_TYPE IrrVT[] = { video::EVT_STANDARD, video::EVT_2TCOORDS, video::EVT_TANGENTS }; for (unsigned i = 0; i < VTXTYPE_COUNT; i++) { video::E_VERTEX_TYPE tp = IrrVT[i]; if (!vbo[tp] || !ibo[tp]) continue; GLuint vao = createVAO(vbo[tp], ibo[tp], tp); glBindBuffer(GL_ARRAY_BUFFER, instance_vbo[InstanceTypeThreeTex]); VAOInstanceUtil<InstanceDataThreeTex>::SetVertexAttrib(); InstanceVAO[std::pair<video::E_VERTEX_TYPE, InstanceType>(tp, InstanceTypeThreeTex)] = vao; vao = createVAO(vbo[tp], ibo[tp], tp); glBindBuffer(GL_ARRAY_BUFFER, instance_vbo[InstanceTypeFourTex]); VAOInstanceUtil<InstanceDataFourTex>::SetVertexAttrib(); InstanceVAO[std::pair<video::E_VERTEX_TYPE, InstanceType>(tp, InstanceTypeFourTex)] = vao; vao = createVAO(vbo[tp], ibo[tp], tp); glBindBuffer(GL_ARRAY_BUFFER, instance_vbo[InstanceTypeShadow]); VAOInstanceUtil<InstanceDataSingleTex>::SetVertexAttrib(); InstanceVAO[std::pair<video::E_VERTEX_TYPE, InstanceType>(tp, InstanceTypeShadow)] = vao; vao = createVAO(vbo[tp], ibo[tp], tp); glBindBuffer(GL_ARRAY_BUFFER, instance_vbo[InstanceTypeRSM]); VAOInstanceUtil<InstanceDataSingleTex>::SetVertexAttrib(); InstanceVAO[std::pair<video::E_VERTEX_TYPE, InstanceType>(tp, InstanceTypeRSM)] = vao; vao = createVAO(vbo[tp], ibo[tp], tp); glBindBuffer(GL_ARRAY_BUFFER, instance_vbo[InstanceTypeGlow]); VAOInstanceUtil<GlowInstanceData>::SetVertexAttrib(); InstanceVAO[std::pair<video::E_VERTEX_TYPE, InstanceType>(tp, InstanceTypeGlow)] = vao; glBindVertexArray(0); } }
void AppManager::init(){ /* Initialize the library */ if (glfwInit() != GL_TRUE) { THROW_EXCEPTION("Failed to initialize GLFW"); } glfwSetErrorCallback(error_callback); createOpenGLContext(); setOpenGLStates(); createFBO(); createProgram(); createVAO(); applyInitial(); }
void STKMeshSceneNode::updatevbo() { for (unsigned i = 0; i < Mesh->getMeshBufferCount(); ++i) { scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i); if (!mb) continue; GLMesh &mesh = GLmeshes[i]; glDeleteBuffers(1, &(mesh.vertex_buffer)); glDeleteBuffers(1, &(mesh.index_buffer)); glDeleteVertexArrays(1, &(mesh.vao)); fillLocalBuffer(mesh, mb); mesh.vao = createVAO(mesh.vertex_buffer, mesh.index_buffer, mb->getVertexType()); } }
void STKMeshSceneNode::updateGL() { if (isGLInitialized) return; for (u32 i = 0; i < Mesh->getMeshBufferCount(); ++i) { scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i); if (!mb) continue; GLMesh &mesh = GLmeshes[i]; irr::video::IVideoDriver* driver = irr_driver->getVideoDriver(); video::E_MATERIAL_TYPE type = mb->getMaterial().MaterialType; video::IMaterialRenderer* rnd = driver->getMaterialRenderer(type); if (!rnd->isTransparent()) { Material* material = material_manager->getMaterialFor(mb->getMaterial().getTexture(0), mb); Material* material2 = NULL; if (mb->getMaterial().getTexture(1) != NULL) material2 = material_manager->getMaterialFor(mb->getMaterial().getTexture(1), mb); Material::ShaderType MatType = MaterialTypeToMeshMaterial(type, mb->getVertexType(), material, material2); if (!immediate_draw) InitTextures(mesh, MatType); } else if (!immediate_draw) InitTexturesTransparent(mesh); if (!immediate_draw && irr_driver->hasARB_base_instance()) { std::pair<unsigned, unsigned> p = VAOManager::getInstance()->getBase(mb); mesh.vaoBaseVertex = p.first; mesh.vaoOffset = p.second; } else { fillLocalBuffer(mesh, mb); mesh.vao = createVAO(mesh.vertex_buffer, mesh.index_buffer, mb->getVertexType()); glBindVertexArray(0); } } isGLInitialized = true; }
void RenderManager::render(const QString& object_name) { for (auto it = objects[object_name].begin(); it != objects[object_name].end(); ++it) { GLuint texId = it.key(); // vaoを作成 it->createVAO(); if (texId > 0) { // テクスチャなら、バインドする glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, texId); glUniform1i(glGetUniformLocation(programs["pass1"], "textureEnabled"), 1); glUniform1i(glGetUniformLocation(programs["pass1"], "tex0"), 0); } else { glUniform1i(glGetUniformLocation(programs["pass1"], "textureEnabled"), 0); } if (it->lighting) { glUniform1i(glGetUniformLocation(programs["pass1"], "lighting"), 1); } else { glUniform1i(glGetUniformLocation(programs["pass1"], "lighting"), 0); } if (useShadow) { glUniform1i(glGetUniformLocation(programs["pass1"], "useShadow"), 1); if (softShadow) { glUniform1i(glGetUniformLocation(programs["pass1"], "softShadow"), 1); } else { glUniform1i(glGetUniformLocation(programs["pass1"], "softShadow"), 0); } } else { glUniform1i(glGetUniformLocation(programs["pass1"], "useShadow"), 0); } // 描画 glBindVertexArray(it->vao); glDrawArrays(GL_TRIANGLES, 0, it->vertices.size()); glBindVertexArray(0); } }
/** * This function is called once before the first call to paintGL() or resizeGL(). */ void GLWidget3D::initializeGL() { // init glew GLenum err = glewInit(); if (err != GLEW_OK) { qDebug() << "Error: " << glewGetErrorString(err); } // load shaders Shader shader; program = shader.createProgram("shaders/vertex.glsl", "shaders/fragment.glsl"); glUseProgram(program); // set the clear color for the screen qglClearColor(QColor(113, 112, 117)); // load a triangle model OBJLoader::load("models/triangle.obj", vertices); createVAO(vertices, vao); }
void VBORenderManager::renderVAO(RenderSt& renderSt,bool cleanVertex){ //printf("renderVAO numVert %d texNum %d vao %d numVertVert %d\n",renderSt.numVertex,renderSt.texNum,renderSt.vao,renderSt.vertices.size()); // 1. Create if necessary if(renderSt.numVertex!=renderSt.vertices.size()&&renderSt.vertices.size()>0){ if(renderSt.numVertex!=-1){ cleanVAO(renderSt.vbo,renderSt.vao); } // generate vao/vbo createVAO(renderSt.vertices,renderSt.vbo,renderSt.vao,renderSt.numVertex); if(cleanVertex) renderSt.vertices.clear(); } // 2. Render // 2.1 TEX int mode=renderSt.shaderMode; if((mode&mode_TexArray)==mode_TexArray){ // MULTI TEX mode=mode&(~mode_TexArray);//remove tex array bit glActiveTexture(GL_TEXTURE8); glBindTexture(GL_TEXTURE_2D,0); glBindTexture(GL_TEXTURE_2D_ARRAY, renderSt.texNum); glActiveTexture(GL_TEXTURE0); glUniform1i (glGetUniformLocation (program, "tex_3D"), 8); }else{ glBindTexture(GL_TEXTURE_2D, renderSt.texNum); } // 2.2 mode //if(renderSt.texNum==0){ //glUniform1i (glGetUniformLocation (program, "mode"), 1|(renderSt.shaderMode&0xFF00));//MODE: same modifiers but just color (renderSt.shaderMode&0xFF00) //}else{ glUniform1i (glGetUniformLocation (program, "mode"), mode); //} glUniform1i (glGetUniformLocation (program, "tex0"), 0);//tex0: 0 glBindVertexArray(renderSt.vao); glDrawArrays(renderSt.geometryType,0,renderSt.numVertex); glBindVertexArray(0); }
void GraphicModel::loadDatafromFile(char * filename) { FileHandle fh; FileError ferror; PackageHeader * pkH = new PackageHeader(); ChunkHeader * CDM = new ChunkHeader(); ChunkHeader * VBO = new ChunkHeader(); ChunkHeader * TRI = new ChunkHeader(); ChunkHeader * TEXRGB = new ChunkHeader(); CDM_Header * ModelHeader = new CDM_Header(); ////////////////////////////////////READ PACKAGE////////////////////////////// ferror = File::open(fh,filename,FILE_READ); assert(ferror == FILE_SUCCESS); ferror= File::read(fh,pkH,sizeof(PackageHeader)); assert(ferror == FILE_SUCCESS); if (pkH->numChunks > 0) { ferror= File::read(fh,CDM,sizeof(ChunkHeader)); assert(ferror == FILE_SUCCESS); ferror= File::read(fh,ModelHeader,sizeof(CDM_Header)); assert(ferror == FILE_SUCCESS); } if (pkH->numChunks > 1) { ////////////////////////////////////VBOS/////////////////////////////////////// ferror= File::read(fh,VBO,sizeof(ChunkHeader)); assert(ferror == FILE_SUCCESS); int totalsize = VBO->chunkSize/ sizeof(FBX_Vertex_vsn); this->model_vert.reserve(totalsize); FBX_Vertex_vsn * tempRead = new FBX_Vertex_vsn(); for (int i=0; i< totalsize; i++) { ferror= File::read(fh,tempRead,sizeof(FBX_Vertex_vsn)); this->model_vert.push_back(*tempRead); } } if (pkH->numChunks > 2) { /////////////////////////////////TRIANGLE LIST/////////////////////////////// ferror= File::read(fh,TRI,sizeof(ChunkHeader)); assert(ferror == FILE_SUCCESS); int totalsize = TRI->chunkSize/ sizeof(VBO_Trilist); this->model_trilist.reserve(totalsize); VBO_Trilist * tempRead = new VBO_Trilist(); for (int i=0; i< totalsize; i++) { ferror= File::read(fh,tempRead,sizeof(VBO_Trilist)); this->model_trilist.push_back(*tempRead); }; } //////////////////////////////CREATE VAO with TRILIST and VBOs//////////////////////// createVAO(); if (pkH->numChunks > 3 && ModelHeader->incTex) { ////////////////////////////////////TEXTURE////////////////////////////////////// ferror= File::read(fh,TEXRGB,sizeof(ChunkHeader)); assert(ferror == FILE_SUCCESS); TEX_Header * texHeader = new TEX_Header(); ferror = File::read(fh, texHeader,sizeof(TEX_Header)); assert(ferror == FILE_SUCCESS); int size = TEXRGB->chunkSize - sizeof(TEX_Header); char * texBuffer = (char *)malloc(size); ferror = File::read(fh, texBuffer,size); assert(ferror == FILE_SUCCESS); ferror = File::close(fh); loadTexturefromBuffer(texBuffer,*texHeader); free (texBuffer); } else { //loadTexture(texName) } delete pkH; delete CDM; delete VBO; delete TRI; delete TEXRGB; delete ModelHeader; }
void initvaostate(GLMesh &mesh, video::E_MATERIAL_TYPE type) { switch (irr_driver->getPhase()) { case SOLID_NORMAL_AND_DEPTH_PASS: if (mesh.vao_first_pass) return; if (type == irr_driver->getShader(ES_NORMAL_MAP)) { mesh.vao_first_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::NormalMapShader::attrib_position, MeshShader::NormalMapShader::attrib_texcoord, -1, -1, MeshShader::NormalMapShader::attrib_tangent, MeshShader::NormalMapShader::attrib_bitangent, -1, mesh.Stride); } else if (type == irr_driver->getShader(ES_OBJECTPASS_REF)) { mesh.vao_first_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::ObjectPass1Shader::attrib_position, MeshShader::ObjectRefPass1Shader::attrib_texcoord, -1, MeshShader::ObjectPass1Shader::attrib_normal, -1, -1, -1, mesh.Stride); } else if (type == irr_driver->getShader(ES_GRASS) || type == irr_driver->getShader(ES_GRASS_REF)) { mesh.vao_first_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::GrassPass1Shader::attrib_position, MeshShader::GrassPass1Shader::attrib_texcoord, -1, MeshShader::GrassPass1Shader::attrib_normal, -1, -1, MeshShader::GrassPass1Shader::attrib_color, mesh.Stride); } else { mesh.vao_first_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::ObjectPass1Shader::attrib_position, -1, -1, MeshShader::ObjectPass1Shader::attrib_normal, -1, -1, -1, mesh.Stride); } return; case SOLID_LIT_PASS: if (mesh.vao_second_pass) return; if (type == irr_driver->getShader(ES_SPHERE_MAP)) { mesh.vao_second_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::SphereMapShader::attrib_position, -1, -1, MeshShader::SphereMapShader::attrib_normal, -1, -1, -1, mesh.Stride); } else if (type == irr_driver->getShader(ES_SPLATTING)) { mesh.vao_second_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::SplattingShader::attrib_position, MeshShader::SplattingShader::attrib_texcoord, MeshShader::SplattingShader::attrib_second_texcoord, -1, -1, -1, -1, mesh.Stride); } else if (type == irr_driver->getShader(ES_OBJECTPASS_REF)) { mesh.vao_second_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::ObjectRefPass2Shader::attrib_position, MeshShader::ObjectRefPass2Shader::attrib_texcoord, -1, -1, -1, -1, -1, mesh.Stride); } else if (type == irr_driver->getShader(ES_OBJECTPASS_RIMLIT)) { mesh.vao_second_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::ObjectRimLimitShader::attrib_position, MeshShader::ObjectRimLimitShader::attrib_texcoord, -1, MeshShader::ObjectRimLimitShader::attrib_normal, -1, -1, -1, mesh.Stride); } else if (type == irr_driver->getShader(ES_GRASS) || type == irr_driver->getShader(ES_GRASS_REF)) { mesh.vao_second_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::GrassPass2Shader::attrib_position, MeshShader::GrassPass2Shader::attrib_texcoord, -1, -1, -1, -1, MeshShader::GrassPass2Shader::attrib_color, mesh.Stride); } else if (type == irr_driver->getShader(ES_OBJECT_UNLIT)) { mesh.vao_second_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::ObjectUnlitShader::attrib_position, MeshShader::ObjectUnlitShader::attrib_texcoord, -1, -1, -1, -1, -1, mesh.Stride); } else if (type == irr_driver->getShader(ES_CAUSTICS)) { mesh.vao_second_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::CausticsShader::attrib_position, MeshShader::CausticsShader::attrib_texcoord, -1, -1, -1, -1, -1, mesh.Stride); } else if (mesh.textures[1]) { mesh.vao_second_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::DetailledObjectPass2Shader::attrib_position, MeshShader::DetailledObjectPass2Shader::attrib_texcoord, MeshShader::DetailledObjectPass2Shader::attrib_second_texcoord, -1, -1, -1, -1, mesh.Stride); } else if (!mesh.textures[0]) { mesh.vao_second_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::UntexturedObjectShader::attrib_position, -1, -1, -1, -1, -1, MeshShader::UntexturedObjectShader::attrib_color, mesh.Stride); } else { mesh.vao_second_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::ObjectPass2Shader::attrib_position, MeshShader::ObjectPass2Shader::attrib_texcoord, -1, -1, -1, -1, -1, mesh.Stride); } return; case GLOW_PASS: if (mesh.vao_glow_pass) return; mesh.vao_glow_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::ColorizeShader::attrib_position, -1, -1, -1, -1, -1, -1, mesh.Stride); return; case TRANSPARENT_PASS: if (mesh.vao_first_pass) return; if (type == irr_driver->getShader(ES_BUBBLES)) { mesh.vao_first_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::BubbleShader::attrib_position, MeshShader::BubbleShader::attrib_texcoord, -1, -1, -1, -1, -1, mesh.Stride); } else if (World::getWorld()->getTrack()->isFogEnabled()) { mesh.vao_first_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::TransparentFogShader::attrib_position, MeshShader::TransparentFogShader::attrib_texcoord, -1, -1, -1, -1, -1, mesh.Stride); } else { mesh.vao_first_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::TransparentShader::attrib_position, MeshShader::TransparentShader::attrib_texcoord, -1, -1, -1, -1, -1, mesh.Stride); } return; case DISPLACEMENT_PASS: if (mesh.vao_displace_pass) return; mesh.vao_displace_mask_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::DisplaceShader::attrib_position,-1, -1, -1, -1, -1, -1, mesh.Stride); mesh.vao_displace_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::DisplaceShader::attrib_position, MeshShader::DisplaceShader::attrib_texcoord, MeshShader::DisplaceShader::attrib_second_texcoord, -1, -1, -1, -1, mesh.Stride); return; case SHADOW_PASS: if (mesh.vao_shadow_pass) return; if (type == irr_driver->getShader(ES_OBJECTPASS_REF)) { mesh.vao_shadow_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::RefShadowShader::attrib_position, MeshShader::RefShadowShader::attrib_texcoord, -1, -1, -1, -1, -1, mesh.Stride); } /*else if (type == irr_driver->getShader(ES_GRASS) || type == irr_driver->getShader(ES_GRASS_REF)) { mesh.vao_shadow_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::GrassShadowShader::attrib_position, MeshShader::GrassShadowShader::attrib_texcoord, -1, -1, -1, -1, MeshShader::GrassShadowShader::attrib_color, mesh.Stride); }*/ else { mesh.vao_shadow_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::ShadowShader::attrib_position, -1, -1, -1, -1, -1, -1, mesh.Stride); } return; } }
/** * Load an OBJ file and create the corresponding VAO. */ void GLWidget3D::loadOBJ(const QString& filename) { OBJLoader::load(filename, vertices); createVAO(vertices, vao); }
void init() { vf::skinned_geom_t::vao = createVAO(ARRAY_SIZE(vf::descSkinnedGeom), vf::descSkinnedGeom, 0, NULL); vf::static_geom_t::vao = createVAO(ARRAY_SIZE(vf::descStaticGeom), vf::descStaticGeom, 0, NULL); vf::p2_vertex_t::vao = createVAO(ARRAY_SIZE(vf::fmtdesc_p2), vf::fmtdesc_p2, 0, NULL); vf::p2uv2_vertex_t::vao = createVAO(ARRAY_SIZE(vf::fmtdesc_p2uv2), vf::fmtdesc_p2uv2, 0, NULL); vf::p2uv3_vertex_t::vao = createVAO(ARRAY_SIZE(vf::fmtdesc_p2uv3), vf::fmtdesc_p2uv3, 0, NULL); vf::p2cu4_vertex_t::vao = createVAO(ARRAY_SIZE(vf::fmtdesc_p2cu4), vf::fmtdesc_p2cu4, 0, NULL); vf::p2uv2cu4_vertex_t::vao = createVAO(ARRAY_SIZE(vf::fmtdesc_p2uv2cu4), vf::fmtdesc_p2uv2cu4, 0, NULL); vf::p3_vertex_t::vao = createVAO(ARRAY_SIZE(vf::fmtdesc_p3), vf::fmtdesc_p3, 0, NULL); vf::p3cu4_vertex_t::vao = createVAO(ARRAY_SIZE(vf::fmtdesc_p3cu4), vf::fmtdesc_p3cu4, 0, NULL); vf::p3uv2cu4_vertex_t::vao = createVAO(ARRAY_SIZE(vf::fmtdesc_p3uv2cu4), vf::fmtdesc_p3uv2cu4, 0, NULL); glGenVertexArrays(1, &vf::empty_geom_t::vao); prgUI = res::createProgramFromFiles("UI.vert", "UI.frag"); prgRasterCubic = res::createProgramFromFiles("VG.Cubic.vert", "VG.Mask.Cubic.frag"); prgRasterCubicAA = res::createProgramFromFiles("VG.Cubic.vert", "VG.Mask.Cubic.AA.frag"); prgPaintSolid = res::createProgramFromFiles("VG.Paint.vert", "VG.Paint.Solid.frag"); prgPaintLinGradient = res::createProgramFromFiles("VG.Paint.vert", "VG.Paint.LinearGradient.frag"); const char* version = "#version 430\n\n"; const char* enableColor = "#define ENABLE_COLOR\n"; const char* enableTexture = "#define ENABLE_TEXTURE\n"; const char* enableVGAA = "#define EDGE_AA 1\n"; const char* headers[3] = {version}; size_t numHeaders; for (size_t i=0; i<STD_PROGRAM_COUNT; ++i) { numHeaders = 1; if (i&gfx::STD_FEATURE_COLOR) { headers[numHeaders++] = enableColor; } if (i&gfx::STD_FEATURE_TEXTURE) { headers[numHeaders++] = enableTexture; } stdPrograms[i] = res::createProgramFromFiles("MESH.std.vert", "MESH.std.frag", numHeaders, headers); } headers[1] = enableColor; prgLine = res::createProgramFromFiles("MESH.Line.vert", "MESH.std.frag", 2, headers); prgPoint = res::createProgramFromFiles("MESH.Point.vert", "MESH.std.frag", 2, headers); prgRect = res::createProgramFromFiles("MESH.Rect.vert", "MESH.std.frag", 2, headers); headers[1] = enableVGAA; prgNanoVG = res::createProgramFromFiles("NanoVG.vert", "NanoVG.frag", 1, headers); prgNanoVGAA = res::createProgramFromFiles("NanoVG.vert", "NanoVG.frag", 2, headers); gfx::vertex_element_t ve[2] = { {0, 0, 0, GL_FLOAT, 4, GL_FALSE, GL_FALSE}, {1, 0, 1, GL_UNSIGNED_BYTE, 4, GL_FALSE, GL_TRUE }, }; GLuint divs[2] = {1, 1}; vaoRect = gfx::createVAO(2, ve, 2, divs); vgGArena = etlsf_create(VG_BUFFER_SIZE, GFX_MAX_ALLOCS); glGenBuffers(1, &buffer); glNamedBufferStorageEXT(buffer, VG_BUFFER_SIZE, 0, GL_MAP_WRITE_BIT); vg::defaultFont = vg::createFont(anonymousProBTTF, sizeof(anonymousProBTTF), 16); vg::nvgDefFont = nvgCreateFontMem(vg::ctx, "default", anonymousProBTTF, sizeof(anonymousProBTTF), 0); }