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.");
}
