/// <summary>
 /// Creates a new DrawTechnique using the specified <see cref="BlendMode"/> and <see cref="Duality.Resources.ShaderProgram"/>.
 /// </summary>
 /// <param name="blendType"></param>
 /// <param name="shader"></param>
 /// <param name="formatPref"></param>
 public DrawTechnique(BlendMode blendType, ContentRef<ShaderProgram> shader, VertexDeclaration formatPref = null)
 {
     this.blendType = blendType;
     this.shader = shader;
     this.prefFormat = formatPref;
     this.prefType = formatPref != null ? formatPref.DataType : null;
 }

 public void ReImportFile(ContentRef<Resource> r, string srcFile)
 {
     PixelData pixelData = LoadPixelData(srcFile);
     Pixmap res = r.Res as Pixmap;
     res.MainLayer = pixelData;
     res.SourcePath = srcFile;
 }

 public CreatureContainer(CreatureType type, bool forwardOnSpecial, ContentRef<Material> combatSprite, params NameOfAbility[] abilities)
 {
     this.CombatSprite = combatSprite;
     this.forwardOnSpecial = forwardOnSpecial;
     this.CreatureType = type;
     this.AbilityNameStorage = new List<NameOfAbility>(abilities);
 }

 internal SoundInstance(ContentRef<Sound> sound, GameObject attachObj)
 {
     this.attachedTo = attachObj;
     this.is3D = true;
     this.sound = sound;
     this.audioData = this.sound.IsAvailable ? this.sound.Res.FetchData() : null;
 }

 public void ReImportFile(ContentRef<Resource> r, string srcFile)
 {
     Font font = r.Res as Font;
     font.SourcePath = srcFile;
     font.EmbeddedTrueTypeFont = File.ReadAllBytes(srcFile);
     font.RenderGlyphs();
 }

 public ApplyToPrefabAction(GameObject obj, ContentRef<Prefab> target)
     : base(new[] { obj })
 {
     this.targetPrefab = new ContentRef<Prefab>[this.targetObj.Length];
     for (int i = 0; i < this.targetPrefab.Length; i++)
         this.targetPrefab[i] = target;
 }

 public TilesetSelectionChangedEventArgs(ContentRef<Tileset> prev, ContentRef<Tileset> next, SelectionChangeReason reason)
     : base()
 {
     this.prev = prev;
     this.next = next;
     this.reason = reason;
 }

 // We are going to use ContentRefs instead of using Scene Resources directly
 /// <summary>
 /// Function to switch to another scene.
 /// </summary>
 /// <param name="scene">The ContentRef of the scene to switch to.</param>
 public static void Switch(ContentRef<Scene> scene)
 {
     // Note that we are not doing any scene disposal here. This means that
     // the current scene will not be removed from memory, and that it will
     // retain changes made to it.
     Scene.SwitchTo(scene);
 }

        /// <summary>
        /// Function to save a copy of the specified scene.
        /// </summary>
        /// <param name="scene">The scene to be saved.</param>
        public static void SaveSceneCopy(ContentRef<Scene> scene)
        {
            // This is the path to which the file will be saved. It is constructed by
            // combining the Duality Data directory path with the sample name, which
            // results in the actual directory the file will be saved to.
            // This result is concatenated with the actual file name.
            // The file name is constructed by concatenating the specified scene's name,
            // along with "_Copy" and the Scene Resource file extension.
            string filePath = Duality.IO.PathOp.Combine(DualityApp.DataDirectory, "SceneTransitions")
                                + (scene.Name + "_Copy" + Resource.GetFileExtByType<Scene>());

            // Here we save the scene.
            scene.Res.Save(filePath);

            // The "Press to save" object's TextRenderer.
            TextRenderer textRenderer = scene.Res.FindGameObject("Text5").GetComponent<TextRenderer>();

            // Set the "Press to save" object's TextRenderer's source text and color tint,
            // if the TextRenderer was found.
            if (textRenderer != null)
            {
                textRenderer.Text.ApplySource("The saved scene can be found in the Duality Data directory.");
                textRenderer.ColorTint = ColorRgba.Green;
            }
        }

		/// <summary>
		/// Creates a new Sound Resource based on the specified AudioData, saves it and returns a reference to it.
		/// </summary>
		/// <param name="baseRes"></param>
		/// <returns></returns>
		public static ContentRef<Sound> CreateFromAudioData(ContentRef<AudioData> baseRes)
		{
			string resPath = PathHelper.GetFreePath(baseRes.FullName, FileExt);
			Sound res = new Sound(baseRes);
			res.Save(resPath);
			return res;
		}

 public void ReImportFile(ContentRef<Resource> r, string srcFile)
 {
     AbstractShader s = r.Res as AbstractShader;
     string sourceCode = File.ReadAllText(srcFile);
     s.Source = sourceCode;
     s.SourcePath = srcFile;
     s.Compile();
 }

 public bool CanReImportFile(ContentRef<Resource> r, string srcFile)
 {
     string ext = Path.GetExtension(srcFile);
     if (r.Is<VertexShader>() && string.Equals(ext, SourceFileExtVertex, StringComparison.InvariantCultureIgnoreCase))
         return true;
     else if (r.Is<FragmentShader>() && string.Equals(ext, SourceFileExtFragment, StringComparison.InvariantCultureIgnoreCase))
         return true;
     else
         return false;
 }

        public static bool SceneContainsTileset(Scene scene, ContentRef<Tileset> tileset)
        {
            foreach (Tilemap tilemap in scene.FindComponents<Tilemap>())
            {
                if (tilemap.Tileset == tileset)
                    return true;
            }

            return false;
        }

        /// <summary>
        /// Function to switch to another scene after disposing the specified scene.
        /// </summary>
        /// <param name="nextScene">The ContentRef of the scene to dispose.</param>
        /// <param name="nextScene">The ContentRef of the scene to switch to.</param>
        public static void DisposeAndSwitch(ContentRef<Scene> disposeScene, 
                                            ContentRef<Scene> nextScene)
        {
            // In this function, the current scene will be disposed, or removed
            // from memory, before the switch to the next scene commences.

            // We are using DisposeLater() for safety, it will only dispose the
            // scene after the current update cycle is over.
            disposeScene.Res.DisposeLater();
            Scene.SwitchTo(nextScene);
        }

        public ScreenCaptureStream(BlockingCollection<CapturedFrame> frames, string streamName, ContentRef<RenderTarget> output, int numberOfCachedFrames)
        {
            _frames = frames;
            _output = output;
            StreamName = streamName;

            _numberOfCachedFrames = numberOfCachedFrames;

            _pboIds[0] = GL.GenBuffer();
            _pboIds[1] = GL.GenBuffer();
        }

 public static string GenerateSourceFilePath(ContentRef<Resource> r, string srcFileExt)
 {
     string filePath = PathHelper.MakeFilePathRelative(r.Path, DualityApp.DataDirectory);
     string fileDir = Path.GetDirectoryName(filePath);
     if (filePath.Contains(".."))
     {
         filePath = Path.GetFileName(filePath);
         fileDir = ".";
     }
     return PathHelper.GetFreePath(Path.Combine(Path.Combine(EditorHelper.SourceMediaDirectory, fileDir), r.Name), srcFileExt);
 }

        /// <summary>
        /// Prepares the specified <see cref="Tilemap"/> for user editing using the specified size.
        /// </summary>
        /// <param name="tilemap"></param>
        /// <param name="tilesetRef"></param>
        /// <param name="width"></param>
        /// <param name="height"></param>
        /// <param name="isUpperLayer"></param>
        public static void SetupTilemap(Tilemap tilemap, ContentRef<Tileset> tilesetRef, int width, int height, bool isUpperLayer)
        {
            Tileset tileset = tilesetRef.Res;

            // Determine the first tile index that matches the layer type.
            int fillTileIndex = GetDefaultTileIndex(tileset, isUpperLayer);

            // Resize the Tilemap and fill it with the first visually non-empty tile.
            tilemap.Tileset = tileset;
            tilemap.Resize(width, height);
            tilemap.BeginUpdateTiles().Fill(
                new Tile(fillTileIndex),
                0,
                0,
                tilemap.Size.X,
                tilemap.Size.Y);
            tilemap.EndUpdateTiles();
        }

		internal static void InitDefaultContent()
		{
			const string VirtualContentPath				= ContentProvider.VirtualContentPath + "Texture:";
			const string ContentPath_DualityIcon		= VirtualContentPath + "DualityIcon";
			const string ContentPath_DualityIconB		= VirtualContentPath + "DualityIconB";
			const string ContentPath_DualityLogoBig		= VirtualContentPath + "DualityLogoBig";
			const string ContentPath_DualityLogoMedium	= VirtualContentPath + "DualityLogoMedium";
			const string ContentPath_DualityLogoSmall	= VirtualContentPath + "DualityLogoSmall";
			const string ContentPath_White				= VirtualContentPath + "White";
			const string ContentPath_Checkerboard		= VirtualContentPath + "Checkerboard";

			ContentProvider.AddContent(ContentPath_DualityIcon, new Texture(Pixmap.DualityIcon));
			ContentProvider.AddContent(ContentPath_DualityIconB, new Texture(Pixmap.DualityIconB));
			ContentProvider.AddContent(ContentPath_DualityLogoBig, new Texture(Pixmap.DualityLogoBig));
			ContentProvider.AddContent(ContentPath_DualityLogoMedium, new Texture(Pixmap.DualityLogoMedium));
			ContentProvider.AddContent(ContentPath_DualityLogoSmall, new Texture(Pixmap.DualityLogoSmall));
			ContentProvider.AddContent(ContentPath_White, new Texture(Pixmap.White));
			ContentProvider.AddContent(ContentPath_Checkerboard, new Texture(Pixmap.Checkerboard, wrapX: TextureWrapMode.Repeat, wrapY: TextureWrapMode.Repeat));

			DualityIcon			= ContentProvider.RequestContent<Texture>(ContentPath_DualityIcon);
			DualityIconB		= ContentProvider.RequestContent<Texture>(ContentPath_DualityIconB);
			DualityLogoBig		= ContentProvider.RequestContent<Texture>(ContentPath_DualityLogoBig);
			DualityLogoMedium	= ContentProvider.RequestContent<Texture>(ContentPath_DualityLogoMedium);
			DualityLogoSmall	= ContentProvider.RequestContent<Texture>(ContentPath_DualityLogoSmall);
			White				= ContentProvider.RequestContent<Texture>(ContentPath_White);
			Checkerboard		= ContentProvider.RequestContent<Texture>(ContentPath_Checkerboard);
		}

		public ApplyToPrefabAction(IEnumerable<GameObject> obj) : base(obj.Where(
			o => o != null && 
			o.PrefabLink != null && 
			o.PrefabLink.Prefab.IsAvailable))
		{
			this.targetPrefab = this.targetObj.Select(o => o.PrefabLink.Prefab).ToArray();
		}

		internal static void InitDefaultContent()
		{
			const string VirtualContentPath		= ContentProvider.VirtualContentPath + "AudioData:";
			const string ContentPath_Beep		= VirtualContentPath + "Beep";

			ContentProvider.AddContent(ContentPath_Beep, new AudioData(DefaultContent.Beep));

			Beep = ContentProvider.RequestContent<AudioData>(ContentPath_Beep);
		}