void RenderingEngine::Initialize(const vector<ISurface*>& surfaces)
{
vector<ISurface*>::const_iterator surface;
for (surface = surfaces.begin(); surface != surfaces.end(); ++surface) {
// Create the VBO for the vertices.
vector<float> vertices;
(*surface)->GenerateVertices(vertices, VertexFlagsNormals|VertexFlagsTexCoords);
GLuint vertexBuffer;
glGenBuffers(1, &vertexBuffer);
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
glBufferData(GL_ARRAY_BUFFER,
vertices.size() * sizeof(vertices[0]),
&vertices[0],
GL_STATIC_DRAW);
// Create a new VBO for the indices if needed.
int indexCount = (*surface)->GetTriangleIndexCount();
GLuint indexBuffer;
if (!m_drawables.empty() && indexCount == m_drawables[0].IndexCount) {
indexBuffer = m_drawables[0].IndexBuffer;
} else {
vector<GLushort> indices(indexCount);
(*surface)->GenerateTriangleIndices(indices);
glGenBuffers(1, &indexBuffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
indexCount * sizeof(GLushort),
&indices[0],
GL_STATIC_DRAW);
}
int lineIndexCount = (*surface)->GetLineIndexCount();
GLuint lineIndexBuffer;
vector<GLushort> lineIndices(lineIndexCount);
(*surface)->GenerateLineIndices(lineIndices);
glGenBuffers(1, &lineIndexBuffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, lineIndexBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
lineIndexCount * sizeof(GLushort),
&lineIndices[0],
GL_STATIC_DRAW);
Drawable drawable = { vertexBuffer, indexBuffer , indexCount};
m_drawables.push_back(drawable);
}
// Extract width and height.
int width, height;
glGetRenderbufferParameteriv(GL_RENDERBUFFER,
GL_RENDERBUFFER_WIDTH, &width);
glGetRenderbufferParameteriv(GL_RENDERBUFFER,
GL_RENDERBUFFER_HEIGHT, &height);
// Create a depth buffer that has the same size as the color buffer.
glGenRenderbuffers(1, &m_depthRenderbuffer);
glBindRenderbuffer(GL_RENDERBUFFER, m_depthRenderbuffer);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, width, height);
// Create the framebuffer object.
GLuint framebuffer;
glGenFramebuffers(1, &framebuffer);
glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_RENDERBUFFER, m_colorRenderbuffer);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
GL_RENDERBUFFER, m_depthRenderbuffer);
glBindRenderbuffer(GL_RENDERBUFFER, m_colorRenderbuffer);
// Create the GLSL program.
GLuint program = BuildProgram(SimpleVertexShader, SimpleFragmentShader);
glUseProgram(program);
// Extract the handles to attributes and uniforms.
m_attributes.Position = glGetAttribLocation(program, "Position");
m_attributes.Normal = glGetAttribLocation(program, "Normal");
m_attributes.Diffuse = glGetAttribLocation(program, "DiffuseMaterial");
m_attributes.TextureCoord = glGetAttribLocation(program, "TextureCoord");
m_uniforms.Projection = glGetUniformLocation(program, "Projection");
m_uniforms.Modelview = glGetUniformLocation(program, "Modelview");
m_uniforms.NormalMatrix = glGetUniformLocation(program, "NormalMatrix");
m_uniforms.LightPosition = glGetUniformLocation(program, "LightPosition");
m_uniforms.AmbientMaterial = glGetUniformLocation(program, "AmbientMaterial");
m_uniforms.SpecularMaterial = glGetUniformLocation(program, "SpecularMaterial");
m_uniforms.Shininess = glGetUniformLocation(program, "Shininess");
// Set up some default material parameters.
glUniform3f(m_uniforms.AmbientMaterial, 0.04f, 0.04f, 0.04f);
glUniform3f(m_uniforms.SpecularMaterial, 0.5, 0.5, 0.5);
glUniform1f(m_uniforms.Shininess, 50);
// Set the active sampler to stage 0. Not really necessary since the uniform
// defaults to zero anyway, but good practice.
glActiveTexture(GL_TEXTURE0);
glUniform1i(m_uniforms.Sampler, 0);
// Load the texture.
glGenTextures(1,&m_gridTexture);
glBindTexture(GL_TEXTURE_2D, m_gridTexture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
m_resourceManager = CreateResourceManager();
m_resourceManager->LoadPngImage("Grid16.png");
void* pixels = m_resourceManager->GetImageData();
ivec2 size = m_resourceManager->GetImageSize();
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, size.x,
size.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
m_resourceManager->UnloadImage();
// Initialize various state.
glEnableVertexAttribArray(m_attributes.Position);
glEnableVertexAttribArray(m_attributes.Normal);
glEnableVertexAttribArray(m_attributes.TextureCoord);
glEnable(GL_DEPTH_TEST);
// Set up transforms.
m_translation = mat4::Translate(0, 0, -7);
}
void StateRenderTest::InitGrid(beRenderInterface* renderInterface)
{
const int gridRadius = 100;
const float gridSize = 1.f;
const float xyOffset = gridSize / 2.f; // Don't draw on same spot as renderAxes
const float gridOffset = ((float)gridRadius / 2.f);
const int quadCount = gridRadius * gridRadius;
const int vertexCount = quadCount * 8;
const int triCount = quadCount * 2;
const int triIndexCount = triCount * 3;
const float noiseScale = 5.f;
const float noiseHeight = 8.f;
beRandom rng;
rng.InitFromSystemTime();
bePerlinNoise2D noise;
noise.Initialise(rng.Next());
beVector<beShaderColour::VertexType> vertices(vertexCount, vertexCount, 0);
beVector<u32> lineIndices(vertexCount, vertexCount, 0);
beVector<u32> triIndices(triIndexCount, triIndexCount, 0);
for (int i : RangeIter(lineIndices.Count()))
{
lineIndices[i] = i;
}
for (int i : RangeIter(quadCount))
{
const int triListIndex = i * 6;
const int lineListIndex = i * 8;
triIndices[triListIndex+0] = lineListIndex+0;
triIndices[triListIndex+1] = lineListIndex+2;
triIndices[triListIndex+2] = lineListIndex+4;
triIndices[triListIndex+3] = lineListIndex+4;
triIndices[triListIndex+4] = lineListIndex+6;
triIndices[triListIndex+5] = lineListIndex+0;
}
int vertexIndex = 0;
for (float x = -gridOffset; x < gridOffset; x += gridSize)
{
const float xPos0 = x + xyOffset;
const float xPos1 = xPos0+gridSize;
for (float y = -gridOffset; y < gridOffset; y += gridSize)
{
const float yPos0 = y + xyOffset;
const float yPos1 = yPos0+gridSize;
const float zPos0 = noiseHeight * noise.GetOctave(xPos0/noiseScale, yPos0/noiseScale, 4);
const float zPos1 = noiseHeight * noise.GetOctave(xPos0/noiseScale, yPos1/noiseScale, 4);
const float zPos2 = noiseHeight * noise.GetOctave(xPos1/noiseScale, yPos1/noiseScale, 4);
const float zPos3 = noiseHeight * noise.GetOctave(xPos1/noiseScale, yPos0/noiseScale, 4);
const Vec4 pos0(xPos0, yPos0, zPos0, 1.f);
const Vec4 pos1(xPos0, yPos1, zPos1, 1.f);
const Vec4 pos2(xPos1, yPos1, zPos2, 1.f);
const Vec4 pos3(xPos1, yPos0, zPos3, 1.f);
//LOG("[{},{}] 0- {}", x, y, pos0);
//LOG("[{},{}] 1- {}", x, y, pos1);
//LOG("[{},{}] 2- {}", x, y, pos2);
//LOG("[{},{}] 3- {}", x, y, pos3);
vertices[vertexIndex+0].position = pos0;
vertices[vertexIndex+1].position = pos1;
vertices[vertexIndex+2].position = pos1;
vertices[vertexIndex+3].position = pos2;
vertices[vertexIndex+4].position = pos2;
vertices[vertexIndex+5].position = pos3;
vertices[vertexIndex+6].position = pos3;
vertices[vertexIndex+7].position = pos0;
vertices[vertexIndex+0].colour = Vec4(zPos0 / noiseHeight, zPos0 / noiseHeight, 1.f, 1.f);
vertices[vertexIndex+1].colour = Vec4(zPos1 / noiseHeight, zPos1 / noiseHeight, 1.f, 1.f);
vertices[vertexIndex+2].colour = Vec4(zPos1 / noiseHeight, zPos1 / noiseHeight, 1.f, 1.f);
vertices[vertexIndex+3].colour = Vec4(zPos2 / noiseHeight, zPos2 / noiseHeight, 1.f, 1.f);
vertices[vertexIndex+4].colour = Vec4(zPos2 / noiseHeight, zPos2 / noiseHeight, 1.f, 1.f);
vertices[vertexIndex+5].colour = Vec4(zPos3 / noiseHeight, zPos3 / noiseHeight, 1.f, 1.f);
vertices[vertexIndex+6].colour = Vec4(zPos3 / noiseHeight, zPos3 / noiseHeight, 1.f, 1.f);
vertices[vertexIndex+7].colour = Vec4(zPos0 / noiseHeight, zPos0 / noiseHeight, 1.f, 1.f);
vertexIndex += 8;
}
}
beRenderBuffer vertexBuffer, indexBuffer, linesIndexB;
vertexBuffer.Allocate(renderInterface, ElementSize(vertices), vertexCount, D3D11_USAGE_DEFAULT, D3D11_BIND_VERTEX_BUFFER, 0, 0, 0, vertices.begin());
beModel::Material materials[1];
materials[0].m_shader = beRendering::ShaderType::Colour;
beModel::Mesh meshes[2];
meshes[0].m_name = beString("GroundFilled");
meshes[0].m_indexBuffer.Allocate(renderInterface, decltype(triIndices)::element_size, triIndices.Count(), D3D11_USAGE_DEFAULT, D3D11_BIND_INDEX_BUFFER, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST, 0, 0, triIndices.begin());
meshes[0].m_materialIndex = 0;
meshes[0].m_enabled = false;
meshes[1].m_name = beString("GroundLines");
meshes[1].m_indexBuffer.Allocate(renderInterface, decltype(lineIndices)::element_size, vertexCount, D3D11_USAGE_DEFAULT, D3D11_BIND_INDEX_BUFFER, D3D11_PRIMITIVE_TOPOLOGY_LINELIST, 0, 0, lineIndices.begin());
meshes[1].m_materialIndex = 0;
const bool success = m_gridModel.InitFromBuffers(&vertexBuffer, meshes, materials);
if (!success) { BE_ASSERT(false); return; }
}
void RenderingEngine::Initialize(const vector<ISurface*>& surfaces)
{
vector<ISurface*>::const_iterator surface;
for (surface = surfaces.begin(); surface != surfaces.end(); ++surface) {
// Create the VBO for the vertices.
vector<float> vertices;
(*surface)->GenerateVertices(vertices, VertexFlagsNormals);
GLuint vertexBuffer;
glGenBuffers(1, &vertexBuffer);
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
glBufferData(GL_ARRAY_BUFFER,
vertices.size() * sizeof(vertices[0]),
&vertices[0],
GL_STATIC_DRAW);
// Create a VBO for the triangle indices.
int triangleIndexCount = (*surface)->GetTriangleIndexCount();
vector<GLushort> triangleIndices(triangleIndexCount);
(*surface)->GenerateTriangleIndices(triangleIndices);
GLuint triangleIndexBuffer;
glGenBuffers(1, &triangleIndexBuffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, triangleIndexBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
triangleIndexCount * sizeof(GLushort),
&triangleIndices[0],
GL_STATIC_DRAW);
// Create a VBO for the line indices.
int lineIndexCount = (*surface)->GetTriangleIndexCount();
vector<GLushort> lineIndices(lineIndexCount);
(*surface)->GenerateLineIndices(lineIndices);
GLuint lineIndexBuffer;
glGenBuffers(1, &lineIndexBuffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, lineIndexBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
lineIndexCount * sizeof(GLushort),
&lineIndices[0],
GL_STATIC_DRAW);
Drawable drawable = {
vertexBuffer,
triangleIndexBuffer,
lineIndexBuffer,
triangleIndexCount,
lineIndexBuffer
};
m_drawables.push_back(drawable);
}
#ifndef MACOSX
// Extract width and height from the color buffer.
int width, height;
glGetRenderbufferParameterivOES(GL_RENDERBUFFER_OES,
GL_RENDERBUFFER_WIDTH_OES, &width);
glGetRenderbufferParameterivOES(GL_RENDERBUFFER_OES,
GL_RENDERBUFFER_HEIGHT_OES, &height);
// Create a depth buffer that has the same size as the color buffer.
glGenRenderbuffersOES(1, &m_depthRenderbuffer);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, m_depthRenderbuffer);
glRenderbufferStorageOES(GL_RENDERBUFFER_OES, GL_DEPTH_COMPONENT16_OES,
width, height);
// Create the framebuffer object.
GLuint framebuffer;
glGenFramebuffersOES(1, &framebuffer);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, framebuffer);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES,
GL_RENDERBUFFER_OES, m_colorRenderbuffer);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES,
GL_RENDERBUFFER_OES, m_depthRenderbuffer);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, m_colorRenderbuffer);
#endif
// Set up various GL state.
glEnableClientState(GL_VERTEX_ARRAY);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_FLAT);
glEnable(GL_LINE_SMOOTH);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
// Set up the material properties.
vec4 ambient(0.2f, 0.2f, 0.2f, 1);
vec4 specular(0.5f, 0.5f, 0.5f, 1);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambient.Pointer());
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular.Pointer());
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 30.0f);
m_translation = mat4::Translate(0, 0, -7);
}
