GameEditorWorld.cpp

Go to the documentation of this file.

#include "GameEditorWorld.h"
#include <World/Entity.h>
#include <Resources/Loader/MaterialLoader.h>
#include <GamePlay/MeshController.h>
#include <Resources/ResourcePool/ResourcePool.h>
#include <Systems/ResourceSystem.h>
#include <Extensions/Gltf/GltfCollection.h>
 
namespace Spices {
 
    void GameEditorWorld::OnPreActivate()
    {
        SPICES_PROFILE_ZONE;
 
        ResourceSystem::RegistryResourceFolder(SPICES_GAME_ASSETS_PATH);
 
        EditorWorld::OnPreActivate();
 
        // 3dsmax poly canton
        {
            /*Entity& meshentity = CreateEntity("DefaultMesh");
            MeshComponent& meshComp = meshentity.AddComponent<MeshComponent>();
            TransformComponent& transformComp1 = meshentity.GetComponent<TransformComponent>();
            transformComp1.SetScale({ 25.0f, 25.0f, 25.0f });
            transformComp1.SetPostion({ 0.0f, -5.0f, 0.0f });
 
            std::shared_ptr<FilePack> pack1 = std::make_shared<FilePack>("112");
            pack1->SetMaterial("BasePassRenderer.Mesh.0");
            std::shared_ptr<Mesh> mesh = Mesh::Builder().AddPack(pack1).Build();
            meshComp.SetMesh(mesh);*/
        }
 
        // bridge pbr model
        {
            WorldFunctions::CreateMeshEntity(this, "DefaultMesh", []() {
 
                std::shared_ptr<FilePack> pack1 = std::make_shared<FilePack>("interior_stair_wl3ieamdw_01");
                std::shared_ptr<FilePack> pack2 = std::make_shared<FilePack>("interior_stair_wl3ieamdw_02");
                std::shared_ptr<FilePack> pack3 = std::make_shared<FilePack>("interior_stair_wl3ieamdw_03");
                std::shared_ptr<FilePack> pack4 = std::make_shared<FilePack>("interior_stair_wl3ieamdw_04");
                std::shared_ptr<FilePack> pack5 = std::make_shared<FilePack>("interior_stair_wl3ieamdw_05");
 
                pack1->SetMaterial("BasePassRenderer.Mesh.interior_stair_wl3ieamdw");
                pack2->SetMaterial("BasePassRenderer.Mesh.interior_stair_wl3ieamdw");
                pack3->SetMaterial("BasePassRenderer.Mesh.interior_stair_wl3ieamdw");
                pack4->SetMaterial("BasePassRenderer.Mesh.interior_stair_wl3ieamdw");
                pack5->SetMaterial("BasePassRenderer.Mesh.interior_stair_wl3ieamdw");
 
                return Mesh::Builder().AddPack(pack1).AddPack(pack2).AddPack(pack3).AddPack(pack4).AddPack(pack5).Build();
 
            }, [](Entity& e) {
 
                auto& transform = e.GetComponent<TransformComponent>();
                transform.SetPosition({ 10.0f, 2.0f, 30.0f });
                transform.SetRotation({ -180.0f, 0.0f, -180.0f });
 
            });
        }
 
        // CornellBox
        {
            for(int i = 0; i < 3; i++)
            {
                std::stringstream ss;
                ss << "CornellBox_" << i;
 
                WorldFunctions::CreateMeshEntity(this, ss.str(), [=]() {
 
                    std::shared_ptr<FilePack> pack = std::make_shared<FilePack>("Test_room");
 
                    std::stringstream mss;
                    mss << "BasePassRenderer.Mesh.CornellBox" << i;
                    pack->SetMaterial(mss.str());
                    return Mesh::Builder().AddPack(pack).Build();
 
                }, [=](Entity& e) {
 
                    auto& transform = e.GetComponent<TransformComponent>();
                    transform.SetPosition({ -7.0f, 5.0f, 5.0f + i * 10.0f });
                    transform.SetRotation({ 0.0f, -90.0f, 0.0f });
 
                });
            }
        }
 
        // sphere
        {
            for(int i = 0; i < 4; i++)  // range in albedo
            {
                for(int j = 0; j < 10; j++)  // range in roughness
                {
                    std::stringstream ss;
                    ss << "Sphere_" << 10 * i + j;
 
                    WorldFunctions::CreateMeshEntity(this, ss.str(), [=]() {
 
                        std::shared_ptr<SpherePack> pack = std::make_shared<SpherePack>(100, 100);
 
                        std::stringstream mss;
                        mss << "BasePassRenderer.Mesh." << 10 * i + j;
 
                        pack->SetMaterial(mss.str());
                        return Mesh::Builder().AddPack(pack).Build();
 
                    }, [=](Entity& e) {
 
                        auto& transform = e.GetComponent<TransformComponent>();
                        transform.SetPosition({ 3.0f * i, 0.0f, 3.0f * j });
 
                    });
                }
            }
        }
 
        // testsphere
        /*{
            for (int i = 0; i < 1; i++)  // range in albedo
            {
                for (int j = 0; j < 100; j++)  // range in roughness
                {
                    for (int k = 0; k < 100; k++)
                    {
                        std::stringstream ss;
                        ss << "TestSphere_" << 10000 * i + 100 * j + k;
 
                        WorldFunctions::CreateMeshEntity(this, ss.str(), []() {
 
                            std::shared_ptr<PlanePack> pack = std::make_shared<PlanePack>(2, 2, false);
                            
                            std::stringstream mss;
                            mss << "BasePassRenderer.Mesh.0";
                            
                            pack->SetMaterial(mss.str());
                            return Mesh::Builder().AddPack(pack).Build();
                            
                        }, [i, j, k](Entity& e) {
 
                            auto& transform = e.GetComponent<TransformComponent>();
                            transform.SetPosition({ 3.0f * i, 3.0f * k, 3.0f * j });
 
                        });
                    }
                }
            }
        }*/
 
        // ground
        WorldFunctions::CreateMeshEntity(this, "Ground", []() {
 
            std::shared_ptr<PlanePack> pack = std::make_shared<PlanePack>(1000, 1000);
 
            pack->SetMaterial("BasePassRenderer.Mesh.ground");
            return Mesh::Builder().AddPack(pack).Build();
 
        }, [](Entity& e) {
 
            auto& transform = e.GetComponent<TransformComponent>();
            transform.SetPosition({ 0.0f, -1.1f, 15.0f });
            transform.SetRotation({ 90.0f, 0.0f, 0.0f });
            transform.SetScale({ 500.0f, 500.0f, 500.0f });
 
        });
 
        // pointlight
        {
            Entity plightentity = CreateEntity("PointLight");
            PointLightComponent& plightComp = plightentity.AddComponent<PointLightComponent>();
            plightComp.SetColor(glm::vec3(1.0f, 1.0f, 0.0f));
            plightComp.SetIntensity(20.0f);
            SpriteComponent& sprite = plightentity.AddComponent<SpriteComponent>();
            sprite.SetMaterial("SpriteRenderer.Sprite.S_LightPoint");
            TransformComponent& transformComp = plightentity.GetComponent<TransformComponent>();
            transformComp.SetPosition({ -7.0f, 7.0f, 5.0f });
        }
        {
            Entity plightentity = CreateEntity("PointLight");
            PointLightComponent& plightComp = plightentity.AddComponent<PointLightComponent>();
            plightComp.SetColor(glm::vec3(1.0f, 0.0f, 1.0f));
            plightComp.SetIntensity(20.0f);
            SpriteComponent& sprite = plightentity.AddComponent<SpriteComponent>();
            sprite.SetMaterial("SpriteRenderer.Sprite.S_LightPoint");
            TransformComponent& transformComp = plightentity.GetComponent<TransformComponent>();
            transformComp.SetPosition({ -7.0f, 5.0f, 15.0f });
        }
        {
            Entity plightentity = CreateEntity("PointLight");
            PointLightComponent& plightComp = plightentity.AddComponent<PointLightComponent>();
            plightComp.SetColor(glm::vec3(1.0f, 1.0f, 1.0f));
            plightComp.SetIntensity(20.0f);
            SpriteComponent& sprite = plightentity.AddComponent<SpriteComponent>();
            sprite.SetMaterial("SpriteRenderer.Sprite.S_LightPoint");
            TransformComponent& transformComp = plightentity.GetComponent<TransformComponent>();
            transformComp.SetPosition({ -7.0f, 5.0f, 25.0f });
        }
 
        /*{
            GltfCollection collection("E:/OpenGLProjects/ExtensionAssets/BoomBox/glTF/BoomBox.gltf");
            collection.CreateEntity(this, "BoomBox");
        }*/
    }
 
    void GameEditorWorld::OnActivate(TimeStep& ts)
    {
        SPICES_PROFILE_ZONE;
 
        EditorWorld::OnActivate(ts);
    }
 
    void GameEditorWorld::OnDeactivate()
    {
        SPICES_PROFILE_ZONE;
 
        EditorWorld::OnDeactivate();
    }
 
}