Full gizmo implementation

Author: tsun3doku

HeatSpectra/App.cpp

@@ -163,6 +163,13 @@ void App::applyGizmoTranslation() {
             else if (lastPick.gizmoAxis == PickedGizmoAxis::Z) hitAxis = GizmoAxis::Z;
 
             if (hitAxis != GizmoAxis::None) {
+                // Auto-detect mode based on stencil value: 3-5 = translate, 6-8 = rotate
+                if (lastPick.stencilValue >= 3 && lastPick.stencilValue <= 5) {
+                    gizmo->setMode(GizmoMode::Translate);
+                } else if (lastPick.stencilValue >= 6 && lastPick.stencilValue <= 8) {
+                    gizmo->setMode(GizmoMode::Rotate);
+                }
+                
                 // Start drag using original click position
                 PickingRequest pickReq = modelSelection->getLastPickRequest();
                 glm::vec3 gizmoPosition = gizmo->calculateGizmoPosition(*resourceManager, *modelSelection);
@@ -174,6 +181,7 @@ void App::applyGizmoTranslation() {
                 gizmo->startDrag(hitAxis, rayOrigin, rayDir, cachedGizmoPosition);
                 modelStartPosition = cachedGizmoPosition;
                 accumulatedTranslation = glm::vec3(0.0f);
+                accumulatedRotation = 0.0f;
 
                 modelSelection->clearLastPickedResult();
             }
@@ -183,23 +191,52 @@ void App::applyGizmoTranslation() {
     if (!isDraggingGizmo || !modelSelection || !resourceManager)
         return;
 
-    glm::vec3 currentTranslation = accumulatedTranslation; 
-    glm::vec3 deltaTranslation = currentTranslation - lastAppliedTranslation;
-    
-    if (glm::length(deltaTranslation) < 1e-6) 
-        return;
-    
-    // Apply incremental translation to all selected models
     const auto& selectedIDs = modelSelection->getSelectedModelIDsRenderThread();
-    for (uint32_t id : selectedIDs) {
-        if (id == 1) {
-            resourceManager->getVisModel().translate(deltaTranslation);
-        } else if (id == 2) {
-            resourceManager->getHeatModel().translate(deltaTranslation);
+    
+    if (gizmo->getMode() == GizmoMode::Translate) {
+        glm::vec3 currentTranslation = accumulatedTranslation; 
+        glm::vec3 deltaTranslation = currentTranslation - lastAppliedTranslation;
+        
+        if (glm::length(deltaTranslation) < 1e-6) 
+            return;
+        
+        // Apply incremental translation to all selected models
+        for (uint32_t id : selectedIDs) {
+            if (id == 1) {
+                resourceManager->getVisModel().translate(deltaTranslation);
+            } else if (id == 2) {
+                resourceManager->getHeatModel().translate(deltaTranslation);
+            }
+        }
+        
+        lastAppliedTranslation = currentTranslation;
+    }
+    else if (gizmo->getMode() == GizmoMode::Rotate) {
+        float currentRotation = accumulatedRotation;
+        float deltaRotation = currentRotation - lastAppliedRotation;
+        
+        if (fabs(deltaRotation) < 0.01f) 
+            return;
+        
+        // Get rotation axis
+        glm::vec3 rotationAxis;
+        GizmoAxis activeAxis = gizmo->getActiveAxis();
+        if (activeAxis == GizmoAxis::X) rotationAxis = glm::vec3(1, 0, 0);
+        else if (activeAxis == GizmoAxis::Y) rotationAxis = glm::vec3(0, 1, 0);
+        else if (activeAxis == GizmoAxis::Z) rotationAxis = glm::vec3(0, 0, 1);
+        else return;
+        
+        // Apply incremental rotation to all selected models around gizmo center
+        for (uint32_t id : selectedIDs) {
+            if (id == 1) {
+                resourceManager->getVisModel().rotate(glm::radians(deltaRotation), rotationAxis, cachedGizmoPosition);
+            } else if (id == 2) {
+                resourceManager->getHeatModel().rotate(glm::radians(deltaRotation), rotationAxis, cachedGizmoPosition);
+            }
         }
+        
+        lastAppliedRotation = currentRotation;
     }
-    
-    lastAppliedTranslation = currentTranslation;
 }
 
 void App::handleMouseMove(float mouseX, float mouseY) {
@@ -212,11 +249,15 @@ void App::handleMouseMove(float mouseX, float mouseY) {
         glm::vec3 rayOrigin = camera.getPosition();
         glm::vec3 rayDir = camera.screenToWorldRay(mouseX, mouseY, swapChainExtent.width, swapChainExtent.height);
 
-        // Use cached gizmo position
-        glm::vec3 newTranslation = gizmo->calculateTranslationDelta(rayOrigin, rayDir, cachedGizmoPosition, gizmo->getActiveAxis());
-        
-        // Store accumulated translation
-        accumulatedTranslation = newTranslation;
+        // Auto-detect based on active mode
+        if (gizmo->getMode() == GizmoMode::Translate) {
+            glm::vec3 newTranslation = gizmo->calculateTranslationDelta(rayOrigin, rayDir, cachedGizmoPosition, gizmo->getActiveAxis());
+            accumulatedTranslation = newTranslation;
+        } 
+        else if (gizmo->getMode() == GizmoMode::Rotate) {
+            float angle = gizmo->calculateRotationDelta(rayOrigin, rayDir, cachedGizmoPosition, gizmo->getActiveAxis());
+            accumulatedRotation = angle;
+        }
     }
 }
 
@@ -228,6 +269,8 @@ void App::handleMouseRelease(int button, float mouseX, float mouseY) {
         gizmo->endDrag();
         accumulatedTranslation = glm::vec3(0.0f);
         lastAppliedTranslation = glm::vec3(0.0f);
+        accumulatedRotation = 0.0f;
+        lastAppliedRotation = 0.0f;
     }
 }
 

HeatSpectra/App.h

@@ -96,6 +96,8 @@ class App {
     glm::vec3 modelStartPosition{0.0f};
     glm::vec3 accumulatedTranslation{0.0f};  // UI thread writes total translation
     glm::vec3 lastAppliedTranslation{0.0f};  // Render thread tracks what's been applied
+    float accumulatedRotation = 0.0f;  // UI thread writes total rotation angle (degrees)
+    float lastAppliedRotation = 0.0f;  // Render thread tracks applied rotation
     glm::vec3 cachedGizmoPosition{0.0f};  // Cached during drag to prevent stuttering
     bool isShuttingDown;
 

HeatSpectra/GBuffer.cpp

@@ -1336,11 +1336,11 @@ void GBuffer::createIntrinsicOverlayPipeline(VkExtent2D extent) {
     dynamicState.dynamicStateCount = static_cast<uint32_t>(dynamicStates.size());
     dynamicState.pDynamicStates = dynamicStates.data();
 
-    // Push constant for translation offset
+    // Push constant for model matrix
     VkPushConstantRange pushConstantRange{};
     pushConstantRange.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
     pushConstantRange.offset = 0;
-    pushConstantRange.size = sizeof(glm::vec3);
+    pushConstantRange.size = sizeof(glm::mat4);
 
     VkPipelineLayoutCreateInfo layoutInfo{};
     layoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
@@ -1641,14 +1641,14 @@ void GBuffer::recordCommandBuffer(ResourceManager& resourceManager, HeatSystem&
     // Reset depth bias
     vkCmdSetDepthBias(commandBuffer, 0.0f, 0.0f, 0.0f);
 
-    // Draw commonsub model with visModel's translation offset
+    // Draw commonsub model with visModel's full transformation
     if (drawCommonSubdivision) {
         vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, intrinsicOverlayPipeline);
 
-        // Pass visModel's translation offset so commonSub follows it
-        glm::vec3 offset = resourceManager.getVisModel().getTranslationOffset();
+        // Pass visModel's full model matrix so commonSub follows translation AND rotation
+        glm::mat4 modelMatrix = resourceManager.getVisModel().getModelMatrix();
         vkCmdPushConstants(commandBuffer, intrinsicOverlayPipelineLayout, 
-            VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(glm::vec3), &offset);
+            VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(glm::mat4), &modelMatrix);
 
         vkCmdSetDepthBias(commandBuffer, 0.1f, 0.0f, 0.1f);