Esempio n. 1
0
        /// <summary>
        /// Copies the specified amount of lights contained from the specified collection,
        /// but preserves the lights already present in this collection.
        /// </summary>
        /// <param name="copyFrom">Light collection to copy from</param>
        /// <param name="copyCount">Number of lights to copy</param>
        public void CopyLights(ILightCollection copyFrom, int copyCount)
        {
            if (copyCount > copyFrom.LightCount)
            {
                throw new ArgumentOutOfRangeException("Cannot copy more lights than contained in the light collection to copy from.");
            }

            if (copyCount > copyFrom.MaxLights)
            {
                copyCount = copyFrom.LightCount;
            }

            //Check if we need to resize
            if (copyCount + _lightCount > _lights.Length)
            {
                Light[] temp = new Light[(copyCount + _lightCount) * 2];
                Array.Copy(_lights, temp, _lightCount);
                Array.Clear(_lights, 0, _lightCount);
                _lights = temp;
            }

            for (int i = _lightCount, j = 0; j < copyCount; i++, j++)
            {
                _lights[i] = copyFrom[j];
            }

            _lightCount += copyCount;

            _refreshShader = true;
            if (_spatial != null)
            {
                _spatial.PropagateDirtyDown(DirtyMark.Lighting);
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Copies all the lights contained from the specified collection,
        /// but preserves the lights already present in this collection.
        /// </summary>
        /// <param name="copyFrom">Light collection to copy from</param>
        public void CopyLights(ILightCollection copyFrom)
        {
            int copyCount = copyFrom.LightCount;

            //Check if we need to resize
            if (copyCount + _lightCount > _lights.Length)
            {
                Light[] temp = new Light[(copyCount + _lightCount) * 2];
                Array.Copy(_lights, temp, _lightCount);
                Array.Clear(_lights, 0, _lightCount);
                _lights = temp;
            }

            for (int i = _lightCount, j = 0; j < copyCount; i++, j++)
            {
                _lights[i] = copyFrom[j];
            }
            _lightCount += copyCount;

            _refreshShader = true;
            if (_spatial != null)
            {
                _spatial.PropagateDirtyDown(DirtyMark.Lighting);
            }
        }
Esempio n. 3
0
        /// <summary>
        /// Sets the specified lights.
        /// </summary>
        /// <param name="lights">The lights to copy.</param>
        /// <param name="copyLights">if set to <c>true</c> [copy lights].</param>
        public void Set(ILightCollection lights, bool copyLights)
        {
            _maxLights     = lights.MaxLights;
            _globalAmbient = lights.GlobalAmbient;
            _isEnabled     = lights.IsEnabled;
            _refreshShader = true;

            if (copyLights)
            {
                //Clear the array
                Array.Clear(_lights, 0, _lightCount);

                //If the collection to copy from has more lights than we can carry, expand array to fit its light count
                if (lights.LightCount > _lights.Length)
                {
                    _lights = new Light[lights.LightCount * 2];
                }

                //Copy lights
                for (int i = 0; i < lights.LightCount; i++)
                {
                    _lights[i] = lights[i];
                }
                _lightCount = lights.LightCount;

                //New lights, update children
                if (_spatial != null)
                {
                    _spatial.PropagateDirtyDown(DirtyMark.Lighting);
                }
            }
        }
Esempio n. 4
0
        public Level(int minX, int minY, int minZ, int maxX, int maxY, int maxZ)
        {
            m_transform   = Matrix4.Identity;
            m_timeMachine = new TimeMachine();
            m_tileMap     = new TileMap(this, minX, minY, minZ, maxX, maxY, maxZ);

            m_entities         = new List <Entity>();
            m_entityCollection = new EntityCollection(this);
            m_info             = new LevelInfo();

            m_depthComparer       = new EntityDistanceComparer();
            m_depthSortedEntities = new List <Entity>();

            m_ambientLight        = new AmbientLight(new Vector3(0.5f, 0.5f, 0.5f));
            m_ambientLight.Active = true;

            m_skyLight        = new DirectionalLight(new Vector3(0.6f, -1.0f, -0.6f), new Vector3(0.5f, 0.5f, 0.5f));
            m_skyLight.Active = true;

            m_skyLight2        = new DirectionalLight(-Vector3.UnitY, Vector3.Zero);
            m_skyLight2.Active = false;

            m_pointLights     = new List <PointLight>();
            m_lightCollection = new LightCollection(this);

            m_telepadDirectory = new TelepadDirectory();
            m_hintDirectory    = new HintDirectory();

            Visible = true;
            Random  = new Random();

            m_flatOpaqueEffect     = new FlatEffectInstance();
            m_flatCutoutEffect     = new FlatCutoutEffectInstance();
            m_litOpaqueEffect      = new LitEffectInstance(RenderPass.Opaque);
            m_litCutoutEffect      = new LitEffectInstance(RenderPass.Cutout);
            m_litTranslucentEffect = new LitEffectInstance(RenderPass.Translucent);
            m_shadowEffect         = new ShadowEffectInstance();

            m_particles = new ParticleManager(this);
        }
Esempio n. 5
0
 public ReadOnlyKeyedCollection(string[] keys, ILightCollection <T> items)
 {
     _coll = new KeyedCollection <T>(keys, items.GetItems());
 }
Esempio n. 6
0
 public ReadOnlyKeyedCollection(ILightCollection <T> collection)
 {
     string[] keys = CreateFreeKeys(collection.Count);
     _coll = new KeyedCollection <T>(keys, collection.GetItems());
 }
Esempio n. 7
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="index"></param>
 /// <param name="items"></param>
 public virtual void InsertRange(int index, ILightCollection <T> items)
 {
     InsertRange(index, items.GetItems());
 }
Esempio n. 8
0
 /// <summary>
 /// Add a range of Items to this collection
 /// </summary>
 /// <param name="items">An ILightCollection<T> derived collection</param>
 public virtual void AddRange(ILightCollection <T> items)
 {
     InsertRange(this._count, items.GetItems());
 }
Esempio n. 9
0
        /// <summary>
        /// Constructor of LightCollection
        /// </summary>
        /// <param name="coll">The collection from where copy items</param>
        public LightCollection(ILightCollection <T> coll)
        {
            Init(coll.Count);

            this.AddRange(coll.GetItems());
        }
Esempio n. 10
0
        /// <summary>
        /// Execute the logic for the given material and renderable (usually a Mesh).
        /// </summary>
        /// <param name="material">Material that is executing the logic.</param>
        /// <param name="renderer">Renderer used for drawing</param>
        /// <param name="renderable">Renderable that owns the Material</param>
        public override void Execute(Material material, IRenderer renderer, IRenderable renderable)
        {
            if (renderable == null || renderer == null || material == null)
            {
                return;
            }

            if (IsEnabled)
            {
                if (_needsRefresh)
                {
                    CacheParameters(material.Effect);
                }

                //We assume this comes to us already sorted.
                ILightCollection lights = renderable.WorldLights;

                //Return if the collection doesn't need to update us or there are no lights to update with
                if (!lights.RefreshShader || lights.LightCount == 0)
                {
                    //Set to zero
                    if (_cachedLightCount != null)
                    {
                        _cachedLightCount.SetValue(0);
                    }
                    return;
                }

                //Tell the collection not to update us until it changes
                lights.RefreshShader = false;

                //Set the global ambient value
                if (_cachedGlobalAmbient != null)
                {
                    _cachedGlobalAmbient.SetValue(lights.GlobalAmbient.ToVector3());
                }

                //Update the actual light list
                if (_cachedLightList != null)
                {
                    //If we're dealing with a single parameter and not an array...
                    if (_cachedLightList.Elements.Count == 0)
                    {
                        SetLight(lights[0], _cachedLightList);
                        return;
                    }

                    //Ensure the max light counts match, if the element count is less than
                    //the collection's max lights, use that, otherwise use the collection's
                    int numLights = 0;
                    if (lights.LightCount <= _cachedLightList.Elements.Count)
                    {
                        numLights = lights.LightCount;
                    }
                    else if (lights.LightCount > _cachedLightList.Elements.Count)
                    {
                        numLights = _cachedLightList.Elements.Count;
                    }

                    //Set the number of lights
                    if (_cachedLightCount != null)
                    {
                        _cachedLightCount.SetValue(numLights);
                    }

                    //Go through each light, and update it to the shader
                    for (int i = 0; i < numLights; i++)
                    {
                        Light            light  = lights[i];
                        IEffectParameter lParam = _cachedLightList.Elements[i];
                        SetLight(light, lParam);
                    }
                }
            }
        }
Esempio n. 11
0
 public StringCollection(ILightCollection <string> collection)
 {
     _coll = new LightCollection <string>(collection);
 }
Esempio n. 12
0
 public void InsertRange(int index, ILightCollection <string> items)
 {
     _coll.InsertRange(index, items);
 }
Esempio n. 13
0
 public void AddRange(ILightCollection <string> items)
 {
     _coll.AddRange(items);
 }
Esempio n. 14
0
 public ReadOnlyCollection(ILightCollection <T> collection)
 {
     _coll = (LightCollection <T>)collection; // new LightCollection<T>(collection);
 }
Esempio n. 15
0
 /// <summary>
 /// Resets the collection's data and copies the input light collection's data.
 /// </summary>
 /// <param name="lights">Light collection to copy from</param>
 public void Set(ILightCollection lights)
 {
     Set(lights, true);
 }