use circle instead of Square in Gizmo3DMove

example/Gizmo/Gizmo.h

@@ -20,14 +20,15 @@ enum class GizmoColor:uint
 
 enum class GizmoShape:uint
 {
-    Plane=0,    //平面
+    Square=0,   //方块
+    Circle,     //圆
     Cube,       //立方体
     Sphere,     //球
     Cone,       //圆锥
     Cylinder,   //圆柱
     Torus,      //圆环
 
-    ENUM_CLASS_RANGE(Plane,Torus)
+    ENUM_CLASS_RANGE(Square,Torus)
 };
 
 bool InitGizmoResource(RenderResource *);

example/Gizmo/Gizmo3DMove.cpp

@@ -59,11 +59,11 @@ bool InitGizmoMoveStaticMesh()
         GetGizmoRenderable(GizmoShape::Cone,GizmoColor::Blue),
     };
 
-    Renderable *plane[3]=
+    Renderable *circle[3]=
     {
-        GetGizmoRenderable(GizmoShape::Plane,GizmoColor::Red),
-        GetGizmoRenderable(GizmoShape::Plane,GizmoColor::Green),
-        GetGizmoRenderable(GizmoShape::Plane,GizmoColor::Blue)
+        GetGizmoRenderable(GizmoShape::Circle,GizmoColor::Red),
+        GetGizmoRenderable(GizmoShape::Circle,GizmoColor::Green),
+        GetGizmoRenderable(GizmoShape::Circle,GizmoColor::Blue)
     };
 
     if(!sphere)
@@ -77,63 +77,65 @@ bool InitGizmoMoveStaticMesh()
         if(!cone[i])
             return(false);
 
-        if(!plane[i])
+        if(!circle[i])
             return(false);
     }
 
     {
-        SceneNode *root_node=new SceneNode(scale(0.5f),sphere);
+        SceneNode *root_node=new SceneNode();
+        
+        root_node->CreateSubNode(sphere);
 
         {
             Transform tm;
 
             const Vector3f one_scale(1);
-            const Vector3f plane_scale(2);
-            const Vector3f cylinder_scale(0.35f,0.35f,4.0f);
+            const Vector3f circle_scale(2);
+            const Vector3f cylinder_scale(GIZMO_CYLINDER_RADIUS,GIZMO_CYLINDER_RADIUS,GIZMO_CYLINDER_HALF_LENGTH);
 
             {
                 tm.SetScale(cylinder_scale);
-                tm.SetTranslation(0,0,4.5f);
+                tm.SetTranslation(0,0,GIZMO_CYLINDER_OFFSET);
                 root_node->CreateSubNode(tm,cylinder[2]);       //Z 向上圆柱
 
                 tm.SetScale(one_scale);
-                tm.SetTranslation(0,0,9.5f);
+                tm.SetTranslation(0,0,GIZMO_CONE_OFFSET);
                 root_node->CreateSubNode(tm,cone[2]);           //Z 向上圆锥
 
-                tm.SetScale(plane_scale);
-                tm.SetTranslation(5,5,0);
-                root_node->CreateSubNode(tm,plane[2]);
+                tm.SetScale(circle_scale);
+                tm.SetTranslation(GIZMO_TWO_AXIS_OFFSET,GIZMO_TWO_AXIS_OFFSET,0);
+                root_node->CreateSubNode(tm,circle[2]);
             }
 
             {
                 tm.SetScale(cylinder_scale);
                 tm.SetRotation(AxisVector::Y,90);
-                tm.SetTranslation(4.5f,0,0);
+                tm.SetTranslation(GIZMO_CYLINDER_OFFSET,0,0);
                 root_node->CreateSubNode(tm,cylinder[0]);       //X 向右圆柱
 
                 tm.SetScale(one_scale);
-                tm.SetTranslation(9.5f,0,0);
+                tm.SetTranslation(GIZMO_CONE_OFFSET,0,0);
                 root_node->CreateSubNode(tm,cone[0]);           //X 向右圆锥
 
-                tm.SetScale(plane_scale);
-                tm.SetTranslation(0,5,5);
-                root_node->CreateSubNode(tm,plane[0]);
+                tm.SetScale(circle_scale);
+                tm.SetTranslation(0,GIZMO_TWO_AXIS_OFFSET,GIZMO_TWO_AXIS_OFFSET);
+                root_node->CreateSubNode(tm,circle[0]);
             }
 
             {
                 tm.SetScale(cylinder_scale);
                 tm.SetRotation(AxisVector::X,-90);
-                tm.SetTranslation(0,4.5f,0);
+                tm.SetTranslation(0,GIZMO_CYLINDER_OFFSET,0);
                 
                 root_node->CreateSubNode(tm,cylinder[1]);       //Y 向前圆柱
 
                 tm.SetScale(one_scale);
-                tm.SetTranslation(0,9.5f,0);
+                tm.SetTranslation(0,GIZMO_CONE_OFFSET,0);
                 root_node->CreateSubNode(tm,cone[1]);           //Y 向前圆锥
 
-                tm.SetScale(plane_scale);
-                tm.SetTranslation(5,0,5);
-                root_node->CreateSubNode(tm,plane[1]);
+                tm.SetScale(circle_scale);
+                tm.SetTranslation(GIZMO_TWO_AXIS_OFFSET,0,GIZMO_TWO_AXIS_OFFSET);
+                root_node->CreateSubNode(tm,circle[1]);
             }
         }
 

example/Gizmo/Gizmo3DRotate.cpp

@@ -42,7 +42,7 @@ bool InitGizmoRotateStaticMesh()
         {
             Transform tm;
 
-            tm.SetScale(5.0f);
+            tm.SetScale(GIZMO_ARROW_LENGTH);
 
             root_node->CreateSubNode(tm,torus[0]);
 

example/Gizmo/Gizmo3DScale.cpp

@@ -44,7 +44,7 @@ void ClearGizmoScaleStaticMesh()
 
 bool InitGizmoScaleStaticMesh()
 {
-    Renderable *sphere=GetGizmoRenderable(GizmoShape::Sphere,GizmoColor::White);
+    Renderable *center_cube=GetGizmoRenderable(GizmoShape::Cube,GizmoColor::White);
     Renderable *cylinder[3]
     {
         GetGizmoRenderable(GizmoShape::Cylinder,GizmoColor::Red),
@@ -59,14 +59,14 @@ bool InitGizmoScaleStaticMesh()
         GetGizmoRenderable(GizmoShape::Cube,GizmoColor::Blue),
     };
 
-    Renderable *plane[3]=
+    Renderable *square[3]=
     {
-        GetGizmoRenderable(GizmoShape::Plane,GizmoColor::Red),
-        GetGizmoRenderable(GizmoShape::Plane,GizmoColor::Green),
-        GetGizmoRenderable(GizmoShape::Plane,GizmoColor::Blue)
+        GetGizmoRenderable(GizmoShape::Square,GizmoColor::Red),
+        GetGizmoRenderable(GizmoShape::Square,GizmoColor::Green),
+        GetGizmoRenderable(GizmoShape::Square,GizmoColor::Blue)
     };
 
-    if(!sphere)
+    if(!center_cube)
         return(false);
 
     for(int i=0;i<3;i++)
@@ -77,63 +77,65 @@ bool InitGizmoScaleStaticMesh()
         if(!cube[i])
             return(false);
 
-        if(!plane[i])
+        if(!square[i])
             return(false);
     }
 
     {
-        SceneNode *root_node=new SceneNode(scale(0.5f),sphere);
+        SceneNode *root_node=new SceneNode();
+        
+        root_node->CreateSubNode(scale(GIZMO_CENTER_SPHERE_RADIUS*2),center_cube);
 
         {
             Transform tm;
 
-            const Vector3f one_scale(2);
+            const Vector3f one_scale(1);
             const Vector3f plane_scale(2);
-            const Vector3f cylinder_scale(0.35f,0.35f,4.0f);
+            const Vector3f cylinder_scale(GIZMO_CYLINDER_RADIUS,GIZMO_CYLINDER_RADIUS,GIZMO_CYLINDER_HALF_LENGTH);
 
             {
                 tm.SetScale(cylinder_scale);
-                tm.SetTranslation(0,0,4.5f);
+                tm.SetTranslation(0,0,GIZMO_CYLINDER_OFFSET);
                 root_node->CreateSubNode(tm,cylinder[2]);       //Z 向上圆柱
 
                 tm.SetScale(one_scale);
-                tm.SetTranslation(0,0,9.5f);
+                tm.SetTranslation(0,0,GIZMO_CONE_OFFSET);
                 root_node->CreateSubNode(tm,cube[2]);           //Z 向上圆锥
 
                 tm.SetScale(plane_scale);
-                tm.SetTranslation(5,5,0);
-                root_node->CreateSubNode(tm,plane[2]);
+                tm.SetTranslation(GIZMO_TWO_AXIS_OFFSET,GIZMO_TWO_AXIS_OFFSET,0);
+                root_node->CreateSubNode(tm,square[2]);
             }
 
             {
                 tm.SetScale(cylinder_scale);
                 tm.SetRotation(AxisVector::Y,90);
-                tm.SetTranslation(4.5f,0,0);
+                tm.SetTranslation(GIZMO_CYLINDER_OFFSET,0,0);
                 root_node->CreateSubNode(tm,cylinder[0]);       //X 向右圆柱
 
                 tm.SetScale(one_scale);
-                tm.SetTranslation(9.5f,0,0);
+                tm.SetTranslation(GIZMO_CONE_OFFSET,0,0);
                 root_node->CreateSubNode(tm,cube[0]);           //X 向右圆锥
 
                 tm.SetScale(plane_scale);
-                tm.SetTranslation(0,5,5);
-                root_node->CreateSubNode(tm,plane[0]);
+                tm.SetTranslation(0,GIZMO_TWO_AXIS_OFFSET,GIZMO_TWO_AXIS_OFFSET);
+                root_node->CreateSubNode(tm,square[0]);
             }
 
             {
                 tm.SetScale(cylinder_scale);
                 tm.SetRotation(AxisVector::X,-90);
-                tm.SetTranslation(0,4.5f,0);
+                tm.SetTranslation(0,GIZMO_CYLINDER_OFFSET,0);
                 
                 root_node->CreateSubNode(tm,cylinder[1]);       //Y 向前圆柱
 
                 tm.SetScale(one_scale);
-                tm.SetTranslation(0,9.5f,0);
+                tm.SetTranslation(0,GIZMO_CONE_OFFSET,0);
                 root_node->CreateSubNode(tm,cube[1]);           //Y 向前圆锥
 
                 tm.SetScale(plane_scale);
-                tm.SetTranslation(5,0,5);
-                root_node->CreateSubNode(tm,plane[1]);
+                tm.SetTranslation(GIZMO_TWO_AXIS_OFFSET,0,GIZMO_TWO_AXIS_OFFSET);
+                root_node->CreateSubNode(tm,square[1]);
             }
         }
 

example/Gizmo/GizmoResource.cpp

@@ -190,7 +190,18 @@ namespace
             using namespace inline_geometry;
 
             {
-                InitGizmoRenderable(GizmoShape::Plane,CreatePlane(gizmo_triangle.prim_creater),gizmo_triangle.pipeline);
+                InitGizmoRenderable(GizmoShape::Square,CreatePlaneSqaure(gizmo_triangle.prim_creater),gizmo_triangle.pipeline);
+            }
+
+            {
+                CircleCreateInfo cci;
+
+                cci.center=Vector2f(0,0);
+                cci.radius=Vector2f(0.5,0.5);
+                cci.field_count=16;
+                cci.has_center=false;
+                
+                InitGizmoRenderable(GizmoShape::Circle,CreateCircle3DByIndexTriangles(gizmo_triangle.prim_creater,&cci),gizmo_triangle.pipeline);
             }
 
             {
@@ -210,8 +221,8 @@ namespace
             {
                 ConeCreateInfo cci;
 
-                cci.radius      =1;         //圆锥半径
-                cci.halfExtend  =1;         //圆锤一半高度
+                cci.radius      =GIZMO_CONE_RADIUS;         //圆锥半径
+                cci.halfExtend  =1;                 //圆锤一半高度
                 cci.numberSlices=16;        //圆锥底部分割数
                 cci.numberStacks=3;         //圆锥高度分割数
 

example/Gizmo/GizmoResource.h

@@ -20,6 +20,21 @@ constexpr const COLOR gizmo_color[size_t(GizmoColor::RANGE_SIZE)]=
     COLOR::BlenderYellow,
 };
 
+constexpr const float GIZMO_ARROW_LENGTH=10;                ///<箭头整体长度
+constexpr const float GIZMO_CENTER_SPHERE_RADIUS=1.0f;      ///<中心球半径
+
+constexpr const float GIZMO_CONE_LENGTH=1.0f;               ///<圆锥高度
+constexpr const float GIZMO_CONE_RADIUS=1.0f;               ///<圆锥底部半径
+constexpr const float GIZMO_CONE_OFFSET=GIZMO_ARROW_LENGTH-(GIZMO_CONE_LENGTH/2.0f);    ///<圆锥偏移量
+
+constexpr const float GIZMO_CYLINDER_RADIUS=0.25f;          ///<圆柱半径
+constexpr const float GIZMO_CYLINDER_LENGTH=GIZMO_ARROW_LENGTH-GIZMO_CENTER_SPHERE_RADIUS-GIZMO_CONE_LENGTH;    ///<圆柱长度
+
+constexpr const float GIZMO_CYLINDER_HALF_LENGTH=GIZMO_CYLINDER_LENGTH/2.0f;                                    ///<圆柱一半长度
+constexpr const float GIZMO_CYLINDER_OFFSET=GIZMO_CYLINDER_HALF_LENGTH+GIZMO_CENTER_SPHERE_RADIUS;              ///<圆柱偏移量
+
+constexpr const float GIZMO_TWO_AXIS_OFFSET=5.0F;           ///<二轴调节点偏移量(方片或圆)
+
 Renderable *GetGizmoRenderable(const GizmoShape &gs,const GizmoColor &);
 
 StaticMesh *CreateGizmoStaticMesh(SceneNode *);

example/Gizmo/GizmoTest.cpp

@@ -6,61 +6,62 @@ using namespace hgl;
 using namespace hgl::graph;
 
 const Vector3f GizmoPosition(0,0,0);
-
-/**
-* 一种永远转向正面的场景节点
-*/
-class BillboardSceneNode:public SceneNode
-{
-    CameraInfo *camera_info=nullptr;
-    bool face_to_camera=false;
-
-    ViewportInfo *viewport_info=nullptr;
-    float fixed_scale=1.0;
-
-public:
-
-    using SceneNode::SceneNode;
-    virtual ~BillboardSceneNode()=default;
-
-    virtual void SetCameraInfo  (CameraInfo *   ci  ){camera_info   =ci;}
-    virtual void SetViewportInfo(ViewportInfo * vi  ){viewport_info =vi;}
-
-    virtual void SetFaceToCamera(bool           ftc ){face_to_camera=ftc;}
-    virtual void SetFixedScale  (const float    size){fixed_scale   =size;}
-
-    virtual bool RefreshTransform(const Transform &tf=IdentityTransform) override
-    {
-        if(!camera_info)
-        {
-            return SceneNode::RefreshTransform(tf);
-        }
-
-        if(face_to_camera)
-        {
-            LocalTransform.SetRotation(CalculateFacingRotationQuat(GetWorldPosition(),camera_info->view,AxisVector::X));
-        }
-
-        if(viewport_info)
-        {
-            const float screen_height=viewport_info->GetViewportHeight();
-
-            const Vector4f pos=camera_info->Project(GetWorldPosition());
-
-            LocalTransform.SetScale(pos.w*fixed_scale/screen_height);
-        }
-
-        return SceneNode::RefreshTransform(tf);
-    }
-};//class BillboardSceneNode:public SceneNode
+//
+///**
+//* 一种永远转向正面的场景节点
+//*/
+//class BillboardSceneNode:public SceneNode
+//{
+//    CameraInfo *camera_info=nullptr;
+//    bool face_to_camera=false;
+//
+//    ViewportInfo *viewport_info=nullptr;
+//    float fixed_scale=1.0;
+//
+//public:
+//
+//    using SceneNode::SceneNode;
+//    virtual ~BillboardSceneNode()=default;
+//
+//    virtual void SetCameraInfo  (CameraInfo *   ci  ){camera_info   =ci;}
+//    virtual void SetViewportInfo(ViewportInfo * vi  ){viewport_info =vi;}
+//
+//    virtual void SetFaceToCamera(bool           ftc ){face_to_camera=ftc;}
+//    virtual void SetFixedScale  (const float    size){fixed_scale   =size;}
+//
+//    virtual bool RefreshTransform(const Transform &tf=IdentityTransform) override
+//    {
+//        if(!camera_info)
+//        {
+//            return SceneNode::RefreshTransform(tf);
+//        }
+//
+//        if(face_to_camera)
+//        {
+//            LocalTransform.SetRotation(CalculateFacingRotationQuat(GetWorldPosition(),camera_info->view,AxisVector::X));
+//        }
+//
+//        if(viewport_info)
+//        {
+//            const float screen_height=viewport_info->GetViewportHeight();
+//
+//            const Vector4f pos=camera_info->Project(GetWorldPosition());
+//
+//            LocalTransform.SetScale(pos.w*fixed_scale/screen_height);
+//        }
+//
+//        return SceneNode::RefreshTransform(tf);
+//    }
+//};//class BillboardSceneNode:public SceneNode
 
 class TestApp:public SceneAppFramework
 {
     SceneNode root;
-    BillboardSceneNode *rotate_white_torus=nullptr;
+    //BillboardSceneNode *rotate_white_torus=nullptr;
 
     StaticMesh *sm_move=nullptr;
     StaticMesh *sm_rotate=nullptr;
+    StaticMesh *sm_scale=nullptr;
 
     Renderable *face_torus=nullptr;
 
@@ -73,6 +74,7 @@ private:
 
         sm_move     =GetGizmoMoveStaticMesh();
         sm_rotate   =GetGizmoRotateStaticMesh();
+        sm_scale    =GetGizmoScaleStaticMesh();
 
         face_torus  =GetGizmoRenderable(GizmoShape::Torus,GizmoColor::White);
 
@@ -88,21 +90,22 @@ private:
 
         root.CreateSubNode(sm_move->GetScene());
         root.CreateSubNode(sm_rotate->GetScene());
+        //root.CreateSubNode(sm_scale->GetScene());
 
-        {
-            Transform tm;
+        //{
+        //    Transform tm;
 
-            tm.SetScale(7.5);
+        //    tm.SetScale(7.5);
 
-            rotate_white_torus=new BillboardSceneNode(tm,face_torus);
+        //    rotate_white_torus=new BillboardSceneNode(tm,face_torus);
 
-            rotate_white_torus->SetCameraInfo(ci);
-            rotate_white_torus->SetFaceToCamera(true);
+        //    rotate_white_torus->SetCameraInfo(ci);
+        //    rotate_white_torus->SetFaceToCamera(true);
 
-            root.AddSubNode(rotate_white_torus);
-        }
+        //    root.AddSubNode(rotate_white_torus);
+        //}
 
-        root.RefreshTransform();
+        root.RefreshMatrix();
         render_list->SetCamera(ci);
         render_list->Expend(&root);
     }
@@ -149,8 +152,8 @@ public:
         //    root.SetLocalTransform(tm);
         //}
 
-        root.RefreshTransform();
-        render_list->UpdateTransform();
+        root.RefreshMatrix();
+        render_list->UpdateLocalToWorld();
 
         SceneAppFramework::BuildCommandBuffer(index);
     }

example/Gizmo/MetricCellsGrid.cpp

@@ -85,7 +85,7 @@ private:
     {
         PrimitiveCreater pc(device,material->GetDefaultVIL());
 
-        ro_plane=inline_geometry::CreatePlane(&pc);
+        ro_plane=inline_geometry::CreatePlaneSqaure(&pc);
 
         if(ro_plane)
             db->Add(ro_plane);

inc/hgl/graph/InlineGeometry.h

@@ -48,9 +48,9 @@ namespace hgl
             {
                 Vector2f center;            ///<圆心坐标
                 Vector2f radius;            ///<半径
-                uint field_count=8;         ///<分段次数
+                uint field_count=8;         ///<分段数量
 
-                bool has_color  =false;
+                bool has_center;            ///<是否有圆心点
 
                 Vector4f center_color;      ///<圆心颜色
                 Vector4f border_color;      ///<边缘颜色
@@ -59,7 +59,17 @@ namespace hgl
             /**
              * 创建一个2D圆形(扇形/线圈)
              */
-            Primitive *CreateCircle(PrimitiveCreater *pc,const CircleCreateInfo *cci);
+            Primitive *CreateCircle2D(PrimitiveCreater *pc,const CircleCreateInfo *cci);
+            
+            /**
+             * 创建一个3D圆形(扇形/圆形，XY，Z永远为0)
+             */
+            Primitive *CreateCircle3D(PrimitiveCreater *pc,const CircleCreateInfo *cci);
+
+            /**
+             * 创建一个使用三角形绘制的3D圆形(扇形/圆形，XY，Z永远为0)
+             */
+            Primitive *CreateCircle3DByIndexTriangles(PrimitiveCreater *pc,const CircleCreateInfo *cci);
 
             /**
              * 平面网格创建信息<br>
@@ -83,9 +93,9 @@ namespace hgl
             Primitive *CreatePlaneGrid3D(PrimitiveCreater *pc,const PlaneGridCreateInfo *pgci);
 
             /**
-             * 创建一个平面(三角形)
+             * 创建一个平面正方形(三角形)
              */
-            Primitive *CreatePlane(PrimitiveCreater *pc);
+            Primitive *CreatePlaneSqaure(PrimitiveCreater *pc);
 
             struct CubeCreateInfo
             {

inc/hgl/graph/MaterialRenderList.h

@@ -95,6 +95,6 @@ public:
 
     void Render(RenderCmdBuffer *);
 
-    void UpdateTransform();          //刷新所有对象的LocalToWorld矩阵
+    void UpdateLocalToWorld();          //刷新所有对象的LocalToWorld矩阵
 };//class MaterialRenderList
 VK_NAMESPACE_END

inc/hgl/graph/MaterialRenderMap.h

@@ -32,10 +32,10 @@ public:
             it->value->Render(rcb);
     }
 
-    void UpdateTransform()
+    void UpdateLocalToWorld()
     {
         for(auto *it:data_list)
-            it->value->UpdateTransform();
+            it->value->UpdateLocalToWorld();
     }
 };//class MaterialRenderMap
 VK_NAMESPACE_END

inc/hgl/graph/PrimitiveCreater.h

@@ -25,6 +25,7 @@ protected:
 
     uint32_t        vertices_number;  ///<顶点数量
 
+    bool            has_index;        ///<是否有索引
     uint32_t        index_number;     ///<索引数量
     IndexType       index_type;       ///<索引类型
     IndexBuffer *   ibo;              ///<索引缓冲区
@@ -62,6 +63,7 @@ public: //顶点缓冲区
 
 public: //索引缓冲区
 
+    const   bool            hasIndex()const{return vdm?has_index:index_number>0;}                                           ///<是否有索引缓冲区
     const   IndexType       GetIndexType()const{return index_type;}                                                         ///<取得索引类型
     const   uint32_t        GetIndexCount()const{return index_number;}                                                      ///<取得索引数量
 

inc/hgl/graph/RenderList.h

@@ -39,7 +39,7 @@ namespace hgl
 
             virtual bool Render(RenderCmdBuffer *);                                 ///<渲染所有对象
 
-            virtual void UpdateTransform();                                         ///<更新所有对象的变换数据
+            virtual void UpdateLocalToWorld();                                      ///<更新所有对象的变换数据
 
             virtual void Clear();                                                   ///<彻底清理
         };//class RenderList

inc/hgl/graph/RenderNode.h

@@ -15,7 +15,7 @@ namespace hgl
         {
             SceneNode *scene_node;
 
-            uint32 l2w_transform_version;
+            uint32 l2w_version;
             uint32 l2w_index;
 
             Vector3f world_position;

inc/hgl/graph/SceneNode.h

@@ -3,7 +3,6 @@
 
 #include<hgl/type/ObjectList.h>
 #include<hgl/graph/SceneOrient.h>
-#include<hgl/graph/VK.h>
 #include<hgl/graph/AABB.h>
 namespace hgl
 {
@@ -33,13 +32,18 @@ namespace hgl
             SceneNode()=default;
             SceneNode(SceneNode *);
             SceneNode(                      Renderable *ri  )                   {render_obj=ri;}
-            SceneNode(const Transform &tf                   ):SceneOrient(tf)   {}
-            SceneNode(const Transform &tf,  Renderable *ri  ):SceneOrient(tf)   {render_obj=ri;}
+            SceneNode(const Matrix4f &mat                   ):SceneOrient(mat)  {}
+            SceneNode(const Matrix4f &mat,  Renderable *ri  ):SceneOrient(mat)  {render_obj=ri;}
 
             virtual ~SceneNode()=default;
 
-            void Clear()
+            void Clear() override
             {
+                SceneOrient::Clear();
+
+                BoundingBox.SetZero();
+                LocalBoundingBox.SetZero();
+
                 SubNode.Clear();
                 render_obj=nullptr;
             }
@@ -129,7 +133,7 @@ namespace hgl
 
             virtual         void        SetBoundingBox      (const AABB &bb){BoundingBox=bb;}                           ///<设置绑定盒
 
-            virtual         bool        RefreshTransform    (const Transform &tf=IdentityTransform) override;           ///<刷新世界变换
+            virtual         void        RefreshMatrix       () override;           ///<刷新世界变换
             virtual         void        RefreshBoundingBox  ();                                                         ///<刷新绑定盒
 
             virtual const   AABB &      GetBoundingBox      ()const{return BoundingBox;}                                ///<取得绑定盒

inc/hgl/graph/SceneOrient.h

@@ -1,58 +1,157 @@
 #ifndef HGL_GRAPH_SCENE_ORIENT_INCLUDE
 #define HGL_GRAPH_SCENE_ORIENT_INCLUDE
 
-//#include<hgl/type/List.h>
-#include<hgl/math/Math.h>
 #include<hgl/graph/VK.h>
+#include<hgl/math/Transform.h>
 namespace hgl
 {
     namespace graph
     {
+        class SceneMatrix :public VersionData<Matrix4f>
+        {
+        protected:
+
+            Matrix4f parent_matrix;
+            Matrix4f local_matrix;
+            TransformManager transform_manager;
+            Matrix4f transform_matrix;
+
+        protected:
+
+            Matrix4f inverse_local_to_world_matrix;                                                                     ///<世界到本地矩阵
+            Matrix4f inverse_transpose_local_to_world_matrix;                                                           ///<世界到本地矩阵的转置矩阵
+
+            void MakeNewestData(Matrix4f &local_to_world_matrix) override                                               ///<生成最新的数据(需要派生类重载)
+            {
+                transform_manager.GetMatrix(transform_matrix);
+
+                local_to_world_matrix=parent_matrix*local_matrix*transform_matrix;
+            
+                inverse_local_to_world_matrix          =inverse(local_to_world_matrix);
+                inverse_transpose_local_to_world_matrix=transpose(inverse_local_to_world_matrix);
+            }
+
+        public:
+
+            void Clear()
+            {
+                parent_matrix=Identity4f;
+                local_matrix=Identity4f;
+                transform_matrix=Identity4f;
+                UpdateVersion();
+            }
+
+            const Matrix4f &GetLocalMatrix()const{return local_matrix;}                                                 ///<取得本地矩阵
+
+            const Matrix4f &GetLocalToWorldMatrix(){return GetNewestVersionData();}                                     ///<取得本地到世界矩阵
+            const Matrix4f &GetInverseLocalToWorldMatrix(){UpdateNewestData();return inverse_local_to_world_matrix;}    ///<取得世界到本地矩阵
+            const Matrix4f &GetInverseTransposeLocalToWorldMatrix()                                                     ///<取得世界到本地矩阵的转置矩阵
+            {
+                UpdateNewestData();
+                return inverse_transpose_local_to_world_matrix;
+            }
+
+            TransformManager &GetTransform() { return transform_manager; }                     ///<取得变换管理器
+
+        public:
+
+            SceneMatrix():VersionData(Identity4f)
+            {
+                Clear();
+            }
+
+            SceneMatrix(SceneMatrix &so):VersionData(so.GetLocalToWorldMatrix())
+            {
+                parent_matrix=so.parent_matrix;
+                local_matrix=so.local_matrix;
+                transform_manager=so.transform_manager;
+                transform_matrix=so.transform_matrix;
+
+                inverse_local_to_world_matrix=so.inverse_local_to_world_matrix;
+                inverse_transpose_local_to_world_matrix=so.inverse_transpose_local_to_world_matrix;
+                UpdateVersion();
+            }
+
+            SceneMatrix(const Matrix4f &mat):VersionData(Identity4f)
+            {
+                SetLocalMatrix(mat);
+                UpdateVersion();
+            }
+
+            void SetLocalMatrix(const Matrix4f &mat)
+            {
+                //if (IsNearlyEqual(local_matrix,mat))
+                if(!hgl_cmp(local_matrix,mat))
+                    return;
+
+                local_matrix=mat;
+                UpdateVersion();
+            }
+
+            void SetParentMatrix(const Matrix4f &pm)
+            {
+                //if (IsNearlyEqual(parent_matrix,pm))
+                if(!hgl_cmp(parent_matrix,pm))
+                    return;
+
+                parent_matrix=pm;
+                UpdateVersion();
+            }
+        };//class SceneMatrix
+
         /**
-        * 方向定位数据基类
+        * 方向定位数据基类<br>
+        * 用于描述一个物体在3D空间中的位置、旋转、缩放等信息。<br>
+        * 构成说明:<br>
+        * <ul>
+        *   <li>LocalMatrix 一般用于描述当前节点相对上一级的变换矩阵</li>
+        *   <li>LocalToWorldMatrix 最终用于描述当前节点相对于世界的变换矩阵，在渲染时使用</li>
+        * 
+        *   <li>transform_manager 用于管理当前节点所有的变换情况，如果本节点不存在额外变换，数量为0。</li>
+        * </ul>
+        * 
+        * LocalToWorldMatrix=ParnetMatrix * LocalMatrix * TraansformMatrix<br>
         */
         class SceneOrient                                                                                                   ///场景定位类
         {
         protected:
 
-            Vector3f Position;                                                                                              ///<坐标
-            Vector3f Direction;                                                                                             ///<方向
+            SceneMatrix scene_matrix;
 
-            Transform LocalTransform;                                                                                       ///<当前变换(指相对上一级的变换)
-            Transform WorldTransform;                                                                                       ///<当前到世界变换
-
-        protected:
-
-                    void        SetWorldTransform   (const Transform &);                                                    ///<设定当前节点到世界矩阵
+            Vector3f WorldPosition;
 
         public:
 
-            SceneOrient();
+            SceneOrient()=default;
             SceneOrient(const SceneOrient &);
-            SceneOrient(const Transform &);
+            SceneOrient(const Matrix4f &);
             virtual ~SceneOrient()=default;
 
-                    void        SetPosition         (const Vector3f &pos){Position=pos;}
-                    void        SetDirection        (const Vector3f &dir){Direction=dir;}
+            virtual void Clear()
+            {
+                scene_matrix.Clear();
+                WorldPosition=ZeroVector3f;
+            }
 
-            const   Vector3f &  GetLocalPosition    ()const {return Position;}
-            const   Vector3f &  GetLocalDirection   ()const {return Direction;}
-            const   Vector3f    GetWorldPosition    ()      {return WorldTransform.TransformPosition(Position);}
-            const   Vector3f    GetWorldDirection   ()      {return WorldTransform.TransformDirection(Direction);}
-
-        public: 
-
-                    void        SetLocalTransform   (const Transform &);                                                    ///<设定当前节点矩阵
-
-             const  Transform & GetLocalTransform   ()const {return LocalTransform;}                                        ///<取得当前节点矩阵
-             const  Transform & GetWorldTransform   ()const {return WorldTransform;}                                        ///<取得当前节点到世界矩阵
-    
-                    Transform & GetLocalTransform   ()      {LocalTransform.UpdateMatrix();return LocalTransform;}          ///<取得当前节点矩阵
-                    Transform & GetWorldTransform   ()      {WorldTransform.UpdateMatrix();return WorldTransform;}          ///<取得当前节点到世界矩阵
+            void SetLocalMatrix  (const Matrix4f &mat){scene_matrix.SetLocalMatrix(mat);}               ///<设置本地矩阵
+            void SetParentMatrix (const Matrix4f &mat){scene_matrix.SetParentMatrix(mat);}              ///<设置上级到世界空间变换矩阵
 
         public:
 
-            virtual bool        RefreshTransform    (const Transform &);                                                    ///<刷新到世界空间变换
+            const uint32        GetLocalToWorldMatrixVersion()const             { return scene_matrix.GetNewestVersion(); }     ///<取得版本号
+
+            const Vector3f &    GetWorldPosition() const                        { return WorldPosition; }                       ///<取得世界坐标
+            const Matrix4f &    GetLocalMatrix                          ()const {return scene_matrix.GetLocalMatrix();}         ///<取得本地矩阵
+
+            TransformManager &  GetTransform                            ()      {return scene_matrix.GetTransform();}           ///<取得变换管理器
+
+            const Matrix4f &    GetLocalToWorldMatrix                   ()      {return scene_matrix.GetLocalToWorldMatrix();}  ///<取得本地到世界矩阵
+            const Matrix4f &    GetInverseLocalToWorldMatrix            ()      {return scene_matrix.GetInverseLocalToWorldMatrix();}
+            const Matrix4f &    GetInverseTransposeLocalToWorldMatrix   ()      {return scene_matrix.GetInverseTransposeLocalToWorldMatrix();}
+
+        public:
+
+            virtual void RefreshMatrix();
         };//class SceneOrient
     }//namespace graph
 }//namespace hgl

src/SceneGraph/InlineGeometry.cpp

@@ -113,14 +113,14 @@ namespace hgl
                 return pc->Create();
             }
 
-            Primitive *CreateCircle(PrimitiveCreater *pc,const CircleCreateInfo *cci)
+            Primitive *CreateCircle2D(PrimitiveCreater *pc,const CircleCreateInfo *cci)
             {
                 if(!pc)return(nullptr);
 
                 uint edge;
                 uint vertex_count;
 
-                if(cci->has_color)
+                if(cci->has_center)
                 {
                     edge=cci->field_count+1;
                     vertex_count=cci->field_count+2;
@@ -139,13 +139,12 @@ namespace hgl
                 if(!vertex.IsValid())
                     return(nullptr);
 
-                if(cci->has_color)
+                if(cci->has_center)
                 {
-                    if(!color.IsValid())
-                        return(nullptr);
-
                     vertex->Write(cci->center);
-                    color->Write(cci->center_color);
+
+                    if(color.IsValid())
+                        color->Write(cci->center_color);
                 }
 
                 for(uint i=0;i<edge;i++)
@@ -157,12 +156,157 @@ namespace hgl
 
                     vertex->Write(x,y);
                 
-                    if(cci->has_color)
+                    if(color.IsValid())
                         color->Write(cci->border_color);
                 }
 
                 return pc->Create();
             }
+
+            template<typename T>
+            void WriteIBO(T *p,const T start,const T count)
+            {
+                for(T i=start;i<start+count;i++)
+                {
+                    *p=i;
+                    ++p;
+                }
+            }
+
+            Primitive *CreateCircle3D(PrimitiveCreater *pc,const CircleCreateInfo *cci)
+            {
+                if(!pc)return(nullptr);
+
+                uint edge;
+                uint vertex_count;
+
+                if(cci->has_center)
+                {
+                    edge=cci->field_count+1;
+                    vertex_count=cci->field_count+2;
+                }
+                else
+                {
+                    edge=cci->field_count;
+                    vertex_count=cci->field_count;
+                }
+
+                bool has_index=pc->hasIndex();
+
+                if(!pc->Init("Circle",vertex_count,has_index?vertex_count:0))return(nullptr);
+
+                VABMap3f vertex(pc->GetVABMap(VAN::Position));
+                VABMap4f color(pc->GetVABMap(VAN::Color));
+                VABMap3f normal(pc->GetVABMap(VAN::Normal));
+
+                if(!vertex.IsValid())
+                    return(nullptr);
+
+                if(cci->has_center)
+                {
+                    vertex->Write(cci->center.x,cci->center.y,0);
+
+                    if(color.IsValid())
+                        color->Write(cci->center_color);
+
+                    if(normal.IsValid())
+                        normal->Write(AxisVector::Z);
+                }
+
+                for(uint i=0;i<edge;i++)
+                {
+                    float ang=float(i)/float(cci->field_count)*360.0f;
+
+                    float x=cci->center.x+sin(deg2rad(ang))*cci->radius.x;
+                    float y=cci->center.y+cos(deg2rad(ang))*cci->radius.y;
+
+                    vertex->Write(x,y,0);
+                
+                    if(color.IsValid())
+                        color->Write(cci->border_color);
+
+                    if(normal.IsValid())
+                        normal->Write(AxisVector::Z);
+                }
+
+                if(has_index)
+                {
+                    IBMap *ib_map=pc->GetIBMap();
+
+                    if(pc->GetIndexType()==IndexType::U16)WriteIBO<uint16>((uint16 *)(ib_map->Map()),0,vertex_count);else
+                    if(pc->GetIndexType()==IndexType::U32)WriteIBO<uint32>((uint32 *)(ib_map->Map()),0,vertex_count);else
+                    if(pc->GetIndexType()==IndexType::U8 )WriteIBO<uint8 >((uint8  *)(ib_map->Map()),0,vertex_count);
+
+                    ib_map->Unmap();
+                }
+
+                return pc->Create();
+            }
+
+            template<typename T>
+            void WriteCircleIBO(T *ibo,const uint edge_count)
+            {
+                T *p=ibo;
+
+                for(T i=1;i<edge_count;i++)
+                {
+                    *p=0;  ++p;
+                    *p=i+1;++p;
+                    *p=i;  ++p;
+                }
+
+                *p=0;           ++p;
+                *p=1;           ++p;
+                *p=edge_count;
+            }
+            
+            Primitive *CreateCircle3DByIndexTriangles(PrimitiveCreater *pc,const CircleCreateInfo *cci)
+            {
+                if(!pc)return(nullptr);
+
+                uint vertex_count;
+                uint index_count;
+
+                vertex_count=cci->field_count;
+                index_count=(vertex_count-2)*3;
+
+                if(!pc->Init("Circle",vertex_count,index_count))return(nullptr);
+
+                VABMap3f vertex(pc->GetVABMap(VAN::Position));
+                VABMap4f color(pc->GetVABMap(VAN::Color));
+                VABMap3f normal(pc->GetVABMap(VAN::Normal));
+
+                if(!vertex.IsValid())
+                    return(nullptr);
+
+                for(uint i=0;i<cci->field_count+1;i++)
+                {
+                    float ang=float(i)/float(cci->field_count)*360.0f;
+
+                    float x=cci->center.x+sin(deg2rad(ang))*cci->radius.x;
+                    float y=cci->center.y+cos(deg2rad(ang))*cci->radius.y;
+
+                    vertex->Write(x,y,0);
+                
+                    if(color.IsValid())
+                        color->Write(cci->border_color);
+
+                    if(normal.IsValid())
+                        normal->Write(AxisVector::Z);
+                }
+
+                {
+                    IBMap *ib_map=pc->GetIBMap();
+
+                    if(pc->GetIndexType()==IndexType::U16)WriteCircleIBO<uint16>((uint16 *)(ib_map->Map()),cci->field_count);else
+                    if(pc->GetIndexType()==IndexType::U32)WriteCircleIBO<uint32>((uint32 *)(ib_map->Map()),cci->field_count);else
+                    if(pc->GetIndexType()==IndexType::U8 )WriteCircleIBO<uint8 >((uint8  *)(ib_map->Map()),cci->field_count);
+
+                    ib_map->Unmap();
+                }
+
+                return pc->Create();
+            }
             
             Primitive *CreatePlaneGrid2D(PrimitiveCreater *pc,const PlaneGridCreateInfo *pgci)
             {
@@ -268,7 +412,7 @@ namespace hgl
                 return pc->Create();
             }
 
-            Primitive *CreatePlane(PrimitiveCreater *pc)
+            Primitive *CreatePlaneSqaure(PrimitiveCreater *pc)
             {
                 const   float       xy_vertices [] = { -0.5f,-0.5f,0.0f,  +0.5f,-0.5f,0.0f,    +0.5f,+0.5f,0.0f,    -0.5f,+0.5f,0.0f   };
                         float       xy_tex_coord[] = {  0.0f, 0.0f,        1.0f, 0.0f,          1.0f, 1.0f,          0.0f, 1.0f        };

src/SceneGraph/MaterialRenderList.cpp

@@ -113,7 +113,7 @@ void MaterialRenderList::Add(SceneNode *sn)
 
     rn.scene_node       =sn;
 
-    rn.l2w_transform_version=sn->GetWorldTransform().GetVersion();
+    rn.l2w_version=sn->GetLocalToWorldMatrixVersion();
     rn.l2w_index=0;
 
     rn.world_position   =sn->GetWorldPosition();
@@ -141,7 +141,7 @@ void MaterialRenderList::End()
         assign_buffer->WriteNode(rn_list);
 }
 
-void MaterialRenderList::UpdateTransform()
+void MaterialRenderList::UpdateLocalToWorld()
 {
     if(!assign_buffer)
         return;
@@ -154,13 +154,14 @@ void MaterialRenderList::UpdateTransform()
 
     int first=-1,last=-1;
     int update_count=0;
+    uint32 l2w_version=0;
     RenderNode *rn=rn_list.GetData();
 
     for(int i=0;i<node_count;i++)
     {
-        Transform &tf=rn->scene_node->GetWorldTransform();
+        l2w_version=rn->scene_node->GetLocalToWorldMatrixVersion();
 
-        if(rn->l2w_transform_version!=tf.GetVersion())       //版本不对，需要更新
+        if(rn->l2w_version!=l2w_version)       //版本不对，需要更新
         {
             if(first==-1)
             {
@@ -169,7 +170,7 @@ void MaterialRenderList::UpdateTransform()
             
             last=rn->l2w_index;
 
-            rn->l2w_transform_version=tf.GetVersion();
+            rn->l2w_version=l2w_version;
 
             rn_update_l2w_list.Add(rn);
 
@@ -181,7 +182,7 @@ void MaterialRenderList::UpdateTransform()
 
     if(update_count>0)
     {
-        assign_buffer->UpdateTransform(rn_update_l2w_list,first,last);
+        assign_buffer->UpdateLocalToWorld(rn_update_l2w_list,first,last);
         rn_update_l2w_list.Clear();
     }
 }

src/SceneGraph/PrimitiveCreater.cpp

@@ -13,6 +13,7 @@ PrimitiveCreater::PrimitiveCreater(GPUDevice *dev,const VIL *v)
     vdm             =nullptr;
     vil             =v;
 
+    has_index       =false;
     prim_data       =nullptr;
 
     Clear();
@@ -23,6 +24,8 @@ PrimitiveCreater::PrimitiveCreater(VertexDataManager *_vdm)
 {
     vdm=_vdm;
 
+    has_index=vdm->GetIBO();
+
     index_type=vdm->GetIndexType();
 }
 

src/SceneGraph/RenderAssignBuffer.cpp

@@ -73,7 +73,7 @@ void RenderAssignBuffer::StatL2W(const RenderNodeList &rn_list)
 
     for(uint i=0;i<rn_list.GetCount();i++)
     {
-        *l2wp=rn->scene_node->GetWorldTransform().GetMatrix();
+        *l2wp=rn->scene_node->GetLocalToWorldMatrix();
         ++l2wp;
         ++rn;
     }
@@ -81,7 +81,7 @@ void RenderAssignBuffer::StatL2W(const RenderNodeList &rn_list)
     l2w_buffer->Unmap();
 }
 
-void RenderAssignBuffer::UpdateTransform(const RenderNodePointerList &rnp_list,const int first,const int last)
+void RenderAssignBuffer::UpdateLocalToWorld(const RenderNodePointerList &rnp_list,const int first,const int last)
 {
     if(!l2w_buffer)
         return;
@@ -97,7 +97,7 @@ void RenderAssignBuffer::UpdateTransform(const RenderNodePointerList &rnp_list,c
 
     for(uint i=0;i<count;i++)
     {
-        l2wp[(*rn)->l2w_index-first]=(*rn)->scene_node->GetWorldTransform().GetMatrix();
+        l2wp[(*rn)->l2w_index-first]=(*rn)->scene_node->GetLocalToWorldMatrix();
 
         ++rn;
     }

src/SceneGraph/RenderAssignBuffer.h

@@ -92,6 +92,6 @@ public:
 
     void WriteNode(const RenderNodeList &);
 
-    void UpdateTransform(const RenderNodePointerList &,const int first,const int last);
+    void UpdateLocalToWorld(const RenderNodePointerList &,const int first,const int last);
 };//struct RenderAssignBuffer
 VK_NAMESPACE_END

src/SceneGraph/RenderList.cpp

@@ -78,12 +78,12 @@ namespace hgl
             mrl_map.Clear();
         }
         
-        void RenderList::UpdateTransform()
+        void RenderList::UpdateLocalToWorld()
         {
             if(renderable_count<=0)
                 return;
 
-            mrl_map.UpdateTransform();
+            mrl_map.UpdateLocalToWorld();
         }
     }//namespace graph
 }//namespace hgl

src/SceneGraph/SceneNode.cpp

@@ -40,18 +40,16 @@ namespace hgl
         }
 
         /**
-        * 刷新变换
-        * @param parent_transform 上级节点变换
+        * 刷新矩阵变换
         */
-        bool SceneNode::RefreshTransform(const Transform &parent_transform)
+        void SceneNode::RefreshMatrix()
         {
-            if(!parent_transform.IsLastVersion())
-                return(false);
+            SceneOrient::RefreshMatrix();
 
-            if(!parent_transform.IsIdentity())
-                SceneOrient::RefreshTransform(parent_transform);
-            else
-                SetWorldTransform(LocalTransform);
+//            if (scene_matrix.IsNewestVersion())       //自己不变，不代表下面不变
+                //return;
+
+            const Matrix4f &l2w=scene_matrix.GetLocalToWorldMatrix();
 
             const int count=SubNode.GetCount();
 
@@ -59,13 +57,11 @@ namespace hgl
 
             for(int i=0;i<count;i++)
             {
-                if(!(*sub)->RefreshTransform(WorldTransform))
-                    return(false);
+                (*sub)->SetParentMatrix(l2w);
+                (*sub)->RefreshMatrix();
 
                 sub++;
             }
-
-            return(true);
         }
 
         /**

src/SceneGraph/SceneOrient.cpp

@@ -3,59 +3,32 @@ namespace hgl
 {
     namespace graph
     {
-        SceneOrient::SceneOrient()
-        {
-            Position=Vector3f(0.0f);
-            Direction=Vector3f(0.0f);
-        }
-        
         SceneOrient::SceneOrient(const SceneOrient &so)
         {
-            hgl_cpy(*this,so);
+            scene_matrix=so.scene_matrix;
+            WorldPosition=so.WorldPosition;
+
+            scene_matrix.UpdateNewestData();
         }
 
-        SceneOrient::SceneOrient(const Transform &t)
+        SceneOrient::SceneOrient(const Matrix4f &mat):SceneOrient()
         {
-            SetLocalTransform(t);
+            scene_matrix.SetLocalMatrix(mat);
+            
+            scene_matrix.UpdateNewestData();
+
+            WorldPosition=TransformPosition(GetLocalToWorldMatrix(),ZeroVector3f);
         }
 
-        void SceneOrient::SetLocalTransform(const Transform &t)
+        void SceneOrient::RefreshMatrix()
         {
-            if(LocalTransform==t)
-                return;
-
-            LocalTransform=t;
-        }
-
-        void SceneOrient::SetWorldTransform(const Transform &t)
-        {
-            if(WorldTransform==t)
-                return;
-
-            WorldTransform=t;
-        }
-
-        /**
-         * 刷新世界变换
-         * @param m 上一级local to world变换
-         */
-        bool SceneOrient::RefreshTransform(const Transform &t)
-        {
-            if(!t.IsLastVersion())      //都不是最新版本
-                return(false);
-
-            //理论上讲，Transform在正常转const的情况下，就已经做了UpdateMatrix()的操作，这个需要测试一下
-
-            if(LocalTransform.IsIdentity())
+            if (scene_matrix.IsNewestVersion())
             {
-                SetWorldTransform(t);
-            }
-            else
-            {
-                SetWorldTransform(t.TransformTransform(LocalTransform));
+                //是最新版本，证明没有更新，那不用刷新了
+                return;
             }
 
-            return(true);
+            WorldPosition=TransformPosition(GetLocalToWorldMatrix(),ZeroVector3f);
         }
     }//namespace graph
 }//namespace hgl