Do alot of stuff

project/src/Scenes/BaseScene.cpp

@@ -0,0 +1,5 @@
+//
+// Created by Bram on 25/12/2024.
+//
+
+#include "BaseScene.h"

project/src/Scenes/BaseScene.h

@@ -0,0 +1,32 @@
+#ifndef GP1_DIRECTX_BASESCENE_H
+#define GP1_DIRECTX_BASESCENE_H
+
+
+#include <d3d11.h>
+#include <memory>
+#include <vector>
+
+#include "../Mesh.h"
+#include "../Material.h"
+
+
+class BaseScene {
+public:
+    BaseScene() = default;
+
+    virtual ~BaseScene() = default;
+
+    virtual void Initialize(ID3D11Device *DevicePtr) = 0;
+
+//    virtual void Update() = 0;
+
+//    virtual void Render() = 0;
+
+    virtual void Cleanup() = 0;
+
+    virtual std::vector<Mesh*>& GetMeshes() = 0;
+    virtual std::vector<std::shared_ptr<Material>>& GetMaterials() = 0;
+};
+
+
+#endif //GP1_DIRECTX_BASESCENE_H

project/src/Scenes/DioramaScene.cpp

@@ -0,0 +1,80 @@
+//
+// Created by Bram on 25/12/2024.
+//
+
+#include "DioramaScene.h"
+#include "../Utils.h"
+#include "../Effects/Effect.h"
+#include "../Effects/FireEffect.h"
+
+#include <iostream>
+
+
+
+void DioramaScene::Initialize(ID3D11Device *DevicePtr) {
+
+        std::vector<std::unique_ptr<Utils::MaterialMesh>> materialMeshes;
+        Utils::LoadObjWithMaterials("resources/scene.obj", materialMeshes, true, DevicePtr);
+        for (const auto &mesh: materialMeshes) {
+            if(mesh->vertices.size() > 0) {
+                std::shared_ptr<Material> material = std::make_shared<Material>();
+                BaseEffect *effect{ nullptr };
+
+                if(mesh->opacity_map != ""){
+//                    std::cout << "Opacity map found" << mesh->opacity_map << std::endl;
+                    effect = new FireEffect(DevicePtr, L"resources/Fire.fx");
+                    material->diffuseTexturePtr = Texture::LoadFromFile("./resources/diorama/" + mesh->diffuse_texture, DevicePtr);
+//                    material-> = Texture::LoadFromFile("./resources/" + mesh->opacity_map, DevicePtr);
+                } else {
+                    material->diffuseTexturePtr = Texture::LoadFromFile("./resources/diorama/" + mesh->diffuse_texture, DevicePtr);
+                    effect = new Effect(DevicePtr, L"resources/SimpleDiffuse.fx");
+                }
+
+
+                m_meshes.push_back(new Mesh(DevicePtr, mesh->vertices, mesh->indices, material, effect));
+
+                Matrix worldMatrix = m_meshes.back()->GetWorldMatrix();
+                worldMatrix *= Matrix::CreateScale(2.f, 2.f, 2.f);
+                worldMatrix *= Matrix::CreateScale(-1.f, 1.f, 1.f);
+                m_meshes.back()->SetWorldMatrix(worldMatrix);
+            }
+        }
+
+    materialMeshes.clear();
+    Utils::LoadObjWithMaterials("resources/brok/brok.obj", materialMeshes, true, DevicePtr);
+    for (const auto &mesh: materialMeshes) {
+        if(mesh->vertices.size() > 0) {
+            std::shared_ptr<Material> material = std::make_shared<Material>();
+            BaseEffect *effect{ nullptr };
+
+            effect = new Effect(DevicePtr, L"resources/SimpleDiffuse.fx");
+            material->diffuseTexturePtr = Texture::LoadFromFile("./resources/brok/" + mesh->diffuse_texture, DevicePtr);
+
+
+            m_meshes.push_back(new Mesh(DevicePtr, mesh->vertices, mesh->indices, material, effect));
+
+            Matrix worldMatrix = m_meshes.back()->GetWorldMatrix();
+            worldMatrix *= Matrix::CreateRotationY(3.14f / 2.f);
+            worldMatrix *= Matrix::CreateScale(0.021f, 0.021f, 0.021f);
+            worldMatrix *= Matrix::CreateScale(-1.f, 1.f, 1.f);
+            worldMatrix *= Matrix::CreateTranslation(-8.55f, 12.33f, 0.69f);
+            m_meshes.back()->SetWorldMatrix(worldMatrix);
+        }
+    }
+}
+
+std::vector<Mesh *> &DioramaScene::GetMeshes() {
+    return m_meshes;
+}
+
+std::vector<std::shared_ptr<Material>> &DioramaScene::GetMaterials() {
+    return m_materials;
+}
+
+void DioramaScene::Cleanup() {
+    for (Mesh *mesh : m_meshes) {
+        delete mesh;
+    }
+    m_meshes.clear();
+    m_materials.clear();
+}

project/src/Scenes/DioramaScene.h

@@ -0,0 +1,21 @@
+#ifndef GP1_DIRECTX_DIORAMASCENE_H
+#define GP1_DIRECTX_DIORAMASCENE_H
+
+#include "BaseScene.h"
+
+class DioramaScene : public BaseScene {
+public:
+    void Cleanup() override;
+
+    void Initialize(ID3D11Device *DevicePtr) override;
+
+    std::vector<Mesh *> &GetMeshes() override;
+
+    std::vector<std::shared_ptr<Material>> &GetMaterials() override;
+private:
+    std::vector<Mesh *> m_meshes{};
+    std::vector<std::shared_ptr<Material>> m_materials{};
+
+};
+
+#endif //GP1_DIRECTX_DIORAMASCENE_H

project/src/Scenes/MainScene.cpp

@@ -0,0 +1,71 @@
+//
+// Created by Bram on 25/12/2024.
+//
+
+#include "MainScene.h"
+#include "../pch.h"
+#include "../Utils.h"
+#include "../Effects/Effect.h"
+#include "../Effects/FireEffect.h"
+
+#include <cassert>
+
+
+void MainScene::Initialize(ID3D11Device *DevicePtr) {
+
+    std::vector<VertexIn> vertices{};
+    std::vector<uint32_t> indices{};
+
+    if (!Utils::ParseOBJNew("resources/vehicle.obj", vertices, indices, false)) {
+        assert(true && "Model failed to load");
+    }
+
+    std::shared_ptr<Material> vehicleMaterial = std::make_shared<Material>();
+    vehicleMaterial->diffuseTexturePtr = Texture::LoadFromFile("resources/vehicle_diffuse.png", DevicePtr);
+    vehicleMaterial->normalTexturePtr = Texture::LoadFromFile("resources/vehicle_normal.png", DevicePtr);
+    vehicleMaterial->specularTexturePtr = Texture::LoadFromFile("resources/vehicle_specular.png", DevicePtr);
+    vehicleMaterial->glossTexturePtr = Texture::LoadFromFile("resources/vehicle_gloss.png", DevicePtr);
+
+    auto* effect = new Effect(DevicePtr, L"resources/PosCol3D.fx");
+    m_meshes.push_back(new Mesh(DevicePtr, vertices, indices, vehicleMaterial, effect));
+
+
+    Matrix worldMatrix = m_meshes.back()->GetWorldMatrix();
+    worldMatrix *= Matrix::CreateTranslation(0, 0, 50.f);
+    m_meshes.back()->SetWorldMatrix(worldMatrix);
+
+
+
+    indices.clear();
+    vertices.clear();
+    if(!Utils::ParseOBJNew("resources/fireFX.obj", vertices, indices, false)){
+        assert(true && "Model failed to load");
+    }
+
+    std::shared_ptr<Material> FireMaterial = std::make_shared<Material>();
+    FireMaterial->diffuseTexturePtr = Texture::LoadFromFile("resources/fireFX_diffuse.png", DevicePtr);
+
+    auto* fireEffect = new FireEffect(DevicePtr, L"resources/Fire.fx");
+    m_meshes.push_back(new Mesh(DevicePtr, vertices, indices, FireMaterial, fireEffect));
+
+    worldMatrix = m_meshes.back()->GetWorldMatrix();
+    worldMatrix *= Matrix::CreateTranslation(0, 0, 50.f);
+    m_meshes.back()->SetWorldMatrix(worldMatrix);
+}
+
+
+void MainScene::Cleanup() {
+    for (Mesh* mesh : m_meshes) {
+        delete mesh;
+    }
+    m_meshes.clear();
+}
+
+std::vector<Mesh *> &MainScene::GetMeshes() {
+    return m_meshes;
+}
+
+std::vector<std::shared_ptr<Material>> &MainScene::GetMaterials() {
+    return m_materials;
+}
+

project/src/Scenes/MainScene.h

@@ -0,0 +1,32 @@
+#ifndef GP1_DIRECTX_MAINSCENE_H
+#define GP1_DIRECTX_MAINSCENE_H
+
+
+#include "BaseScene.h"
+#include "../Mesh.h"
+#include "../Material.h"
+#include "../Camera.h"
+
+#include <memory>
+#include <vector>
+
+class MainScene : public BaseScene {
+public:
+    void Initialize(ID3D11Device* DevicePtr) override;
+
+    void Cleanup() override;
+
+    std::vector<Mesh *> &GetMeshes() override;
+
+    std::vector<std::shared_ptr<Material>> &GetMaterials() override;
+
+
+private:
+
+    std::vector<Mesh*> m_meshes{};
+    std::vector<std::shared_ptr<Material>> m_materials{};
+
+};
+
+
+#endif //GP1_DIRECTX_MAINSCENE_H