public static void Draw(Device device, EEDCamera Camera)
        {
            Update(device, Camera);

            device.ImmediateContext.InputAssembler.InputLayout = EEEM.layout;
            device.ImmediateContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.LineList;
            device.ImmediateContext.InputAssembler.SetVertexBuffers(0, binding);

            EEEM.renderTechniques[0].GetPassByIndex(0).Apply(device.ImmediateContext);

            constants.WVP = Matrix.Transpose(Camera.viewProjectionMatrix);

            var dataBox = ModelViewer.Program.context.MapSubresource(constantsBuffer, 0, MapMode.WriteDiscard, SharpDX.Direct3D11.MapFlags.None);
            Utilities.Write(dataBox.DataPointer, ref constants);
            ModelViewer.Program.context.UnmapSubresource(constantsBuffer, 0);

            //Константный буффер передается шейдерам
            device.ImmediateContext.VertexShader.SetConstantBuffer(0, constantsBuffer);
            device.ImmediateContext.PixelShader.SetConstantBuffer(0, constantsBuffer);

            device.ImmediateContext.Draw(DrawLineCount*2, 0);
        }
        public void Render(Device device, EEDCamera Camera)
        {
            ShaderResourceView SRV = null; int Index = -1;
            DrawHelper.GetOcclusionTestResult(OcclRequest, out SRV, out Index);

            device.ImmediateContext.InputAssembler.InputLayout = EEEM.layout;
            device.ImmediateContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
            device.ImmediateContext.InputAssembler.SetVertexBuffers(0, MMesh.binding);
            device.ImmediateContext.InputAssembler.SetIndexBuffer(MMesh.Indices, Format.R32_UInt, 0);

            EEEM.renderTechniques[0].GetPassByIndex(0).Apply(device.ImmediateContext);

            device.ImmediateContext.PixelShader.SetShaderResource(0, TexCont.TextureResource);
            device.ImmediateContext.PixelShader.SetSampler(0, DrawHelper.SamplAnsWrapMip);

            device.ImmediateContext.PixelShader.SetShaderResource(1, SRV);
            device.ImmediateContext.VertexShader.SetShaderResource(1, SRV);

            constants.OcclIndex = new Vector4(((float)Index) / DrawHelper.OcclPixelInTex, 0, 0, 0);

            Matrix Transform = Conversion.ToMatrix(DMatrix.CreateScale(20) * DMatrix.CreateTranslation(Position) * DMatrix.CreateTranslation(-Camera.position));

            constants.World = Matrix.Transpose(Transform);
            constants.WVP = Matrix.Transpose(Transform * Camera.viewProjectionMatrix);
            constants.InvertMat = Matrix.Transpose(Camera.invertViewMatrix);

            var dataBox = ModelViewer.Program.device.ImmediateContext.MapSubresource(constantsBuffer, 0, MapMode.WriteDiscard, SharpDX.Direct3D11.MapFlags.None);
            Utilities.Write(dataBox.DataPointer, ref constants);
            ModelViewer.Program.device.ImmediateContext.UnmapSubresource(constantsBuffer, 0);

            //Константный буффер передается шейдерам
            device.ImmediateContext.VertexShader.SetConstantBuffer(0, constantsBuffer);
            device.ImmediateContext.PixelShader.SetConstantBuffer(0, constantsBuffer);

            device.ImmediateContext.DrawIndexed(MMesh.FaceCount*3, 0, 0);
        }
        private static void Update(Device device, EEDCamera Cam)
        {
            LineList.AddRange(L);
            DrawLineCount = 0;
            if (LineList.Count > 0)
            {
                var vertices = new DataStream(BytesPerVertex * LineList.Count * 2, true, true);

                for (int i = 0; i < LineList.Count; i++)
                {
                    if (LineList[i] != null)
                    {
                        vertices.Write(Conversion.ToVector3(LineList[i].Start - Cam.position));
                        vertices.Write(LineList[i].Color);
                        vertices.Write(Conversion.ToVector3(LineList[i].Stop - Cam.position));
                        vertices.Write(LineList[i].Color);
                        DrawLineCount++;
                    }
                }
                vertices.Position = 0;

                if (DrawLineCount > CurrentBufferSize)
                {
                    //Resize
                    //TODO удваивать буффер
                    Vertexs.Dispose();
                    Vertexs = new Buffer(device, BytesPerVertex * DrawLineCount * 2, ResourceUsage.Dynamic, BindFlags.VertexBuffer, CpuAccessFlags.Write, ResourceOptionFlags.None, 0);
                }

                DataStream stream;
                device.ImmediateContext.MapSubresource(Vertexs, MapMode.WriteDiscard, SharpDX.Direct3D11.MapFlags.None, out stream);

                stream.Position = 0;
                stream.WriteRange(vertices.DataPointer, vertices.Length);

                device.ImmediateContext.UnmapSubresource(Vertexs, 0);

                stream.Dispose();
                vertices.Dispose();

                binding = new VertexBufferBinding(Vertexs, BytesPerVertex, 0);
            }
        }
        public static void Update(float TimeMili, EEDCamera Cam)
        {
            if (InputManager.KeyPressed(Keys.W))
                Cam.position += Conversion.ToDoubleVector(Cam.direction) * TimeMili * Speed * 0.001f;
            if (InputManager.KeyPressed(Keys.S))
                Cam.position -= Conversion.ToDoubleVector(Cam.direction) * TimeMili * Speed * 0.001f;
            if (InputManager.KeyPressed(Keys.D))
            {
                Vector3 R = Vector3.Cross(Cam.direction, new Vector3(0, 1, 0));
                Cam.position += Conversion.ToDoubleVector(R) * TimeMili * Speed * 0.001f;
            }
            if (InputManager.KeyPressed(Keys.A))
            {
                Vector3 R = Vector3.Cross(Cam.direction, new Vector3(0, 1, 0));
                Cam.position -= Conversion.ToDoubleVector(R) * TimeMili * Speed * 0.001f;
            }
            if (InputManager.KeyPressed(Keys.Space))
                Cam.position += Conversion.ToDoubleVector(new Vector3(0, 1, 0)) * TimeMili * Speed * 0.001f;
            if (InputManager.KeyPressed(Keys.ControlKey))
                Cam.position -= Conversion.ToDoubleVector(new Vector3(0, 1, 0)) * TimeMili * Speed * 0.001f;

            if (InputManager.KeyPressed(Keys.D1))
                Speed = 10f;
            if (InputManager.KeyPressed(Keys.D2))
                Speed = 20f;
            if (InputManager.KeyPressed(Keys.D3))
                Speed = 40f;
            if (InputManager.KeyPressed(Keys.D4))
                Speed = 80f;
            if (InputManager.KeyPressed(Keys.D5))
                Speed = 160f;
            if (InputManager.KeyPressed(Keys.D6))
                Speed = 320f;
            if (InputManager.KeyPressed(Keys.D7))
                Speed = 640;

            if (InputManager.PreRightMouse && !InputManager.RightMouse)
            {
                InputManager.CursorToCenter = !InputManager.CursorToCenter;
            }

            if (InputManager.CursorToCenter)
            {
                yawn -= InputManager.MouseDelta.X / 1000f;
                if (yawn < -2d*Math.PI) yawn = 0;//-(float)Math.PI;
                if (yawn > 2d*Math.PI) yawn = 0;//(float)Math.PI;

                pitch -= InputManager.MouseDelta.Y / 1000f;
                if (pitch <= -Math.PI / 2d) pitch = -(float)Math.PI / 2f;//-(float)Math.PI;
                if (pitch > Math.PI / 2d) pitch = (float)Math.PI / 2f;//(float)Math.PI;
            }

            Quaternion quat = Quaternion.RotationYawPitchRoll((float)yawn, (float)pitch, 0);
            Cam.quaternion = quat;

            //Program.form.Text = Cam.position.ToString();

            if (PreKeyEnter && !InputManager.KeyPressed(Keys.Enter))
            {
                //Shapshot
                DebugDraw.ShadowsShapshot();
            }
            PreKeyEnter = InputManager.KeyPressed(Keys.Enter);
        }
 public void DrawEffects(Device device, EEDCamera Camera)
 {
     for (int i = 0 ; i < EngPosition.Length; i++)
     {
         DVector3 Pos = DVector3.Transform(EngPosition[i], Transformation);
         LensBatching.DrawLens(Pos, new Vector2(50, 25), new Vector2(0, 0), new Vector2(1, 1), new Vector4(1, 0.5f, 0, 1), Lens);
     }
 }
 /// <summary>
 /// Отрисовать карту глубины
 /// </summary>
 /// <param name="device"></param>
 /// <param name="Camera"></param>
 public void DrawDepth(Device device, EEDCamera Camera)
 {
     Matrix Transform = Conversion.ToMatrix(Transformation * DMatrix.CreateTranslation(-Camera.position));
     MMC.DrawDepth(0, Transform * Camera.viewProjectionMatrix, Camera);
 }
 /// <summary>
 /// Отрисовать без теней
 /// </summary>
 /// <param name="device"></param>
 /// <param name="Camera"></param>
 /// <param name="LightColor"></param>
 /// <param name="LightDirection"></param>
 public void Draw(Device device, EEDCamera Camera, Vector3 LightColor, Vector3 LightDirection)
 {
     Matrix Transform = Conversion.ToMatrix(Transformation * DMatrix.CreateTranslation(-Camera.position));
     MMC.DrawNoShadows(0, Transform, Camera.viewProjectionMatrix, -LightDirection, LightColor);
 }
        public void DrawDepth(float TimeMili, Matrix MainWVP, EEDCamera Camera)
        {
            constants.WVP = Matrix.Transpose(MainWVP);
            constants.Color = new Vector4(0, 0, 0, 0);
            constants.CamPosition.Z = Camera.farClip;
            constants.CamPosition.W = Camera.nearClip;
            Program.context.InputAssembler.InputLayout = Materials[0].Effect.layout;
            Program.context.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
            Program.context.InputAssembler.SetVertexBuffers(0, binding);
            Program.context.InputAssembler.SetIndexBuffer(Indices, Format.R32_UInt, 0);

            //NoDoubleSide&NoAlphaTest
            {
                Materials[0].Effect.renderTechniques[1].GetPassByIndex(2).Apply(Program.context);

                SetConstants(false);

                for (int i = 0; i < Materials.Length; i++)
                {
                    if (!Materials[i].DoubleSide && Materials[i].Alpha < 1)
                        Program.context.DrawIndexed(Meshes[i].IndexCount, Meshes[i].StartIndex, 0);
                }
            }
            DifuseName = "";

            //NoDoubleSide&AlphaTest
            for (int i = 0; i < Materials.Length; i++)
            {
                if (!Materials[i].DoubleSide && Materials[i].Alpha >= 1)
                {
                    if (ShaderName != Materials[i].Effect.Name)
                    {
                        Materials[i].Effect.renderTechniques[1].GetPassByIndex(2).Apply(Program.context);
                        ShaderName = Materials[i].Effect.Name;
                        DifuseName = "";
                    }
                    if (DifuseName != Materials[i].Diffuse.Name)
                    {
                        Program.context.PixelShader.SetShaderResource(0, Materials[i].Diffuse.TextureResource);
                        Program.context.PixelShader.SetSampler(0, Materials[i].DiffuseSamplerState);
                        DifuseName = Materials[i].Diffuse.Name;
                    }

                    constants.Color = Conversion.ToVector4(new Vector3(), Materials[i].Alpha / 255f);
                    SetConstants(false);
                    Program.context.DrawIndexed(Meshes[i].IndexCount, Meshes[i].StartIndex, 0);
                }
            }

            //DoubleSide&AlphaTest
            for (int i = 0; i < Materials.Length; i++)
            {
                if (Materials[i].DoubleSide)
                {
                    if (ShaderName != Materials[i].Effect.Name)
                    {
                        Materials[i].Effect.renderTechniques[1].GetPassByIndex(3).Apply(Program.context);
                        ShaderName = Materials[i].Effect.Name;
                        DifuseName = "";
                    }
                    if (DifuseName != Materials[i].Diffuse.Name)
                    {
                        Program.context.PixelShader.SetShaderResource(0, Materials[i].Diffuse.TextureResource);
                        Program.context.PixelShader.SetSampler(0, Materials[i].DiffuseSamplerState);
                        DifuseName = Materials[i].Diffuse.Name;
                    }

                    constants.Color = Conversion.ToVector4(new Vector3(), Materials[i].Alpha / 255f);
                    SetConstants(false);
                    Program.context.DrawIndexed(Meshes[i].IndexCount, Meshes[i].StartIndex, 0);
                }
            }
        }
        private static void GenerateSplit(EEDCamera Camera, DVector3 ShadowVector)
        {
            Vector3 Up = new Vector3(0, 1, 0);
            NewShadowPos = Camera.position;
            DVector3.Normalize(ShadowVector);
            float d = Vector3.Dot(ShadowVector, Up);
            if (d == 1 || d == -1)
            {
                Up = new Vector3(1, 0, 0);
            }
            NewShadowPos -= ShadowDistance * ShadowVector;

            const int ShadowStep = 50;
            NewShadowPos.X = ((int)NewShadowPos.X) / ShadowStep * ShadowStep;
            NewShadowPos.Y = ((int)NewShadowPos.Y) / ShadowStep * ShadowStep;
            NewShadowPos.Z = ((int)NewShadowPos.Z) / ShadowStep * ShadowStep;

            double Coff = 0.125f;
            for (int i = 0; i < SplitsNumber + 1; i++)
            {
                SplitSlices[i] = (Camera.nearClip + (Camera.farClip - Camera.nearClip) * (float)i / (float)SplitsNumber) * (Coff);
                SplitSlices[i] += (Camera.nearClip * System.Math.Pow(Camera.farClip / Camera.nearClip, (float)i / (float)SplitsNumber)) * (1 - Coff);
                SplitSlices[i] /= Camera.farClip;
                SplitSlices[i] *= ShadowDistance;

                CamFrustumPos[i, 0] = Camera.position + (Camera.FarT1 - Camera.position) * (SplitSlices[i] / Camera.farClip);
                CamFrustumPos[i, 1] = Camera.position + (Camera.FarT2 - Camera.position) * (SplitSlices[i] / Camera.farClip);
                CamFrustumPos[i, 2] = Camera.position + (Camera.FarT3 - Camera.position) * (SplitSlices[i] / Camera.farClip);
                CamFrustumPos[i, 3] = Camera.position + (Camera.FarT4 - Camera.position) * (SplitSlices[i] / Camera.farClip);
            }

            Matrix ProjShadowMatrix = Matrix.OrthoRH(100f, 100f, (float)ShadowDistance / 1000f, (float)ShadowDistance * 2f);
            Matrix ViewShadowMatrix = Matrix.LookAtRH(new Vector3(0, 0, 0), Conversion.ToVector3(ShadowVector), Vector3.Cross(Camera.direction, ShadowVector));
            LightViewProjMatrix = ViewShadowMatrix * ProjShadowMatrix;

            for (int i = 0; i < SplitsNumber; i++)
            {

                Vector3[] TransformSplit = new Vector3[8];
                for (int t = 0; t < 4; t++)
                {
                    TransformSplit[t] = Conversion.ToVector3(Vector3.Transform(Conversion.ToVector3(CamFrustumPos[i, t] - NewShadowPos), LightViewProjMatrix));
                    TransformSplit[t + 4] = Conversion.ToVector3(Vector3.Transform(Conversion.ToVector3(CamFrustumPos[i + 1, t] - NewShadowPos), LightViewProjMatrix));
                }

                Vector3 AABBMax = TransformSplit[0];
                Vector3 AABBMin = TransformSplit[0];

                for (int y = 0; y < 8; y++)
                {
                    if (AABBMax.X < TransformSplit[y].X) AABBMax.X = TransformSplit[y].X;
                    if (AABBMax.Y < TransformSplit[y].Y) AABBMax.Y = TransformSplit[y].Y;
                    if (AABBMax.Z < TransformSplit[y].Z) AABBMax.Z = TransformSplit[y].Z;

                    if (AABBMin.X > TransformSplit[y].X) AABBMin.X = TransformSplit[y].X;
                    if (AABBMin.Y > TransformSplit[y].Y) AABBMin.Y = TransformSplit[y].Y;
                    if (AABBMin.Z > TransformSplit[y].Z) AABBMin.Z = TransformSplit[y].Z;
                }
                /*
                AABBMax += new Vector3(0.05f);
                AABBMin -= new Vector3(0.05f);
                */

                // Create the crop matrix
                float scaleX, scaleY, scaleZ;
                float offsetX, offsetY, offsetZ;
                // Use default near-plane value
                AABBMin.Z = 0.0f;

                scaleX = 2.0f / (AABBMax.X - AABBMin.X);
                scaleY = 2.0f / (AABBMax.Y - AABBMin.Y);
                offsetX = -0.5f * (AABBMax.X + AABBMin.X) * scaleX;
                offsetY = -0.5f * (AABBMax.Y + AABBMin.Y) * scaleY;
                scaleZ = 1.0f / ((AABBMax.Z - AABBMin.Z));
                offsetZ = -AABBMin.Z * scaleZ;

                const int CoffShadowStep = 5;
                const float CoffMulti = 100f;
                const float CoffMultiScale = 1000f;

                offsetX = ((float)(((int)(offsetX * CoffMulti)) / CoffShadowStep * CoffShadowStep)) / CoffMulti;
                offsetY = ((float)(((int)(offsetY * CoffMulti)) / CoffShadowStep * CoffShadowStep)) / CoffMulti;
                offsetZ = ((float)(((int)(offsetZ * CoffMulti)) / CoffShadowStep * CoffShadowStep)) / CoffMulti;

                scaleX = ((float)(((int)(scaleX * CoffMultiScale)) / CoffShadowStep * CoffShadowStep)) / CoffMultiScale;
                scaleY = ((float)(((int)(scaleY * CoffMultiScale)) / CoffShadowStep * CoffShadowStep)) / CoffMultiScale;
                scaleZ = ((float)(((int)(scaleZ * CoffMultiScale)) / CoffShadowStep * CoffShadowStep)) / CoffMultiScale;

                CropMatrices[i] = new Matrix(scaleX, 0.0f, 0.0f, 0.0f, 0.0f, scaleY, 0.0f, 0.0f, 0.0f, 0.0f, scaleZ, 0.0f, offsetX, offsetY, offsetZ, 1.0f);

                DMatrix Inv = DMatrix.Invert(Conversion.ToDoubleMatrix(LightViewProjMatrix * CropMatrices[i]));

                DVector3 LocPos = DVector3.Transform(new DVector3(), Inv);
                NewCamPositions[i] = NewShadowPos + LocPos;
            }
        }
        public static void RenderObj(float TimeMili, Device device, EEDCamera Camera, Vector3 LightDirection, Vector3 LightColor, List<GameObject> GOs)
        {
            Matrix[] S_VP = new Matrix[SplitsNumber];
            float[] SplitDistances = new float[SplitsNumber];
            for (int i = 0; i < SplitsNumber; i++)
            {
                S_VP[i] = LightViewProjMatrix * CropMatrices[i];
                SplitDistances[i] = (float)SplitSlices[i + 1];///Camera.farClip;
            }
            DMatrix W_S_CAM = DMatrix.CreateTranslation(-NewShadowPos);

            Matrix[] S_WVP = new Matrix[SplitsNumber];
            for (int i = 0; i < GOs.Count; i++)
                if (GOs[i] != null)
                {
                    for (int y = 0; y < SplitsNumber; y++)
                    {
                        S_WVP[y] = Conversion.ToMatrix(GOs[i].Transformation * DMatrix.CreateTranslation(-NewShadowPos)) * S_VP[y];
                    }

                    if (GOs[i].StopSplit > -1)
                        GOs[i].DrawPSSM(device, TimeMili, Camera, LightDirection, LightColor, S_WVP, SplitDistances);
                    else
                        GOs[i].Draw(device, Camera, LightColor, LightDirection);
                }
        }
        public static void RenderAllSplits(Device device, EEDCamera Camera, DVector3 ShadowVector, KDtree KDT, List<GameObject> ObjInCam)
        {
            for (int t = 0; t < ObjInCam.Count; t++)
                if (ObjInCam[t] != null)
                {
                    ObjInCam[t].StartSplit = -1;
                    ObjInCam[t].StopSplit = -1;
                }
            //string title = "";
            GenerateSplit(Camera, ShadowVector);
            for (int i = 0; i < SplitsNumber; i++)
            {
                DMatrix Inv = DMatrix.Invert(Conversion.ToDoubleMatrix(LightViewProjMatrix * CropMatrices[i]));
                Vector3 View = Conversion.ToVector3(DVector3.Transform(new DVector3(0, 0, 1), Inv) - DVector3.Transform(new DVector3(0, 0, 0), Inv));
                Vector3 Right = Conversion.ToVector3(DVector3.Transform(new DVector3(1, 0, 0), Inv) - DVector3.Transform(new DVector3(0, 0, 0), Inv));
                Vector3 Up = Conversion.ToVector3(DVector3.Transform(new DVector3(0, 1, 0), Inv) - DVector3.Transform(new DVector3(0, 0, 0), Inv));
                BoundingFrustum BF = new BoundingFrustum(View, Right, Up);

                ObjInSplites[i] =

                    //KDT.GetBody(new DVector3(), ShadowDistance);
                    KDT.GetBodyInCamera(NewCamPositions[i], BF);

                //title += "  "  + ObjInSplites[i].Count;
            }
            //Program.form.Text = title;
            RenderTargetView RTV_ = null;
            device.ImmediateContext.OutputMerger.SetTargets(SMArrayDSV, RTV_);

            device.ImmediateContext.ClearDepthStencilView(SMArrayDSV, DepthStencilClearFlags.Depth, 1.0f, 0);

            device.ImmediateContext.Rasterizer.SetViewports(SMArrayV);

            for (int i = 0; i < SplitsNumber; i++)
            {
                for (int y = 0; y < ObjInSplites[i].Count; y++)
                {
                    GameObject GO = ObjInSplites[i][y];
                    if (GO != null)
                    {
                        int Start = i;
                        int Stop = i;

                        if (i < SplitsNumber)
                        {
                            for (int j = i + 1; j < SplitsNumber; j++)
                            {
                                //Перебор последующих срезов
                                if (ObjInSplites[j].Contains(GO))
                                {
                                    Stop = j;
                                    ObjInSplites[j].Remove(GO);
                                }
                            }
                        }
                        //Draw
                        GO.StartSplit = Start;
                        GO.StopSplit = Stop;

                        GO.DrawPSSMSplit(device, NewShadowPos, LightViewProjMatrix, CropMatrices, Start, Stop);
                    }
                }
            }
        }
        private static void SortDraw(ref Request[] In, ref Request[] Out, int InCount, Device device, EEDCamera Camera, ShaderResourceView DepthMap)
        {
            int OutCount = 0;
            if (InCount > 0)
            {
                var vertices = new DataStream(BytesPerVertex * MassSize, true, true);
                int DrawVertexCout = 0;
                string FirstTexName = In[0].Textur.Name;

                for (int i = 0; i < InCount; i++)
                {
                    if (In[i].Textur.Name == FirstTexName)
                    {
                        //Go vertex
                        DrawVertexCout++;
                        vertices.Write(Conversion.ToVector3(In[i].Position - Camera.position));
                        vertices.Write(new Half2(In[i].Size.X, In[i].Size.Y));
                        vertices.Write(new Half4(In[i].UVMin.X, In[i].UVMin.Y, In[i].UVMax.X, In[i].UVMax.Y));
                        vertices.Write(new Half4(In[i].Color.X, In[i].Color.Y, In[i].Color.Z, In[i].Color.W));
                    }
                    else
                    {
                        //Go out
                        Out[OutCount] = In[i];
                        OutCount++;
                    }
                }
                vertices.Position = 0;

                DataStream stream;
                device.ImmediateContext.MapSubresource(Vertexs, MapMode.WriteDiscard, SharpDX.Direct3D11.MapFlags.None, out stream);
                stream.Position = 0;
                stream.WriteRange(vertices.DataPointer, vertices.Length);
                device.ImmediateContext.UnmapSubresource(Vertexs, 0);
                stream.Dispose();
                vertices.Dispose();
                binding = new VertexBufferBinding(Vertexs, BytesPerVertex, 0);

                device.ImmediateContext.InputAssembler.SetVertexBuffers(0, binding);
                device.ImmediateContext.PixelShader.SetShaderResource(0, In[0].Textur.TextureResource);
                device.ImmediateContext.Draw(DrawVertexCout, 0);

                SortDraw(ref Out, ref In, OutCount, device, Camera, DepthMap);
            }
        }
        public static void BatchingDrawLens(Device device, EEDCamera Camera, ShaderResourceView DepthMap)
        {
            if (LastFreeIndex > 0)
            {
                if (ResizeVertex)
                {
                    Vertexs = new Buffer(device, BytesPerVertex * MassSize, ResourceUsage.Dynamic, BindFlags.VertexBuffer, CpuAccessFlags.Write, ResourceOptionFlags.None, 0);
                    //binding = new VertexBufferBinding(Vertexs, BytesPerVertex, 0);
                    ResizeVertex = false;
                }
                //sorting draw

                constants.FarPlane = new Vector4(Camera.farClip, 0, 0, 0);
                constants.VP = Matrix.Transpose(Camera.viewProjectionMatrix);
                var dataBox = ModelViewer.Program.device.ImmediateContext.MapSubresource(constantsBuffer, 0, MapMode.WriteDiscard, SharpDX.Direct3D11.MapFlags.None);
                Utilities.Write(dataBox.DataPointer, ref constants);
                ModelViewer.Program.device.ImmediateContext.UnmapSubresource(constantsBuffer, 0);

                device.ImmediateContext.InputAssembler.InputLayout = EEEM.layout;
                device.ImmediateContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.PointList;

                EEEM.renderTechniques[0].GetPassByIndex(0).Apply(device.ImmediateContext);
                device.ImmediateContext.VertexShader.SetShaderResource(1, DepthMap);
                //Константный буффер передается шейдерам
                device.ImmediateContext.VertexShader.SetConstantBuffer(0, constantsBuffer);
                device.ImmediateContext.PixelShader.SetSampler(0, DrawHelper.SamplAnsWrapMip);

                SortDraw(ref MasterRequest, ref SlaveRequest, LastFreeIndex, device, Camera, DepthMap);
                LastFreeIndex = 0;
            }
        }
        public static void OcclusionTest(Device device, EEDCamera Cam, ShaderResourceView DepthMap)
        {
            device.ImmediateContext.InputAssembler.InputLayout = EEEM.layout;
            device.ImmediateContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
            device.ImmediateContext.InputAssembler.SetVertexBuffers(0, MConteints.binding);
            device.ImmediateContext.InputAssembler.SetIndexBuffer(MConteints.Indices, Format.R32_UInt, 0);

            device.ImmediateContext.Rasterizer.SetViewports(OcclViewport);

            int stepcount = LastFreeIndex / OcclPixelInTex;
            for (int i = 0; i <= stepcount; i++)
            {
                int TestCount = OcclPixelInTex;
                if (i == stepcount)
                    TestCount = LastFreeIndex % OcclPixelInTex;

                device.ImmediateContext.OutputMerger.SetTargets(OcclRTV[i]);
                device.ImmediateContext.ClearRenderTargetView(OcclRTV[i], new Color4(0.0f, 0.0f, 0.0f, 1.0f));

                EEEM.renderTechniques[0].GetPassByIndex(0).Apply(device.ImmediateContext);

                device.ImmediateContext.PixelShader.SetShaderResource(0, DepthMap);
                device.ImmediateContext.PixelShader.SetSampler(0, SamplPntWrap);

                //
                //constants
                constants.CamViewProj = Matrix.Transpose(Cam.viewProjectionMatrix);
                constants.FarPlane = new Vector4(Cam.farClip, 0, 0, 0);
                unsafe
                {
                    fixed (float* buffer = constants.Positions)
                    {
                        for (int x = 0; x < TestCount; x++)
                        {
                            DVector3 Pos = OcclusionRequestPosition[x + i * OcclPixelInTex];
                            Vector3 LocPos = Conversion.ToVector3(Pos - Cam.position);

                            buffer[x * 4 + 0] = LocPos.X;
                            buffer[x * 4 + 1] = LocPos.Y;
                            buffer[x * 4 + 2] = LocPos.Z;
                            buffer[x * 4 + 3] = 0;
                        }
                    }
                }

                var dataBox = ModelViewer.Program.context.MapSubresource(constantsBuffer, 0, MapMode.WriteDiscard, SharpDX.Direct3D11.MapFlags.None);
                Utilities.Write(dataBox.DataPointer, ref constants);
                device.ImmediateContext.UnmapSubresource(constantsBuffer, 0);

                //Константный буффер передается шейдерам
                device.ImmediateContext.VertexShader.SetConstantBuffer(0, constantsBuffer);
                device.ImmediateContext.PixelShader.SetConstantBuffer(0, constantsBuffer);

                device.ImmediateContext.DrawIndexed(6, 0, 0);
            }
            LastFreeIndex = 0;
        }
Esempio n. 15
0
        public void LoadContent(Device device)
        {
            Light = new EELightShadow(new DVector3(10, 40, 40), new Vector3(2.4f, 2.2f, 2.0f));
            Camera = new EEDCamera(Global.Settings.Width, Global.Settings.Height, 45, 1, 10000);

            //Camera = new EEDCamera(Global.Settings.Width, Global.Settings.Height, 90, 1, 1000);
            Light = new EELightShadow(new DVector3(10, 40, 40), new Vector3(2.4f, 2.2f, 2.0f));
            SkyBox = new EESkyBox();
            SkyBox.Initialize();
            //TestCube_UV2
            //"Content\\Models\\Argon_1_export.material"
            AllObjects.Add(new GameObject("Content\\Models\\Argon_1_export.material"));
            AllObjects.Add(new GameObject("Content\\Models\\Argon_1_export.material"));
            AllObjects.Add(new GameObject("Content\\Models\\TestCube_UV2.material"));

            AllObjects[1].TempSetPos(new DVector3(0, 50, -200));
            AllObjects[2].TempSetPos(new DVector3(-100, -1000, 1000));

            Random R = new Random(1);
            for (int y = 0; y < 10; y++)
            {
                GameObject GO = new GameObject("Content\\Models\\Argon_1_export.material");
                GO.TempSetPos(new DVector3(R.NextDouble(-300, 300), R.NextDouble(-500, 500), R.NextDouble(-500, 500)));
                AllObjects.Add(GO);
            }

            float yawn = (float)Math.PI/ 2f;
            float pitch = 0f;

            Vector3 t_vec = new Vector3(0, 0, 350);
            Quaternion quat = Quaternion.RotationYawPitchRoll((float)yawn, (float)pitch, 0);
            Camera.position = Conversion.ToDoubleVector(Vector3.Transform(t_vec, quat));// +target;
            Camera.quaternion = quat;

            /*
            TS = new List<GSSprite> { };

            R = new Random(2);
            for (int i = 0; i < 1; i++)
            {
                DVector3 t = new DVector3(R.NextDouble(-500, 500), R.NextDouble(-500, 500), R.NextDouble(-500, 500));
                TS.Add(new GSSprite(device, t));
            }*/
            TC1 = ContentManager.LoadTexture2D("Content/Textures/Particl");
            TC2 = ContentManager.LoadTexture2D("Content/Textures/Particl2");
        }
Esempio n. 16
0
        public void Render(Device device, EEDCamera Camera, ShaderResourceView DepthMap)
        {
            var vertices = new DataStream(BytesPerVertex * VertexsCount, true, true);

            vertices.Write(Conversion.ToVector3(Position - Camera.position));
            vertices.Write(new Half2(50, 50));
            vertices.Write(new Half4(0, 0, 1, 1));
            vertices.Write(new Half4(0, 0, 1, 1));
            vertices.Position = 0;

            DataStream stream;
            device.ImmediateContext.MapSubresource(Vertexs, MapMode.WriteDiscard, SharpDX.Direct3D11.MapFlags.None, out stream);
            stream.Position = 0;
            stream.WriteRange(vertices.DataPointer, vertices.Length);
            device.ImmediateContext.UnmapSubresource(Vertexs, 0);
            stream.Dispose();
            vertices.Dispose();
            binding = new VertexBufferBinding(Vertexs, BytesPerVertex, 0);

            constants.FarPlane = new Vector4(Camera.farClip,0,0,0);
            constants.VP = Matrix.Transpose(Camera.viewProjectionMatrix);
            var dataBox = ModelViewer.Program.device.ImmediateContext.MapSubresource(constantsBuffer, 0, MapMode.WriteDiscard, SharpDX.Direct3D11.MapFlags.None);
            Utilities.Write(dataBox.DataPointer, ref constants);
            ModelViewer.Program.device.ImmediateContext.UnmapSubresource(constantsBuffer, 0);

            device.ImmediateContext.InputAssembler.InputLayout = EEEM.layout;
            device.ImmediateContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.PointList;
            device.ImmediateContext.InputAssembler.SetVertexBuffers(0, binding);

            EEEM.renderTechniques[0].GetPassByIndex(0).Apply(device.ImmediateContext);

            device.ImmediateContext.PixelShader.SetShaderResource(0, TexCont.TextureResource);
            device.ImmediateContext.PixelShader.SetSampler(0, DrawHelper.SamplAnsWrapMip);

            //device.ImmediateContext.PixelShader.SetShaderResource(1, DepthMap);
            device.ImmediateContext.VertexShader.SetShaderResource(1, DepthMap);

            //Константный буффер передается шейдерам
            device.ImmediateContext.VertexShader.SetConstantBuffer(0, constantsBuffer);
            //device.ImmediateContext.PixelShader.SetConstantBuffer(0, constantsBuffer);

            device.ImmediateContext.Draw(VertexsCount, 0);
        }
Esempio n. 17
0
        public void Draw(float TimeMili, Device device, DeviceContext context, EEDCamera Camera)
        {
            time += TimeMili;
            if (time > Cikl) time = 0;
            TP = time / Cikl;
            if (EEEM == null || RVtextures == null) return;

            Matrix viewMatrix = Matrix.LookAtRH(new Vector3(), Camera.direction, Camera.up_vector);
            Matrix worldMatrix = Matrix.Translation(new Vector3());
            Vector3 vCameraDirection = Camera.direction;

            SSC.WVP = Matrix.Transpose(worldMatrix * viewMatrix * Camera.projectionMatrix);

            //Загружаем геометрию
            context.InputAssembler.InputLayout = EEEM.layout;
            context.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
            context.InputAssembler.SetVertexBuffers(0, MContains.binding);
            context.InputAssembler.SetIndexBuffer(MContains.Indices, SharpDX.DXGI.Format.R32_UInt, 0);
            //Получаем буффер из структуры, структурируем и помещаем в GPU

            var dataBox = ModelViewer.Program.context.MapSubresource(SkyConstantsBuffer, 0, MapMode.WriteDiscard, SharpDX.Direct3D11.MapFlags.None);
            Utilities.Write(dataBox.DataPointer, ref SSC);
            ModelViewer.Program.context.UnmapSubresource(SkyConstantsBuffer, 0);

            //Устанавливаем эффект
            //int Technique = 0; int Pass = 0;
            EEEM.renderTechniques[0].GetPassByIndex(0).Apply(ModelViewer.Program.context);
            //Константный буффер передается шейдерам
            ModelViewer.Program.device.ImmediateContext.VertexShader.SetConstantBuffer(0, SkyConstantsBuffer);
            ModelViewer.Program.device.ImmediateContext.PixelShader.SetConstantBuffer(0, SkyConstantsBuffer);
            ModelViewer.Program.context.PixelShader.SetSampler(0,SSWrapMipLinear);

            for (int x = 0; x < 6; x++)
            {
                float f = 0;
                switch (x)
                {
                    case 0: //зад
                        f = Vector3.Dot(vCameraDirection, new Vector3(0f, 0f, -1f));
                        break;
                    case 1: //перед
                        f = Vector3.Dot(vCameraDirection, new Vector3(0f, 0f, 1f));
                        break;
                    case 2: //низ
                        f = Vector3.Dot(vCameraDirection, new Vector3(0f, 1f, 0f));
                        break;
                    case 3: //верх
                        f = Vector3.Dot(vCameraDirection, new Vector3(0f, -1f, 0f));
                        break;
                    case 4: //лево
                        f = Vector3.Dot(vCameraDirection, new Vector3(1f, 0f, 0f));
                        break;
                    case 5: //право
                        f = Vector3.Dot(vCameraDirection, new Vector3(-1f, 0f, 0f));
                        break;
                }

                if (f - 0.5f <= 0)
                {
                    ModelViewer.Program.context.PixelShader.SetShaderResource(0, RVtextures[x].TextureResource);
                    //Program.context.PixelShader.SetSampler(SSWrapMipLinear, 0);
                    ModelViewer.Program.context.DrawIndexed(6, x * 6, 0);
                }

            }
            /*
            GraphicsDevice device = Global.Game.GraphicsDevice;
            for (int x = 0; x < 6; x++)
            {
            //...
                if (f - 0.5f <= 0)
                {

                    effectProjectionParameter.SetValue(cam_.projectionMatrix);
                    effectViewportScaleParameter.SetValue(new Vector2(0.5f / device.Viewport.AspectRatio, -0.5f));
                    effectTimeParameter.SetValue(0f);
                    PEffect.Parameters["baseTexture"].SetValue(Diff);
                    PEffect.Parameters["RTexture"].SetValue(Rand);
                    PEffect.Parameters["GTexture"].SetValue(Grad);
                    //PEffect.Parameters["DTexture"].SetValue(Depth);
                    PEffect.Parameters["H"].SetValue(Global.Game.GraphicsDevice.Viewport.Height);
                    PEffect.Parameters["W"].SetValue(Global.Game.GraphicsDevice.Viewport.Width);
                    PEffect.Parameters["VP"].SetValue(worldMatrix * viewMatrix * projectionMatrix);
                    PEffect.Parameters["CurrentTime"].SetValue(TP);
                    PEffect.Parameters["cubeTexture"].SetValue(RTCube);
                    PEffect.CurrentTechnique = PEffect.Techniques["Particles"];
                    PEffect.CurrentTechnique.Passes[0].Apply();

                    device.SetVertexBuffer(vertexBuffer[x]);
                    device.Indices = indexBuffer;
                    device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, MaxParticl * 4, 0, MaxParticl * 2);
                }
            }*/
        }
 /// <summary>
 /// Отрисовать с тенями
 /// </summary>
 /// <param name="device"></param>
 /// <param name="TimeMili"></param>
 /// <param name="Camera"></param>
 /// <param name="LightDirection"></param>
 /// <param name="LightColor"></param>
 /// <param name="S_WVP"></param>
 /// <param name="SplitDistances"></param>
 public void DrawPSSM(Device device, float TimeMili, EEDCamera Camera, Vector3 LightDirection, Vector3 LightColor, Matrix[] S_WVP, float[] SplitDistances)
 {
     Matrix Transform = Conversion.ToMatrix(Transformation * DMatrix.CreateTranslation(-Camera.position));
     MMC.DrawSplitShadows(TimeMili, Transform, Camera.viewProjectionMatrix, -LightDirection, LightColor, S_WVP, SplitDistances);
 }