public void AddBox(Vector3 min, Vector3 max, MeshMaterial material)
        {
            if (!parts.ContainsKey(material))
            {
                throw new InvalidOperationException("Material not created by the meshbuilder");
            }
            TangentVertex[] vertices;
            short[]         indices;
            BoxMesh.CreateUnitBoxVerticesAndIndices(out vertices, out indices);

            var data = parts[material];

            for (int i = 0; i < indices.Length; i++)
            {
                var pos = vertices[indices[i]].pos;

                pos.X = pos.X * (max.X - min.X);
                pos.Y = pos.Y * (max.Y - min.Y);
                pos.Z = pos.Z * (max.Z - min.Z);

                data.Positions.Add(pos + min.xna());
                data.Normals.Add(vertices[indices[i]].normal);
                data.Texcoords.Add(vertices[indices[i]].uv);
            }
        }
示例#2
0
        private void drawBox()
        {
            TangentVertex[] vertices;
            short[]         sIndices;

            BoxMesh.CreateUnitBoxVerticesAndIndices(out vertices, out sIndices);
            int[] indices = new int[sIndices.Length];
            for (int i = 0; i < sIndices.Length; i++)
            {
                indices[i] = sIndices[i];
            }


            GraphicsDevice.VertexDeclaration = tangentVertexDeclaration;


            renderGBufferShader.SetParameter("World", Matrix.Identity);
            renderGBufferShader.SetParameter("View", game.Camera.View);
            renderGBufferShader.SetParameter("Projection", game.Camera.Projection);
            renderGBufferShader.SetParameter("Texture", boxTexture);

            renderGBufferShader.RenderMultipass(delegate
            {
                GraphicsDevice.DrawUserIndexedPrimitives(PrimitiveType.TriangleList, vertices, 0, vertices.Length, sIndices,
                                                         0, sIndices.Length / 3);
            });
        }
        public void TestTriangleMesh()
        {
            XNAGame game = new XNAGame();

            game.SpectaterCamera.CameraPosition = new Vector3(0, 0, -40);
            PhysicsEngine engine = new PhysicsEngine();

            //game.AddXNAObject(engine);



            game.InitializeEvent += delegate
            {
                engine.Initialize();

                PhysicsDebugRendererXNA debugRenderer = new PhysicsDebugRendererXNA(game, engine.Scene);

                game.AddXNAObject(debugRenderer);

                TangentVertex[] vertices;
                short[]         indices;
                BoxMesh.CreateUnitBoxVerticesAndIndices(out vertices, out indices);

                var positions = new Vector3[vertices.Length];
                for (int i = 0; i < positions.Length; i++)
                {
                    positions[i] = vertices[i].pos;
                }

                int[] intIndices = new int[indices.Length];
                for (int i = 0; i < intIndices.Length; i++)
                {
                    intIndices[i] = indices[i];
                }

                var triangleMesh = CreateTriangleMesh(positions, intIndices, engine.Scene);

                var triangleMeshShapeDesc = new TriangleMeshShapeDescription();
                triangleMeshShapeDesc.TriangleMesh = triangleMesh;

                var actorDesc = new ActorDescription(triangleMeshShapeDesc);

                var actor = engine.Scene.CreateActor(actorDesc);
            };

            game.UpdateEvent += delegate
            {
                engine.Update(game.Elapsed);
            };

            game.Run();

            engine.Dispose();
        }
        public void TestDefaultRendererRenderModel()
        {
            //TODO: maybe detach this from the defaultrenderer?


            DefaultRenderer renderer = new DefaultRenderer();


            TangentVertex[] vertices;
            short[]         indices;
            var             mat = new DefaultModelMaterialTextured();

            BoxMesh.CreateUnitBoxVerticesAndIndices(out vertices, out indices);



            var renderable = renderer.CreateModelRenderable(vertices, indices, mat);

            var el = renderer.CreateRenderElement(renderable);


            XNAGame game = new XNAGame();

            game.InitializeEvent += delegate
            {
                //TODO: make the renderer manage textures!!!

                using (var fs = new FileStream(TestFiles.WoodPlanksBareJPG, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    mat.DiffuseTexture = Texture2D.FromFile(game.GraphicsDevice, fs);
                }
            };

            game.AddXNAObject(renderer);

            game.Run();
        }
示例#5
0
        private void drawBoxShadowMap()
        {
            TangentVertex[] vertices;
            short[]         sIndices;

            BoxMesh.CreateUnitBoxVerticesAndIndices(out vertices, out sIndices);
            int[] indices = new int[sIndices.Length];
            for (int i = 0; i < sIndices.Length; i++)
            {
                indices[i] = sIndices[i];
            }


            GraphicsDevice.VertexDeclaration = tangentVertexDeclaration;


            shadowMapShader.SetParameter("g_matWorld", Matrix.Identity);

            shadowMapShader.RenderMultipass(delegate
            {
                GraphicsDevice.DrawUserIndexedPrimitives(PrimitiveType.TriangleList, vertices, 0, vertices.Length, sIndices,
                                                         0, sIndices.Length / 3);
            });
        }