예제 #1
0
        static void Main()
        {
            if (!SharpDevice.IsDirectX11Supported())
            {
                System.Windows.Forms.MessageBox.Show("DirectX11 Not Supported");
                return;
            }

            //render form
            RenderForm form = new RenderForm();
            form.Text = "Tutorial 7: Loading Obj File";
            //frame rate counter
            SharpFPS fpsCounter = new SharpFPS();


            using (SharpDevice device = new SharpDevice(form))
            {
                //load font
                SharpBatch font = new SharpBatch(device, "textfont.dds");

                //load model from wavefront obj file
                SharpMesh mesh = SharpMesh.CreateFromObj(device, "../../../Models/car/car.obj");

                //init shader
                SharpShader shader = new SharpShader(device, "../../HLSL.txt",
                    new SharpShaderDescription() { VertexShaderFunction = "VS", PixelShaderFunction = "PS" },
                    new InputElement[] {  
                        new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0),
                        new InputElement("NORMAL", 0, Format.R32G32B32_Float, 12, 0),
                        new InputElement("TEXCOORD", 0, Format.R32G32_Float, 24, 0)
                    });

                //init constant buffer
                Buffer11 buffer = shader.CreateBuffer<Data>();

                //init frame counter
                fpsCounter.Reset();

                //main loop
                RenderLoop.Run(form, () =>
                {
                    //Resizing
                    if (device.MustResize)
                    {
                        device.Resize();
                        font.Resize();
                    }

                    //apply states
                    device.UpdateAllStates();

                    //clear color
                    device.Clear(Color.CornflowerBlue);

                    //apply shader
                    shader.Apply();

                    //set transformation matrix
                    float ratio = (float)form.ClientRectangle.Width / (float)form.ClientRectangle.Height;
                    Matrix projection = Matrix.PerspectiveFovLH(3.14F / 3.0F, ratio, 1F, 1000.0F);
                    Matrix view = Matrix.LookAtLH(new Vector3(0, 10, -30), new Vector3(), Vector3.UnitY);
                    Matrix world = Matrix.RotationY(Environment.TickCount / 1000.0F);

                    //light direction
                    Vector3 lightDirection = new Vector3(0.5f, 0, -1);
                    lightDirection.Normalize();


                    Data sceneInformation = new Data()
                    {
                        world = world,
                        worldViewProjection = world * view * projection,
                        lightDirection = new Vector4(lightDirection, 1)
                    };

                    //write data inside constant buffer
                    device.UpdateData<Data>(buffer, sceneInformation);

                    //apply constant buffer to shader
                    device.DeviceContext.VertexShader.SetConstantBuffer(0, buffer);
                    device.DeviceContext.PixelShader.SetConstantBuffer(0, buffer);

                    //draw mesh
                    mesh.Begin();
                    for (int i = 0; i < mesh.SubSets.Count; i++)
                    {
                        device.DeviceContext.PixelShader.SetShaderResource(0, mesh.SubSets[i].DiffuseMap);
                        mesh.Draw(i);
                    }


                    //begin drawing text
                    font.Begin();

                    //draw string
                    fpsCounter.Update();
                    font.DrawString("FPS: " + fpsCounter.FPS, 0, 0, Color.White);

                    //flush text to view
                    font.End();
                    //present
                    device.Present();

                });

                //release resource
                font.Dispose();
                mesh.Dispose();
                buffer.Dispose();
            }
        }
예제 #2
0
        static void Main()
        {
            if (!SharpDevice.IsDirectX11Supported())
            {
                System.Windows.Forms.MessageBox.Show("DirectX11 Not Supported");
                return;
            }

            //render form
            RenderForm form = new RenderForm();

            form.Text = "Tutorial 15: Toon Shading With Multiple Render Target";
            //frame rate counter
            SharpFPS fpsCounter = new SharpFPS();


            using (SharpDevice device = new SharpDevice(form))
            {
                //load font
                SharpBatch font = new SharpBatch(device, "textfont.dds");

                //load model from wavefront obj file
                SharpMesh dogMesh = SharpMesh.CreateFromObj(device, "../../../Models/dog/dog.obj");

                //quad
                SharpMesh quad = SharpMesh.CreateQuad(device);

                //init shader
                SharpShader firstPass = new SharpShader(device, "../../HLSL.txt",
                                                        new SharpShaderDescription()
                {
                    VertexShaderFunction = "VS", PixelShaderFunction = "PS"
                },
                                                        new InputElement[] {
                    new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0),
                    new InputElement("NORMAL", 0, Format.R32G32B32_Float, 12, 0),
                    new InputElement("TEXCOORD", 0, Format.R32G32_Float, 24, 0)
                });

                //second pass
                SharpShader secondPass = new SharpShader(device, "../../HLSL.txt",
                                                         new SharpShaderDescription()
                {
                    VertexShaderFunction = "VS_QUAD", PixelShaderFunction = "PS_QUAD"
                },
                                                         new InputElement[] {
                    new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0),
                });

                //render target
                SharpRenderTarget target = new SharpRenderTarget(device, form.ClientSize.Width, form.ClientSize.Height, Format.R8G8B8A8_UNorm);
                //render target
                SharpRenderTarget target2 = new SharpRenderTarget(device, form.ClientSize.Width, form.ClientSize.Height, Format.R8G8B8A8_UNorm);


                //toon texture
                ShaderResourceView bandTexture = ShaderResourceView.FromFile(device.Device, "../../../Models/band.bmp");

                //init constant buffer
                Buffer11 toonConstantBuffer = firstPass.CreateBuffer <ToonData>();

                //init frame counter
                fpsCounter.Reset();


                //main loop
                RenderLoop.Run(form, () =>
                {
                    //Resizing
                    if (device.MustResize)
                    {
                        device.Resize();

                        //render target
                        target.Dispose();
                        target = new SharpRenderTarget(device, form.ClientSize.Width, form.ClientSize.Height, Format.R8G8B8A8_UNorm);


                        //render target
                        target2.Dispose();
                        target2 = new SharpRenderTarget(device, form.ClientSize.Width, form.ClientSize.Height, Format.R8G8B8A8_UNorm);


                        font.Resize();
                    }

                    //apply states
                    device.UpdateAllStates();


                    //BEGIN RENDERING TO TEXTURE (MULTIPLE)

                    device.ApplyMultipleRenderTarget(target, target2);


                    target.Clear(Color.CornflowerBlue);
                    target2.Clear(Color.Black);


                    //set transformation matrix
                    float ratio       = (float)form.ClientRectangle.Width / (float)form.ClientRectangle.Height;
                    Matrix projection = Matrix.PerspectiveFovLH(3.14F / 3.0F, ratio, 1F, 1000.0F);

                    Vector3 from = new Vector3(0, 70, -150);
                    Vector3 to   = new Vector3(0, 50, 0);

                    Matrix view  = Matrix.LookAtLH(from, to, Vector3.UnitY);
                    Matrix world = Matrix.RotationY(Environment.TickCount / 2000.0F);

                    //light direction
                    Vector3 lightDirection = new Vector3(0.5f, 0, -1);
                    lightDirection.Normalize();


                    ToonData sceneInformation = new ToonData()
                    {
                        world = world,
                        worldViewProjection = world * view * projection,
                        lightDirection      = new Vector4(lightDirection, 1),
                        cameraPosition      = new Vector4(from, 1)
                    };


                    //apply shader
                    firstPass.Apply();

                    //set toon band texture
                    device.DeviceContext.PixelShader.SetShaderResource(1, bandTexture);

                    //write data inside constant buffer
                    device.UpdateData <ToonData>(toonConstantBuffer, sceneInformation);

                    //apply constant buffer to shader
                    device.DeviceContext.VertexShader.SetConstantBuffer(0, toonConstantBuffer);
                    device.DeviceContext.PixelShader.SetConstantBuffer(0, toonConstantBuffer);

                    //draw mesh
                    dogMesh.Begin();
                    for (int i = 0; i < dogMesh.SubSets.Count; i++)
                    {
                        device.DeviceContext.PixelShader.SetShaderResource(0, dogMesh.SubSets[i].DiffuseMap);
                        dogMesh.Draw(i);
                    }



                    //RENDERING TO DEVICE

                    //Set original targets
                    device.SetDefaultTargers();

                    //apply shader
                    secondPass.Apply();


                    //clear color
                    device.Clear(Color.Black);

                    secondPass.Apply();

                    //set target
                    device.DeviceContext.PixelShader.SetShaderResource(0, target.Resource);
                    device.DeviceContext.PixelShader.SetShaderResource(1, target2.Resource);

                    quad.Draw();


                    //begin drawing text
                    font.Begin();

                    //draw string
                    fpsCounter.Update();
                    font.DrawString("FPS: " + fpsCounter.FPS, 0, 0, Color.White);

                    //flush text to view
                    font.End();
                    //present
                    device.Present();
                });


                //release resource
                font.Dispose();
                dogMesh.Dispose();
                quad.Dispose();
                toonConstantBuffer.Dispose();
                firstPass.Dispose();
                secondPass.Dispose();
                bandTexture.Dispose();
                target.Dispose();
                target2.Dispose();
            }
        }
예제 #3
0
        static void Main()
        {
            //SharpDX.RawInput.Device.RegisterDevice(UsagePage.Generic, UsageId.GenericMouse, DeviceFlags.None);
            //SharpDX.RawInput.Device.MouseInput += (sender, args) => textBox.Invoke(new UpdateTextCallback(UpdateMouseText), args);

            SharpDX.RawInput.Device.RegisterDevice(UsagePage.Generic, UsageId.GenericKeyboard, DeviceFlags.None);
            SharpDX.RawInput.Device.KeyboardInput += (sender, args) => UpdateKeyboardText(args);

            if (!SharpDevice.IsDirectX11Supported())
            {
                System.Windows.Forms.MessageBox.Show("DirectX11 Not Supported");
                return;
            }

            //Init textured cube
            int[] indices = new int[]
            {
                0, 1, 2, 0, 2, 3,
                4, 6, 5, 4, 7, 6,
                8, 9, 10, 8, 10, 11,
                12, 14, 13, 12, 15, 14,
                16, 18, 17, 16, 19, 18,
                20, 21, 22, 20, 22, 23
            };

            TexturedVertex[] vertices = new[]
            {
                ////TOP
                new TexturedVertex(new Vector3(-5, 5, 5), new Vector2(1, 1)),
                new TexturedVertex(new Vector3(5, 5, 5), new Vector2(0, 1)),
                new TexturedVertex(new Vector3(5, 5, -5), new Vector2(0, 0)),
                new TexturedVertex(new Vector3(-5, 5, -5), new Vector2(1, 0)),
                //BOTTOM
                new TexturedVertex(new Vector3(-5, -5, 5), new Vector2(1, 1)),
                new TexturedVertex(new Vector3(5, -5, 5), new Vector2(0, 1)),
                new TexturedVertex(new Vector3(5, -5, -5), new Vector2(0, 0)),
                new TexturedVertex(new Vector3(-5, -5, -5), new Vector2(1, 0)),
                //LEFT
                new TexturedVertex(new Vector3(-5, -5, 5), new Vector2(0, 1)),
                new TexturedVertex(new Vector3(-5, 5, 5), new Vector2(0, 0)),
                new TexturedVertex(new Vector3(-5, 5, -5), new Vector2(1, 0)),
                new TexturedVertex(new Vector3(-5, -5, -5), new Vector2(1, 1)),
                //RIGHT
                new TexturedVertex(new Vector3(5, -5, 5), new Vector2(1, 1)),
                new TexturedVertex(new Vector3(5, 5, 5), new Vector2(1, 0)),
                new TexturedVertex(new Vector3(5, 5, -5), new Vector2(0, 0)),
                new TexturedVertex(new Vector3(5, -5, -5), new Vector2(0, 1)),
                //FRONT
                new TexturedVertex(new Vector3(-5, 5, 5), new Vector2(1, 0)),
                new TexturedVertex(new Vector3(5, 5, 5), new Vector2(0, 0)),
                new TexturedVertex(new Vector3(5, -5, 5), new Vector2(0, 1)),
                new TexturedVertex(new Vector3(-5, -5, 5), new Vector2(1, 1)),
                //BACK
                new TexturedVertex(new Vector3(-5, 5, -5), new Vector2(0, 0)),
                new TexturedVertex(new Vector3(5, 5, -5), new Vector2(1, 0)),
                new TexturedVertex(new Vector3(5, -5, -5), new Vector2(1, 1)),
                new TexturedVertex(new Vector3(-5, -5, -5), new Vector2(0, 1))
            };



            //render form
            RenderForm form = new RenderForm();

            form.Text = "SGE Demo";
            SharpFPS fpsCounter = new SharpFPS();


            using (SharpDevice device = new SharpDevice(form))
            {
                //Init Mesh
                //SharpMesh mesh = SharpMesh.Create<TexturedVertex>(device, vertices, indices);

                //Init shader from file
                //SharpShader shader = new SharpShader(device, "../../HLSL.txt",
                //    new SharpShaderDescription() { VertexShaderFunction = "VS", PixelShaderFunction = "PS" },
                //    new InputElement[] {
                //        new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0),
                //        new InputElement("TEXCOORD", 0, Format.R32G32_Float, 12, 0)
                //    });

                SharpShader shader = new SharpShader(device, "../../HLSL.txt",
                                                     new SharpShaderDescription()
                {
                    VertexShaderFunction = "VS", PixelShaderFunction = "PS"
                },
                                                     new InputElement[] {
                    new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0),
                    new InputElement("NORMAL", 0, Format.R32G32B32_Float, 12, 0),
                    new InputElement("TEXCOORD", 0, Format.R32G32_Float, 24, 0)
                });

                //Create constant buffer
                Buffer11 buffer = shader.CreateBuffer <Data>();
                //Create texture from file
                ShaderResourceView texture = device.LoadTextureFromFile("../../texture2.bmp");

                fpsCounter.Reset();


                var gm = new GameManager();
                gm.gameObjects.Add(new GameObject()
                {
                    mesh = SharpMesh.CreateFromObj(device, "../../Models/sword/sword.obj")
                });

                gm.gameObjects[0].update = (delta)
                                           =>
                {
                    gm.gameObjects[0].position  = Vector3.Up * (-8 + (float)Math.Sin((float)Environment.TickCount / 500));
                    gm.gameObjects[0].rotation *= Quaternion.RotationYawPitchRoll(0.0002f, 0, 0);
                    return(0);
                };
                gm.gameObjects[0].scale *= 4;

                gm.gameObjects.Add(new GameObject()
                {
                    mesh = SharpMesh.CreateFromObj(device, "../../Models/Sphere/sphere2.obj")
                });

                gm.gameObjects[1].update = (delta)
                                           =>
                {
                    gm.gameObjects[1].position += Vector3.Up * -0.0001f;
                    gm.gameObjects[1].rotation *= Quaternion.RotationYawPitchRoll(-0.0001f, 0, 0);
                    return(0);
                };
                gm.gameObjects[1].scale *= 1;


                //var go = new GameObject();

                //main loop
                RenderLoop.Run(form, () =>
                {
                    //Resizing
                    if (device.MustResize)
                    {
                        device.Resize();
                    }

                    //apply states
                    device.UpdateAllStates();

                    //clear color
                    device.Clear(Color.CornflowerBlue);


                    //apply shader
                    shader.Apply();

                    //apply constant buffer to shader
                    //device.DeviceContext.VertexShader.SetConstantBuffer(0, buffer);

                    //set texture
                    //device.DeviceContext.PixelShader.SetShaderResource(0, texture);

                    //set transformation matrix
                    float ratio       = (float)form.ClientRectangle.Width / (float)form.ClientRectangle.Height;
                    Matrix projection = Matrix.PerspectiveFovLH(3.14F / 3.0F, ratio, 0.1F, 1000.0F);
                    Matrix view       = Matrix.LookAtLH(new Vector3(0, 10, -30), new Vector3(), Vector3.UnitY);
                    Matrix world      = Matrix.RotationY(Environment.TickCount / 1000.0F);
                    Matrix WVP        = world * view * projection;
                    //device.UpdateData<Matrix>(buffer, WVP);

                    //draw mesh
                    //mesh.Draw();

                    //light direction
                    Vector3 lightDirection = new Vector3(0.5f, 0, -1);
                    lightDirection.Normalize();


                    Data sceneInformation = new Data()
                    {
                        world = world,
                        worldViewProjection = world * view * projection,
                        lightDirection      = new Vector4(lightDirection, 1)
                    };

                    //write data inside constant buffer
                    device.UpdateData <Data>(buffer, sceneInformation);

                    //apply constant buffer to shader



                    //world = Matrix.Transformation(Vector3.Zero, Quaternion.Identity, new Vector3(1.2f, 1.2f, 1.2f), Vector3.Zero, Quaternion.Identity, new Vector3(0, -5, 0));
                    //WVP = world * view * projection;

                    for (int i = 0; i < gm.gameObjects.Count; i++)
                    {
                        gm.gameObjects[i].update(1.0f / fpsCounter.FPS);
                        WVP = gm.gameObjects[i].transform * view * projection;
                        //device.UpdateData<Matrix>(buffer, WVP);

                        sceneInformation.world = gm.gameObjects[i].transform;
                        WVP = sceneInformation.world * view * projection;
                        sceneInformation.worldViewProjection = WVP;
                        device.UpdateData <Data>(buffer, sceneInformation);

                        device.DeviceContext.VertexShader.SetConstantBuffer(0, buffer);
                        device.DeviceContext.PixelShader.SetConstantBuffer(0, buffer);

                        //device.DeviceContext.PixelShader.SetShaderResource(0, gm.gameObjects[i].mesh.SubSets[i].DiffuseMap);
                        //gm.gameObjects[i].mesh.Draw();
                        gm.gameObjects[i].mesh.Begin();
                        for (int j = 0; j < gm.gameObjects[i].mesh.SubSets.Count; j++)
                        {
                            device.DeviceContext.PixelShader.SetShaderResource(0, gm.gameObjects[i].mesh.SubSets[j].DiffuseMap);
                            gm.gameObjects[i].mesh.Draw(j);
                        }
                    }

                    //go.position = go.position + Vector3.Up * 0.001f;

                    //go.rotation = go.rotation * Quaternion.RotationYawPitchRoll(0.0001f, 0, 0);

                    //WVP = go.transform * view * projection;

                    //device.UpdateData<Matrix>(buffer, WVP);

                    //mesh.Draw();



                    //begin drawing text
                    device.Font.Begin();

                    //draw string
                    fpsCounter.Update();
                    device.Font.DrawString("FPS: " + fpsCounter.FPS, 0, 0);
                    device.Font.DrawString(text, 0, 20);

                    //flush text to view
                    device.Font.End();
                    //present
                    device.Present();
                });

                //release resource
                //mesh.Dispose();
                foreach (GameObject go in gm.gameObjects)
                {
                    go.mesh.Dispose();
                }

                buffer.Dispose();
                texture.Dispose();
            }
        }
예제 #4
0
        static void Main()
        {
            if (!SharpDevice.IsDirectX11Supported())
            {
                System.Windows.Forms.MessageBox.Show("DirectX11 Not Supported");
                return;
            }

            //render form
            RenderForm form = new RenderForm();

            form.Text = "Tutorial 17: Query";
            //frame rate counter
            SharpFPS fpsCounter = new SharpFPS();


            using (SharpDevice device = new SharpDevice(form))
            {
                //load font
                SharpBatch font = new SharpBatch(device, "textfont.dds");

                //load model from wavefront obj file
                SharpMesh earth = SharpMesh.CreateFromObj(device, "../../../Models/planets/earth.obj");
                SharpMesh moon  = SharpMesh.CreateFromObj(device, "../../../Models/planets/moon.obj");

                //init shader
                SharpShader shader = new SharpShader(device, "../../HLSL.txt",
                                                     new SharpShaderDescription()
                {
                    VertexShaderFunction = "VS", PixelShaderFunction = "PS"
                },
                                                     new InputElement[] {
                    new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0),
                    new InputElement("NORMAL", 0, Format.R32G32B32_Float, 12, 0),
                    new InputElement("TEXCOORD", 0, Format.R32G32_Float, 24, 0)
                });

                //init constant buffer
                Buffer11 buffer = shader.CreateBuffer <Data>();

                Query pipelineQuery = new Query(device.Device, new QueryDescription()
                {
                    Flags = QueryFlags.None, Type = QueryType.PipelineStatistics
                });

                QueryDataPipelineStatistics stats = new QueryDataPipelineStatistics();


                //init frame counter
                fpsCounter.Reset();

                int   lastX        = 0;
                float currentAngle = 200;
                form.MouseMove += (sender, e) =>
                {
                    if (e.Button == MouseButtons.Left)
                    {
                        currentAngle += (lastX - e.X);
                    }
                    lastX = e.X;
                };

                //main loop
                RenderLoop.Run(form, () =>
                {
                    //Resizing
                    if (device.MustResize)
                    {
                        device.Resize();
                        font.Resize();
                    }

                    //apply states
                    device.UpdateAllStates();

                    //clear color
                    device.Clear(Color.CornflowerBlue);

                    //apply shader
                    shader.Apply();


                    //apply constant buffer to shader
                    device.DeviceContext.VertexShader.SetConstantBuffer(0, buffer);
                    device.DeviceContext.PixelShader.SetConstantBuffer(0, buffer);

                    //set transformation matrix
                    float ratio       = (float)form.ClientRectangle.Width / (float)form.ClientRectangle.Height;
                    Matrix projection = Matrix.PerspectiveFovLH(3.14F / 3.0F, ratio, 1F, 1000.0F);
                    Matrix view       = Matrix.LookAtLH(new Vector3(0, 0, -250), new Vector3(), Vector3.UnitY);
                    Matrix world      = Matrix.Translation(0, 0, 200) * Matrix.RotationY(MathUtil.DegreesToRadians(currentAngle));

                    //light direction
                    Vector3 lightDirection = new Vector3(0.5f, 0, -1);
                    lightDirection.Normalize();


                    Data sceneInformation = new Data()
                    {
                        world = world,
                        worldViewProjection = world * view * projection,
                        lightDirection      = new Vector4(lightDirection, 1)
                    };

                    //write data inside constant buffer
                    device.UpdateData <Data>(buffer, sceneInformation);

                    //draw mesh
                    moon.Begin();
                    for (int i = 0; i < moon.SubSets.Count; i++)
                    {
                        device.DeviceContext.PixelShader.SetShaderResource(0, moon.SubSets[i].DiffuseMap);
                        moon.Draw(i);
                    }

                    //begin analizing
                    device.DeviceContext.Begin(pipelineQuery);

                    world            = Matrix.RotationY(Environment.TickCount / 2000.0F);
                    sceneInformation = new Data()
                    {
                        world = world,
                        worldViewProjection = world * view * projection,
                        lightDirection      = new Vector4(lightDirection, 1)
                    };

                    //write data inside constant buffer
                    device.UpdateData <Data>(buffer, sceneInformation);

                    //draw mesh
                    earth.Begin();
                    for (int i = 0; i < earth.SubSets.Count; i++)
                    {
                        device.DeviceContext.PixelShader.SetShaderResource(0, earth.SubSets[i].DiffuseMap);
                        earth.Draw(i);
                    }
                    //end analizing
                    device.DeviceContext.End(pipelineQuery);

                    //get result
                    while (!device.DeviceContext.GetData <QueryDataPipelineStatistics>(pipelineQuery, AsynchronousFlags.None, out stats))
                    {
                    }

                    //begin drawing text
                    font.Begin();

                    //draw string
                    fpsCounter.Update();
                    font.DrawString("Earth Stats : FPS: " + fpsCounter.FPS, 0, 0, Color.White);

                    //print earth stats
                    font.DrawString("Earth Stats : Rotate Moon To Cover Earth ", 0, 30, Color.White);
                    font.DrawString(string.Format("Primitive Count: {0}", stats.IAPrimitiveCount), 0, 60, Color.White);
                    font.DrawString(string.Format("Vertex Count Count: {0}", stats.IAVerticeCount), 0, 90, Color.White);
                    font.DrawString(string.Format("Vertex Shader Execution: {0}", stats.VSInvocationCount), 0, 120, Color.White);
                    font.DrawString(string.Format("Pixel Shader Execution: {0}", stats.PSInvocationCount), 0, 150, Color.White);

                    //flush text to view
                    font.End();
                    //present
                    device.Present();
                });

                //release resource
                font.Dispose();
                earth.Dispose();
                moon.Dispose();
                buffer.Dispose();
                pipelineQuery.Dispose();
            }
        }
예제 #5
0
        static void Main()
        {
            if (!SharpDevice.IsDirectX11Supported())
            {
                System.Windows.Forms.MessageBox.Show("DirectX11 Not Supported");
                return;
            }

            //render form
            RenderForm form = new RenderForm();

            form.Text = "Tutorial 10: Render Target";
            //frame rate counter
            SharpFPS fpsCounter = new SharpFPS();


            using (SharpDevice device = new SharpDevice(form))
            {
                //load model from wavefront obj file
                SharpMesh dogMesh  = SharpMesh.CreateNormalMappedFromObj(device, "../../../Models/dog/dog.obj");
                SharpMesh cubeMesh = SharpMesh.CreateFromObj(device, "../../../Models/cube.obj");

                //init shader
                SharpShader phongShader = new SharpShader(device, "../../HLSL.txt",
                                                          new SharpShaderDescription()
                {
                    VertexShaderFunction = "VS", PixelShaderFunction = "PS"
                },
                                                          new InputElement[] {
                    new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0),
                    new InputElement("NORMAL", 0, Format.R32G32B32_Float, 12, 0),
                    new InputElement("TANGENT", 0, Format.R32G32B32_Float, 24, 0),
                    new InputElement("BINORMAL", 0, Format.R32G32B32_Float, 36, 0),
                    new InputElement("TEXCOORD", 0, Format.R32G32_Float, 48, 0)
                });

                SharpShader renderTargetShader = new SharpShader(device, "../../HLSL_RT.txt",
                                                                 new SharpShaderDescription()
                {
                    VertexShaderFunction = "VS", PixelShaderFunction = "PS"
                },
                                                                 new InputElement[] {
                    new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0),
                    new InputElement("NORMAL", 0, Format.R32G32B32_Float, 12, 0),
                    new InputElement("TEXCOORD", 0, Format.R32G32_Float, 24, 0)
                });

                //render target
                SharpRenderTarget target = new SharpRenderTarget(device, 512, 512, Format.B8G8R8A8_UNorm);

                //init constant buffer
                Buffer11 phongConstantBuffer        = phongShader.CreateBuffer <PhongData>();
                Buffer11 renderTargetConstantBuffer = phongShader.CreateBuffer <RenderTargetData>();

                //init frame counter
                fpsCounter.Reset();

                var capture = false;

                //effect inside shader
                int mode = 0;
                form.KeyDown += (sender, e) =>
                {
                    switch (e.KeyCode)
                    {
                    case Keys.D1:
                        mode = 0;
                        break;

                    case Keys.D2:
                        mode = 1;
                        break;

                    case Keys.D3:
                        mode = 2;
                        break;

                    case Keys.D4:
                        mode = 3;
                        break;

                    case Keys.D5:
                        capture = true;
                        break;
                    }
                };

                //main loop
                RenderLoop.Run(form, () =>
                {
                    //Resizing
                    if (device.MustResize)
                    {
                        device.Resize();
                    }

                    //apply states
                    device.UpdateAllStates();


                    //BEGIN RENDERING TO TEXTURE
                    target.Apply();
                    target.Clear(Color.CornflowerBlue);

                    //set transformation matrix
                    float ratio       = (float)form.ClientRectangle.Width / (float)form.ClientRectangle.Height;
                    Matrix projection = Matrix.PerspectiveFovLH(3.14F / 3.0F, ratio, 1F, 1000.0F);

                    Vector3 from = new Vector3(0, 70, -150);
                    Vector3 to   = new Vector3(0, 50, 0);

                    Matrix view  = Matrix.LookAtLH(from, to, Vector3.UnitY);
                    Matrix world = Matrix.RotationY(Environment.TickCount / 2000.0F);

                    //light direction
                    Vector3 lightDirection = new Vector3(0.5f, 0, -1);
                    lightDirection.Normalize();


                    PhongData sceneInformation = new PhongData()
                    {
                        world = world,
                        worldViewProjection = world * view * projection,
                        lightDirection      = new Vector4(lightDirection, 1),
                    };


                    //apply shader
                    phongShader.Apply();

                    //write data inside constant buffer
                    device.UpdateData <PhongData>(phongConstantBuffer, sceneInformation);

                    //apply constant buffer to shader
                    device.DeviceContext.VertexShader.SetConstantBuffer(0, phongConstantBuffer);
                    device.DeviceContext.PixelShader.SetConstantBuffer(0, phongConstantBuffer);

                    //draw mesh
                    dogMesh.Begin();
                    for (int i = 0; i < dogMesh.SubSets.Count; i++)
                    {
                        device.DeviceContext.PixelShader.SetShaderResource(0, dogMesh.SubSets[i].DiffuseMap);
                        device.DeviceContext.PixelShader.SetShaderResource(1, dogMesh.SubSets[i].NormalMap);
                        dogMesh.Draw(i);
                    }


                    //RENDERING TO DEVICE

                    //Set original targets
                    device.SetDefaultTargers();

                    if (capture)
                    {
                        target.ToBitmap().Save("Test.jpg");
                        capture = false;
                    }

                    //apply shader
                    renderTargetShader.Apply();

                    Matrix WVP =
                        Matrix.RotationY(Environment.TickCount / 2000.0F) *
                        Matrix.LookAtLH(new Vector3(7, 10, -13), new Vector3(), Vector3.UnitY) *
                        projection;
                    device.UpdateData <RenderTargetData>(renderTargetConstantBuffer, new RenderTargetData()
                    {
                        worldViewProjection = WVP, data = new Vector4(mode, 0, 0, 0)
                    });


                    //clear color
                    device.Clear(Color.Black);

                    renderTargetShader.Apply();

                    //apply constant buffer to shader
                    device.DeviceContext.VertexShader.SetConstantBuffer(0, renderTargetConstantBuffer);
                    device.DeviceContext.PixelShader.SetConstantBuffer(0, renderTargetConstantBuffer);

                    //set target
                    device.DeviceContext.PixelShader.SetShaderResource(0, target.Resource);

                    cubeMesh.Draw();


                    //begin drawing text
                    device.Font.Begin();

                    //draw string
                    fpsCounter.Update();
                    device.Font.DrawString("FPS: " + fpsCounter.FPS, 0, 0);
                    device.Font.DrawString("Press 1 To 4 to change Effect", 0, 30);

                    //flush text to view
                    device.Font.End();
                    //present
                    device.Present();
                });


                //release resource
                dogMesh.Dispose();
                cubeMesh.Dispose();
                phongConstantBuffer.Dispose();
                renderTargetConstantBuffer.Dispose();
                phongShader.Dispose();
                renderTargetShader.Dispose();
            }
        }
예제 #6
0
        static void Main()
        {
            if (!SharpDevice.IsDirectX11Supported())
            {
                System.Windows.Forms.MessageBox.Show("DirectX11 Not Supported");
                return;
            }

            //render form
            RenderForm form = new RenderForm();

            form.Text = "Tutorial 16: Environment Mapping";
            //frame rate counter
            SharpFPS fpsCounter = new SharpFPS();


            using (SharpDevice device = new SharpDevice(form))
            {
                //load font
                SharpBatch font = new SharpBatch(device, "textfont.dds");

                //load model from wavefront obj file
                SharpMesh teapot = SharpMesh.CreateFromObj(device, "../../../Models/teapot.obj");

                //init shader
                SharpShader cubeMapPass = new SharpShader(device, "../../HLSL.txt",
                                                          new SharpShaderDescription()
                {
                    VertexShaderFunction = "VS", GeometryShaderFunction = "GS", PixelShaderFunction = "PS"
                },
                                                          new InputElement[] {
                    new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0),
                    new InputElement("NORMAL", 0, Format.R32G32B32_Float, 12, 0),
                    new InputElement("TEXCOORD", 0, Format.R32G32_Float, 24, 0)
                });

                //second pass
                SharpShader standard = new SharpShader(device, "../../HLSL.txt",
                                                       new SharpShaderDescription()
                {
                    VertexShaderFunction = "VS_SECOND", PixelShaderFunction = "PS_SECOND"
                },
                                                       new InputElement[] {
                    new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0),
                    new InputElement("NORMAL", 0, Format.R32G32B32_Float, 12, 0),
                    new InputElement("TEXCOORD", 0, Format.R32G32_Float, 24, 0)
                });


                //second pass
                SharpShader reflection = new SharpShader(device, "../../HLSL.txt",
                                                         new SharpShaderDescription()
                {
                    VertexShaderFunction = "VS_SECOND", PixelShaderFunction = "PS_REFLECTION"
                },
                                                         new InputElement[] {
                    new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0),
                    new InputElement("NORMAL", 0, Format.R32G32B32_Float, 12, 0),
                    new InputElement("TEXCOORD", 0, Format.R32G32_Float, 24, 0)
                });

                //render target
                SharpCubeTarget cubeTarget = new SharpCubeTarget(device, 512, Format.R8G8B8A8_UNorm);

                //init constant buffer
                Buffer11 dataConstantBuffer = cubeMapPass.CreateBuffer <Data>();

                //init frame counter
                fpsCounter.Reset();


                //main loop
                RenderLoop.Run(form, () =>
                {
                    //Resizing
                    if (device.MustResize)
                    {
                        device.Resize();

                        font.Resize();
                    }

                    //apply states
                    device.UpdateAllStates();


                    //MATRICES

                    //set transformation matrix
                    float ratio = (float)form.ClientRectangle.Width / (float)form.ClientRectangle.Height;
                    //90° degree with 1 ratio
                    Matrix projection = Matrix.PerspectiveFovLH(3.14F / 2.0F, 1, 1F, 10000.0F);

                    //camera
                    Vector3 from = new Vector3(0, 30, 70);
                    Vector3 to   = new Vector3(0, 0, 0);

                    Matrix view  = Matrix.LookAtLH(from, to, Vector3.UnitY);
                    Matrix world = Matrix.Translation(0, 0, 50) * Matrix.RotationY(Environment.TickCount / 1000.0F);

                    //light direction
                    Vector3 lightDirection = new Vector3(0.5f, 0, -1);
                    lightDirection.Normalize();

                    //six axis
                    Matrix view1 = Matrix.LookAtLH(new Vector3(), new Vector3(1, 0, 0), Vector3.UnitY);
                    Matrix view2 = Matrix.LookAtLH(new Vector3(), new Vector3(-1, 0, 0), Vector3.UnitY);
                    Matrix view3 = Matrix.LookAtLH(new Vector3(), new Vector3(0, 1, 0), -Vector3.UnitZ);
                    Matrix view4 = Matrix.LookAtLH(new Vector3(), new Vector3(0, -1, 0), Vector3.UnitZ);
                    Matrix view5 = Matrix.LookAtLH(new Vector3(), new Vector3(0, 0, 1), Vector3.UnitY);
                    Matrix view6 = Matrix.LookAtLH(new Vector3(), new Vector3(0, 0, -1), Vector3.UnitY);



                    //BEGIN RENDERING TO CUBE TEXTURE

                    cubeTarget.Apply();
                    cubeTarget.Clear(Color.CornflowerBlue);


                    Data sceneInformation = new Data()
                    {
                        world = world,
                        worldViewProjection = world * view * projection,
                        lightDirection      = new Vector4(lightDirection, 1),
                        cameraPosition      = new Vector4(from, 1),
                        mat1 = world * view1 * projection,
                        mat2 = world * view2 * projection,
                        mat3 = world * view3 * projection,
                        mat4 = world * view4 * projection,
                        mat5 = world * view5 * projection,
                        mat6 = world * view6 * projection
                    };
                    //write data inside constant buffer
                    device.UpdateData <Data>(dataConstantBuffer, sceneInformation);


                    //apply shader
                    cubeMapPass.Apply();

                    //apply constant buffer to shader
                    device.DeviceContext.VertexShader.SetConstantBuffer(0, dataConstantBuffer);
                    device.DeviceContext.GeometryShader.SetConstantBuffer(0, dataConstantBuffer);
                    device.DeviceContext.PixelShader.SetConstantBuffer(0, dataConstantBuffer);

                    //draw mesh
                    teapot.Begin();
                    for (int i = 0; i < teapot.SubSets.Count; i++)
                    {
                        device.DeviceContext.PixelShader.SetShaderResource(0, teapot.SubSets[i].DiffuseMap);
                        teapot.Draw(i);
                    }


                    //RENDERING TO DEVICE

                    //Set original targets
                    device.SetDefaultTargers();

                    //clear color
                    device.Clear(Color.Blue);

                    //apply shader
                    standard.Apply();


                    //set target
                    device.DeviceContext.PixelShader.SetShaderResource(1, cubeTarget.Resource);


                    projection       = Matrix.PerspectiveFovLH(3.14F / 3.0F, ratio, 1, 10000.0F);
                    sceneInformation = new Data()
                    {
                        world = world,
                        worldViewProjection = world * view * projection,
                        lightDirection      = new Vector4(lightDirection, 1),
                        cameraPosition      = new Vector4(from, 1),
                        mat1 = world * view1 * projection,
                        mat2 = world * view2 * projection,
                        mat3 = world * view3 * projection,
                        mat4 = world * view4 * projection,
                        mat5 = world * view5 * projection,
                        mat6 = world * view6 * projection
                    };
                    //write data inside constant buffer
                    device.UpdateData <Data>(dataConstantBuffer, sceneInformation);

                    //room
                    teapot.Begin();
                    for (int i = 0; i < teapot.SubSets.Count; i++)
                    {
                        device.DeviceContext.PixelShader.SetShaderResource(0, teapot.SubSets[i].DiffuseMap);
                        teapot.Draw(i);
                    }



                    //apply shader
                    reflection.Apply();


                    sceneInformation = new Data()
                    {
                        world = Matrix.Identity,
                        worldViewProjection = view * projection,
                        lightDirection      = new Vector4(lightDirection, 1),
                        cameraPosition      = new Vector4(from, 1),
                        mat1 = Matrix.Identity,
                        mat2 = Matrix.Identity,
                        mat3 = Matrix.Identity,
                        mat4 = Matrix.Identity,
                        mat5 = Matrix.Identity,
                        mat6 = Matrix.Identity
                    };
                    //write data inside constant buffer
                    device.UpdateData <Data>(dataConstantBuffer, sceneInformation);

                    //draw mesh
                    teapot.Begin();
                    for (int i = 0; i < teapot.SubSets.Count; i++)
                    {
                        device.DeviceContext.PixelShader.SetShaderResource(0, teapot.SubSets[i].DiffuseMap);
                        teapot.Draw(i);
                    }

                    //begin drawing text
                    font.Begin();

                    //draw string
                    fpsCounter.Update();
                    font.DrawString("FPS: " + fpsCounter.FPS, 0, 0, Color.White);

                    //flush text to view
                    font.End();
                    //present
                    device.Present();
                });


                //release resource
                font.Dispose();
                teapot.Dispose();
                dataConstantBuffer.Dispose();

                cubeMapPass.Dispose();
                standard.Dispose();
                reflection.Dispose();

                cubeTarget.Dispose();
            }
        }