//-----------------------------------------------------------------------------------
void Skeleton::Render() const
{
if (!m_joints)
{
MeshBuilder builder;
for (const Matrix4x4& modelSpaceMatrix : m_boneToModelSpace)
{
builder.AddIcoSphere(1.0f, RGBA::BLUE, 0, modelSpaceMatrix.GetTranslation());
}
m_joints = new MeshRenderer(new Mesh(), new Material(new ShaderProgram("Data/Shaders/fixedVertexFormat.vert", "Data/Shaders/fixedVertexFormat.frag"),
RenderState(RenderState::DepthTestingMode::OFF, RenderState::FaceCullingMode::RENDER_BACK_FACES, RenderState::BlendMode::ALPHA_BLEND)));
m_joints->m_material->SetDiffuseTexture(Renderer::instance->m_defaultTexture);
builder.CopyToMesh(m_joints->m_mesh, &Vertex_PCUTB::Copy, sizeof(Vertex_PCUTB), &Vertex_PCUTB::BindMeshToVAO);
}
if (!m_bones)
{
MeshBuilder builder;
for (unsigned int i = 0; i < m_parentIndices.size(); i++)
{
int parentIndex = m_parentIndices[i];
if (parentIndex >= 0)
{
builder.AddLine(m_boneToModelSpace[i].GetTranslation(), m_boneToModelSpace[parentIndex].GetTranslation(), RGBA::SEA_GREEN);
}
}
m_bones = new MeshRenderer(new Mesh(), new Material(new ShaderProgram("Data/Shaders/fixedVertexFormat.vert", "Data/Shaders/fixedVertexFormat.frag"),
RenderState(RenderState::DepthTestingMode::OFF, RenderState::FaceCullingMode::RENDER_BACK_FACES, RenderState::BlendMode::ALPHA_BLEND)));
m_bones->m_material->SetDiffuseTexture(Renderer::instance->m_defaultTexture);
builder.CopyToMesh(m_bones->m_mesh, &Vertex_PCUTB::Copy, sizeof(Vertex_PCUTB), &Vertex_PCUTB::BindMeshToVAO);
}
m_joints->Render();
m_bones->Render();
}
//-----------------------------------------------------------------------------------
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;
}
TheGame::TheGame()
: m_pauseTexture(Texture::CreateOrGetTexture("Data/Images/Test.png"))
, m_camera(new Camera3D())
, m_twahSFX(AudioSystem::instance->CreateOrGetSound("Data/SFX/Twah.wav"))
, m_renderAxisLines(false)
, m_showSkeleton(false)
{
SetUpShader();
#pragma TODO("Fix this blatant memory leak")
Texture* blankTex = new Texture(1600, 900, Texture::TextureFormat::RGBA8);
Texture* depthTex = new Texture(1600, 900, Texture::TextureFormat::D24S8);
m_fbo = Framebuffer::FramebufferCreate(1, &blankTex, depthTex);
Material* fboMaterial = new Material(new ShaderProgram("Data/Shaders/Post/post.vert", "Data/Shaders/Post/post.frag"), //post_pixelation
RenderState(RenderState::DepthTestingMode::ON, RenderState::FaceCullingMode::RENDER_BACK_FACES, RenderState::BlendMode::ALPHA_BLEND));
fboMaterial->SetDiffuseTexture(blankTex);
fboMaterial->SetNormalTexture(depthTex);
MeshBuilder builder;
builder.AddQuad(Vector3(-1, -1, 0), Vector3::UP, 2.0f, Vector3::RIGHT, 2.0f);
quadForFBO = new MeshRenderer(new Mesh(), fboMaterial);
builder.CopyToMesh(quadForFBO->m_mesh, &Vertex_PCUTB::Copy, sizeof(Vertex_PCUTB), &Vertex_PCUTB::BindMeshToVAO);
quadForFBO->m_material->SetFloatUniform("gPixelationFactor", 8.0f);
}
//-----------------------------------------------------------------------------------
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 TheGame::RenderMainMenu()
{
if (m_mainMenuText == nullptr)
{
MeshBuilder builder;
BitmapFont* bmFont = BitmapFont::CreateOrGetFontFromGlyphSheet("Runescape");
builder.AddText2D(Vector2(450, 600), "Picougelike", 7.0f, RGBA::VAPORWAVE, true, bmFont);
builder.AddText2D(Vector2(450, 300), "New Game (N)", 5.0f, RGBA::CYAN, true, bmFont);
builder.AddText2D(Vector2(450, 150), "Quit (Q)", 5.0f, RGBA::CYAN, true, bmFont);
m_mainMenuText = new MeshRenderer(new Mesh(), bmFont->GetMaterial());
builder.CopyToMesh(m_mainMenuText->m_mesh, &Vertex_TextPCT::Copy, sizeof(Vertex_TextPCT), &Vertex_TextPCT::BindMeshToVAO);
}
m_mainMenuText->Render();
}
//-----------------------------------------------------------------------------------
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;
}
//-----------------------------------------------------------------------------------
void TheGame::Update(float deltaTime)
{
DebugRenderer::instance->Update(deltaTime);
if (InputSystem::instance->WasKeyJustPressed(InputSystem::ExtraKeys::TILDE))
{
Console::instance->ActivateConsole();
}
if (Console::instance->IsActive())
{
return; //Don't do anything involving input updates.
}
UpdateCamera(deltaTime);
for (int i = 0; i < 16; i++)
{
m_lightPositions[i] = Vector3(sinf(static_cast<float>(GetCurrentTimeSeconds() + i)) * 5.0f, cosf(static_cast<float>(GetCurrentTimeSeconds() + i) / 2.0f) * 3.0f, 0.5f);
m_lights[i].SetPosition(m_lightPositions[i]);
m_currentMaterial->m_shaderProgram->SetVec3Uniform(Stringf("gLightPosition[%i]", i).c_str(), m_lightPositions[i], 16);
}
if (InputSystem::instance->WasKeyJustPressed('O'))
{
m_renderAxisLines = !m_renderAxisLines;
}
if (InputSystem::instance->WasKeyJustPressed('1'))
{
MeshBuilder builder;
MeshBuilder::PlaneData* data = new MeshBuilder::PlaneData(Vector3::ZERO, Vector3::RIGHT, Vector3::UP);
builder.BuildPatch(-5.0f, 5.0f, 50, -5.0f, 5.0f, 50,
[](const void* userData, float x, float y)
{
MeshBuilder::PlaneData const *plane = (MeshBuilder::PlaneData const*)userData;
Vector3 position = plane->initialPosition
+ (plane->right * x)
+ (plane->up * y);
return position;
}
, data);
builder.CopyToMesh(loadedMesh->m_mesh, &Vertex_SkinnedPCTN::Copy, sizeof(Vertex_SkinnedPCTN), &Vertex_SkinnedPCTN::BindMeshToVAO);
spinFactor = 0.0f;
}
if (InputSystem::instance->WasKeyJustPressed('2'))
{
MeshBuilder builder;
MeshBuilder::PlaneData* data = new MeshBuilder::PlaneData(Vector3::ZERO, Vector3::RIGHT, Vector3::UP);
builder.BuildPatch(-5.0f, 5.0f, 50, -5.0f, 5.0f, 50,
[](const void* userData, float x, float y)
{
MeshBuilder::PlaneData const *plane = (MeshBuilder::PlaneData const*)userData;
Vector3 position = plane->initialPosition
+ (plane->right * x)
+ (plane->up * y);
position.z = sin(x + y);
return position;
}
, data);
builder.CopyToMesh(loadedMesh->m_mesh, &Vertex_SkinnedPCTN::Copy, sizeof(Vertex_SkinnedPCTN), &Vertex_SkinnedPCTN::BindMeshToVAO);
spinFactor = 0.0f;
}
if (InputSystem::instance->WasKeyJustPressed('3'))
{
MeshBuilder builder;
MeshBuilder::PlaneData* data = new MeshBuilder::PlaneData(Vector3::ZERO, Vector3::RIGHT, Vector3::UP);
builder.BuildPatch(-5.0f, 5.0f, 50, -5.0f, 5.0f, 50,
[](const void* userData, float x, float y)
{
MeshBuilder::PlaneData const *plane = (MeshBuilder::PlaneData const*)userData;
Vector3 position = plane->initialPosition
+ (plane->right * x)
+ (plane->up * y);
position.z = .05f * -cos(((float)GetCurrentTimeSeconds() * 4.0f) + (Vector2(x, y).CalculateMagnitude() * 100.0f));
return position;
}
, data);
builder.CopyToMesh(loadedMesh->m_mesh, &Vertex_SkinnedPCTN::Copy, sizeof(Vertex_SkinnedPCTN), &Vertex_SkinnedPCTN::BindMeshToVAO);
spinFactor = 0.0f;
}
if (InputSystem::instance->WasKeyJustPressed('4'))
{
FbxListScene("Data/FBX/SampleBox.fbx");
}
if (InputSystem::instance->WasKeyJustPressed('5'))
{
Console::instance->RunCommand("fbxLoad Data/FBX/unitychan.fbx");
}
if (InputSystem::instance->WasKeyJustPressed('6'))
{
Console::instance->RunCommand("fbxLoad Data/FBX/samplebox.fbx");
}
if (InputSystem::instance->WasKeyJustPressed('7'))
{
Console::instance->RunCommand("saveMesh saveFile.picomesh");
}
if (InputSystem::instance->WasKeyJustPressed('8'))
{
Console::instance->RunCommand("loadMesh saveFile.picomesh");
}
if (g_loadedMesh != nullptr)
{
loadedMesh->m_mesh = g_loadedMesh;
}
if (InputSystem::instance->WasKeyJustPressed('B'))
{
m_currentMaterial = m_testMaterial;
}
else if (InputSystem::instance->WasKeyJustPressed('N'))
{
m_currentMaterial = m_normalDebugMaterial;
}
else if (InputSystem::instance->WasKeyJustPressed('U'))
{
m_currentMaterial = m_uvDebugMaterial;
}
if(InputSystem::instance->WasKeyJustPressed('K'))
{
m_showSkeleton = !m_showSkeleton;
}
if (InputSystem::instance->WasKeyJustPressed('I') && g_loadedMotion != nullptr)
{
g_loadedMotion->m_playbackMode = AnimationMotion::CLAMP;
}
else if (InputSystem::instance->WasKeyJustPressed('L') && g_loadedMotion != nullptr)
{
g_loadedMotion->m_playbackMode = AnimationMotion::LOOP;
}
else if (InputSystem::instance->WasKeyJustPressed('P') && g_loadedMotion != nullptr)
{
g_loadedMotion->m_playbackMode = AnimationMotion::PING_PONG;
}
else if (InputSystem::instance->WasKeyJustPressed('O') && g_loadedMotion != nullptr)
{
g_loadedMotion->m_playbackMode = AnimationMotion::PAUSED;
}
quadForFBO->m_material->SetFloatUniform("gTime", (float)GetCurrentTimeSeconds());
}
//-----------------------------------------------------------------------------------
void TheGame::SetUpShader()
{
m_testMaterial = new Material(
new ShaderProgram("Data/Shaders/SkinDebug.vert", "Data/Shaders/SkinDebug.frag"), //fixedVertexFormat timeBased basicLight multiLight
RenderState(RenderState::DepthTestingMode::ON, RenderState::FaceCullingMode::CULL_BACK_FACES, RenderState::BlendMode::ALPHA_BLEND)
);
m_uvDebugMaterial = new Material(
new ShaderProgram("Data/Shaders/basicLight.vert", "Data/Shaders/uvDebug.frag"),
RenderState(RenderState::DepthTestingMode::ON, RenderState::FaceCullingMode::CULL_BACK_FACES, RenderState::BlendMode::ALPHA_BLEND)
);
m_normalDebugMaterial = new Material(
new ShaderProgram("Data/Shaders/basicLight.vert", "Data/Shaders/normalDebug.frag"),
RenderState(RenderState::DepthTestingMode::ON, RenderState::FaceCullingMode::CULL_BACK_FACES, RenderState::BlendMode::ALPHA_BLEND)
);
m_testMaterial->SetDiffuseTexture("Data/Images/stone_diffuse.png");
m_testMaterial->SetNormalTexture("Data/Images/stone_normal.png");
m_testMaterial->SetEmissiveTexture("Data/Images/pattern_81/maymay.tga");
m_testMaterial->SetNoiseTexture("Data/Images/perlinNoise.png");
m_testMaterial->SetVec4Uniform("gDissolveColor", Vector4(0.0f, 1.0f, 0.3f, 1.0f));
m_testMaterial->SetVec4Uniform("gColor", Vector4(1.0f, 1.0f, 1.0f, 1.0f));
m_testMaterial->SetVec4Uniform("gAmbientLight", Vector4(1.0f, 1.0f, 1.0f, 0.0f));
m_testMaterial->SetFloatUniform("gSpecularPower", 16.0f);
m_testMaterial->SetFloatUniform("gSpecularIntensity", 0.5f); //0 to 1
m_testMaterial->SetVec4Uniform("gFogColor", Vector4(0.7f, 0.7f, 0.7f, 1.0f));
m_testMaterial->SetFloatUniform("gMinFogDistance", 10.0f);
m_testMaterial->SetFloatUniform("gMaxFogDistance", 20.0f);
m_testMaterial->SetIntUniform("gLightCount", NUM_LIGHTS);
lightMaterial = new Material(
new ShaderProgram("Data/Shaders/fixedVertexFormat.vert", "Data/Shaders/fixedVertexFormat.frag"), //fixedVertexFormat timeBased basicLight
RenderState(RenderState::DepthTestingMode::ON, RenderState::FaceCullingMode::CULL_BACK_FACES, RenderState::BlendMode::ALPHA_BLEND)
);
lightMaterial->SetDiffuseTexture(Renderer::instance->m_defaultTexture);
//Set all attributes of the arrays to default values
for (int i = 0; i < 16; i++)
{
m_lightPositions[i] = Vector3::ZERO;
m_lightDirections[i] = Vector3::FORWARD;
m_lightDirectionFactor[i] = 0.0f;
m_nearPower[i] = 1.0f;
m_farPower[i] = 1.0f;
m_nearDistance[i] = 2.0f;
m_farDistance[i] = 6.0f;
m_innerPower[i] = 1.0f;
m_outerPower[i] = 1.0f;
m_innerAngle[i] = 1.0f;
m_outerAngle[i] = -1.0f;
m_lightColors[i] = RGBA::BLACK.ToVec4(); //i % 2 == 0 ? RGBA::RED.ToVec4() : RGBA::BLUE.ToVec4();//
}
//Initialize the lights for the demo
// m_lights[0] = Light(Vector3::ZERO, RGBA(RGBA::RED), lightMaterial);
// m_lights[0].ConvertToLocalPointLight(2.0f, 6.0f, 1.0f, 0.0f);
// m_lights[1] = Light(Vector3::ZERO, RGBA(RGBA::GREEN), lightMaterial);
// m_lights[1].ConvertToGlobalDirectLight(Vector3::FORWARD, 2.0f, 6.0f);
//Initialize the arrays with our values
for (int i = 0; i < NUM_LIGHTS; i++)
{
m_lightColors[i] = m_lights[i].GetColor();
m_lightDirections[i] = m_lights[i].GetDirection();
m_lightDirectionFactor[i] = m_lights[i].IsDirectional() ? 1.0f : 0.0f;
m_nearPower[i] = m_lights[i].GetNearPower();
m_farPower[i] = m_lights[i].GetFarPower();
m_nearDistance[i] = m_lights[i].GetNearDistance();
m_farDistance[i] = m_lights[i].GetFarDistance();
m_innerPower[i] = m_lights[i].GetInnerPower();
m_outerPower[i] = m_lights[i].GetOuterPower();
m_innerAngle[i] = m_lights[i].GetInnerAngle();
m_outerAngle[i] = m_lights[i].GetOuterAngle();
}
for (int i = 0; i < NUM_LIGHTS; i++)
{
m_testMaterial->SetVec4Uniform(Stringf("gLightColor[%i]", i).c_str(), m_lightColors[i], 16);
m_testMaterial->SetVec3Uniform(Stringf("gLightDirection[%i]", i).c_str(), m_lightDirections[i], 16);
m_testMaterial->SetFloatUniform(Stringf("gLightDirectionFactor[%i]", i).c_str(), m_lightDirectionFactor[i], 16);
m_testMaterial->SetFloatUniform(Stringf("gNearPower[%i]", i).c_str(), m_nearPower[i], 16);
m_testMaterial->SetFloatUniform(Stringf("gFarPower[%i]", i).c_str(), m_farPower[i], 16);
m_testMaterial->SetFloatUniform(Stringf("gNearDistance[%i]", i).c_str(), m_nearDistance[i], 16);
m_testMaterial->SetFloatUniform(Stringf("gFarDistance[%i]", i).c_str(), m_farDistance[i], 16);
m_testMaterial->SetFloatUniform(Stringf("gInnerPower[%i]", i).c_str(), m_innerPower[i], 16);
m_testMaterial->SetFloatUniform(Stringf("gOuterPower[%i]", i).c_str(), m_outerPower[i], 16);
m_testMaterial->SetFloatUniform(Stringf("gInnerAngle[%i]", i).c_str(), m_innerAngle[i], 16);
m_testMaterial->SetFloatUniform(Stringf("gOuterAngle[%i]", i).c_str(), m_outerAngle[i], 16);
}
m_currentMaterial = m_testMaterial;
MeshBuilder builder;
builder.AddCube(2.0f);
//Lol more blatant memory leaks fml
loadedMesh = new MeshRenderer(new Mesh(), m_currentMaterial);
builder.CopyToMesh(loadedMesh->m_mesh, &Vertex_SkinnedPCTN::Copy, sizeof(Vertex_SkinnedPCTN), &Vertex_SkinnedPCTN::BindMeshToVAO);
m_uvDebugMaterial->SetDiffuseTexture(Renderer::instance->m_defaultTexture);
m_uvDebugMaterial->SetNormalTexture(Renderer::instance->m_defaultTexture);
m_uvDebugMaterial->SetEmissiveTexture("Data/Images/pattern_81/maymay.tga");
m_uvDebugMaterial->SetNoiseTexture("Data/Images/perlinNoise.png");
m_uvDebugMaterial->SetVec4Uniform("gDissolveColor", Vector4(0.0f, 1.0f, 0.3f, 1.0f));
m_uvDebugMaterial->SetVec4Uniform("gColor", Vector4(1.0f, 1.0f, 1.0f, 1.0f));
m_uvDebugMaterial->SetVec4Uniform("gAmbientLight", Vector4(1.0f, 1.0f, 1.0f, 0.0f));
m_uvDebugMaterial->SetFloatUniform("gSpecularPower", 16.0f);
m_uvDebugMaterial->SetFloatUniform("gSpecularIntensity", 0.5f); //0 to 1
m_uvDebugMaterial->SetVec4Uniform("gFogColor", Vector4(0.7f, 0.7f, 0.7f, 1.0f));
m_uvDebugMaterial->SetFloatUniform("gMinFogDistance", 10.0f);
m_uvDebugMaterial->SetFloatUniform("gMaxFogDistance", 20.0f);
m_uvDebugMaterial->SetIntUniform("gLightCount", NUM_LIGHTS);
for (int i = 0; i < NUM_LIGHTS; i++)
{
m_uvDebugMaterial->SetVec4Uniform(Stringf("gLightColor[%i]", i).c_str(), m_lightColors[i], 16);
m_uvDebugMaterial->SetVec3Uniform(Stringf("gLightDirection[%i]", i).c_str(), m_lightDirections[i], 16);
m_uvDebugMaterial->SetFloatUniform(Stringf("gLightDirectionFactor[%i]", i).c_str(), m_lightDirectionFactor[i], 16);
m_uvDebugMaterial->SetFloatUniform(Stringf("gNearPower[%i]", i).c_str(), m_nearPower[i], 16);
m_uvDebugMaterial->SetFloatUniform(Stringf("gFarPower[%i]", i).c_str(), m_farPower[i], 16);
m_uvDebugMaterial->SetFloatUniform(Stringf("gNearDistance[%i]", i).c_str(), m_nearDistance[i], 16);
m_uvDebugMaterial->SetFloatUniform(Stringf("gFarDistance[%i]", i).c_str(), m_farDistance[i], 16);
m_uvDebugMaterial->SetFloatUniform(Stringf("gInnerPower[%i]", i).c_str(), m_innerPower[i], 16);
m_uvDebugMaterial->SetFloatUniform(Stringf("gOuterPower[%i]", i).c_str(), m_outerPower[i], 16);
m_uvDebugMaterial->SetFloatUniform(Stringf("gInnerAngle[%i]", i).c_str(), m_innerAngle[i], 16);
m_uvDebugMaterial->SetFloatUniform(Stringf("gOuterAngle[%i]", i).c_str(), m_outerAngle[i], 16);
}
m_normalDebugMaterial->SetDiffuseTexture("Data/Images/stone_diffuse.png");
m_normalDebugMaterial->SetNormalTexture("Data/Images/stone_normal.png");
m_normalDebugMaterial->SetEmissiveTexture("Data/Images/pattern_81/maymay.tga");
m_normalDebugMaterial->SetNoiseTexture("Data/Images/perlinNoise.png");
m_normalDebugMaterial->SetVec4Uniform("gDissolveColor", Vector4(0.0f, 1.0f, 0.3f, 1.0f));
m_normalDebugMaterial->SetVec4Uniform("gColor", Vector4(1.0f, 1.0f, 1.0f, 1.0f));
m_normalDebugMaterial->SetVec4Uniform("gAmbientLight", Vector4(1.0f, 1.0f, 1.0f, 0.0f));
m_normalDebugMaterial->SetFloatUniform("gSpecularPower", 16.0f);
m_normalDebugMaterial->SetFloatUniform("gSpecularIntensity", 0.5f); //0 to 1
m_normalDebugMaterial->SetVec4Uniform("gFogColor", Vector4(0.7f, 0.7f, 0.7f, 1.0f));
m_normalDebugMaterial->SetFloatUniform("gMinFogDistance", 10.0f);
m_normalDebugMaterial->SetFloatUniform("gMaxFogDistance", 20.0f);
m_normalDebugMaterial->SetIntUniform("gLightCount", NUM_LIGHTS);
for (int i = 0; i < NUM_LIGHTS; i++)
{
m_normalDebugMaterial->SetVec4Uniform(Stringf("gLightColor[%i]", i).c_str(), m_lightColors[i], 16);
m_normalDebugMaterial->SetVec3Uniform(Stringf("gLightDirection[%i]", i).c_str(), m_lightDirections[i], 16);
m_normalDebugMaterial->SetFloatUniform(Stringf("gLightDirectionFactor[%i]", i).c_str(), m_lightDirectionFactor[i], 16);
m_normalDebugMaterial->SetFloatUniform(Stringf("gNearPower[%i]", i).c_str(), m_nearPower[i], 16);
m_normalDebugMaterial->SetFloatUniform(Stringf("gFarPower[%i]", i).c_str(), m_farPower[i], 16);
m_normalDebugMaterial->SetFloatUniform(Stringf("gNearDistance[%i]", i).c_str(), m_nearDistance[i], 16);
m_normalDebugMaterial->SetFloatUniform(Stringf("gFarDistance[%i]", i).c_str(), m_farDistance[i], 16);
m_normalDebugMaterial->SetFloatUniform(Stringf("gInnerPower[%i]", i).c_str(), m_innerPower[i], 16);
m_normalDebugMaterial->SetFloatUniform(Stringf("gOuterPower[%i]", i).c_str(), m_outerPower[i], 16);
m_normalDebugMaterial->SetFloatUniform(Stringf("gInnerAngle[%i]", i).c_str(), m_innerAngle[i], 16);
m_normalDebugMaterial->SetFloatUniform(Stringf("gOuterAngle[%i]", i).c_str(), m_outerAngle[i], 16);
}
int NUM_BONES = 200;
Matrix4x4 mat = Matrix4x4::IDENTITY;
for (int i = 0; i < NUM_BONES; ++i)
{
m_testMaterial->SetMatrix4x4Uniform(Stringf("gBoneMatrices[%i]", i).c_str(), mat, NUM_BONES);
}
}
