public Property(SurfaceTexture tex,string name){
			SurfaceProperty=tex.GetProperty(name,true);
			IsTexture=(SurfaceProperty.Value is TextureValue);
			
			// Pull the values right now:
			Prepare(null);
		}
        /// <summary>Builds or rebuilds the property map.</summary>
        public void CreateMap()
        {
            if (Properties == null)
            {
                PropertyMap = null;
                return;
            }

            // Create:
            PropertyMap = new Dictionary <string, SurfaceProperty>();

            // For each property..
            for (int i = 0; i < Properties.Length; i++)
            {
                // Get property:
                SurfaceProperty prop = Properties[i];

                // Got a name at all?
                if (string.IsNullOrEmpty(prop.Name))
                {
                    // Nope - skip.
                    continue;
                }

                // Push:
                PropertyMap[prop.Name] = prop;
            }
        }
        /// <summary>Sets the named property.</summary>
        public void SetProperty(string property, Values.PropertyValue value)
        {
            // Get or create:
            SurfaceProperty prop = GetProperty(property, true);

            // Apply value:
            prop.Value = value;
        }
		public override void Read(TextureReader reader){
			
			// Property ID:
			int index=(int)reader.ReadCompressed();
			
			// Get from the current surface being loaded:
			SurfaceProperty=reader.CurrentSurface.Properties[index];
			IsTexture=(SurfaceProperty.Value is TextureValue);
			
		}
        /// <summary>Gets the named property by nice name, optionally creating it.</summary>
        public SurfaceProperty GetProperty(string property, bool create)
        {
            property = property.ToLower();

            // Already exists?
            SurfaceProperty result = null;

            if (Properties != null)
            {
                if (PropertyMap == null)
                {
                    CreateMap();
                }

                PropertyMap.TryGetValue(property, out result);
            }

            if (result != null || !create)
            {
                return(result);
            }

            // Create now:
            result      = new SurfaceProperty();
            result.Name = property;

            // Insert:
            if (Properties == null)
            {
                Properties = new SurfaceProperty[1];
            }
            else
            {
                // Resize:
                SurfaceProperty[] set = new SurfaceProperty[Properties.Length + 1];
                Array.Copy(Properties, 0, set, 0, Properties.Length);
                Properties = set;
            }

            // Add:
            result.ID             = Properties.Length - 1;
            Properties[result.ID] = result;

            if (PropertyMap != null)
            {
                // Update map:
                PropertyMap[property] = result;
            }

            return(result);
        }
        /// <summary>Loads the set of properties from the given reader.</summary>
        public void LoadProperties(TextureReader reader)
        {
            // Note that each property has an optional name and optional default value.
            // (However, they serve as 'containers' which materials drop the current values into).

            // How many properties? Also contains 3 flags for names, defaults and unused.
            uint propertiesAndFlags = (uint)reader.ReadCompressed();

            // Chop off the 3 bits:
            int properties = (int)(propertiesAndFlags >> 3);

            if (properties == 0)
            {
                return;
            }

            // Got names?
            // Got any defaults at all?
            bool gotNames    = ((propertiesAndFlags & 1) == 1);
            bool gotDefaults = ((propertiesAndFlags & 2) == 2);

            // Create the set:
            Properties = new SurfaceProperty[properties];

            // For each one..
            for (int i = 0; i < properties; i++)
            {
                // Create:
                SurfaceProperty prop = new SurfaceProperty();

                // Apply ID:
                prop.ID = i;

                if (gotNames)
                {
                    // Read a nice name:
                    prop.Name = reader.ReadString();
                }

                if (gotDefaults)
                {
                    // Read a value:
                    prop.Value = reader.ReadPropertyValue();
                }

                // Add to set:
                Properties[i] = prop;
            }
        }
        /// <summary>Gets a property value by its nice name. Note that nice names are generally rare. Null if it doesn't exist.</summary>
        public Values.PropertyValue this[string property] {
            get{
                SurfaceProperty sp = GetProperty(property, false);

                if (sp == null)
                {
                    return(null);
                }

                return(sp.Value);
            }
            set{
                SetProperty(property, value);
            }
        }
        /// <summary>Removes the given property by its nice name.</summary>
        public void RemoveProperty(string property)
        {
            property = property.ToLower();

            // Exists?
            SurfaceProperty exists = GetProperty(property, false);

            if (exists == null || Properties == null)
            {
                return;
            }

            // One property?
            if (exists.ID == 0 && Properties.Length == 1)
            {
                Properties  = null;
                PropertyMap = null;
            }
            else
            {
                // Slice from the array at exists.ID
                SurfaceProperty[] newSet = new SurfaceProperty[Properties.Length - 1];

                int index = 0;

                for (int i = 0; i < Properties.Length; i++)
                {
                    if (i == exists.ID)
                    {
                        // Skip the one we're removing.
                        continue;
                    }

                    SurfaceProperty movingProp = Properties[i];
                    movingProp.ID = index;
                    newSet[index] = movingProp;
                    index++;
                }

                if (PropertyMap != null)
                {
                    // Update map:
                    PropertyMap.Remove(property);
                }
            }
        }
        /// <summary>Saves the property set to the given writer.</summary>
        public void SaveProperties(BinaryIO.Writer writer, bool withNiceNames, bool withValues)
        {
            // Write property count and extra flags:
            int count = Properties == null?0:Properties.Length;

            uint flags = 0;

            if (withNiceNames)
            {
                flags |= 1;
            }

            if (withValues)
            {
                flags |= 2;
            }

            // Write count and flags now:
            writer.WriteCompressed((((uint)count) << 3) | flags);

            // For each property..
            for (int i = 0; i < count; i++)
            {
                // Get:
                SurfaceProperty sp = Properties[i];

                if (withNiceNames)
                {
                    // Write the nice name:
                    // (Optional because properties ref by index in the actual graph).
                    writer.WriteString(sp.Name);
                }

                if (withValues)
                {
                    // Write the value:
                    sp.Value.Write(writer);
                }
            }
        }
Esempio n. 10
0
        /// <summary>Convenience function. It also helps to cache the original property value and straight edit that.</summary>
        public void Set(string property, float value)
        {
            // Get the property:
            SurfaceProperty prop = GetProperty(property, true);

            // Get as float:
            Values.FloatValue v = prop.Value as Values.FloatValue;

            // Set it:
            if (v == null)
            {
                prop.Value = new Values.FloatValue(value);
            }
            else
            {
                v.Value = value;

                if (v.Changed)
                {
                    // No longer idling - changes detected.
                    Changed = true;
                }
            }
        }
Esempio n. 11
0
		public Property(SurfaceProperty prop){
			SurfaceProperty=prop;
			
			// Pull the values right now:
			Prepare(null);
		}