DrawNode local properties full supported now, removed all hardcoded clamps; DrawNode cpp-tests switched to ImGUI ;

axmol/2d/DrawNode.h

@@ -489,9 +489,9 @@ class AX_DLL DrawNode : public Node, public BlendProtocol
      */
 
     void drawColoredTriangle(const Vec2* vertices3, const Color* color3);
-    void drawTriangle(const Vec2* vertices3, const Color& color);
 
-    void drawTriangle(const Vec2& p1, const Vec2& p2, const Vec2& p3, const Color& color);
+    void drawTriangle(const Vec2* vertices3, const Color& color, float thickness = 1.0f);
+    void drawTriangle(const Vec2& p1, const Vec2& p2, const Vec2& p3, const Color& color, float thickness = 1.0f);
 
     void drawSolidTriangle(const Vec2* vertices3,
                            const Color& fillColor,
@@ -582,15 +582,9 @@ class AX_DLL DrawNode : public Node, public BlendProtocol
     // Internal function _drawDot
     void _drawDot(const Vec2& pos, float radius, const Color& color);
 
-    // Internal function _drawTriangle
+    // Internal function _drawColoredTriangle
     // Note: modifies supplied vertex array
-    void _drawTriangle(Vec2* vertices3,
-                       const Color& borderColor,
-                       const Color& fillColor,
-                       bool solid      = true,
-                       float thickness = 0.0f);
-
-    void _drawColoredTriangle(Vec2* vertices3, const Color* color3);
+    void _drawColoredTriangle(const Vec2* vertices3, const Color* color3);
 
     // Internal function _drawAStar
     void _drawAStar(const Vec2& center,
@@ -663,96 +657,91 @@ class AX_DLL DrawNode : public Node, public BlendProtocol
      */
     tlx::pod_vector<Vec2> _transform(const Vec2* vertices, unsigned int& count, bool closedPolygon = false);
 
-    void applyTransform(const Vec2* from, Vec2* to, unsigned int count);
-
-private:
-    AX_DISALLOW_COPY_AND_ASSIGN(DrawNode);
+    void applyLocalTransform(const Vec2* from, Vec2* to, unsigned int count) const;
 
+    /// Advanced settings
 public:
-    class AX_DLL Properties
+    float getThicknessScale() const { return _thicknessScale; }
+    void setThicknessScale(float s)
     {
-    public:
-        float factor;  /// thickness scale factor
-
-        // transforming stuff
-        Vec2 scale;
-        Vec2 center;
-        float rotation;
-        Vec2 position;
-
-        // Drawing flags
-        bool transform = false;
-        bool drawOrder = false;
-
-        /** Set the DrawNode drawOrder
-        *
-        * @param drawOrder. true/false = On/Off
-        * Its for performance there
-        * false = cocos2dx behaviour => faster but works only on 1.0f thickness
-
-        */
-        void setDrawOrder(bool dO) { drawOrder = dO; };
-
-        /** Get the DrawNode drawOrder
-         *
-         */
-        bool getDrawOrder(void) { return drawOrder; };
-
-        /** Set the DrawNode transform
-         *
-         * @param transform. true/false = On/Off
-         *
-         */
-        void setTransform(bool t) { transform = t; };
-
-        /** Get the DrawNode transform
-         *
-         */
-        bool getTransform(void) { return transform; };
-
-        /** Set the DrawNode scale for each drawing primitive after this.
-
-        */
-        void setScale(Vec2 s) { scale = s; };
-
-        /** Set the DrawNode rotation for each drawing primitive after this.
+        _thicknessScale = s;
+        _linesDirty = _trianglesDirty = true;
+    }
 
-        */
-        void setRotation(float r) { rotation = r; };
-
-        /** Get the DrawNode rotation for each drawing primitive after this.
-
-        */
-        float getRotation() { return rotation; };
-
-        /** Set the DrawNode center of rotation for each drawing primitive after this.
+    bool isLocalTransformEnabled() const { return _localTransformEnabled; }
+    void setLocalTransformEnabled(bool e)
+    {
+        _localTransformEnabled = e;
+        _linesDirty = _trianglesDirty = true;
+    }
 
-        */
-        void setCenter(Vec2 c) { center = c; };
+    void setLocalScale(const Vec2& s)
+    {
+        _localScale     = s;
+        _trianglesDirty = _linesDirty = true;
+    }
+    const Vec2& getLocalScale() const { return _localScale; }
 
-        /** Get the DrawNode center of rotation for each drawing primitive after this.
+    void setLocalPivot(const Vec2& c)
+    {
+        _localPivot     = c;
+        _trianglesDirty = _linesDirty = true;
+    }
+    const Vec2& getLocalPivot() const { return _localPivot; }
 
-        */
-        Vec2 getCenter() { return center; };
+    void setLocalRotation(float a)
+    {
+        _localRotation    = a;
+        _localRotationRad = AX_DEGREES_TO_RADIANS(_localRotation);
+        _trianglesDirty = _linesDirty = true;
+    }
+    float getLocalRotation() const { return _localRotation; }
 
-        /** Set the DrawNode position for each drawing primitive after this.
+    void setLocalPosition(const Vec2& p)
+    {
+        _localPosition  = p;
+        _trianglesDirty = _linesDirty = true;
+    }
+    const Vec2& getLocalPosition() const { return _localPosition; }
 
-        */
-        void setPosition(Vec2 p) { position = p; };
+    void setPreserveDrawOrder(bool v)
+    {
+        _preserveDrawOrder = v;
+        _trianglesDirty = _linesDirty = true;
+    }
+    bool isPreserveDrawOrder() const { return _preserveDrawOrder; }
 
-        /** Get the DrawNode position for drawing primitive.
+    // convenience: reset to defaults
+    void resetAdvancedSettings()
+    {
+        _thicknessScale        = 1.0f;
+        _localScale            = Vec2(1.0f, 1.0f);
+        _localPivot            = Vec2::ZERO;
+        _localRotation         = 0.0f;
+        _localRotationRad      = 0.0f;
+        _localPosition         = Vec2::ZERO;
+        _preserveDrawOrder     = false;
+        _localTransformEnabled = false;
+        _trianglesDirty = _linesDirty = _pointsDirty = true;
+    }
 
-        */
-        Vec2 getPosition() { return position; };
+protected:
+    // thickness scale (was factor)
+    float _thicknessScale{1.0f};
 
-        /** Set all default DrawNode properties.
+    // optional local transform applied to primitives when enabled
+    Vec2 _localScale{1.0f, 1.0f};
+    Vec2 _localPivot{0.0f, 0.0f};
+    float _localRotation{0.0f};     // local rotation in degrees
+    float _localRotationRad{0.0f};  // local rotation in radians (cached for efficiency)
+    Vec2 _localPosition{0.0f, 0.0f};
 
-        */
-        void setDefaultValues();
-        float getFactor() { return factor; };
-        void setFactor(float fac) { factor = fac; };
+    // flags
+    bool _localTransformEnabled{false};
+    bool _preserveDrawOrder{false};
 
-    } properties;
+private:
+    AX_DISALLOW_COPY_AND_ASSIGN(DrawNode);
 };
 
 /** @} */

axmol/2d/Label.cpp

@@ -1523,8 +1523,7 @@ void Label::enableUnderline()
         _lineDrawNode = DrawNode::create();
         _lineDrawNode->setGlobalZOrder(getGlobalZOrder());
         _lineDrawNode->setOpacity(_displayedColor.a);
-        _lineDrawNode->properties.setFactor(_lineDrawNode->properties.getFactor() *
-                                            2.0f);  // 2.0f: Makes the line smaller
+        _lineDrawNode->setThicknessScale(_lineDrawNode->getThicknessScale() * 0.5f);  // 0.5f: Makes the line smaller
         addChild(_lineDrawNode, 100000);
     }
 }
@@ -1542,8 +1541,7 @@ void Label::enableStrikethrough()
         _lineDrawNode = DrawNode::create();
         _lineDrawNode->setGlobalZOrder(getGlobalZOrder());
         _lineDrawNode->setOpacity(_displayedColor.a);
-        _lineDrawNode->properties.setFactor(_lineDrawNode->properties.getFactor() *
-                                            2.0f);  // 2.0f: Makes the line smaller
+        _lineDrawNode->setThicknessScale(_lineDrawNode->getThicknessScale() * 0.5f);  // 0.5f: Makes the line smaller
         addChild(_lineDrawNode, 100000);
     }
 }