public RenderObject(Model9 model, Entity entity, string metaName, string technique)
 {
     Model = model;
     Entity = entity;
     MetaName = metaName;
     Technique = technique;
 }
        public string GetSplatTechniqueExtention(Model9 model, Settings settings)
        {
            bool splat1 = false;
            bool splat2 = false;

            if (model.MaterialTexture[0] != null || model.MaterialTexture[1] != null || model.MaterialTexture[2] != null || model.MaterialTexture[3] != null)
                splat1 = true;

            if (model.MaterialTexture[4] != null || model.MaterialTexture[5] != null || model.MaterialTexture[6] != null || model.MaterialTexture[7] != null)
                splat2 = true;

            string techniqueExtention = "";

            if (splat1)
                techniqueExtention += "Splat1";
            else
                techniqueExtention += "NoSplat1";

            if (splat2)
                techniqueExtention += "Splat2";
            else
                techniqueExtention += "NoSplat2";

            if (settings.TerrainQuality == Settings.TerrainQualities.Low)
                return techniqueExtention + "Lowest";
            else
                return techniqueExtention + "NoLowest";
        }
        void RenderModelWithEffect(Graphics.Content.Model9 model, SlimDX.Matrix world, Matrix viewProjection, Matrix halfPixelOffset,
                                   Graphics.Content.MetaResource <Graphics.Content.Model9, Graphics.Content.Model10> metaResource)
        {
            if (model == null)
            {
                return;
            }

            interfaceRenderer9Effect.SetTexture(EHTexture, model.Texture);
            //StateManager.SetTexture(0, model.Texture);

            //Device.SetSamplerState(4, SamplerState.MagFilter, TextureFilter.Anisotropic);
            //e.Scale = new Vector3((int)e.Scale.X, (int)e.Scale.Y, (int)e.Scale.Z);

            var g = metaResource as Graphics.Content.Graphic;

            if (g != null)
            {
                world = Matrix.Translation(g.Position) * world;
                //world = world * halfPixelOffset;
                world.M41 = (float)((int)world.M41) - 0.5f;
                world.M42 = (float)((int)world.M42) - 0.5f;
                StateManager.SetSamplerState(0, SamplerState.AddressU, g.TextureAdressMode);
                StateManager.SetSamplerState(0, SamplerState.AddressV, g.TextureAdressMode);
                interfaceRenderer9Effect.SetValue(EHOpacity, g.Alpha);
            }
            else
            {
                world = ((Graphics.Content.MetaModel)metaResource).World * world;

                StateManager.SetSamplerState(0, SamplerState.AddressU, TextureAddress.Clamp);
                StateManager.SetSamplerState(0, SamplerState.AddressV, TextureAddress.Clamp);

                interfaceRenderer9Effect.SetValue(EHOpacity, 1);
            }
            //Forces

            if (model.XMesh != null)
            {
                interfaceRenderer9Effect.SetValue(EHWorldViewProjection,
                                                  world * Scene.Camera.View * Matrix.PerspectiveFovLH(((LookatCamera)Scene.Camera).FOV, ((LookatCamera)Scene.Camera).AspectRatio, 1, 50));
            }
            else
            {
                interfaceRenderer9Effect.SetValue(EHWorldViewProjection, world * viewProjection);
            }
            interfaceRenderer9Effect.CommitChanges();
            //device.SetTransform(TransformState.World, world);
            if (model.Mesh != null)
            {
                model.Mesh.Draw(device);
                intermediateTrianglesPerFrame += model.Mesh.NFaces;
            }
            else if (model.XMesh != null)
            {
                model.XMesh.DrawSubset(0);
                intermediateTrianglesPerFrame += model.XMesh.FaceCount;
            }
        }
 public override void Release(MetaT metaResource, ContentPool content, Model9 resource)
 {
     if (resource.Mesh != null)
     {
         content.Release(resource.Mesh);
     }
     content.Release(resource.Texture);
 }
            public override Model9 Construct(MetaT metaResource, ContentPool content)
            {
                var    glyphs = metaResource.BuildGlyphs();
                Model9 m      = new Model9
                {
                    Texture = content.Acquire <SlimDX.Direct3D9.Texture>(metaResource.Texture),
                    Mesh    = content.Acquire <Mesh9>(new MeshConcretize {
                        MetaMesh = glyphs, Layout = Software.Vertex.PositionTexcoord.Instance
                    })
                };

                return(m);
            }
 public void Insert(Model9 model, Entity entity, MetaModel metaModel, string metaName, SkinnedMesh skinnedMesh, SlimDX.Direct3D9.Mesh mesh, bool halfSkinned)
 {
     if (skinnedMesh != null)
     {
         RenderSkinnedMesh sm;
         if (!SkinnedMeshes.TryGetValue(skinnedMesh, out sm))
             SkinnedMeshes[skinnedMesh] = sm = new RenderSkinnedMesh();
         sm.Insert(model, entity, metaModel, metaName);
     }
     else if (mesh != null)
     {
         RenderMesh m;
         if (!Meshes.TryGetValue(mesh, out m))
             Meshes[mesh] = m = new RenderMesh(mesh.IndexBuffer, mesh.VertexBuffer);
         m.Insert(model, entity, metaModel, metaName);
     }
 }
        void RenderModel(Graphics.Content.Model9 model, SlimDX.Matrix world, Matrix halfPixelOffset,
                         Graphics.Content.MetaResource <Graphics.Content.Model9, Graphics.Content.Model10> metaResource)
        {
            if (model == null)
            {
                return;
            }

            var device = Scene.View.Device9;

            StateManager.SetTexture(0, model.Texture);

            //Device.SetSamplerState(4, SamplerState.MagFilter, TextureFilter.Anisotropic);
            //e.Scale = new Vector3((int)e.Scale.X, (int)e.Scale.Y, (int)e.Scale.Z);

            var g = metaResource as Graphics.Content.Graphic;

            if (g != null)
            {
                world = Matrix.Translation(g.Position) * world;
                //world = world * halfPixelOffset;
                world.M41 = (float)((int)world.M41) - 0.5f;
                world.M42 = (float)((int)world.M42) - 0.5f;
                StateManager.SetSamplerState(0, SamplerState.AddressU, g.TextureAdressMode);
                StateManager.SetSamplerState(0, SamplerState.AddressV, g.TextureAdressMode);
            }
            else
            {
                world = ((Graphics.Content.MetaModel)metaResource).World * world;

                StateManager.SetSamplerState(0, SamplerState.AddressU, TextureAddress.Clamp);
                StateManager.SetSamplerState(0, SamplerState.AddressV, TextureAddress.Clamp);
            }
            device.SetTransform(TransformState.World, world);
            if (model.Mesh != null)
            {
                model.Mesh.Draw(device);
                intermediateTrianglesPerFrame += model.Mesh.NFaces;
            }
            else if (model.XMesh != null)
            {
                model.XMesh.DrawSubset(0);
                intermediateTrianglesPerFrame += model.XMesh.FaceCount;
            }
        }
 public void Insert(Model9 model, Entity e, MetaModel metaModel, string metaName)
 {
     RenderObjects.Add(new Common.Tuple<Model9, Entity, string>(model, e, metaName));
 }
        public void Insert(Model9 model, Entity entity, MetaModel metaModel, string metaName, Settings settings)
        {
            //if (!IsVisible(metaModel, settings)) return;

            string techniqueNameEnding = Renderer.GetTechniqueNameExtension(metaModel, settings, techniqueNames);

            if (metaModel.HasAlpha)
            {
                //Renderer.totalAddedItems++;
                AlphaObjects.Add(new Common.Tuple<Model9, Entity, string, string>(model, entity, metaName, techniqueNameEnding));
            }
            else if (metaModel.SplatMapped)
            {
                //Renderer.totalAddedItems++;

                string techniqueName = "";
                techniqueName = "Standard" + Renderer.GetTechniqueNameExtension(metaModel, settings, techniqueNames);
                techniqueName += GetSplatTechniqueExtention(model, settings);

                RenderSplatMesh r;
                if (!SplatTechniques.TryGetValue(techniqueName, out r))
                    SplatTechniques[techniqueName] = r = new RenderSplatMesh();
                r.Insert(model, entity, metaModel, metaName);
                if(entity.Scene.DesignMode)
                    SplatObjects.Add(new Common.Tuple<Model9, Entity, string>(model, entity, metaName));
            }
            else if (metaModel.SkinnedMesh != null)
            {
                foreach (var SM in model.SkinnedMesh.MeshContainers)
                {
                    if (SM.Second.SkinInfo != null)
                    {
                        //Renderer.totalAddedItems++;
                        string techniqueName = "SkinnedMesh" + techniqueNameEnding;

                        RenderTechnique r;
                        if (!Techniques.TryGetValue(techniqueName, out r))
                            Techniques[techniqueName] = r = new RenderTechnique();
                        r.Insert(model, entity, metaModel, metaName, model.SkinnedMesh, null, false);
                    }
                    else
                    {
                        //Renderer.totalAddedItems++;

                        RenderTechnique r;
                        if (!Techniques.TryGetValue("ShadowedSceneInstanced" + techniqueNameEnding, out r))
                            Techniques["ShadowedSceneInstanced" + techniqueNameEnding] = r = new RenderTechnique();
                        r.Insert(model, entity, metaModel, metaName, null, SM.Second.MeshData.Mesh, true);
                    }
                }
            }
            else if (metaModel.XMesh != null)
            {
                //Renderer.totalAddedItems++;

                RenderTechnique r;
                if (!Techniques.TryGetValue("ShadowedSceneInstanced" + techniqueNameEnding, out r))
                    Techniques["ShadowedSceneInstanced" + techniqueNameEnding] = r = new RenderTechnique();
                r.Insert(model, entity, metaModel, metaName, null, model.XMesh, false);
            }
        }
        public void Remove(Entity entity, MetaResource<Model9, Model10> metaResource, Model9 model, string metaName)
        {
            MetaModel metaModel = (MetaModel)metaResource;
            if (metaModel.HasAlpha)
            {
                RenderRoot.AlphaObjects.Remove(new Common.Tuple<Model9, Entity, string, string>(model, entity, metaName, GetTechniqueNameExtension(metaModel, Settings, techniqueNames)));

            #if LOG_RENDERTREE
                //renderTreeLogFile.WriteLine("R | Alpha");
                totalRemovedItems++;
            #endif
            }
            else if (metaModel.SplatMapped)
            {
                if(entity.Scene.DesignMode)
                    RenderRoot.SplatObjects.Remove(new Common.Tuple<Model9, Entity, string>(model, entity, metaName));

                RenderRoot.SplatTechniques["Standard" + GetTechniqueNameExtension(metaModel, Settings, techniqueNames) + RenderRoot.GetSplatTechniqueExtention(model, Settings)].TextureCombinations[new SplatTextureCombination { BaseTexture = model.BaseTexture, MaterialTexture = model.MaterialTexture, SplatTexture = model.SplatTexture }].RenderObjects.Remove(new Common.Tuple<Model9,Entity,string>(model, entity, metaName));
            #if LOG_RENDERTREE
                //renderTreeLogFile.WriteLine("R | Splat");
                totalRemovedItems++;
            #endif
            }
            else if (model.SkinnedMesh != null)
            {
                foreach (Common.Tuple<CustomFrame, CustomMeshContainer> meshContainer in model.SkinnedMesh.MeshContainers)
                {
                    if (meshContainer.Second.SkinInfo != null)
                    {
                        string tmp = "SkinnedMesh" + GetTechniqueNameExtension(metaModel, Settings, techniqueNames);

                        RenderRoot.Techniques[tmp].SkinnedMeshes[model.SkinnedMesh].Textures[model.Texture].RenderObjects.Remove(new Common.Tuple<Model9, Entity, string>(model, entity, metaName));

                        if (RenderRoot.Techniques[tmp].SkinnedMeshes[model.SkinnedMesh].Textures[model.Texture].RenderObjects.Count == 0)
                            RenderRoot.Techniques[tmp].SkinnedMeshes[model.SkinnedMesh].Textures.Remove(model.Texture);

            #if LOG_RENDERTREE
                        //renderTreeLogFile.WriteLine("R | SkinnedMesh");
                        totalRemovedItems++;
            #endif
                    }
                    else
                    {
            #if LOG_RENDERTREE
                        //renderTreeLogFile.WriteLine("R | Mesh");
                        totalRemovedItems++;
            #endif
                        string tmp = "ShadowedSceneInstanced" + GetTechniqueNameExtension(metaModel, Settings, techniqueNames);

            #if DEBUG_RENDERER
                        RenderRoot.Techniques[tmp].Meshes[meshContainer.Second.MeshData.Mesh].Textures[model.Texture].RenderObjects.Remove(new Common.Tuple<Model9, Entity, string>(model, entity, metaName));

                        if (RenderRoot.Techniques[tmp].Meshes[meshContainer.Second.MeshData.Mesh].Textures[model.Texture].RenderObjects.Count == 0)
                            RenderRoot.Techniques[tmp].Meshes[meshContainer.Second.MeshData.Mesh].Textures.Remove(model.Texture);
            #else
                        if (!model.SkinnedMesh.MeshContainers[0].Second.OriginalMesh.Disposed)
                            RenderRoot.Techniques[tmp].Meshes[meshContainer.Second.MeshData.Mesh].Textures[model.Texture].RenderObjects.Remove(new Common.Tuple<Model9, Entity, string>(model, entity, metaName));

                        if (meshContainer.Second.MeshData != null)
                            if (RenderRoot.Techniques[tmp].Meshes[meshContainer.Second.MeshData.Mesh].Textures[model.Texture].RenderObjects.Count == 0)
                                RenderRoot.Techniques[tmp].Meshes[meshContainer.Second.MeshData.Mesh].Textures.Remove(model.Texture);
            #endif
                    }
                }

                //RenderRoot.skinnedMeshes[model.SkinnedMesh].textures[model.Texture].RenderObjects.Remove(new Common.Tuple<Model9, Entity, string>(model, entity, metaName));
            }
            else if (model.XMesh != null)
            {
                string tmp = "ShadowedSceneInstanced" + GetTechniqueNameExtension(metaModel, Settings, techniqueNames);

                RenderRoot.Techniques[tmp].Meshes[model.XMesh].Textures[model.Texture].RenderObjects.Remove(new Common.Tuple<Model9, Entity, string>(model, entity, metaName));

                if (RenderRoot.Techniques[tmp].Meshes[model.XMesh].Textures[model.Texture].RenderObjects.Count == 0)
                    RenderRoot.Techniques[tmp].Meshes[model.XMesh].Textures.Remove(model.Texture);

                //RenderRoot.meshes[model.XMesh].textures[model.Texture].RenderObjects.Remove(new Common.Tuple<Model9, Entity, string>(model, entity, metaName));
            #if LOG_RENDERTREE
                //renderTreeLogFile.WriteLine("R | XMesh");
                totalRemovedItems++;
            #endif
            }
            if (!releaseWarningAdded)
            {
                releaseWarningAdded = true;
                Common.ProgramConfigurationInformation.AddWarning(new Common.ProgramConfigurationWarning
                {
                    Text = "RENDERER_RELEASE",
                    Type = Common.ProgramConfigurationWarningType.Performance | Common.ProgramConfigurationWarningType.Stability,
                    Importance = Common.Importance.Critical,
                    Description = "Content release is commented out in the renderer"
                });
            }
        }
 public void Add(Entity entity, MetaResource<Model9, Model10> metaResource, Model9 model, string metaName)
 {
     if (RenderRoot != null)
     {
         RenderRoot.Insert(model, entity, (MetaModel)((MetaModel)metaResource).Clone(), metaName, Settings);
     }
     else
         throw new Exception("Renderer needs initialization.");
 }