using System;
using System.Collections.Generic;
using System.Diagnostics.Metrics;
using System.Linq;
using System.Numerics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;
using MagicPhysX; // for enable Extension Methods.
using MagicPhysX.Toolkit;
using Physx;
using static System.Formats.Asn1.AsnWriter;
using static System.Runtime.InteropServices.JavaScript.JSType;
using static MagicPhysX.NativeMethods; // recommend to use C API.
using static PhysX.PhysxWorldRaycastResultCb_1;





//测试bug问题总结 使用注意点 C Api(踩坑血泪史) 
/*
 1 physx_create_foundation 只可以初始化一次，否则后续api 调用会出现 api调用访问非法内存
 2 出现调用api 接口访问非法内存错误， 一般都是当前位置参数错误，或者前面生成参数某些步骤错误（重要）
 3 创建PxGemometry 只能值传递，不可以返回指针 PxBoxGeometry_new 同类型的调用方式也有同样问题
 4 PxShapeFlag.SimulationShape 和 PxShapeFlag.TriggerShape 是互斥的不可同时设置为true ！ 同时 
    当一个设置为true时 另一个必须设置为false(翻源码得知 文档中也有说明 ) 否则会崩
 5 addforce 设置外力时 给与物体速度时 需要确保actor已经加入scence了
 6 当触发onTriger回调方法时候，两个shap 都是PxShapeFlag.TriggerShape属性的时候是无法触发的
 7 如果创建刚体的时候设置gemomry参数时候，刚体会自带一个shap ，否则会不会创建。需要另外添加shap
 8 shap添加进刚体，调用release方法 是因为physx内部内存管理机制， shap是引用计数的。在添加到一个刚体之后
   需要调用relase方法，否则容易引起内存泄露。
 9 PxShapeFlag.SimulationShape 模式下 先执行filetershader 后执行 filterback  (目前filterback func 无法生成,库不支持) 
10 raycast 回调函数目前无法触发 (大概率使用原因,后续验证下)
 */



namespace PhysX
{
    //先使用原来的命名方法 后续改为微软命名风格
    public enum PhysxShapeType
    {
        PX_BOX = 1,
        PX_SPHERE = 2,
        PX_CAPSULE = 3
    };
    public enum PhysxObjectType
    {
        PX_INVALIDE,
        PX_STATICOBJECT,
        PX_AIRSHIP,
        PX_SPELL,
        PX_SPELLTARGETSTATOCOBJECT,
        PX_MONSTERGROUP,
        PX_TRIGGER,
        PX_MONSTER
    };

    public enum PhysxCollisionTypes
    {
        PX_COL_NOTHING = 0,                       //<Collide with nothing
        PX_COL_AIR_SHIP = 1 << 1,                 //<Collide with ships
        PX_COL_STATIC_OBJ = 1 << 2,               //<Collide with static_obj
        PX_COL_SPELL_OBJ = 1 << 3,                //<Collide with spell data
        PX_COL_SPELL_TARGET_STATIC_OBJ = 1 << 4,  // Collide with spell target obj
        PX_COL_MONSTER_GROUP_OBJ = 1 << 5,        // Collide with monster target obj
        PX_COL_TRIGGER_OBJ = 1 << 6,
        PX_COL_MONSTER = 1 << 7                   // Collide with skill obj
    };

    public enum PhysxTestTypes
    {
        PX_CCD = 1 << 29,  // CCD type
    };

    //碰撞结果  放在common中更合适
    public unsafe struct PhysxCollisionHitResult
    {
        public PhysxCollisionHitResult()
        {
            hit_type = PhysxObjectType.PX_INVALIDE;
            pos.x = 0.0f;
            pos.y = 0.0f;
            pos.z = 0.0f;
            user_ptr = null;
            shape_ptr = null;
            actor_ptr = null;
        }
        public bool HasResult() { return hit_type != PhysxObjectType.PX_INVALIDE; }
        public PhysxObjectType hit_type;
        public PxVec3 pos;
        public void* user_ptr;
        public PxShape* shape_ptr;
        public PxRigidActor* actor_ptr;

    };

    //struct ClassType
    //等效于 Unsafe.AsRef<PxRigidStatic>(handler);故不实现

    public unsafe static class PxConstValue
    {
        public const int MaskAirShipCollidesWith = (int)(PhysxCollisionTypes.PX_COL_STATIC_OBJ | PhysxCollisionTypes.PX_COL_SPELL_OBJ | PhysxCollisionTypes.PX_COL_TRIGGER_OBJ);
        public const int MaskStaticCollidesWith = (int)(PhysxCollisionTypes.PX_COL_SPELL_OBJ | PhysxCollisionTypes.PX_COL_AIR_SHIP | PhysxCollisionTypes.PX_COL_MONSTER_GROUP_OBJ);
        public const int MaskSpellCollidesWith = (int)(PhysxCollisionTypes.PX_COL_STATIC_OBJ | PhysxCollisionTypes.PX_COL_AIR_SHIP | PhysxCollisionTypes.PX_COL_SPELL_TARGET_STATIC_OBJ | PhysxCollisionTypes.PX_COL_MONSTER);
        public const int MaskSpellTargetCollidesWith = (int)PhysxCollisionTypes.PX_COL_SPELL_OBJ;
        public const int MaskAirShipNoColldierWith = (int)PhysxCollisionTypes.PX_COL_NOTHING;
        public const int MaskMonsterGroupColldierWith = (int)PhysxCollisionTypes.PX_COL_STATIC_OBJ;
        public const int MaskTriggerColldierWith = (int)(PhysxCollisionTypes.PX_COL_AIR_SHIP | PhysxCollisionTypes.PX_COL_MONSTER);
        public const int MaskMonsterColldersWith = (int)(PhysxCollisionTypes.PX_COL_SPELL_OBJ | PhysxCollisionTypes.PX_COL_TRIGGER_OBJ);

        public static PhysxObjectType PhysxGetUserType(PxRigidActor* actor)
        {
            if (actor->userData == null)
            {
                return PhysxObjectType.PX_STATICOBJECT;
            }
            else
            {
                //TODO 需要补充业务代码
                //return actor0->getPhysxType();
            }
            return PhysxObjectType.PX_INVALIDE;
        }

        //public delegate* unmanaged[Cdecl]<UInt32, PxFilterData, UInt32, PxFilterData, PxPairFlags*, void*, UInt32, PxFilterFlags> tmp;
        public static PxFilterFlags PhysxWorldFilterShader(
                                        UInt32 attributes0,
                                        PxFilterData filterData0,
                                        UInt32 attributes1,
                                        PxFilterData filterData1, PxPairFlags* pairFlags,
                                        void* constantBlock, UInt32 constantBlockSize)
        {
            // let triggers through
            if (phys_PxFilterObjectIsTrigger(attributes0) ||
                phys_PxFilterObjectIsTrigger(attributes1))
            {
                *pairFlags = PxPairFlags.ContactDefault;

                if (((filterData0.word0 & filterData1.word1) != 0) &&
                    ((filterData1.word0 & filterData0.word1) != 0))
                {
                    *pairFlags = PxPairFlags.SolveContact |
                                PxPairFlags.DetectDiscreteContact |
                                PxPairFlags.NotifyTouchFound |
                                PxPairFlags.NotifyTouchLost |
                                PxPairFlags.NotifyContactPoints;
                }
                return 0 | PxFilterFlags.Callback;
            }
            return PxFilterFlags.Callback;
        }
    }


    //create_raycast_filter_callback_func
    public unsafe struct MyOwnerFilterCallbackPhysx //: public physx::PxSimulationFilterCallback 
    {
        public static PxFilterFlags pairFound(
                                  UInt32 pairID, UInt32 attributes0,
                                  PxFilterData filterData0, PxActor* a0,
                                  PxShape* s0, UInt32 attributes1,
                                  PxFilterData filterData1, PxActor* a1,
                                  PxShape* s1, PxPairFlags* pairFlags)
        {
            *pairFlags = PxPairFlags.ContactDefault;
            PxRigidActor* first = (PxRigidActor*)a0;
            PxRigidActor* second = (PxRigidActor*)a1;
            if (first == null || second == null)
            {
                PhysxObjectType type0 = PxConstValue.PhysxGetUserType(first);
                PhysxObjectType type1 = PxConstValue.PhysxGetUserType(second);
                if ((type0 == PhysxObjectType.PX_SPELL) && (type1 == PhysxObjectType.PX_AIRSHIP || type1 == PhysxObjectType.PX_MONSTER))
                {
                    return PxFilterFlags.Kill;
                }
            }
            return PxFilterFlags.Kill;
        }
        public static void pairLost(UInt32 pairID,
                         UInt32 attributes0,
                         PxFilterData filterData0,
                         UInt32 attributes1,
                         PxFilterData filterData1, bool objectRemoved)
        {

        }

        public static bool statusChange(UInt32* pairID, PxPairFlags* pairFlags,
                                  PxFilterFlags* filterFlags)
        {
            return false;
        }
    }


    /////////////////////////////////////////////////////////////////////////
    // PhysxWorldRaycastResultCb
    /////////////////////////////////////////////////////////////////////////
    public unsafe struct PhysxWorldRaycastResultCb_1
    {
        //userdata部分
        public struct RaycastUserData
        {
            public PxVec3 m_rayFromWorld;  // used to calculate hitPointWorld from hitFraction
            public PxVec3 m_rayToWorld;
            public PxVec3 m_hitNormalWorld;
            public PxVec3 m_hitPointWorld;
            public PxRigidActor* actor_;
        }
        public RaycastUserData userData;

        public PhysxWorldRaycastResultCb_1(PxVec3* rayFromWorld, PxVec3* rayToWorld)
        {
            userData.m_rayFromWorld = *rayFromWorld;
            userData.m_rayToWorld = *rayToWorld;
        }

        //uint   flag
        public delegate*<PxRigidActor*, PxFilterData*, PxShape*, uint, void*, PxQueryHitType> callback;
        public static PxQueryHitType preFilter(PxRigidActor* actor, PxFilterData* filterData, PxShape* shape,
                                                uint flags, void* userData)
        {
            ////filterData need adjust？？？
            //子弹屏蔽
            if ((RaycastUserData*)userData != null)
            {
                PxRigidActor* obj0 = actor;
                //TODO 根据自己理解暂时修改  userData 为PhysxWorldRaycastResultCb 中的自定义数据 
                PxRigidActor* obj1 = ((RaycastUserData*)userData)->actor_;
                if (obj0 != null && obj1 != null)
                {
                    int type0 = (int)PxConstValue.PhysxGetUserType(obj0);
                    int type1 = (int)PxConstValue.PhysxGetUserType(obj1);
                    if ((type0 == (int)PhysxObjectType.PX_SPELL) && (type1 == (int)PhysxObjectType.PX_AIRSHIP))
                    {
                        //业务代码先屏蔽
                    }
                    else if ((type0 == (int)PhysxObjectType.PX_AIRSHIP) && (type1 == (int)PhysxObjectType.PX_SPELL))
                    {
                        //业务代码先屏蔽
                    }
                    else if ((type0 == (int)PhysxObjectType.PX_SPELLTARGETSTATOCOBJECT) && (type1 == (int)PhysxObjectType.PX_SPELL))
                    {
                        //业务代码先屏蔽
                    }
                    else if ((type1 == (int)PhysxObjectType.PX_SPELLTARGETSTATOCOBJECT) && (type0 == (int)PhysxObjectType.PX_SPELL))
                    {
                        //业务代码先屏蔽
                    }
                }
            }
            return PxQueryHitType.Block;
        }
    }

    //此接口废弃   此接口使用的继承方式 c#中无法使用c++风格的api  只能数据和方法分离  不就是传说中的Ecs么
    //public static extern PxQueryFilterCallback* create_raycast_filter_callback_func
    //public unsafe struct PhysxWorldRaycastResultCb /* :PxQueryFilterCallback */
    //{
    //};


    //释放内存逻辑暂不实现 需要根据业务详细考虑
    public unsafe struct WorldUserData : IDisposable
    {
        public WorldUserData()
        {
            px_scene_ = null;
            stamp_ = 0;
            _physxBase = new PhysxBase();
            // trigger_mgr_ = null;
        }

        public void Dispose()
        {

        }

        public string PVD_HOST = "127.0.0.1";
        public float DEFAULT_DENSITY = 10.0f;

        public PhysxBase _physxBase;
        public UInt64 test_sync_time_;
        public bool is_init_world_;
        public PxScene* px_scene_;
        public UInt64 stamp_;
        public TriggerManager trigger_mgr_;

        //是否是这样弄？ 
        public PxTriggerPair pairs;
        public UInt32 count = 128;

        public int userid;

    }

    //public static extern PxFilterFlags PxSimulationFilterCallback_pairFound_mut
    //先使用原来的风格 后续改为微软命名风格
    //主要继承PxSimulationEventCallback  然后触发PxSimulationEventCallback中回调函数
    public unsafe struct PhysxWorld : IDisposable // : public PhysxBase, public physx::PxSimulationEventCallback {
    {
        //继承而来
        //PhysxBase _physxBase;
        SimulationEventCallbackInfo* _event_call_back;
        PxSimulationFilterCallback* filter_callback_;


        WorldUserData _worldUserData;

        //Interlocked.Add;
        //原子操作
        static UInt64 atomic_next_id_;
        //UInt64 test_sync_time_;

        public PhysxWorld() { }
        //~PhysxWorld();

        public void Dispose()
        {
            //destroy_simulation_event_callbacks(_event_call_back);
            if (_worldUserData.px_scene_ != null)
            {
                //TODO  构造px_scene_ 使用的 scentdesc 是否需要释放？ 
                _worldUserData.px_scene_->ReleaseMut();
            }
        }

        public void SetPvdHost(string host)
        {
            _worldUserData.PVD_HOST = host;
        }

        //长方体
        public PxBoxGeometry* CreateBoxGeo(float lon, float wide, float height)
        {
            PxBoxGeometry temp = PxBoxGeometry_new(lon, wide, height);
            return &temp;
        }
        //球体
        public PxSphereGeometry* CreateSphereGeo(float radius)
        {
            PxSphereGeometry temp = PxSphereGeometry_new(radius);
            return &temp;
        }
        //胶囊体
        public PxCapsuleGeometry* CreateCapsuleGeo(float radius, float height, int capsuleAxis)
        {
            PxCapsuleGeometry temp = PxCapsuleGeometry_new(radius, height * 0.5f);
            return &temp;
        }

        //创建几何体
        public PxGeometry* CreateGeometry(int shape_type, PxVec3* min_position, PxVec3* max_position)
        {
            PxGeometry* geometry = null;

            PxVec3 size;
            size.x = (MathF.Abs(max_position->x - min_position->x));
            size.y = (MathF.Abs(max_position->y - min_position->y));
            size.z = (MathF.Abs(max_position->z - min_position->z));

            switch (shape_type)
            {
                case (int)PhysxShapeType.PX_SPHERE:
                    {
                        float max_r = MathF.Max(size.x, size.y);

                        max_r = MathF.Max(max_r, size.z);

                        geometry = (PxGeometry*)CreateSphereGeo(max_r * 0.5f);

                        break;
                    }

                case (int)PhysxShapeType.PX_BOX:
                    {
                        geometry = (PxGeometry*)CreateBoxGeo(size.x * 0.5f, size.y * 0.5f, size.z * 0.5f);

                        break;
                    }

                case (int)PhysxShapeType.PX_CAPSULE:
                    {
                        float len = MathF.Max(size.x, size.y);
                        len = MathF.Max(len, size.z);
                        int direction = 0;
                        float radius = 0.0f;
                        float height = len;

                        if (len == size.x)
                        {
                            direction = 0;
                            radius = MathF.Max(size.y, size.z) * 0.5f;
                        }
                        else if (len == size.y)
                        {
                            direction = 1;
                            radius = MathF.Max(size.x, size.z) * 0.5f;
                        }
                        else if (len == size.z)
                        {
                            direction = 2;
                            radius = MathF.Max(size.x, size.y) * 0.5f;
                        }

                        if (MathF.Abs(radius) < 0.000001) return geometry;
                        if (MathF.Abs(height) < 0.000001) return geometry;

                        geometry = (PxGeometry*)CreateCapsuleGeo(radius, height - 2 * radius, direction);

                        break;
                    }
            }
            return geometry;
        }

        //创建一个形状
        PxShape* CreateShap(PxGeometry* geometry, bool isExclusive = false,
                                         PxShapeFlags shapeFlags = PxShapeFlags.Visualization |
                                         PxShapeFlags.SceneQueryShape |
                                         PxShapeFlags.SimulationShape)
        {
            return PxPhysics_createShape_mut(PhysxCommon.Instance.GetPhysics(),
                    geometry, PhysxCommon.Instance.GetDefaultMaterial(), isExclusive, shapeFlags);
        }

        /////////////////////////////////////////////////////////////////////////
        // implement add Trigger shape
        /////////////////////////////////////////////////////////////////////////

        bool AddBoxTrigger(PxRigidDynamic* actor, float lon,
                           float wide, float height,
                           UInt32 effectType, UInt32 effectValue,
                           TriggerCallBack.TRIGGER_FUNC enter, TriggerCallBack.TRIGGER_FUNC leave)
        {
            PxBoxGeometry* box = CreateBoxGeo(lon, wide, height);
            PxShape* shap = CreateShap((PxGeometry*)box, true);  //! must be exclusive
            if (shap == null)
            {
                return false;
            }
            return AddTriggerFromShape(actor, shap, effectType, effectValue, enter, leave);
        }

        bool AddSphereTrigger(PxRigidDynamic* actor, float radius,
                              UInt32 effectType, UInt64 effectValue,
                              TriggerCallBack.TRIGGER_FUNC enter, TriggerCallBack.TRIGGER_FUNC leave)
        {
            if (radius < 0.001f)
            {
                return false;
            }

            PxSphereGeometry* sphere = CreateSphereGeo(radius);
            PxShape* shap = CreateShap((PxGeometry*)sphere, true);
            if (shap == null)
            {
                return false;
            }
            return AddTriggerFromShape(actor, shap, effectType, effectValue, enter, leave);
        }

        bool AddSphereTrigger(void* userPointer, PxVec3 startPosition,
                              PxQuat startOrientation,
                              UInt32 filterGroup, UInt32 filterMask,
                              float radius, UInt32 effectType,
                              UInt64 effectValue, TriggerCallBack.TRIGGER_FUNC enter,
                              TriggerCallBack.TRIGGER_FUNC leave)
        {
            if (radius < 0.001f) return false;

            PxSphereGeometry* sphere = CreateSphereGeo(radius);
            PxShape* shap = CreateShap((PxGeometry*)sphere, true);
            if (shap == null) return false;

            PxFilterData filterData;
            filterData.word0 = filterGroup;  // word0 = own ID
            filterData.word1 = filterMask;   // word1 = ID mask to filter pairs that
                                             // trigger a contact callback;

            shap->SetSimulationFilterDataMut(&filterData);
            shap->SetFlagMut(PxShapeFlag.SimulationShape, false);
            shap->SetFlagMut(PxShapeFlag.TriggerShape, true);

            PxTransform tf = new PxTransform();
            tf.p = startPosition;
            tf.q = startOrientation;
            PxRigidDynamic* actor = shap != null ?
            //PxCreateDynamic( physx_common::GetInst()->GetPhysics(), PxTransform(startPosition, startOrientation), *shap, 10.0f): null;
            phys_PxCreateDynamic_1(PhysxCommon.Instance.GetPhysics(), &tf, shap, 10.0f) : null;

            if (actor == null)
            {
                shap->ReleaseMut();
                return false;
            }
            return true;
        }

        bool AddCapsuleTrigger(PxRigidDynamic* actor, float radius,
                               float height, UInt32 effectType,
                               UInt64 effectValue, TriggerCallBack.TRIGGER_FUNC enter,
                               TriggerCallBack.TRIGGER_FUNC leave)
        {
            PxCapsuleGeometry* capsule = CreateCapsuleGeo(radius, height, 0);
            PxShape* shap = (PxShape*)CreateShap((PxGeometry*)capsule, true);
            if (shap == null) return false;

            return AddTriggerFromShape(actor, shap, effectType, effectValue, enter, leave);
        }

        bool AddTriggerFromShape(PxRigidDynamic* actor, PxShape* shape,
                                 UInt32 effectType, UInt64 effectValue,
                                 TriggerCallBack.TRIGGER_FUNC enter, TriggerCallBack.TRIGGER_FUNC leave)
        {

            if (shape == null) return false;

            PxFilterData filterData;
            filterData.word0 = (uint)PhysxCollisionTypes.PX_COL_TRIGGER_OBJ;  // word0 = own ID
            filterData.word1 = (uint)PxConstValue.MaskTriggerColldierWith;  // word1 = ID mask to filter pairs that // trigger a contact callback;

            shape->SetSimulationFilterDataMut(&filterData);
            ((PxRigidActor*)actor)->AttachShapeMut(shape);
            shape->SetFlagMut(PxShapeFlag.SimulationShape, false);
            shape->SetFlagMut(PxShapeFlag.TriggerShape, true);
            //trigger_mgr_.Push(std::make_shared<TriggerCallBack>( shape, effectType, effectValue, std::forward<TRIGGER_FUNC>(enter), std::forward<TRIGGER_FUNC>(leave)));
            //需要注意 TriggerCallBack * 的释放  智能指针

            TriggerCallBack tmp = new TriggerCallBack(shape, effectType, effectValue, enter, leave);
            _worldUserData.trigger_mgr_.Push(&tmp);

            //这一步是减少引用次数 和用户数据无关  防止内存泄露
            //shape->ReleaseMut();
            return true;
        }

        void DeleteTriggerCallBack(PxRigidActor* actor)
        {
            if (actor != null)
            {
                _worldUserData.trigger_mgr_.OnReleaseActor(actor);
            }
        }

        void ResetTrigger(PxRigidActor* actor)
        {
            if (actor != null)
            {
                _worldUserData.trigger_mgr_.ResetTriggersInActor(actor);
            }
        }
        /////////////////////////////////////////////////////////////////////////
        PxRigidActor* AddCollisionToDynamicsWord(
        int mass, void* userPointer, int userIndex, int userIndex2,
        int shape_type, PxVec3* min_position, PxVec3* max_position,
        PxVec3 startPosition, PxQuat startOrientation,
        PxVec3* hero_position = null)
        {

            //这一部是错误的  api 有bug  不可以返回指针类型  必须在当前栈对象创建PxGemometry ！！
            PxGeometry* geometry = CreateGeometry(shape_type, min_position, max_position);

            if (geometry == null)
            {
                return null;
            }


            PxVec3 center;
            center.x = ((max_position->x + min_position->x) * 0.5f);
            center.y = ((max_position->y + min_position->y) * 0.5f);
            center.z = ((max_position->z + min_position->z) * 0.5f);
            float fmax = float.MaxValue;
            if (mass <= 0)
            {
                startPosition = center;
            }

            //PxSceneWriteLock scopedLock(*px_scene_);
            _worldUserData.px_scene_->LockWriteMut(null, 0);
            PxRigidActor* rigActor = null;
            if (userIndex == (int)PhysxObjectType.PX_STATICOBJECT)
            {
                //TODO
                //需要确认 继承关系 才可以类型强转
                var identity = PxTransform_new_2(PxIDENTITY.PxIdentity);
                var pxTran = new PxTransform { p = startPosition, q = startOrientation };
                rigActor = (PxRigidActor*)phys_PxCreateStatic(
                    PhysxCommon.Instance.GetPhysics(), &pxTran, geometry,
                    PhysxCommon.Instance.GetDefaultMaterial(), &identity);
            }
            else
            {
                var identity = PxTransform_new_2(PxIDENTITY.PxIdentity);
                var pxTran = new PxTransform { p = startPosition, q = startOrientation };
                rigActor = (PxRigidActor*)phys_PxCreateDynamic(
                    PhysxCommon.Instance.GetPhysics(), &pxTran, geometry,
                    PhysxCommon.Instance.GetDefaultMaterial(), 10.0f, &identity);

                if (rigActor == null)
                {
                    //TODO 销毁api
                    //delete geometry;
                    return null;
                }

                //rigActor->SetActorFlag(PxActorFlag.DisableGravity, true);
                PxActor_setActorFlag_mut((PxActor*)rigActor, PxActorFlag.DisableGravity, true);
                //rigActor   setAngularDamping(0);
                PxRigidBody_setAngularDamping_mut((PxRigidBody*)rigActor, 0);
                PxRigidBody_setLinearDamping_mut((PxRigidBody*)rigActor, 0);
                PxRigidBody_setLinearDamping_mut((PxRigidBody*)rigActor, 0);
                PxVec3 tmp = new Vector3(0, 0, 0);
                ((PxRigidDynamic*)rigActor)->SetLinearVelocityMut(&tmp, false);

                PxShape* treasureShape = null;
                rigActor->GetShapes(&treasureShape, 1, 0);

                treasureShape->SetContactOffsetMut(0.2f);
                treasureShape->SetRestOffsetMut(0.01f);
                if (shape_type == (int)PhysxShapeType.PX_CAPSULE)
                {
                    //胶囊调整为沿z轴线缩放
                    //PxTransform relativePose( PxQuat(PxHalfPi, PxVec3(0, 1, 0)));
                    var quat = new PxQuat { w = PhysxCommon.PxHalfPi, x = 0, y = 1, z = 0 };
                    var relativePose = new PxTransform { p = startPosition, q = startOrientation };
                    treasureShape->SetLocalPoseMut(&relativePose);
                }
            }

            if (rigActor == null)
            {
                //TODO：
                //delete geometry;
                return null;
            }


            //可以简化逻辑  调用新的api 直接设置密度和质量  
            // add collision mask
            if (mass > 0)
            {
                if (userIndex == (int)PhysxObjectType.PX_MONSTERGROUP)
                {
                    SetupFiltering(rigActor, (int)PhysxCollisionTypes.PX_COL_MONSTER_GROUP_OBJ, PxConstValue.MaskMonsterGroupColldierWith);
                }
                else if (userIndex == (int)PhysxObjectType.PX_TRIGGER)
                {
                    SetupFiltering(rigActor, (int)PhysxCollisionTypes.PX_COL_TRIGGER_OBJ, PxConstValue.MaskTriggerColldierWith);
                }
                else if (userIndex == (int)PhysxObjectType.PX_MONSTER)
                {
                    SetupFiltering(rigActor, (int)PhysxCollisionTypes.PX_COL_MONSTER, PxConstValue.MaskMonsterColldersWith);
                }
                else
                {
                    SetupFiltering(rigActor, (int)PhysxCollisionTypes.PX_COL_AIR_SHIP, PxConstValue.MaskAirShipCollidesWith);
                }
            }
            else
                SetupFiltering(rigActor, (int)PhysxCollisionTypes.PX_COL_STATIC_OBJ, PxConstValue.MaskStaticCollidesWith);

            _worldUserData._physxBase.AddPhysicsActors(rigActor);

            if (mass > 0)
            {
                if ((PxRigidDynamic*)rigActor != null)
                {
                    ((PxRigidBody*)rigActor)->SetMassMut(fmax);
                    ((PxRigidBody*)rigActor)->SetRigidBodyFlagMut(PxRigidBodyFlag.EnableCcd, true);
                }
            }
            else
            {
                // rigActor->is<physx::PxRigidDynamic*>()->setMass(mass);
            }
            //rigActor->userData = ClassType::CreateClassType(userPointer, (PhysxObjectType)userIndex);
            _worldUserData.px_scene_->AddActorMut((PxActor*)rigActor, null);
            _worldUserData.px_scene_->UnlockWriteMut();
            return rigActor;
        }

        PxRigidActor* AddSpellCollison(
            int mass, void* userPointer, int userIndex, int shape_type, int range,
            PxVec3 startPosition, PxQuat startOrientation,
            PxVec3* spell_position = null)
        {
            return default(PxRigidActor*);
        }
        PxRigidActor* AddFlyerCollison(
            int mass, void* userPointer, int userIndex,
            //Eternity::FlatBuffer::FlyerColliderData* collider_data,
            void* collider_data,  //用户数据
            PxVec3 startPosition, PxQuat startOrientation)
        {
            //return default(PxRigidActor*);
            return null;
        }
        public bool AddActorToDaynamicWorld(PxRigidActor* actor)
        {
            _worldUserData.px_scene_->AddActorMut((PxActor*)actor, null);
            return true;
        }
        public void PickUpActor(PxRigidActor* actor)
        {
            _worldUserData.px_scene_->RemoveActorMut((PxActor*)actor, true);
        }
        int StepSimulation(/*KScene* secene,*/ UInt64 delta_time = 0)
        {

            //update 时间更新代码
            UInt32 error = 0;
            _worldUserData.px_scene_->SimulateMut(delta_time * 0.001f, null, null, 0, controlSimulation: true);
            _worldUserData.px_scene_->FetchResultsMut(true, &error);

            _worldUserData.trigger_mgr_.Update();
            SyncUser();
            return 1;
        }


        // world 类自身方法 start
        public void OnInit()
        {
            if (filter_callback_ != null)
            {
                //delete filter_callback_;
                //filter_callback_->dispose();
                filter_callback_ = null;
            }

            MyOwnerFilterCallbackPhysx tmp = new MyOwnerFilterCallbackPhysx();

            filter_callback_ = (PxSimulationFilterCallback*)&tmp;
            _worldUserData.trigger_mgr_.Clear();

            if (!PhysxCommon.Instance.InitPhyxsSDK())
            {
                //LogMgr::GetInstance()->Error(
                //    "[PhysxWorld]InitPhyxsSDK() cannot init physxSDK!!!!");
                return;
            }

            _worldUserData = new WorldUserData();
            CreatePxScene();
            _worldUserData.is_init_world_ = true;
        }

        void CreatePxScene()
        {
            if (_worldUserData.px_scene_ != null)
            {
                _worldUserData.px_scene_->ReleaseMut();
                _worldUserData.px_scene_ = null;
            }

            PxSceneDesc sceneDesc = PxSceneDesc_new(PxPhysics_getTolerancesScale(PhysxCommon.Instance.GetPhysics()));
            sceneDesc.gravity = new Vector3(0.0f, 0.0f, 0.0f);
            sceneDesc.cpuDispatcher = (PxCpuDispatcher*)PhysxCommon.Instance.GetCpuDispatcher();

            delegate*<UInt32, PxFilterData, UInt32, PxFilterData, PxPairFlags*, void*, UInt32, PxFilterFlags> callback;
            callback = &(PxConstValue.PhysxWorldFilterShader);
            sceneDesc.filterShader = (void*)(delegate* unmanaged[Cdecl]<UInt32, PxFilterData, UInt32, PxFilterData, PxPairFlags*, void*, UInt32, PxFilterFlags>)callback;

            //sceneDesc.simulationEventCallback = this;
            delegate*<void*, PxContactPairHeader*, PxContactPair*, uint, void> tmpContact = &onContact;
            _event_call_back->collision_callback = (delegate* unmanaged[Cdecl]<void*, PxContactPairHeader*, PxContactPair*, uint, void>)tmpContact;
            //根据需要填写用户数据
            _event_call_back->collision_user_data = null;

            delegate*<void*, PxTriggerPair*, uint, void> tmpTrigger = &onTrigger;
            _event_call_back->trigger_callback = (delegate* unmanaged[Cdecl]<void*, PxTriggerPair*, uint, void>)tmpTrigger;
            _event_call_back->trigger_user_data = null;

            //其余方法没有重载 不需要设置回调函数
            sceneDesc.simulationEventCallback = create_simulation_event_callbacks(_event_call_back);
            //TODO: 这个需要关注下
            //sceneDesc.simulationEventCallback->OnContactMut();

            //TODO count该如何传参数？
            fixed (PxTriggerPair* ptr = &_worldUserData.pairs)
            {
                sceneDesc.simulationEventCallback->OnTriggerMut(ptr, _worldUserData.count);
            }

            _worldUserData.px_scene_ = PxPhysics_createScene_mut(PhysxCommon.Instance.GetPhysics(), &sceneDesc);
            if (_worldUserData.px_scene_ == null)
            {
                //LogMgr::GetInstance()->Error(
                //    "PhysxWorld::CreatePxScene() error:px_scene_ is null");
                return;
            }
        }

        void ChangePVDStatus(bool flag = false)
        {
            if (_worldUserData.px_scene_ == null) return;

            PxPvdSceneClient* pvdClient = _worldUserData.px_scene_->GetScenePvdClientMut();
            if (pvdClient != null)
            {
                pvdClient->SetScenePvdFlagMut(PxPvdSceneFlag.TransmitConstraints, flag);
                pvdClient->SetScenePvdFlagMut(PxPvdSceneFlag.TransmitContacts, flag);
                pvdClient->SetScenePvdFlagMut(PxPvdSceneFlag.TransmitScenequeries, flag);
            }
        }

        PxScene* GetActiveScene() { return _worldUserData.px_scene_; }
        bool IsInitWorld() { return _worldUserData.is_init_world_; }

        void SyncUser()
        {
            UInt32 nbDynamics = _worldUserData.px_scene_->GetNbActors(PxActorTypeFlags.RigidDynamic);
            if (nbDynamics < 1) { return; }

            //std::vector<PxRigidActor*> actors(nbDynamics);
            PxRigidActor*[] actors = new PxRigidActor*[nbDynamics];
            fixed (PxRigidActor** actorPtr = actors)
            {
                _worldUserData.px_scene_->GetActors(PxActorTypeFlags.RigidDynamic, (PxActor**)actorPtr, nbDynamics, 0);
            }

            //PxSceneWriteLock scopedLock(*px_scene_);
            //PxSceneWriteLock* sceneLock = PxSceneWriteLock_new_alloc(px_scene_, null, 0);
            _worldUserData.px_scene_->LockWriteMut(null, 0);
            for (UInt32 a = 0; a < nbDynamics; ++a)
            {
                //PxRigidActor* actor = actors[a]->is < PxRigidActor > ();
                PxRigidActor* actor = actors[a];
                if (actor == null)
                {
                    continue;
                }

                // PxRigidDynamic* dynamic = static_cast<PxRigidDynamic*>(actor);
                PxRigidDynamic* dynamic = (PxRigidDynamic*)(actor);
                PxShape* shape;
                actor->GetShapes(&shape, 1, 0);

                PhysxObjectType type0 = PxConstValue.PhysxGetUserType(actor);
                if (type0 == PhysxObjectType.PX_AIRSHIP ||
                    type0 == PhysxObjectType.PX_MONSTER ||
                    type0 == PhysxObjectType.PX_MONSTERGROUP ||
                    type0 == PhysxObjectType.PX_TRIGGER)
                {
                    //业务代码
                }
                else if (type0 == PhysxObjectType.PX_SPELL)
                {
                    //业务代码
                }
            }
            _worldUserData.px_scene_->UnlockWriteMut();
            //PxSceneWriteLock_delete(sceneLock);
        }

        void DeleteCollisionWorld()
        {
            if (!_worldUserData.is_init_world_ || _worldUserData.px_scene_ == null) return;
            UInt32 error;
            //px_scene_->simulate(STEP_SECOND);
            //px_scene_->SimulateMut(10);
            //px_scene_->fetchResults(true, &error);
            //TODO 10 是为了语法不报错  需要填写实际业务代码实际STEP_SECOND
            _worldUserData.px_scene_->SimulateMut(10, null, null, 0, controlSimulation: true);
            _worldUserData.px_scene_->FetchResultsMut(true, &error);
            //PxScene_fetchResults_mut(px_scene_, true, &error);

            _worldUserData.trigger_mgr_.Clear();


            foreach (PxRigidActor* it in _worldUserData._physxBase._physicsActors)
            {
                if ((it != null) && (it->userData != null))
                {
                    //TODO
                    //释放用户数据
                    it->userData = null;
                }
            }

            _worldUserData._physxBase.RemoveAllActor();

            if (filter_callback_ != null)
            {
                //TODO:
                //delete filter_callback_;
                filter_callback_ = null;
            }

            //px_scene_->release();
            _worldUserData.px_scene_->ReleaseMut();
            _worldUserData.px_scene_ = null;
            _worldUserData.is_init_world_ = false;
        }

        void RemoveAirShipOrSpell(PxRigidActor* obj)
        {
            if (obj != null)
            {
                DeleteTriggerCallBack(obj);


                UInt32 error;
                _worldUserData.px_scene_->SimulateMut(10, null, null, 0, controlSimulation: true);
                _worldUserData.px_scene_->FetchResultsMut(true, &error);

                //PxSceneWriteLock scopedLock(*px_scene_);
                PxSceneWriteLock* sceneLock = PxSceneWriteLock_new_alloc(_worldUserData.px_scene_, null, 0);
                if (obj->userData != null)
                {
                    //delete obj->userData;
                    //TODO 释放用户数据
                    obj->userData = null;
                }
                _worldUserData._physxBase.RemoveActor(obj);
                PxSceneWriteLock_delete(sceneLock);
            }
        }

        void SetupFiltering(PxRigidActor* actor, UInt32 filterGroup,
                            UInt32 filterMask)
        {
            _worldUserData.px_scene_->LockWriteMut(null, 0);
            PxFilterData filterData = default;
            filterData.word0 = filterGroup;  // word0 = own ID
            filterData.word1 = filterMask;   // word1 = ID mask to filter pairs that
            filterData.word3 |= (1 << 29);   // trigger a contact callback;


            UInt32 numShapes = actor->GetNbShapes();
            PxShape*[] shapes = new PxShape*[numShapes];
            fixed (PxShape** p = shapes)
            {
                actor->GetShapes(p, numShapes, 0);
                for (UInt32 i = 0; i < numShapes; i++)
                {
                    PxShape* shape = shapes[i];
                    //shape->setSimulationFilterData(filterData);
                    shape->SetSimulationFilterDataMut(&filterData);
                }
            }

            _worldUserData.px_scene_->UnlockWriteMut();
        }
        // world 类自身方法 end


        bool RayTest(
                    PxRigidActor* actor, PxVec3 start_position,
                    PxVec3 normalizedDir, int mask, int group,
                    PhysxCollisionHitResult* hit_result,
                    float distance = float.MaxValue)
        {

            if (actor == null) return false;

            PxRaycastHit* rayHit= stackalloc PxRaycastHit[1];

            PxQueryFilterData filterData;
            filterData.flags = (PxQueryFlags)mask;


            PhysxWorldRaycastResultCb_1 CB = new PhysxWorldRaycastResultCb_1(&start_position, &normalizedDir);
            CB.callback = &(PhysxWorldRaycastResultCb_1.preFilter);

            PxQueryFilterCallback* fliterCallBack = create_raycast_filter_callback_func(
                (delegate* unmanaged[Cdecl]<PxRigidActor*, PxFilterData*, PxShape*, uint, void*, PxQueryHitType>)(CB.callback), (void*)&CB.userData);
            bool hasBlock = PxSceneQueryExt_raycastSingle(_worldUserData.px_scene_, &start_position, &normalizedDir, distance, PxHitFlags.Default,rayHit, &filterData, fliterCallBack, null);


            PxQueryFilterCallback_delete(fliterCallBack);
            if (hasBlock)
            {
                hit_result->hit_type = PxConstValue.PhysxGetUserType(rayHit->actor);
                hit_result->pos = rayHit->position;
                PxVec3 disPos = start_position.Multiply(&hit_result->pos);
                float length = disPos.Magnitude();
                //TODO:
                //hit_result->user_ptr = rayHit.block.actor->userData;
                hit_result->shape_ptr = rayHit->shape;
                hit_result->actor_ptr = rayHit->actor;
                return true;
            }
            return false;
        }

        bool SweepCheck(PxGeometry* geometry,
                         PxTransform* shapePose,
                         PxVec3* unitDir,
                         PhysxCollisionHitResult* hit_result)
        {
            if (_worldUserData.px_scene_ == null) return false;

            //PxSweepBuffer sweepHit =default;
            PxSweepHit sweepHit = default(PxSweepHit);
            PxQueryFilterData filterData = default;
            filterData.flags = PxQueryFlags.Static;
            float distance = 0.1f;

            bool hasHit = PxSceneQueryExt_sweepSingle(_worldUserData.px_scene_, geometry, shapePose, unitDir, distance, PxHitFlags.Default, &sweepHit, &filterData, null, null, 0.0f);
            if (hasHit = true)
            {
                //hit_result->hit_type = PxConstValue.PhysxGetUserType(sweepHit.actor);
                //// hit_result.pos = sweepHit.block.position;
                //hit_result->user_ptr = sweepHit.actor->userData;
                //hit_result->shape_ptr = sweepHit.shape;
                //hit_result->actor_ptr = sweepHit.actor;
                return true;
            }
            return false;
        }

        bool OverlapCheck(PxGeometry* geometry,
                           PxTransform* shapePose,
                            List<IntPtr> hero_list)
        {
            if (_worldUserData.px_scene_ == null) return false;

            PxOverlapHit* hitBuffer = stackalloc PxOverlapHit[128];

            PxQueryFilterData filterData;
            filterData.flags = PxQueryFlags.Dynamic;

            bool hasOverLap = PxSceneQueryExt_overlapAny(_worldUserData.px_scene_, geometry, shapePose, hitBuffer, null,null);
            if (hasOverLap )
            {
                return true;
            }

            return false;
        }

        bool RayCastStatic(
            PxVec3 start_pos, PxVec3 normalized_dir,
            float distance = float.MaxValue)
        {
            //PxRaycastBuffer rayHits = default;
            PxRaycastHit rayHit = default;
            PxQueryFilterData filterData;
            filterData.flags = PxQueryFlags.Static;

            //注意normalized_dir 需要经过 标准向量化
            bool hasblock = PxSceneQueryExt_raycastSingle(_worldUserData.px_scene_, &start_pos, &normalized_dir, distance, PxHitFlags.Default, &rayHit, &filterData, null, null);

            if (hasblock == true)
            {
                return true;
            }
            return false;
        }

        void RayCastDynamic(PxVec3 start_pos, PxVec3 normalized_dir,
                            float distance, List<IntPtr>* hero_list)
        {

            PxRaycastHit* rayHit = stackalloc PxRaycastHit[128];
            PxQueryFilterData filterData = default;
            filterData.flags = PxQueryFlags.Dynamic;


            //如果查询数据超过128  最多返回128 经测试不会崩溃
            int buffSize = PxSceneQueryExt_raycastMultiple(_worldUserData.px_scene_ , & start_pos, &normalized_dir, distance, PxHitFlags.Default, rayHit, 128 , null, &filterData, null ,null);

            for (int i = 0; i < buffSize; i++)
            {
                PxRigidActor* tmp = rayHit[i].actor;
                PhysxObjectType type = PxConstValue.PhysxGetUserType(tmp);
                if (type == PhysxObjectType.PX_AIRSHIP ||
                    type == PhysxObjectType.PX_MONSTER)
                {
                }
            }
        }

        //工具方法 end 


        // 静态回调方法 
        public static void onTrigger(void* userData, PxTriggerPair* pairs, UInt32 count)
        {
            if (userData == null) { return; }
            WorldUserData* _worldUserData = (WorldUserData*)userData;
            for (UInt32 i = 0; i < count; i++)
            {
                PxTriggerPair* tp = &pairs[i];
                // ignore pairs when shapes have been deleted
                if ((tp->flags & (PxTriggerPairFlags.RemovedShapeTrigger |
                                 PxTriggerPairFlags.RemovedShapeOther)) != 0)
                {
                    continue;
                }

                if (tp->otherActor == null || tp->triggerActor == null)
                {
                    continue;
                }

                //TriggerCallBackPtr cb_ptr = trigger_mgr_.FindTrigger(tp->triggerShape);
                //记得释放指针 TriggerCallBackPtr是智能指针定义
                TriggerCallBack* cb_ptr = _worldUserData->trigger_mgr_.FindTrigger(tp->triggerShape);

                if (cb_ptr == null)
                {
                    continue;
                }

                if ((tp->status & PxPairFlag.NotifyTouchFound) != 0)
                {
                    cb_ptr->OnEnter((PxRigidActor*)tp->triggerActor, (PxRigidActor*)tp->otherActor, cb_ptr->effectType_);
                }
                else if ((tp->status & PxPairFlag.NotifyTouchLost) != 0)
                {
                    cb_ptr->OnLeave((PxRigidActor*)tp->triggerActor, (PxRigidActor*)tp->otherActor, cb_ptr->effectType_);
                }
            }
        }

        public static void onContact(void* userData, PxContactPairHeader* pairHeader, PxContactPair* pairs, UInt32 nbPairs)
        {

            if (userData == null) { return; }
            WorldUserData* _worldUserData = (WorldUserData*)userData;

            //List<PxContactPairPoint> contactPoints;
            IntPtr[] contactPoints = new IntPtr[128];

            for (UInt32 i = 0; i < nbPairs; i++)
            {
                PxContactPair* cp = &pairs[i];
                PhysxObjectType type0 = PxConstValue.PhysxGetUserType((PxRigidActor*)pairHeader->actors[0]);
                PhysxObjectType type1 = PxConstValue.PhysxGetUserType((PxRigidActor*)pairHeader->actors[1]);

                if (((int)cp->events & (int)(PxPairFlag.NotifyTouchFound |
                                 PxPairFlag.NotifyTouchCcd)) != 0)
                {
                    UInt32 contactCount = cp->contactCount;
                    if (contactCount < 1) continue;
                    Array.Resize<IntPtr>(ref contactPoints, (int)contactCount);
                    //structgen_pad0 函数地址
                    fixed (IntPtr* contactPointsPtr = contactPoints)
                    {
                        PxContactPairPoint* conPtr0 = (PxContactPairPoint*)contactPointsPtr->ToPointer();
                        cp->ExtractContacts(conPtr0, contactCount);
                    }

                    for (UInt32 j = 0; j < contactCount; j++)
                    {
                        if ((type0 == PhysxObjectType.PX_AIRSHIP &&
                             type1 == PhysxObjectType.PX_STATICOBJECT) ||
                            (type1 == PhysxObjectType.PX_AIRSHIP &&
                             type0 == PhysxObjectType.PX_STATICOBJECT))
                        {
                            PxRigidDynamic* dynamic = null;
                            //KHero* hero = null;
                            void* hero = null; // 用户数据
                            if (type0 == PhysxObjectType.PX_AIRSHIP)
                            {
                                //dynamic = Unsafe.AsRef<PxRigidDynamic>(ptr);
                                dynamic = (PxRigidDynamic*)(pairHeader->actors[0]);
                            }
                            else
                            {
                                //dynamic = Unsafe.AsRef<PxRigidDynamic>(ptr);
                                dynamic = (PxRigidDynamic*)(pairHeader->actors[0]);
                            }
                            if (dynamic != null)
                            {
                                //hero = static_cast<ClassType*>(dynamic->userData)->is < KHero *> ();
                                //if (!hero || hero->hit_wall_) continue;

                                //UInt64 now = KG_GetTickCount();
                                //TODO:需要根据实际业务完善
                                UInt64 now = 100;
                                if (now - _worldUserData->test_sync_time_ <= 1000) continue;
                                if (type1 != PhysxObjectType.PX_STATICOBJECT) continue;

                                //auto player = hero->GetOwnerPlayer();
                                //if (!player) continue;

                                //PxRigidStatic* static_actor =   static_cast<PxRigidStatic*>(pairHeader.actors[1]);
                                PxRigidStatic* static_actor = (PxRigidStatic*)(pairHeader->actors[1]);

                                UInt32 num = ((PxRigidActor*)(static_actor))->GetNbShapes();
                                PxShape*[] shapes = new PxShape*[num];
                                fixed (PxShape** p = shapes)
                                {
                                    UInt32 nbShapes = ((PxRigidActor*)(static_actor))->GetShapes(p, num, 0);
                                    if (num != nbShapes) continue;
                                }

                                //将碰撞盒子发给客户端显示
                                //List<GeometryInfo> geometry_list;
                                for (UInt32 k = 0; k < num; k++)
                                {
                                    //if (shapes[k]->GetGeometryType() != PxGeometryType.Box)
                                    //    continue;

                                    //必须这么写 和system GetType重名了 总是会调用System GetType
                                    var geoType = NativeMethodsGroupingExtensions.GetType(ref *shapes[k]->GetGeometry());
                                    if (geoType != PxGeometryType.Box)
                                        continue;

                                    PxVec3 st_pos = ((PxRigidActor*)(static_actor))->GetGlobalPose().p;
                                    PxQuat st_quat = ((PxRigidActor*)(static_actor))->GetGlobalPose().q;
                                    //GeometryInfo info;

                                    if (shapes[k]->GetGeometry() != null)
                                    {
                                        PxBoxGeometry* box_geometry = (PxBoxGeometry*)(shapes[k]->GetGeometry());
                                        //业务代码
                                    }
                                }
                                _worldUserData->test_sync_time_ = now;

                            }
                            continue;
                        }
                        else if ((type0 == PhysxObjectType.PX_AIRSHIP ||
                                    type0 == PhysxObjectType.PX_MONSTER) &&
                                   type1 == PhysxObjectType.PX_SPELL)
                        {
                            //业务代码

                        }
                        else if (type0 == PhysxObjectType.PX_SPELL &&
                                   (type1 == PhysxObjectType.PX_AIRSHIP ||
                                    type1 == PhysxObjectType.PX_MONSTER))
                        {
                            //业务代码
                        }
                        else if (type0 == PhysxObjectType.PX_SPELL &&
                                   type1 == PhysxObjectType.PX_STATICOBJECT)
                        {
                            //业务代码

                        }
                        else if (type0 == PhysxObjectType.PX_STATICOBJECT &&
                                   type1 == PhysxObjectType.PX_SPELL)
                        {
                            //业务代码

                        }
                    }
                }
                else if (((int)cp->events & (int)PxPairFlag.NotifyTouchLost) != 0)
                {
                    if ((type0 == PhysxObjectType.PX_AIRSHIP &&
                         type1 == PhysxObjectType.PX_STATICOBJECT) ||
                        (type1 == PhysxObjectType.PX_AIRSHIP &&
                         type0 == PhysxObjectType.PX_STATICOBJECT))
                    {
                        PxRigidDynamic* dynamic = null;
                        //KHero* hero = null;
                        void* hero = null; //业务代码
                        if (type0 == PhysxObjectType.PX_AIRSHIP)
                        {
                            dynamic = (PxRigidDynamic*)(pairHeader->actors[0]);

                        }
                        else
                        {
                            dynamic = (PxRigidDynamic*)(pairHeader->actors[1]);
                        }
                        if (dynamic != null)
                        {
                            if (dynamic->userData != null)
                            {
                                // hero = static_cast<ClassType*>(dynamic->userData)->is < KHero *> ();
                            }
                            if (hero == null)
                            {
                                // hero->hit_wall_ = false;
                            }
                        }
                    }
                }
            }

        }
        public static void onConstraintBreak(void* userData, PxConstraintInfo* info, UInt32 flag) { }
        public static void onWake(void* userData, PxActor** actors, UInt32 count) { }
        public static void onSleep(void* userData, PxActor** actors, UInt32 count) { }
        public static void onAdvance(void* userData, PxRigidBody** ppRigid, PxTransform* pTrans, UInt32 nb) { }

    }
}