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()); }