bool MeshBuilder::operator==( const MeshBuilder& other ) const
{
if ( vertices() != other.vertices() )
return false;
if ( polygons() != other.polygons() )
return false;
if ( vertexMaps() != other.vertexMaps() )
return false;
if ( discontinuousVertexMaps() != other.discontinuousVertexMaps() )
return false;
for ( int i = 0 ; i < m_this->vertices.size() ; ++i )
if ( *m_this->vertices[i] != *other.m_this->vertices[i] )
return false;
for ( int i = 0 ; i < m_this->polygons.size() ; ++i )
if ( *m_this->polygons[i] != *other.m_this->polygons[i] )
return false;
for ( int i = 0 ; i < m_this->vertexMaps.size() ; ++i )
if ( *m_this->vertexMaps[i] != *other.m_this->vertexMaps[i] )
return false;
for ( int i = 0 ; i < m_this->discontinuousVertexMaps.size() ; ++i )
if ( *m_this->discontinuousVertexMaps[i] != *other.m_this->discontinuousVertexMaps[i] )
return false;
return true;
}
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);
}
// Method to forge our junks
Scene* SceneBuilder::forge()
{
Scene* scene = new Scene();
// Grabbing all world settings
json11::Json* wsJson = new json11::Json((*this->json)["worldSettings"]);
json11::Json::object worldSettingsJson = wsJson->object_items();
WorldSettingsBuilder* wsBuilder = new WorldSettingsBuilder(wsJson);
scene->setWorldSettings(wsBuilder->forgeWorldSettings());
json11::Json* mJson = new json11::Json((*this->json)["meshes"]);
MeshBuilder* meshBuilder = new MeshBuilder();
meshBuilder->setJson(mJson);
scene->setMeshes(meshBuilder->forgeMeshes());
json11::Json* pJson = new json11::Json((*this->json)["camera"]);
PovBuilder* povBuilder = new PovBuilder();
povBuilder->setJson(pJson);
scene->setPov(povBuilder->forge());
// WorldSettingsBuilder deallocates the json so we will set it to null
wsJson = NULL;
return scene;
};
void generateMesh(Terrain* const t,const QString& obj,int echantillion){
MeshBuilder bu;
QString nom="terrain";
Mesh m =bu.terrain(*t,echantillion,nom);
bu.saveMesh(obj,m);
}
//-----------------------------------------------------------------------------------
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;
}
Mesh RezDeChaussee::generate() const
{
QVector<PolyangleHauteur> polyangles;
polyangles << PolyangleHauteur(base, hauteur)
<< PolyangleHauteur(base, hauteur + hauteurRDC);
MeshBuilder mb;
Mesh rdcMesh = mb.generationPolyanglesRelies(polyangles);
Etage etage = Etage(base, hauteur + hauteurRDC, hauteurRDC);
rdcMesh.merge(etage.generate());
return rdcMesh;
}
//-----------------------------------------------------------------------------------
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 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();
}
Mesh PetitEtageResidentiel::generate() const
{
MeshBuilder mb;
Mesh etageMesh = mb.generationEtage(this);
QVector<std::pair<Batiment*,int>> bats;
ToitResidentiel tr(base,hauteur+hauteurEtage,hauteurEtage,hMax-1,shrinkMax,aireMin);
EtageResidentiel er(base,hauteur+hauteurEtage,hauteurEtage,hMax-1,shrinkMax,aireMin);
bats << std::make_pair(&tr,5);
if(hMax>1){
bats << std::make_pair(&er,50);
}
etageMesh.merge(Batiment::getRandomBatiment(bats)->generate());
return etageMesh;
}
//-----------------------------------------------------------------------------------
static void ImportVertex(MeshBuilder& builder, const Matrix4x4& transform, FbxMesh* mesh, int polyIndex, int vertIndex, std::vector<SkinWeight>& skinWeights)
{
Vector3 normal;
if (GetNormal(normal, transform, mesh, polyIndex, vertIndex))
{
builder.SetNormal(normal);
//Temporary hack to get around not supporting multiple vertex definitions
Vector3 bitangent = Vector3::UP;
if (normal == bitangent)
{
bitangent = Vector3::FORWARD;
}
Vector3 tangent = Vector3::Cross(bitangent, normal);
bitangent = Vector3::Cross(normal, tangent);
builder.SetTangent(tangent);
builder.SetBitangent(bitangent);
}
RGBA color;
if (GetColor(color, mesh, polyIndex, vertIndex))
{
builder.SetColor(color);
}
Vector2 uv;
if (GetUV(uv, mesh, polyIndex, vertIndex, 0))
{
builder.SetUV(uv);
}
//Set Skin Weights
int controlIndex = mesh->GetPolygonVertex(polyIndex, vertIndex);
if (controlIndex < skinWeights.size())
{
builder.SetBoneWeights(skinWeights[controlIndex].indices, skinWeights[controlIndex].weights);
builder.RenormalizeSkinWeights(); //Just to be safe.
}
else
{
builder.ClearBoneWeights();
}
Vector3 position;
if (GetPosition(&position, transform, mesh, polyIndex, vertIndex))
{
builder.AddVertex(position);
}
}
// Builds one square
void buildSquare(Object &object, const GLfloat side, MeshBuilder & builder) {
builder.addVertex(-side, -side, 0); // bottom left
builder.addVertex(side, -side, 0); // bottom right
builder.addVertex(-side, side, 0); // top left
builder.addVertex(side, side, 0); // top right
builder.addFace(0, 2, 3); // First triangle : top left
builder.addFace(0, 1, 3); // Second triangle : bottom right
vector<unsigned int> indices;
vector<Vector3f> vertices;
vector<Vector3f> normals;
vector<UV> uvs;
builder.unpack(indices, vertices, normals, uvs);
// Sends the data into buffers on the GPU
object.sendPrimitives(vertices, indices);
}
bool TangentSpaceBuilder::compute(MeshBuilder& builder, int indexIdx, int posIdx, int normalIdx, int uvIdx, int tangentIdx)
{
const IndexArray idxPtr = builder.getAttributeAs<uint16_t>(indexIdx);
const Vec3fArray posPtr = builder.getAttributeAs<Vec3f>(posIdx);
const Vec3fArray nrmPtr = builder.getAttributeAs<Vec3f>(normalIdx);
const Vec2fArray uvPtr = builder.getAttributeAs<Vec2f>(uvIdx);
Vec3fArray tangentPtr = builder.getAttributeAs<Vec3f>(tangentIdx);
if(!idxPtr.data || !posPtr.data || !nrmPtr.data || !uvPtr.data || !tangentPtr.data)
return false;
if(idxPtr.size != builder.indexCount())
return false;
if(posPtr.size != builder.vertexCount())
return false;
compute(idxPtr, posPtr, nrmPtr, uvPtr, tangentPtr);
return true;
}
//-----------------------------------------------------------------------------------
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 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::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;
}
DebugDraw::DebugDraw(
Renderer* renderer,
GameWorld* world,
Component::Camera* camera,
std::shared_ptr<Material> material,
UINT maxLines) :
mRenderer(renderer),
mWorld(world),
mCamera(camera),
mMaterial(material),
mMaxLines(maxLines)
{
_ASSERT(renderer);
_ASSERT(camera);
_ASSERT(material.get());
_ASSERT(maxLines > 0);
auto shader = material->mShader.lock();
MeshBuilder builder;
builder.mLayout = shader->Layout();
for (UINT x = 0; x < maxLines; ++x)
{
UINT index = x << 1;
builder.mVertex.push_back(MeshBuilder::Vertex(Vector3(0.0f, 0.0f, 0.0f)));
builder.mVertex.push_back(MeshBuilder::Vertex(Vector3(0.0f, 0.0f, 0.0f)));
}
builder.mPrimitive = PrimitiveFormat::LINES;
mMesh = builder.BuildMesh(mRenderer, false);
if (!mMesh)
throw AppException("Failed to create Mesh in Debug");
}
Mesh PetitEtageBusiness::generate() const
{
MeshBuilder mb;
Mesh pebMesh = mb.generationEtage(this);
QVector<std::pair<Batiment*,int>> bats;
ToitBusiness tb(base, hauteur+hauteurEtage, hauteurEtage, hMax, shrinkMax, aireMin);
EtageBusiness eb(base, hauteur+hauteurEtage, hauteurEtage, hMax-1, shrinkMax, aireMin);
Division d(base, hauteur+hauteurEtage, hauteurEtage, hMax-1, shrinkMax-1, aireMin);
bats.append(std::make_pair(&tb, 2));
if(hMax > 1)
{
bats.append(std::make_pair(&eb, 70));
if(shrinkMax > 0 && d.getPoly1().area()>aireMin && d.getPoly2().area() > aireMin)
{
bats.append(std::make_pair(&d, 10));
}
}
pebMesh.merge(getRandomBatiment(bats)->generate());
return pebMesh;
}
//-----------------------------------------------------------------------------------
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 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 applyBoundaryConditions(const double& value,
const Epetra_Vector& x, Epetra_CrsMatrix& Jac,
Epetra_Vector& f, const MeshBuilder mb)
{
// This function assumes a serial run. It will not check process rank.
// Assumes two equations.
// Left edge includes global nodes 0 and 1, dofs 0,1,2,3
int num_nonzero_entries_in_row = 0;
int* row_indices;
double* row_values;
int num_eq = 2;
const std::vector<int>& left_nodes = mb.leftNodeSetGlobalIds();
for (std::size_t node = 0; node < left_nodes.size(); ++node) {
for (int eq = 0; eq < num_eq; ++eq) {
int lid = Jac.RowMap().LID(left_nodes[node] * num_eq + eq);
Jac.ExtractMyRowView(lid, num_nonzero_entries_in_row, row_values,
row_indices);
for (int col=0; col < num_nonzero_entries_in_row; ++col) {
if (row_indices[col] == lid)
row_values[col] = 1.0;
else
row_values[col] = 0.0;
}
f[lid] = value - x[lid];
}
}
}
static int test()
{
MeshBuilder mesh;
Vertex* v[4];
int i;
for ( i = 0 ; i < 4 ; ++i ) // 0 1
v[i] = mesh.addVertex(); // 3 2
Polygon* a = mesh.addPolygon();
a->addVertex( v[0] );
a->addVertex( v[1] );
a->addVertex( v[2] );
Polygon* b = mesh.addPolygon();
b->addVertex( v[0] );
b->addVertex( v[2] );
b->addVertex( v[3] );
VertexMap* vmap = mesh.addVertexMap( 2, "TXUV", VertexMapFormat::VERTEXMAP_TEXCOORD );
float uv[4][2] = { {0, 0}, {1,0}, {1,1}, {0,1} };
vmap->addValue( v[2]->index(), uv[2], 2 );
vmap->addValue( v[1]->index(), uv[1], 2 );
vmap->addValue( v[3]->index(), uv[3], 2 );
vmap->addValue( v[0]->index(), uv[0], 2 );
v[1] = a->getVertex(1)->clone();
a->setVertex( 1, v[1] );
assert( mesh.vertices() == 5 );
float uv1[4][2];
memset( uv1, 0, sizeof(uv1) );
for ( i = 0 ; i < 4 ; ++i )
{
vmap->getValue( v[i]->index(), uv1[i], 2 );
assert( !memcmp(uv[i],uv1[i],sizeof(uv[i])) );
}
assert( vmap->dimensions() == 2 );
assert( vmap->name() == "TXUV" );
return 0;
}
MeshBuilder* MeshBuilder__New_1(::uStatic* __this)
{
MeshBuilder* inst = (::app::Fuse::Drawing::Tesselation::MeshBuilder*)::uAllocObject(sizeof(::app::Fuse::Drawing::Tesselation::MeshBuilder), ::app::Fuse::Drawing::Tesselation::MeshBuilder__typeof());
inst->_ObjInit();
return inst;
}
//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);
}
static int fillModelMesh( MeshBuilder& builder , mstudiotexture_t& texDesc , short* tri , Vector3 vtxPos[] , uint8* vtxBone )
{
int numTri = 0;
float fs = 1.0f / texDesc.width;
float ft = 1.0f / texDesc.height;
int base = 0;
if ( vtxBone )
{
while (1)
{
short nEle = *(tri++);
if ( nEle == 0)
break;
if ( nEle < 0 )
{
//triangle fan
nEle = -nEle;
builder.setPosition( vtxPos[ tri[0] ] );
builder.setBlendIndices( vtxBone[ tri[0] ] + 1 );
builder.setTexCoord( 0 , fs * tri[2] , ft * tri[3] );
builder.addVertex();
int start = base++;
tri += 4;
builder.setPosition( vtxPos[ tri[0] ] );
builder.setBlendIndices( vtxBone[ tri[0] ] + 1 );
builder.setTexCoord( 0 , fs * tri[2] , ft * tri[3] );
builder.addVertex();
int prev = base++;
tri += 4;
for( int n = 2 ; n < nEle ; ++n )
{
builder.setPosition( vtxPos[ tri[0] ] );
builder.setBlendIndices( vtxBone[ tri[0] ] + 1 );
builder.setTexCoord( 0 , fs * tri[2] , ft * tri[3] );
builder.addVertex();
int cur = base++;
builder.addTriangle( start , cur , prev );
++numTri;
prev = cur;
tri += 4;
}
}
else
{
//triangle strip
builder.setPosition( vtxPos[ tri[0] ] );
builder.setBlendIndices( vtxBone[ tri[0] ] + 1 );
builder.setTexCoord( 0 , fs * tri[2] , ft * tri[3] );
builder.addVertex();
int prev2 = base++;
tri += 4;
builder.setPosition( vtxPos[ tri[0] ] );
builder.setBlendIndices( vtxBone[ tri[0] ] + 1 );
builder.setTexCoord( 0 , fs * tri[2] , ft * tri[3] );
builder.addVertex();
int prev = base++;
tri += 4;
for( int n = 2 ; n < nEle ; ++n )
{
builder.setPosition( vtxPos[ tri[0] ] );
builder.setBlendIndices( vtxBone[ tri[0] ] + 1 );
builder.setTexCoord( 0 , fs * tri[2] , ft * tri[3] );
builder.addVertex();
int cur = base++;
if ( n % 2 == 0 )
builder.addTriangle( prev2 , cur , prev );
else
builder.addTriangle( prev2 , prev , cur );
++numTri;
prev2 = prev;
prev = cur;
tri += 4;
}
}
}
}
else //vtxBone
{
while (1)
{
short nEle = *(tri++);
if ( nEle == 0)
break;
if ( nEle < 0 )
{
//triangle fan
nEle = -nEle;
builder.setPosition( vtxPos[ tri[0] ] );
builder.setTexCoord( 0 , fs * tri[2] , ft * tri[3] );
builder.addVertex();
int start = base++;
tri += 4;
builder.setPosition( vtxPos[ tri[0] ] );
builder.setTexCoord( 0 , fs * tri[2] , ft * tri[3] );
builder.addVertex();
int prev = base++;
tri += 4;
for( int n = 2 ; n < nEle ; ++n )
{
builder.setPosition( vtxPos[ tri[0] ] );
builder.setTexCoord( 0 , fs * tri[2] , ft * tri[3] );
builder.addVertex();
int cur = base++;
builder.addTriangle( start , cur , prev );
++numTri;
prev = cur;
tri += 4;
}
}
else
{
//triangle strip
builder.setPosition( vtxPos[ tri[0] ] );
builder.setTexCoord( 0 , fs * tri[2] , ft * tri[3] );
builder.addVertex();
int prev2 = base++;
tri += 4;
builder.setPosition( vtxPos[ tri[0] ] );
builder.setTexCoord( 0 , fs * tri[2] , ft * tri[3] );
builder.addVertex();
int prev = base++;
tri += 4;
for( int n = 2 ; n < nEle ; ++n )
{
builder.setPosition( vtxPos[ tri[0] ] );
builder.setTexCoord( 0 , fs * tri[2] , ft * tri[3] );
builder.addVertex();
int cur = base++;
if ( n % 2 == 0 )
builder.addTriangle( prev2 , cur , prev );
else
builder.addTriangle( prev2 , prev , cur );
++numTri;
prev2 = prev;
prev = cur;
tri += 4;
}
}
}
}
return numTri;
}
int Object::createPlane( Material* mat , float w , float h , float* color , float xTile , float yTile ,
Vector3 const& normal , Vector3 const& alignDir , Vector3 const& offset , bool invYDir )
{
Vector3 yLen = normal.cross( alignDir );
assert( yLen.length2() > 1e-4 );
yLen.normalize();
Vector3 xLen = yLen.cross( normal );
xLen *= 0.5f * w;
yLen *= 0.5f * h;
if ( invYDir )
yLen = -yLen;
Vector3 n = normal;
n.normalize();
int texLen = 2;
VertexType type = ( color ) ? CFVT_XYZ_N_CF1 : CFVT_XYZ_N;
//VertexType type = ( color ) ? CFVT_XYZ_CF1 : CFVT_XYZ;
MeshBuilder builder = MeshBuilder( type | CFVF_TEX1( 2 ) );
if ( color )
builder.setColor( color );
builder.setNormal( n );
builder.reserveVexterBuffer( 4 );
builder.reserveIndexBuffer( 12 );
builder.setPosition( offset - xLen - yLen );
builder.setTexCoord( 0 , 0 , 0 );
builder.addVertex();
builder.setPosition( offset + xLen - yLen );
builder.setTexCoord( 0 ,xTile, 0 );
builder.addVertex();
builder.setPosition( offset + xLen + yLen );
builder.setTexCoord( 0 , xTile , yTile );
builder.addVertex();
builder.setPosition( offset - xLen + yLen );
builder.setTexCoord( 0 , 0 , yTile );
builder.addVertex();
builder.addQuad( 0 , 1 , 2 , 3 );
return builder.createIndexTrangle( this , mat );
}
SurfaceMesh::SurfaceMesh (const CSG::Surface& surface)
: _surface (surface)
{
MeshBuilder b;
int cnt = 0;
surface.traverse([&] (const CSG::Pixel& pix, bool filled)
{
float s2 = pix.size / 2;
Math::Vector2 pts[8];
float densities[4];
int tbl_index = 0;
pts[0] = pix.center;
pts[0].x += s2;
pts[0].y += s2;
if (_surface.test_point (pts[0]))
tbl_index |= 1;
densities[0] = _surface.density (pts[0]);
pts[1] = pix.center;
pts[1].x += s2;
pts[1].y -= s2;
if (_surface.test_point (pts[1]))
tbl_index |= 2;
densities[1] = _surface.density (pts[1]);
pts[2] = pix.center;
pts[2].x -= s2;
pts[2].y -= s2;
if (_surface.test_point (pts[2]))
tbl_index |= 4;
densities[2] = _surface.density (pts[2]);
pts[3] = pix.center;
pts[3].x -= s2;
pts[3].y += s2;
if (_surface.test_point (pts[3]))
tbl_index |= 8;
densities[3] = _surface.density (pts[3]);
if (MSEdgeTable[tbl_index] & 1) {
pts[4] = Math::Vector2 (
Math::f_interpolate (0, densities[0], pts[0].x,
densities[1], pts[1].x),
Math::f_interpolate (0, densities[0], pts[0].y,
densities[1], pts[1].y));
}
if (MSEdgeTable[tbl_index] & 2) {
pts[5] = Math::Vector2 (
Math::f_interpolate (0, densities[1], pts[1].x,
densities[2], pts[2].x),
Math::f_interpolate (0, densities[1], pts[1].y,
densities[2], pts[2].y));
}
if (MSEdgeTable[tbl_index] & 4) {
pts[6] = Math::Vector2 (
Math::f_interpolate (0, densities[2], pts[2].x,
densities[3], pts[3].x),
Math::f_interpolate (0, densities[2], pts[2].y,
densities[3], pts[3].y));
}
if (MSEdgeTable[tbl_index] & 8) {
pts[7] = Math::Vector2 (
Math::f_interpolate (0, densities[3], pts[3].x,
densities[0], pts[0].x),
Math::f_interpolate (0, densities[3], pts[3].y,
densities[0], pts[0].y));
}
for (int i = 0; MSTriangleTable[tbl_index][i] != -1; i += 3) {
b.add_triangle (Math::Vector3 (
pts[MSTriangleTable[tbl_index][i]].x,
pts[MSTriangleTable[tbl_index][i]].y,
0),
Math::Vector3 (
pts[MSTriangleTable[tbl_index][i + 1]].x,
pts[MSTriangleTable[tbl_index][i + 1]].y,
0),
Math::Vector3 (
pts[MSTriangleTable[tbl_index][i + 2]].x,
pts[MSTriangleTable[tbl_index][i + 2]].y,
0));
}
return true;
}, .1);
MeshBuilder::Buffs buffs = b.finalize ();
_v.alloc (std::get<0> (buffs).first, std::get<0> (buffs).second);
_w.alloc (std::get<1> (buffs).first, std::get<1> (buffs).second);
_f.alloc (std::get<2> (buffs).first, std::get<2> (buffs).second);
const CSG::BRect& br = _surface.bounds ();
MeshBuilder bb;
bb.add_line (Math::Vector3 (br.lb.x, br.lb.y, 0),
Math::Vector3 (br.lb.x, br.ub.y, 0));
bb.add_line (Math::Vector3 (br.lb.x, br.ub.y, 0),
Math::Vector3 (br.ub.x, br.ub.y, 0));
bb.add_line (Math::Vector3 (br.ub.x, br.ub.y, 0),
Math::Vector3 (br.ub.x, br.lb.y, 0));
bb.add_line (Math::Vector3 (br.ub.x, br.lb.y, 0),
Math::Vector3 (br.lb.x, br.lb.y, 0));
MeshBuilder::Buffs bb_buffs = bb.finalize ();
_bbv.alloc (std::get<0> (bb_buffs).first, std::get<0> (bb_buffs).second);
_bbe.alloc (std::get<1> (bb_buffs).first, std::get<1> (bb_buffs).second);
}
//--------------------------------------------------------------------
Ptr<TransformNode> Nebula3Writer::writeSkinGeometryData( const NodeData& instanceNodeData,const SkinData& skinData,GeometryData& geometryData )
{
Ptr<TransformNode> transformNode = TransformNode::Create();
MeshBuilder meshBuilder;
Util::String meshFilename ="msh:" + geometryData.mGeometryName;meshFilename.Append(".nvx2");
for (int groupIndex=0;groupIndex<geometryData.mMeshDatas.Size();groupIndex++)
{
/// 设置基本信息
GeometryData::MeshData& meshData = geometryData.mMeshDatas[groupIndex];
Ptr<CharacterSkinNode> shapeNode = CharacterSkinNode::Create();
Util::String shapeName(geometryData.mGeometryName);
shapeName.Append("_s_");
shapeName.AppendInt(groupIndex);
shapeNode->SetName(shapeName);
shapeNode->SetPrimitiveGroupIndex(groupIndex);
shapeNode->SetMeshResourceId(meshFilename);
this->writeMaterialData(instanceNodeData,geometryData,groupIndex,shapeNode.upcast<ModelNode>());
for (int j=0;j< meshData.positionIndices.Size();j+=3 )
{
MeshBuilderVertex vertex01,vertex02,vertex03;
vertex01.SetComponent(MeshBuilderVertex::CoordIndex,geometryData.mPositions[meshData.positionIndices[j]]);
vertex02.SetComponent(MeshBuilderVertex::CoordIndex,geometryData.mPositions[meshData.positionIndices[j+1]]);
vertex03.SetComponent(MeshBuilderVertex::CoordIndex,geometryData.mPositions[meshData.positionIndices[j+2]]);
if( !meshData.normalIndices.IsEmpty())
{
vertex01.SetComponent(MeshBuilderVertex::NormalIndex,geometryData.mNormals[meshData.normalIndices[j]]);
vertex02.SetComponent(MeshBuilderVertex::NormalIndex,geometryData.mNormals[meshData.normalIndices[j+1]]);
vertex03.SetComponent(MeshBuilderVertex::NormalIndex,geometryData.mNormals[meshData.normalIndices[j+2]]);
}
if( !meshData.mDiffMapUVs.IsEmpty())
{
vertex01.SetComponent(MeshBuilderVertex::Uv0Index,meshData.mDiffMapUVs[meshData.mDiffMapIndices[j]]);
vertex02.SetComponent(MeshBuilderVertex::Uv0Index,meshData.mDiffMapUVs[meshData.mDiffMapIndices[j+1]]);
vertex03.SetComponent(MeshBuilderVertex::Uv0Index,meshData.mDiffMapUVs[meshData.mDiffMapIndices[j+2]]);
}
if( !geometryData.mJointIndices.IsEmpty())
{
vertex01.SetComponent(MeshBuilderVertex::JIndicesIndex,geometryData.mJointIndices[meshData.positionIndices[j]]);
vertex01.SetComponent(MeshBuilderVertex::WeightsIndex,geometryData.mWeights[meshData.positionIndices[j]]);
vertex02.SetComponent(MeshBuilderVertex::JIndicesIndex,geometryData.mJointIndices[meshData.positionIndices[j+1]]);
vertex02.SetComponent(MeshBuilderVertex::WeightsIndex,geometryData.mWeights[meshData.positionIndices[j+1]]);
vertex03.SetComponent(MeshBuilderVertex::JIndicesIndex,geometryData.mJointIndices[meshData.positionIndices[j+2]]);
vertex03.SetComponent(MeshBuilderVertex::WeightsIndex,geometryData.mWeights[meshData.positionIndices[j+2]]);
}
meshBuilder.AddVertex(vertex01);
size_t indices01 = meshBuilder.GetNumVertices() -1;
meshBuilder.AddVertex(vertex02);
size_t indices02 = meshBuilder.GetNumVertices() -1;
meshBuilder.AddVertex(vertex03);
size_t indices03 = meshBuilder.GetNumVertices() -1;
MeshBuilderTriangle triangle;
triangle.SetGroupId(groupIndex);
triangle.SetVertexIndices(indices01,indices02,indices03);
meshBuilder.AddTriangle(triangle);
}///end for
transformNode->AddChild(shapeNode.upcast<ModelNode>());
}///end for
/// 保存模型文件
if( !MeshBuilderSaver::SaveNvx2(meshFilename,meshBuilder,Platform::Win32) )
{
n_error("Save [%s] Failed!\n",meshFilename);
}///end if
Math::bbox boundingbox = meshBuilder.ComputeBoundingBox();
transformNode->SetName(geometryData.mGeometryName);
transformNode->SetBoundingBox(boundingbox);
Util::Array<Ptr<ModelNode>> shapeNodes = transformNode->GetChildren();
for (int i=0;i<shapeNodes.Size();i++)
{
shapeNodes[i]->SetBoundingBox(boundingbox);
}///end for
/// 设置位置信息
//Math::vector outTranslate;Math::quaternion outRotate;Math::vector outScale;
//Math::matrix44 matTemp = this->getGeometryMatrix(instanceNodeData.nodeUniqueId);
//matTemp.decompose(outScale,outRotate,outTranslate);
//transformNode->SetPosition(outTranslate);
//transformNode->SetRotation(outRotate);
//transformNode->SetScale(outScale);
return transformNode;
}
int main(int argc, char *argv[])
{
/*int arg=1;
QTime time;
float values[9] = {1.0f,2.0f,3.0f,4.0f,5.0f,6.0f,7.0f,8.0f,9.0f};
Matrix3 mat(values);
cout << mat << endl;
cout << mat.transpose() << endl;*/
/* time.restart();
QString img=argv[arg++];
Terrain* t=generationImage(img);
std::cout << "Terrain from image generated : " << time.restart() << "ms." << std::endl;//*/
/* time.restart();
Terrain* t=generationProcedural();
std::cout << "Terrain generated : " << time.restart() << "ms." << std::endl;
//*/
/*time.restart();
QString obj=argv[arg++];
generateMesh(t,obj,300);
std::cout << "Mesh generated : " << time.restart() << "ms." << std::endl;//*/
/*time.restart();
QString destination=argv[arg++];
shoot(t,destination);
std::cout << "Image generated from ray launching : " << time.restart() << "ms." << std::endl;//*/
/* time.restart();
QString destination=argv[arg++];
shootMulti(t,destination,100);
std::cout << "100 images generated from ray launching : " << time.restart() << "ms." << std::endl;//*/
//delete t;
/*Vector3D centre(1.0f,0.0f,0.0f);
Vector3D centre2(.5f,.5f,0.0f);
Vector3D origine(-3.0f,0.0f,0.0f);
Vector3D direction(1.0f,0.0f,0.0f);
Vector3D soleil(-10000.0f,0.0f,0.0f);
CSGSphere sphere(centre, 1.0f);
CSGSphere sphere2(centre2, 0.75f);
CSGDifference uni(&sphere,&sphere2);
Camera cam(origine, direction,1.0);
QImage result = cam.printScreen(uni, soleil, 900, 900);
QString nameImage = "C:/Users/etu/Desktop/sphereTest.png";
result.save(nameImage);
MeshBuilder mb;
TableauVoxel tab(500,500,500,10.0/500,Vector3D(-5,-5,-5),uni);
//TableauVoxel tab(3,3,3,10,Vector3D(0,0,0));
//tab(1,1,1)=1;
QString name2 = "C:/Users/etu/Desktop/voxel.obj";
Mesh m=mb.voxel(tab,name2);
mb.saveMesh(name2,m);*/
QList<Vector3D> points = Vector3D::randHemisphere(1000);
QList<Vector3D> points2 = Vector3D::rotateScaleTranslate(points, Vector3D(0,0,0), 1, Vector3D(0,0.5,0.5).normalized());
QList<int> topo;
QList<Vector3D> normales;
Mesh m1(points, topo, normales, "ololo");
Mesh m2(points2, topo, normales, "ololo2");
MeshBuilder m;
m.saveMesh("m1.obj", m1);
m.saveMesh("m3.obj", m2);
return 0;
}
//-----------------------------------------------------------------------------------
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);
}
}
//-----------------------------------------------------------------------------------
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());
}
