D:/guillaume/guillara/3D/DXGfx/Backup/DXGfxLib/EffectGroup.cs

Go to the documentation of this file.

//BSD License  
//DXGfx® - http://www.eteractions.com
//Copyright (c) 2005
//by Guillaume Randon
//Permission is hereby granted, free of charge, to any person obtaining a copy of this software
//and associated documentation files (the "Software"), to deal in the Software without restriction,
//including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
//and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
//subject to the following conditions:
//The above copyright notice and this permission notice shall be included in all copies or substantial
//portions of the Software.
//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
//INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE 
//AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
//DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
using System.IO;
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;
using Microsoft.Samples.DirectX.UtilityToolkit;

namespace DXGfxLib
{
    public enum EffectCategory
    {
        RenderScene,
        RenderLight,
        RenderEnvMap
    }

    public class EffectGroup : IComparable, IDisposable
    {
        protected Effect renderScene = null;

        public Effect RenderScene
        {
            get { return renderScene; }
        }

        public Effect Default
        {
            get { return renderScene; }
        }

        protected string renderSceneEffectFile = "";

        public string RenderSceneEffectFile
        {
            get { return renderSceneEffectFile; }
        }

        public string DefaultFile
        {
            get { return renderSceneEffectFile; }
        }

        public string EffectGroupName
        {
            get { return renderSceneEffectFile; }
        }

        protected Effect renderLight = null;

        public Effect RenderLight
        {
            get { return renderLight; }
        }

        protected string renderLightEffectFile = "";

        public string RenderLightEffectFile
        {
            get { return renderLightEffectFile; }
        }

        protected Effect renderEnvMap = null;

        public Effect RenderEnvMap
        {
            get { return renderEnvMap; }
        }

        protected string renderEnvMapEffectFile = "";

        public string RenderEnvMapEffectFile
        {
            get { return renderEnvMapEffectFile; }
        }

        public void Dispose()
        {
            if (renderScene != null)
            {
                renderScene.Dispose();
            }
            if (renderLight != null)
            {
                renderLight.Dispose();
            }
            if (renderEnvMap != null)
            {
                renderEnvMap.Dispose();
            }
        }

        public void Set(Device d3ddevice, string fileName)
        {
            Set(d3ddevice, fileName, EffectCategory.RenderScene);
        }

        public void Set(Device d3ddevice, string fileName, EffectCategory category)
        {
            if (!File.Exists(fileName))
            {
                // Let's try to found it
                fileName = Utility.FindMediaFile(StringUtil.GetName(fileName));
            }

            string strErr = "No Problem!";
            Effect effect = null;
            String effectFileName = "";

            try
            {
                effect = ResourceCache.GetGlobalInstance().CreateEffectFromFile(d3ddevice, fileName, null, null, ShaderFlags.None, null, out strErr);
                effect.Technique = "Default";
                effectFileName = fileName;
            }
            catch (Exception ex)
            {
                Trace.WriteLine(strErr);
                throw new EffectException("Exception while creating effect", fileName, strErr, ex);
            }

            switch (category)
            {
                case EffectCategory.RenderScene:
                    renderScene = effect;
                    renderSceneEffectFile = effectFileName;
                    break;
                case EffectCategory.RenderLight:
                    renderLight = effect;
                    renderLightEffectFile = effectFileName;
                    break;
                case EffectCategory.RenderEnvMap:
                    renderEnvMap = effect;
                    renderEnvMapEffectFile = effectFileName;
                    break;
            }
        }

        public void Set(Effect effect, string fileName)
        {
            Set(effect, fileName, EffectCategory.RenderScene);
        }

        public void Set(Effect effect, string fileName, EffectCategory category)
        {
            if (effect.Technique == string.Empty)
            {
                effect.Technique = "Default";
            }

            switch (category)
            {
                case EffectCategory.RenderScene:
                    renderScene = effect;
                    renderSceneEffectFile = fileName;
                    break;
                case EffectCategory.RenderLight:
                    renderLight = effect;
                    renderLightEffectFile = fileName;
                    break;
                case EffectCategory.RenderEnvMap:
                    renderEnvMap = effect;
                    renderEnvMapEffectFile = fileName;
                    break;
            }
        }

        public int CompareTo(Object obj)
        {
            int ret = 1;
            EffectGroup effectGroup = obj as EffectGroup;

            if (effectGroup != null)
            {
                ret = renderSceneEffectFile.CompareTo(effectGroup.RenderSceneEffectFile);
            }
            return ret;
        }

        public int CompareTo(EffectGroup effectGroup)
        {
            return renderSceneEffectFile.CompareTo(effectGroup.RenderSceneEffectFile);
        }
    }
}

---