예제 #1
0
        public void TestSpotLightRendererShadowing()
        {
            var game = new DX11Game();

            game.InitDirectX();
            var device  = game.Device;
            var context = device.ImmediateContext;

            var filledGBuffer = new TestFilledGBuffer(game, 800, 600);

            var light = new SpotLightRenderer(game, filledGBuffer.GBuffer);

            light.LightRadius *= 2;

            light.ShadowsEnabled = true;

            var toggle = false;



            game.GameLoopEvent += delegate
            {
                filledGBuffer.DrawUpdatedGBuffer();

                light.UpdateLightCamera();
                game.Camera = light.LightCamera;

                light.UpdateShadowMap(filledGBuffer.Draw);

                game.Camera = game.SpectaterCamera;


                game.SetBackbuffer();

                if (game.Keyboard.IsKeyPressed(Key.C))
                {
                    toggle = !toggle;
                }

                if (toggle)
                {
                    light.SpotDirection = game.SpectaterCamera.CameraDirection;
                    light.LightPosition = game.SpectaterCamera.CameraPosition;
                }

                if (game.Keyboard.IsKeyDown(Key.I))
                {
                    GBufferTest.DrawGBuffer(game, filledGBuffer.GBuffer);
                }
                else
                {
                    light.Draw();
                    game.TextureRenderer.Draw(light.ShadowMapRv, new Vector2(10, 10), new Vector2(300, 300));
                    game.LineManager3D.AddViewFrustum(light.LightCamera.ViewProjection,
                                                      new Color4(1, 0, 0));
                }
            };

            game.Run();
        }
예제 #2
0
        public void TestPhysicsDebugRenderer()
        {
            var game = new DX11Game();

            game.InitDirectX();

            PhysicsEngine engine = new PhysicsEngine();

            engine.Initialize();

            var debugRenderer = new PhysicsDebugRenderer(game, engine.Scene);

            debugRenderer.Initialize();
            InitTestScene(engine.Scene);

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

                debugRenderer.Render();
            };

            game.Run();

            engine.Dispose();
        }
        private DX11Game createGame()
        {
            var ret = new DX11Game();

            ret.InitDirectX();
            return(ret);
        }
예제 #4
0
        public void TestRenderText()
        {
            var game = new DX11Game();

            game.InitDirectX();

            var txt = new TextTexture(game, 100, 100);

            txt.DrawText("The Wizards", new Vector2(0, 0), new Color4(0.3f, 0.3f, 0.3f));

            txt.UpdateTexture();

            game.GameLoopEvent += delegate
            {
                txt.Clear();
                txt.DrawText("The Wizards", new Vector2(0, 0), new Color4(0.3f, 0.3f, 0.3f));

                txt.UpdateTexture();

                game.Device.ImmediateContext.OutputMerger.BlendState =
                    game.HelperStates.AlphaBlend;

                game.TextureRenderer.Draw(txt.GPUTexture.View, new Vector2(0, 0),
                                          new Vector2(100, 100));
            };

            game.Run();
        }
예제 #5
0
        public SurfaceMaterial(DX11Game game, ShaderResourceView diffuseTexture)
        {
            this.game = game;


            textures[0] = diffuseTexture;
            textures[1] = null; //normalTexture;
            textures[2] = null; //specularTexture;


            baseShader = BasicShader.LoadAutoreload(game, ShaderFiles.DCSurface, delegate { }, createShaderMacros());
            baseShader.SetTechnique("DCSurface");
            //baseShader.DiffuseTexture = checkerTexture;

            var desc = new SamplerDescription()
            {
                AddressU          = TextureAddressMode.Wrap,
                AddressV          = TextureAddressMode.Wrap,
                AddressW          = TextureAddressMode.Wrap,
                Filter            = Filter.Anisotropic,
                MaximumAnisotropy = 16
            };

            sampler = SamplerState.FromDescription(game.Device, desc);

            inputLayout = CreateInputLayout();
        }
        public void TestPlayAnimation()
        {
            var controller = new AnimationControllerSkeleton(null);

            Skeleton skeleton;

            TheWizards.Animation.Animation animation;
            CreateTestAnimation(out skeleton, out animation);

            controller.SetAnimation(0, animation);

            var p = new Vector3(4, 5, 4);

            var m1 = Matrix.RotationAxis(Vector3.Normalize(new Vector3(-1, 4, 3)), 4) * Matrix.Translation(p);
            var m2 = Matrix.RotationAxis(Vector3.Normalize(new Vector3(3, 2, 8)), 4) * Matrix.Translation(p);

            var game       = new DX11Game();
            var visualizer = new SkeletonVisualizer();

            game.GameLoopEvent += delegate
            {
                controller.ProgressTime(game.Elapsed);
                controller.UpdateSkeleton();
                skeleton.UpdateAbsoluteMatrices();
                visualizer.VisualizeSkeleton(game, skeleton);
            };

            game.Run();
        }
예제 #7
0
        private GPUTexture3D(DX11Game game, Texture3DDescription desc)
        {
            Texture3D resource = new Texture3D(game.Device, desc);

            Resource = resource;
            View     = new ShaderResourceView(resource.Device, Resource);
        }
        public void VisualizeSkeleton(DX11Game game, Skeleton skeleton, Vector3 offset)
        {
            for (int i = 0; i < skeleton.Joints.Count; i++)
            {
                var joint = skeleton.Joints[i];



                var c = Vector3.TransformCoordinate(Vector3.Zero, joint.AbsoluteMatrix) + offset;
                var x = Vector3.TransformCoordinate(Vector3.UnitX, joint.AbsoluteMatrix) + offset;
                var y = Vector3.TransformCoordinate(Vector3.UnitY, joint.AbsoluteMatrix) + offset;
                var z = Vector3.TransformCoordinate(Vector3.UnitZ, joint.AbsoluteMatrix) + offset;

                var p = c;
                if (joint.Parent != null)
                {
                    p = Vector3.TransformCoordinate(Vector3.Zero, joint.Parent.AbsoluteMatrix) + offset;
                }


                game.LineManager3D.AddLine(p, c, new Color4(Color.White));

                game.LineManager3D.AddLine(c, y, new Color4(Color.Green));
                game.LineManager3D.AddLine(c, z, new Color4(Color.Blue));
                game.LineManager3D.AddLine(c, x, new Color4(Color.Red));
            }
        }
예제 #9
0
        public void TestToneMap()
        {
            var game = new DX11Game();

            game.InitDirectX();
            var device  = game.Device;
            var context = device.ImmediateContext;


            var toneMap = new ToneMapRenderer(game);


            var hdrImage = Texture2D.FromFile(device, HdrImageDDS);

            var hdrImageRV = new ShaderResourceView(device, hdrImage);

            var avgLuminance = 1f;

            game.GameLoopEvent += delegate
            {
                if (game.Keyboard.IsKeyDown(Key.UpArrow))
                {
                    avgLuminance += game.Elapsed;
                }
                if (game.Keyboard.IsKeyDown(Key.DownArrow))
                {
                    avgLuminance -= game.Elapsed;
                }

                toneMap.DrawTonemapped(hdrImageRV, avgLuminance);
            };

            game.Run();
        }
예제 #10
0
        public void TestDirectX11Game()
        {
            var game = new DX11Game();

            game.InitDirectX();
            game.Run();
        }
예제 #11
0
        public void TestRenderManyMeshes()
        {
            var game = new DX11Game();

            game.InitDirectX();

            var renderer = new DeferredRenderer(game);
            var mesh     = UtilityMeshes.CreateBoxColored(new Color4(1, 0, 0), new Vector3(0.1f));

            DeferredMeshElement[] elements = new DeferredMeshElement[100];

            for (int i = 0; i < elements.Length; i++)
            {
                elements[i]             = renderer.CreateMeshElement(mesh);
                elements[i].WorldMatrix =
                    Matrix.Translation((float)Math.Cos((float)i / elements.Length * MathHelper.TwoPi) * 5, 0,
                                       (float)Math.Sin((float)i / elements.Length * MathHelper.TwoPi) * 5);
            }


            game.GameLoopEvent += delegate
            {
                renderer.Draw();
            };

            game.Run();
        }
예제 #12
0
        public void TestCalculateIntersections()
        {
            var game = new DX11Game();

            game.InitDirectX();
            var size   = 64;
            var target = new GPUHermiteCalculator(game);

            var signsTex = target.CreateDensitySignsTexture(size);

            target.WriteHermiteSigns(size, new Vector3(), new Vector3(), "", signsTex);

            var intersectionsTex = target.CreateIntersectionsTexture(size);
            var normals1Tex      = target.CreateNormalsTexture(size);
            var normals2Tex      = target.CreateNormalsTexture(size);
            var normals3Tex      = target.CreateNormalsTexture(size);

            target.WriteHermiteIntersections(size, signsTex, intersectionsTex, normals1Tex, normals2Tex, normals3Tex);


            signsTex.SaveToImageSlices(game, TWDir.Test.CreateSubdirectory("DualContouring.GPU/Signs"));
            intersectionsTex.SaveToImageSlices(game, TWDir.Test.CreateSubdirectory("DualContouring.GPU/Intersections"));
            normals1Tex.SaveToImageSlices(game, TWDir.Test.CreateSubdirectory("DualContouring.GPU/Normals1"));
            normals2Tex.SaveToImageSlices(game, TWDir.Test.CreateSubdirectory("DualContouring.GPU/Normals2"));
            normals3Tex.SaveToImageSlices(game, TWDir.Test.CreateSubdirectory("DualContouring.GPU/Normals3"));
        }
예제 #13
0
        public void TestCombineFinalSSAO()
        {
            //TODO: add a way to show the specular in the alpha channel

            var game = new DX11Game();

            game.InitDirectX();

            var test = new DeferredTest.TestCombineFinalClass(game);

            var ssao = new HorizonSSAORenderer(game, 800, 600);


            game.GameLoopEvent += delegate
            {
                test.DrawUpdatedDeferredRendering();

                ssao.OnFrameRender(test.FilledGBuffer.GBuffer.DepthRV, test.FilledGBuffer.GBuffer.NormalRV);


                game.Device.ImmediateContext.ClearState();
                game.SetBackbuffer();

                test.DrawCombined(ssao.MSsaoBuffer.pSRV);

                //game.TextureRenderer.Draw(ssao.MSsaoBuffer.pSRV, new SlimDX.Vector2(0, 0),
                //                                                   new SlimDX.Vector2(800, 600));
            };

            game.Run();
        }
        public void TestCreateTexture2D()
        {
            var game = new DX11Game();

            game.InitDirectX();

            var tex = new Texture2D(game.Device, new Texture2DDescription
            {
                ArraySize         = 1,
                MipLevels         = 1,
                Format            = Format.B8G8R8A8_UNorm,
                Usage             = ResourceUsage.Dynamic,
                CpuAccessFlags    = CpuAccessFlags.Write,
                Width             = 2,
                Height            = 1,
                SampleDescription = new SampleDescription(1, 0),
                BindFlags         = BindFlags.ShaderResource
            });

            var box = game.Device.ImmediateContext.MapSubresource(tex, 0, 0, MapMode.WriteDiscard,
                                                                  SlimDX.Direct3D11.MapFlags.None);

            box.Data.Write(new byte[] { 0, 0, 255, 255 }, 0, 4);

            game.Device.ImmediateContext.UnmapSubresource(tex, 0);

            var view = new ShaderResourceView(game.Device, tex);

            game.GameLoopEvent += delegate
            {
                game.TextureRenderer.Draw(view, Vector2.Zero, new Vector2(100, 100));
            };
            game.Run();
        }
        private const int ThreadGroupSize = 8; // corresponds to shader

        public GaussianBlurFilter(DX11Game game)
        {
            this.game = game;
            context   = game.Device.ImmediateContext;
            csX       = loadComputeShader(CompiledShaderCache.Current.RootShaderPath + "Filters\\GaussianBlurCS.hlsl", "CSMAINX");
            csY       = loadComputeShader(CompiledShaderCache.Current.RootShaderPath + "Filters\\GaussianBlurCS.hlsl", "CSMAINY");
        }
예제 #16
0
        public void TestDeleteMeshNoMemoryLeak()
        {
            var game = new DX11Game();

            game.InitDirectX();

            var renderer = new DeferredRenderer(game);
            var mesh     = UtilityMeshes.CreateBoxColored(new Color4(1, 0, 0), new Vector3(0.1f));

            DeferredMeshElement[] elements = new DeferredMeshElement[100];

            int i = 0;

            game.GameLoopEvent += delegate
            {
                elements[i]             = renderer.CreateMeshElement(mesh);
                elements[i].WorldMatrix =
                    Matrix.Translation((float)Math.Cos((float)i / elements.Length * MathHelper.TwoPi) * 5, 0,
                                       (float)Math.Sin((float)i / elements.Length * MathHelper.TwoPi) * 5);

                i = (i + 1) % elements.Length;
                //if (elements[i] != null) elements[i].Delete();

                renderer.Draw();
            };

            game.Run();
        }
        public void TestRenderUsingGDI()
        {
            var game = new DX11Game();

            game.InitDirectX();

            // Create the DirectX11 texture2D.  This texture will be shared with the DirectX10
            // device.  The DirectX10 device will be used to render text onto this texture.  DirectX11
            // will then draw this texture (blended) onto the screen.
            // The KeyedMutex flag is required in order to share this resource.
            SlimDX.Direct3D11.Texture2D textureD3D11 = new Texture2D(game.Device, new Texture2DDescription
            {
                Width             = 100,
                Height            = 100,
                MipLevels         = 1,
                ArraySize         = 1,
                Format            = Format.B8G8R8A8_UNorm,
                SampleDescription = new SampleDescription(1, 0),
                Usage             = ResourceUsage.Default,
                BindFlags         = BindFlags.RenderTarget | BindFlags.ShaderResource,
                CpuAccessFlags    = CpuAccessFlags.None,
                OptionFlags       = ResourceOptionFlags.KeyedMutex
            });

            var surface  = textureD3D11.AsSurface();
            var surface1 = Surface1.FromPointer(surface.ComPointer);



            game.GameLoopEvent += delegate
            {
            };
        }
        public DirectionalLightRenderer(DX11Game game, GBuffer gBuffer)
        {
            this.game    = game;
            this.gBuffer = gBuffer;
            var device = game.Device;

            context = device.ImmediateContext;

            shadowsShader = BasicShader.LoadAutoreload(game,
                                                       new System.IO.FileInfo(
                                                           CompiledShaderCache.Current.RootShaderPath + "Deferred\\DirectionalLight.fx"));

            shadowsShader.SetTechnique("Technique0");

            noShadowsShader = BasicShader.LoadAutoreload(game,
                                                         new System.IO.FileInfo(
                                                             CompiledShaderCache.Current.RootShaderPath + "Deferred\\DirectionalLight.fx"), null, new[] { new ShaderMacro("DISABLE_SHADOWS") });

            noShadowsShader.SetTechnique("Technique0");

            quad = new FullScreenQuad(device);

            layout = FullScreenQuad.CreateInputLayout(device, shadowsShader.GetCurrentPass(0));

            LightDirection = Vector3.Normalize(new Vector3(1, 2, 1));
            Color          = new Vector3(1, 1, 0.9f);

            CSMRenderer = new CSM.CSMRenderer(game);
        }
예제 #19
0
        public void TestCullerPlaceInTree()
        {
            var           game   = new DX11Game();
            Vector3       radius = new Vector3(100, 1000, 100);
            FrustumCuller culler = new FrustumCuller(new BoundingBox(-radius, radius), 5);


            var visualizer = new QuadTreeVisualizer();

            List <TestCullObject> cullObjects = new List <TestCullObject>();


            TestCullObject obj;

            obj = new TestCullObject(new Vector3(5, 2, 5), 2);
            cullObjects.Add(obj);

            obj = new TestCullObject(new Vector3(-20, 2, -20), 15);
            cullObjects.Add(obj);

            obj = new TestCullObject(new Vector3(100, 2, -20), 4);
            cullObjects.Add(obj);

            obj = new TestCullObject(new Vector3(-50, 9, 24), 20);
            cullObjects.Add(obj);

            for (int i = 0; i < cullObjects.Count; i++)
            {
                culler.AddCullable(cullObjects[i]);
            }

            game.GameLoopEvent +=
                delegate
            {
                for (int i = 0; i < cullObjects.Count; i++)
                {
                    game.LineManager3D.AddBox(cullObjects[i].BoundingBox, Color.Red.dx());
                }
                visualizer.RenderNodeGroundBoundig(game, culler.RootNode,
                                                   delegate(FrustumCuller.CullNode node, out Color4 col)
                {
                    col = Color.Green.dx();

                    return(node.Cullables.Count == 0);
                });

                visualizer.RenderNodeGroundBoundig(game, culler.RootNode,
                                                   delegate(FrustumCuller.CullNode node, out Color4 col)
                {
                    col = Color.Orange.dx();

                    return(node.Cullables.Count > 0);
                });
            };



            game.Run();
        }
예제 #20
0
        public DeferredMeshesRenderer(DX11Game game, GBuffer gBuffer, TexturePool texturePool)
        {
            this.game = game;
            this.pool = texturePool;
            ctx       = game.Device.ImmediateContext;

            initialize(texturePool);
        }
        public static DeferredMeshesRenderer InitDefaultMeshRenderer(DX11Game game, GBuffer gBuffer)
        {
            var texturePool = new TexturePool(game);

            var renderer = new DeferredMeshesRenderer(game, gBuffer, texturePool);

            return(renderer);
        }
예제 #22
0
        public void BasicBalTest()
        {
            Emitter  emit;
            DX11Game game = new DX11Game();

            game.InitDirectX();


            var texPool                 = new TexturePool(game);
            var testTexture             = GetTestTexture();
            BallParticleCreater creater = new BallParticleCreater();
            //SimpleParticleCreater creater = new SimpleParticleCreater();
            EmitterParameters param = new EmitterParameters();

            param.texture         = testTexture;
            param.particleCreater = creater;
            emit = new Emitter(texPool, game, param, 800, 600);//note: again screen size
            //game.Wpf.CreateClassForm(param);
            Seeder seed  = new Seeder(54);
            var    curve = Curve3D.CreateTestCurve();



            emit.Initialize();
            emit.InitializeRender();


            emit.CreateRenderData();
            emit.SetRenderData();
            emit.SetPosition(Vector3.Zero);
            float dist = 0;

            game.GameLoopEvent += delegate
            {
                // emit.setShader();
                emit.Update();
                if (dist > 100)
                {
                    dist = 0;
                }
                else
                {
                    dist += game.Elapsed * 1;
                }
                //emit.SetPosition(new Vector3(dist, 0, 0));
                Temp(dist, emit, curve);

                //Draw part

                //game.GraphicsDevice.Clear(Color.Black);
                game.Device.ImmediateContext.Rasterizer.State = game.HelperStates.RasterizerShowAll;
                emit.Render(game.SpectaterCamera.ViewProjection, game.SpectaterCamera.ViewInverse);
            };



            game.Run();
        }
예제 #23
0
        public void TestBasicShaderIncludeRoot()
        {
            BasicShader    shader = null;
            FullScreenQuad quad   = null;
            var            game   = new DX11Game();

            game.InitDirectX();

            var fi      = new FileInfo("../../Common.Core/Shaders/TestAutoReload.fx");
            var include = new FileInfo("../../Common.Core/Shaders/IncludeTest.fx");


            using (var fs = new StreamWriter(fi.OpenWrite()))
            {
                fs.WriteLine("float4 Color = float4(1,0,0,1);");
            }
            using (var fs = new StreamWriter(include.OpenWrite()))
            {
                fs.WriteLine("float4 Color2 = float4(0,0,0,1);");
            }

            shader = BasicShader.LoadAutoreload(game, fi);
            shader.SetTechnique("TestAutoReload");
            quad = new FullScreenQuad(game.Device);



            var inputLayout = FullScreenQuad.CreateInputLayout(game.Device, shader.GetCurrentPass(0));
            var time        = 0f;

            game.GameLoopEvent += delegate
            {
                shader.Apply();
                quad.Draw(inputLayout);

                if (time > 2 && time < 3)
                {
                    using (var fs = new StreamWriter(fi.OpenWrite()))
                    {
                        fs.WriteLine("float4 Color = float4(1,1,0,1);");
                        time = 5;
                    }
                }


                if (time > 6 && time < 7)
                {
                    using (var fs = new StreamWriter(include.OpenWrite()))
                    {
                        fs.WriteLine("float4 Color2 = float4(-1,0,0,1);");
                        time = 10;
                    }
                }

                time += game.Elapsed;
            };
            game.Run();
        }
        private static void saveTest3DTexture(DX11Game game, int size, string name, byte[] data)
        {
            var texture3D = GPUTexture3D.CreateCPUWritable(game, size, size, size, Format.R8G8B8A8_UNorm);

            texture3D.SetTextureRawData(data);
            Texture3D.SaveTextureToFile(game.Device.ImmediateContext, texture3D.Resource, ImageFileFormat.Dds,
                                        TWDir.Test.CreateSubdirectory("GPU").CreateFile(name + ".dds").FullName);
            texture3D.SaveToImageSlices(game, TWDir.Test.CreateSubdirectory("GPU").CreateSubdirectory(name));
        }
예제 #25
0
 public static void DrawGBuffer(DX11Game game, GBuffer buffer)
 {
     game.TextureRenderer.Draw(buffer.DiffuseRV, new Vector2(0, 0),
                               new Vector2(400, 300));
     game.TextureRenderer.Draw(buffer.NormalRV, new Vector2(400, 00),
                               new Vector2(400, 300));
     game.TextureRenderer.Draw(buffer.DepthRV, new Vector2(00, 300),
                               new Vector2(400, 300));
 }
예제 #26
0
        /// <summary>
        /// Creates the renderer
        /// </summary>
        public CSMRenderer(DX11Game game)
        {
            this.game = game;
            var device = game.Device;

            context = device.ImmediateContext;

            // Load the effect we need
            shadowMapShader = BasicShader.LoadAutoreload(game, new FileInfo(CompiledShaderCache.Current.RootShaderPath + @"CSM\CSM.fx"));

            // Create the shadow map, using a 32-bit floating-point surface format
            shadowMap = new Texture2D(device, new Texture2DDescription
            {
                Width             = ShadowMapSize * NumSplits,
                Height            = ShadowMapSize,
                MipLevels         = 1,
                ArraySize         = 1,
                BindFlags         = BindFlags.DepthStencil | BindFlags.ShaderResource,
                Format            = global::SlimDX.DXGI.Format.R32_Typeless,
                SampleDescription = new global::SlimDX.DXGI.SampleDescription(1, 0)
            });

            shadowMapDsv = new DepthStencilView(device, shadowMap, new DepthStencilViewDescription
            {
                ArraySize = 1,
                Dimension = DepthStencilViewDimension.Texture2D,
                Flags     = DepthStencilViewFlags.None,
                Format    = global::SlimDX.DXGI.Format.D32_Float,
                MipSlice  = 0
            });
            ShadowMapRV = new ShaderResourceView(device, shadowMap, new ShaderResourceViewDescription
            {
                ArraySize       = 1,
                Dimension       = ShaderResourceViewDimension.Texture2D,
                MipLevels       = 1,
                MostDetailedMip = 0,
                Format          = global::SlimDX.DXGI.Format.R32_Float
            });


            // Create the full-screen quad
            fullScreenQuad = new FullScreenQuad(device);



            // We'll keep an array of EffectTechniques that will let us map a
            // ShadowFilteringType to a technique for calculating shadow occlusion
            shadowOcclusionTechniques[0] = "CreateShadowTerm2x2PCF";
            shadowOcclusionTechniques[1] = "CreateShadowTerm3x3PCF";
            shadowOcclusionTechniques[2] = "CreateShadowTerm5x5PCF";
            shadowOcclusionTechniques[3] = "CreateShadowTerm7x7PCF";

            shadowMapShader.SetTechnique(shadowOcclusionTechniques[0]);

            layout = FullScreenQuad.CreateInputLayout(device, shadowMapShader.GetCurrentPass(0));
        }
예제 #27
0
        public static GPUTexture3D CreateCPUReadable(DX11Game game, int width, int height, int depth, Format format)
        {
            var desc = getBaseDesc(width, height, depth, format);

            desc.Usage          = ResourceUsage.Staging;
            desc.CpuAccessFlags = CpuAccessFlags.Read;
            desc.BindFlags      = BindFlags.None;

            return(new GPUTexture3D(new Texture3D(game.Device, desc), null, null));
        }
        public MeshRenderDataFactory(DX11Game game, BasicShader baseShader, TexturePool texturePool)
        {
            this.game        = game;
            this.baseShader  = baseShader;
            this.texturePool = texturePool;

            checkerTexture = Texture2D.FromFile(game.Device, TWDir.GameData.CreateSubdirectory("Core").FullName + "\\checker.png");

            checkerTextureRV = new ShaderResourceView(game.Device, checkerTexture);
        }
예제 #29
0
        public static GPUTexture3D CreateDefault(DX11Game game, int width, int height, int depth, Format format)
        {
            var desc = getBaseDesc(width, height, depth, format);

            desc.Usage          = ResourceUsage.Default;
            desc.CpuAccessFlags = CpuAccessFlags.None;
            desc.BindFlags      = BindFlags.ShaderResource;

            return(new GPUTexture3D(game, desc));
        }
예제 #30
0
 private void drawASFJoint(DX11Game game, ASFJoint joint, Vector3 pos)
 {
     for (int i = 0; i < joint.children.Count; i++)
     {
         var child = joint.children[i];
         var end   = pos + child.direction * child.length;
         game.LineManager3D.AddLine(pos, end, Color.White);
         drawASFJoint(game, child, end);
     }
 }