#5746: Implement a few PatchNode methods

include/ipatch.h

@@ -211,6 +211,12 @@ class IPatch
 
 	// Alligns the assigned texture at the given edge (if possible)
 	virtual void alignTexture(AlignEdge type) = 0;
+
+    // Reverts any transform that has been applied since the last time freezeTransform() was called
+    virtual void revertTransform() = 0;
+
+    // Promotes the current transformed state to the new base state
+    virtual void freezeTransform() = 0;
 };
 
 namespace patch

radiantcore/patch/Patch.h

@@ -146,9 +146,9 @@ class Patch :
 	void evaluateTransform();
 
 	// Revert the changes, fall back to the saved state in <m_ctrl>
-	void revertTransform();
+	void revertTransform() override;
 	// Apply the transformed control array, save it into <m_ctrl> and overwrite the old values
-	void freezeTransform();
+	void freezeTransform() override;
 
 	// callback for changed control points
 	void controlPointsChanged() override;

radiantcore/selection/textool/PatchNode.h

@@ -20,45 +20,100 @@ class PatchNode :
 
     void beginTransformation() override
     {
+        _patch.undoSave();
     }
 
     void revertTransformation() override
     {
+        _patch.revertTransform();
+        _patch.controlPointsChanged();
     }
 
     void applyTransformToSelected(const Matrix3& transform) override
     {
-        // TODO
+        foreachVertex([&](PatchControl& vertex)
+        {
+            vertex.texcoord = transform * vertex.texcoord;
+        });
+
+        _patch.controlPointsChanged();
     }
 
     void commitTransformation() override
     {
+        _patch.freezeTransform();
     }
 
     const AABB& localAABB() const
     {
         _bounds = AABB();
 
-        for (std::size_t col = 0; col < _patch.getWidth(); ++col)
+        foreachVertex([&](PatchControl& vertex)
         {
-            for (std::size_t row = 0; row < _patch.getHeight(); ++row)
-            {
-                const auto& ctrl = _patch.ctrlAt(row, col);
-                _bounds.includePoint({ ctrl.texcoord.x(), ctrl.texcoord.y(), 0 });
-            }
-        }
+            _bounds.includePoint({ vertex.texcoord.x(), vertex.texcoord.y(), 0 });
+        });
 
         return _bounds;
     }
 
     void testSelect(Selector& selector, SelectionTest& test) override
     {
-        // TODO
+        test.BeginMesh(Matrix4::getIdentity(), true);
+
+        foreachVertex([&](PatchControl& vertex)
+        {
+            SelectionIntersection intersection;
+
+            test.TestPoint(Vector3(vertex.texcoord.x(), vertex.texcoord.y(), 0), intersection);
+
+            if (intersection.isValid())
+            {
+                Selector_add(selector, *this);
+            }
+        });
     }
 
     void render() override
     {
-        // TODO
+        glEnable(GL_BLEND);
+        glBlendColor(0, 0, 0, 0.3f);
+        glBlendFunc(GL_CONSTANT_ALPHA_EXT, GL_ONE_MINUS_CONSTANT_ALPHA_EXT);
+
+        glColor3f(1, 1, 1);
+
+        // Get the tesselation and the first
+        auto tess = _patch.getTesselatedPatchMesh();
+
+        auto renderInfo = _patch.getRenderIndices();
+        auto* strip_indices = &renderInfo.indices.front();
+
+        for (std::size_t i = 0; i < renderInfo.numStrips; i++, strip_indices += renderInfo.lenStrips)
+        {
+            glBegin(GL_QUAD_STRIP);
+
+            for (std::size_t offset = 0; offset < renderInfo.lenStrips; offset++)
+            {
+                // Retrieve the mesh vertex from the line strip
+                auto& meshVertex = tess.vertices[*(strip_indices + offset)];
+                glVertex2d(meshVertex.texcoord[0], meshVertex.texcoord[1]);
+            }
+
+            glEnd();
+        }
+
+        glDisable(GL_BLEND);
+    }
+
+private:
+    void foreachVertex(const std::function<void(PatchControl&)>& functor) const
+    {
+        for (std::size_t col = 0; col < _patch.getWidth(); ++col)
+        {
+            for (std::size_t row = 0; row < _patch.getHeight(); ++row)
+            {
+                functor(_patch.ctrlAt(row, col));
+            }
+        }
     }
 };