From c1bb8f9fbae1b98c9800f3a08fb2c7d1d1cc4fcd Mon Sep 17 00:00:00 2001
From: Atdunbg <atdunbg@qq.com>
Date: Sun, 8 Mar 2026 19:27:00 +0800
Subject: [PATCH] readd Sprite Renderer render and panel edit; in renderer
 scene, add icon for camera and light; improve a user-friendly EditorCamera,
 is more like UE Editor Camera; fix woring build m_ProjectionMatrix for
 SceneCamera::Orthographic

---
 Editor/Editor/EditorLayer.cpp                 |  13 +-
 Editor/assets/editor/Camera.png               | Bin 0 -> 2240 bytes
 Editor/assets/editor/light.png                | Bin 0 -> 65896 bytes
 Editor/assets/shaders/Renderer2D.glsl         |  13 +-
 Prism/src/Prism/Core/ImGui/ImGui.h            |   5 +
 Prism/src/Prism/Core/KeyCodes.h               |   7 +-
 Prism/src/Prism/Editor/EditorCamera.cpp       |  95 ++++++++-
 Prism/src/Prism/Editor/EditorCamera.h         |  11 +
 Prism/src/Prism/Editor/SceneHierachyPanel.cpp |  95 +++++----
 Prism/src/Prism/Renderer/Renderer2D.cpp       |  73 ++++---
 Prism/src/Prism/Renderer/Renderer2D.h         |  11 +
 Prism/src/Prism/Scene/Components.h            |  12 +-
 Prism/src/Prism/Scene/Scene.cpp               | 198 +++++++++++-------
 Prism/src/Prism/Scene/Scene.h                 |   4 +
 Prism/src/Prism/Scene/SceneCamera.cpp         |   2 +-
 15 files changed, 380 insertions(+), 159 deletions(-)
 create mode 100644 Editor/assets/editor/Camera.png
 create mode 100644 Editor/assets/editor/light.png

diff --git a/Editor/Editor/EditorLayer.cpp b/Editor/Editor/EditorLayer.cpp
index 61ef8b1..8bc513e 100644
--- a/Editor/Editor/EditorLayer.cpp
+++ b/Editor/Editor/EditorLayer.cpp
@@ -102,6 +102,7 @@ namespace Prism
                     }
                 }
 
+                // Draw Colliders
                 if (!m_SelectionContext.empty())
                 {
                     auto& selection = m_SelectionContext[0];
@@ -492,6 +493,7 @@ namespace Prism
         m_ObjectsPanel->OnImGuiRender();
 
         m_SceneHierarchyPanel->OnImGuiRender();
+        m_EditorCamera.OnImGuiRender();
 
         // Editor Panel ------------------------------------------------------------------------------
         ImGui::Begin("Environment");
@@ -880,14 +882,17 @@ namespace Prism
             m_RuntimeScene->OnEvent(e);
         }
 
-		EventDispatcher dispatcher(e);
-		dispatcher.Dispatch<KeyPressedEvent>(PM_BIND_EVENT_FN(EditorLayer::OnKeyPressedEvent));
-		dispatcher.Dispatch<MouseButtonPressedEvent>(PM_BIND_EVENT_FN(EditorLayer::OnMouseButtonPressedEvent));
+        if (Input::GetCursorMode() == CursorMode::Normal)
+        {
+		    EventDispatcher dispatcher(e);
+            dispatcher.Dispatch<KeyPressedEvent>(PM_BIND_EVENT_FN(EditorLayer::OnKeyPressedEvent));
+            dispatcher.Dispatch<MouseButtonPressedEvent>(PM_BIND_EVENT_FN(EditorLayer::OnMouseButtonPressedEvent));
+        }
     }
 
     bool EditorLayer::OnKeyPressedEvent(KeyPressedEvent& e)
     {
-        if (m_ViewportPanelHovered)
+        if (m_ViewportPanelFocused)
         {
             switch (e.GetKeyCode())
             {
diff --git a/Editor/assets/editor/Camera.png b/Editor/assets/editor/Camera.png
new file mode 100644
index 0000000000000000000000000000000000000000..11c81636a4cc8270ae5718c7659d9406c11825de
GIT binary patch
literal 2240
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
QNgb>}HkKUb-F=?eAH_A2?*IS*

literal 0
HcmV?d00001

diff --git a/Editor/assets/editor/light.png b/Editor/assets/editor/light.png
new file mode 100644
index 0000000000000000000000000000000000000000..6f235b02d3096a167eb5fed51f55568b5e18d826
GIT binary patch
literal 65896
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

literal 0
HcmV?d00001

diff --git a/Editor/assets/shaders/Renderer2D.glsl b/Editor/assets/shaders/Renderer2D.glsl
index 203cc89..26c7206 100644
--- a/Editor/assets/shaders/Renderer2D.glsl
+++ b/Editor/assets/shaders/Renderer2D.glsl
@@ -6,14 +6,14 @@
 layout(location = 0) in vec3 a_Position;
 layout(location = 1) in vec4 a_Color;
 layout(location = 2) in vec2 a_TexCoord;
-layout(location = 3) in float a_TexIndex;
+layout(location = 3) in int a_TexIndex;
 layout(location = 4) in float a_TilingFactor;
 
 uniform mat4 u_ViewProjection;
 
 out vec4 v_Color;
 out vec2 v_TexCoord;
-out float v_TexIndex;
+flat out int v_TexIndex;
 out float v_TilingFactor;
 
 void main()
@@ -32,12 +32,17 @@ layout(location = 0) out vec4 color;
 
 in vec4 v_Color;
 in vec2 v_TexCoord;
-in float v_TexIndex;
+flat in int v_TexIndex;
 in float v_TilingFactor;
 
 uniform sampler2D u_Textures[32];
 
 void main()
 {
-    color = texture(u_Textures[int(v_TexIndex)], v_TexCoord * v_TilingFactor) * v_Color;
+    vec4 texColor = texture(u_Textures[v_TexIndex], v_TexCoord * v_TilingFactor) * v_Color;
+
+    if(texColor.a < 0.1)
+        discard;
+
+    color = texColor;
 }
diff --git a/Prism/src/Prism/Core/ImGui/ImGui.h b/Prism/src/Prism/Core/ImGui/ImGui.h
index 6b6e462..b90a53a 100644
--- a/Prism/src/Prism/Core/ImGui/ImGui.h
+++ b/Prism/src/Prism/Core/ImGui/ImGui.h
@@ -41,6 +41,11 @@ namespace Prism::UI {
 		ImGui::Columns(2);
 	}
 
+	static void Separator()
+	{
+		ImGui::Separator();
+	}
+
 	static bool Property(const char* label, std::string& value, const bool error = false)
 	{
 		bool modified = false;
diff --git a/Prism/src/Prism/Core/KeyCodes.h b/Prism/src/Prism/Core/KeyCodes.h
index c2ac9f5..9278538 100644
--- a/Prism/src/Prism/Core/KeyCodes.h
+++ b/Prism/src/Prism/Core/KeyCodes.h
@@ -9,9 +9,10 @@ namespace Prism
 {
     enum class CursorMode
     {
-        Normal = 0,
-        Hidden = 1,
-        Locked = 2
+        Normal  = 0,
+        Hidden  = 1,
+        Disable = 2,
+        Capture = 3
     };
 
     typedef enum class MouseButton : uint16_t
diff --git a/Prism/src/Prism/Editor/EditorCamera.cpp b/Prism/src/Prism/Editor/EditorCamera.cpp
index d8f477f..0d974d8 100644
--- a/Prism/src/Prism/Editor/EditorCamera.cpp
+++ b/Prism/src/Prism/Editor/EditorCamera.cpp
@@ -46,11 +46,93 @@ namespace Prism
 
     void EditorCamera::OnUpdate(TimeStep deltaTime)
     {
-        if (Input::IsKeyPressed(Key::LEFT_ALT))
+        const bool altPressed = Input::IsKeyPressed(Key::LEFT_ALT);
+
+        if (Input::IsMouseButtonPressed(MouseButton::Right) && !altPressed)
         {
+            Input::SetCursorMode(CursorMode::Disable);
+
+            if (!m_IsRightButtonDownState)
+            {
+                m_InitialMousePosition = { Input::GetMouseX(), Input::GetMouseY() };
+                m_IsRightButtonDownState = true;
+                m_FreeLookActive = true;
+                m_FreeLookPosition = m_Position;
+                m_Velocity = glm::vec3(0.0f);
+            }
+
+            const glm::vec2& mouse{ Input::GetMouseX(), Input::GetMouseY() };
+            glm::vec2 delta = (mouse - m_InitialMousePosition) * 0.002f;
+            m_InitialMousePosition = mouse;
+            m_Yaw += delta.x;
+            m_Pitch += delta.y;
+            m_Pitch = glm::clamp(m_Pitch, -1.5f, 1.5f);
+
+            glm::vec3 desiredDir(0.0f);
+            if (Input::IsKeyPressed(Key::W)) desiredDir += GetForwardDirection();
+            if (Input::IsKeyPressed(Key::S)) desiredDir -= GetForwardDirection();
+            if (Input::IsKeyPressed(Key::A)) desiredDir -= GetRightDirection();
+            if (Input::IsKeyPressed(Key::D)) desiredDir += GetRightDirection();
+
+            if (Input::IsKeyPressed(Key::Q)) desiredDir -= GetUpDirection();
+            if (Input::IsKeyPressed(Key::E)) desiredDir += GetUpDirection();
+
+            if (glm::length(desiredDir) > 0.001f)
+                desiredDir = glm::normalize(desiredDir) * m_MaxSpeed;
+            else
+                desiredDir = glm::vec3(0.0f);
+
+            // (desiredDir - m_Velocity)
+            const glm::vec3 accel = (desiredDir - m_Velocity) * m_Acceleration;
+            m_Velocity += accel * deltaTime.GetSeconds();
+
+            // m_Velocity *= (1.0f - m_Damping * deltaTime);
+
+            m_FreeLookPosition += m_Velocity * deltaTime.GetSeconds();
+            // ---------------------------------
+
+            glm::quat orientation = GetOrientation();
+            m_ViewMatrix = glm::translate(glm::mat4(1.0f), m_FreeLookPosition) * glm::toMat4(orientation);
+            m_ViewMatrix = glm::inverse(m_ViewMatrix);
+            m_Rotation = glm::eulerAngles(orientation) * (180.0f / (float)M_PI);
+            return;
+        }
+        else
+        {
+            if (m_IsRightButtonDownState)
+            {
+                Input::SetCursorMode(CursorMode::Normal);
+                m_IsRightButtonDownState = false;
+                if (m_FreeLookActive)
+                {
+                    m_Position = m_FreeLookPosition;
+                    m_FocalPoint = m_Position + GetForwardDirection() * m_Distance;
+                    m_FreeLookActive = false;
+                }
+            }
+        }
+
+
+        // for alt process
+
+        const bool anyMouseButtonPressed = Input::IsMouseButtonPressed(MouseButton::Left) ||
+                                     Input::IsMouseButtonPressed(MouseButton::Middle) ||
+                                     Input::IsMouseButtonPressed(MouseButton::Right);
+
+        if (altPressed && anyMouseButtonPressed)
+        {
+            if (!m_IsAltKeyDownState)
+            {
+                Input::SetCursorMode(CursorMode::Disable);
+                m_IsAltKeyDownState = true;
+
+                m_InitialMousePosition = { Input::GetMouseX(), Input::GetMouseY() };
+            }
+
             const glm::vec2& mouse{ Input::GetMouseX(), Input::GetMouseY() };
             const glm::vec2 delta = (mouse - m_InitialMousePosition) * 0.003f;
             m_InitialMousePosition = mouse;
+
             if (delta.x != 0.0f || delta.y != 0.0f)
             {
                 if (Input::IsMouseButtonPressed(MouseButton::Middle))
@@ -60,6 +142,11 @@ namespace Prism
                 else if (Input::IsMouseButtonPressed(MouseButton::Right))
                     MouseZoom(delta.y);
             }
+        }else if (m_IsAltKeyDownState)
+        {
+            Input::SetCursorMode(CursorMode::Normal);
+            m_IsAltKeyDownState = false;
+            return;
         }
 
         UpdateCameraView();
@@ -88,7 +175,8 @@ namespace Prism
 
     void EditorCamera::OnImGuiRender()
     {
-        ImGui::Begin("Camera Info");
+        ImGui::Begin("Debug Camera Info");
+        UI::BeginPropertyGrid();
         UI::Property("yaw", m_Yaw);
         UI::Property("pitch", m_Pitch);
         UI::Property("focus", m_FocalPoint);
@@ -96,6 +184,9 @@ namespace Prism
         UI::Property("rotation", m_Rotation);
         UI::Property("focus", m_FocalPoint);
         UI::Property("position", m_Position);
+        UI::Separator();
+        UI::Property("Current Speed", m_Velocity);
+        UI::EndPropertyGrid();
         ImGui::End();
     }
 
diff --git a/Prism/src/Prism/Editor/EditorCamera.h b/Prism/src/Prism/Editor/EditorCamera.h
index e8b9c9d..b7abd22 100644
--- a/Prism/src/Prism/Editor/EditorCamera.h
+++ b/Prism/src/Prism/Editor/EditorCamera.h
@@ -79,6 +79,17 @@ namespace Prism
 
 
         float m_Pitch, m_Yaw;
+
+        bool m_IsRightButtonDownState = false;
+
+        bool m_IsAltKeyDownState = false;
+        bool m_FreeLookActive;
+        glm::vec3 m_FreeLookPosition;
+
+        glm::vec3 m_Velocity = glm::vec3(0.0f);   // 当前速度
+        float m_MaxSpeed = 20.0f;                       // 最大移动速度（单位/秒）
+        float m_Acceleration = 10.0f;                   // 加速度系数（决定响应快慢）
+        float m_Damping = 5.0f;                         // 阻尼系数（无输入时的减速速率）
     };
 
 }
diff --git a/Prism/src/Prism/Editor/SceneHierachyPanel.cpp b/Prism/src/Prism/Editor/SceneHierachyPanel.cpp
index 51534da..ac9474e 100644
--- a/Prism/src/Prism/Editor/SceneHierachyPanel.cpp
+++ b/Prism/src/Prism/Editor/SceneHierachyPanel.cpp
@@ -232,6 +232,30 @@ namespace Prism
     					isCreated = true;
     					SetSelected(newEntity);
     				}
+
+    				if (ImGui::BeginMenu("Camera"))
+    				{
+    					if (ImGui::MenuItem("Orthographic Camera"))
+    					{
+    						auto newEntity = m_Context->CreateEntity("Camera");
+    						auto& component = newEntity.AddComponent<CameraComponent>();
+    						component.Camera.SetProjectionType(SceneCamera::ProjectionType::Orthographic);
+
+    						isCreated = true;
+    						SetSelected(newEntity);
+    					}
+    					if (ImGui::MenuItem("Perspective Camera"))
+    					{
+    						auto newEntity = m_Context->CreateEntity("Camera");
+    						auto& component = newEntity.AddComponent<CameraComponent>();
+    						component.Camera.SetProjectionType(SceneCamera::ProjectionType::Perspective);
+
+    						isCreated = true;
+    						SetSelected(newEntity);
+    					}
+    					ImGui::EndMenu();
+    				}
+
     				if (ImGui::MenuItem("Mesh"))
     				{
     					auto newEntity = m_Context->CreateEntity("Mesh");
@@ -239,23 +263,34 @@ namespace Prism
     					isCreated = true;
     					SetSelected(newEntity);
     				}
+
     				ImGui::Separator();
-    				if (ImGui::MenuItem("Directional Light"))
+
+    				if (ImGui::BeginMenu("Light"))
     				{
-    					auto newEntity = m_Context->CreateEntity("Directional Light");
-    					newEntity.AddComponent<DirectionalLightComponent>();
-    					isCreated = true;
-    					SetSelected(newEntity);
-    				}
-    				if (ImGui::MenuItem("Sky Light"))
-    				{
-    					auto newEntity = m_Context->CreateEntity("Sky Light");
-    					newEntity.AddComponent<SkyLightComponent>();
-    					isCreated = true;
-    					SetSelected(newEntity);
+    					if (ImGui::MenuItem("Sky Light"))
+    					{
+    						auto newEntity = m_Context->CreateEntity("Sky Light");
+    						newEntity.AddComponent<SkyLightComponent>();
+    						isCreated = true;
+    						SetSelected(newEntity);
+    					}
+    					if (ImGui::MenuItem("Spot Light"))
+    					{
+							PM_CORE_WARN("not impl");
+    					}
+    					if (ImGui::MenuItem("Directional Light"))
+    					{
+    						auto newEntity = m_Context->CreateEntity("Directional Light");
+    						newEntity.AddComponent<DirectionalLightComponent>();
+    						isCreated = true;
+    						SetSelected(newEntity);
+    					}
+    					ImGui::EndMenu();
     				}
     				ImGui::EndMenu();
 
+
     				if (isCreated)
     				{
     					if (m_SelectionChangedCallback)
@@ -602,31 +637,6 @@ namespace Prism
 			UI::BeginPropertyGrid();
 			UI::PropertyAssetReference("Mesh", meshComponent.Mesh, AssetType::Mesh);
 			UI::EndPropertyGrid();
-
-			/*
-			ImGui::Columns(3);
-			ImGui::SetColumnWidth(0, 100);
-			ImGui::SetColumnWidth(1, 300);
-			ImGui::SetColumnWidth(2, 40);
-			ImGui::Text("File Path");
-			ImGui::NextColumn();
-			ImGui::PushItemWidth(-1);
-
-			if (meshComponent.Mesh)
-				ImGui::InputText("##meshFilePath", (char*)meshComponent.Mesh->GetFilePath().c_str(), 256, ImGuiInputTextFlags_ReadOnly);
-			else
-				ImGui::InputText("##meshFilePath", (char*)"Null", 256, ImGuiInputTextFlags_ReadOnly);
-
-			ImGui::PopItemWidth();
-			ImGui::NextColumn();
-			if (ImGui::Button("...##openmesh"))
-			{
-				const std::string file = Application::Get().OpenFile();
-				if (!file.empty())
-					meshComponent.Mesh = Ref<Mesh>::Create(file);
-			}
-			ImGui::Columns(1);
-			*/
 		});
 
 		DrawComponent<CameraComponent>("Camera", entity, [](CameraComponent& cameraComponent) {
@@ -660,7 +670,7 @@ namespace Prism
 				float nearClip = cameraComponent.Camera.GetPerspectiveNearClip();
 				if (UI::Property("Near Clip", nearClip))
 					cameraComponent.Camera.SetPerspectiveNearClip(nearClip);
-				ImGui::SameLine();
+
 				float farClip = cameraComponent.Camera.GetPerspectiveFarClip();
 				if (UI::Property("Far Clip", farClip))
 					cameraComponent.Camera.SetPerspectiveFarClip(farClip);
@@ -676,7 +686,7 @@ namespace Prism
 				float nearClip = cameraComponent.Camera.GetOrthographicNearClip();
 				if (UI::Property("Near Clip", nearClip))
 					cameraComponent.Camera.SetOrthographicNearClip(nearClip);
-				ImGui::SameLine();
+
 				float farClip = cameraComponent.Camera.GetOrthographicFarClip();
 				if (UI::Property("Far Clip", farClip))
 					cameraComponent.Camera.SetOrthographicFarClip(farClip);
@@ -704,8 +714,13 @@ namespace Prism
 			UI::EndPropertyGrid();
 		});
 
-		DrawComponent<SpriteRendererComponent>("Sprite Renderer", entity, [](SpriteRendererComponent& mc)
+		DrawComponent<SpriteRendererComponent>("Sprite Renderer", entity, [](SpriteRendererComponent& sc)
 		{
+			UI::BeginPropertyGrid();
+			UI::PropertyColor("Color", sc.Color);
+			UI::Property("Tiling Factor", sc.TilingFactor, 0.01f, 0.0f, 5.0f);
+			UI::PropertyAssetReference("Texture", sc.Texture, AssetType::Texture);
+			UI::EndPropertyGrid();
 		});
 
 		DrawComponent<ScriptComponent>("Script", entity, [=](ScriptComponent& scriptComponent) mutable {
diff --git a/Prism/src/Prism/Renderer/Renderer2D.cpp b/Prism/src/Prism/Renderer/Renderer2D.cpp
index d2b564f..54b15e1 100644
--- a/Prism/src/Prism/Renderer/Renderer2D.cpp
+++ b/Prism/src/Prism/Renderer/Renderer2D.cpp
@@ -16,7 +16,7 @@ namespace Prism
         glm::vec3 Position;
         glm::vec4 Color;
         glm::vec2 TexCoord;
-        float TexIndex;
+        int TexIndex;
         float TilingFactor;
     };
 
@@ -99,7 +99,7 @@ namespace Prism
 	    		{ ShaderDataType::Float3, "a_Position" },
 				{ ShaderDataType::Float4, "a_Color" },
 				{ ShaderDataType::Float2, "a_TexCoord" },
-				{ ShaderDataType::Float, "a_TexIndex" },
+				{ ShaderDataType::Int, "a_TexIndex" },
 				{ ShaderDataType::Float, "a_TilingFactor" }
 	    	};
 	    	s_Data.QuadPipeline = Pipeline::Create(pipelineSpecification);
@@ -278,8 +278,6 @@ namespace Prism
     void Renderer2D::DrawQuad(const glm::mat4& transform, const glm::vec4& color)
     {
     	constexpr size_t quadVertexCount = 4;
-    	const float textureIndex = 0.0f; // White Texture
-    	constexpr float tilingFactor = 1.0f;
 
     	if (s_Data.QuadIndexCount >= Renderer2DData::MaxIndices)
     		FlushAndReset();
@@ -289,8 +287,8 @@ namespace Prism
     		s_Data.QuadVertexBufferPtr->Position = transform * s_Data.QuadVertexPositions[i];
     		s_Data.QuadVertexBufferPtr->Color = color;
     		s_Data.QuadVertexBufferPtr->TexCoord = defaultTexCoords[i];
-    		s_Data.QuadVertexBufferPtr->TexIndex = textureIndex;
-    		s_Data.QuadVertexBufferPtr->TilingFactor = tilingFactor;
+    		s_Data.QuadVertexBufferPtr->TexIndex = 0;
+    		s_Data.QuadVertexBufferPtr->TilingFactor = 1.0f;
     		s_Data.QuadVertexBufferPtr++;
     	}
 
@@ -302,27 +300,26 @@ namespace Prism
     void Renderer2D::DrawQuad(const glm::mat4& transform, const Ref<Texture2D>& texture, float tilingFactor, const glm::vec4& tintColor)
     {
     	constexpr size_t quadVertexCount = 4;
-    	constexpr glm::vec4 color = { 1.0f, 1.0f, 1.0f, 1.0f };
 
     	if (s_Data.QuadIndexCount >= Renderer2DData::MaxIndices)
     		FlushAndReset();
 
-    	float textureIndex = 0.0f;
+    	int textureIndex = 0;
     	for (uint32_t i = 1; i < s_Data.TextureSlotIndex; i++)
     	{
     		if (*s_Data.TextureSlots[i].Raw() == *texture.Raw())
     		{
-    			textureIndex = (float)i;
+    			textureIndex = i;
     			break;
     		}
     	}
 
-    	if (textureIndex == 0.0f)
+    	if (textureIndex == 0)
     	{
     		if (s_Data.TextureSlotIndex >= Renderer2DData::MaxTextureSlots)
     			FlushAndReset();
 
-    		textureIndex = (float)s_Data.TextureSlotIndex;
+    		textureIndex = s_Data.TextureSlotIndex;
     		s_Data.TextureSlots[s_Data.TextureSlotIndex] = texture;
     		s_Data.TextureSlotIndex++;
     	}
@@ -330,7 +327,7 @@ namespace Prism
     	for (size_t i = 0; i < quadVertexCount; i++)
     	{
     		s_Data.QuadVertexBufferPtr->Position = transform * s_Data.QuadVertexPositions[i];
-    		s_Data.QuadVertexBufferPtr->Color = color;
+    		s_Data.QuadVertexBufferPtr->Color = tintColor;
     		s_Data.QuadVertexBufferPtr->TexCoord = defaultTexCoords[i];
     		s_Data.QuadVertexBufferPtr->TexIndex = textureIndex;
     		s_Data.QuadVertexBufferPtr->TilingFactor = tilingFactor;
@@ -342,6 +339,27 @@ namespace Prism
     	s_Data.Stats.QuadCount++;
     }
 
+    void Renderer2D::DrawBillBoardQuad(const glm::vec3& position, const Ref<Texture2D>& texture,
+	    const glm::vec3& cameraPos, const glm::vec3& upDirection, const float tilingFactor, const glm::vec4& tintColor)
+    {
+    	const glm::vec3 forward = glm::normalize(cameraPos - position);
+    	glm::vec3 up = upDirection;
+    	if (glm::abs(glm::dot(forward, up)) > 0.999f)
+    		up = glm::vec3(0.0f, 0.0f, 1.0f); // 备选上方向
+
+    	const glm::vec3 right = glm::normalize(glm::cross(up, forward));
+    	const glm::vec3 correctedUp = glm::cross(forward, right);
+
+    	glm::mat4 rotation(1.0f);
+    	rotation[0] = glm::vec4(right, 0.0f);
+    	rotation[1] = glm::vec4(correctedUp, 0.0f);
+    	rotation[2] = glm::vec4(forward, 0.0f);
+
+    	const glm::mat4 transform = glm::translate(glm::mat4(1.0f), position) * rotation;
+
+		DrawQuad(transform, texture, tilingFactor, tintColor);
+    }
+
     void Renderer2D::DrawQuad(const glm::vec2& position, const glm::vec2& size, const glm::vec4& color)
     {
 		DrawQuad({ position.x, position.y, 0.0f }, size, color);
@@ -352,9 +370,6 @@ namespace Prism
     	if (s_Data.QuadIndexCount >= Renderer2DData::MaxIndices)
     		FlushAndReset();
 
-    	const float textureIndex = 0.0f; // White Texture
-    	const float tilingFactor = 1.0f;
-
     	glm::mat4 transform = glm::translate(glm::mat4(1.0f), position)
 			* glm::scale(glm::mat4(1.0f), { size.x, size.y, 1.0f });
 
@@ -363,8 +378,8 @@ namespace Prism
 			s_Data.QuadVertexBufferPtr->Position = transform * s_Data.QuadVertexPositions[i];
 			s_Data.QuadVertexBufferPtr->Color = color;
 			s_Data.QuadVertexBufferPtr->TexCoord = defaultTexCoords[i];
-			s_Data.QuadVertexBufferPtr->TexIndex = textureIndex;
-			s_Data.QuadVertexBufferPtr->TilingFactor = tilingFactor;
+			s_Data.QuadVertexBufferPtr->TexIndex = 0;
+			s_Data.QuadVertexBufferPtr->TilingFactor = 1.0f;
 			s_Data.QuadVertexBufferPtr++;
     	}
 
@@ -385,25 +400,26 @@ namespace Prism
 
 		constexpr glm::vec4 color = { 1.0f, 1.0f, 1.0f, 1.0f };
 
-		float textureIndex = 0.0f;
+		int textureIndex = 0;
 		for (uint32_t i = 1; i < s_Data.TextureSlotIndex; i++)
 		{
 			if (*s_Data.TextureSlots[i].Raw() == *texture.Raw())
 			{
-				textureIndex = (float)i;
+				textureIndex = i;
 				break;
 			}
 		}
 
 		if (textureIndex == 0.0f)
 		{
-			textureIndex = (float)s_Data.TextureSlotIndex;
+			textureIndex = s_Data.TextureSlotIndex;
 			s_Data.TextureSlots[s_Data.TextureSlotIndex] = texture;
 			s_Data.TextureSlotIndex++;
 		}
 
-		glm::mat4 transform = glm::translate(glm::mat4(1.0f), position)
-			* glm::scale(glm::mat4(1.0f), { size.x, size.y, 1.0f });
+		const glm::mat4 transform = glm::translate(glm::mat4(1.0f), position) *
+								    glm::scale(glm::mat4(1.0f), { size.x, size.y, 1.0f });
+
 		for (uint32_t i = 0; i < 4; i++)
 		{
 			s_Data.QuadVertexBufferPtr->Position = transform * s_Data.QuadVertexPositions[i];
@@ -429,9 +445,6 @@ namespace Prism
     	if (s_Data.QuadIndexCount >= Renderer2DData::MaxIndices)
     		FlushAndReset();
 
-    	const float textureIndex = 0.0f; // White Texture
-    	const float tilingFactor = 1.0f;
-
     	glm::mat4 transform = glm::translate(glm::mat4(1.0f), position)
 			* glm::rotate(glm::mat4(1.0f), rotation, { 0.0f, 0.0f, 1.0f })
 			* glm::scale(glm::mat4(1.0f), { size.x, size.y, 1.0f });
@@ -441,8 +454,8 @@ namespace Prism
 			s_Data.QuadVertexBufferPtr->Position = transform * s_Data.QuadVertexPositions[i];
 			s_Data.QuadVertexBufferPtr->Color = color;
 			s_Data.QuadVertexBufferPtr->TexCoord = defaultTexCoords[i];
-			s_Data.QuadVertexBufferPtr->TexIndex = textureIndex;
-			s_Data.QuadVertexBufferPtr->TilingFactor = tilingFactor;
+			s_Data.QuadVertexBufferPtr->TexIndex = 0;
+			s_Data.QuadVertexBufferPtr->TilingFactor = 1.0f;
 			s_Data.QuadVertexBufferPtr++;
     	}
 
@@ -463,19 +476,19 @@ namespace Prism
 
 		constexpr glm::vec4 color = { 1.0f, 1.0f, 1.0f, 1.0f };
 
-		float textureIndex = 0.0f;
+		int textureIndex = 0;
 		for (uint32_t i = 1; i < s_Data.TextureSlotIndex; i++)
 		{
 			if (*s_Data.TextureSlots[i].Raw() == *texture.Raw())
 			{
-				textureIndex = (float)i;
+				textureIndex = i;
 				break;
 			}
 		}
 
 		if (textureIndex == 0.0f)
 		{
-			textureIndex = (float)s_Data.TextureSlotIndex;
+			textureIndex = s_Data.TextureSlotIndex;
 			s_Data.TextureSlots[s_Data.TextureSlotIndex] = texture;
 			s_Data.TextureSlotIndex++;
 		}
diff --git a/Prism/src/Prism/Renderer/Renderer2D.h b/Prism/src/Prism/Renderer/Renderer2D.h
index 3bf9fe4..418524e 100644
--- a/Prism/src/Prism/Renderer/Renderer2D.h
+++ b/Prism/src/Prism/Renderer/Renderer2D.h
@@ -25,6 +25,17 @@ namespace Prism
         static void DrawQuad(const glm::mat4& transform, const glm::vec4& color);
         static void DrawQuad(const glm::mat4& transform, const Ref<Texture2D>& texture, float tilingFactor = 1.0f, const glm::vec4& tintColor = glm::vec4(1.0f));
 
+        /**
+         * draw a Billboard's texture
+         * @param position entity position
+         * @param texture entity texture
+         * @param cameraPos editcamera or camera postion
+         * @param upDirection default (0.0f, 1.0f, 0.0f)
+         * @param tilingFactor default 0
+         * @param tintColor default (1.0f, 1.0f, 1.0f)
+         */
+        static void DrawBillBoardQuad(const glm::vec3& position, const Ref<Texture2D>& texture, const glm::vec3& cameraPos, const glm::vec3& upDirection = glm::vec3(0.0f, 1.0f, 0.0f), float tilingFactor = 1.0f, const glm::vec4& tintColor = glm::vec4(1.0f));
+
         static void DrawQuad(const glm::vec2& position, const glm::vec2& size, const glm::vec4& color);
         static void DrawQuad(const glm::vec3& position, const glm::vec2& size, const glm::vec4& color);
         static void DrawQuad(const glm::vec2& position, const glm::vec2& size, const Ref<Texture2D>& texture, float tilingFactor = 1.0f, const glm::vec4& tintColor = glm::vec4(1.0f));
diff --git a/Prism/src/Prism/Scene/Components.h b/Prism/src/Prism/Scene/Components.h
index 5818fa6..2e3d10c 100644
--- a/Prism/src/Prism/Scene/Components.h
+++ b/Prism/src/Prism/Scene/Components.h
@@ -19,6 +19,7 @@
 #include <glm/gtx/quaternion.hpp>
 #include <utility>
 
+#include "Prism/Core/Math/Math.h"
 #include "Prism/Renderer/SceneEnvironment.h"
 
 namespace Prism
@@ -53,6 +54,10 @@ namespace Prism
     };
 
 
+    /**
+     * to storage entity Translation Rotation Scale info
+     * this Rotation is Euler angle
+     */
     struct TransformComponent
     {
 
@@ -69,6 +74,10 @@ namespace Prism
         TransformComponent(const glm::vec3& translation)
             : Translation(translation) {}
 
+        void SetTransform(const glm::mat4 &transform)
+        {
+            Math::DecomposeTransform(transform, Translation, Rotation, Scale);
+        }
         glm::mat4 GetTransform() const
         {
             return glm::translate(glm::mat4(1.0f), Translation)
@@ -80,7 +89,7 @@ namespace Prism
 
     struct MeshComponent
     {
-        Ref<Prism::Mesh> Mesh;
+        Ref<Mesh> Mesh;
 
         MeshComponent() = default;
         MeshComponent(const MeshComponent& other) = default;
@@ -122,6 +131,7 @@ namespace Prism
         float TilingFactor = 1.0f;
 
         SpriteRendererComponent() = default;
+        SpriteRendererComponent(const glm::vec4 &color) : Color(color){}
         SpriteRendererComponent(const SpriteRendererComponent& other) = default;
     };
 
diff --git a/Prism/src/Prism/Scene/Scene.cpp b/Prism/src/Prism/Scene/Scene.cpp
index b3bd442..c5729fd 100644
--- a/Prism/src/Prism/Scene/Scene.cpp
+++ b/Prism/src/Prism/Scene/Scene.cpp
@@ -19,8 +19,11 @@
 #define PX_PHYSX_STATIC_LIB
 #include <PxPhysicsAPI.h>
 
+#include "Prism/Asset/AssetsManager.h"
 #include "Prism/Core/Input.h"
 #include "Prism/Core/Math/Math.h"
+#include "Prism/Renderer/Renderer.h"
+#include "Prism/Renderer/Renderer2D.h"
 
 namespace Prism
 {
@@ -147,6 +150,9 @@ namespace Prism
         const auto skyboxShader = Shader::Create("assets/shaders/Skybox.glsl");
         m_SkyboxMaterial = MaterialInstance::Create(Material::Create(skyboxShader));
         m_SkyboxMaterial->SetFlag(MaterialFlag::DepthTest, false);
+
+        m_CameraIcon = AssetsManager::GetAsset<Texture2D>("assets/editor/Camera.png");
+        m_LightIcon = AssetsManager::GetAsset<Texture2D>("assets/editor/light.png");
     }
 
     void Scene::OnShutdown()
@@ -225,7 +231,7 @@ namespace Prism
         }
     }
 
-    void Scene::OnRenderRuntime(TimeStep ts)
+    void Scene::OnRenderRuntime(const TimeStep ts)
     {
         /////////////////////////////////////////////////////////////////////
         //                        RENDER 3D SCENE                          //
@@ -294,26 +300,33 @@ namespace Prism
         /////////////////////////////////////////////////////////////////////
 
 
-#if 0
-        // Render all sprites
-        Renderer2D::BeginScene(*camera);
+        /////////////////////////////////////////////////////////////////////
+        //                        RENDER 2D SCENE                          //
+        /////////////////////////////////////////////////////////////////////
+
+        Renderer::BeginRenderPass(SceneRenderer::GetFinalRenderPass(), false);
+        const glm::mat4 cameraViewProjection = cameraViewMatrix * camera.GetProjectionMatrix();
+        Renderer2D::BeginScene(cameraViewProjection, false);
+
+        // render sprite
         {
-            auto group = m_Registry.group<TransformComponent>(entt::get<SpriteRenderer>);
-            for (auto entity : group)
+            const auto entitiesGroup = m_Registry.group<TransformComponent>(entt::get<SpriteRendererComponent>);
+            for (const auto entity : entitiesGroup)
             {
-                auto [transformComponent, spriteRendererComponent] = group.get<TransformComponent, SpriteRenderer>(entity);
+                auto [transformComponent, spriteRendererComponent] = entitiesGroup.get<TransformComponent, SpriteRendererComponent>(entity);
                 if (spriteRendererComponent.Texture)
-                    Renderer2D::DrawQuad(transformComponent.Transform, spriteRendererComponent.Texture, spriteRendererComponent.TilingFactor);
+                    Renderer2D::DrawQuad(transformComponent.GetTransform(), spriteRendererComponent.Texture, spriteRendererComponent.TilingFactor, spriteRendererComponent.Color);
                 else
-                    Renderer2D::DrawQuad(transformComponent.Transform, spriteRendererComponent.Color);
+                    Renderer2D::DrawQuad(transformComponent.GetTransform(), spriteRendererComponent.Color);
             }
         }
 
+
         Renderer2D::EndScene();
-#endif
+        Renderer::EndRenderPass();
     }
 
-    void Scene::OnRenderEditor(TimeStep ts, const EditorCamera& editorCamera)
+    void Scene::OnRenderEditor(const TimeStep ts, const EditorCamera& editorCamera)
     {
         /////////////////////////////////////////////////////////////////////
         //                        RENDER 3D SCENE                          //
@@ -340,111 +353,148 @@ namespace Prism
 
         // TODO: only one sky light at the moment!
         {
-			m_Environment = Ref<Environment>::Create();
             auto lights = m_Registry.group<SkyLightComponent>(entt::get<TransformComponent>);
-            for (auto entity : lights)
+            if (!lights.empty())
             {
-                auto [transformComponent, skyLightComponent] = lights.get<TransformComponent, SkyLightComponent>(entity);
-                m_Environment = skyLightComponent.SceneEnvironment;
-                m_EnvironmentIntensity = skyLightComponent.Intensity;
-                SetSkybox(m_Environment->RadianceMap);
+                for (auto entity : lights)
+                {
+                    auto [transformComponent, skyLightComponent] = lights.get<TransformComponent, SkyLightComponent>(entity);
+                    m_Environment = skyLightComponent.SceneEnvironment;
+                    m_EnvironmentIntensity = skyLightComponent.Intensity;
+                    SetSkybox(m_Environment->RadianceMap);
+                }
+            }else
+            {
+                // TODO:
             }
         }
 
         m_SkyboxMaterial->Set("u_TextureLod", m_SkyboxLod);
 
         auto group = m_Registry.group<MeshComponent>(entt::get<TransformComponent>);
-        // SceneRenderer::BeginScene(this, { static_cast<Camera>(editorCamera), editorCamera.GetViewMatrix() });
 		SceneRenderer::BeginScene(this, { static_cast<Camera>(editorCamera), editorCamera.GetViewMatrix(), 0.1f, 1000.0f, 45.0f }); // TODO: real values
-        for (const auto entity : group)
         {
-            const auto& [transformComponent, meshComponent] = group.get<TransformComponent, MeshComponent>(entity);
-            if (meshComponent.Mesh)
+            for (const auto entity : group)
             {
-                meshComponent.Mesh->OnUpdate(ts);
+                const auto& [transformComponent, meshComponent] = group.get<TransformComponent, MeshComponent>(entity);
+                if (meshComponent.Mesh)
+                {
+                    meshComponent.Mesh->OnUpdate(ts);
 
-				glm::mat4 transform = GetTransformRelativeToParent(Entity{ entity, this });
+                    glm::mat4 transform = GetTransformRelativeToParent(Entity{ entity, this });
 
-                // TODO: Should we render (logically)
-                if (m_SelectedEntity == entity)
-					SceneRenderer::SubmitSelectedMesh(meshComponent, transform);
-                else
-					SceneRenderer::SubmitMesh(meshComponent, transform);
+                    // TODO: Should we render (logically)
+                    if (m_SelectedEntity == entity)
+                        SceneRenderer::SubmitSelectedMesh(meshComponent, transform);
+                    else
+                        SceneRenderer::SubmitMesh(meshComponent, transform);
+                }
             }
-        }
 
-        {
-            const auto view = m_Registry.view<BoxColliderComponent>();
-            for (const auto entity : view)
             {
-                Entity e = { entity, this };
-                auto& collider = e.GetComponent<BoxColliderComponent>();
-                glm::mat4 transform = GetTransformRelativeToParent(e);
+                const auto view = m_Registry.view<BoxColliderComponent>();
+                for (const auto entity : view)
+                {
+                    Entity e = { entity, this };
+                    auto& collider = e.GetComponent<BoxColliderComponent>();
+                    glm::mat4 transform = GetTransformRelativeToParent(e);
 
-                if (m_SelectedEntity == entity)
-					SceneRenderer::SubmitColliderMesh(collider, transform);
+                    if (m_SelectedEntity == entity)
+                        SceneRenderer::SubmitColliderMesh(collider, transform);
+                }
             }
-        }
 
-        {
-            const auto view = m_Registry.view<SphereColliderComponent>();
-            for (const auto entity : view)
             {
-                Entity e = { entity, this };
-                auto& collider = e.GetComponent<SphereColliderComponent>();
-                glm::mat4 transform = GetTransformRelativeToParent(e);
+                const auto view = m_Registry.view<SphereColliderComponent>();
+                for (const auto entity : view)
+                {
+                    Entity e = { entity, this };
+                    auto& collider = e.GetComponent<SphereColliderComponent>();
+                    glm::mat4 transform = GetTransformRelativeToParent(e);
 
-                if (m_SelectedEntity == entity)
-					SceneRenderer::SubmitColliderMesh(collider, transform);
+                    if (m_SelectedEntity == entity)
+                        SceneRenderer::SubmitColliderMesh(collider, transform);
+                }
             }
-        }
 
-        {
-            const auto view = m_Registry.view<CapsuleColliderComponent>();
-            for (const auto entity : view)
             {
-                Entity e = { entity, this };
-                auto& collider = e.GetComponent<CapsuleColliderComponent>();
-                glm::mat4 transform = GetTransformRelativeToParent(e);
+                const auto view = m_Registry.view<CapsuleColliderComponent>();
+                for (const auto entity : view)
+                {
+                    Entity e = { entity, this };
+                    auto& collider = e.GetComponent<CapsuleColliderComponent>();
+                    glm::mat4 transform = GetTransformRelativeToParent(e);
 
-                if (m_SelectedEntity == entity)
-					SceneRenderer::SubmitColliderMesh(collider, transform);
+                    if (m_SelectedEntity == entity)
+                        SceneRenderer::SubmitColliderMesh(collider, transform);
+                }
             }
-        }
 
-        {
-            const auto view = m_Registry.view<MeshColliderComponent>();
-            for (const auto entity : view)
             {
-                Entity e = { entity, this };
-                auto& collider = e.GetComponent<MeshColliderComponent>();
-                glm::mat4 transform = GetTransformRelativeToParent(e);
+                const auto view = m_Registry.view<MeshColliderComponent>();
+                for (const auto entity : view)
+                {
+                    Entity e = { entity, this };
+                    auto& collider = e.GetComponent<MeshColliderComponent>();
+                    glm::mat4 transform = GetTransformRelativeToParent(e);
 
-                if (m_SelectedEntity == entity)
-					SceneRenderer::SubmitColliderMesh(collider, transform);
+                    if (m_SelectedEntity == entity)
+                        SceneRenderer::SubmitColliderMesh(collider, transform);
+                }
             }
         }
 
         SceneRenderer::EndScene();
         /////////////////////////////////////////////////////////////////////
 
-#if 0
-        // Render all sprites
-        Renderer2D::BeginScene(*camera);
+
+        /////////////////////////////////////////////////////////////////////
+        //                        RENDER 2D SCENE                          //
+        /////////////////////////////////////////////////////////////////////
+
+        Renderer::BeginRenderPass(SceneRenderer::GetFinalRenderPass(), false);
+        const auto viewProj = editorCamera.GetViewProjection();
+        Renderer2D::BeginScene(viewProj, false);
+
+        // render sprite
         {
-            auto group = m_Registry.group<TransformComponent>(entt::get<SpriteRenderer>);
-            for (auto entity : group)
+            const auto entitiesGroup = m_Registry.group<TransformComponent>(entt::get<SpriteRendererComponent>);
+            for (const auto entity : entitiesGroup)
             {
-                auto [transformComponent, spriteRendererComponent] = group.get<TransformComponent, SpriteRenderer>(entity);
+                auto [transformComponent, spriteRendererComponent] = entitiesGroup.get<TransformComponent, SpriteRendererComponent>(entity);
                 if (spriteRendererComponent.Texture)
-                    Renderer2D::DrawQuad(transformComponent.Transform, spriteRendererComponent.Texture, spriteRendererComponent.TilingFactor);
+                    Renderer2D::DrawQuad(transformComponent.GetTransform(), spriteRendererComponent.Texture, spriteRendererComponent.TilingFactor, spriteRendererComponent.Color);
                 else
-                    Renderer2D::DrawQuad(transformComponent.Transform, spriteRendererComponent.Color);
+                    Renderer2D::DrawQuad(transformComponent.GetTransform(), spriteRendererComponent.Color);
             }
         }
 
-        Renderer2D::EndScene();
-#endif
+
+        // render camera icon
+        {
+            const auto cameras = m_Registry.view<CameraComponent>();
+            if (!cameras.empty())
+            {
+                for (auto& entity : cameras)
+                {
+                    Entity e = { entity, this };
+                    Renderer2D::DrawBillBoardQuad(e.Transform().Translation, m_CameraIcon, editorCamera.GetPosition(), editorCamera.GetUpDirection());
+                }
+            }
+
+            const auto lights = m_Registry.view<SkyLightComponent>();
+            if (!lights.empty())
+            {
+                for (auto& entity : lights)
+                {
+                    Entity e = { entity, this };
+                    Renderer2D::DrawBillBoardQuad(e.Transform().Translation, m_LightIcon, editorCamera.GetPosition(), editorCamera.GetUpDirection());
+                }
+            }
+        }
+
+            Renderer2D::EndScene();
+        Renderer::EndRenderPass();
     }
 
     void Scene::OnEvent(Event& e)
diff --git a/Prism/src/Prism/Scene/Scene.h b/Prism/src/Prism/Scene/Scene.h
index 73051e4..2926c54 100644
--- a/Prism/src/Prism/Scene/Scene.h
+++ b/Prism/src/Prism/Scene/Scene.h
@@ -137,6 +137,10 @@ namespace Prism
 
         float m_SkyboxLod = 1.0f;
 
+
+        Ref<Texture2D> m_CameraIcon;
+        Ref<Texture2D> m_LightIcon;
+
     private:
         friend class Entity;
         friend class SceneRenderer;
diff --git a/Prism/src/Prism/Scene/SceneCamera.cpp b/Prism/src/Prism/Scene/SceneCamera.cpp
index 6ee8c03..570e598 100644
--- a/Prism/src/Prism/Scene/SceneCamera.cpp
+++ b/Prism/src/Prism/Scene/SceneCamera.cpp
@@ -43,7 +43,7 @@ namespace Prism
             const float aspect = (float)width / (float)height;
             const float w = m_OrthographicSize * aspect;
             const float h = m_OrthographicSize;
-            m_ProjectionMatrix = glm::ortho(-w * 0.5f, w * 0.5f, -h * 0.5f, h * 0.5f);
+            m_ProjectionMatrix = glm::ortho(-w * 0.5f, w * 0.5f, -h * 0.5f, h * 0.5f, m_OrthographicNear, m_OrthographicFar);
             break;
         }
     }