public override void CheckSetup(Preset preset, Table table)
		{
			preset.CardCards[this] = new CardCollection();
			// Grab all of the Black Market Supply cards and stick them into the CardCards for Black Market
			foreach (Type cardType in table.SpecialPiles[TypeClass.BlackMarketSupply].CardTypes)
				preset.CardCards[this].Add(Card.CreateInstance(cardType));
		}

        /// <summary>
        /// Encodes a video and audio file.
        /// </summary>
        /// <param name="id">An ID used to track the item being encoded.</param>
        /// <param name="preset">The preset used to encode the given file.</param>
        /// <param name="file">The location of the file to encode.</param>
        /// <param name="command">The command used to tell Handbrake how to encode the video.</param>
        /// <param name="progress">The callback function fired when progress of a file's encoding is updated. The action is given the percentage complete.</param>
        /// <param name="complete">The callback function fired when encoding is complete. The action is given the location of the encoded file.</param>
        /// <returns>An ID used to track the item being encoded.</returns>
        public void Encode(Guid id, Preset preset, string file, string command, Action<EncodingMovieTask, double> progress, Action<EncodingMovieTask> complete)
        {
            if (string.IsNullOrEmpty(file))
                throw new ArgumentNullException("file");
            if (!System.IO.File.Exists(file))
                throw new FileNotFoundException(file);

            command = string.Format(command, "\"" + file + "\"", id.ToString("N") + ".mp4" + PresetIndicator.Get(preset));

            var task = new EncodingMovieTask {ID = id, File = file, PercentComplete = 0};

            Logger.Info("Beginning encoding: " + command);

            new Thread(() => {
                var process = new Process();
                process.StartInfo.FileName = @"c:\Code\showveoservice\ShowveoService.MVCApplication\Resources\HandbrakeCLI.exe";
                process.StartInfo.Arguments = command;
                process.StartInfo.RedirectStandardOutput = true;
                process.StartInfo.UseShellExecute = false;
                process.OutputDataReceived += (sender, args) => OnDataReceived(progress, task, args);
                process.ErrorDataReceived += (sender, args) => OnErrorReceived(args);
                process.Exited += (sender, args) => complete.Invoke(task);
                process.Start();

                process.BeginOutputReadLine();

                while (!process.HasExited) {}
            }).Start();
        }

	public LightPresets(LightConfiguration l)
	{
		lc = l;
		
		/*Preset p1 = new Preset();
		p1.p_name = "LightPresets.Inside";
		p1.l_intensity = 0.2f;
		p1.s_blur = 3f;
		p1.s_power = 0.9f;
		p1.r_id = 1;
		p1.r_rate = 0;
		p1.imgBackground_r = 128;
		p1.imgBackground_g = 128;
		p1.imgBackground_b = 128;
		p1.id = 0;*/
		
		Preset p2 = new Preset();
		p2.p_name = "LightPresets.LightingOutdoor";
		p2.l_intensity = 0.3f;
		p2.s_blur = 2.8f;
		p2.s_power = 0.4f;
		p2.r_id = 6;
		p2.r_rate = 0;
		p2.imgBackground_r = 128;
		p2.imgBackground_g = 128;
		p2.imgBackground_b = 128;
		p2.id = 1;
		
		Preset p3 = new Preset();
		p3.p_name = "LightPresets.CloudyOutdoor";
		p3.l_intensity = 0.2f;
		p3.s_blur = 6f;
		p3.s_power = 0.8f;
		p3.r_id = 6;
		p3.r_rate = 0;
		p3.imgBackground_r = 128;
		p3.imgBackground_g = 128;
		p3.imgBackground_b = 128;
		p3.id = 2;
		
		Preset p4 = new Preset();
		p4.p_name = "LightPresets.Night";
		p4.l_intensity = 0.05f;
		p4.s_blur = 6f;
		p4.s_power = 1.0f;
		p4.r_id = 6;
		p4.r_rate = 0;
		p4.imgBackground_r = 33;
		p4.imgBackground_g = 44;
		p4.imgBackground_b = 80;	
		p4.id = 3;
		
		//presetsList.Add(p1);
		presetsList.Add(p2);
		presetsList.Add(p3);
		presetsList.Add(p4);
		
	}

 public void EnablePreset(Preset preset)
 {
     foreach (var mod in preset)
     {
         modManager.EnableMod(mod);
     }
     preset.IsEnabled = true;
     UpdatePreset(preset);
 }

 public void DisablePreset(Preset preset)
 {
     foreach (var mod in preset)
     {
         modManager.DisableMod(mod);
     }
     preset.IsEnabled = false;
     UpdatePreset(preset);
 }

        /// <summary>Creates a new preset view model.</summary>
        public PresetViewModel(Preset preset, ModManager modManager, PresetManager presetManager)
        {
            this.modManager = modManager;
            this.presetManager = presetManager;

            Preset = preset;

            RenameCommand = new Command(Rename);
            DisbandCommand = new Command(Disband);
        }

        /// <summary>
        /// The export preset.
        /// </summary>
        /// <param name="export">
        /// The export.
        /// </param>
        /// <param name="config">
        /// HandBrakes configuration options.
        /// </param>
        /// <returns>
        /// The <see cref="Preset"/>.
        /// </returns>
        public static PresetTransportContainer ExportPreset(Preset export, HBConfiguration config)
        {
            PresetTransportContainer container = new PresetTransportContainer();
            container.VersionMajor = "0";
            container.VersionMinor = "10";
            container.VersionMicro = "2";
            container.PresetList = new List<HBPreset> { CreateHbPreset(export, config) };

            return container;
        }

        /// <summary>
        /// Creates an encoder based on a preset.
        /// </summary>
        /// <param name="preset">The preset used to generate the appropriate encoder.</param>
        /// <returns>The created encoder.</returns>
        public IEncoder Create(Preset preset)
        {
            switch (preset)
            {
                case Preset.Phone: return new PhoneHandbrakeEncoder(_configuration);
                case Preset.TV: return new TVHandbrakeEncoder(_configuration);
                case Preset.Tablet: return new TabletHandbrakeEncoder(_configuration);
            }

            throw new ArgumentException("The preset " + preset + " has no implementation.");
        }

        public static string Get(Preset preset)
        {
            switch (preset)
            {
                case Preset.Phone: return ".phone";
                case Preset.Tablet: return ".tablet";
                case Preset.TV: return ".tv";
            }

            throw new InvalidOperationException("No indicator exists for preset \"" + preset + "\".");
        }

	// 
	void SetPresetSettings(Preset p)
	{
		HighlightingBase hb = FindObjectOfType<HighlightingBase>();

		if (hb == null) { return; }

		hb.downsampleFactor = p.downsampleFactor;
		hb.iterations = p.iterations;
		hb.blurMinSpread = p.blurMinSpread;
		hb.blurSpread = p.blurSpread;
		hb.blurIntensity = p.blurIntensity;
	}

	void ApplyPreset( Preset ps )
	{
		m_idTexture = ps.m_idTexture;
		m_idMask = ps.m_idMask;
		GetComponent<Renderer>().material.SetTexture("_MainTex", m_textureList[m_idTexture]);
		GetComponent<Renderer>().material.SetTexture("_MaskTex", m_maskList[m_idMask]);
		
		GetComponent<Renderer>().material.SetFloat( "_Emission", ps.m_Emission );
		GetComponent<Renderer>().material.SetFloat( "_Alpha", ps.m_Alpha );
		GetComponent<Renderer>().material.SetFloat( "_AlphaCutOffMask", ps.m_AlphaCutOffMask );
		GetComponent<Renderer>().material.SetFloat( "_AlphaCutOffSmooth", ps.m_AlphaCutOffSmooth );
		GetComponent<Renderer>().material.SetFloat( "_AlphaMask", ps.m_AlphaMask );
	}

 public void AddModToPreset(Mod mod, Preset preset)
 {
     if (!ModIsInAPreset(mod))
     {
         preset.Add(mod);
         if (mod.IsEnabled != preset.IsEnabled)
         {
             modManager.ToggleEnabled(mod);
         }
         SavePreset(preset);
         LoadModsBuffer();
     }
 }

    public void SetForce(float max, float min)
    {
        if (max == preset.maxForce && min == preset.minForce) return;

        Preset newP = new Preset();
        newP.in_curve = preset.in_curve;
        newP.out_curve = preset.out_curve;
        newP.in_time = preset.in_time;
        newP.out_time = preset.out_time;

        newP.maxForce = max;
        newP.minForce = min;
        ChangePreset(newP);
    }

    protected void btnSave_Click(object sender, EventArgs e)
    {
        var p = new Preset
        {
            ID = 0,
            Name = txtCropName.Text,
            IdealTemperature = Convert.ToInt32(txtIdealTemp.Text),
            TemperatureThreshold = Convert.ToInt32(txtTempRange.Text),
            IdealLightIntensity = Convert.ToInt32(txtLightRange.Text),
            LightIntensityThreshold = Convert.ToInt32(txtLightRange.Text),
            IdealHumidity = Convert.ToInt32(txtHumidity.Text),
            HumidityThreshold = Convert.ToInt32(txtHumidityRange.Text),
            IdealWaterLevel = Convert.ToInt32(txtWaterLevel.Text),
            WaterLevelThreshold = Convert.ToInt32(txtWaterThreshold.Text)

        };
        p.Save();
    }

 private void btnAddPreset_Click(object sender, EventArgs e)
 {
     try
     {
         MouseClicker.InputBox iBox = new MouseClicker.InputBox("Define preset name", "My preset");
         if (iBox.ShowDialog() == System.Windows.Forms.DialogResult.OK)
         {
             Preset p = new Preset(iBox.Value, "", "", "");
             _presets.Add(p);
             DisplayPresets();
             cboPresets.SelectedItem = p;
             SavePresets();
         }
     }
     catch (Exception ex)
     {
         MessageBox.Show(ex.Message);
     }
 }

 public void AssignChanges(Preset preset)
 {
     foreach (KeyValuePair<PawnData, Preset> pair in PresetDatabase.assignedPresets)
     {
         if (!pawns.Exists(pawn => pawn.ThingID == pair.Key.ID))
         {
             PresetDatabase.assignedPresets.Remove(pair.Key);
         }
         else if (pair.Value.Name == preset.Name)
         {
             foreach (WorkTypeDef job in VisibleWorkTypeDefsInPriorityOrder)
             {
                 pawns.Find(pawn => pawn.ThingID == pair.Key.ID);
                 if (!pawns.Find(pawn => pawn.ThingID == pair.Key.ID).story.WorkTypeIsDisabled(job))
                     pawns.Find(pawn => pawn.ThingID == pair.Key.ID).workSettings.SetPriority(job, preset.priorities[job]);
             }
         }
     }
 }

		protected override void OnRenderImage(RenderTexture source, RenderTexture destination)
		{
			if (Palette != m_CurrentPreset)
			{
				m_CurrentPreset = Palette;

				if (Palette == Preset.None)
					LookupTexture = null;
				else
					LookupTexture = Resources.Load<Texture2D>("LoFiPalettes/" + Palette.ToString());
			}

			if (LookupTexture == null || Amount <= 0f)
			{
				Graphics.Blit(source, destination);
				return;
			}

			if (m_Use2DLut || ForceCompatibility)
				RenderLut2D(source, destination);
			else
				RenderLut3D(source, destination);
		}

		protected override void OnRenderImage(RenderTexture source, RenderTexture destination)
		{
			if (Palette != m_CurrentPreset)
			{
				m_CurrentPreset = Palette;

				if (Palette == Preset.None)
					LookupTexture = null;
				else
					LookupTexture = Resources.Load<Texture2D>("LoFiPalettes/" + Palette.ToString());
			}

			if (LookupTexture == null)
			{
				Graphics.Blit(source, destination);
				return;
			}

			if (LookupTexture.name != m_BaseTextureName)
				ConvertBaseTexture();

			if (m_Lut3D == null)
				SetIdentityLut();

			m_Lut3D.filterMode = FilterMode.Point;
			Material.SetTexture("_LookupTex", m_Lut3D);
			float lutSize = (float)m_Lut3D.width;
			Material.SetVector("_Params", new Vector4(
					(lutSize - 1f) / (1f * lutSize),
					1f / (2f * lutSize),
					Amount,
					PixelSize
				));

			int pass = (Pixelize ? 2 : 0) + (CLib.IsLinearColorSpace() ? 1 : 0);
			Graphics.Blit(source, destination, Material, pass);
		}

        private void AddToPreset(Preset preset)
        {
            if (Mod.IsInOriginalInstallation())
            {
                MessageBox.Show("This mod cannot be added to a preset, as it is part of the core of Cortex Command.", "Notice", MessageBoxButton.OK, MessageBoxImage.Exclamation);
                return;
            }

            presetManager.AddModToPreset(Mod, preset);

            if (OnAddedToPreset != null)
                OnAddedToPreset(preset);
        }

        private void AddToNewPreset()
        {
            if (Mod.IsInOriginalInstallation())
            {
                MessageBox.Show("This mod cannot be added to a preset, as it is part of the core of Cortex Command.", "Notice", MessageBoxButton.OK, MessageBoxImage.Exclamation);
                return;
            }

            var addPresetWindow = new AddPresetWindow();
            addPresetWindow.Owner = Global.MainWindow;
            addPresetWindow.WindowStartupLocation = WindowStartupLocation.CenterOwner;

            var result = (bool)addPresetWindow.ShowDialog();

            if (result)
            {
                var presetName = addPresetWindow.PresetName;
                var preset = new Preset(presetName, Mod.IsEnabled);
                preset.Add(Mod);
                presetManager.SavePreset(preset);

                if (OnAddedToPreset != null)
                    OnAddedToPreset(preset);
            }
        }