public void Commit(CCommandList cmd, Graphics.CGfxCamera camera, GamePlay.SceneGraph.CheckVisibleParam param, EPoolType poolType)
        {
            switch (poolType)
            {
            case EPoolType.Normal:
            {
                using (var i = Meshes.Values.GetEnumerator())
                {
                    while (i.MoveNext())
                    {
                        if (i.Current.CurSize == 0)
                        {
                            continue;
                        }

                        i.Current.MeshComp.CommitVisual(cmd, camera, param);
                        i.Current.Flush2VB(cmd);
                    }
                }
            }
            break;

            case EPoolType.Shadow:
            {
                using (var i = ShadowMeshes.Values.GetEnumerator())
                {
                    while (i.MoveNext())
                    {
                        if (i.Current.CurSize == 0)
                        {
                            continue;
                        }

                        i.Current.MeshComp.CommitVisual(cmd, camera, param);
                        i.Current.Flush2VB(cmd);
                    }
                }
            }
            break;
            }
        }
示例#2
0
 public override void CommitVisual(CCommandList cmd, Graphics.CGfxCamera camera, GamePlay.SceneGraph.CheckVisibleParam param)
 {
     if (EngineNS.CIPlatform.Instance.PlayMode == CIPlatform.enPlayMode.Editor)
     {
         mLineMeshComponent?.CommitVisual(cmd, camera, param);
     }
 }
示例#3
0
 public override void CommitVisual(CCommandList cmd, EngineNS.Graphics.CGfxCamera camera, GamePlay.SceneGraph.CheckVisibleParam param)
 {
     base.CommitVisual(cmd, camera, param);
     if (mMeshComponent != null)
     {
         mMeshComponent?.CommitVisual(cmd, camera, param);
     }
 }
        public override void _OnEditorCommitVisual(CCommandList cmd, Graphics.CGfxCamera camera, GamePlay.SceneGraph.CheckVisibleParam param)
        {
            if (CEngine.PhysicsDebug == false)
            {
                return;
            }
            if (mDebugActor == null && mReady == false)
            {
                mReady = true;
                var test = CreateDefaultCapsule();

                test = SetMaterial();
            }

            if (mDebugActor != null)
            {
                float r          = 0.5f;
                float halfHeight = 0.5f;
                HostShape.IfGetCapsule(ref r, ref halfHeight);
                var trans = Placement.Transform * SocketMatrix * HostPlaceable.Placement.WorldMatrix;
                //mDebugActor.Placement.Location = RigidBody.Position;
                Vector3    scale, loc;//mDebugActor.Placement.Scale;
                Quaternion rotate;
                trans.Decompose(out scale, out rotate, out loc);
                var y = (r + halfHeight) * 2;
                scale.SetValue(scale.X * r * 2, scale.Y * y, scale.Z * r * 2);
                mDebugActor.Placement.Scale = scale;
            }
        }
示例#5
0
        public void OnEditorCommitVisual(CCommandList cmd, Graphics.CGfxCamera camera, GamePlay.Actor.GActor hostactor, GamePlay.SceneGraph.CheckVisibleParam param)
        {
            if (hostactor == null || !hostactor.Visible)
            {
                return;
            }

            var rc = CEngine.Instance.RenderContext;

            switch (ShapeType)
            {
            case EPhysShapeType.PST_Convex:
            {
                if (mDebugActor == null)
                {
                    Graphics.Mesh.CGfxMeshPrimitives mp = IfGetConvexMesh(rc);
                    mDebugActor = EngineNS.GamePlay.Actor.GActor.NewMeshActorDirect(CEngine.Instance.MeshManager.CreateMesh(rc, mp));
                    EngineNS.Thread.Async.TaskLoader.Release(ref WaitContext, null);
                    var test = SetMaterial();
                }
                mDebugActor.Placement.SetMatrix(ref hostactor.Placement.mDrawTransform);
            }
            break;

            case EPhysShapeType.PST_TriangleMesh:
            {
                if (mDebugActor == null)
                {
                    Graphics.Mesh.CGfxMeshPrimitives mp = IfGetTriMesh(rc);
                    CEngine.Instance.MeshManager.CreateMesh(rc, mp);
                    EngineNS.Thread.Async.TaskLoader.Release(ref WaitContext, null);
                    mDebugActor = EngineNS.GamePlay.Actor.GActor.NewMeshActorDirect(CEngine.Instance.MeshManager.CreateMesh(rc, mp));

                    var test = SetMaterial();
                }
                mDebugActor.Placement.SetMatrix(ref hostactor.Placement.mDrawTransform);
            }
            break;

            case EPhysShapeType.PST_Box:
            {
                if (mDebugActor == null && mReady == false)
                {
                    mReady = true;
                    var test = CreateDefaultBox();

                    test = SetMaterial();
                }

                if (mDebugActor != null)
                {
                    float w = 1.0f;
                    float h = 1.0f;
                    float l = 1.0f;
                    SDK_PhyShape_IfGetBox(ref w, ref h, ref l);
                    mDebugActor.Placement.SetMatrix(ref hostactor.Placement.mDrawTransform);
                    Vector3 scale = Vector3.UnitXYZ;        //mDebugActor.Placement.Scale;
                    scale.SetValue(scale.X * w, scale.Y * h, scale.Z * l);
                    mDebugActor.Placement.Scale = scale;
                }
            }
            break;

            case EPhysShapeType.PST_Sphere:
            {
                if (mDebugActor == null && mReady == false)
                {
                    mReady = true;
                    var test = CreateDefaultSphere();
                    test = SetMaterial();
                }

                if (mDebugActor != null)
                {
                    float r = 1.0f;
                    IfGetSphere(ref r);
                    mDebugActor.Placement.SetMatrix(ref hostactor.Placement.mDrawTransform);
                    Vector3 scale = Vector3.UnitXYZ;        //mDebugActor.Placement.Scale;
                    scale.SetValue(scale.X * r, scale.Y * r, scale.Z * r);
                    mDebugActor.Placement.Scale = scale;
                }
            }
            break;

            default:
                break;
            }

            if (mDebugActor != null)
            {
                foreach (var comp in mDebugActor.Components)
                {
                    var meshComp = comp as EngineNS.GamePlay.Component.GVisualComponent;
                    if (meshComp != null)
                    {
                        meshComp.CommitVisual(cmd, camera, param);
                    }
                }
            }
        }
示例#6
0
 partial void OnEditorCheckVisible(CCommandList cmd, Graphics.CGfxCamera camera, GamePlay.SceneGraph.CheckVisibleParam param)
 {
     if (CIPlatform.Instance.PlayMode == CIPlatform.enPlayMode.Game)
     {
         return;
     }
     for (int i = 0; i < Components.Count; ++i)
     {
         Components[i].OnEditorCommitVisual(cmd, camera, param);
     }
 }
示例#7
0
 public override void OnEditorCommitVisual(CCommandList cmd, Graphics.CGfxCamera camera, GamePlay.SceneGraph.CheckVisibleParam param)
 {
     for (int i = 0; i < Components.Count; ++i)
     {
         var comp = Components[i];
         comp.OnEditorCommitVisual(cmd, camera, param);
     }
     base.OnEditorCommitVisual(cmd, camera, param);
 }