atdunbg/Prism
1
1
Fork 0
Code Issues Pull Requests Actions Projects Releases Wiki Activity

add Console panel; fix the problem when cs set Rotation the direction not update; fix some little bug; add simple texture material Edit system;some treaks

Browse Source
This commit is contained in:
Atdunbg
2026-03-27 18:02:57 +08:00
parent ef4ea45edc
commit 4266a0b570
56 changed files with 1927 additions and 614 deletions
Download Patch File Download Diff File Expand all files Collapse all files

166
Editor/Editor/EditorLayer.cpp
View File

@ -19,6 +19,7 @@
#include "Prism/Physics/Physics3D.h"
#include "Prism/Renderer/Renderer2D.h"
#include "Prism/Script/ScriptEngine.h"
#include "Prism/Script/ScriptWrappers.h"
namespace Prism
{
@ -56,6 +57,12 @@ namespace Prism
AssetEditorPanel::RegisterDefaultEditors();
FileSystem::StartWatching();
m_ConsolePanel = CreateScope<ConsolePanel>();
Script::SetLogCallback([this](const std::string& message)
{
if (m_ConsolePanel)
m_ConsolePanel->AddMessage(message, ImVec4(1,1,1,1));
});
}
void EditorLayer::OnDetach()
@ -147,6 +154,18 @@ namespace Prism
}
}
if (m_SceneState == SceneState::Play)
{
if (Input::GetCursorMode() != CursorMode::Normal)
{
if (Input::IsKeyPressed(KeyCode::LEFT_CONTROL) && Input::IsKeyPressed(KeyCode::LEFT_ALT) && Input::IsKeyPressed(KeyCode::GRAVE_ACCENT))
{
Input::SetCursorMode(CursorMode::Normal);
}
}
}
}
void EditorLayer::OnImGuiRender()
@ -278,8 +297,9 @@ namespace Prism
Entity selectedEntity = m_SelectionContext.front().Entity;
if (selectedEntity.HasComponent<MeshComponent>())
{
Ref<Mesh> mesh = selectedEntity.GetComponent<MeshComponent>().Mesh;
if (mesh)
auto& meshComponent = selectedEntity.GetComponent<MeshComponent>();
if (Ref<Mesh> mesh = meshComponent.Mesh)
{
auto& materials = mesh->GetMaterials();
static uint32_t selectedMaterialIndex = 0;
@ -307,27 +327,13 @@ namespace Prism
}
ImGui::EndChild();
}
/*
for (uint32_t i = 0; i < materials.size(); i++)
{
const auto& materialInstance = materials[i];
ImGuiTreeNodeFlags node_flags = (selectedMaterialIndex == i ? ImGuiTreeNodeFlags_Selected : 0) | ImGuiTreeNodeFlags_Leaf;
bool opened = ImGui::TreeNodeEx((void*)(&materialInstance), node_flags, "%s", materialInstance->GetName().c_str());
if (ImGui::IsItemClicked())
{
selectedMaterialIndex = i;
}
if (opened)
ImGui::TreePop();
}
*/
ImGui::Separator();
if (selectedMaterialIndex < materials.size())
{
bool shouldUpdate = false;
auto& materialInstance = materials[selectedMaterialIndex];
ImGui::Text("Shader: %s", materialInstance->GetShader()->GetName().c_str());
// Textures ------------------------------------------------------------------------------
@ -342,6 +348,21 @@ namespace Prism
Ref<Texture2D> albedoMap = materialInstance->TryGetResource<Texture2D>("u_AlbedoTexture");
ImGui::Image(albedoMap ? (ImTextureRef)albedoMap->GetRendererID() : (ImTextureRef)m_CheckerboardTex->GetRendererID(), ImVec2(64, 64));
if (ImGui::BeginDragDropTarget())
{
if (const auto data = ImGui::AcceptDragDropPayload("asset_payload"))
{
AssetHandle assetHandle = *(AssetHandle*)data->Data;
if (AssetsManager::IsAssetType(assetHandle, AssetType::Texture))
{
albedoMap = AssetsManager::GetAsset<Texture2D>(assetHandle);
shouldUpdate = true;
}
}
ImGui::EndDragDropTarget();
}
ImGui::PopStyleVar();
if (ImGui::IsItemHovered())
{
@ -354,28 +375,23 @@ namespace Prism
ImGui::Image((ImTextureRef)albedoMap->GetRendererID(), ImVec2(384, 384));
ImGui::EndTooltip();
}
if (ImGui::IsItemClicked())
{
if (std::string filename = FileSystem::OpenFileSelector("*.png;*.tga;*.jpg;*.jpeg"); !filename.empty())
{
albedoMap = Texture2D::Create(filename, true/*m_AlbedoInput.SRGB*/);
materialInstance->Set("u_AlbedoTexture", albedoMap);
}
}
}
ImGui::SameLine();
ImGui::BeginGroup();
if (ImGui::Checkbox("Use##AlbedoMap", &useAlbedoMap))
materialInstance->Set<float>("u_AlbedoTexToggle", useAlbedoMap ? 1.0f : 0.0f);
/*if (ImGui::Checkbox("sRGB##AlbedoMap", &m_AlbedoInput.SRGB))
{
if (m_AlbedoInput.TextureMap)
m_AlbedoInput.TextureMap = Texture2D::Create(m_AlbedoInput.TextureMap->GetPath(), m_AlbedoInput.SRGB);
}*/
materialInstance->Set<float>("u_AlbedoTexToggle", useAlbedoMap ? 1.0f : 0.0f);
shouldUpdate = true;
}
ImGui::EndGroup();
ImGui::SameLine();
ImGui::ColorEdit3("Color##Albedo", glm::value_ptr(albedoColor), ImGuiColorEditFlags_NoInputs);
if (ImGui::ColorEdit3("Color##Albedo", glm::value_ptr(albedoColor), ImGuiColorEditFlags_NoInputs))
{
meshComponent.UpdateMaterials(selectedMaterialIndex);
shouldUpdate = true;
}
}
}
{
@ -388,6 +404,21 @@ namespace Prism
Ref<Texture2D> normalMap = materialInstance->TryGetResource<Texture2D>("u_NormalTexture");
ImGui::Image(normalMap ? (ImTextureRef)normalMap->GetRendererID() : (ImTextureRef)m_CheckerboardTex->GetRendererID(), ImVec2(64, 64));
if (ImGui::BeginDragDropTarget())
{
if (const auto data = ImGui::AcceptDragDropPayload("asset_payload"))
{
AssetHandle assetHandle = *(AssetHandle*)data->Data;
if (AssetsManager::IsAssetType(assetHandle, AssetType::Texture))
{
normalMap = AssetsManager::GetAsset<Texture2D>(assetHandle);
shouldUpdate = true;
}
}
ImGui::EndDragDropTarget();
}
ImGui::PopStyleVar();
if (ImGui::IsItemHovered())
{
@ -406,12 +437,16 @@ namespace Prism
{
normalMap = Texture2D::Create(filename);
materialInstance->Set("u_NormalTexture", normalMap);
shouldUpdate = true;
}
}
}
ImGui::SameLine();
if (ImGui::Checkbox("Use##NormalMap", &useNormalMap))
{
materialInstance->Set<float>("u_NormalTexToggle", useNormalMap ? 1.0f : 0.0f);
shouldUpdate = true;
}
}
}
{
@ -425,6 +460,21 @@ namespace Prism
Ref<Texture2D> metalnessMap = materialInstance->TryGetResource<Texture2D>("u_MetalnessTexture");
ImGui::Image(metalnessMap ? (ImTextureRef)metalnessMap->GetRendererID() : (ImTextureRef)m_CheckerboardTex->GetRendererID(), ImVec2(64, 64));
if (ImGui::BeginDragDropTarget())
{
if (const auto data = ImGui::AcceptDragDropPayload("asset_payload"))
{
AssetHandle assetHandle = *(AssetHandle*)data->Data;
if (AssetsManager::IsAssetType(assetHandle, AssetType::Texture))
{
metalnessMap = AssetsManager::GetAsset<Texture2D>(assetHandle);
shouldUpdate = true;
}
}
ImGui::EndDragDropTarget();
}
ImGui::PopStyleVar();
if (ImGui::IsItemHovered())
{
@ -437,20 +487,18 @@ namespace Prism
ImGui::Image((ImTextureRef)metalnessMap->GetRendererID(), ImVec2(384, 384));
ImGui::EndTooltip();
}
if (ImGui::IsItemClicked())
{
if (std::string filename = FileSystem::OpenFileSelector("*.png;*.tga;*.jpg;*.jpeg"); !filename.empty())
{
metalnessMap = Texture2D::Create(filename);
materialInstance->Set("u_MetalnessTexture", metalnessMap);
}
}
}
ImGui::SameLine();
if (ImGui::Checkbox("Use##MetalnessMap", &useMetalnessMap))
{
materialInstance->Set<float>("u_MetalnessTexToggle", useMetalnessMap ? 1.0f : 0.0f);
shouldUpdate = true;
}
ImGui::SameLine();
ImGui::SliderFloat("Value##MetalnessInput", &metalnessValue, 0.0f, 1.0f);
if (ImGui::SliderFloat("Value##MetalnessInput", &metalnessValue, 0.0f, 1.0f))
{
shouldUpdate = true;
}
}
}
{
@ -463,6 +511,20 @@ namespace Prism
Ref<Texture2D> roughnessMap = materialInstance->TryGetResource<Texture2D>("u_RoughnessTexture");
ImGui::Image(roughnessMap ? (ImTextureRef)roughnessMap->GetRendererID() : (ImTextureRef)m_CheckerboardTex->GetRendererID(), ImVec2(64, 64));
if (ImGui::BeginDragDropTarget())
{
if (const auto data = ImGui::AcceptDragDropPayload("asset_payload"))
{
AssetHandle assetHandle = *(AssetHandle*)data->Data;
if (AssetsManager::IsAssetType(assetHandle, AssetType::Texture))
{
roughnessMap = AssetsManager::GetAsset<Texture2D>(assetHandle);
shouldUpdate = true;
}
}
ImGui::EndDragDropTarget();
}
ImGui::PopStyleVar();
if (ImGui::IsItemHovered())
{
@ -475,22 +537,21 @@ namespace Prism
ImGui::Image((ImTextureRef)roughnessMap->GetRendererID(), ImVec2(384, 384));
ImGui::EndTooltip();
}
if (ImGui::IsItemClicked())
{
if (std::string filename = FileSystem::OpenFileSelector("*.png;*.tga;*.jpg;*.jpeg"); !filename.empty())
{
roughnessMap = Texture2D::Create(filename);
materialInstance->Set("u_RoughnessTexture", roughnessMap);
}
}
}
ImGui::SameLine();
if (ImGui::Checkbox("Use##RoughnessMap", &useRoughnessMap))
{
materialInstance->Set<float>("u_RoughnessTexToggle", useRoughnessMap ? 1.0f : 0.0f);
shouldUpdate = true;
}
ImGui::SameLine();
ImGui::SliderFloat("Value##RoughnessInput", &roughnessValue, 0.0f, 1.0f);
if (ImGui::SliderFloat("Value##RoughnessInput", &roughnessValue, 0.0f, 1.0f))
{
shouldUpdate = true;
}
}
}
if (shouldUpdate) meshComponent.UpdateMaterials(selectedMaterialIndex);
}
}
}
@ -508,7 +569,8 @@ namespace Prism
m_ObjectsPanel->OnImGuiRender();
m_SceneHierarchyPanel->OnImGuiRender();
m_EditorCamera.OnImGuiRender();
// m_EditorCamera.OnImGuiRender();
m_ConsolePanel->OnImGuiRender();
// Editor Panel ------------------------------------------------------------------------------
ImGui::Begin("Environment");

4
Editor/Editor/EditorLayer.h
View File

@ -5,6 +5,7 @@
#ifndef EDITORLAYER_H
#define EDITORLAYER_H
#include "Panels/ConsolePanel.h"
#include "Prism.h"
#include "Prism/Editor/ContentBrowserPanel.h"
#include "Prism/Editor/ObjectsPanel.h"
@ -150,6 +151,9 @@ namespace Prism
Edit = 0, Play = 1, Pause = 2
};
SceneState m_SceneState = SceneState::Edit;
private:
Scope<ConsolePanel> m_ConsolePanel;
};
}

66
Editor/Editor/Panels/ConsolePanel.cpp Normal file
View File

@ -0,0 +1,66 @@
//
// Created by Atdunbg on 2026/3/26.
//
#include "ConsolePanel.h"
namespace Prism
{
ConsolePanel::ConsolePanel()
{
// 预留一些空间
m_Messages.reserve(1000);
}
void ConsolePanel::OnImGuiRender()
{
ImGui::Begin("Console");
// 工具栏
if (ImGui::Button("Clear"))
{
std::lock_guard<std::mutex> lock(m_Mutex);
m_Messages.clear();
}
ImGui::SameLine();
ImGui::Checkbox("Auto-scroll", &m_AutoScroll);
ImGui::SameLine();
m_Filter.Draw("Filter", 200);
// 消息列表区域
ImGui::BeginChild("ScrollingRegion", ImVec2(0, 0), ImGuiChildFlags_Borders, ImGuiWindowFlags_HorizontalScrollbar);
{
std::lock_guard<std::mutex> lock(m_Mutex);
for (const auto& [msg, color] : m_Messages)
{
if (m_Filter.PassFilter(msg.c_str()))
{
ImGui::PushStyleColor(ImGuiCol_Text, color);
ImGui::TextUnformatted(msg.c_str());
ImGui::PopStyleColor();
}
}
if (m_ScrollToBottom)
{
ImGui::SetScrollHereY(1.0f);
m_ScrollToBottom = false;
}
}
ImGui::EndChild();
ImGui::End();
}
void ConsolePanel::AddMessage(const std::string& message, ImVec4 color)
{
std::lock_guard<std::mutex> lock(m_Mutex);
m_Messages.emplace_back(message, color);
while (m_Messages.size() > 5000)
m_Messages.erase(m_Messages.begin());
if (m_AutoScroll && !m_ScrollToBottom)
m_ScrollToBottom = true;
}
}

31
Editor/Editor/Panels/ConsolePanel.h Normal file
View File

@ -0,0 +1,31 @@
//
// Created by Atdunbg on 2026/3/26.
//
#ifndef PRISM_CONSOLEPANEL_H
#define PRISM_CONSOLEPANEL_H
#include <mutex>
#include <vector>
#include "imgui.h"
namespace Prism
{
class ConsolePanel
{
public:
ConsolePanel();
void OnImGuiRender();
void AddMessage(const std::string& message, ImVec4 color = ImVec4(1,1,1,1));
private:
std::vector<std::pair<std::string, ImVec4>> m_Messages;
ImGuiTextFilter m_Filter;
bool m_AutoScroll = true;
bool m_ScrollToBottom = false;
std::mutex m_Mutex;
};
}
#endif //PRISM_CONSOLEPANEL_H

44
Editor/imgui.ini
View File

@ -1,6 +1,6 @@
[Window][DockSpace Demo]
Pos=0,0
Size=2560,1566
Size=1920,1080
Collapsed=0
[Window][Debug##Default]
@ -9,32 +9,32 @@ Size=400,400
Collapsed=0
[Window][Scene Hierarchy]
Pos=2089,24
Size=471,563
Pos=1449,24
Size=471,385
Collapsed=0
DockId=0x00000009,0
[Window][Properties]
Pos=2089,589
Size=471,977
Pos=1449,411
Size=471,669
Collapsed=0
DockId=0x0000000A,0
[Window][Scene Renderer]
Pos=0,843
Size=481,723
Pos=0,585
Size=481,495
Collapsed=0
DockId=0x00000006,0
[Window][Materials]
Pos=0,24
Size=481,817
Size=481,559
Collapsed=0
DockId=0x00000005,0
[Window][Script Engine Debug]
Pos=2089,589
Size=471,977
Pos=1449,411
Size=471,669
Collapsed=0
DockId=0x0000000A,2
@ -52,25 +52,25 @@ DockId=0x00000001,0
[Window][Viewport]
Pos=483,58
Size=1604,955
Size=964,647
Collapsed=0
DockId=0x0000000B,0
[Window][Environment]
Pos=2089,589
Size=471,977
Pos=1449,411
Size=471,669
Collapsed=0
DockId=0x0000000A,1
[Window][Project]
Pos=483,1015
Size=1604,551
Pos=483,707
Size=964,373
Collapsed=0
DockId=0x0000000C,0
[Window][Objects]
Pos=483,1015
Size=1604,551
Pos=483,707
Size=964,373
Collapsed=0
DockId=0x0000000C,1
@ -81,12 +81,18 @@ Collapsed=0
[Window][##tool_bar]
Pos=483,24
Size=1604,32
Size=964,32
Collapsed=0
DockId=0x00000001,0
[Window][Console]
Pos=483,707
Size=964,373
Collapsed=0
DockId=0x0000000C,2
[Docking][Data]
DockSpace ID=0xC0DFADC4 Window=0xD0388BC8 Pos=0,58 Size=2560,1542 Split=X Selected=0x0C01D6D5
DockSpace ID=0xC0DFADC4 Window=0xD0388BC8 Pos=268,189 Size=1920,1056 Split=X Selected=0x0C01D6D5
DockNode ID=0x00000007 Parent=0xC0DFADC4 SizeRef=1557,1542 Split=X
DockNode ID=0x00000003 Parent=0x00000007 SizeRef=481,1542 Split=Y Selected=0x5D711C2C
DockNode ID=0x00000005 Parent=0x00000003 SizeRef=481,817 Selected=0x5D711C2C

87
ExampleApp/Src/FPSPlayer.cs
View File

@ -8,7 +8,9 @@ namespace FPSExample
public float WalkingSpeed = 10.0f;
public float RunSpeed = 20.0f;
public float JumpForce = 50.0f;
public float m_Radius = 0.5f;
public float TorqueStrength = 10.0f;
[NonSerialized]
public float MouseSensitivity = 10.0f;
@ -68,15 +70,20 @@ namespace FPSExample
UpdateRotation(ts);
UpdateCameraTransform();
}
void OnPhysicsUpdate(float fixedTimeStep)
{
UpdateMovement();
}
private void UpdateRotation(float ts)
{
Vec2 currentMousePosition = Input.GetMousePosition();
Vec2 delta = m_LastMousePosition - currentMousePosition;
float m_CurrentYMovement = delta.X * MouseSensitivity * ts;
m_CurrentYMovement = delta.X * MouseSensitivity * ts;
float xRotation = delta.Y * MouseSensitivity * ts;
m_RigidBody.Rotate(new Vec3(0.0f, m_CurrentYMovement, 0.0f));
// m_RigidBody.Rotate(new Vec3(0.0f, m_CurrentYMovement, 0.0f));
if (delta.X != 0 || delta.Y != 0)
{
@ -90,17 +97,25 @@ namespace FPSExample
private void UpdateMovementInput()
{
if (Input.IsKeyPressed(KeyCode.W))
m_MovementDirection.Y += 1.0f;
else if (Input.IsKeyPressed(KeyCode.S))
if (Input.IsKeyPressed(KeyCode.W)){
m_MovementDirection.Y -= 1.0f;
Debug.Log("KeyPressed: W");
}
else if (Input.IsKeyPressed(KeyCode.S)){
m_MovementDirection.Y += 1.0f;
Debug.Log("KeyPressed: S");
}
else
m_MovementDirection.Y = 0.0f;
if(Input.IsKeyPressed(KeyCode.A))
m_MovementDirection.X -= 1.0f;
else if (Input.IsKeyPressed(KeyCode.D))
if(Input.IsKeyPressed(KeyCode.A)){
m_MovementDirection.X += 1.0f;
Debug.Log("KeyPressed: A");
}
else if (Input.IsKeyPressed(KeyCode.D)){
m_MovementDirection.X -= 1.0f;
Debug.Log("KeyPressed: D");
}
else
m_MovementDirection.X = 0.0f;
@ -136,26 +151,64 @@ namespace FPSExample
}
void OnPhysicsUpdate(float fixedTimeStep)
{
UpdateMovement();
}
private void UpdateMovement()
{
m_RigidBody.Rotate(new Vec3(0.0f, m_CurrentYMovement, 0.0f));
Vec3 movement = m_CameraTransform.Transform.Right * m_MovementDirection.X + m_CameraTransform.Transform.Forward * m_MovementDirection.Y;
// 2. 计算期望的移动方向（世界坐标系）
Vec3 desiredDirection = Vec3.Zero;
if (m_MovementDirection.LengthSquared() != 0.0f)
{
Vec3 right = m_CameraTransform.Transform.Right;
Vec3 forward = m_CameraTransform.Transform.Forward;
right.Y = 0; forward.Y = 0;
right.Normalize(); forward.Normalize();
desiredDirection = right * m_MovementDirection.X + forward * m_MovementDirection.Y;
desiredDirection.Normalize();
/*
Vec3 movement = right * m_MovementDirection.X + forward * m_MovementDirection.Y;
movement.Normalize();
Vec3 velocity = movement * m_CurrentSpeed;
velocity.Y = m_RigidBody.GetLinearVelocity().Y;
m_RigidBody.SetLinearVelocity(velocity);
*/
}
Vec3 targetAngularVelocity = Vec3.Zero;
if (desiredDirection.LengthSquared() > 0.01f)
{
Vec3 up = Vec3.Up;
Vec3 rotationAxis = Vec3.Cross(desiredDirection, up).Normalized();
float angularSpeed = 2 * (m_CurrentSpeed / m_Radius);
targetAngularVelocity = rotationAxis * angularSpeed;
Vec3 currentAngular = m_RigidBody.GetAngularVelocity();
Vec3 angularDiff = targetAngularVelocity - currentAngular;
float inertia = 0.4f * m_RigidBody.Mass * m_Radius * m_Radius;
Vec3 torque = angularDiff * inertia * TorqueStrength;
m_RigidBody.AddTorque(torque, RigidBodyComponent.ForceMode.Force);
}
/*
// 3. 获取当前角速度，计算需要调整的差值
Vec3 currentAngular = m_RigidBody.GetAngularVelocity();
Vec3 angularDiff = targetAngularVelocity - currentAngular;
// 4. 施加扭矩：扭矩 = 转动惯量 * 角加速度
// 球体的转动惯量 I = (2/5) * m * r^2 （实心球）
float inertia = TorqueStrength * m_RigidBody.Mass * m_Radius * m_Radius;
// 设定一个系数控制响应速度（可调）
float torqueStrength = 5.0f;
Vec3 torque = angularDiff * inertia * torqueStrength;
m_RigidBody.AddTorque(-torque, RigidBodyComponent.ForceMode.Force);
*/
if (m_ShouldJump && m_Colliding)
{
Debug.Log("Jump");
m_RigidBody.AddForce(Vec3.Up * JumpForce, RigidBodyComponent.ForceMode.Impulse);
m_ShouldJump = false;
}
@ -163,7 +216,7 @@ namespace FPSExample
private void UpdateCameraTransform(){
Vec3 position = m_Transform.Translation + m_CameraTransform.Transform.Forward * CameraForwardOffset;
position.Y += m_Transform.Translation.Y + CameraYOffset;
position.Y += CameraYOffset;
m_CameraTransform.Translation = position;
}
}

10
Prism-ScriptCore/Src/Prism/Math/Vec3.cs
View File

@ -52,6 +52,15 @@ namespace Prism
Y = vec.Y;
Z = vec.Z;
}
public static Vec3 Cross(Vec3 a, Vec3 b)
{
return new Vec3(
a.Y * b.Z - a.Z * b.Y,
a.Z * b.X - a.X * b.Z,
a.X * b.Y - a.Y * b.X
);
}
public void Clamp(Vec3 min, Vec3 max)
{
@ -59,6 +68,7 @@ namespace Prism
Y = Mathf.Clamp(Y, min.Y, max.Y);
Z = Mathf.Clamp(Z, min.Z, max.Z);
}
public float LengthSquared()
{

38
Prism/CMakeLists.txt
View File

@ -197,7 +197,45 @@ set_target_properties(${SHARED_LIBRARY} PROPERTIES
)
# static runtime library
set(RUNTIME_LIBRARY ${PROJECT_NAME}-Runtime)
add_library(${RUNTIME_LIBRARY} STATIC ${SRC_SOURCE})
target_compile_definitions(${RUNTIME_LIBRARY} PRIVATE
PRISM_RUNTIME
INTERFACE
PRISM_STATIC
)
target_include_directories(${RUNTIME_LIBRARY} PUBLIC
${TARGET_INCLUDE_DIR}
)
target_link_directories(${RUNTIME_LIBRARY} INTERFACE
${PHYSX_LIB_DIR}
)
target_link_libraries(${RUNTIME_LIBRARY}
PRIVATE
${LINK_LIBRARIES_PRIVATE}
PUBLIC
${LINK_LIBRARIES_PUBLIC}
)
target_precompile_headers(${RUNTIME_LIBRARY} PRIVATE
src/pmpch.h
)
set_target_properties(${RUNTIME_LIBRARY} PROPERTIES
OUTPUT_NAME ${PROJECT_NAME}
ARCHIVE_OUTPUT_NAME ${PROJECT_NAME}rd
)
# alias
add_library(Prism::static ALIAS Prism-static)
add_library(Prism::shared ALIAS Prism-shared)
add_library(Prism ALIAS Prism-shared)
add_library(Prism::Runtime ALIAS Prism-Runtime)

25
Prism/src/Prism/Asset/Asset.cpp Normal file
View File

@ -0,0 +1,25 @@
//
// Created by Atdunbg on 2026/3/26.
//
#include "Asset.h"
#include "Prism/Renderer/Texture.h"
namespace Prism
{
PhysicsMaterialAsset::PhysicsMaterialAsset(): StaticFriction(0), DynamicFriction(0), Bounciness(0)
{
Type = AssetType::PhysicsMaterial;
}
PhysicsMaterialAsset::PhysicsMaterialAsset(const float staticFriction, const float dynamicFriction,
const float bounciness): StaticFriction(staticFriction), DynamicFriction(dynamicFriction), Bounciness(bounciness)
{
Type = AssetType::PhysicsMaterial;
}
PBRMaterialAsset::PBRMaterialAsset()
{
Type = AssetType::Material;
}
}

47
Prism/src/Prism/Asset/Asset.h
View File

@ -5,14 +5,20 @@
#ifndef PRISM_ASSET_H
#define PRISM_ASSET_H
#include <glm/glm.hpp>
#include "Prism/Core/UUID.h"
#include "Prism/Core/Ref.h"
namespace Prism
{
class Texture2D;
class Shader;
class MaterialInstance;
enum class AssetType
{
Scene = 0, Mesh, Texture, EnvMap, Audio, Script, PhysicsMaterial, Directory, Other, None
Scene = 0, Mesh, Texture, EnvMap, Audio, Script, Material, PhysicsMaterial, Directory, Other, None
};
using AssetHandle = UUID;
@ -35,20 +41,17 @@ namespace Prism
}
};
class PRISM_API PhysicsMaterial : public Asset
class PRISM_API PhysicsMaterialAsset : public Asset
{
public:
float StaticFriction;
float DynamicFriction;
float Bounciness;
PhysicsMaterial() = default;
PhysicsMaterialAsset();
PhysicsMaterialAsset(const float staticFriction, const float dynamicFriction, const float bounciness);
PhysicsMaterial(const float staticFriction, const float dynamicFriction, const float bounciness)
: StaticFriction(staticFriction), DynamicFriction(dynamicFriction), Bounciness(bounciness)
{
Type = AssetType::PhysicsMaterial;
}
};
// Treating directories as assets simplifies the asset manager window rendering by a lot
@ -63,6 +66,34 @@ namespace Prism
}
};
class PBRMaterialAsset : public Asset
{
public:
PBRMaterialAsset();
virtual ~PBRMaterialAsset() = default;
// Albedo
glm::vec3 AlbedoColor = glm::vec3(1.0f);
float AlbedoTexToggle = 0.0f;
Ref<Texture2D> AlbedoTexture;
// Normal
float NormalTexToggle = 0.0f;
Ref<Texture2D> NormalTexture;
// Metalness
float Metalness = 0.8f;
float MetalnessTexToggle = 0.0f;
Ref<Texture2D> MetalnessTexture;
// Roughness
float Roughness = 0.1f;
float RoughnessTexToggle = 0.0f;
Ref<Texture2D> RoughnessTexture;
bool IsDirty = true;
};
}
#endif //PRISM_ASSET_H

247
Prism/src/Prism/Asset/AssetSerializer.cpp
View File

@ -12,6 +12,7 @@
#include "Prism/Renderer/SceneRenderer.h"
#include "yaml-cpp/yaml.h"
#include "Prism/Utilities/SerializeUtils.h"
namespace Prism
{
@ -40,15 +41,114 @@ namespace Prism
{
case Prism::AssetType::PhysicsMaterial:
{
Ref<PhysicsMaterial> material = Ref<PhysicsMaterial>(asset);
out << YAML::Key << "StaticFriction" << material->StaticFriction;
out << YAML::Key << "DynamicFriction" << material->DynamicFriction;
out << YAML::Key << "Bounciness" << material->Bounciness;
Ref<PhysicsMaterialAsset> physicsMaterial = Ref<PhysicsMaterialAsset>(asset);
out << YAML::Key << "StaticFriction" << physicsMaterial->StaticFriction;
out << YAML::Key << "DynamicFriction" << physicsMaterial->DynamicFriction;
out << YAML::Key << "Bounciness" << physicsMaterial->Bounciness;
break;
}
case AssetType::Material:
{
const auto& material = Ref<PBRMaterialAsset>(asset);
// Albedo
out << YAML::Key << "Albedo";
out << YAML::BeginMap;
{
out << YAML::Key << "Color" << YAML::Value << material->AlbedoColor;
out << YAML::Key << "TexToggle" << YAML::Value << material->AlbedoTexToggle;
out << YAML::Key << "Texture";
out << YAML::BeginMap;
if (material->AlbedoTexture)
{
out << YAML::Key << "AssetHandle" << YAML::Value << material->AlbedoTexture->Handle;
out << YAML::Key << "AssetPath" << YAML::Value << material->AlbedoTexture->FilePath;
}
else
{
out << YAML::Key << "AssetHandle" << YAML::Value << 0;
out << YAML::Key << "AssetPath" << YAML::Value << "";
}
out << YAML::EndMap;
}
out << YAML::EndMap;
// Normal
out << YAML::Key << "Normal";
out << YAML::BeginMap;
{
out << YAML::Key << "TexToggle" << YAML::Value << material->NormalTexToggle;
out << YAML::Key << "Texture";
out << YAML::BeginMap;
if (material->NormalTexture)
{
out << YAML::Key << "AssetHandle" << YAML::Value << material->NormalTexture->Handle;
out << YAML::Key << "AssetPath" << YAML::Value << material->NormalTexture->FilePath;
}
else
{
out << YAML::Key << "AssetHandle" << YAML::Value << 0;
out << YAML::Key << "AssetPath" << YAML::Value << "";
}
out << YAML::EndMap;
}
out << YAML::EndMap;
// Metalness
out << YAML::Key << "Metalness";
out << YAML::BeginMap;
{
out << YAML::Key << "Value" << YAML::Value << material->Metalness; // 金属度数值
out << YAML::Key << "TexToggle" << YAML::Value << material->MetalnessTexToggle;
out << YAML::Key << "Texture";
out << YAML::BeginMap;
if (material->MetalnessTexture)
{
out << YAML::Key << "AssetHandle" << YAML::Value << material->MetalnessTexture->Handle;
out << YAML::Key << "AssetPath" << YAML::Value << material->MetalnessTexture->FilePath;
}
else
{
out << YAML::Key << "AssetHandle" << YAML::Value << 0;
out << YAML::Key << "AssetPath" << YAML::Value << "";
}
out << YAML::EndMap;
}
out << YAML::EndMap;
// Roughness
out << YAML::Key << "Roughness";
out << YAML::BeginMap;
{
out << YAML::Key << "Value" << YAML::Value << material->Roughness; // 粗糙度数值
out << YAML::Key << "TexToggle" << YAML::Value << material->RoughnessTexToggle;
out << YAML::Key << "Texture";
out << YAML::BeginMap;
if (material->RoughnessTexture)
{
out << YAML::Key << "AssetHandle" << YAML::Value << material->RoughnessTexture->Handle;
out << YAML::Key << "AssetPath" << YAML::Value << material->RoughnessTexture->FilePath;
}
else
{
out << YAML::Key << "AssetHandle" << YAML::Value << 0;
out << YAML::Key << "AssetPath" << YAML::Value << "";
}
out << YAML::EndMap;
}
out << YAML::EndMap;
break;
}
}
out << YAML::EndMap;
PM_CORE_INFO("Save Asset change...");
std::ofstream fout(asset->FilePath);
fout << out.c_str();
}
@ -61,13 +161,125 @@ namespace Prism
YAML::Node data = YAML::Load(strStream.str());
if (asset->Type == AssetType::PhysicsMaterial)
switch (asset->Type)
{
float staticFriction = data["StaticFriction"].as<float>();
float dynamicFriction = data["DynamicFriction"].as<float>();
float bounciness = data["Bounciness"].as<float>();
case AssetType::PhysicsMaterial:
{
float staticFriction = data["StaticFriction"].as<float>();
float dynamicFriction = data["DynamicFriction"].as<float>();
float bounciness = data["Bounciness"].as<float>();
return Ref<PhysicsMaterial>::Create(staticFriction, dynamicFriction, bounciness);
return Ref<PhysicsMaterialAsset>::Create(staticFriction, dynamicFriction, bounciness);
}
case AssetType::Material:
{
Ref<PBRMaterialAsset> material = Ref<PBRMaterialAsset>::Create();
// ==================== Albedo ====================
if (data["Albedo"])
{
auto albedoNode = data["Albedo"];
material->AlbedoColor = albedoNode["Color"].as<glm::vec3>();
material->AlbedoTexToggle = albedoNode["TexToggle"].as<float>();
if (albedoNode["Texture"])
{
auto texNode = albedoNode["Texture"];
UUID texHandle = 0;
std::string texPath;
if (texNode["AssetHandle"])
texHandle = texNode["AssetHandle"].as<uint64_t>();
if (texNode["AssetPath"])
texPath = texNode["AssetPath"].as<std::string>();
if (texHandle != 0 && AssetsManager::IsAssetHandleValid(texHandle))
material->AlbedoTexture = AssetsManager::GetAsset<Texture2D>(texHandle);
else if (!texPath.empty())
material->AlbedoTexture = Texture2D::Create(texPath);
else
material->AlbedoTexture = nullptr;
}
}
// ==================== Normal ====================
if (data["Normal"])
{
auto normalNode = data["Normal"];
material->NormalTexToggle = normalNode["TexToggle"].as<float>();
if (normalNode["Texture"])
{
auto texNode = normalNode["Texture"];
UUID texHandle = 0;
std::string texPath;
if (texNode["AssetHandle"])
texHandle = texNode["AssetHandle"].as<uint64_t>();
if (texNode["AssetPath"])
texPath = texNode["AssetPath"].as<std::string>();
if (texHandle != 0 && AssetsManager::IsAssetHandleValid(texHandle))
material->NormalTexture = AssetsManager::GetAsset<Texture2D>(texHandle);
else if (!texPath.empty())
material->NormalTexture = Texture2D::Create(texPath);
else
material->NormalTexture = nullptr;
}
}
// ==================== Metalness ====================
if (data["Metalness"])
{
auto metalNode = data["Metalness"];
material->Metalness = metalNode["Value"].as<float>();
material->MetalnessTexToggle = metalNode["TexToggle"].as<float>();
if (metalNode["Texture"])
{
auto texNode = metalNode["Texture"];
UUID texHandle = 0;
std::string texPath;
if (texNode["AssetHandle"])
texHandle = texNode["AssetHandle"].as<uint64_t>();
if (texNode["AssetPath"])
texPath = texNode["AssetPath"].as<std::string>();
if (texHandle != 0 && AssetsManager::IsAssetHandleValid(texHandle))
material->MetalnessTexture = AssetsManager::GetAsset<Texture2D>(texHandle);
else if (!texPath.empty())
material->MetalnessTexture = Texture2D::Create(texPath);
else
material->MetalnessTexture = nullptr;
}
}
// ==================== Roughness ====================
if (data["Roughness"])
{
auto roughNode = data["Roughness"];
material->Roughness = roughNode["Value"].as<float>();
material->RoughnessTexToggle = roughNode["TexToggle"].as<float>();
if (roughNode["Texture"])
{
auto texNode = roughNode["Texture"];
UUID texHandle = 0;
std::string texPath;
if (texNode["AssetHandle"])
texHandle = texNode["AssetHandle"].as<uint64_t>();
if (texNode["AssetPath"])
texPath = texNode["AssetPath"].as<std::string>();
if (texHandle != 0 && AssetsManager::IsAssetHandleValid(texHandle))
material->RoughnessTexture = AssetsManager::GetAsset<Texture2D>(texHandle);
else if (!texPath.empty())
material->RoughnessTexture = Texture2D::Create(texPath);
else
material->RoughnessTexture = nullptr;
}
}
return material;
}
}
return nullptr;
@ -106,8 +318,10 @@ namespace Prism
asset->ParentDirectory = parentHandle;
asset->IsDataLoaded = false;
#ifndef PRISM_RUNTIME
if (!hasMeta)
CreateMetaFile(asset);
#endif
return asset;
}
@ -191,7 +405,9 @@ namespace Prism
if (asset->FileName == "assets" && asset->Handle == 0)
{
asset->Handle = AssetHandle();
#ifndef PRISM_RUNTIME
CreateMetaFile(asset);
#endif
}
}
@ -208,4 +424,17 @@ namespace Prism
std::ofstream fout(asset->FilePath + ".meta");
fout << out.c_str();
}
void AssetSerializer::UpdateMetaFile(const Ref<Asset>& asset)
{
YAML::Emitter out;
out << YAML::BeginMap;
out << YAML::Key << "Asset" << YAML::Value << asset->Handle;
out << YAML::Key << "FilePath" << YAML::Value << asset->FilePath;
out << YAML::Key << "Type" << YAML::Value << (int)asset->Type;
out << YAML::EndMap;
std::ofstream fout(asset->FilePath + ".meta");
fout << out.c_str();
}
}

1
Prism/src/Prism/Asset/AssetSerializer.h
View File

@ -28,6 +28,7 @@ namespace Prism
static Ref<Asset> DeserializeYAML(const Ref<Asset>& asset);
static void LoadMetaData(Ref<Asset>& asset);
static void CreateMetaFile(const Ref<Asset>& asset);
static void UpdateMetaFile(const Ref<Asset>& asset);
private:
friend class AssetsManager;

68
Prism/src/Prism/Asset/AssetsManager.cpp
View File

@ -13,6 +13,7 @@
#include <yaml-cpp/yaml.h>
#include "AssetSerializer.h"
#include "Prism/Core/Application.h"
#include "Prism/Renderer/SceneEnvironment.h"
#include "Prism/Utilities/StringUtils.h"
@ -26,9 +27,13 @@ namespace Prism
s_Types["dae"] = AssetType::Mesh;
s_Types["obj"] = AssetType::Mesh;
s_Types["png"] = AssetType::Texture;
s_Types["jpg"] = AssetType::Texture;
s_Types["jpeg"] = AssetType::Texture;
s_Types["bmp"] = AssetType::Texture;
s_Types["tga"] = AssetType::Texture;
s_Types["hdr"] = AssetType::EnvMap;
s_Types["blend"] = AssetType::Mesh;
s_Types["pmat"] = AssetType::Material;
s_Types["hpm"] = AssetType::PhysicsMaterial;
s_Types["wav"] = AssetType::Audio;
s_Types["ogg"] = AssetType::Audio;
@ -150,7 +155,7 @@ namespace Prism
template PRISM_API Ref<Asset> AssetsManager::GetAsset(AssetHandle, bool);
template PRISM_API Ref<Mesh> AssetsManager::GetAsset(AssetHandle, bool);
template PRISM_API Ref<PhysicsMaterial> AssetsManager::GetAsset(AssetHandle, bool);
template PRISM_API Ref<PhysicsMaterialAsset> AssetsManager::GetAsset(AssetHandle, bool);
template PRISM_API Ref<Environment> AssetsManager::GetAsset(AssetHandle, bool);
template PRISM_API Ref<Directory> AssetsManager::GetAsset(AssetHandle, bool);
template PRISM_API Ref<Texture2D> AssetsManager::GetAsset(AssetHandle, bool);
@ -161,35 +166,30 @@ namespace Prism
return GetAsset<T>(GetAssetHandleFromFilePath(filepath), loadData);
}
template PRISM_API Ref<Asset> AssetsManager::GetAsset(const std::string&, bool);
template PRISM_API Ref<Mesh> AssetsManager::GetAsset(const std::string&, bool);
template PRISM_API Ref<PhysicsMaterial> AssetsManager::GetAsset(const std::string&, bool);
template PRISM_API Ref<PhysicsMaterialAsset> AssetsManager::GetAsset(const std::string&, bool);
template PRISM_API Ref<PBRMaterialAsset> AssetsManager::GetAsset(const std::string&, bool);
template PRISM_API Ref<Environment> AssetsManager::GetAsset(const std::string&, bool);
template PRISM_API Ref<Directory> AssetsManager::GetAsset(const std::string&, bool);
template PRISM_API Ref<Texture2D> AssetsManager::GetAsset(const std::string&, bool);
// temp
Ref<PhysicsMaterial> AssetsManager::CreateAssetPhysicsMaterial(const std::string& filename, const AssetType type, const AssetHandle& directoryHandle, float v1, float v2, float v3)
template <typename T>
Ref<T> AssetsManager::TryGetAsset(const std::string& filepath, const bool loadData)
{
const auto& directory = GetAsset<Directory>(directoryHandle);
Ref<PhysicsMaterial> asset = Ref<PhysicsMaterial>::Create(v1, v2, v3);
asset->Type = type;
asset->FilePath = directory->FilePath + "/" + filename;
asset->FileName = Utils::RemoveExtension(Utils::GetFilename(asset->FilePath));
asset->Extension = Utils::GetFilename(filename);
asset->ParentDirectory = directoryHandle;
asset->Handle = std::hash<std::string>()(asset->FilePath);
asset->IsDataLoaded = true;
s_LoadedAssets[asset->Handle] = asset;
AssetSerializer::SerializeAsset(asset);
AssetSerializer::CreateMetaFile(asset);
return asset;
AssetHandle assetHandle = GetAssetHandleFromFilePath(filepath);
if (!assetHandle) return Ref<T>();
return GetAsset<T>(assetHandle, loadData);
}
template PRISM_API Ref<Asset> AssetsManager::TryGetAsset(const std::string&, bool);
template PRISM_API Ref<Mesh> AssetsManager::TryGetAsset(const std::string&, bool);
template PRISM_API Ref<PhysicsMaterialAsset> AssetsManager::TryGetAsset(const std::string&, bool);
template PRISM_API Ref<PBRMaterialAsset> AssetsManager::TryGetAsset(const std::string&, bool);
template PRISM_API Ref<Environment> AssetsManager::TryGetAsset(const std::string&, bool);
template PRISM_API Ref<Directory> AssetsManager::TryGetAsset(const std::string&, bool);
template PRISM_API Ref<Texture2D> AssetsManager::TryGetAsset(const std::string&, bool);
void AssetsManager::RemoveAsset(AssetHandle assetHandle)
{
@ -233,7 +233,8 @@ namespace Prism
asset->FileName = Utils::RemoveExtension(Utils::GetFilename(asset->FilePath));
asset->Extension = Utils::GetFilename(filename);
asset->ParentDirectory = directoryHandle;
asset->Handle = std::hash<std::string>()(asset->FilePath);
asset->Handle = std::hash<std::string>()(asset->FilePath + std::to_string(Application::Get().GetTime()));
asset->IsDataLoaded = true;
s_LoadedAssets[asset->Handle] = asset;
@ -243,6 +244,10 @@ namespace Prism
return asset;
}
template PRISM_API Ref<PhysicsMaterialAsset> AssetsManager::CreateAsset<PhysicsMaterialAsset, float, float, float>(const std::string&, AssetType, AssetHandle, float&&, float&&, float&&);
template PRISM_API Ref<PhysicsMaterialAsset> AssetsManager::CreateAsset<PhysicsMaterialAsset>( const std::string&, AssetType, AssetHandle);
template PRISM_API Ref<PBRMaterialAsset> AssetsManager::CreateAsset<PBRMaterialAsset>( const std::string&, AssetType, AssetHandle);
bool AssetsManager::IsAssetType(const AssetHandle assetHandle, const AssetType type)
@ -288,7 +293,7 @@ namespace Prism
{
const std::string extension = Utils::GetExtension(filepath);
if (extension == "meta")
return Ref<Asset>();
return {};
const AssetType type = AssetTypes::GetAssetTypeFromExtension(extension);
Ref<Asset> asset = AssetSerializer::LoadAssetInfo(filepath, parentHandle, type);
@ -349,7 +354,9 @@ namespace Prism
ProcessDirectory(e.FilePath, parentHandle);
else
{
Ref<Asset> asset = ImportAsset(e.FilePath, parentHandle);
AssetHandle assetHandle = GetAssetHandleFromFilePath(e.FilePath);
if (!assetHandle)
ImportAsset(e.FilePath, parentHandle);
}
}
@ -366,10 +373,10 @@ namespace Prism
{
Ref<Asset> asset = nullptr;
{
const std::string oldMetaPath = std::filesystem::path(e.FilePath).parent_path().string() + "/" + e.OldName;
const std::string oldFilePath = Utils::ReplaceFilePathName(e.FilePath, e.OldName);
for (auto& [handle, existingAsset] : s_LoadedAssets)
{
if (existingAsset->FilePath == oldMetaPath)
if (existingAsset->FilePath == oldFilePath)
{
asset = existingAsset;
break;
@ -379,13 +386,16 @@ namespace Prism
if (asset)
{
std::string extension = Utils::GetExtension(asset->FilePath);
std::string oldMetaPath = asset->FilePath + ".meta";
FileSystem::Rename(oldMetaPath, e.NewName);
FileSystem::Rename(oldMetaPath, e.NewName + "." + extension);
asset->FilePath = e.FilePath;
asset->FileName = e.NewName;
asset->Extension = Utils::GetExtension(e.FilePath);
asset->Extension = extension;
AssetSerializer::UpdateMetaFile(asset);
}
}
break;

4
Prism/src/Prism/Asset/AssetsManager.h
View File

@ -46,7 +46,7 @@ namespace Prism
static bool IsAssetHandleValid(const AssetHandle& assetHandle);
static Ref<PhysicsMaterial> CreateAssetPhysicsMaterial(const std::string& filename, AssetType type, const AssetHandle& directoryHandle, float v1, float v2, float v3);
static Ref<PhysicsMaterialAsset> CreateAssetPhysicsMaterial(const std::string& filename, AssetType type, const AssetHandle& directoryHandle, float v1, float v2, float v3);
static void RemoveAsset(AssetHandle assetHandle);
@ -58,6 +58,8 @@ namespace Prism
template<typename T>
static Ref<T> GetAsset(const std::string& filepath, bool loadData = true);
template <class T>
static Ref<T> TryGetAsset(const std::string& filepath, bool loadData = true);
static bool IsAssetType(AssetHandle assetHandle, AssetType type);

20
Prism/src/Prism/Core/EntryPoint.h
View File

@ -13,17 +13,17 @@
extern Prism::Application* Prism::CreateApplication(CommandArgs args);
#ifdef PRISM_GUI
#ifdef _WIN32
#include <windows.h>
int MainEntry(int argc, char* argv[]);
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
return MainEntry(__argc, __argv);
}
#endif
int MainEntry(int argc, char** argv)
#ifdef _WIN32
#include <windows.h>
int MainEntry(int argc, char* argv[]);
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
return MainEntry(__argc, __argv);
}
#endif
int MainEntry(int argc, char** argv)
#else
int main(int argc, char** argv)
int main(int argc, char** argv)
#endif
{
//TODO: this will use other method to impl

4
Prism/src/Prism/Core/Math/AABB.h
View File

@ -19,6 +19,10 @@ namespace Prism
AABB(const glm::vec3& min, const glm::vec3& max)
: Min(min), Max(max) {}
bool IsValid() const {
return Min.x <= Max.x && Min.y <= Max.y && Min.z <= Max.z;
}
};
}

6
Prism/src/Prism/Editor/AssetEditorPanel.cpp
View File

@ -52,6 +52,7 @@ namespace Prism
{
RegisterEditor<TextureViewer>(AssetType::Texture);
RegisterEditor<PhysicsMaterialEditor>(AssetType::PhysicsMaterial);
RegisterEditor<PBRMaterialEditor>(AssetType::Material);
}
void AssetEditorPanel::OnImGuiRender()
@ -62,6 +63,11 @@ namespace Prism
void AssetEditorPanel::OpenEditor(const Ref<Asset>& asset)
{
if (!asset)
{
PM_CORE_WARN("asset is Invalid!");
return;
}
if (s_Editors.find(asset->Type) == s_Editors.end())
{
PM_CORE_WARN("No editor registered for {0} assets", asset->Extension);

82
Prism/src/Prism/Editor/ContentBrowserPanel.cpp
View File

@ -33,7 +33,9 @@ namespace Prism
m_AssetIconMap["blend"] = AssetsManager::GetAsset<Texture2D>("assets/editor/blend.png");
// TODO: get a logo for this project
m_AssetIconMap["scene"] = Texture2D::Create("assets/editor/asset.png");
m_AssetIconMap["scene"] = AssetsManager::GetAsset<Texture2D>("assets/editor/asset.png");
m_AssetIconMap["pmat"] = AssetsManager::GetAsset<Texture2D>("assets/editor/asset.png");
m_BackbtnTex = AssetsManager::GetAsset<Texture2D>("assets/editor/btn_back.png");
m_FwrdbtnTex = AssetsManager::GetAsset<Texture2D>("assets/editor/btn_fwrd.png");
@ -105,17 +107,53 @@ namespace Prism
const std::string filePath = m_CurrentDirectory->FilePath + "/new folder";
FileSystem::CreateFolder(filePath);
UpdateCurrentDirectory(m_CurrentDirHandle);
// const auto& createdDirectory = AssetsManager::CreateDirectory(filePath, m_CurrentDirHandle);
/*
if (createdDirectory)
}
if (ImGui::MenuItem("PBRMaterial"))
{
const std::string fileName = "Material.pmat";
const auto& directory = AssetsManager::GetAsset<Directory>(m_CurrentDirHandle);
// for hash UUID use
std::string baseName = Utils::RemoveExtension(fileName);
std::string extension = Utils::GetExtension(fileName, true);
std::string finalFilename = fileName;
std::string finalPath = directory->FilePath + "/" + finalFilename;
int counter = 1;
while (AssetsManager::GetAssetHandleFromFilePath(finalPath) != 0)
{
UpdateCurrentDirectory(m_CurrentDirHandle);
m_SelectedAssets.Select(createdDirectory->Handle);
memset(m_InputBuffer, 0, MAX_INPUT_BUFFER_LENGTH);
memcpy(m_InputBuffer, createdDirectory->FileName.c_str(), createdDirectory->FileName.size());
m_RenamingSelected = true;
finalFilename = baseName + "_" + std::to_string(counter++) + extension;
finalPath = directory->FilePath + "/" + finalFilename;
}
*/
AssetsManager::CreateAsset<PBRMaterialAsset>(finalFilename, AssetType::Material, m_CurrentDirHandle);
UpdateCurrentDirectory(m_CurrentDirHandle);
}
if (ImGui::MenuItem("Physics Material"))
{
const std::string fileName = "PhysicsMaterial.hpm";
const auto& directory = AssetsManager::GetAsset<Directory>(m_CurrentDirHandle);
// for hash UUID use
std::string baseName = Utils::RemoveExtension(fileName);
std::string extension = Utils::GetExtension(fileName, true);
std::string finalFilename = fileName;
std::string finalPath = directory->FilePath + "/" + finalFilename;
int counter = 1;
while (AssetsManager::GetAssetHandleFromFilePath(finalPath) != 0)
{
finalFilename = baseName + "_" + std::to_string(counter++) + extension;
finalPath = directory->FilePath + "/" + finalFilename;
}
AssetsManager::CreateAsset<PhysicsMaterialAsset>(finalFilename, AssetType::PhysicsMaterial, m_CurrentDirHandle, 0.6f, 0.6f, 0.0f);
UpdateCurrentDirectory(m_CurrentDirHandle);
}
if (ImGui::MenuItem("Scene"))
@ -128,13 +166,23 @@ namespace Prism
PM_CORE_INFO("Creating Script...");
}
/*
if (ImGui::MenuItem("Prefab"))
{
PM_CORE_INFO("Creating Prefab...");
}
*/
ImGui::EndMenu();
}
ImGui::Separator();
if (ImGui::MenuItem("Open In Explorer"))
{
Ref<Asset> asset = AssetsManager::GetAsset<Asset>(m_CurrentDirHandle);
FileSystem::OpenInExplorer(asset->FilePath);
}
ImGui::Separator();
if (ImGui::MenuItem("Import"))
{
@ -146,12 +194,6 @@ namespace Prism
UpdateCurrentDirectory(m_CurrentDirHandle);
}
if (ImGui::MenuItem("Physics Material"))
{
// TODO: use template
AssetsManager::CreateAssetPhysicsMaterial("New Physics Material.hpm", AssetType::PhysicsMaterial, m_CurrentDirHandle, 0.6f, 0.6f, 0.0f);
UpdateCurrentDirectory(m_CurrentDirHandle);
}
ImGui::EndPopup();
}
@ -305,6 +347,12 @@ namespace Prism
if (ImGui::BeginPopupContextItem())
{
if (ImGui::MenuItem("Open In Explorer"))
{
FileSystem::OpenInExplorer(asset->FilePath);
}
ImGui::Separator();
if (ImGui::MenuItem("Rename"))
{
m_SelectedAssets.Select(assetHandle);
@ -528,7 +576,7 @@ namespace Prism
if (ImGui::InputText("##rename_dummy", m_InputBuffer, MAX_INPUT_BUFFER_LENGTH, ImGuiInputTextFlags_EnterReturnsTrue))
{
PM_CORE_INFO("Renaming to {0}", m_InputBuffer);
const std::string filename = m_InputBuffer + Utils::GetExtension(asset->FilePath);
const std::string filename = m_InputBuffer;
FileSystem::Rename(asset->FilePath, filename);
m_RenamingSelected = false;
m_SelectedAssets.Clear();

222
Prism/src/Prism/Editor/DefaultAssetEditors.cpp
View File

@ -13,6 +13,12 @@ namespace Prism
PhysicsMaterialEditor::PhysicsMaterialEditor()
: AssetEditor("Edit Physics Material") {}
void PhysicsMaterialEditor::SetAsset(const Ref<Asset>& asset)
{
if (m_Asset) AssetSerializer::SerializeAsset(m_Asset);
m_Asset = static_cast<Ref<PhysicsMaterialAsset>>(asset);
}
void PhysicsMaterialEditor::Render()
{
if (!m_Asset)
@ -37,6 +43,12 @@ namespace Prism
SetMaxSize(500, 1000);
}
void TextureViewer::SetAsset(const Ref<Asset>& asset)
{
if (m_Asset) AssetSerializer::SerializeAsset(m_Asset);
m_Asset = static_cast<Ref<Texture>>(asset);
}
void TextureViewer::Render()
{
if (!m_Asset)
@ -58,4 +70,214 @@ namespace Prism
UI::EndPropertyGrid();
}
PBRMaterialEditor::PBRMaterialEditor() : AssetEditor("Material Editor")
{
}
// 辅助函数：绘制纹理拖拽槽
void DrawTextureSlot(Ref<Texture2D>& texture, const std::function<void(Ref<Texture2D>)>& onDrop)
{
static Ref<Texture2D> s_Checkerboard = nullptr;
if (!s_Checkerboard)
s_Checkerboard = AssetsManager::GetAsset<Texture2D>("assets/editor/Checkerboard.tga");
ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(10, 10));
ImGui::Image(texture ? (ImTextureID)(intptr_t)texture->GetRendererID() : (ImTextureID)(intptr_t)s_Checkerboard->GetRendererID(),
ImVec2(64, 64));
ImGui::PopStyleVar();
if (ImGui::BeginDragDropTarget())
{
if (const auto data = ImGui::AcceptDragDropPayload("asset_payload"))
{
AssetHandle assetHandle = *(AssetHandle*)data->Data;
if (AssetsManager::IsAssetType(assetHandle, AssetType::Texture))
{
Ref<Texture2D> newTex = AssetsManager::GetAsset<Texture2D>(assetHandle);
if (onDrop) onDrop(newTex);
}
}
ImGui::EndDragDropTarget();
}
if (ImGui::IsItemHovered())
{
if (texture)
{
ImGui::BeginTooltip();
ImGui::PushTextWrapPos(ImGui::GetFontSize() * 35.0f);
ImGui::TextUnformatted(texture->GetPath().c_str());
ImGui::PopTextWrapPos();
ImGui::Image((ImTextureID)(intptr_t)texture->GetRendererID(), ImVec2(384, 384));
ImGui::EndTooltip();
}
/*
// TODO: how to solve this
if (ImGui::IsItemClicked(ImGuiMouseButton_Left))
{
std::string filename = FileSystem::OpenFileSelector("*.png;*.tga;*.jpg;*.jpeg");
if (!filename.empty())
{
Ref<Texture2D> newTex = Texture2D::Create(filename);
if (onDrop) onDrop(newTex);
}
}
*/
}
}
void PBRMaterialEditor::SetAsset(const Ref<Asset>& asset)
{
if (m_Asset)
{
if (m_Asset->Handle == asset->Handle) return;
if (AssetsManager::IsAssetHandleValid(m_Asset->Handle))
AssetSerializer::SerializeAsset(m_Asset);
}
m_Asset = static_cast<Ref<PBRMaterialAsset>>(asset);
}
void PBRMaterialEditor::Render()
{
if (!m_Asset) return;
auto& material = m_Asset;
if (ImGui::BeginTabBar("MaterialProperties", ImGuiTabBarFlags_None))
{
// ==================== Parameters ====================
if (ImGui::BeginTabItem("Parameters"))
{
ImGui::Spacing();
if (ImGui::CollapsingHeader("Albedo", ImGuiTreeNodeFlags_DefaultOpen))
{
ImGui::Indent();
if (ImGui::ColorEdit3("Color##Albedo", glm::value_ptr(material->AlbedoColor)))
{
m_Asset->IsDirty = true;
}
bool useAlbedoMap = (material->AlbedoTexToggle > 0.5f);
if (ImGui::Checkbox("Use Texture##Albedo", &useAlbedoMap))
{
material->AlbedoTexToggle = useAlbedoMap ? 1.0f : 0.0f;
m_Asset->IsDirty = true;
}
DrawTextureSlot(material->AlbedoTexture, [&](const Ref<Texture2D>& newTex) {
material->AlbedoTexture = newTex;
material->AlbedoTexToggle = true;
m_Asset->IsDirty = true;
});
ImGui::SameLine();
ImGui::Text("Albedo Texture");
ImGui::Unindent();
}
// Normal Map
if (ImGui::CollapsingHeader("Normal Map", ImGuiTreeNodeFlags_DefaultOpen))
{
ImGui::Indent();
bool useNormalMap = (material->NormalTexToggle > 0.5f);
if (ImGui::Checkbox("Use Texture##Normal", &useNormalMap))
{
material->NormalTexToggle = useNormalMap ? 1.0f : 0.0f;
m_Asset->IsDirty = true;
}
DrawTextureSlot(material->NormalTexture, [&](const Ref<Texture2D>& newTex) {
material->NormalTexture = newTex;
material->NormalTexToggle = true;
m_Asset->IsDirty = true;
});
ImGui::SameLine();
ImGui::Text("Normal Texture");
ImGui::Unindent();
}
// Metalness
if (ImGui::CollapsingHeader("Metalness", ImGuiTreeNodeFlags_DefaultOpen))
{
ImGui::Indent();
if (ImGui::SliderFloat("Value##Metalness", &material->Metalness, 0.0f, 1.0f))
{
// 自动保存
m_Asset->IsDirty = true;
}
bool useMetalnessMap = (material->MetalnessTexToggle > 0.5f);
if (ImGui::Checkbox("Use Texture##Metalness", &useMetalnessMap))
{
material->MetalnessTexToggle = useMetalnessMap ? 1.0f : 0.0f;
m_Asset->IsDirty = true;
}
DrawTextureSlot(material->MetalnessTexture, [&](const Ref<Texture2D>& newTex) {
material->MetalnessTexture = newTex;
material->MetalnessTexToggle = true;
m_Asset->IsDirty = true;
});
ImGui::SameLine();
ImGui::Text("Metalness Texture");
ImGui::Unindent();
}
// Roughness
if (ImGui::CollapsingHeader("Roughness", ImGuiTreeNodeFlags_DefaultOpen))
{
ImGui::Indent();
if (ImGui::SliderFloat("Value##Roughness", &material->Roughness, 0.0f, 1.0f))
{
// 自动保存
m_Asset->IsDirty = true;
}
bool useRoughnessMap = (material->RoughnessTexToggle > 0.5f);
if (ImGui::Checkbox("Use Texture##Roughness", &useRoughnessMap))
{
material->RoughnessTexToggle = useRoughnessMap ? 1.0f : 0.0f;
m_Asset->IsDirty = true;
}
DrawTextureSlot(material->RoughnessTexture, [&](const Ref<Texture2D>& newTex) {
material->RoughnessTexture = newTex;
material->RoughnessTexToggle = true;
m_Asset->IsDirty = true;
});
ImGui::SameLine();
ImGui::Text("Roughness Texture");
ImGui::Unindent();
}
ImGui::EndTabItem();
}
// ==================== 预览 ====================
if (ImGui::BeginTabItem("Preview"))
{
// 简单显示纹理预览
if (material->AlbedoTexture)
{
ImGui::Text("Albedo Preview");
ImGui::Image((ImTextureID)(intptr_t)material->AlbedoTexture->GetRendererID(), ImVec2(128, 128));
}
ImGui::EndTabItem();
}
ImGui::EndTabBar();
}
}
}

29
Prism/src/Prism/Editor/DefaultAssetEditors.h
View File

@ -15,14 +15,14 @@ namespace Prism
public:
PhysicsMaterialEditor();
virtual Ref<Asset> GetAsset() override { return m_Asset; }
virtual void SetAsset(const Ref<Asset>& asset) override { m_Asset = (Ref<PhysicsMaterial>)asset; }
Ref<Asset> GetAsset() override { return m_Asset; }
void SetAsset(const Ref<Asset>& asset) override;
private:
virtual void Render() override;
void Render() override;
private:
Ref<PhysicsMaterial> m_Asset;
Ref<PhysicsMaterialAsset> m_Asset;
};
class TextureViewer : public AssetEditor
@ -30,16 +30,31 @@ namespace Prism
public:
TextureViewer();
virtual Ref<Asset> GetAsset() override { return m_Asset; }
virtual void SetAsset(const Ref<Asset>& asset) override { m_Asset = static_cast<Ref<Texture>>(asset); }
Ref<Asset> GetAsset() override { return m_Asset; }
void SetAsset(const Ref<Asset>& asset) override;
private:
virtual void Render() override;
void Render() override;
private:
Ref<Texture> m_Asset;
};
class PBRMaterialEditor : public AssetEditor
{
public:
PBRMaterialEditor();
Ref<Asset> GetAsset() override { return m_Asset; }
void SetAsset(const Ref<Asset>& asset) override;
private:
void Render() override;
private:
Ref<PBRMaterialAsset> m_Asset;
};
}
#endif //PRISM_DEFAULTASSETEDITORS_H

52
Prism/src/Prism/Editor/SceneHierachyPanel.cpp
View File

@ -14,6 +14,7 @@
#include <glm/gtx/quaternion.hpp>
#include <glm/gtx/matrix_decompose.hpp>
#include "AssetEditorPanel.h"
#include "Prism/Core/Application.h"
#include "Prism/Core/Math/Math.h"
#include "Prism/Physics/PhysicsLayer.h"
@ -547,7 +548,7 @@ namespace Prism
template<typename T, typename UIFunction>
static void DrawComponent(const std::string& name, Entity entity, UIFunction uiFunction)
{
const ImGuiTreeNodeFlags treeNodeFlags = ImGuiTreeNodeFlags_DefaultOpen |
constexpr ImGuiTreeNodeFlags treeNodeFlags = ImGuiTreeNodeFlags_DefaultOpen |
ImGuiTreeNodeFlags_Framed |
ImGuiTreeNodeFlags_SpanAvailWidth |
ImGuiTreeNodeFlags_AllowOverlap |
@ -886,13 +887,50 @@ namespace Prism
DrawComponent<MeshComponent>("Mesh", entity, [](MeshComponent& meshComponent) {
UI::BeginPropertyGrid();
UI::PropertyAssetReference("Mesh", meshComponent.Mesh, AssetType::Mesh);
// UI::Property("AnimationPlaying", meshComponent.Mesh->m_AnimationPlaying);
// UI::Property("TimeMultiple", meshComponent.Mesh->m_TimeMultiplier);
// UI::Property("AnimationTime", meshComponent.Mesh->m_AnimationTime);
// UI::Property("WorldTime", meshComponent.Mesh->m_WorldTime);
if (UI::PropertyAssetReference("Mesh", meshComponent.Mesh, AssetType::Mesh))
{
meshComponent.MaterialInstances.clear();
meshComponent.MaterialDescs.clear();
const auto& materialInstances = meshComponent.Mesh->GetMaterials();
for (uint32_t i = 0; i < materialInstances.size(); i++)
{
Ref<MaterialInstance> materialInstance = MaterialInstance::Copy(materialInstances[i]);
meshComponent.MaterialInstances.push_back(materialInstance);
}
meshComponent.MaterialDescs.resize(materialInstances.size());
}
UI::EndPropertyGrid();
for (auto i = 0; i < meshComponent.MaterialDescs.size(); i++)
{
// TODO: 这里通过 MaterialDesc进行存储信息，然后修改后由此处更新MaterialInstances，同时还缺少一个在MeshComponent中MaterialDesc的序列化
if (UI::BeginTreeNode((std::string("Slot ") + std::to_string(i)).c_str()))
{
UI::BeginPropertyGrid();
if (meshComponent.MaterialDescs[i])
{
if (ImGui::Button("X"))
{
meshComponent.MaterialDescs[i] = nullptr;
meshComponent.UpdateMaterials(i);
}
ImGui::SameLine();
}
if (ImGui::Button("Edit")) AssetEditorPanel::OpenEditor(meshComponent.MaterialDescs[i]);
ImGui::SameLine();
if (UI::PropertyAssetReference(meshComponent.MaterialInstances[i]->GetName().c_str(), meshComponent.MaterialDescs[i], AssetType::Material))
{
meshComponent.UpdateMaterials(-1, true);
}
UI::EndPropertyGrid();
UI::EndTreeNode();
}
}
});
DrawComponent<AnimationComponent>("AnimatorController", entity, [this](AnimationComponent& animatorComponent)
@ -1360,7 +1398,7 @@ namespace Prism
if (UI::Property("Size", bcc.Size))
{
bcc.DebugMesh = MeshFactory::CreateBox(bcc.Size);
bcc.DebugMesh = MeshFactory::CreateBox(bcc.Size * 2.0f);
}
UI::Property("IsTrigger", bcc.IsTrigger);

36
Prism/src/Prism/Physics/PhysicsActor.cpp
View File

@ -11,6 +11,8 @@
#include "Prism/Script/ScriptEngine.h"
#include <glm/gtx/compatibility.hpp>
#include "glm/gtx/euler_angles.hpp"
namespace Prism
{
PhysicsActor::PhysicsActor(Entity entity)
@ -177,15 +179,24 @@ namespace Prism
Ref<Scene> scene = Scene::GetScene(m_Entity.GetSceneUUID());
glm::mat4 transform = scene->GetTransformRelativeToParent(m_Entity);
if (m_RigidBody.BodyType == RigidBodyComponent::Type::Static)
{
m_ActorInternal = physics.createRigidStatic(ToPhysXTransform(transform));
}
else
glm::vec3 translation, rotationEuler, scale;
Math::DecomposeTransform(transform, translation, rotationEuler, scale);
const glm::mat4 rotMat = glm::eulerAngleYXZ(rotationEuler.y, rotationEuler.x, rotationEuler.z);
const glm::quat rotationQuat = glm::quat_cast(rotMat);
physx::PxTransform pxTransform(ToPhysXVector(translation), ToPhysXQuat(rotationQuat));
// PhysicsActor::Initialize 中
m_WorldScale = scale;
if (IsDynamic())
{
const PhysicsSettings& settings = Physics3D::GetSettings();
physx::PxRigidDynamic* actor = physics.createRigidDynamic(ToPhysXTransform(transform));
physx::PxRigidDynamic* actor = physics.createRigidDynamic(pxTransform);
actor->setLinearDamping(m_RigidBody.LinearDrag);
actor->setAngularDamping(m_RigidBody.AngularDrag);
actor->setRigidBodyFlag(physx::PxRigidBodyFlag::eKINEMATIC, m_RigidBody.IsKinematic);
@ -198,15 +209,26 @@ namespace Prism
actor->setActorFlag(physx::PxActorFlag::eDISABLE_GRAVITY, m_RigidBody.DisableGravity);
actor->setSolverIterationCounts(settings.SolverIterations, settings.SolverVelocityIterations);
physx::PxRigidBodyExt::setMassAndUpdateInertia(*actor, m_RigidBody.Mass);
m_ActorInternal = actor;
}
else
{
m_ActorInternal = physics.createRigidStatic(pxTransform);
}
// Add Collider
if (m_Entity.HasComponent<BoxColliderComponent>()) PhysicsWrappers::AddBoxCollider(*this);
if (m_Entity.HasComponent<SphereColliderComponent>()) PhysicsWrappers::AddSphereCollider(*this);
if (m_Entity.HasComponent<CapsuleColliderComponent>()) PhysicsWrappers::AddCapsuleCollider(*this);
if (m_Entity.HasComponent<MeshColliderComponent>()) PhysicsWrappers::AddMeshCollider(*this);
if (IsDynamic())
{
auto* dynamicActor = static_cast<physx::PxRigidDynamic*>(m_ActorInternal);
physx::PxRigidBodyExt::setMassAndUpdateInertia(*dynamicActor, m_RigidBody.Mass);
}
if (!PhysicsLayerManager::IsLayerValid(m_RigidBody.Layer))
m_RigidBody.Layer = 0;

4
Prism/src/Prism/Physics/PhysicsActor.h
View File

@ -49,6 +49,8 @@ namespace Prism
Entity& GetEntity() { return m_Entity; }
glm::vec3 GetWorldScale() const { return m_WorldScale; }
private:
void Initialize();
void Spawn() const;
@ -64,6 +66,8 @@ namespace Prism
physx::PxRigidActor* m_ActorInternal;
glm::vec3 m_WorldScale = glm::vec3(1.0f);
friend class Physics3D;
friend class PhysicsWrappers;

4
Prism/src/Prism/Physics/PhysicsUtils.cpp
View File

@ -36,12 +36,12 @@ namespace Prism
physx::PxVec3 ToPhysXVector(const glm::vec3& vector)
{
return *(physx::PxVec3*)&vector;
return physx::PxVec3(vector.x, vector.y, vector.z);
}
physx::PxVec4 ToPhysXVector(const glm::vec4& vector)
{
return *(physx::PxVec4*)&vector;
return physx::PxVec4(vector.x, vector.y, vector.z, vector.w);
}
physx::PxQuat ToPhysXQuat(const glm::quat& quat)

17
Prism/src/Prism/Physics/PhysicsWrappers.cpp
View File

@ -184,16 +184,11 @@ namespace Prism
auto& collider = actor.m_Entity.GetComponent<BoxColliderComponent>();
if (!collider.Material)
collider.Material = Ref<PhysicsMaterial>::Create(0.6F, 0.6F, 0.0f);
collider.Material = Ref<PhysicsMaterialAsset>::Create(0.6F, 0.6F, 0.0f);
const glm::vec3 scale = actor.m_Entity.Transform().Scale;
glm::vec3 colliderSize = collider.Size;
glm::vec3 colliderSize = collider.Size * actor.GetWorldScale();
if (scale.x != 0.0f) colliderSize.x *= scale.x;
if (scale.y != 0.0f) colliderSize.y *= scale.y;
if (scale.z != 0.0f) colliderSize.z *= scale.z;
const auto boxGeometry = physx::PxBoxGeometry(colliderSize.x / 2.0f, colliderSize.y / 2.0f, colliderSize.z / 2.0f);
const auto boxGeometry = physx::PxBoxGeometry(colliderSize.x, colliderSize.y, colliderSize.z);
const physx::PxMaterial* material = s_Physics->createMaterial(collider.Material->StaticFriction, collider.Material->DynamicFriction, collider.Material->Bounciness);
physx::PxShape* shape = physx::PxRigidActorExt::createExclusiveShape(*actor.m_ActorInternal, boxGeometry, *material);
@ -207,7 +202,7 @@ namespace Prism
{
auto& collider = actor.m_Entity.GetComponent<SphereColliderComponent>();
if (!collider.Material)
collider.Material = Ref<PhysicsMaterial>::Create(0.6F, 0.6F, 0.0f);
collider.Material = Ref<PhysicsMaterialAsset>::Create(0.6F, 0.6F, 0.0f);
const glm::vec3 scale = actor.m_Entity.Transform().Scale;
float colliderRadius = collider.Radius;
@ -227,7 +222,7 @@ namespace Prism
{
auto& collider = actor.m_Entity.GetComponent<CapsuleColliderComponent>();
if (!collider.Material)
collider.Material = Ref<PhysicsMaterial>::Create(0.6F, 0.6F, 0.0f);
collider.Material = Ref<PhysicsMaterialAsset>::Create(0.6F, 0.6F, 0.0f);
const glm::vec3 scale = actor.m_Entity.Transform().Scale;
float colliderRadius = collider.Radius;
@ -255,7 +250,7 @@ namespace Prism
{
auto& collider = actor.m_Entity.GetComponent<MeshColliderComponent>();
if (!collider.Material)
collider.Material = Ref<PhysicsMaterial>::Create(0.6f, 0.6f, 0.0f);
collider.Material = Ref<PhysicsMaterialAsset>::Create(0.6f, 0.6f, 0.0f);
glm::vec3 scale = actor.m_Entity.Transform().Scale;
physx::PxMaterial* material = s_Physics->createMaterial(collider.Material->StaticFriction, collider.Material->DynamicFriction, collider.Material->Bounciness);

4
Prism/src/Prism/Platform/OpenGL/OpenGLRenderPass.h
View File

@ -15,8 +15,8 @@ namespace Prism
OpenGLRenderPass(const RenderPassSpecification& spec);
virtual ~OpenGLRenderPass();
virtual RenderPassSpecification& GetSpecification() override { return m_Spec; }
virtual const RenderPassSpecification& GetSpecification() const { return m_Spec; }
RenderPassSpecification& GetSpecification() override { return m_Spec; }
const RenderPassSpecification& GetSpecification() const override { return m_Spec; }
private:
RenderPassSpecification m_Spec;

8
Prism/src/Prism/Platform/OpenGL/OpenGLRendererAPI.cpp
View File

@ -157,10 +157,13 @@ namespace Prism
glClearColor(r, g, b, a);
}
void RendererAPI::DrawIndexed(uint32_t count, PrimitiveType type, bool depthTest, bool faceCulling)
void RendererAPI::DrawIndexed(const uint32_t count, const PrimitiveType type, const bool depthTest, const bool faceCulling)
{
if (!depthTest)
{
glDisable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
}
GLenum glPrimitiveType = 0;
switch (type)
@ -181,7 +184,10 @@ namespace Prism
glDrawElements(glPrimitiveType, count, GL_UNSIGNED_INT, nullptr);
if (!depthTest)
{
glEnable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
}
}
void RendererAPI::SetLineThickness(const float thickness)

49
Prism/src/Prism/Platform/OpenGL/OpenGLTexture.cpp
View File

@ -54,7 +54,7 @@ namespace Prism
// Texture2D
// ******************************************
OpenGLTexture2D::OpenGLTexture2D(TextureFormat format, uint32_t width, uint32_t height, TextureWrap wrap)
OpenGLTexture2D::OpenGLTexture2D(const TextureFormat format, const uint32_t width, const uint32_t height, const TextureWrap wrap)
: m_Format(format), m_Width(width), m_Height(height), m_Wrap(wrap)
{
Ref<OpenGLTexture2D> instance = this;
@ -83,6 +83,53 @@ namespace Prism
m_ImageData.Allocate(width * height * GetBPP(m_Format));
}
OpenGLTexture2D::OpenGLTexture2D(const TextureFormat format, const uint32_t width, const uint32_t height, const void* data, const TextureWrap wrap)
: m_Format(format), m_Width(width), m_Height(height), m_Wrap(wrap)
{
// 计算图像数据大小（假设是 RGBA8，或根据格式动态计算）
uint32_t bpp = GetBPP(format);
uint32_t dataSize = width * height * bpp;
// 保存一份数据到 CPU 缓冲区（供后续可能的读取）
if (data)
{
m_ImageData.Allocate(dataSize);
memcpy(m_ImageData.Data, data, dataSize);
}
else
{
m_ImageData.Allocate(dataSize);
memset(m_ImageData.Data, 0, dataSize); // 可选：初始化为0
}
Ref<OpenGLTexture2D> instance = this;
Renderer::Submit([instance]() mutable {
glGenTextures(1, &instance->m_RendererID);
glBindTexture(GL_TEXTURE_2D, instance->m_RendererID);
// 设置纹理参数
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
GLint wrap = instance->m_Wrap == TextureWrap::Clamp ? GL_CLAMP_TO_EDGE : GL_REPEAT;
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap);
glTextureParameterf(instance->m_RendererID, GL_TEXTURE_MAX_ANISOTROPY, RendererAPI::GetCapabilities().MaxAnisotropy);
// 上传数据（如果已有数据则使用，否则传 nullptr 创建空纹理）
glTexImage2D(GL_TEXTURE_2D, 0,
SizedInternalFormat(instance->m_Format),
(GLint)instance->m_Width, (GLint)instance->m_Height, 0,
ImageFormat(instance->m_Format),
DataType(instance->m_Format),
instance->m_ImageData.Data); // 这里传入数据指针
// 如果需要生成 mipmap，取消注释下一行
// glGenerateMipmap(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 0);
});
}
OpenGLTexture2D::OpenGLTexture2D(const std::string& path, bool srgb)
: m_FilePath(path)

1
Prism/src/Prism/Platform/OpenGL/OpenGLTexture.h
View File

@ -14,6 +14,7 @@ namespace Prism
{
public:
OpenGLTexture2D(TextureFormat format, uint32_t width, uint32_t height, TextureWrap wrap);
OpenGLTexture2D(TextureFormat format, uint32_t width, uint32_t height, const void* data, TextureWrap wrap = TextureWrap::Clamp);
OpenGLTexture2D(const std::string& path, bool srgb);
virtual ~OpenGLTexture2D();

37
Prism/src/Prism/Platform/Windows/WindowsFileSystemWatcher.cpp
View File

@ -16,6 +16,7 @@
#include "Prism/Core/Application.h"
#include "efsw/efsw.hpp"
#include "Prism/Utilities/StringUtils.h"
namespace Prism
{
@ -30,22 +31,22 @@ namespace Prism
public:
void handleFileAction(efsw::WatchID watchid,
const std::string& dir,
const std::string& filename,
const std::string& filepath,
efsw::Action action,
std::string oldFilename = "") override
std::string oldFilepath = "") override
{
// 如果引擎自身操作设置了忽略标志，则跳过本次事件
if (FileSystem::s_IgnoreNextChange.load())
return;
std::string fullPath = (std::filesystem::path(dir) / filename).string();
std::string fullPath = (std::filesystem::path(dir) / filepath).string();
std::replace(fullPath.begin(), fullPath.end(), '\\', '/');
fullPath = Utils::NormalizePath(fullPath);
FileSystemChangedEvent e;
e.FilePath = fullPath;
e.NewName = filename;
e.OldName = oldFilename; // efsw 在重命名时会提供旧文件名
e.NewName = Utils::GetFilename(filepath);
e.OldName = Utils::GetFilename(oldFilepath); // efsw 在重命名时会提供旧文件名
e.IsDirectory = false; // 稍后根据实际情况判断
// 判断是否为目录（可能抛出异常，使用 error_code 版本）
@ -163,6 +164,30 @@ namespace Prism
return result ? std::string(result) : std::string();
}
void FileSystem::OpenInExplorer(const std::string& path)
{
const std::filesystem::path absPath = std::filesystem::absolute(path);
if (!std::filesystem::exists(absPath))
{
PM_CORE_WARN("Path does not exist: {}", path);
return;
}
std::string cmd;
if (std::filesystem::is_directory(absPath))
{
// 打开目录
cmd = absPath.string();
ShellExecuteA(nullptr, "open", "explorer.exe", cmd.c_str(), NULL, SW_SHOW);
}
else
{
// 打开并选中文件
cmd = "/select, \"" + absPath.string() + "\"";
ShellExecuteA(nullptr, "open", "explorer.exe", cmd.c_str(), NULL, SW_SHOW);
}
}
bool FileSystem::CreateFolder(const std::filesystem::path& filepath)
{

21
Prism/src/Prism/Renderer/Material.cpp
View File

@ -140,6 +140,27 @@ namespace Prism
return Ref<MaterialInstance>::Create(material);
}
Ref<MaterialInstance> MaterialInstance::Copy(Ref<MaterialInstance> other)
{
if (!other) return nullptr;
auto newInstance = Create(other->m_Material);
newInstance->m_Name = other->m_Name + "_Override";
// 复制 uniform 缓冲区
newInstance->m_VSUniformStorageBuffer = Buffer::Copy(other->m_VSUniformStorageBuffer.Data, other->m_VSUniformStorageBuffer.GetSize());
newInstance->m_PSUniformStorageBuffer = Buffer::Copy(other->m_PSUniformStorageBuffer.Data, other->m_PSUniformStorageBuffer.GetSize());
// 复制纹理列表（共享纹理引用）
newInstance->m_Textures = other->m_Textures;
// 复制覆盖标记集合
newInstance->m_OverriddenValues = other->m_OverriddenValues;
return newInstance;
}
void MaterialInstance::OnShaderReloaded()
{
AllocateStorage();

5
Prism/src/Prism/Renderer/Material.h
View File

@ -119,6 +119,11 @@ namespace Prism
static Ref<MaterialInstance> Create(const Ref<Material>& material);
/**
*
* @param other copy other data to a new Data
* @return the new Data will as Ref return
*/
static Ref<MaterialInstance> Copy(Ref<MaterialInstance> other);
template<typename T>

95
Prism/src/Prism/Renderer/Mesh.cpp
View File

@ -64,6 +64,13 @@ namespace Prism
return result;
}
static AABB UnionAABB(const AABB& a, const AABB& b) {
AABB result;
result.Min = glm::min(a.Min, b.Min);
result.Max = glm::max(a.Max, b.Max);
return result;
}
void AnimatedVertex::AddBoneData(uint32_t BoneID, float Weight)
{
@ -300,9 +307,9 @@ namespace Prism
std::string texturePath = parentPath.string();
PM_MESH_LOG(" Albedo map path = {0}", texturePath);
auto texture = AssetsManager::GetAsset<Texture2D>(texturePath);
auto texture = AssetsManager::TryGetAsset<Texture2D>(texturePath);
// auto texture = Texture2D::Create(texturePath, true);
if (texture->Loaded())
if (texture && texture->Loaded())
{
m_Textures[i] = texture;
mi->Set("u_AlbedoTexture", m_Textures[i]);
@ -333,9 +340,9 @@ namespace Prism
std::string texturePath = parentPath.string();
PM_MESH_LOG(" Normal map path = {0}", texturePath);
auto texture = AssetsManager::GetAsset<Texture2D>(texturePath);
auto texture = AssetsManager::TryGetAsset<Texture2D>(texturePath);
// auto texture = Texture2D::Create(texturePath);
if (texture->Loaded())
if (texture && texture->Loaded())
{
mi->Set("u_NormalTexture", texture);
mi->Set("u_NormalTexToggle", 1.0f);
@ -362,9 +369,9 @@ namespace Prism
std::string texturePath = parentPath.string();
PM_MESH_LOG(" Roughness map path = {0}", texturePath);
auto texture = AssetsManager::GetAsset<Texture2D>(texturePath);
auto texture = AssetsManager::TryGetAsset<Texture2D>(texturePath);
// auto texture = Texture2D::Create(texturePath);
if (texture->Loaded())
if (texture && texture->Loaded())
{
PM_CORE_TRACE(" Roughness map path = {0}", texturePath);
mi->Set("u_RoughnessTexture", texture);
@ -458,9 +465,9 @@ namespace Prism
PM_MESH_LOG(" Metalness map path = {0}", texturePath);
auto texture = AssetsManager::GetAsset<Texture2D>(texturePath);
auto texture = AssetsManager::TryGetAsset<Texture2D>(texturePath);
// auto texture = Texture2D::Create(texturePath);
if (texture->Loaded())
if (texture && texture->Loaded())
{
mi->Set("u_MetalnessTexture", texture);
mi->Set("u_MetalnessTexToggle", 1.0f);
@ -517,6 +524,32 @@ namespace Prism
PipelineSpecification pipelineSpecification;
pipelineSpecification.Layout = vertexBufferLayout;
m_Pipeline = Pipeline::Create(pipelineSpecification);
if (!m_IsAnimated)
{
for (const auto& submesh : m_Submeshes) {
glm::vec3 corners[8];
corners[0] = submesh.Transform * glm::vec4(submesh.BoundingBox.Min, 1.0f);
corners[1] = submesh.Transform * glm::vec4(submesh.BoundingBox.Max, 1.0f);
corners[2] = submesh.Transform * glm::vec4(glm::vec3(submesh.BoundingBox.Min.x, submesh.BoundingBox.Min.y, submesh.BoundingBox.Max.z), 1.0f);
corners[3] = submesh.Transform * glm::vec4(glm::vec3(submesh.BoundingBox.Min.x, submesh.BoundingBox.Max.y, submesh.BoundingBox.Min.z), 1.0f);
corners[4] = submesh.Transform * glm::vec4(glm::vec3(submesh.BoundingBox.Min.x, submesh.BoundingBox.Max.y, submesh.BoundingBox.Max.z), 1.0f);
corners[5] = submesh.Transform * glm::vec4(glm::vec3(submesh.BoundingBox.Max.x, submesh.BoundingBox.Min.y, submesh.BoundingBox.Min.z), 1.0f);
corners[6] = submesh.Transform * glm::vec4(glm::vec3(submesh.BoundingBox.Max.x, submesh.BoundingBox.Min.y, submesh.BoundingBox.Max.z), 1.0f);
corners[7] = submesh.Transform * glm::vec4(glm::vec3(submesh.BoundingBox.Max.x, submesh.BoundingBox.Max.y, submesh.BoundingBox.Min.z), 1.0f);
AABB transformedAABB;
transformedAABB.Min = corners[0];
transformedAABB.Max = corners[0];
for (int i = 1; i < 8; ++i) {
transformedAABB.Min = glm::min(transformedAABB.Min, corners[i]);
transformedAABB.Max = glm::max(transformedAABB.Max, corners[i]);
}
m_BoundingBox = UnionAABB(m_BoundingBox, transformedAABB);
}
}
}
Mesh::Mesh(const std::vector<Vertex>& vertices, const std::vector<Index>& indices, const glm::mat4& transform)
@ -541,6 +574,16 @@ namespace Prism
{ ShaderDataType::Float2, "a_TexCoord" },
};
m_Pipeline = Pipeline::Create(pipelineSpecification);
// boundingbox
m_BoundingBox.Min = glm::vec3(FLT_MAX);
m_BoundingBox.Max = glm::vec3(-FLT_MAX);
for (const auto& vertex : vertices) {
glm::vec3 transformedPos = transform * glm::vec4(vertex.Position, 1.0f);
m_BoundingBox.Min = glm::min(m_BoundingBox.Min, transformedPos);
m_BoundingBox.Max = glm::max(m_BoundingBox.Max, transformedPos);
}
}
Mesh::~Mesh() = default;
@ -569,6 +612,24 @@ namespace Prism
*/
}
void Mesh::TraverseNodes(const aiNode* node, const glm::mat4& parentTransform, uint32_t level)
{
const glm::mat4 localTransform = parentTransform * Mat4FromAssimpMat4(node->mTransformation);
glm::mat4 transform = parentTransform * localTransform;
for (uint32_t i = 0; i < node->mNumMeshes; i++)
{
const uint32_t mesh = node->mMeshes[i];
auto& submesh = m_Submeshes[mesh];
submesh.NodeName = node->mName.C_Str();
submesh.Transform = transform;
submesh.LocalTransform = localTransform;
}
for (uint32_t i = 0; i < node->mNumChildren; i++)
{
TraverseNodes(node->mChildren[i], localTransform, level + 1);
}
}
void Mesh::DumpVertexBuffer()
{
@ -657,24 +718,6 @@ namespace Prism
}
*/
void Mesh::TraverseNodes(const aiNode* node, const glm::mat4& parentTransform, uint32_t level)
{
const glm::mat4 localTransform = parentTransform * Mat4FromAssimpMat4(node->mTransformation);
glm::mat4 transform = parentTransform * localTransform;
for (uint32_t i = 0; i < node->mNumMeshes; i++)
{
const uint32_t mesh = node->mMeshes[i];
auto& submesh = m_Submeshes[mesh];
submesh.NodeName = node->mName.C_Str();
submesh.Transform = transform;
submesh.LocalTransform = localTransform;
}
for (uint32_t i = 0; i < node->mNumChildren; i++)
{
TraverseNodes(node->mChildren[i], localTransform, level + 1);
}
}
/*
const aiNodeAnim* Mesh::FindNodeAnim(const aiAnimation* animation, const std::string& nodeName)

6
Prism/src/Prism/Renderer/Mesh.h
View File

@ -141,6 +141,9 @@ namespace Prism
{
return m_AnimatorController ? m_AnimatorController->GetFinalBoneTransforms() : m_EmptyTransforms;
}
const AABB& GetBoundingBox() const { return m_BoundingBox; }
private:
void TraverseNodes(const aiNode* node, const glm::mat4& parentTransform = glm::mat4(1.0f), uint32_t level = 0);
@ -182,6 +185,9 @@ namespace Prism
// float m_TimeMultiplier = 1.0f;
std::string m_FilePath;
AABB m_BoundingBox;
private:
friend class Renderer;
friend class SceneHierarchyPanel;

1
Prism/src/Prism/Renderer/RenderPass.h
View File

@ -20,6 +20,7 @@ namespace Prism
virtual ~RenderPass() = default;
virtual RenderPassSpecification& GetSpecification() = 0;
virtual const RenderPassSpecification& GetSpecification() const = 0;
static Ref<RenderPass> Create(const RenderPassSpecification& spec);
};

123
Prism/src/Prism/Renderer/Renderer.cpp
View File

@ -42,8 +42,8 @@ namespace Prism
// FullScreen Quad
static float fullScreenQuadVertex[] = {
-1.0f, -1.0f, 0.1f, 0.0f, 0.0f,
1.0f, -1.0f, 0.1f, 1.0f, 0.0f,
1.0f, 1.0f, 0.1f, 1.0f, 1.0f,
1.0f, -1.0f, 0.1f, 1.0f, 0.0f,
1.0f, 1.0f, 0.1f, 1.0f, 1.0f,
-1.0f, 1.0f, 0.1f, 0.0f, 1.0f
};
static uint32_t fullScreenQuadIndices[] = {
@ -66,7 +66,7 @@ namespace Prism
{
Submit([]()
{
RendererAPI::Clear(0.0f, 0.0f, 0.0f, 1.0f);
RendererAPI::Clear(0.0f, 0.0f, 0.0f, 1.0f);
});
}
@ -81,6 +81,13 @@ namespace Prism
{
}
Ref<ShaderLibrary> Renderer::GetShaderLibrary()
{
return s_Data.m_ShaderLibrary;
}
void Renderer::DrawIndexed(const uint32_t count, const PrimitiveType type, const bool depthTest, bool cullFace)
{
Submit([=]() {
@ -88,13 +95,6 @@ namespace Prism
});
}
Ref<ShaderLibrary> Renderer::GetShaderLibrary()
{
return s_Data.m_ShaderLibrary;
}
void Renderer::SetLineThickness(const float thickness)
{
Submit([=]() {
@ -135,7 +135,7 @@ namespace Prism
void Renderer::SubmitQuad(Ref<MaterialInstance>& material, const glm::mat4& transform)
{
bool depthTest = true;
bool cullFace = true;
bool cullFace = true;
if (material)
{
@ -172,6 +172,55 @@ namespace Prism
Renderer::DrawIndexed(6, PrimitiveType::Triangles, depthTest, cullFace);
}
void Renderer::SubmitMesh(Ref<Mesh>& mesh, const glm::mat4& transform, const std::vector<Ref<MaterialInstance>>& overrideMaterials)
{
// auto material = overrideMaterial ? overrideMaterial : mesh->GetMaterialInstance();
// auto shader = material->GetShader();
// TODO: Sort this out
mesh->m_VertexBuffer->Bind();
mesh->m_Pipeline->Bind();
mesh->m_IndexBuffer->Bind();
const auto& materials = mesh->GetMaterials();
for (Submesh& submesh : mesh->m_Submeshes)
{
// Material
auto material = overrideMaterials.empty() ? materials[submesh.MaterialIndex] : overrideMaterials[submesh.MaterialIndex];
auto shader = material->GetShader();
material->Bind();
if (mesh->m_IsAnimated)
{
const auto& boneTransform = mesh->GetBoneTransforms();
for (size_t i = 0; i < boneTransform.size(); i++)
{
std::string uniformName = std::string("u_BoneTransforms[") + std::to_string(i) + std::string("]");
shader->SetMat4(uniformName, boneTransform[i]);
}
}
shader->SetMat4("u_Transform", transform * submesh.Transform);
Renderer::Submit([submesh, material]() {
if (material->GetFlag(MaterialFlag::DepthTest))
{
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
}
else
glDisable(GL_DEPTH_TEST);
if (!material->GetFlag(MaterialFlag::TwoSided))
glEnable(GL_CULL_FACE);
else
glDisable(GL_CULL_FACE);
glDrawElementsBaseVertex(GL_TRIANGLES, submesh.IndexCount, GL_UNSIGNED_INT, (void*)(sizeof(uint32_t) * submesh.BaseIndex), submesh.BaseVertex);
});
}
}
void Renderer::SubmitMesh(Ref<Mesh>& mesh, const glm::mat4& transform, const Ref<MaterialInstance>& overrideMaterial)
{
// auto material = overrideMaterial ? overrideMaterial : mesh->GetMaterialInstance();
@ -246,32 +295,6 @@ namespace Prism
}
}
void Renderer::DrawAABB(const Ref<Mesh>& mesh, const glm::mat4& transform, const glm::vec4& color)
{
for (const Submesh& submesh : mesh->m_Submeshes)
{
const auto& aabb = submesh.BoundingBox;
auto aabbTransform = transform * submesh.Transform;
DrawAABB(aabb, aabbTransform, color);
}
}
void Renderer::DispatchCompute(int x, int y, int z)
{
Submit([x, y, z]()
{
RendererAPI::DispatchCompute(x, y, z);
});
}
void Renderer::MemoryBarrier(int barrier)
{
Submit([barrier]()
{
RendererAPI::MemoryBarrier(barrier);
});
}
void Renderer::DrawAABB(const AABB& aabb, const glm::mat4& transform, const glm::vec4& color)
{
glm::vec4 min = { aabb.Min.x, aabb.Min.y, aabb.Min.z, 1.0f };
@ -300,6 +323,32 @@ namespace Prism
Renderer2D::DrawLine(corners[i], corners[i + 4], color);
}
void Renderer::DrawAABB(const Ref<Mesh>& mesh, const glm::mat4& transform, const glm::vec4& color)
{
for (const Submesh& submesh : mesh->m_Submeshes)
{
const auto& aabb = submesh.BoundingBox;
auto aabbTransform = transform * submesh.Transform;
DrawAABB(aabb, aabbTransform, color);
}
}
void Renderer::DispatchCompute(int x, int y, int z)
{
Submit([x, y, z]()
{
RendererAPI::DispatchCompute(x, y, z);
});
}
void Renderer::MemoryBarrier(int barrier)
{
Submit([barrier]()
{
RendererAPI::MemoryBarrier(barrier);
});
}
RenderCommandQueue& Renderer::GetRenderCommandQueue()
{
return s_Data.m_CommandQueue;

3
Prism/src/Prism/Renderer/Renderer.h
View File

@ -54,7 +54,8 @@ namespace Prism
static void SubmitQuad(Ref<MaterialInstance>& material, const glm::mat4& transform = glm::mat4(1.0f));
static void SubmitFullscreenQuad(Ref<MaterialInstance> material);
static void SubmitMesh(Ref<Mesh>& mesh, const glm::mat4& transform, const Ref<MaterialInstance>& overrideMaterial = nullptr);
static void SubmitMesh(Ref<Mesh>& mesh, const glm::mat4& transform, const std::vector<Ref<MaterialInstance>>& overrideMaterials = {});
static void SubmitMesh(Ref<Mesh>& mesh, const glm::mat4& transform, const Ref<MaterialInstance>& overrideMaterial = nullptr);
static void SubmitMeshWithShader(Ref<Mesh> mesh, const glm::mat4& transform, Ref<Shader> shader);
static void DrawAABB(const AABB& aabb, const glm::mat4& transform, const glm::vec4& color = glm::vec4(1.0f));

180
Prism/src/Prism/Renderer/Renderer3D.cpp
View File

@ -100,7 +100,7 @@ namespace Prism
struct DrawCommand
{
Ref<Mesh> mesh;
Ref<MaterialInstance> Material;
std::vector<Ref<MaterialInstance>> MaterialInstances;
glm::mat4 Transform;
};
std::vector<DrawCommand> DrawList;
@ -128,6 +128,7 @@ namespace Prism
SceneRendererOptions Options;
Ref<TextureCube> BlackCubeTexture;
Ref<Texture2D> BlackTexture;
};
struct Renderer3DStats
@ -267,6 +268,7 @@ namespace Prism
uint32_t blackTextureData[6] = { 0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000 };
s_Data.BlackCubeTexture = TextureCube::Create(TextureFormat::RGBA, 1, 1, &blackTextureData);
s_Data.BlackTexture = Texture2D::Create(TextureFormat::RGBA, 1, 1, &blackTextureData[0]);
}
void Renderer3D::SetViewportSize(const uint32_t width, const uint32_t height)
@ -295,39 +297,39 @@ namespace Prism
FlushDrawList(renderPass);
}
void Renderer3D::SubmitMesh(const Ref<Mesh>& mesh, const glm::mat4& transform, const Ref<MaterialInstance>& overrideMaterial)
void Renderer3D::SubmitMesh(const Ref<Mesh>& mesh, const glm::mat4& transform, const std::vector<Ref<MaterialInstance>>& overrideMaterials)
{
// TODO: Culling, sorting, etc.
s_Data.DrawList.push_back({ mesh, overrideMaterial, transform });
s_Data.ShadowPassDrawList.push_back({ mesh, overrideMaterial, transform });
s_Data.DrawList.push_back({ mesh, overrideMaterials, transform });
s_Data.ShadowPassDrawList.push_back({ mesh, overrideMaterials, transform });
}
void Renderer3D::SubmitSelectedMesh(const Ref<Mesh>& mesh, const glm::mat4& transform)
void Renderer3D::SubmitSelectedMesh(const Ref<Mesh>& mesh, const glm::mat4& transform, const std::vector<Ref<MaterialInstance>>& overrideMaterials)
{
s_Data.SelectedMeshDrawList.push_back({ mesh, nullptr, transform });
s_Data.ShadowPassDrawList.push_back({ mesh, nullptr, transform });
s_Data.SelectedMeshDrawList.push_back({ mesh, overrideMaterials, transform });
s_Data.ShadowPassDrawList.push_back({ mesh, overrideMaterials, transform });
}
void Renderer3D::SubmitColliderMesh(const BoxColliderComponent& component, const glm::mat4& parentTransform)
{
s_Data.ColliderDrawList.push_back({ component.DebugMesh, nullptr, glm::translate(parentTransform, component.Offset)});
s_Data.ColliderDrawList.push_back({ component.DebugMesh, {}, glm::translate(parentTransform, component.Offset)});
}
void Renderer3D::SubmitColliderMesh(const SphereColliderComponent& component, const glm::mat4& parentTransform)
{
s_Data.ColliderDrawList.push_back({ component.DebugMesh, nullptr, parentTransform });
s_Data.ColliderDrawList.push_back({ component.DebugMesh, {}, parentTransform });
}
void Renderer3D::SubmitColliderMesh(const CapsuleColliderComponent& component, const glm::mat4& parentTransform)
{
s_Data.ColliderDrawList.push_back({ component.DebugMesh, nullptr, parentTransform });
s_Data.ColliderDrawList.push_back({ component.DebugMesh, {}, parentTransform });
}
void Renderer3D::SubmitColliderMesh(const MeshColliderComponent& component, const glm::mat4& parentTransform)
{
for (const auto debugMesh : component.ProcessedMeshes)
s_Data.ColliderDrawList.push_back({ debugMesh, nullptr, parentTransform });
for (const auto& debugMesh : component.ProcessedMeshes)
s_Data.ColliderDrawList.push_back({ debugMesh, {}, parentTransform });
}
// TODO: temp
@ -451,6 +453,11 @@ namespace Prism
return s_Data.BlackCubeTexture;
}
Ref<Texture2D> Renderer3D::GetBlackTexture()
{
return s_Data.BlackTexture;
}
void Renderer3D::FlushDrawList(Ref<RenderPass>& outRenderPass)
{
@ -468,24 +475,22 @@ namespace Prism
Renderer::Submit([] { s_Stats.GeometryPass = s_Stats.GeometryPassTimer.ElapsedMillis(); });
}
ResolveMSAA();
// Compute average luminance and update exposure (GPU-copy + mipmap -> read 1 texel)
{
Renderer::Submit([]() { s_Stats.AutoExposurePassTimer.Reset(); });
AutoExposurePass();
Renderer::Submit([] { s_Stats.AutoExposurePass = s_Stats.AutoExposurePassTimer.ElapsedMillis(); });
}
ResolveMSAA();
BloomBlurPass();
OverlayPass();
GridPass();
{
Renderer::Submit([]() { s_Stats.CompositePassTimer.Reset(); });
CompositePass(outRenderPass);
Renderer::Submit([] { s_Stats.CompositePass = s_Stats.CompositePassTimer.ElapsedMillis(); });
// BloomBlurPass();
}
s_Data.DrawList.clear();
@ -655,19 +660,6 @@ namespace Prism
baseMaterial->Set("u_ViewProjectionMatrix", cameraViewProjection);
baseMaterial->Set("u_ViewMatrix", sceneCamera.ViewMatrix);
baseMaterial->Set("u_CameraPosition", cameraPosition);
// baseMaterial->Set("u_LightMatrixCascade0", s_Data.LightMatrices[0]);
// baseMaterial->Set("u_LightMatrixCascade1", s_Data.LightMatrices[1]);
// baseMaterial->Set("u_LightMatrixCascade2", s_Data.LightMatrices[2]);
// baseMaterial->Set("u_LightMatrixCascade3", s_Data.LightMatrices[3]);
// baseMaterial->Set("u_ShowCascades", s_Data.ShowCascades);
// baseMaterial->Set("u_LightView", s_Data.LightViewMatrix);
// baseMaterial->Set("u_CascadeSplits", s_Data.CascadeSplits);
// baseMaterial->Set("u_SoftShadows", s_Data.SoftShadows);
// baseMaterial->Set("u_LightSize", s_Data.LightSize);
// baseMaterial->Set("u_MaxShadowDistance", s_Data.MaxShadowDistance);
// baseMaterial->Set("u_ShadowFade", s_Data.ShadowFade);
// baseMaterial->Set("u_CascadeFading", s_Data.CascadeFading);
// baseMaterial->Set("u_CascadeTransitionFade", s_Data.CascadeTransitionFade);
baseMaterial->Set("u_IBLContribution", s_Data.SceneData.SceneEnvironmentIntensity);
// Environment (TODO: don't do this per mesh)
@ -704,38 +696,7 @@ namespace Prism
});
}
/*
auto rd = baseMaterial->FindResourceDeclaration("u_ShadowMapTexture");
if (rd)
{
auto reg = rd->GetRegister();
auto tex = s_Data.ShadowMapRenderPass[0]->GetSpecification().TargetFramebuffer->GetDepthAttachmentRendererID();
auto tex1 = s_Data.ShadowMapRenderPass[1]->GetSpecification().TargetFramebuffer->GetDepthAttachmentRendererID();
auto tex2 = s_Data.ShadowMapRenderPass[2]->GetSpecification().TargetFramebuffer->GetDepthAttachmentRendererID();
auto tex3 = s_Data.ShadowMapRenderPass[3]->GetSpecification().TargetFramebuffer->GetDepthAttachmentRendererID();
Renderer::Submit([reg, tex, tex1, tex2, tex3]() mutable
{
// 4 cascades
glBindTextureUnit(reg, tex);
glBindSampler(reg++, s_Data.ShadowMapSampler);
glBindTextureUnit(reg, tex1);
glBindSampler(reg++, s_Data.ShadowMapSampler);
glBindTextureUnit(reg, tex2);
glBindSampler(reg++, s_Data.ShadowMapSampler);
glBindTextureUnit(reg, tex3);
glBindSampler(reg++, s_Data.ShadowMapSampler);
});
}
*/
constexpr auto overrideMaterial = nullptr; // dc.Material;
Renderer::SubmitMesh(dc.mesh, dc.Transform, overrideMaterial);
Renderer::SubmitMesh(dc.mesh, dc.Transform, dc.MaterialInstances);
}
if (outline)
@ -752,14 +713,6 @@ namespace Prism
baseMaterial->Set("u_ViewProjectionMatrix", cameraViewProjection);
baseMaterial->Set("u_ViewMatrix", sceneCamera.ViewMatrix);
baseMaterial->Set("u_CameraPosition", cameraPosition);
// baseMaterial->Set("u_CascadeSplits", s_Data.CascadeSplits);
// baseMaterial->Set("u_ShowCascades", s_Data.ShowCascades);
// baseMaterial->Set("u_SoftShadows", s_Data.SoftShadows);
// baseMaterial->Set("u_LightSize", s_Data.LightSize);
// baseMaterial->Set("u_MaxShadowDistance", s_Data.MaxShadowDistance);
// baseMaterial->Set("u_ShadowFade", s_Data.ShadowFade);
// baseMaterial->Set("u_CascadeFading", s_Data.CascadeFading);
// baseMaterial->Set("u_CascadeTransitionFade", s_Data.CascadeTransitionFade);
baseMaterial->Set("u_IBLContribution", s_Data.SceneData.SceneEnvironmentIntensity);
@ -768,11 +721,6 @@ namespace Prism
baseMaterial->Set("u_EnvIrradianceTex", s_Data.SceneData.SceneEnvironment->IrradianceMap);
baseMaterial->Set("u_BRDFLUTTexture", s_Data.BRDFLUT);
// baseMaterial->Set("u_LightMatrixCascade0", s_Data.LightMatrices[0]);
// baseMaterial->Set("u_LightMatrixCascade1", s_Data.LightMatrices[1]);
// baseMaterial->Set("u_LightMatrixCascade2", s_Data.LightMatrices[2]);
// baseMaterial->Set("u_LightMatrixCascade3", s_Data.LightMatrices[3]);
// Set lights (TODO: move to light environment and don't do per mesh)
baseMaterial->Set("u_DirectionalLights", s_Data.SceneData.SceneLightEnvironment.DirectionalLights[0]);
baseMaterial->Set("u_PointLightCount", s_Data.SceneData.SceneLightEnvironment.PointLightCount);
@ -801,37 +749,8 @@ namespace Prism
glBindSampler(reg, s_Data.ShadowMapSampler);
});
}
/*
auto rd = baseMaterial->FindResourceDeclaration("u_ShadowMapTexture");
if (rd)
{
auto reg = rd->GetRegister();
auto tex = s_Data.ShadowMapRenderPass[0]->GetSpecification().TargetFramebuffer->GetDepthAttachmentRendererID();
auto tex1 = s_Data.ShadowMapRenderPass[1]->GetSpecification().TargetFramebuffer->GetDepthAttachmentRendererID();
auto tex2 = s_Data.ShadowMapRenderPass[2]->GetSpecification().TargetFramebuffer->GetDepthAttachmentRendererID();
auto tex3 = s_Data.ShadowMapRenderPass[3]->GetSpecification().TargetFramebuffer->GetDepthAttachmentRendererID();
Renderer::Submit([reg, tex, tex1, tex2, tex3]() mutable
{
// 4 cascades
glBindTextureUnit(reg, tex);
glBindSampler(reg++, s_Data.ShadowMapSampler);
glBindTextureUnit(reg, tex1);
glBindSampler(reg++, s_Data.ShadowMapSampler);
glBindTextureUnit(reg, tex2);
glBindSampler(reg++, s_Data.ShadowMapSampler);
glBindTextureUnit(reg, tex3);
glBindSampler(reg++, s_Data.ShadowMapSampler);
});
}
*/
constexpr auto overrideMaterial = nullptr; // dc.Material;
Renderer::SubmitMesh(dc.mesh, dc.Transform, overrideMaterial);
Renderer::SubmitMesh(dc.mesh, dc.Transform, dc.MaterialInstances);
}
@ -881,9 +800,6 @@ namespace Prism
{
Renderer::Submit([]()
{
// glStencilFunc(GL_NOTEQUAL, 1, 0xff);
// glStencilMask(0);
glLineWidth(1);
glEnable(GL_LINE_SMOOTH);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
@ -912,8 +828,6 @@ namespace Prism
Renderer::Submit([]()
{
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// glStencilMask(0xff);
// glStencilFunc(GL_ALWAYS, 1, 0xff);
glEnable(GL_DEPTH_TEST);
});
}
@ -976,11 +890,6 @@ namespace Prism
Renderer::EndRenderPass();
}
// 将最终模糊结果拷贝到 BloomBlendPass（供合成使用）
uint32_t finalBlurTex = (iterations % 2 == 0) ?
s_Data.BloomBlurPass[1]->GetSpecification().TargetFramebuffer->GetColorAttachmentRendererID() :
s_Data.BloomBlurPass[0]->GetSpecification().TargetFramebuffer->GetColorAttachmentRendererID();
Renderer::BeginRenderPass(s_Data.BloomBlendPass);
s_Data.BloomBlurShader->Bind();
s_Data.BloomBlurShader->SetInt("u_Texture", 0);
@ -994,12 +903,16 @@ namespace Prism
Renderer::EndRenderPass();
}
void Renderer3D::OverlayPass()
void Renderer3D::GridPass()
{
Renderer::BeginRenderPass(s_Data.GeoPass, false);
if (const auto option = GetOptions(); option.ShowGrid)
{
Renderer::Submit([]() {
glDepthMask(GL_FALSE);
});
const auto& sceneCamera = s_Data.SceneData.SceneCamera;
const auto cameraProjection = sceneCamera.Camera.GetProjectionMatrix();
@ -1019,6 +932,10 @@ namespace Prism
s_Data.GridData.GridMaterial->Set("u_FadeDistance", s_Data.GridData.FadeDistance);
Renderer::SubmitFullscreenQuad(s_Data.GridData.GridMaterial);
Renderer::Submit([]() {
glDepthMask(GL_TRUE);
});
}
Renderer::EndRenderPass();
@ -1043,6 +960,18 @@ namespace Prism
void Renderer3D::CompositePass(const Ref<RenderPass>& outRenderPass)
{
Renderer::Submit([srcFB = s_Data.GeoPass->GetSpecification().TargetFramebuffer,
dstFB = outRenderPass->GetSpecification().TargetFramebuffer]()
{
glBindFramebuffer(GL_READ_FRAMEBUFFER, srcFB->GetRendererID());
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, dstFB->GetRendererID());
glBlitFramebuffer(0, 0, srcFB->GetWidth(), srcFB->GetHeight(),
0, 0, dstFB->GetWidth(), dstFB->GetHeight(),
GL_DEPTH_BUFFER_BIT, GL_NEAREST);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
});
Renderer::BeginRenderPass(outRenderPass);
s_Data.CompositeShader->Bind();
@ -1054,10 +983,8 @@ namespace Prism
s_Data.CompositeShader->SetBool("u_EnableBloom", s_Data.EnableBloom);
// 绑定几何阶段颜色纹理（多重采样）
s_Data.GeoPass->GetSpecification().TargetFramebuffer->BindTexture(0); // 通常绑定到单元0
Renderer::Submit([]() {
glBindTextureUnit(1, s_Data.GeoPass->GetSpecification().TargetFramebuffer->GetDepthAttachmentRendererID());
});
s_Data.GeoPass->GetSpecification().TargetFramebuffer->BindTexture();
s_Data.GeoPass->GetSpecification().TargetFramebuffer->BindDepthTexture(1);
if (s_Data.EnableBloom)
{
@ -1216,19 +1143,6 @@ namespace Prism
UI::EndTreeNode();
}
/*
if (UI::BeginTreeNode("Auto Exposure", false))
{
UI::BeginPropertyGrid();
UI::Property("Enable Auto Exposure", s_Data.AutoExposureData.EnableAutoExposure);
UI::Property("Key (middle gray)", s_Data.AutoExposureData.Key, 0.001f, 0.001f, 2.5f);
UI::Property("Adaptation Speed", s_Data.AutoExposureData.AdaptationSpeed, 0.01f, 0.001f, 5.0f);
UI::Property("Current Exposure", s_Data.AutoExposureData.CurrentExposure, 0.01f, 0.0f, 0.0f, true);
UI::EndPropertyGrid();
UI::EndTreeNode();
}
*/
if (UI::BeginTreeNode("Auto Exposure", false))
{

7
Prism/src/Prism/Renderer/Renderer3D.h
View File

@ -33,8 +33,8 @@ namespace Prism
static void BeginScene(const Scene* scene, const SceneRendererCamera& camera);
static void EndScene(Ref<RenderPass>& renderPass);
static void SubmitMesh(const Ref<Mesh>& mesh, const glm::mat4& transform = glm::mat4(1.0f), const Ref<MaterialInstance>& overrideMaterial = nullptr);
static void SubmitSelectedMesh(const Ref<Mesh>& mesh, const glm::mat4& transform = glm::mat4(1.0f));
static void SubmitMesh(const Ref<Mesh>& mesh, const glm::mat4& transform = glm::mat4(1.0f), const std::vector<Ref<MaterialInstance>>& overrideMaterials = {});
static void SubmitSelectedMesh(const Ref<Mesh>& mesh, const glm::mat4& transform = glm::mat4(1.0f), const std::vector<Ref<MaterialInstance>>& overrideMaterials = {});
static void SubmitColliderMesh(const BoxColliderComponent& component, const glm::mat4& parentTransform = glm::mat4(1.0f));
static void SubmitColliderMesh(const SphereColliderComponent& component, const glm::mat4& parentTransform = glm::mat4(1.0f));
@ -54,6 +54,7 @@ namespace Prism
static SceneRendererOptions& GetOptions();
static Ref<TextureCube> GetBlackCubeTexture();
static Ref<Texture2D> GetBlackTexture();
private:
static void FlushDrawList(Ref<RenderPass>& outRenderPass);
@ -62,7 +63,7 @@ namespace Prism
static void ShadowMapPass();
static void GeometryPass();
static void BloomBlurPass();
static void OverlayPass();
static void GridPass();
static void CompositePass(const Ref<RenderPass>& outRenderPass);

16
Prism/src/Prism/Renderer/SceneRenderer.cpp
View File

@ -142,14 +142,14 @@ namespace Prism
//////////////////// 3D API ////////////////////
void SceneRenderer::SubmitMesh(const Ref<Mesh>& mesh, const glm::mat4& transform, const Ref<MaterialInstance>& overrideMaterial)
void SceneRenderer::SubmitMesh(const Ref<Mesh>& mesh, const glm::mat4& transform, const std::vector<Ref<MaterialInstance>>& overrideMaterials)
{
Renderer3D::SubmitMesh(mesh, transform, overrideMaterial);
Renderer3D::SubmitMesh(mesh, transform, overrideMaterials);
}
void SceneRenderer::SubmitSelectedMesh(const Ref<Mesh>& mesh, const glm::mat4& transform)
void SceneRenderer::SubmitSelectedMesh(const Ref<Mesh>& mesh, const glm::mat4& transform, const std::vector<Ref<MaterialInstance>>& overrideMaterials)
{
Renderer3D::SubmitSelectedMesh(mesh, transform);
Renderer3D::SubmitSelectedMesh(mesh, transform, overrideMaterials);
}
void SceneRenderer::SubmitColliderMesh(const BoxColliderComponent& component, const glm::mat4& parentTransform)
@ -222,10 +222,10 @@ namespace Prism
glBindFramebuffer(GL_READ_FRAMEBUFFER, fb->GetColorAttachmentRendererID());
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
glBlitFramebuffer(0, 0, fbWidth, fbHeight, // 源矩形
0, 0, fbWidth, fbHeight, // 目标矩形
GL_COLOR_BUFFER_BIT, // 只复制颜色缓冲
GL_NEAREST); // 过滤器
glBlitFramebuffer(0, 0, fbWidth, fbHeight,
0, 0, fbWidth, fbHeight,
GL_COLOR_BUFFER_BIT,
GL_NEAREST);
});
}
}

4
Prism/src/Prism/Renderer/SceneRenderer.h
View File

@ -70,8 +70,8 @@ namespace Prism
// Renderer3D
static void SubmitMesh(const Ref<Mesh>& mesh, const glm::mat4& transform = glm::mat4(1.0f), const Ref<MaterialInstance>& overrideMaterial = nullptr);
static void SubmitSelectedMesh(const Ref<Mesh>& mesh, const glm::mat4& transform = glm::mat4(1.0f));
static void SubmitMesh(const Ref<Mesh>& mesh, const glm::mat4& transform = glm::mat4(1.0f), const std::vector<Ref<MaterialInstance>>& overrideMaterials = {});
static void SubmitSelectedMesh(const Ref<Mesh>& mesh, const glm::mat4& transform = glm::mat4(1.0f), const std::vector<Ref<MaterialInstance>>& overrideMaterials = {});
static void SubmitColliderMesh(const BoxColliderComponent& component, const glm::mat4& parentTransform = glm::mat4(1.0f));
static void SubmitColliderMesh(const SphereColliderComponent& component, const glm::mat4& parentTransform = glm::mat4(1.0f));

10
Prism/src/Prism/Renderer/Texture.cpp
View File

@ -38,6 +38,16 @@ namespace Prism
return nullptr;
}
Ref<Texture2D> Texture2D::Create(TextureFormat format, unsigned int width, unsigned int height, const void* data, TextureWrap wrap)
{
switch (RendererAPI::Current())
{
case RendererAPIType::None: return nullptr;
case RendererAPIType::OpenGL: return Ref<OpenGLTexture2D>::Create(format, width, height, data, wrap);
}
return nullptr;
}
Ref<Texture2D> Texture2D::Create(const std::string& path, bool srgb)
{

3
Prism/src/Prism/Renderer/Texture.h
View File

@ -5,9 +5,9 @@
#ifndef TEXTURE_H
#define TEXTURE_H
#include "RendererAPI.h"
#include "Prism/Asset/Asset.h"
#include "Prism/Core/Buffer.h"
#include "Prism/Core/Ref.h"
#include "../Asset/Asset.h"
namespace Prism
@ -53,6 +53,7 @@ namespace Prism
{
public:
static Ref<Texture2D> Create(TextureFormat format, unsigned int width, unsigned int height, TextureWrap wrap = TextureWrap::Clamp);
static Ref<Texture2D> Create(TextureFormat format, unsigned int width, unsigned int height, const void* data, TextureWrap wrap = TextureWrap::Clamp);
static Ref<Texture2D> Create(const std::string& path, bool srgb = false);

123
Prism/src/Prism/Scene/Components.h
View File

@ -81,8 +81,9 @@ namespace Prism
}
glm::mat4 GetTransform() const
{
return glm::translate(glm::mat4(1.0f), Translation)
* glm::toMat4(glm::quat((Rotation)))
* glm::toMat4(glm::quat(Rotation))
* glm::scale(glm::mat4(1.0f), Scale);
}
};
@ -91,32 +92,112 @@ namespace Prism
struct MeshComponent
{
Ref<Mesh> Mesh;
// std::vector<Ref<MaterialInstance>> Materials;
std::vector<Ref<MaterialInstance>> MaterialInstances;
std::vector<Ref<PBRMaterialAsset>> MaterialDescs;
MeshComponent() = default;
MeshComponent(const MeshComponent& other) = default;
MeshComponent(const MeshComponent& other)
: Mesh(other.Mesh)
{
MaterialInstances.clear();
MaterialDescs.clear();
for (auto i = 0; i < other.MaterialInstances.size(); i ++)
{
Ref<MaterialInstance> materialInstance = MaterialInstance::Copy(other.MaterialInstances[i]);
MaterialInstances.push_back(materialInstance);
MaterialDescs.push_back(other.MaterialDescs[i]);
}
UpdateMaterials();
}
MeshComponent(const Ref<Prism::Mesh>& mesh)
: Mesh(mesh) {}
operator Ref<Prism::Mesh> () { return Mesh; }
/*
MeshComponent(Ref<Prism::Mesh> mesh)
: Mesh(mesh)
{
// 复制 Mesh 的材质实例，每个实体拥有独立副本
if (mesh)
MaterialInstances.clear();
MaterialDescs.clear();
const auto& materialInstances = Mesh->GetMaterials();
for (const auto & i : materialInstances)
{
const auto& srcMaterials = mesh->GetMaterials();
Materials.reserve(srcMaterials.size());
for (auto& srcMat : srcMaterials)
Ref<MaterialInstance> materialInstance = MaterialInstance::Copy(i);
MaterialInstances.push_back(materialInstance);
}
MaterialDescs.resize(materialInstances.size());
}
void UpdateMaterials(const int index = -1, bool forceUpdate = false)
{
if (index <= -1)
{
for (uint32_t i = 0; i < MaterialInstances.size(); i++)
{
auto newMat = MaterialInstance::Copy(srcMat);
Materials.push_back(newMat);
if (auto& desc = MaterialDescs[i])
{
if (!desc->IsDirty && !forceUpdate) continue;
MaterialInstances[i]->Set("u_AlbedoColor", desc->AlbedoColor);
MaterialInstances[i]->Set("u_AlbedoTexToggle", desc->AlbedoTexToggle);
MaterialInstances[i]->Set("u_AlbedoTexture", desc->AlbedoTexture);
MaterialInstances[i]->Set("u_NormalTexToggle", desc->NormalTexToggle);
MaterialInstances[i]->Set("u_NormalTexture", desc->NormalTexture);
MaterialInstances[i]->Set("u_Metalness", desc->Metalness);
MaterialInstances[i]->Set("u_MetalnessTexToggle", desc->MetalnessTexToggle);
MaterialInstances[i]->Set("u_MetalnessTexture", desc->MetalnessTexture);
MaterialInstances[i]->Set("u_Roughness", desc->Roughness);
MaterialInstances[i]->Set("u_RoughnessTexToggle", desc->RoughnessTexToggle);
MaterialInstances[i]->Set("u_RoughnessTexture", desc->RoughnessTexture);
}else
{
auto& baseMaterial = Mesh->GetMaterials();
MaterialInstances[i]->Set("u_AlbedoColor", baseMaterial[i]->Get<glm::vec3>("u_AlbedoColor"));
MaterialInstances[i]->Set("u_AlbedoTexToggle", baseMaterial[i]->Get<float>("u_AlbedoTexToggle"));
MaterialInstances[i]->Set("u_AlbedoTexture", baseMaterial[i]->TryGetResource<Texture2D>("u_AlbedoTexture"));
MaterialInstances[i]->Set("u_NormalTexToggle", baseMaterial[i]->Get<float>("u_NormalTexToggle"));
MaterialInstances[i]->Set("u_NormalTexture", baseMaterial[i]->TryGetResource<Texture2D>("u_NormalTexture"));
MaterialInstances[i]->Set("u_Metalness", baseMaterial[i]->Get<float>("u_Metalness"));
MaterialInstances[i]->Set("u_MetalnessTexToggle", baseMaterial[i]->Get<float>("u_MetalnessTexToggle"));
MaterialInstances[i]->Set("u_MetalnessTexture", baseMaterial[i]->TryGetResource<Texture2D>("u_MetalnessTexture"));
MaterialInstances[i]->Set("u_Roughness", baseMaterial[0]->Get<float>("u_Roughness"));
MaterialInstances[i]->Set("u_RoughnessTexToggle", baseMaterial[i]->Get<float>("u_RoughnessTexToggle"));
MaterialInstances[i]->Set("u_RoughnessTexture", baseMaterial[i]->TryGetResource<Texture2D>("u_RoughnessTexture"));
}
}
}else
{
if (index >= MaterialInstances.size()) return;
const auto& desc = MaterialDescs[index];
if (desc)
{
MaterialInstances[index]->Set("u_AlbedoColor", desc->AlbedoColor);
MaterialInstances[index]->Set("u_AlbedoTexToggle", desc->AlbedoTexToggle);
MaterialInstances[index]->Set("u_AlbedoTexture", desc->AlbedoTexture);
MaterialInstances[index]->Set("u_NormalTexToggle", desc->NormalTexToggle);
MaterialInstances[index]->Set("u_NormalTexture", desc->NormalTexture);
MaterialInstances[index]->Set("u_Metalness", desc->Metalness);
MaterialInstances[index]->Set("u_MetalnessTexToggle", desc->MetalnessTexToggle);
MaterialInstances[index]->Set("u_MetalnessTexture", desc->MetalnessTexture);
MaterialInstances[index]->Set("u_Roughness", desc->Roughness);
MaterialInstances[index]->Set("u_RoughnessTexToggle", desc->RoughnessTexToggle);
MaterialInstances[index]->Set("u_RoughnessTexture", desc->RoughnessTexture);
}else
{
auto& baseMaterial = Mesh->GetMaterials();
MaterialInstances[index]->Set("u_AlbedoColor", baseMaterial[index]->Get<glm::vec3>("u_AlbedoColor"));
MaterialInstances[index]->Set("u_AlbedoTexToggle", baseMaterial[index]->Get<float>("u_AlbedoTexToggle"));
MaterialInstances[index]->Set("u_AlbedoTexture", baseMaterial[index]->TryGetResource<Texture2D>("u_AlbedoTexture"));
MaterialInstances[index]->Set("u_NormalTexToggle", baseMaterial[index]->Get<float>("u_NormalTexToggle"));
MaterialInstances[index]->Set("u_NormalTexture", baseMaterial[index]->TryGetResource<Texture2D>("u_NormalTexture"));
MaterialInstances[index]->Set("u_Metalness", baseMaterial[index]->Get<float>("u_Metalness"));
MaterialInstances[index]->Set("u_MetalnessTexToggle", baseMaterial[index]->Get<float>("u_MetalnessTexToggle"));
MaterialInstances[index]->Set("u_MetalnessTexture", baseMaterial[index]->TryGetResource<Texture2D>("u_MetalnessTexture"));
MaterialInstances[index]->Set("u_Roughness", baseMaterial[0]->Get<float>("u_Roughness"));
MaterialInstances[index]->Set("u_RoughnessTexToggle", baseMaterial[index]->Get<float>("u_RoughnessTexToggle"));
MaterialInstances[index]->Set("u_RoughnessTexture", baseMaterial[index]->TryGetResource<Texture2D>("u_RoughnessTexture"));
}
}
}
*/
operator Ref<Prism::Mesh> () { return Mesh; }
};
struct AnimationComponent
@ -305,7 +386,7 @@ namespace Prism
{
float Radius = 0.5f;
bool IsTrigger = false;
Ref<PhysicsMaterial> Material;
Ref<PhysicsMaterialAsset> Material;
// The mesh that will be drawn in the editor to show the collision bounds
Ref<Mesh> DebugMesh;
@ -344,7 +425,7 @@ namespace Prism
glm::vec3 Size = { 1.0f, 1.0f, 1.0f };
glm::vec3 Offset = { 0.0f, 0.0f, 0.0f };
bool IsTrigger = false;
Ref<PhysicsMaterial> Material;
Ref<PhysicsMaterialAsset> Material;
// The mesh that will be drawn in the editor to show the collision bounds
Ref<Mesh> DebugMesh;
@ -358,7 +439,7 @@ namespace Prism
float Radius = 0.5f;
float Height = 1.0f;
bool IsTrigger = false;
Ref<PhysicsMaterial> Material;
Ref<PhysicsMaterialAsset> Material;
Ref<Mesh> DebugMesh;
@ -373,7 +454,7 @@ namespace Prism
bool IsConvex = false;
bool IsTrigger = false;
bool OverrideMesh = false;
Ref<PhysicsMaterial> Material;
Ref<PhysicsMaterialAsset> Material;
MeshColliderComponent() = default;
MeshColliderComponent(const MeshColliderComponent& other) = default;

48
Prism/src/Prism/Scene/Scene.cpp
View File

@ -81,6 +81,7 @@ namespace Prism
{
b2DestroyWorld(m_Registry.get<Box2DWorldComponent>(m_SceneEntity).World);
Physics3D::DestroyScene();
ScriptEngine::OnSceneDestruct(m_SceneID);
}
void Scene::OnUpdate(TimeStep ts)
@ -90,14 +91,14 @@ namespace Prism
const auto sceneView = m_Registry.view<Box2DWorldComponent>();
const auto& box2DWorld = m_Registry.get<Box2DWorldComponent>(sceneView.front()).World;
int32_t velocityIterations = 6;
constexpr int32_t positionIterations = 2;
// box2DWorld->Step(ts, velocityIterations, positionIterations);
b2World_Step(box2DWorld, ts, positionIterations);
// Process Contact Envents box2d version 3.0^ should impl contact event after b2World_Step
Physics2D::ProcessContactEvents(box2DWorld);
// Physics3D
Physics3D::Simulate(ts);
{
const auto view = m_Registry.view<RigidBody2DComponent>();
for (const auto entity : view)
@ -137,8 +138,6 @@ namespace Prism
}
Physics3D::Simulate(ts);
// Update all entities
{
const auto view = m_Registry.view<ScriptComponent>();
@ -149,6 +148,7 @@ namespace Prism
ScriptEngine::OnUpdateEntity(e, ts);
}
}
}
void Scene::OnRenderRuntime(const TimeStep ts)
@ -188,19 +188,35 @@ namespace Prism
SceneRenderer::BeginScene(this, { static_cast<Camera>(camera), cameraViewMatrix }, false);
{
const auto group = m_Registry.group<MeshComponent>(entt::get<TransformComponent>);
// this maybe not to set
// in Editor actually only one materialdesc will be changed
Ref<PBRMaterialAsset> materialAsset;
for (const auto entity : group)
{
const auto& [transformComponent, meshComponent] = group.get<TransformComponent, MeshComponent>(entity);
if (meshComponent.Mesh)
{
for (auto i = 0; i < meshComponent.MaterialInstances.size(); i++)
{
if (meshComponent.MaterialDescs[i] && meshComponent.MaterialDescs[i]->IsDirty)
{
materialAsset = meshComponent.MaterialDescs[i];
meshComponent.UpdateMaterials(i);
}
}
meshComponent.Mesh->OnUpdate(ts);
glm::mat4 transform = GetTransformRelativeToParent(Entity(entity, this));
// TODO: Should we render (logically)
SceneRenderer::SubmitMesh(meshComponent, transform);
SceneRenderer::SubmitMesh(meshComponent, transform, meshComponent.MaterialInstances);
}
}
if (materialAsset) materialAsset->IsDirty = false;
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
@ -271,21 +287,35 @@ namespace Prism
const auto group = m_Registry.group<MeshComponent>(entt::get<TransformComponent>);
{
// in Editor actually only one materialdesc will be changed
Ref<PBRMaterialAsset> materialAsset;
for (const auto [entity, meshComponent, transformComponent]: group.each())
{
Entity e = {entity, this};
if (meshComponent.Mesh)
{
for (auto i = 0; i < meshComponent.MaterialInstances.size(); i++)
{
if (meshComponent.MaterialDescs[i] && meshComponent.MaterialDescs[i]->IsDirty)
{
materialAsset = meshComponent.MaterialDescs[i];
meshComponent.UpdateMaterials(i);
}
}
meshComponent.Mesh->OnUpdate(ts);
glm::mat4 transform = GetTransformRelativeToParent(e);
// TODO: Should we render (logically)
if (m_SelectedEntity == entity)
SceneRenderer::SubmitSelectedMesh(meshComponent, transform);
SceneRenderer::SubmitSelectedMesh(meshComponent, transform, meshComponent.MaterialInstances);
else
SceneRenderer::SubmitMesh(meshComponent, transform);
SceneRenderer::SubmitMesh(meshComponent, transform, meshComponent.MaterialInstances);
}
// Renderer Collider
@ -303,6 +333,8 @@ namespace Prism
SceneRenderer::SubmitColliderMesh(*collider, transform);
}
}
if (materialAsset) materialAsset->IsDirty = false;
}
/////////////////////////////////////////////////////////////////////

2
Prism/src/Prism/Scene/Scene.h
View File

@ -169,7 +169,7 @@ namespace Prism
Ref<TextureCube> m_SkyboxTexture;
Ref<MaterialInstance> m_SkyboxMaterial;
float m_SkyboxLod = 1.0f;
float m_SkyboxLod = 0.0f;
Ref<Texture2D> m_CameraIcon;

229
Prism/src/Prism/Scene/SceneSerializer.cpp
View File

@ -13,142 +13,13 @@
#include "Prism/Physics/PhysicsLayer.h"
#include "Prism/Physics/PhysicsWrappers.h"
#include "Prism/Renderer/Meshfactory.h"
#include "../Asset/AssetsManager.h"
#include "Prism/Asset/AssetsManager.h"
namespace YAML
{
template<>
struct convert<glm::vec2>
{
static Node encode(const glm::vec2& rhs)
{
Node node;
node.push_back(rhs.x);
node.push_back(rhs.y);
return node;
}
static bool decode(const Node& node, glm::vec2& rhs)
{
if (!node.IsSequence() || node.size() != 2)
return false;
rhs.x = node[0].as<float>();
rhs.y = node[1].as<float>();
return true;
}
};
template<>
struct convert<glm::vec3>
{
static Node encode(const glm::vec3& rhs)
{
Node node;
node.push_back(rhs.x);
node.push_back(rhs.y);
node.push_back(rhs.z);
return node;
}
static bool decode(const Node& node, glm::vec3& rhs)
{
if (!node.IsSequence() || node.size() != 3)
return false;
rhs.x = node[0].as<float>();
rhs.y = node[1].as<float>();
rhs.z = node[2].as<float>();
return true;
}
};
template<>
struct convert<glm::vec4>
{
static Node encode(const glm::vec4& rhs)
{
Node node;
node.push_back(rhs.x);
node.push_back(rhs.y);
node.push_back(rhs.z);
node.push_back(rhs.w);
return node;
}
static bool decode(const Node& node, glm::vec4& rhs)
{
if (!node.IsSequence() || node.size() != 4)
return false;
rhs.x = node[0].as<float>();
rhs.y = node[1].as<float>();
rhs.z = node[2].as<float>();
rhs.w = node[3].as<float>();
return true;
}
};
template<>
struct convert<glm::quat>
{
static Node encode(const glm::quat& rhs)
{
Node node;
node.push_back(rhs.w);
node.push_back(rhs.x);
node.push_back(rhs.y);
node.push_back(rhs.z);
return node;
}
static bool decode(const Node& node, glm::quat& rhs)
{
if (!node.IsSequence() || node.size() != 4)
return false;
rhs.w = node[0].as<float>();
rhs.x = node[1].as<float>();
rhs.y = node[2].as<float>();
rhs.z = node[3].as<float>();
return true;
}
};
}
#include "Prism/Utilities/SerializeUtils.h"
namespace Prism
{
YAML::Emitter& operator<<(YAML::Emitter& out, const glm::vec2& v)
{
out << YAML::Flow;
out << YAML::BeginSeq << v.x << v.y << YAML::EndSeq;
return out;
}
YAML::Emitter& operator<<(YAML::Emitter& out, const glm::vec3& v)
{
out << YAML::Flow;
out << YAML::BeginSeq << v.x << v.y << v.z << YAML::EndSeq;
return out;
}
YAML::Emitter& operator<<(YAML::Emitter& out, const glm::vec4& v)
{
out << YAML::Flow;
out << YAML::BeginSeq << v.x << v.y << v.z << v.w << YAML::EndSeq;
return out;
}
YAML::Emitter& operator<<(YAML::Emitter& out, const glm::quat& v)
{
out << YAML::Flow;
out << YAML::BeginSeq << v.w << v.x << v.y << v.z << YAML::EndSeq;
return out;
}
SceneSerializer::SceneSerializer(const Ref<Scene>& scene)
: m_Scene(scene)
{
@ -163,7 +34,7 @@ namespace Prism
if (entity.HasComponent<RelationshipComponent>())
{
auto& relationshipComponent = entity.GetComponent<RelationshipComponent>();
const auto& relationshipComponent = entity.GetComponent<RelationshipComponent>();
out << YAML::Key << "Parent" << YAML::Value << relationshipComponent.ParentHandle;
out << YAML::Key << "Children";
@ -258,11 +129,38 @@ namespace Prism
out << YAML::Key << "MeshComponent";
out << YAML::BeginMap; // MeshComponent
const auto mesh = entity.GetComponent<MeshComponent>().Mesh;
if (mesh)
const auto& meshComponent = entity.GetComponent<MeshComponent>();
if (meshComponent.Mesh)
{
const auto& mesh = meshComponent.Mesh;
out << YAML::Key << "AssetID" << YAML::Value << mesh->Handle;
out << YAML::Key << "AssetPath" << YAML::Value << mesh->FilePath;
if (!meshComponent.MaterialDescs.empty())
{
out << YAML::Key << "Materials";
out << YAML::BeginMap;
for (auto i = 0; i < meshComponent.MaterialDescs.size(); ++i)
{
{
std::string slots = "Slot " + std::to_string(i);
out << YAML::Key << slots;
out << YAML::BeginMap;
if (meshComponent.MaterialDescs[i])
{
out << YAML::Key << "AssetHandle" << YAML::Value << meshComponent.MaterialDescs[i]->Handle;
out << YAML::Key << "AssetPath" << YAML::Value << meshComponent.MaterialDescs[i]->FilePath;
}else
{
out << YAML::Key << "AssetHandle" << YAML::Value << 0;
out << YAML::Key << "AssetPath" << YAML::Value << "";
}
out << YAML::EndMap;
}
}
out << YAML::EndMap;
}
}
else
{
@ -602,7 +500,7 @@ namespace Prism
out << YAML::Key << "MeshColliderComponent";
out << YAML::BeginMap; // MeshColliderComponent
auto meshColliderComponent = entity.GetComponent<MeshColliderComponent>();
const auto& meshColliderComponent = entity.GetComponent<MeshColliderComponent>();
if (meshColliderComponent.OverrideMesh && meshColliderComponent.CollisionMesh)
{
out << YAML::Key << "AssetID" << YAML::Value << meshColliderComponent.CollisionMesh->Handle;
@ -883,7 +781,46 @@ namespace Prism
if (AssetsManager::IsAssetHandleValid(assetID) && !deserializedEntity.HasComponent<MeshComponent>())
{
deserializedEntity.AddComponent<MeshComponent>(AssetsManager::GetAsset<Mesh>(assetID));
auto& mc = deserializedEntity.AddComponent<MeshComponent>(AssetsManager::GetAsset<Mesh>(assetID));
if (meshComponent["Materials"])
{
auto materialsNode = meshComponent["Materials"];
// 遍历 "Slot X" 键
for (auto it = materialsNode.begin(); it != materialsNode.end(); ++it)
{
std::string slotKey = it->first.as<std::string>();
if (slotKey.rfind("Slot ", 0) == 0) // 确保是 "Slot X"
{
int slotIndex = std::stoi(slotKey.substr(5));
auto slotNode = it->second;
// 获取材质资产的 Handle
UUID materialHandle = 0;
if (slotNode["AssetPath"])
{
std::string matPath = slotNode["AssetPath"].as<std::string>();
if (!matPath.empty())
materialHandle = AssetsManager::GetAssetHandleFromFilePath(matPath);
}
else if (slotNode["AssetHandle"])
{
materialHandle = slotNode["AssetHandle"].as<uint64_t>();
}
// 调整 MaterialDescs 大小（确保索引有效）
if (slotIndex >= mc.MaterialDescs.size())
mc.MaterialDescs.resize(slotIndex + 1);
// 加载材质资产并赋值
if (materialHandle != 0 && AssetsManager::IsAssetHandleValid(materialHandle))
mc.MaterialDescs[slotIndex] = AssetsManager::GetAsset<PBRMaterialAsset>(materialHandle);
else
mc.MaterialDescs[slotIndex] = nullptr;
}
}
mc.UpdateMaterials(-1, true);
}
}
}
@ -1099,18 +1036,18 @@ namespace Prism
auto material = boxColliderComponent["Material"];
if (material && AssetsManager::IsAssetHandleValid(material.as<uint64_t>()))
{
component.Material = AssetsManager::GetAsset<PhysicsMaterial>(material.as<uint64_t>());
component.Material = AssetsManager::GetAsset<PhysicsMaterialAsset>(material.as<uint64_t>());
}else
{
const auto materialPath = boxColliderComponent["MaterialPath"].as<std::string>();
if (const auto assetId = AssetsManager::GetAssetHandleFromFilePath(materialPath); assetId != 0)
{
component.Material = AssetsManager::GetAsset<PhysicsMaterial>(assetId);
component.Material = AssetsManager::GetAsset<PhysicsMaterialAsset>(assetId);
}
}
component.DebugMesh = MeshFactory::CreateBox(component.Size);
component.DebugMesh = MeshFactory::CreateBox(component.Size * 2.0f);
}
if (auto sphereColliderComponent = entity["SphereColliderComponent"])
@ -1122,13 +1059,13 @@ namespace Prism
auto material = sphereColliderComponent["Material"];
if (material && AssetsManager::IsAssetHandleValid(material.as<uint64_t>()))
{
component.Material = AssetsManager::GetAsset<PhysicsMaterial>(material.as<uint64_t>());
component.Material = AssetsManager::GetAsset<PhysicsMaterialAsset>(material.as<uint64_t>());
}else
{
const auto materialPath = sphereColliderComponent["MaterialPath"].as<std::string>();
if (const auto assetId = AssetsManager::GetAssetHandleFromFilePath(materialPath); assetId != 0)
{
component.Material = AssetsManager::GetAsset<PhysicsMaterial>(assetId);
component.Material = AssetsManager::GetAsset<PhysicsMaterialAsset>(assetId);
}
}
@ -1146,13 +1083,13 @@ namespace Prism
auto material = capsuleColliderComponent["Material"];
if (material && AssetsManager::IsAssetHandleValid(material.as<uint64_t>()))
{
component.Material = AssetsManager::GetAsset<PhysicsMaterial>(material.as<uint64_t>());
component.Material = AssetsManager::GetAsset<PhysicsMaterialAsset>(material.as<uint64_t>());
}else
{
const auto materialPath = capsuleColliderComponent["MaterialPath"].as<std::string>();
if (const auto assetId = AssetsManager::GetAssetHandleFromFilePath(materialPath); assetId != 0)
{
component.Material = AssetsManager::GetAsset<PhysicsMaterial>(assetId);
component.Material = AssetsManager::GetAsset<PhysicsMaterialAsset>(assetId);
}
}
@ -1193,7 +1130,7 @@ namespace Prism
auto material = meshColliderComponent["Material"];
if (material && AssetsManager::IsAssetHandleValid(material.as<uint64_t>()))
{
component.Material = AssetsManager::GetAsset<PhysicsMaterial>(material.as<uint64_t>());
component.Material = AssetsManager::GetAsset<PhysicsMaterialAsset>(material.as<uint64_t>());
if (component.IsConvex)
PhysicsWrappers::CreateConvexMesh(component, deserializedEntity.Transform().Scale);
@ -1204,7 +1141,7 @@ namespace Prism
const auto materialPath = meshColliderComponent["MaterialPath"].as<std::string>();
if (const auto assetId = AssetsManager::GetAssetHandleFromFilePath(materialPath); assetId != 0)
{
component.Material = AssetsManager::GetAsset<PhysicsMaterial>(assetId);
component.Material = AssetsManager::GetAsset<PhysicsMaterialAsset>(assetId);
if (component.IsConvex)
PhysicsWrappers::CreateConvexMesh(component, deserializedEntity.Transform().Scale);
@ -1228,7 +1165,7 @@ namespace Prism
if (physicsMaterialComponent)
{
//auto& component = deserializedEntity.AddComponent<PhysicsMaterialComponent>();
Ref<PhysicsMaterial> material = Ref<PhysicsMaterial>::Create();
Ref<PhysicsMaterialAsset> material = Ref<PhysicsMaterialAsset>::Create();
material->StaticFriction = physicsMaterialComponent["StaticFriction"].as<float>();
material->DynamicFriction = physicsMaterialComponent["DynamicFriction"].as<float>();
material->Bounciness = physicsMaterialComponent["Bounciness"].as<float>();

22
Prism/src/Prism/Script/ScriptWrappers.cpp
View File

@ -37,14 +37,21 @@ namespace Prism { namespace Script {
// Debug ////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
static LogCallback s_LogCallback = nullptr;
void SetLogCallback(const LogCallback& callback)
{
s_LogCallback = callback;
}
void Prism_Log_Native(MonoString* message)
{
if (message)
{
char* utf8 = mono_string_to_utf8(message);
if (utf8)
if (char* utf8 = mono_string_to_utf8(message))
{
PM_CLIENT_INFO("[c#]: {}", utf8);
if (s_LogCallback) s_LogCallback(utf8);
mono_free(utf8);
}
}
@ -404,7 +411,8 @@ namespace Prism { namespace Script {
Entity entity = entityMap.at(entityID);
auto& transform = entity.GetComponent<TransformComponent>() = *inTransform;
auto& transform = entity.GetComponent<TransformComponent>();
transform = *inTransform;
transform.Rotation = glm::radians(transform.Rotation);
}
@ -473,7 +481,13 @@ namespace Prism { namespace Script {
PM_CORE_ASSERT(entityMap.find(entityID) != entityMap.end(), "Invalid entity ID or entity doesn't exist in scene!");
Entity entity = entityMap.at(entityID);
entity.GetComponent<TransformComponent>().Rotation = glm::radians(*inRotation);
auto& transformComponent = entity.GetComponent<TransformComponent>();
transformComponent.Rotation = glm::radians(*inRotation);
const auto rotationQuat = glm::quat(transformComponent.Rotation);
transformComponent.Up = glm::normalize(glm::rotate(rotationQuat, glm::vec3(0.0f, 1.0f, 0.0f)));
transformComponent.Right = glm::normalize(glm::rotate(rotationQuat, glm::vec3(1.0f, 0.0f, 0.0f)));
transformComponent.Forward = glm::normalize(glm::rotate(rotationQuat, glm::vec3(0.0f, 0.0f, -1.0f)));
}
void Prism_TransformComponent_GetScale(uint64_t entityID, glm::vec3* outScale)

8
Prism/src/Prism/Script/ScriptWrappers.h
View File

@ -14,7 +14,11 @@ extern "C" {
typedef struct _MonoArray MonoArray;
}
namespace Prism { namespace Script {
namespace Prism::Script
{
using LogCallback = std::function<void(const char*)>;
void SetLogCallback(const LogCallback& callback);
/*
struct ScriptTransform
@ -117,7 +121,7 @@ namespace Prism { namespace Script {
void* Prism_MeshComponent_GetMesh(uint64_t entityID);
void Prism_MeshComponent_SetMesh(uint64_t entityID, const Ref<Mesh>* inMesh);
} }
}
#endif //SCRIPTWRAPPERS_H

2
Prism/src/Prism/Utilities/FileSystem.h
View File

@ -38,6 +38,8 @@ namespace Prism
static std::string OpenFileSelector(const std::string& filter = "");
static std::string SaveFileSelector(const std::string& filter = "");
static void OpenInExplorer(const std::string& path);
static bool CreateFolder(const std::filesystem::path& filepath);
static bool Exists(const std::string& filepath);
static std::string Rename(const std::string& filepath, const std::string& newName);

145
Prism/src/Prism/Utilities/SerializeUtils.h Normal file
View File

@ -0,0 +1,145 @@
//
// Created by Atdunbg on 2026/3/25.
//
#ifndef PRISM_SERIALIZEUTILS_H
#define PRISM_SERIALIZEUTILS_H
#include <yaml-cpp/yaml.h>
#include <glm/glm.hpp>
namespace YAML
{
template<>
struct convert<glm::vec2>
{
static Node encode(const glm::vec2& rhs)
{
Node node;
node.push_back(rhs.x);
node.push_back(rhs.y);
return node;
}
static bool decode(const Node& node, glm::vec2& rhs)
{
if (!node.IsSequence() || node.size() != 2)
return false;
rhs.x = node[0].as<float>();
rhs.y = node[1].as<float>();
return true;
}
};
template<>
struct convert<glm::vec3>
{
static Node encode(const glm::vec3& rhs)
{
Node node;
node.push_back(rhs.x);
node.push_back(rhs.y);
node.push_back(rhs.z);
return node;
}
static bool decode(const Node& node, glm::vec3& rhs)
{
if (!node.IsSequence() || node.size() != 3)
return false;
rhs.x = node[0].as<float>();
rhs.y = node[1].as<float>();
rhs.z = node[2].as<float>();
return true;
}
};
template<>
struct convert<glm::vec4>
{
static Node encode(const glm::vec4& rhs)
{
Node node;
node.push_back(rhs.x);
node.push_back(rhs.y);
node.push_back(rhs.z);
node.push_back(rhs.w);
return node;
}
static bool decode(const Node& node, glm::vec4& rhs)
{
if (!node.IsSequence() || node.size() != 4)
return false;
rhs.x = node[0].as<float>();
rhs.y = node[1].as<float>();
rhs.z = node[2].as<float>();
rhs.w = node[3].as<float>();
return true;
}
};
template<>
struct convert<glm::quat>
{
static Node encode(const glm::quat& rhs)
{
Node node;
node.push_back(rhs.w);
node.push_back(rhs.x);
node.push_back(rhs.y);
node.push_back(rhs.z);
return node;
}
static bool decode(const Node& node, glm::quat& rhs)
{
if (!node.IsSequence() || node.size() != 4)
return false;
rhs.w = node[0].as<float>();
rhs.x = node[1].as<float>();
rhs.y = node[2].as<float>();
rhs.z = node[3].as<float>();
return true;
}
};
}
namespace Prism
{
inline YAML::Emitter& operator<<(YAML::Emitter& out, const glm::vec2& v)
{
out << YAML::Flow;
out << YAML::BeginSeq << v.x << v.y << YAML::EndSeq;
return out;
}
inline YAML::Emitter& operator<<(YAML::Emitter& out, const glm::vec3& v)
{
out << YAML::Flow;
out << YAML::BeginSeq << v.x << v.y << v.z << YAML::EndSeq;
return out;
}
inline YAML::Emitter& operator<<(YAML::Emitter& out, const glm::vec4& v)
{
out << YAML::Flow;
out << YAML::BeginSeq << v.x << v.y << v.z << v.w << YAML::EndSeq;
return out;
}
inline YAML::Emitter& operator<<(YAML::Emitter& out, const glm::quat& v)
{
out << YAML::Flow;
out << YAML::BeginSeq << v.w << v.x << v.y << v.z << YAML::EndSeq;
return out;
}
}
#endif //PRISM_SERIALIZEUTILS_H

10
Prism/src/Prism/Utilities/StringUtils.cpp
View File

@ -4,6 +4,8 @@
#include "StringUtils.h"
#include <filesystem>
namespace Prism::Utils
{
@ -17,10 +19,16 @@ namespace Prism::Utils
return "";
}
std::string ReplaceFilePathName(const std::string& filepath, const std::string& newName)
{
const std::string extension = GetExtension(filepath, true);
return std::filesystem::path(filepath).parent_path().string() + "/" + newName + extension;
}
std::string GetExtension(const std::string& filename, const bool includeDot)
{
if (const std::vector<std::string> parts = SplitString(filename, '.'); parts.size() > 1)
return parts[ includeDot ? parts.size() - 1 : parts.size()];
return (includeDot ? "." : "") + parts[parts.size() - 1];
return "";
}

4
Prism/src/Prism/Utilities/StringUtils.h
View File

@ -9,8 +9,10 @@
namespace Prism::Utils
{
std::string ReplaceFilePathName(const std::string& filepath, const std::string& newName);
std::string GetFilename(const std::string& filepath);
std::string GetExtension(const std::string& filename, bool includeDot = true);
std::string GetExtension(const std::string& filename, bool includeDot = false);
std::string RemoveExtension(const std::string& filename);
std::string NormalizePath(std::string path);
std::string StringToLower(const std::string& str);

4
PrismRuntime/CMakeLists.txt
View File

@ -4,8 +4,8 @@ file(GLOB_RECURSE SRC_SOURCE ./PrismRuntime/**.cpp)
add_executable(${PROJECT_NAME} WIN32 ${SRC_SOURCE})
target_compile_definitions(${PROJECT_NAME} PRIVATE PRISM_GUI)
target_link_libraries(${PROJECT_NAME} PRIVATE Prism-static)
target_link_libraries(${PROJECT_NAME} PRIVATE Prism-Runtime)
add_executable(${PROJECT_NAME}-Console ${SRC_SOURCE})
target_link_libraries(${PROJECT_NAME}-Console PRIVATE Prism-static)
target_link_libraries(${PROJECT_NAME}-Console PRIVATE Prism-Runtime)

49
PrismRuntime/PrismRuntime/PrismRuntime.cpp
View File

@ -4,6 +4,7 @@
#include "PrismRuntime.h"
#include "Prism/Core/Input.h"
#include "Prism/Renderer/Renderer.h"
#include "Prism/Renderer/SceneRenderer.h"
#include "Prism/Scene/SceneSerializer.h"
@ -15,13 +16,31 @@ void PrismRuntime::OnAttach()
AppInstance = &Prism::Application::Get();
PM_CLIENT_INFO("Create Scene");
sceneName.emplace_back("assets/scenes/FPS.scene");
sceneName.emplace_back("assets/scenes/FPSdemo.scene");
LoadScene(sceneName[0]);
}
void PrismRuntime::OnDetach()
{
PM_CLIENT_INFO("Scene Shutdown");
m_CurrentScene->OnShutdown();
}
void PrismRuntime::LoadScene(const std::string& scene)
{
if (m_CurrentScene)
{
PM_CLIENT_INFO("Scene Shutdown");
m_CurrentScene->OnShutdown();
}
const Prism::Ref<Prism::Scene> newScene = Prism::Ref<Prism::Scene>::Create("runtime Scene", false, true);
Prism::SceneSerializer serializer(newScene);
const char* scenePath = "assets/scenes/FPS.scene";
PM_CLIENT_INFO("loading Scene: ", scenePath);
serializer.Deserialize(scenePath);
PM_CLIENT_INFO("loading Scene: ", scene);
serializer.Deserialize(scene);
m_CurrentScene = newScene;
@ -32,16 +51,9 @@ void PrismRuntime::OnAttach()
m_CurrentScene->SetViewportSize(windowSize);
}
PM_CLIENT_INFO("Scene Start");
m_CurrentScene->OnRuntimeStart();
}
void PrismRuntime::OnDetach()
{
PM_CLIENT_INFO("Scene Shutdown");
m_CurrentScene->OnShutdown();
}
void PrismRuntime::OnUpdate(const Prism::TimeStep deltaTime)
{
m_CurrentScene->OnUpdate(deltaTime);
@ -52,10 +64,25 @@ void PrismRuntime::OnUpdate(const Prism::TimeStep deltaTime)
{
m_CurrentScene->SetViewportSize(windowSize);
}
if (shouldChangeScene)
{
LoadScene(sceneName[nextScene]);
shouldChangeScene = false;
}
}
void PrismRuntime::OnEvent(Prism::Event& e)
{
if (Prism::Input::IsKeyPressed(Prism::KeyCode::L) && nextScene == 0)
{
shouldChangeScene = true;
nextScene++;
} else if (Prism::Input::IsKeyPressed(Prism::KeyCode::K) && nextScene == 1)
{
shouldChangeScene = true;
nextScene--;
}
}
void PrismRuntime::OnImGuiRender()

8
PrismRuntime/PrismRuntime/PrismRuntime.h
View File

@ -15,6 +15,8 @@ public:
void OnAttach() override;
void OnDetach() override;
void LoadScene(const std::string& scene);
void OnUpdate(Prism::TimeStep deltaTime) override;
void OnEvent(Prism::Event& e) override;
void OnImGuiRender() override;
@ -24,6 +26,12 @@ private:
Prism::Ref<Prism::Scene> m_CurrentScene;
Prism::Application* AppInstance = nullptr;
bool shouldChangeScene = false;
// debug
std::vector<std::string> sceneName;
int nextScene = 0;
};