Esempio n. 1
0
 internal static void SetTexture(this Effect effect, Texture2D texture)
 {
     if (effect is BasicEffect)
     {
         BasicEffect source = effect as BasicEffect;
         source.Texture        = texture;
         source.TextureEnabled = texture != null;
     }
     else if (effect is SkinnedEffect)
     {
         SkinnedEffect source = effect as SkinnedEffect;
         source.Texture = texture;
     }
     else if (effect is EnvironmentMapEffect)
     {
         EnvironmentMapEffect source = effect as EnvironmentMapEffect;
         source.Texture = texture;
     }
     else if (effect is DualTextureEffect)
     {
         DualTextureEffect source = effect as DualTextureEffect;
         source.Texture = texture;
     }
     else if (effect is AlphaTestEffect)
     {
         AlphaTestEffect source = effect as AlphaTestEffect;
         source.Texture = texture;
     }
 }
Esempio n. 2
0
        internal static Texture2D GetTexture(this Effect sourceEffect)
        {
            Texture2D texture = null;

            if (sourceEffect is BasicEffect)
            {
                BasicEffect source = sourceEffect as BasicEffect;
                texture = source.Texture;
            }
            else if (sourceEffect is SkinnedEffect)
            {
                SkinnedEffect source = sourceEffect as SkinnedEffect;
                texture = source.Texture;
            }
            else if (sourceEffect is EnvironmentMapEffect)
            {
                EnvironmentMapEffect source = sourceEffect as EnvironmentMapEffect;
                texture = source.Texture;
            }
            else if (sourceEffect is DualTextureEffect)
            {
                DualTextureEffect source = sourceEffect as DualTextureEffect;
                texture = source.Texture;
            }
            else if (sourceEffect is AlphaTestEffect)
            {
                AlphaTestEffect source = sourceEffect as AlphaTestEffect;
                texture = source.Texture;
            }

            return(texture);
        }
Esempio n. 3
0
        public override void LoadContent()
        {
            base.LoadContent();

            // To hacked for now
            if (!_environmentTextureLoaded && _environmentTextureNames != null)
            {
                // Detect the texture size if it doesn't specified
                if (_environmentTextureSize == 0)
                {
                    Texture2D firstTexture = YnG.Content.Load <Texture2D>(_environmentTextureNames[0]);
                    _environmentTextureSize = Math.Min(firstTexture.Width, firstTexture.Height);
                }

                // Create the environment texture
                _environmentTexture = new TextureCube(YnG.GraphicsDevice, _environmentTextureSize, _enableTextureMipmap, SurfaceFormat.Color);

                Texture2D texture = null;   // Temp texture
                Color[]   textureData;      // Temp textureData array
                string[]  tempTextureNames = new string[6];

                // If the texture array has not a size of 6, we replace empty texture by the latest
                int nbTextures = _environmentTextureNames.Length;

                for (int i = 0; i < 6; i++)
                {
                    if (i < nbTextures) // Texture
                    {
                        tempTextureNames[i] = _environmentTextureNames[i];
                    }
                    else // Copied texture
                    {
                        tempTextureNames[i] = _environmentTextureNames[nbTextures - 1];
                    }

                    // Load the texture and add it to the TextureCube
                    texture     = YnG.Content.Load <Texture2D>(tempTextureNames[i]);
                    textureData = new Color[texture.Width * texture.Height];
                    texture.GetData <Color>(textureData);
                    _environmentTexture.SetData <Color>((CubeMapFace)i, textureData);
                }

                // Update the texture names array
                _environmentTextureNames  = tempTextureNames;
                _environmentTextureLoaded = true;

                // If the first texture is null we create a dummy texture with the same size of environment texture
                if (_texture == null)
                {
                    _texture       = YnGraphics.CreateTexture(Color.White, _environmentTextureSize, _environmentTextureSize);
                    _textureLoaded = true;
                }
            }

            if (!_effectLoaded)
            {
                _effect       = new EnvironmentMapEffect(YnG.GraphicsDevice);
                _effectLoaded = true;
            }
        }
Esempio n. 4
0
        public override void Update(BaseCamera camera, ref Matrix world)
        {
            if (!_effectLoaded)
            {
                return;
            }

            // Update matrices
            base.Update(camera, ref world);

            EnvironmentMapEffect environmentMapEffect = (EnvironmentMapEffect)_effect;

            // Texture
            environmentMapEffect.Texture                = _texture;
            environmentMapEffect.EnvironmentMap         = _environmentTexture;
            environmentMapEffect.EnvironmentMapAmount   = _environmentAmount;
            environmentMapEffect.EnvironmentMapSpecular = _specularColor * _specularIntensity;
            environmentMapEffect.FresnelFactor          = _fresnelFactor;
            // Fog
            UpdateFog(environmentMapEffect);

            // Lights
            if (UpdateLights(environmentMapEffect))
            {
                environmentMapEffect.EmissiveColor = _emissiveColor;
                environmentMapEffect.DiffuseColor  = _diffuseColor * _diffuseIntensity;
                environmentMapEffect.Alpha         = _alphaColor;
            }
        }
Esempio n. 5
0
 /// <summary>
 /// Initializes this instance.
 /// </summary>
 /// <param name="ginfo"></param>
 /// <param name="factory"></param>
 /// <param name="obj"></param>
 public override void Initialize(GraphicInfo ginfo, GraphicFactory factory, IObject obj)
 {
     effect = factory.GetEnvironmentMapEffect();
     if (enableLightining)
     {
         effect.EnableDefaultLighting();
     }
     effect.EnvironmentMapAmount = amountDiffuse;
     base.Initialize(ginfo, factory, obj);
 }
Esempio n. 6
0
        public GenericEffect(Effect effectToAssimilate)
            : this()
        {
            /*
             * DefaultShaderType type = DetermineEffect( false, effectToAssimilate );
             * if( type == DefaultShaderType.Basic )
             * {
             *  mBasicEffect = (BasicEffect)effectToAssimilate;
             * }
             * else if( type == DefaultShaderType.DualTexture )
             * {
             *  mDualTextureEffect = (DualTextureEffect)effectToAssimilate;
             * }
             * else if( type == DefaultShaderType.EnvironmentMapped )
             * {
             *  mEnvironmentMapEffect = (EnvironmentMapEffect)effectToAssimilate;
             * }
             * else if( type == DefaultShaderType.Skinned )
             * {
             *  mSkinnedEffect = (SkinnedEffect)effectToAssimilate;
             * }
             */
            if (effectToAssimilate is BasicEffect)
            {
                mBasicEffect = effectToAssimilate as BasicEffect;
            }
            else if (effectToAssimilate is AlphaTestEffect)
            {
                mAlphaTestEffect = effectToAssimilate as AlphaTestEffect;
            }
#if !MONOGAME
            else if (effectToAssimilate is DualTextureEffect)
            {
                mDualTextureEffect = effectToAssimilate as DualTextureEffect;
            }
            else if (effectToAssimilate is EnvironmentMapEffect)
            {
                mEnvironmentMapEffect = effectToAssimilate as EnvironmentMapEffect;
            }
            else if (effectToAssimilate is SkinnedEffect)
            {
                mSkinnedEffect = effectToAssimilate as SkinnedEffect;
            }
#endif
        }
Esempio n. 7
0
 private void DrawModel(Model m, Matrix world, EnvironmentMapEffect be, ChaseCamera camera)
 {
     foreach (ModelMesh mm in m.Meshes)
     {
         foreach (ModelMeshPart mmp in mm.MeshParts)
         {
             be.View       = camera.View;
             be.Projection = camera.Projection;
             be.World      = world;
             ScreenManager.GraphicsDevice.SetVertexBuffer(mmp.VertexBuffer, mmp.VertexOffset);
             ScreenManager.GraphicsDevice.Indices = mmp.IndexBuffer;
             be.CurrentTechnique.Passes[0].Apply();
             ScreenManager.GraphicsDevice.DrawIndexedPrimitives(
                 PrimitiveType.TriangleList, 0, 0,
                 mmp.NumVertices, mmp.StartIndex, mmp.PrimitiveCount);
         }
     }
 }
Esempio n. 8
0
        /// <summary>
        /// Allows the game to perform any initialization it needs to before starting to run.
        /// This is where it can query for any required services and load any non-graphic
        /// related content.  Calling base.Initialize will enumerate through any components
        /// and initialize them as well.
        /// </summary>
        protected override void Initialize()
        {
            // Calculate the screen aspect ratio
            float aspectRatio = (float)GraphicsDevice.Viewport.Width / GraphicsDevice.Viewport.Height;
            // Create a projection matrix
            Matrix projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.ToRadians(45), aspectRatio, 0.1f, 1000.0f);

            // Calculate a view matrix (where we are looking from and to)
            Matrix view = Matrix.CreateLookAt(new Vector3(0, 0, 4), Vector3.Zero, Vector3.Up);

            // Create and initialize the effect
            _effect            = new EnvironmentMapEffect(GraphicsDevice);
            _effect.Projection = projection;
            _effect.View       = view;
            _effect.World      = Matrix.Identity;
            _effect.EnableDefaultLighting();

            base.Initialize();
        }
Esempio n. 9
0
        public GenericEffect(DefaultShaderType type)
            : this()
        {
            if (type != DefaultShaderType.Determine)
            {
                if (type == DefaultShaderType.Basic)
                {
                    mBasicEffect = new BasicEffect(FlatRedBallServices.GraphicsDevice);
                }

                else if (type == DefaultShaderType.AlphaTest)
                {
                    mAlphaTestEffect = new AlphaTestEffect(FlatRedBallServices.GraphicsDevice);
                }

                else if (type == DefaultShaderType.DualTexture)
                {
#if MONOGAME
                    throw new NotImplementedException();
#else
                    mDualTextureEffect = new DualTextureEffect(FlatRedBallServices.GraphicsDevice);
#endif
                }

                else if (type == DefaultShaderType.EnvironmentMapped)
                {
#if MONOGAME
                    throw new NotImplementedException();
#else
                    mEnvironmentMapEffect = new EnvironmentMapEffect(FlatRedBallServices.GraphicsDevice);
#endif
                }

                else if (type == DefaultShaderType.Skinned)
                {
#if MONOGAME
                    throw new NotImplementedException();
#else
                    mSkinnedEffect = new SkinnedEffect(FlatRedBallServices.GraphicsDevice);
#endif
                }
            }
        }
        /// <summary>
        /// Prepare a BasicEffect for rendering
        /// </summary>
        /// <param name="effect"></param>
        protected void PrepareEffect(EnvironmentMapEffect effect)
        {
            // Apply the texture if we have one and it differs from the active texture
            if (effect.Texture != ObjectTexture && ObjectTexture != null)
            {
                effect.Texture = ObjectTexture;
            }

            // Set the color and alpha
            effect.DiffuseColor  = ObjectColor.ToVector3();
            effect.EmissiveColor = EmissiveColor.ToVector3();
            effect.Alpha         = (float)ObjectColor.A / 255.0f;

            // Set other effect properties
            // Do we have a valid texture?
            if (effect.Texture != null)
            {
                // Yes, so apply the other environment map properties as normal
                effect.EnvironmentMapAmount   = EnvironmentMapAmount;
                effect.EnvironmentMapSpecular = EnvironmentMapSpecular.ToVector3();
                effect.FresnelFactor          = FresnelFactor;
            }
            else
            {
                // No, so make the object completely reflective.
                // Any texture set by other objects will remain but will be entirely hidden by the environment map
                effect.EnvironmentMapAmount   = 1.0f;
                effect.EnvironmentMapSpecular = Vector3.Zero;
                effect.FresnelFactor          = 0.0f;
            }

            // Apply the transformation matrix
            effect.World = Transformation;

            // Now the effect is ready for the derived class to actually draw the object
        }
Esempio n. 11
0
        /// <summary>
        /// Load graphics content for the game.
        /// </summary>
        public override void Activate(bool instancePreserved)
        {
            if (!instancePreserved)
            {
                if (content == null)
                {
                    content = new ContentManager(ScreenManager.Game.Services, "Content");
                }

                topViewport    = ScreenManager.GraphicsDevice.Viewport;
                bottomViewport = ScreenManager.GraphicsDevice.Viewport;

                if (ScreenManager.ScreenHorizontal == true)
                {
                    topViewport.Height    = topViewport.Height / 2;
                    bottomViewport.Height = bottomViewport.Height / 2;
                    bottomViewport.Y      = topViewport.Height;

                    camera.AspectRatio = (float)ScreenManager.GraphicsDevice.Viewport.Width /
                                         (ScreenManager.GraphicsDevice.Viewport.Height / 2);
                    camera2.AspectRatio = (float)ScreenManager.GraphicsDevice.Viewport.Width /
                                          (ScreenManager.GraphicsDevice.Viewport.Height / 2);

                    camera.FieldOfView  = MathHelper.ToRadians(45);
                    camera2.FieldOfView = MathHelper.ToRadians(45);
                }
                else
                {
                    topViewport.Width    = topViewport.Width / 2;
                    bottomViewport.Width = bottomViewport.Width / 2;
                    bottomViewport.X     = topViewport.Width;

                    camera.AspectRatio = (float)(ScreenManager.GraphicsDevice.Viewport.Width / 2) /
                                         ScreenManager.GraphicsDevice.Viewport.Height;
                    camera2.AspectRatio = (float)(ScreenManager.GraphicsDevice.Viewport.Width / 2) /
                                          ScreenManager.GraphicsDevice.Viewport.Height;

                    camera.FieldOfView  = MathHelper.ToRadians(60);
                    camera2.FieldOfView = MathHelper.ToRadians(60);
                }

                gameFont    = content.Load <SpriteFont>("gamefont");
                rockModel   = content.Load <Model>("Rock");
                shipModel   = content.Load <Model>("SpaceShip1");
                shipModel2  = content.Load <Model>("SpaceShip2");
                groundModel = content.Load <Model>("Ground");
                cubeModel   = content.Load <Model>("cube");
                bulletModel = content.Load <Model>("Cone");
                skyBoxModel = content.Load <Model>("Space_SkyBox");
                audioEngine = ScreenManager.AudioEngine;
                soundBank   = ScreenManager.SoundBank;
                waveBank    = ScreenManager.WaveBank;
                acSFX       = audioEngine.GetCategory("SFX");
                acMusic     = audioEngine.GetCategory("Music");

                // Environmental Map Effect for Player 1
                envEffect1            = new EnvironmentMapEffect(ScreenManager.GraphicsDevice);
                envEffect1.Projection = Matrix.CreatePerspectiveFieldOfView(
                    MathHelper.PiOver4, ScreenManager.GraphicsDevice.Viewport.AspectRatio, 1.0f, 100.0f);
                envEffect1.View = Matrix.CreateLookAt(
                    new Vector3(2, 3, 32), Vector3.Zero, Vector3.Up);
                textureCube1 = new TextureCube(ScreenManager.GraphicsDevice, 256, false, SurfaceFormat.Color);
                Color[] facedata1 = new Color[256 * 256];
                for (int i = 0; i < 6; i++)
                {
                    envEffect1.Texture = content.Load <Texture2D>("skybox" + i.ToString());
                    envEffect1.Texture.GetData <Color>(facedata1);
                    textureCube1.SetData <Color>((CubeMapFace)i, facedata1);
                }
                envEffect1.Texture        = (shipModel.Meshes[0].Effects[0] as EnvironmentMapEffect).Texture;
                envEffect1.EnvironmentMap = textureCube1;
                envEffect1.EnableDefaultLighting();
                envEffect1.EnvironmentMapAmount   = 1.0f;
                envEffect1.FresnelFactor          = 1.0f;
                envEffect1.EnvironmentMapSpecular = Vector3.Zero;

                // Environmental Map Effect for Player 2
                envEffect2            = new EnvironmentMapEffect(ScreenManager.GraphicsDevice);
                envEffect2.Projection = Matrix.CreatePerspectiveFieldOfView(
                    MathHelper.PiOver4, ScreenManager.GraphicsDevice.Viewport.AspectRatio, 1.0f, 100.0f);
                envEffect2.View = Matrix.CreateLookAt(
                    new Vector3(2, 3, 32), Vector3.Zero, Vector3.Up);
                textureCube2 = new TextureCube(ScreenManager.GraphicsDevice, 256, false, SurfaceFormat.Color);
                Color[] facedata2 = new Color[256 * 256];
                for (int i = 0; i < 6; i++)
                {
                    envEffect2.Texture = content.Load <Texture2D>("skybox" + i.ToString());
                    envEffect2.Texture.GetData <Color>(facedata2);
                    textureCube2.SetData <Color>((CubeMapFace)i, facedata2);
                }
                envEffect2.Texture        = (shipModel2.Meshes[0].Effects[0] as EnvironmentMapEffect).Texture;
                envEffect2.EnvironmentMap = textureCube2;
                envEffect2.EnableDefaultLighting();
                envEffect2.EnvironmentMapAmount   = 1.0f;
                envEffect2.FresnelFactor          = 1.0f;
                envEffect2.EnvironmentMapSpecular = Vector3.Zero;

                //audioEngine = ScreenManager.AudioEngine;
                //soundBank = ScreenManager.SoundBank;
                //waveBank = ScreenManager.WaveBank;

                if (ScreenManager.AudioEnabled == true)
                {
                    acSFX.SetVolume(ScreenManager.SFXVolume);
                    acMusic.SetVolume(ScreenManager.AudioVolume);
                }
                else
                {
                    acSFX.SetVolume(0);
                    acMusic.SetVolume(0);
                }

                FxCue = soundBank.GetCue("ShotFx");
                //FxCue.Apply3D(shipListen1, shipEmit1);

                ship1Pos = new Vector3(10000, 350, 10000);
                ship2Pos = new Vector3(100, 350, 100);

                // Create shiplllllllllllllllllllllllllllll
                ship  = new Ship(ScreenManager.GraphicsDevice, ship1Pos, soundBank);
                ship2 = new Ship(ScreenManager.GraphicsDevice, ship2Pos, soundBank);
                //ship2.Position = new Vector3(100, 100, 100);

                RandomRockSpawner();

                UpdateCameraChaseTarget(ship, camera);
                UpdateCameraChaseTarget(ship2, camera2);

                camera.Reset();
                camera2.Reset();

                // A real game would probably have more content than this sample, so
                // it would take longer to load. We simulate that by delaying for a
                // while, giving you a chance to admire the beautiful loading screen.
                Thread.Sleep(1000);

                // once the load has finished, we use ResetElapsedTime to tell the game's
                // timing mechanism that we have just finished a very long frame, and that
                // it should not try to catch up.
                ScreenManager.Game.ResetElapsedTime();
            }

#if WINDOWS_PHONE
            if (Microsoft.Phone.Shell.PhoneApplicationService.Current.State.ContainsKey("PlayerPosition"))
            {
                playerPosition = (Vector2)Microsoft.Phone.Shell.PhoneApplicationService.Current.State["PlayerPosition"];
                enemyPosition  = (Vector2)Microsoft.Phone.Shell.PhoneApplicationService.Current.State["EnemyPosition"];
            }
#endif
        }
Esempio n. 12
0
        internal static void CopyMaterialsFrom(this Effect effect, Effect sourceEffect)
        {
            if (effect == null || sourceEffect == null)
            {
                return;
            }

            Vector3 DiffuseColor  = Vector3.One;
            Vector3 SpecularColor = Vector3.Zero;
            Vector3 EmissiveColor = Vector3.Zero;
            float   SpecularPower = 16;
            float   Alpha         = 1;

            Texture2D Texture = sourceEffect.GetTexture();

            if (Texture != null)
            {
                effect.SetTexture(Texture);
            }

            // Extract from source
            if (sourceEffect is BasicEffect)
            {
                BasicEffect source = sourceEffect as BasicEffect;
                DiffuseColor  = source.DiffuseColor;
                EmissiveColor = source.EmissiveColor;
                SpecularColor = source.SpecularColor;
                SpecularPower = source.SpecularPower;
                Alpha         = source.Alpha;
            }
            else if (sourceEffect is SkinnedEffect)
            {
                SkinnedEffect source = sourceEffect as SkinnedEffect;
                DiffuseColor  = source.DiffuseColor;
                EmissiveColor = source.EmissiveColor;
                SpecularColor = source.SpecularColor;
                SpecularPower = source.SpecularPower;
                Alpha         = source.Alpha;
            }
            else if (sourceEffect is EnvironmentMapEffect)
            {
                EnvironmentMapEffect source = sourceEffect as EnvironmentMapEffect;
                DiffuseColor  = source.DiffuseColor;
                EmissiveColor = source.EmissiveColor;
                Alpha         = source.Alpha;
            }
            else if (sourceEffect is DualTextureEffect)
            {
                DualTextureEffect source = sourceEffect as DualTextureEffect;
                DiffuseColor = source.DiffuseColor;
                Alpha        = source.Alpha;
            }
            else if (sourceEffect is AlphaTestEffect)
            {
                AlphaTestEffect source = sourceEffect as AlphaTestEffect;
                DiffuseColor = source.DiffuseColor;
                Alpha        = source.Alpha;
            }


            // Apply to target
            if (effect is BasicEffect)
            {
                BasicEffect target = effect as BasicEffect;
                target.DiffuseColor  = DiffuseColor;
                target.EmissiveColor = EmissiveColor;
                target.SpecularColor = SpecularColor;
                target.SpecularPower = SpecularPower;
                target.Alpha         = Alpha;
            }
            else if (effect is SkinnedEffect)
            {
                SkinnedEffect target = effect as SkinnedEffect;
                target.DiffuseColor  = DiffuseColor;
                target.EmissiveColor = EmissiveColor;
                target.SpecularColor = SpecularColor;
                target.SpecularPower = SpecularPower;
                target.Alpha         = Alpha;
            }
            else if (effect is EnvironmentMapEffect)
            {
                EnvironmentMapEffect target = effect as EnvironmentMapEffect;
                target.DiffuseColor  = DiffuseColor;
                target.EmissiveColor = EmissiveColor;
                target.Alpha         = Alpha;
            }
            else if (effect is DualTextureEffect)
            {
                DualTextureEffect target = effect as DualTextureEffect;
                target.DiffuseColor = DiffuseColor;
                target.Alpha        = Alpha;
            }
            else if (effect is AlphaTestEffect)
            {
                AlphaTestEffect target = effect as AlphaTestEffect;
                target.DiffuseColor = DiffuseColor;
                target.Alpha        = Alpha;
            }
        }
Esempio n. 13
0
 public EnvironmentMapMaterial(GraphicsDevice graphics)
 {
     GraphicsDevice = graphics;
     effect         = GraphicsResources <EnvironmentMapEffect> .GetInstance(graphics, typeof(EnvironmentMapMaterial));
 }
Esempio n. 14
0
        private DefaultShaderType DetermineEffect(bool createNewEffect, Effect effectToTest)
        {
            #region Determine precendence between effects
            float skinningPrecedence           = mPrecedenceTable["SkinnedEffect"];
            float dualTexturePrecedence        = mPrecedenceTable["DualTextureEffect"];
            float environmentMappingPrecedence = mPrecedenceTable["EnvironmentMapEffect"];
            float basicEffectPrecedence        = mPrecedenceTable["BasicEffect"];
            #endregion

            #region Determining the possible types of Effect

            #region Check for key information for determining possible effect types
            Texture2D tex        = Texture2;
            Matrix[]  transforms = BoneTransforms;
#if !MONOGAME
            TextureCube cube = CubeMap;
#endif
            if (tex == null)
            {
                dualTexturePrecedence = float.MinValue;
            }

#if !MONOGAME
            if (cube == null)
            {
                environmentMappingPrecedence = float.MinValue;
            }
#endif

            if (transforms == null)
            {
                skinningPrecedence = float.MinValue;
            }
            #endregion


            // Three possible outcomes. If its a lower precedence than any
            // of it's competitors, it will lose out.
            // If it's greater than the others, it will win,
            // If it's equal to one another, well in technical terms, we guess.
            // ...
            // WELCOME TO IF STATEMENT HELL
#if !MONOGAME
            #region Skinning Shader determination... Don't look. Ever.
            //... I said don't look. Sigh
            if (skinningPrecedence >= environmentMappingPrecedence)
            {
                if (skinningPrecedence >= dualTexturePrecedence)
                {
                    if (skinningPrecedence > basicEffectPrecedence)
                    {
                        if (createNewEffect)
                        {
                            // Create a skinning shader
                            mSkinnedEffect = new SkinnedEffect(FlatRedBallServices.GraphicsDevice);
                            SetSkinningEffectParameters();
                        }

                        return(DefaultShaderType.Skinned);
                    }
                }
            }
            #endregion

            #region Environment Mapping Determination
            if (environmentMappingPrecedence >= dualTexturePrecedence)
            {
                if (environmentMappingPrecedence >= basicEffectPrecedence)
                {
                    if (createNewEffect)
                    {
                        // Create Environment map
                        mEnvironmentMapEffect = new EnvironmentMapEffect(FlatRedBallServices.GraphicsDevice);
                        SetEnvironmentMapEffectParameters();
                    }
                    return(DefaultShaderType.EnvironmentMapped);
                }
            }
            #endregion

            #region Dual Texture determination
            if (dualTexturePrecedence >= basicEffectPrecedence)
            {
                // Create Dual Texture
                if (createNewEffect)
                {
                    mDualTextureEffect = new DualTextureEffect(FlatRedBallServices.GraphicsDevice);
                    SetDualTextureEffectParameters();
                }
                return(DefaultShaderType.DualTexture);
            }
            #endregion
#endif

            #region Basic Shader determination
            // Create a basic Shader
            if (createNewEffect)
            {
                mBasicEffect = new BasicEffect(FlatRedBallServices.GraphicsDevice);
                SetBasicEffectParameters();
            }

            return(DefaultShaderType.Basic);

            #endregion
            #endregion
        }
        /// <summary>
        /// Looks up shortcut references to our effect parameters.
        /// </summary>
        void CacheEffectParameters(EnvironmentMapEffect cloneSource)
        {
            textureParam                = Parameters["Texture"];
            environmentMapParam         = Parameters["EnvironmentMap"];
            environmentMapAmountParam   = Parameters["EnvironmentMapAmount"];
            environmentMapSpecularParam = Parameters["EnvironmentMapSpecular"];
            fresnelFactorParam          = Parameters["FresnelFactor"];
            diffuseColorParam           = Parameters["DiffuseColor"];
            emissiveColorParam          = Parameters["EmissiveColor"];
            eyePositionParam            = Parameters["EyePosition"];
            fogColorParam               = Parameters["FogColor"];
            fogVectorParam              = Parameters["FogVector"];
            worldParam                  = Parameters["World"];
            worldInverseTransposeParam  = Parameters["WorldInverseTranspose"];
            worldViewProjParam          = Parameters["WorldViewProj"];
            shaderIndexParam            = Parameters["ShaderIndex"];

            light0 = new DirectionalLight(Parameters["DirLight0Direction"],
                                          Parameters["DirLight0DiffuseColor"],
                                          null,
                                          (cloneSource != null) ? cloneSource.light0 : null);

            light1 = new DirectionalLight(Parameters["DirLight1Direction"],
                                          Parameters["DirLight1DiffuseColor"],
                                          null,
                                          (cloneSource != null) ? cloneSource.light1 : null);

            light2 = new DirectionalLight(Parameters["DirLight2Direction"],
                                          Parameters["DirLight2DiffuseColor"],
                                          null,
                                          (cloneSource != null) ? cloneSource.light2 : null);
        }
        /// <summary>
        /// Creates a new EnvironmentMapEffect by cloning parameter settings from an existing instance.
        /// </summary>
        protected EnvironmentMapEffect(EnvironmentMapEffect cloneSource)
            : base(cloneSource)
        {
            CacheEffectParameters(cloneSource);

            fogEnabled = cloneSource.fogEnabled;
            fresnelEnabled = cloneSource.fresnelEnabled;
            specularEnabled = cloneSource.specularEnabled;

            world = cloneSource.world;
            view = cloneSource.view;
            projection = cloneSource.projection;

            diffuseColor = cloneSource.diffuseColor;
            emissiveColor = cloneSource.emissiveColor;
            ambientLightColor = cloneSource.ambientLightColor;

            alpha = cloneSource.alpha;

            fogStart = cloneSource.fogStart;
            fogEnd = cloneSource.fogEnd;
        }