Пример #1
0
        public override void Render(GraphicsPipeline gPipeline)
        {
            gDevice.RenderState.Lighting = false;
            gPipeline.BeginScene();

            // just draw bounding box for now
            //NuGenRenderCore.Rendering.BoundingBox.DrawWireframe(gDevice, bBox, Color.DarkRed.ToArgb());

            // draw geometry
            if (geom != null)
            {
                geom.UseDiffuseTexture = ((GeometryVisLayer)devIf.LocalSettings["GeometryVisLayer.Diffuse"]).Enabled;

                ShaderInterface shader = null;

                /*if ((bool)devIf.LocalSettings["GeometryVis.HeightShadingEnabled"])
                 * {
                 *  shader = hClrShader;
                 *  shader.Effect.SetValue("MinHeight", -0.5f);
                 *  shader.Effect.SetValue("HeightScale", 1f);
                 *  shader.Effect.SetValue("HeightClr", ColorValue.FromColor((Color)devIf.LocalSettings["GeometryVis.HeightShadingClr"]));
                 * }
                 * else if (((GeometryVisLayer)devIf.LocalSettings["GeometryVisLayer.Overlay"]).Enabled)
                 * {
                 *  shader = defaultShader;
                 *  shader.Effect.SetValue("OverlayTexture", overlayTexRz.Texture);
                 * }*/
                shader = sm3Shader;

                if (shader != null)
                {
                    gPipeline.ShaderIf      = shader;
                    gPipeline.ShaderEnabled = true;

                    /*shader.Effect.Begin(FX.None);
                     * shader.Effect.BeginPass(0);*/

                    geom.Render(gPipeline);

                    /*shader.Effect.EndPass();
                     * shader.Effect.End();*/

                    gPipeline.ShaderEnabled = false;
                }
                else
                {
                    geom.Render(gPipeline);
                }

                //gDevice.SetTexture(1, null);
            }

            /*gDevice.VertexFormat = CustomVertex.PositionColored.Format;
             * gDevice.DrawUserPrimitives(PrimitiveType.TriangleStrip, 2, clipBottomSideQuad);*/

            gPipeline.EndScene();
        }
Пример #2
0
        public override void Init(DeviceInterface devIf, SceneManager sManager)
        {
            base.Init(devIf, sManager);

            BuildGeometry();

            axisHelper.Init(devIf, sManager);
            rotAxisHelper.Init(devIf, sManager);

            List <ISharableResource> shared = new List <ISharableResource>();

            overlayTexRz = (TextureResource)devIf.GetSharedResource("file://media/ui/vis/overlay-1s.png", ref shared);

            ShaderHLSL shader;

            if (gProfile.SupportsShaderOverlay)
            {
                shader = new ShaderHLSL(gDevice, devIf.LocalSettings["Base.Path"] + @"shaders\cpu_dem.fx");
                shader.Effect.Technique = shader.Effect.GetTechnique("LitTextured");
                defaultShader           = new ShaderInterface(shader);
            }

            /*shader = new ShaderHLSL(gDevice, devIf.LocalSettings["Base.Path"] + @"shaders\cpu_dem_hClr.fx");
             * shader.Effect.Technique = shader.Effect.GetTechnique("CPU_DEM_HeightClr");
             * hClrShader = new ShaderInterface(shader);*/

            shader = new ShaderHLSL(gDevice, devIf.LocalSettings["Base.Path"] + @"shaders\gpu_dem.fx");
            shader.Effect.Technique = shader.Effect.GetTechnique("Basic");
            sm3Shader = new ShaderInterface(shader);

            /*Shape shape = ShapeContentLoader.LoadShape(gDevice, NuGenDEMVis.Properties.Resource1.VerticalPointer_Shape);
             * pointerEntity = new VerticalPointerEntity(shape, rDb.Layers[0], maxDataValue);
             * pointerEntity.Init(devIf, sManager);
             * sManager.AddEntity(pointerEntity);*/

            /*axisHelper.Init(devIf, sManager);
             * sManager.AddEntity(axisHelper);
             *
             * SetChildren(new IWorldEntity[] { axisHelper, pointerEntity });*/

            //geom.RebuildDiffuseTextures(new HeightMapDEMSampler());
        }
Пример #3
0
        public override void Render(GraphicsPipeline gPipe)
        {
            // draw visible tree
            if (geomPlaneVerts != null)
            {
                gDevice.RenderState.Lighting = false;
                gDevice.SetTexture(0, null);

                ShaderInterface shader = gPipe.ShaderIf;

                foreach (GpuDemSubGeometry subGeom in geometryTree)
                {
                    //if (subGeom.Level != 2 || subGeom.Code == 60)
                    //    continue;
                    gPipe.Push();

                    shader.Effect.Technique = shader.Effect.GetTechnique("Basic");
                    shader.Effect.Begin(FX.None);
                    shader.Effect.BeginPass(0);

                    // draw main chunks - i.e. the middles
                    gDevice.Indices = geomPlaneIndices;
                    gDevice.SetStreamSource(0, geomPlaneVerts, 0);

                    gDevice.VertexFormat = CustomVertex.PositionTextured.Format;

                    gPipe.ShaderIf.Effect.SetValue("dem_level", subGeom.Level);
                    gPipe.ShaderIf.Effect.SetValue("DiffuseTexture", texturesCache[subGeom.Code].Heights);
                    gPipe.ShaderIf.Effect.SetValue("NormalMapTexture", texturesCache[subGeom.Code].Normals);

                    gPipe.WorldMatrix = Matrix.Scaling(new Vector3(subGeom.Dimensions.X, 1, subGeom.Dimensions.Y)) *
                                        Matrix.Translation(new Vector3(subGeom.Position.X, 0, subGeom.Position.Y)) *
                                        gPipe.WorldMatrix;

                    gDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, 14 * 14, 0, 13 * 13 * 2);

                    // draw any non-blending patches - i.e. fill the gaps
                    //gDevice.VertexFormat = PlaneHelper.PatchVertex.Format;
                    gDevice.VertexFormat = CustomVertex.PositionColoredTextured.Format;
                    gDevice.SetStreamSource(0, geomPatchVerts, 0);
                    gDevice.Indices = geomPatchIndices;

                    if (subGeom.SideCodes[3] == ulong.MaxValue)
                    {
                        gDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, (16 * 4) /* + 2*/, 0, 16 * 2, 3 * 15 * 2, 15 * 2);
                    }
                    if (subGeom.SideCodes[2] == ulong.MaxValue)
                    {
                        gDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, (16 * 6) /* + 2*/, 0, 16 * 2, 3 * 15 * 2, 15 * 2);
                    }
                    if (subGeom.SideCodes[0] == ulong.MaxValue)
                    {
                        gDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, /*2*/ 0, 0, 16 * 2, 0, 15 * 2);
                    }
                    if (subGeom.SideCodes[1] == ulong.MaxValue)
                    {
                        gDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, (16 * 2) /* + 2*/, 0, 16 * 2, 0, 15 * 2);
                    }

                    shader.Effect.EndPass();
                    shader.Effect.End();

                    // draw patches required
                    if (subGeom.SideCodes[3] != ulong.MaxValue)
                    {
                        CachedTexture tex = texturesCache[subGeom.SideCodes[3]];
                        gPipe.ShaderIf.Effect.SetValue("NextLevelHeightTexture", tex.Heights);
                        if (tex.Level == subGeom.Level)
                        {
                            shader.Effect.Technique = shader.Effect.GetTechnique("Basic_Patch_Int");
                            shader.Effect.Begin(FX.None);
                            shader.Effect.BeginPass(0);
                        }
                        else
                        {
                            if (subGeom.ChildNum == 1)
                            {
                                shader.Effect.Technique = shader.Effect.GetTechnique("Basic_Patch_Inv");
                                shader.Effect.Begin(FX.None);
                                shader.Effect.BeginPass(0);

                                gPipe.ShaderIf.Effect.SetValue("shift", 0.5f);
                                gPipe.ShaderIf.Effect.SetValue("scale", 0.5f);
                            }
                            else
                            {
                                shader.Effect.Technique = shader.Effect.GetTechnique("Basic_Patch");
                                shader.Effect.Begin(FX.None);
                                shader.Effect.BeginPass(0);

                                gPipe.ShaderIf.Effect.SetValue("shift", 0);
                                gPipe.ShaderIf.Effect.SetValue("scale", 0.5f);
                            }
                        }
                        gPipe.ShaderIf.Effect.SetValue("NormalMapTexture", texturesCache[subGeom.Code].Normals);
                        gPipe.ShaderIf.Effect.SetValue("axis", 0);
                        gPipe.ShaderIf.Effect.CommitChanges();

                        gDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, (16 * 4) + 2, 0, 16 * 2, 3 * 15 * 2, 13 * 2);

                        shader.Effect.EndPass();
                        shader.Effect.End();
                    }
                    if (subGeom.SideCodes[2] != ulong.MaxValue)
                    {
                        CachedTexture tex = texturesCache[subGeom.SideCodes[2]];
                        gPipe.ShaderIf.Effect.SetValue("NextLevelHeightTexture", tex.Heights);
                        if (tex.Level == subGeom.Level)
                        {
                            shader.Effect.Technique = shader.Effect.GetTechnique("Basic_Patch_Int");
                            shader.Effect.Begin(FX.None);
                            shader.Effect.BeginPass(0);
                        }
                        else
                        {
                            if (subGeom.ChildNum == 3)
                            {
                                shader.Effect.Technique = shader.Effect.GetTechnique("Basic_Patch_Inv");
                                shader.Effect.Begin(FX.None);
                                shader.Effect.BeginPass(0);

                                gPipe.ShaderIf.Effect.SetValue("shift", 0.5f);
                                gPipe.ShaderIf.Effect.SetValue("scale", 0.5f);
                            }
                            else
                            {
                                shader.Effect.Technique = shader.Effect.GetTechnique("Basic_Patch");
                                shader.Effect.Begin(FX.None);
                                shader.Effect.BeginPass(0);

                                gPipe.ShaderIf.Effect.SetValue("shift", 0);
                                gPipe.ShaderIf.Effect.SetValue("scale", 0.5f);
                            }
                        }
                        gPipe.ShaderIf.Effect.SetValue("NormalMapTexture", texturesCache[subGeom.Code].Normals);
                        gPipe.ShaderIf.Effect.SetValue("axis", 0);
                        gPipe.ShaderIf.Effect.CommitChanges();

                        gDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, (16 * 6) + 2, 0, 16 * 2, 3 * 15 * 2, 13 * 2);

                        shader.Effect.EndPass();
                        shader.Effect.End();
                    }
                    if (subGeom.SideCodes[0] != ulong.MaxValue)
                    {
                        CachedTexture tex = texturesCache[subGeom.SideCodes[0]];
                        gPipe.ShaderIf.Effect.SetValue("NextLevelHeightTexture", tex.Heights);
                        if (tex.Level == subGeom.Level)
                        {
                            shader.Effect.Technique = shader.Effect.GetTechnique("Basic_Patch_Int");
                            shader.Effect.Begin(FX.None);
                            shader.Effect.BeginPass(0);
                        }
                        else
                        {
                            if (subGeom.ChildNum == 2)
                            {
                                shader.Effect.Technique = shader.Effect.GetTechnique("Basic_Patch_Inv");
                                shader.Effect.Begin(FX.None);
                                shader.Effect.BeginPass(0);

                                gPipe.ShaderIf.Effect.SetValue("shift", 0.5f);
                                gPipe.ShaderIf.Effect.SetValue("scale", 0.5f);
                            }
                            else
                            {
                                shader.Effect.Technique = shader.Effect.GetTechnique("Basic_Patch");
                                shader.Effect.Begin(FX.None);
                                shader.Effect.BeginPass(0);

                                gPipe.ShaderIf.Effect.SetValue("shift", 0);
                                gPipe.ShaderIf.Effect.SetValue("scale", 0.5f);
                            }
                        }
                        gPipe.ShaderIf.Effect.SetValue("NormalMapTexture", texturesCache[subGeom.Code].Normals);
                        gPipe.ShaderIf.Effect.SetValue("axis", 1);
                        gPipe.ShaderIf.Effect.CommitChanges();

                        gDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 2, 0, 16 * 2, 0, 13 * 2);

                        shader.Effect.EndPass();
                        shader.Effect.End();
                    }
                    if (subGeom.SideCodes[1] != ulong.MaxValue)
                    {
                        CachedTexture tex = texturesCache[subGeom.SideCodes[1]];
                        gPipe.ShaderIf.Effect.SetValue("NextLevelHeightTexture", tex.Heights);
                        if (tex.Level == subGeom.Level)
                        {
                            shader.Effect.Technique = shader.Effect.GetTechnique("Basic_Patch_Int");
                            shader.Effect.Begin(FX.None);
                            shader.Effect.BeginPass(0);
                        }
                        else
                        {
                            if (subGeom.ChildNum == 0)
                            {
                                shader.Effect.Technique = shader.Effect.GetTechnique("Basic_Patch_Inv");
                                shader.Effect.Begin(FX.None);
                                shader.Effect.BeginPass(0);

                                gPipe.ShaderIf.Effect.SetValue("shift", 0.5f);
                                gPipe.ShaderIf.Effect.SetValue("scale", 0.5f);
                            }
                            else
                            {
                                shader.Effect.Technique = shader.Effect.GetTechnique("Basic_Patch");
                                shader.Effect.Begin(FX.None);
                                shader.Effect.BeginPass(0);

                                gPipe.ShaderIf.Effect.SetValue("shift", 0);
                                gPipe.ShaderIf.Effect.SetValue("scale", 0.5f);
                            }
                        }
                        gPipe.ShaderIf.Effect.SetValue("NormalMapTexture", texturesCache[subGeom.Code].Normals);
                        gPipe.ShaderIf.Effect.SetValue("axis", 1);
                        gPipe.ShaderIf.Effect.CommitChanges();

                        gDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, (16 * 2) + 2, 0, 16 * 2, 0, 13 * 2);

                        shader.Effect.EndPass();
                        shader.Effect.End();
                    }

                    //TextureLoader.Save("c:/" + subGeom.Code + ".jpg", ImageFileFormat.Jpg, texturesCache[subGeom.Code].Tex);

                    gPipe.Pop();
                }
            }
        }
        public override void Init(DeviceInterface devIf, SceneManager sManager)
        {
 	        base.Init(devIf, sManager);

            BuildGeometry();
            
            axisHelper.Init(devIf, sManager);
            rotAxisHelper.Init(devIf, sManager);

            List<ISharableResource> shared = new List<ISharableResource>();
            overlayTexRz = (TextureResource)devIf.GetSharedResource("file://media/ui/vis/overlay-1s.png", ref shared);

            ShaderHLSL shader;
            if (gProfile.SupportsShaderOverlay)
            {
                shader = new ShaderHLSL(gDevice, devIf.LocalSettings["Base.Path"] + @"shaders\cpu_dem.fx");
                shader.Effect.Technique = shader.Effect.GetTechnique("LitTextured");
                defaultShader = new ShaderInterface(shader);
            }
            /*shader = new ShaderHLSL(gDevice, devIf.LocalSettings["Base.Path"] + @"shaders\cpu_dem_hClr.fx");
            shader.Effect.Technique = shader.Effect.GetTechnique("CPU_DEM_HeightClr");
            hClrShader = new ShaderInterface(shader);*/

            shader = new ShaderHLSL(gDevice, devIf.LocalSettings["Base.Path"] + @"shaders\gpu_dem.fx");
            shader.Effect.Technique = shader.Effect.GetTechnique("Basic");
            sm3Shader = new ShaderInterface(shader);
            
            /*Shape shape = ShapeContentLoader.LoadShape(gDevice, NuGenDEMVis.Properties.Resource1.VerticalPointer_Shape);
            pointerEntity = new VerticalPointerEntity(shape, rDb.Layers[0], maxDataValue);
            pointerEntity.Init(devIf, sManager);
            sManager.AddEntity(pointerEntity);*/

            /*axisHelper.Init(devIf, sManager);
            sManager.AddEntity(axisHelper);

            SetChildren(new IWorldEntity[] { axisHelper, pointerEntity });*/

            //geom.RebuildDiffuseTextures(new HeightMapDEMSampler());
        }