//-----------------------------------------------------------------------------------
void Renderer::DrawVertexArray(const Vertex_PCT* vertexes, int numVertexes, DrawMode drawMode /*= DrawMode::QUADS*/)
{
if (numVertexes == 0)
{
return;
}
MeshBuilder builder;
builder.Begin();
for (int i = 0; i < numVertexes; ++i)
{
builder.SetColor(vertexes[i].color);
builder.SetUV(vertexes[i].texCoords);
builder.SetTBN(Vector3::ZERO, Vector3::ZERO, Vector3::ZERO);
builder.AddVertex(vertexes[i].pos);
builder.AddIndex(i);
}
builder.End();
Mesh* mesh = new Mesh();
builder.CopyToMesh(mesh, &Vertex_PCUTB::Copy, sizeof(Vertex_PCUTB), &Vertex_PCUTB::BindMeshToVAO);
mesh->m_drawMode = drawMode;
MeshRenderer* thingToRender = new MeshRenderer(mesh, m_defaultMaterial);
m_defaultMaterial->SetMatrices(Matrix4x4::IDENTITY, m_viewStack.GetTop(), m_projStack.GetTop());
GL_CHECK_ERROR();
thingToRender->Render();
delete mesh;
}
//-----------------------------------------------------------------------------------
void Path::Render() const
{
MeshBuilder builder;
builder.Begin();
const float TILE_SIZE = 25.0f;
for (PathNode* node : m_openList)
{
Vector2 bottomLeft = Vector2(node->position) * TILE_SIZE;
builder.AddTexturedAABB(AABB2(bottomLeft, bottomLeft + (Vector2::ONE * TILE_SIZE)), Vector2::ZERO, Vector2::ONE, RGBA(0x0000FF7F));
Renderer::instance->DrawText2D(bottomLeft, std::to_string(node->f).substr(0, 4), 0.5f, RGBA::WHITE, false, BitmapFont::CreateOrGetFontFromGlyphSheet("Runescape"));
}
for (PathNode* node : m_closedList)
{
Vector2 bottomLeft = Vector2(node->position) * TILE_SIZE;
builder.AddTexturedAABB(AABB2(bottomLeft, bottomLeft + (Vector2::ONE * TILE_SIZE)), Vector2::ZERO, Vector2::ONE, RGBA(0xFF00007F));
Renderer::instance->DrawText2D(bottomLeft, std::to_string(node->f).substr(0, 4), 0.5f, RGBA::WHITE, false, BitmapFont::CreateOrGetFontFromGlyphSheet("Runescape"));
}
for (PathNode* node : m_resultantPath)
{
Vector2 bottomLeft = Vector2(node->position) * TILE_SIZE;
builder.AddTexturedAABB(AABB2(bottomLeft, bottomLeft + (Vector2::ONE * TILE_SIZE)), Vector2::ZERO, Vector2::ONE, RGBA(0x00FF007F));
}
Vector2 bottomLeft = (Vector2(m_currentGoal) * TILE_SIZE);
builder.AddTexturedAABB(AABB2(bottomLeft, bottomLeft + (Vector2::ONE * TILE_SIZE)), Vector2::ZERO, Vector2::ONE, RGBA(0x00FF007F));
builder.End();
Mesh* mesh = new Mesh();
builder.CopyToMesh(mesh, &Vertex_PCUTB::Copy, sizeof(Vertex_PCUTB), &Vertex_PCUTB::BindMeshToVAO);
MeshRenderer* renderer = new MeshRenderer(mesh, Renderer::instance->m_defaultMaterial);
renderer->Render();
delete mesh;
}
//-----------------------------------------------------------------------------------
void Renderer::DrawText2D(const Vector2& position, const std::string& asciiText, float scale, const RGBA& tint /*= RGBA::WHITE*/, bool drawShadow /*= false*/, const BitmapFont* font /*= nullptr*/, const Vector2& right /*= Vector3::UNIT_X*/, const Vector2& up /*= Vector3::UNIT_Z*/)
{
//To be used when I expand this method to 3D text
UNUSED(up);
UNUSED(right);
if (asciiText.empty())
{
return;
}
if (font == nullptr)
{
font = m_defaultFont;
}
int stringLength = asciiText.size();
Vector2 cursorPosition = position + (Vector2::UNIT_Y * (float)font->m_maxHeight * scale);
const Glyph* previousGlyph = nullptr;
MeshBuilder builder;
builder.Begin();
for (int i = 0; i < stringLength; i++)
{
unsigned char currentCharacter = asciiText[i];
const Glyph* glyph = font->GetGlyph(currentCharacter);
float glyphWidth = static_cast<float>(glyph->width) * scale;
float glyphHeight = static_cast<float>(glyph->height) * scale;
if (previousGlyph)
{
const Vector2 kerning = font->GetKerning(*previousGlyph, *glyph);
cursorPosition += (kerning * scale);
}
Vector2 offset = Vector2(glyph->xOffset * scale, -glyph->yOffset * scale);
Vector2 topRight = cursorPosition + offset + Vector2(glyphWidth, 0.0f);
Vector2 bottomLeft = cursorPosition + offset - Vector2(0.0f, glyphHeight);
AABB2 quadBounds = AABB2(bottomLeft, topRight);
AABB2 glyphBounds = font->GetTexCoordsForGlyph(*glyph);
if (drawShadow)
{
float shadowWidthOffset = glyphWidth / 10.0f;
float shadowHeightOffset = glyphHeight / -10.0f;
Vector2 shadowOffset = Vector2(shadowWidthOffset, shadowHeightOffset);
AABB2 shadowBounds = AABB2(bottomLeft + shadowOffset, topRight + shadowOffset);
builder.AddTexturedAABB(shadowBounds, glyphBounds.mins, glyphBounds.maxs, RGBA::BLACK);
}
builder.AddTexturedAABB(quadBounds, glyphBounds.mins, glyphBounds.maxs, tint);
cursorPosition.x += glyph->xAdvance * scale;
previousGlyph = glyph;
}
builder.End();
Mesh* mesh = new Mesh();
builder.CopyToMesh(mesh, &Vertex_PCUTB::Copy, sizeof(Vertex_PCUTB), &Vertex_PCUTB::BindMeshToVAO);
mesh->m_drawMode = DrawMode::TRIANGLES;
MeshRenderer* thingToRender = new MeshRenderer(mesh, font->GetMaterial());
m_defaultMaterial->SetMatrices(Matrix4x4::IDENTITY, m_viewStack.GetTop(), m_projStack.GetTop());
GL_CHECK_ERROR();
thingToRender->Render();
delete mesh;
delete thingToRender;
}
//-----------------------------------------------------------------------------------
void Renderer::DrawText2D
( const Vector2& startBottomLeft
, const std::string& asciiText
, float cellWidth
, float cellHeight
, const RGBA& tint /*= RGBA::WHITE*/
, bool drawShadow /*= false*/
, const BitmapFont* font /*= nullptr*/)
{
const float SHADOW_WIDTH_OFFSET = cellWidth / 10.0f;
const float SHADOW_HEIGHT_OFFSET = cellHeight / -10.0f;
const Vector2 SHADOW_OFFSET = Vector2(SHADOW_WIDTH_OFFSET, SHADOW_HEIGHT_OFFSET);
if (asciiText.empty())
{
return;
}
MeshBuilder builder;
builder.Begin();
if (font == nullptr)
{
font = m_defaultFont;
}
int stringLength = asciiText.size();
Vector2 currentPosition = startBottomLeft;
for (int i = 0; i < stringLength; i++)
{
unsigned char currentCharacter = asciiText[i];
Vector2 topRight = currentPosition + Vector2(cellWidth, cellHeight);
AABB2 quadBounds = AABB2(currentPosition, topRight);
AABB2 glyphBounds = font->GetTexCoordsForGlyph(currentCharacter);
if (drawShadow)
{
AABB2 shadowBounds = AABB2(currentPosition + SHADOW_OFFSET, topRight + SHADOW_OFFSET);
builder.AddTexturedAABB(shadowBounds, glyphBounds.mins, glyphBounds.maxs, RGBA::BLACK);
}
builder.AddTexturedAABB(quadBounds, glyphBounds.mins, glyphBounds.maxs, tint);
currentPosition.x += cellWidth;
}
builder.End();
Mesh* mesh = new Mesh();
builder.CopyToMesh(mesh, &Vertex_PCUTB::Copy, sizeof(Vertex_PCUTB), &Vertex_PCUTB::BindMeshToVAO);
mesh->m_drawMode = DrawMode::TRIANGLES;
MeshRenderer* thingToRender = new MeshRenderer(mesh, font->GetMaterial());
m_defaultMaterial->SetMatrices(Matrix4x4::IDENTITY, m_viewStack.GetTop(), m_projStack.GetTop());
GL_CHECK_ERROR();
thingToRender->Render();
delete mesh;
delete thingToRender;
}
//-----------------------------------------------------------------------------------
void Renderer::DrawVertexArray(const Vertex_PCT* vertexes, int numVertexes, DrawMode drawMode /*= QUADS*/, Texture* texture /*= nullptr*/)
{
// if (!texture)
// {
// texture = m_defaultTexture;
// }
// BindTexture(*texture);
// glEnableClientState(GL_VERTEX_ARRAY);
// glEnableClientState(GL_COLOR_ARRAY);
// glEnableClientState(GL_TEXTURE_COORD_ARRAY);
//
// glVertexPointer(3, GL_FLOAT, sizeof(Vertex_PCT), &vertexes[0].pos);
// glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Vertex_PCT), &vertexes[0].color);
// glTexCoordPointer(2, GL_FLOAT, sizeof(Vertex_PCT), &vertexes[0].texCoords);
//
// glDrawArrays(GetDrawMode(drawMode), 0, numVertexes);
//
// glDisableClientState(GL_VERTEX_ARRAY);
// glDisableClientState(GL_COLOR_ARRAY);
// glDisableClientState(GL_TEXTURE_COORD_ARRAY);
// UnbindTexture();
if (numVertexes == 0)
{
return;
}
MeshBuilder builder;
builder.Begin();
for (int i = 0; i < numVertexes; ++i)
{
builder.SetColor(vertexes[i].color);
builder.SetUV(vertexes[i].texCoords);
builder.SetTBN(Vector3::ZERO, Vector3::ZERO, Vector3::ZERO);
builder.AddVertex(vertexes[i].pos);
builder.AddIndex(i);
}
builder.End();
Mesh* mesh = new Mesh();
builder.CopyToMesh(mesh, &Vertex_PCUTB::Copy);
mesh->m_drawMode = drawMode;
MeshRenderer thingToRender = MeshRenderer(mesh, m_defaultMaterial);
m_defaultMaterial->SetMatrices(Matrix4x4::IDENTITY, m_viewStack.GetTop(), m_projStack.GetTop());
GL_CHECK_ERROR();
thingToRender.Render();
delete mesh;
}
//-----------------------------------------------------------------------------------
void Renderer::DrawVertexArrayModern(const Vertex_PCT* vertexes, int numVertexes, Renderer::DrawMode drawMode /*= QUADS*/, Texture* texture /*= nullptr*/)
{
MeshBuilder builder;
builder.Begin();
for (int i = 0; i < numVertexes; ++i)
{
builder.SetColor(vertexes[i].color);
builder.SetUV(vertexes[i].texCoords);
builder.SetTBN(Vector3::ZERO, Vector3::ZERO, Vector3::ZERO);
builder.AddVertex(vertexes[i].pos);
builder.AddIndex(i);
}
builder.End();
Mesh* mesh = new Mesh();
builder.CopyToMesh(mesh, &Vertex_PCUTB::Copy);
mesh->m_drawMode = drawMode;
MeshRenderer thingToRender = MeshRenderer(mesh, m_defaultMaterial);
m_defaultMaterial->SetMatrices(Matrix4x4::IDENTITY, m_viewStack.GetTop(), m_projStack.GetTop());
GL_CHECK_ERROR();
thingToRender.Render();
delete mesh;
}
//THIS MUST HAPPEN AFTER IMPORTING SKELETONS.
//-----------------------------------------------------------------------------------
static void ImportMesh(SceneImport* import, FbxMesh* mesh, MatrixStack4x4& matrixStack, std::map<int, FbxNode*>& nodeToJointIndex)
{
MeshBuilder builder = MeshBuilder();
ASSERT_OR_DIE(mesh->IsTriangleMesh(), "Was unable to load the mesh, it's not a triangle mesh!");
Matrix4x4 geoTransform = GetGeometricTransform(mesh);
matrixStack.Push(geoTransform);
int controlPointCount = mesh->GetControlPointsCount();
//Figure out our weighs for all verts before importing any of them
std::vector<SkinWeight> skinWeights;
if (HasSkinWeights(mesh))
{
skinWeights.resize(controlPointCount);
GetSkinWeights(import, skinWeights, mesh, nodeToJointIndex);
}
else
{
FbxNode* node = mesh->GetNode();
//Walk tree up till you reach the node associated with that joint.
//Find the first parent node that has a joint associated with it
//All vertices (fully weighted)
//All Skin Weights = indices{jointINdex, 0, 0, 0 } weights{1.0f, 0.0f, 0.0f, 0.0f};
int jointIndex = Skeleton::INVALID_JOINT_INDEX;
for (auto iter = nodeToJointIndex.begin(); iter != nodeToJointIndex.end(); ++iter)
{
if (iter->second == node)
{
jointIndex = iter->first;
break;
}
}
if (jointIndex == Skeleton::INVALID_JOINT_INDEX)
{
for (unsigned int i = 0; i < skinWeights.size(); ++i)
{
skinWeights[i].indices = Vector4Int::ZERO;
skinWeights[i].weights = Vector4::UNIT_X;
}
}
else
{
for (unsigned int i = 0; i < skinWeights.size(); ++i)
{
skinWeights[i].indices = Vector4Int(jointIndex, 0, 0, 0);
skinWeights[i].weights = Vector4::UNIT_X;
}
}
}
builder.Begin();
{
Matrix4x4 transform = matrixStack.GetTop();
int polyCount = mesh->GetPolygonCount();
for (int polyIndex = 0; polyIndex < polyCount; ++polyIndex)
{
int vertCount = mesh->GetPolygonSize(polyIndex);
ASSERT_OR_DIE(vertCount == 3, "Vertex count was not 3");
for (int vertIndex = 0; vertIndex < vertCount; ++vertIndex)
{
ImportVertex(builder, transform, mesh, polyIndex, vertIndex, skinWeights);
}
}
}
builder.End();
FbxSurfaceMaterial* material = mesh->GetNode()->GetMaterial(0);
builder.SetMaterialName(material->GetName());
matrixStack.Pop();
import->meshes.push_back(builder);
}
