void RenderTerrain::loadData() { m_materialAsset = static_cast<GearMaterialAsset*>(GearAssetManager::getSingleton( )->getAsset("materials/sampleterrain.xml", GearAsset::ASSET_MATERIAL)); m_materialInstance = m_materialAsset->getMaterialInstance(0); m_materialInstance->getMaterial().setCullMode(RenderMaterial::COUNTER_CLOCKWISE); const RenderMaterial::Variable* var = m_materialInstance->findVariable("g_uvMul",RenderMaterial::VARIABLE_FLOAT4); if (var) { Vector4 uvm = getLayersUvMuler(); m_materialInstance->writeData(*var,(void*)(&uvm)); } createIndexBuffer(); if (m_quadTree) { m_quadTree->loadData(); } m_cellNode = m_sceneMgr->createCellNode("_terrain"); m_sceneMgr->getRootCellNode()->addChild(m_cellNode); RenderTransform* tn = m_cellNode->createChildTransformNode(); tn->attachObject(this); tn->setPosition(m_position); }
int main(int argc, char* argv) { glutInit(&argc, &argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA); glutInitWindowSize(1024, 768); glutInitWindowPosition(200, 200); glutCreateWindow("Perspective Projection"); GLint res = glewInit(); if (res != GLEW_OK) { fprintf(stderr, "Error: glewInit\n"); exit(1); } glClearColor(0.0f, 0.0f, 0.0f, 1.0f); InitializeCallback(); createVertexBuffer(); createIndexBuffer(); compileShader(); glutMainLoop(); return 0; }
void op3d::Engine::initVulkan() { instance.create(); callback.setup(instance); surface.create(instance, window); physicalDevice.create(instance, surface); device.create(physicalDevice, surface, graphicsQueue, presentQueue); swapChain.create(device, surface, physicalDevice, window); swapChain.createImageViews(device, swapChainImageViews); createRenderPass(); createDescriptorSetLayout(); createGraphicsPipeline(); commandBufferManager.createCommandPool(physicalDevice, surface); createDepthResources(); createFramebuffers(); createTextureImage(); createTextureImageView(); createTextureSampler(); createVertexBuffer(); createIndexBuffer(); createUniformBuffer(); descriptorPool.createPool(); descriptorSet.createSet(uniformBuffer, textureImageView, textureSampler, descriptorSetLayout, descriptorPool, device); createCommandBuffers(); createSemaphores(); }
geometry* createBox() { geometry* geom = new geometry(); for(int i = 0; i < 8; ++i) { geom->vertices.push_back(box_vertices[i]); geom->normals.push_back(box_normals[i]); } for (int i = 0; i < 36; ++i) geom->indices.push_back(box_indices[i]); createVertexBuffer(geom); glGenBuffers(1, &geom->normalBuffer); glBindBuffer(GL_ARRAY_BUFFER, geom->normalBuffer); glBufferData(GL_ARRAY_BUFFER, geom->normals.size() * sizeof(glm::vec3), &geom->normals[0], GL_STATIC_DRAW); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(1); glBindVertexArray(0); createIndexBuffer(geom); return geom; }
void SceneRenderer::createVAO(GeoModel3D model) { GLuint vao_new_id; std::vector<GLModel3DData> modelData = model.retrieveMeshes(); for (std::vector<GLModel3DData>::iterator mesh = modelData.begin(); mesh != modelData.end(); mesh++) { glGenVertexArrays(1, &vao_new_id); // Create our Vertex Array Object glBindVertexArray(vao_new_id); // Bind our Vertex Array Object so we can use it glGenBuffers(1, &IBO); glGenBuffers(3, vbos); GLuint mesh_id = mesh->getMeshID(); tinyobj::mesh_t mesh_data = mesh->getMeshData(); std::pair<GLuint, GLuint> mapping(mesh_id, vao_new_id); object_vao_map.insert(mapping); createVertexBuffer(mesh_data.positions); /*createNormalsBuffer(mesh_data.normals);*/ createTexCoordsBuffer(mesh_data.texcoords); createIndexBuffer(mesh_data.indices); glEnableVertexAttribArray(0); // Disable our Vertex Array Object glBindVertexArray(0); // Disable our Vertex Buffer Object } }
//Init function, used to initialise the component void CGeometryComponent::init() { //Call create vertex buffer createVertexBuffer(); //Call create index buffer createIndexBuffer(); }
//Init function, used to initialise the component void CGeometry::createBuffers() { //Call create vertex buffer createVertexBuffer(); //Call create index buffer createIndexBuffer(); }
int main( int argc , char **argv ) { glutInit( &argc , argv ); glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGBA ); glutInitWindowSize( WINDOW_WIDTH , WINDOW_HEIGHT ); glutInitWindowPosition( 100 , 100 ); glutCreateWindow( "Perspective Projection" ); glutDisplayFunc( render ); glutIdleFunc( render ); if( glewInit() != GLEW_OK ) return 1; glClearColor( 0.0f , 0.0f , 0.0f , 0.0f ); createVertexBuffer(); createIndexBuffer(); compileShader(); glutMainLoop(); return 0; }
//------------------------------------------------------------------------- void ManualObject::index( const uint32 idx ) { if( m_index == nullptr ) { createIndexBuffer(); } *(m_index++) = idx; }
geometry* createSierpinski(int divisions) { glm::vec3 vertices[4]; std::memcpy(vertices, tetrahedron_vertices, sizeof(glm::vec3) * 4); geometry* geom = new geometry(); divide_sierpinski(geom, vertices, divisions); createVertexBuffer(geom); createIndexBuffer(geom); return geom; }
HRESULT MeshGroup::createBuffers(ID3D11Device* device) { HRESULT hr = S_OK; hr = createIndexBuffer(device); if (FAILED(hr)) return hr; hr = createVertexBuffer(device); return hr; }
geometry* createPyramid() { geometry* geom = new geometry(); for (int i = 0; i < 5; ++i) geom->vertices.push_back(pyramid_vertices[i]); for (int i = 0; i < 18; ++i) geom->indices.push_back(pyramid_indices[i]); createVertexBuffer(geom); createIndexBuffer(geom); return geom; }
geometry* createBox() { geometry* geom = new geometry(); for(int i = 0; i < 8; ++i) geom->vertices.push_back(box_vertices[i]); for (int i = 0; i < 36; ++i) geom->indices.push_back(box_indices[i]); createVertexBuffer(geom); createIndexBuffer(geom); return geom; }
geometry* createTetrahedron() { geometry* geom = new geometry(); for (int i = 0; i < 4; ++i) geom->vertices.push_back(tetrahedron_vertices[i]); for (int i = 0; i < 12; ++i) geom->indices.push_back(tetrahedron_indices[i]); createVertexBuffer(geom); createIndexBuffer(geom); return geom; }
geometry* createTetrahedron() { geometry* geom = new geometry(); for (int i = 0; i < 4; ++i) { geom->vertices.push_back(tetrahedron_vertices[i]); geom->normals.push_back(tetrahedron_normals[i]); } for (int i = 0; i < 12; ++i) geom->indices.push_back(tetrahedron_indices[i]); createVertexBuffer(geom); createNormalBuffer(geom); glBindVertexArray(0); createIndexBuffer(geom); return geom; }
geometry* createPyramid() { geometry* geom = new geometry(); for (int i = 0; i < 5; ++i) { geom->vertices.push_back(pyramid_vertices[i]); geom->normals.push_back(pyramid_normals[i]); } for (int i = 0; i < 18; ++i) geom->indices.push_back(pyramid_indices[i]); createVertexBuffer(geom); createNormalBuffer(geom); glBindVertexArray(0); createIndexBuffer(geom); return geom; }
geometry* createBox() { geometry* geom = new geometry(); for(int i = 0; i < 8; ++i) { geom->vertices.push_back(box_vertices[i]); geom->normals.push_back(box_normals[i]); } for (int i = 0; i < 36; ++i) geom->indices.push_back(box_indices[i]); createVertexBuffer(geom); createNormalBuffer(geom); glBindVertexArray(0); createIndexBuffer(geom); return geom; }
int main(void) { SVGA3DUtil_InitFullscreen(CID, 800, 600); SVGA3DText_Init(); vertexSid = SVGA3DUtil_DefineSurface2D(MESH_NUM_BYTES, 1, SVGA3D_BUFFER); indexSid = createIndexBuffer(); SVGA3DUtil_AllocDMAPool(&vertexDMA, MESH_NUM_BYTES, 16); Matrix_Perspective(perspectiveMat, 45.0f, gSVGA.width / (float)gSVGA.height, 0.1f, 100.0f); while (1) { if (SVGA3DUtil_UpdateFPSCounter(&gFPS)) { Console_Clear(); Console_Format("VMware SVGA3D Example:\n" "Dynamic vertex buffer stress-test.\n" "This example performs a separate DMA and " "Draw for each row of the mesh.\n\n%s", gFPS.text); SVGA3DText_Update(); } SVGA3DUtil_ClearFullscreen(CID, SVGA3D_CLEAR_COLOR | SVGA3D_CLEAR_DEPTH, 0x113366, 1.0f, 0); setupFrame(); render(); SVGA3DText_Draw(); SVGA3DUtil_PresentFullscreen(); } return 0; }
void Tutorial::Run() { #ifdef __TUT_VERSION #if __TUT_VERSION >= 17 if (_tutorialID >= 17) { char windowName[255]; sprintf(&windowName[0], "Tutorial %d", _tutorialID); if (!GLUTBackendCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, false, windowName)) { return; } #if __TUT_VERSION == 17 _tutorial = new Tutorial17(); #elif __TUT_VERSION == 18 _tutorial = new Tutorial18(); #elif __TUT_VERSION == 19 _tutorial = new Tutorial19(); #elif __TUT_VERSION == 20 _tutorial = new Tutorial20(); #elif __TUT_VERSION == 21 _tutorial = new Tutorial21(); #elif __TUT_VERSION == 22 _tutorial = new Tutorial22(); #elif __TUT_VERSION == 23 _tutorial = new Tutorial23(); #endif if (!_tutorial->Init(pVSFileName, pFSFileName)) { return; } char* version = (char*)glGetString(GL_VERSION); fprintf(stdout, "Version: '%s'\n", version); _tutorial->Run(); delete _tutorial; return; } #endif #endif initGlut(); initGlew(); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); if (_tutorialID == 16) { glFrontFace(GL_CW); glCullFace(GL_BACK); glEnable(GL_CULL_FACE); } char* version = (char*)glGetString(GL_VERSION); fprintf(stdout, "Version: '%s'\n", version); /// /// Create vertex buffer: glGenBuffers, glBindBuffer, glBufferData. /// createVertexBuffer(); /// /// Create the index buffer: glGenBuffers, glBindBuffer, glBufferData. /// createIndexBuffer(); /// /// Read shaders from file, compile, verify and add to shader program. /// compileShaders(); if (_tutorialID == 16) { glUniform1i(_gSampler, 0); _pTexture = new Texture(GL_TEXTURE_2D, "/home/lparkin/Projects/S3/OpenGlDirsProject/LearnOpenGL-nonQt/Project/Content/test.png"); if (!_pTexture->Load()) { exit(1); } } /// /// Setup the perspective projection information. /// _gPersProjInfo.FOV = 60.0f; _gPersProjInfo.Height = WINDOW_HEIGHT_1_14; _gPersProjInfo.Width = WINDOW_WIDTH_1_14; _gPersProjInfo.zNear = 1.0f; _gPersProjInfo.zFar = 100.0f; /// /// Start the rendering loop. /// glutMainLoop(); }
RID IndexBufferParser::parse(JSONReader& reader, int childIndex) { IndexBufferDescriptor descriptor; reader.get(childIndex, "size", &descriptor.size); const char* name = reader.get_string(childIndex, "name"); return createIndexBuffer(name, descriptor); }
bool GLES2Renderer::initTexter() { Renderer::initTexter(); PxU32 width, height; getWindowSize(width, height); const PxU32 MIN_CHARACTER_WIDTH = 8; const PxU32 TEXT_MAX_VERTICES = 16 * (width / MIN_CHARACTER_WIDTH); const PxU32 TEXT_MAX_INDICES = TEXT_MAX_VERTICES * 1.5f; // initialize vertex buffer -- will be used by all texts RendererVertexBufferDesc vbdesc; vbdesc.hint = RendererVertexBuffer::HINT_STATIC; vbdesc.maxVertices = TEXT_MAX_VERTICES; vbdesc.semanticFormats[RendererVertexBuffer::SEMANTIC_POSITION] = RendererVertexBuffer::FORMAT_FLOAT3; vbdesc.semanticFormats[RendererVertexBuffer::SEMANTIC_TEXCOORD0] = RendererVertexBuffer::FORMAT_FLOAT2; vbdesc.semanticFormats[RendererVertexBuffer::SEMANTIC_COLOR] = RendererVertexBuffer::FORMAT_COLOR_NATIVE; m_textVertexBuffer = createVertexBuffer(vbdesc); RENDERER_ASSERT(m_textVertexBuffer, "Failed to create Vertex Buffer."); // initialize index buffer RendererIndexBufferDesc inbdesc; inbdesc.hint = RendererIndexBuffer::HINT_STATIC; inbdesc.format = RendererIndexBuffer::FORMAT_UINT16; inbdesc.maxIndices = TEXT_MAX_INDICES; m_textIndexBuffer = createIndexBuffer(inbdesc); RENDERER_ASSERT(m_textIndexBuffer, "Failed to create Instance Buffer."); RendererMeshDesc meshdesc; meshdesc.primitives = RendererMesh::PRIMITIVE_TRIANGLES; meshdesc.vertexBuffers = &m_textVertexBuffer; meshdesc.numVertexBuffers = 1; meshdesc.firstVertex = 0; meshdesc.numVertices = m_textVertexBuffer->getMaxVertices(); meshdesc.indexBuffer = m_textIndexBuffer; meshdesc.firstIndex = 0; meshdesc.numIndices = m_textIndexBuffer->getMaxIndices(); meshdesc.instanceBuffer = NULL; meshdesc.firstInstance = 0; meshdesc.numInstances = 0; m_textMesh = createMesh(meshdesc); RENDERER_ASSERT(m_textMesh, "Failed to create Mesh."); m_textMaterial = NULL; m_textVertexBufferOffset = 0; m_textIndexBufferOffset = 0; // create mesh for quad vbdesc.hint = RendererVertexBuffer::HINT_STATIC; vbdesc.maxVertices = 128; vbdesc.semanticFormats[RendererVertexBuffer::SEMANTIC_POSITION] = RendererVertexBuffer::FORMAT_FLOAT3; vbdesc.semanticFormats[RendererVertexBuffer::SEMANTIC_TEXCOORD0] = RendererVertexBuffer::FORMAT_FLOAT2; vbdesc.semanticFormats[RendererVertexBuffer::SEMANTIC_COLOR] = RendererVertexBuffer::FORMAT_COLOR_NATIVE; m_quadVertexBuffer = createVertexBuffer(vbdesc); RENDERER_ASSERT(m_quadVertexBuffer, "Failed to create Vertex Buffer."); // initialize index buffer inbdesc.hint = RendererIndexBuffer::HINT_STATIC; inbdesc.format = RendererIndexBuffer::FORMAT_UINT16; inbdesc.maxIndices = 128; m_quadIndexBuffer = createIndexBuffer(inbdesc); RENDERER_ASSERT(m_quadIndexBuffer, "Failed to create Instance Buffer."); meshdesc.primitives = RendererMesh::PRIMITIVE_TRIANGLES; meshdesc.vertexBuffers = &m_quadVertexBuffer; meshdesc.numVertexBuffers = 1; meshdesc.firstVertex = 0; meshdesc.numVertices = m_quadVertexBuffer->getMaxVertices(); meshdesc.indexBuffer = m_quadIndexBuffer; meshdesc.firstIndex = 0; meshdesc.numIndices = m_quadIndexBuffer->getMaxIndices(); meshdesc.instanceBuffer = NULL; meshdesc.firstInstance = 0; meshdesc.numInstances = 0; m_quadMesh = createMesh(meshdesc); RENDERER_ASSERT(m_quadMesh, "Failed to create Mesh."); }