コード例 #1
0
ファイル: Body.cs プロジェクト: kindex/labyrinth2
        public Body(World world, Collision collision)
            : base(NativeAPI.CreateBody(world.handle, collision.handle))
        {
            this.World = world;
            this.collision = collision;

            IntPtr ptr = GCHandle.ToIntPtr(GCHandle.Alloc(this));
            NativeAPI.BodySetUserData(handle, ptr);

            NativeAPI.BodySetDestructorCallback(handle, NativeDestructorHandler);
        }
コード例 #2
0
ファイル: CustomJoint.cs プロジェクト: kindex/labyrinth2
        public CustomJoint(int maxDOF, Body body0, Body body1)
            : base(NativeAPI.ConstraintCreateUserJoint(body0.World.handle, maxDOF, NativeSubmitConstraint, NativeGetInfo, body0.handle, (body1 == null ? IntPtr.Zero : body1.handle)))
        {
            this.Body0 = body0;
            this.Body1 = body1;
            this.world = body0.World;

            IntPtr ptr = GCHandle.ToIntPtr(GCHandle.Alloc(this));
            NativeAPI.JointSetUserData(handle, ptr);

            NativeAPI.JointSetDestructor(handle, NativeDestructorHandler);
        }
コード例 #3
0
ファイル: CollisionInfo.cs プロジェクト: kindex/labyrinth2
 internal CollisionInfo(World world, NativeAPI.NewtonCollisionInfoRecord info)
 {
     this.info = info;
     this.world = world;
 }
コード例 #4
0
ファイル: CollisionInfo.cs プロジェクト: kindex/labyrinth2
 internal CompoundCollisionInfo(World world, int childrenCount, IntPtr children)
     : this()
 {
     this.children = new Collision[childrenCount];
     for (int i = 0; i < childrenCount; i++)
     {
         IntPtr newtonCollision = Marshal.ReadIntPtr(new IntPtr(children.ToInt64() + i * IntPtr.Size));
         this.children[i] = Collision.FromNewtonCollision(world, newtonCollision);
     }
 }
コード例 #5
0
ファイル: Collision.cs プロジェクト: kindex/labyrinth2
        internal static Collision FromNewtonCollision(World world, IntPtr newtonCollision)
        {
            NativeAPI.NewtonCollisionInfoRecord info;
            NativeAPI.CollisionGetInfo(newtonCollision, out info);

            Collision collision;

            switch (info.m_collisionType)
            {
                case NativeAPI.SERIALIZE_ID_BOX:
                case NativeAPI.SERIALIZE_ID_CONE:
                case NativeAPI.SERIALIZE_ID_SPHERE:
                case NativeAPI.SERIALIZE_ID_CAPSULE:
                case NativeAPI.SERIALIZE_ID_CYLINDER:
                case NativeAPI.SERIALIZE_ID_COMPOUND:
                case NativeAPI.SERIALIZE_ID_CONVEXHULL:
                case NativeAPI.SERIALIZE_ID_CONVEXMODIFIER:
                case NativeAPI.SERIALIZE_ID_CHAMFERCYLINDER:
                case NativeAPI.SERIALIZE_ID_NULL:
                    collision = new ConvexCollision(world, newtonCollision);
                    break;

                case NativeAPI.SERIALIZE_ID_TREE:
                    collision = new TreeCollision(world, newtonCollision);
                    break;

                case NativeAPI.SERIALIZE_ID_HEIGHFIELD:
                    collision = new Collision(world, newtonCollision);
                    break;

                case NativeAPI.SERIALIZE_ID_SCENE: //TODO
                default:
                    collision = new Collision(world, newtonCollision);
                    break;
            }

            collision.AddReference();
            return collision;
        }
コード例 #6
0
ファイル: Collision.cs プロジェクト: kindex/labyrinth2
 internal Collision(World world, IntPtr handle)
 {
     this.world = world;
     this.handle = handle;
 }
コード例 #7
0
ファイル: Collision.cs プロジェクト: kindex/labyrinth2
 internal TreeCollision(World world, IntPtr Handle)
     : base(world, Handle)
 {
 }
コード例 #8
0
ファイル: Collision.cs プロジェクト: kindex/labyrinth2
 internal ConvexHullModifier(World world, IntPtr Handle)
     : base(world, Handle)
 {
 }
コード例 #9
0
ファイル: Collision.cs プロジェクト: kindex/labyrinth2
 internal ConvexCollision(World world, IntPtr collision)
     : base(world, collision)
 {
 }
コード例 #10
0
ファイル: MaterialPair.cs プロジェクト: kindex/labyrinth2
 public MaterialPair(World world, int id0, int id1)
 {
     this.world = world;
     this.id0 = id0;
     this.id1 = id1;
 }
コード例 #11
0
ファイル: Create.cs プロジェクト: kindex/labyrinth2
        //bool ContactProcessEventHandler(Physics.Newton.MaterialCollision material, Physics.Newton.Body body0, Physics.Newton.Body body1, float timestep, int threadIndex)
        //{
        //    return true;
        //}
        void Create()
        {
            // Physic
            physic_world = new Physics.Newton.World();
            //material_pair = new Physics.Newton.MaterialPair(physic_world, physic_world.DefaultMaterialID, physic_world.DefaultMaterialID);
            //material_pair.SetCollisionCallback(null, ContactProcessEventHandler);

            // create box graph
            Vector3[] quadN = {
                new Vector3(1,0,0), new Vector3(-1, 0, 0),
                new Vector3(0,1,0), new Vector3( 0,-1, 0),
                new Vector3(0,0,1), new Vector3( 0, 0,-1),
            };

            Vector3[] quadX = {
                new Vector3( 0,0,1), new Vector3( 0, 0,-1),
                new Vector3( 1,0,0), new Vector3(-1, 0, 0),
                new Vector3(-1,0,0), new Vector3( 1, 0, 0),
            };

            ushort[] indices = new ushort[6 * 6];

            VF.PositionTexcoordNT[] boxDataVB = new VF.PositionTexcoordNT[6 * 4];
            for (int quad = 0; quad < quadN.Length; quad++)
            {
                boxDataVB[4 * quad + 0].Normal = quadN[quad];
                boxDataVB[4 * quad + 1].Normal = quadN[quad];
                boxDataVB[4 * quad + 2].Normal = quadN[quad];
                boxDataVB[4 * quad + 3].Normal = quadN[quad];

                boxDataVB[4 * quad + 0].Position = quadN[quad] * 0.5f - quadX[quad] * 0.5f - Vector3.Cross(quadN[quad], quadX[quad]) * 0.5f;
                boxDataVB[4 * quad + 1].Position = quadN[quad] * 0.5f + quadX[quad] * 0.5f - Vector3.Cross(quadN[quad], quadX[quad]) * 0.5f;
                boxDataVB[4 * quad + 2].Position = quadN[quad] * 0.5f + quadX[quad] * 0.5f + Vector3.Cross(quadN[quad], quadX[quad]) * 0.5f;
                boxDataVB[4 * quad + 3].Position = quadN[quad] * 0.5f - quadX[quad] * 0.5f + Vector3.Cross(quadN[quad], quadX[quad]) * 0.5f;

                boxDataVB[4 * quad + 0].Texcoord = new Vector2(0, 0);
                boxDataVB[4 * quad + 1].Texcoord = new Vector2(1, 0);
                boxDataVB[4 * quad + 2].Texcoord = new Vector2(1, 1);
                boxDataVB[4 * quad + 3].Texcoord = new Vector2(0, 1);

                indices[6 * quad + 0] = (ushort)(4 * quad + 0);
                indices[6 * quad + 1] = (ushort)(4 * quad + 1);
                indices[6 * quad + 2] = (ushort)(4 * quad + 2);
                indices[6 * quad + 3] = (ushort)(4 * quad + 0);
                indices[6 * quad + 4] = (ushort)(4 * quad + 2);
                indices[6 * quad + 5] = (ushort)(4 * quad + 3);
            }

            Utils.calculate_TB(boxDataVB, indices);

            boxVB = device.CreateVertexBuffer(BufferUsage.StaticDraw, boxDataVB);
            boxIB = device.CreateIndexBuffer(BufferUsage.StaticDraw, indices);

            Material box_m = new Material("wood_box");
            Material floor_m = new Material("metal");

            // create world
            labyrinth_matrix = Labyrinth.Generator.Generator.Generate(7, 7, 0);
            ceil_size = new Vector3(2, 1, 3);

            Box floor = new Box(new Vector3(0, -0.1f, 0), new Vector3(labyrinth_matrix.dim_x, 0, labyrinth_matrix.dim_y).MemberMul(ceil_size), floor_m, physic_world);

            boxes.Add(floor);
            boxes.Add(new Box(new Vector3(0, 0, 0), new Vector3(0.1f, 3, 0.1f), box_m, physic_world)); // start
            boxes.Add(new Box(new Vector3(labyrinth_matrix.dim_x, 0, labyrinth_matrix.dim_y).MemberMul(ceil_size), new Vector3(labyrinth_matrix.dim_x + 0.1f, 5, labyrinth_matrix.dim_y + 0.1f).MemberMul(ceil_size), box_m, physic_world)); // finish

            for (int x = -1; x <= labyrinth_matrix.dim_x; x++)
            {
                for (int y = -1; y <= labyrinth_matrix.dim_y; y++)
                {
                    if (labyrinth_matrix.isUpBorder(x, y))
                    {
                        boxes.Add(new WallBox(new Vector3(x, 0, y + 1).MemberMul(ceil_size), new Vector3(x + 1, 1, y + 1.1f).MemberMul(ceil_size), box_m, physic_world));
                    }
                    if (labyrinth_matrix.isRightBorder(x, y))
                    {
                        boxes.Add(new WallBox(new Vector3(x + 1, 0, y).MemberMul(ceil_size), new Vector3(x + 1.1f, 1, y + 1).MemberMul(ceil_size), box_m, physic_world));
                    }
                }
            }

            for (int i = 0; i < pointlights; i++)
            {
                lights.Add(new PointLight()
                {
                    Ambient = 0.2f,
                    Diffuse = 0.4f,
                    Specular = 0.5f,
                    Shininess = 40.0f,
                    Radius = 2.0f,
                    Position = ceil_size * 0.5f,
                    Color = new Vector3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble()).GetNormalized()
                });
            }

            // Characters
            Character character = new Character(box_m);
            character.PlaceToScene(ceil_size * 0.5f, physic_world);
            characters.Add(character);
            active_character = character;

            character = new Character(box_m);
            character.PlaceToScene(ceil_size * 0.5f + new Vector3(0, 0, 1), physic_world);
            characters.Add(character);

            // Camera
            MouseCaptured = true;

            Vector3 cameraPosition = new Vector3(0.5f, 2, 0.5f);
            Vector3 cameraTarget = new Vector3(2, 0, 2);

            //camera = new SpectatorCamera(cameraPosition, cameraTarget);
            camera = new ThirdPersonCamera(active_character.Position, Vector3.UnitY, maxOrbitRadius);

            gameFlags.debugWifreframe = false;
        }