Esempio n. 1
0
        void LoadContent()
        {
            fontTexture = device.Game.Content.Load <Texture2D>(@"debugFont.tga");

            shader = Game.Content.Load <Ubershader>(@"spriteBatch.hlsl");

            DisposePSO();

            foreach (SpriteBlend blend in Enum.GetValues(typeof(SpriteBlend)))
            {
                var ps = new PipelineState(Game.GraphicsDevice);

                ps.RasterizerState   = RasterizerState.CullNone;
                ps.DepthStencilState = DepthStencilState.None;

                if (blend == SpriteBlend.Opaque)
                {
                    ps.BlendState = BlendState.Opaque;
                }
                if (blend == SpriteBlend.AlphaBlend)
                {
                    ps.BlendState = BlendState.AlphaBlend;
                }
                if (blend == SpriteBlend.AlphaBlendPreMul)
                {
                    ps.BlendState = BlendState.AlphaBlendPreMul;
                }
                if (blend == SpriteBlend.Additive)
                {
                    ps.BlendState = BlendState.Additive;
                }
                if (blend == SpriteBlend.Screen)
                {
                    ps.BlendState = BlendState.Screen;
                }
                if (blend == SpriteBlend.Multiply)
                {
                    ps.BlendState = BlendState.Multiply;
                }
                if (blend == SpriteBlend.NegMultiply)
                {
                    ps.BlendState = BlendState.NegMultiply;
                }
                if (blend == SpriteBlend.ClearAlpha)
                {
                    ps.BlendState = BlendState.ClearAlpha;
                }

                ps.VertexInputElements = VertexInputElement.FromStructure(typeof(SpriteVertex));

                ps.PixelShader  = shader.GetPixelShader("");
                ps.VertexShader = shader.GetVertexShader("");
                ps.Primitive    = Primitive.TriangleList;

                pipelineStates.Add(blend, ps);
            }
        }
Esempio n. 2
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="scene"></param>
        /// <param name="bakeFunc"></param>
        public SceneDrawer(GraphicsDevice device, Scene scene)
        {
            Game        = device.Game;
            this.device = device;
            this.scene  = scene;

            int meshCount = scene.Meshes.Count;

            ibs = new IndexBuffer[scene.Meshes.Count];
            vbs = new VertexBuffer[scene.Meshes.Count];
            vie = VertexInputElement.FromStructure(typeof(TVertex));

            materials = new TMaterial[scene.Materials.Count];

            //	convert materials :
            for (int i = 0; i < scene.Materials.Count; i++)
            {
                materials[i] = Convert(scene.Materials[i]);
            }

            //	convert meshes to vb in ib :
            for (int i = 0; i < meshCount; i++)
            {
                var mesh = scene.Meshes[i];

                // index buffer :
                ibs[i] = new IndexBuffer(device, mesh.IndexCount);
                ibs[i].SetData(mesh.GetIndices());

                // vertex buffer :
                vbs[i] = new VertexBuffer(device, typeof(TVertex), mesh.VertexCount);
                var vdata = new TVertex[mesh.VertexCount];

                for (int j = 0; j < mesh.VertexCount; j++)
                {
                    vdata[j] = Convert(mesh.Vertices[j]);
                }

                vbs[i].SetData(vdata);
            }

            localMatricies = new Matrix[scene.Nodes.Count];
            worldMatricies = new Matrix[scene.Nodes.Count];
            boneMatricies  = new Matrix[scene.Nodes.Count];

            EvaluateScene();
        }
Esempio n. 3
0
        /// <summary>
        /// Initialization
        /// </summary>
        public override void Initialize()
        {
            base.Initialize();

            var dev = Game.GraphicsDevice;

            effect  = Game.Content.Load <Ubershader>("debugRender.hlsl");
            factory = new StateFactory(effect, typeof(RenderFlags), Primitive.LineList, VertexInputElement.FromStructure(typeof(LineVertex)), BlendState.AlphaBlend, RasterizerState.CullNone);

            constData   = new ConstData();
            constBuffer = new ConstantBuffer(dev, typeof(ConstData));


            //	create vertex buffer :
            vertexBuffer             = new VertexBuffer(dev, typeof(LineVertex), vertexBufferSize, VertexBufferOptions.Dynamic);
            vertexDataAccum.Capacity = vertexBufferSize;
        }