void DebugDrawer::reset()
{
GeometryBuffer* linesGB = lines->getGeometryBuffer().get();
linesGB->clear();
GeometryBuffer* trianglesGB = triangles->getGeometryBuffer().get();
trianglesGB->clear();
GeometryBuffer* quadsGB = quads->getGeometryBuffer().get();
quadsGB->clear();
//renderables.clear();
currentColor = Color::White;
currentColor.a = 0.4f;
}
/*************************************************************************
Queues an area of the associated Texture the be drawn on the screen.
Low-level routine not normally used!
*************************************************************************/
void Imageset::draw(GeometryBuffer& buffer, const Rect& source_rect,
const Rect& dest_rect, const Rect* clip_rect,const ColourRect& colours,
QuadSplitMode quad_split_mode) const
{
// get the rect area that we will actually draw to (i.e. perform clipping)
Rect final_rect(clip_rect ? dest_rect.getIntersection(*clip_rect) : dest_rect );
// check if rect was totally clipped
if ((final_rect.getWidth() == 0) || (final_rect.getHeight() == 0))
return;
// Fix bug #45
// Obtain correct scale values from the texture
const float x_scale = d_texture->getTexelScaling().d_x;
const float y_scale = d_texture->getTexelScaling().d_y;
float tex_per_pix_x = source_rect.getWidth() / dest_rect.getWidth();
float tex_per_pix_y = source_rect.getHeight() / dest_rect.getHeight();
// calculate final, clipped, texture co-ordinates
Rect tex_rect((source_rect.d_left + ((final_rect.d_left - dest_rect.d_left) * tex_per_pix_x)) * x_scale,
(source_rect.d_top + ((final_rect.d_top - dest_rect.d_top) * tex_per_pix_y)) * y_scale,
(source_rect.d_right + ((final_rect.d_right - dest_rect.d_right) * tex_per_pix_x)) * x_scale,
(source_rect.d_bottom + ((final_rect.d_bottom - dest_rect.d_bottom) * tex_per_pix_y)) * y_scale);
final_rect.d_left = PixelAligned(final_rect.d_left);
final_rect.d_right = PixelAligned(final_rect.d_right);
final_rect.d_top = PixelAligned(final_rect.d_top);
final_rect.d_bottom = PixelAligned(final_rect.d_bottom);
Vertex vbuffer[6];
// vertex 0
vbuffer[0].position = Vector3(final_rect.d_left, final_rect.d_top, 0.0f);
vbuffer[0].colour_val = colours.d_top_left;
vbuffer[0].tex_coords = Vector2(tex_rect.d_left, tex_rect.d_top);
// vertex 1
vbuffer[1].position = Vector3(final_rect.d_left, final_rect.d_bottom, 0.0f);
vbuffer[1].colour_val = colours.d_bottom_left;
vbuffer[1].tex_coords = Vector2(tex_rect.d_left, tex_rect.d_bottom);
// vertex 2
vbuffer[2].position.d_x = final_rect.d_right;
vbuffer[2].position.d_z = 0.0f;
vbuffer[2].colour_val = colours.d_bottom_right;
vbuffer[2].tex_coords.d_x = tex_rect.d_right;
// top-left to bottom-right diagonal
if (quad_split_mode == TopLeftToBottomRight)
{
vbuffer[2].position.d_y = final_rect.d_bottom;
vbuffer[2].tex_coords.d_y = tex_rect.d_bottom;
}
// bottom-left to top-right diagonal
else
{
vbuffer[2].position.d_y = final_rect.d_top;
vbuffer[2].tex_coords.d_y = tex_rect.d_top;
}
// vertex 3
vbuffer[3].position = Vector3(final_rect.d_right, final_rect.d_top, 0.0f);
vbuffer[3].colour_val = colours.d_top_right;
vbuffer[3].tex_coords = Vector2(tex_rect.d_right, tex_rect.d_top);
// vertex 4
vbuffer[4].position.d_x = final_rect.d_left;
vbuffer[4].position.d_z = 0.0f;
vbuffer[4].colour_val = colours.d_top_left;
vbuffer[4].tex_coords.d_x = tex_rect.d_left;
// top-left to bottom-right diagonal
if (quad_split_mode == TopLeftToBottomRight)
{
vbuffer[4].position.d_y = final_rect.d_top;
vbuffer[4].tex_coords.d_y = tex_rect.d_top;
}
// bottom-left to top-right diagonal
else
{
vbuffer[4].position.d_y = final_rect.d_bottom;
vbuffer[4].tex_coords.d_y = tex_rect.d_bottom;
}
// vertex 5
vbuffer[5].position = Vector3(final_rect.d_right, final_rect.d_bottom, 0.0f);
vbuffer[5].colour_val= colours.d_bottom_right;
vbuffer[5].tex_coords = Vector2(tex_rect.d_right, tex_rect.d_bottom);
// TODO: Remove cast when GeometryBuffer gets it's APIs fixed!
buffer.setActiveTexture((Texture*)d_texture);
buffer.appendGeometry(vbuffer, 6);
}
//----------------------------------------------------------------------------//
void OgreRenderTarget::draw(const GeometryBuffer& buffer)
{
buffer.draw();
}
//----------------------------------------------------------------------------//
void Direct3D10RenderTarget::draw(const GeometryBuffer& buffer)
{
buffer.draw();
}
GameRenderer::GameRenderer(Logger* log, GameData* _data)
: data(_data)
, logger(log)
, renderer(new OpenGLRenderer)
, _renderAlpha(0.f)
, _renderWorld(nullptr)
, cullOverride(false)
, map(renderer, _data)
, water(this)
, text(this)
{
logger->info("Renderer", renderer->getIDString());
worldProg = renderer->createShader(
GameShaders::WorldObject::VertexShader,
GameShaders::WorldObject::FragmentShader);
renderer->setUniformTexture(worldProg, "texture", 0);
renderer->setProgramBlockBinding(worldProg, "SceneData", 1);
renderer->setProgramBlockBinding(worldProg, "ObjectData", 2);
particleProg = renderer->createShader(
GameShaders::WorldObject::VertexShader,
GameShaders::Particle::FragmentShader);
renderer->setUniformTexture(particleProg, "texture", 0);
renderer->setProgramBlockBinding(particleProg, "SceneData", 1);
renderer->setProgramBlockBinding(particleProg, "ObjectData", 2);
skyProg = renderer->createShader(
GameShaders::Sky::VertexShader,
GameShaders::Sky::FragmentShader);
renderer->setProgramBlockBinding(skyProg, "SceneData", 1);
postProg = renderer->createShader(
GameShaders::DefaultPostProcess::VertexShader,
GameShaders::DefaultPostProcess::FragmentShader);
glGenVertexArrays( 1, &vao );
glGenTextures(1, &m_missingTexture);
glBindTexture(GL_TEXTURE_2D, m_missingTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, kMissingTextureBytes);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glGenFramebuffers(1, &framebufferName);
glBindFramebuffer(GL_FRAMEBUFFER, framebufferName);
glGenTextures(2, fbTextures);
glBindTexture(GL_TEXTURE_2D, fbTextures[0]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 128, 128, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glBindTexture(GL_TEXTURE_2D, fbTextures[1]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_R16F, 128, 128, 0, GL_RED, GL_FLOAT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, fbTextures[0], 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, fbTextures[1], 0);
// Give water renderer the data texture
water.setDataTexture(1, fbTextures[1]);
glGenRenderbuffers(1, fbRenderBuffers);
glBindRenderbuffer(GL_RENDERBUFFER, fbRenderBuffers[0]);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 128, 128);
glFramebufferRenderbuffer(
GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, fbRenderBuffers[0]
);
// Create the skydome
size_t segments = skydomeSegments, rows = skydomeRows;
float R = 1.f/(float)(rows-1);
float S = 1.f/(float)(segments-1);
std::vector<VertexP3> skydomeVerts;
skydomeVerts.resize(rows * segments);
for( size_t r = 0, i = 0; r < rows; ++r) {
for( size_t s = 0; s < segments; ++s) {
skydomeVerts[i++].position = glm::vec3(
cos(2.f * M_PI * s * S) * cos(M_PI_2 * r * R),
sin(2.f * M_PI * s * S) * cos(M_PI_2 * r * R),
sin(M_PI_2 * r * R)
);
}
}
skyGbuff.uploadVertices(skydomeVerts);
skyDbuff.addGeometry(&skyGbuff);
skyDbuff.setFaceType(GL_TRIANGLES);
glGenBuffers(1, &skydomeIBO);
std::vector<GLuint> skydomeIndBuff;
skydomeIndBuff.resize(rows*segments*6);
for( size_t r = 0, i = 0; r < (rows-1); ++r ) {
for( size_t s = 0; s < (segments-1); ++s ) {
skydomeIndBuff[i++] = r * segments + s;
skydomeIndBuff[i++] = r * segments + (s+1);
skydomeIndBuff[i++] = (r+1) * segments + (s+1);
skydomeIndBuff[i++] = r * segments + s;
skydomeIndBuff[i++] = (r+1) * segments + (s+1);
skydomeIndBuff[i++] = (r+1) * segments + s;
}
}
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, skydomeIBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * skydomeIndBuff.size(), skydomeIndBuff.data(), GL_STATIC_DRAW);
glBindVertexArray(0);
glGenBuffers(1, &debugVBO);
glGenTextures(1, &debugTex);
glGenVertexArrays(1, &debugVAO);
particleGeom.uploadVertices<ParticleVert>(
{
{ 0.5f, 0.5f, 1.f, 1.f, 1.f, 1.f, 1.f},
{-0.5f, 0.5f, 0.f, 1.f, 1.f, 1.f, 1.f},
{ 0.5f,-0.5f, 1.f, 0.f, 1.f, 1.f, 1.f},
{-0.5f,-0.5f, 0.f, 0.f, 1.f, 1.f, 1.f}
});
particleDraw.addGeometry(&particleGeom);
particleDraw.setFaceType(GL_TRIANGLE_STRIP);
ssRectGeom.uploadVertices(sspaceRect);
ssRectDraw.addGeometry(&ssRectGeom);
ssRectDraw.setFaceType(GL_TRIANGLE_STRIP);
ssRectProgram = compileProgram(GameShaders::ScreenSpaceRect::VertexShader,
GameShaders::ScreenSpaceRect::FragmentShader);
ssRectTexture = glGetUniformLocation(ssRectProgram, "texture");
ssRectColour = glGetUniformLocation(ssRectProgram, "colour");
ssRectSize = glGetUniformLocation(ssRectProgram, "size");
ssRectOffset = glGetUniformLocation(ssRectProgram, "offset");
const static int cylsegments = 16;
std::vector<Model::GeometryVertex> cylverts;
for(int s = 0; s < cylsegments; ++s)
{
float theta = (2.f*glm::pi<float>()/cylsegments) * (s+0);
float gamma = (2.f*glm::pi<float>()/cylsegments) * (s+1);
glm::vec2 p0( glm::sin(theta), glm::cos(theta) );
glm::vec2 p1( glm::sin(gamma), glm::cos(gamma) );
p0 *= 0.5f;
p1 *= 0.5f;
cylverts.push_back({glm::vec3(p0, 2.f), glm::vec3(), glm::vec2(0.45f,0.6f), glm::u8vec4(255, 255, 255, 50)});
cylverts.push_back({glm::vec3(p0,-1.f), glm::vec3(), glm::vec2(0.45f,0.4f), glm::u8vec4(255, 255, 255, 150)});
cylverts.push_back({glm::vec3(p1, 2.f), glm::vec3(), glm::vec2(0.55f,0.6f), glm::u8vec4(255, 255, 255, 50)});
cylverts.push_back({glm::vec3(p0,-1.f), glm::vec3(), glm::vec2(0.45f,0.4f), glm::u8vec4(255, 255, 255, 150)});
cylverts.push_back({glm::vec3(p1,-1.f), glm::vec3(), glm::vec2(0.55f,0.4f), glm::u8vec4(255, 255, 255, 150)});
cylverts.push_back({glm::vec3(p1, 2.f), glm::vec3(), glm::vec2(0.55f,0.6f), glm::u8vec4(255, 255, 255, 50)});
}
cylinderGeometry.uploadVertices<Model::GeometryVertex>(cylverts);
cylinderBuffer.addGeometry(&cylinderGeometry);
cylinderBuffer.setFaceType(GL_TRIANGLES);
}
//----------------------------------------------------------------------------//
void BasicImage::render(GeometryBuffer& buffer, const Rectf& dest_area,
const Rectf* clip_area, const ColourRect& colours) const
{
const QuadSplitMode quad_split_mode(TopLeftToBottomRight);
Rectf dest(dest_area);
// apply rendering offset to the destination Rect
dest.offset(d_scaledOffset);
// get the rect area that we will actually draw to (i.e. perform clipping)
Rectf final_rect(clip_area ? dest.getIntersection(*clip_area) : dest );
// check if rect was totally clipped
if ((final_rect.getWidth() == 0) || (final_rect.getHeight() == 0))
return;
// Obtain correct scale values from the texture
const Vector2f& scale = d_texture->getTexelScaling();
const Vector2f tex_per_pix(d_area.getWidth() / dest.getWidth(), d_area.getHeight() / dest.getHeight());
// calculate final, clipped, texture co-ordinates
const Rectf tex_rect((d_area.d_min + ((final_rect.d_min - dest.d_min) * tex_per_pix)) * scale,
(d_area.d_max + ((final_rect.d_max - dest.d_max) * tex_per_pix)) * scale);
// URGENT FIXME: Shouldn't this be in the hands of the user?
final_rect.d_min.d_x = CoordConverter::alignToPixels(final_rect.d_min.d_x);
final_rect.d_min.d_y = CoordConverter::alignToPixels(final_rect.d_min.d_y);
final_rect.d_max.d_x = CoordConverter::alignToPixels(final_rect.d_max.d_x);
final_rect.d_max.d_y = CoordConverter::alignToPixels(final_rect.d_max.d_y);
Vertex vbuffer[6];
// vertex 0
vbuffer[0].position = Vector3f(final_rect.left(), final_rect.top(), 0.0f);
vbuffer[0].colour_val = colours.d_top_left;
vbuffer[0].tex_coords = Vector2f(tex_rect.left(), tex_rect.top());
// vertex 1
vbuffer[1].position = Vector3f(final_rect.left(), final_rect.bottom(), 0.0f);
vbuffer[1].colour_val = colours.d_bottom_left;
vbuffer[1].tex_coords = Vector2f(tex_rect.left(), tex_rect.bottom());
// vertex 2
vbuffer[2].position.d_x = final_rect.right();
vbuffer[2].position.d_z = 0.0f;
vbuffer[2].colour_val = colours.d_bottom_right;
vbuffer[2].tex_coords.d_x = tex_rect.right();
// top-left to bottom-right diagonal
if (quad_split_mode == TopLeftToBottomRight)
{
vbuffer[2].position.d_y = final_rect.bottom();
vbuffer[2].tex_coords.d_y = tex_rect.bottom();
}
// bottom-left to top-right diagonal
else
{
vbuffer[2].position.d_y = final_rect.top();
vbuffer[2].tex_coords.d_y = tex_rect.top();
}
// vertex 3
vbuffer[3].position = Vector3f(final_rect.right(), final_rect.top(), 0.0f);
vbuffer[3].colour_val = colours.d_top_right;
vbuffer[3].tex_coords = Vector2f(tex_rect.right(), tex_rect.top());
// vertex 4
vbuffer[4].position.d_x = final_rect.left();
vbuffer[4].position.d_z = 0.0f;
vbuffer[4].colour_val = colours.d_top_left;
vbuffer[4].tex_coords.d_x = tex_rect.left();
// top-left to bottom-right diagonal
if (quad_split_mode == TopLeftToBottomRight)
{
vbuffer[4].position.d_y = final_rect.top();
vbuffer[4].tex_coords.d_y = tex_rect.top();
}
// bottom-left to top-right diagonal
else
{
vbuffer[4].position.d_y = final_rect.bottom();
vbuffer[4].tex_coords.d_y = tex_rect.bottom();
}
// vertex 5
vbuffer[5].position = Vector3f(final_rect.right(), final_rect.bottom(), 0.0f);
vbuffer[5].colour_val= colours.d_bottom_right;
vbuffer[5].tex_coords = Vector2f(tex_rect.right(), tex_rect.bottom());
buffer.setActiveTexture(d_texture);
buffer.appendGeometry(vbuffer, 6);
}
void FlowVRCegRenderTarget::draw(const GeometryBuffer& buffer)
{
buffer.draw();
}
