public static IShader New(VideoTypes videoType, IDisposableResource parent, string filename, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback) { IShader api = null; #if WIN32 if (videoType == VideoTypes.D3D9) api = new D3D9.Shader(parent, filename, shaderVersion, vsQuality, psQuality, loadedCallback); #endif #if WIN32 || WINRT || WP8 if (videoType == VideoTypes.D3D11) api = new D3D11.Shader(parent, filename, shaderVersion, vsQuality, psQuality, loadedCallback); #endif #if WIN32 || OSX || LINUX || iOS || ANDROID || NaCl if (videoType == VideoTypes.OpenGL) api = new OpenGL.Shader(parent, filename, shaderVersion, vsQuality, psQuality, loadedCallback); #endif #if XNA if (videoType == VideoTypes.XNA) api = new XNA.Shader(parent, filename, shaderVersion, vsQuality, psQuality, loadedCallback); #endif #if VITA if (videoType == VideoTypes.Vita) api = new Vita.Shader(parent, filename, shaderVersion, vsQuality, psQuality, loadedCallback); #endif if (api == null) Debug.ThrowError("ShaderAPI", "Unsuported InputType: " + videoType); return api; }
public SoundWAV(DisposableI parent, string fileName, int instanceCount, bool looped, Loader.LoadedCallbackMethod loadedCallback) : base(parent) { try { audio = parent.FindParentOrSelfWithException<Audio>(); audio.UpdateCallback += Update; loadedFromContent = true; sound = parent.FindParentOrSelfWithException<RootDisposable>().Content.Load<SoundEffect>(Streams.StripFileExt(fileName)); for (int i = 0; i != instanceCount; ++i) { inactiveInstances.AddLast(new SoundWAVInstance(this, looped)); } } catch (Exception e) { FailedToLoad = true; Loader.AddLoadableException(e); Dispose(); if (loadedCallback != null) loadedCallback(this, false); return; } Loaded = true; if (loadedCallback != null) loadedCallback(this, true); }
protected override void init(Stream stream, bool flip, Loader.LoadedCallbackMethod loadedCallback) { try { using (var image = NSImage.FromStream(stream)) { var rep = image.Representations()[0]; int width = rep.PixelsWide; int height = rep.PixelsHigh; Mipmaps = new Mipmap[1]; Size = new Size2(width, height); var data = new byte[width * height * 4]; var emptyRect = RectangleF.Empty; using (CGContext imageContext = new CGBitmapContext(data, width, height, 8, width*4, CGColorSpace.CreateDeviceRGB(), CGImageAlphaInfo.PremultipliedLast)) using (var cgImage = image.AsCGImage(ref emptyRect, null, null)) { imageContext.DrawImage(new RectangleF(0, 0, width, height), cgImage); Mipmaps[0] = new Mipmap(data, width, height, 1, 4); if (flip) Mipmaps[0].FlipVertical(); } } } catch (Exception e) { FailedToLoad = true; Loader.AddLoadableException(e); if (loadedCallback != null) loadedCallback(this, false); return; } Loaded = true; if (loadedCallback != null) loadedCallback(this, true); }
protected override void init(Stream stream, bool flip, Loader.LoadedCallbackMethod loadedCallback) { try { using (var imageData = NSData.FromStream(stream)) using (var image = UIImage.LoadFromData(imageData)) { int width = (int)image.Size.Width; int height = (int)image.Size.Height; Mipmaps = new Mipmap[1]; Size = new Size2(width, height); var data = new byte[width * height * 4]; using (CGContext imageContext = new CGBitmapContext(data, width, height, 8, width*4, CGColorSpace.CreateDeviceRGB(), CGImageAlphaInfo.PremultipliedLast)) { imageContext.DrawImage(new RectangleF(0, 0, width, height), image.CGImage); Mipmaps[0] = new Mipmap(data, width, height, 1, 4); if (flip) Mipmaps[0].FlipVertical(); } } } catch (Exception e) { FailedToLoad = true; Loader.AddLoadableException(e); if (loadedCallback != null) loadedCallback(this, false); return; } Loaded = true; if (loadedCallback != null) loadedCallback(this, true); }
private void init(string filename, Stream stream, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback) #endif { try { video = Parent.FindParentOrSelfWithException<Video>(); #if WIN32 shaderVersion = (shaderVersion == ShaderVersions.Max) ? video.Cap.MaxShaderVersion : shaderVersion; var code = getShaders(stream); vertex = new VertexShader(this, code[0], shaderVersion); pixel = new PixelShader(this, code[1], shaderVersion); #else await getReflections(filename); var code = getShaders(stream); vertex = new VertexShader(this, code[0]); pixel = new PixelShader(this, code[1]); #endif variables = new List<ShaderVariable>(); resources = new List<ShaderResource>(); } catch (Exception e) { FailedToLoad = true; Loader.AddLoadableException(e); Dispose(); if (loadedCallback != null) loadedCallback(this, false); return; } Loaded = true; if (loadedCallback != null) loadedCallback(this, true); }
public Model(IDisposableResource parent, SoftwareModel softwareModel, bool loadColors, bool loadUVs, bool loadNormals, string contentDirectory, Dictionary<string,Type> materialTypes, List<MaterialFieldBinder> value1BinderTypes, List<MaterialFieldBinder> value2BinderTypes, List<MaterialFieldBinder> value3BinderTypes, List<MaterialFieldBinder> value4BinderTypes, List<MaterialFieldBinder> textureBinderTypes, Dictionary<string,string> fileExtOverrides, int classicInstanceCount, Loader.LoadedCallbackMethod loadedCallback) : base(parent) { Loader.AddLoadable(this); new LoadWaiter(new ILoadable[]{softwareModel}, delegate(object sender, bool succeeeded) { if (succeeeded) { using (var stream = new MemoryStream()) { try { Model.Save(stream, false, softwareModel, loadColors, loadUVs, loadNormals); stream.Position = 0; } catch (Exception e) { FailedToLoad = true; Dispose(); if (loadedCallback != null) loadedCallback(this, false); } if (!FailedToLoad) init(null, stream, contentDirectory, materialTypes, value1BinderTypes, value2BinderTypes, value3BinderTypes, value4BinderTypes, textureBinderTypes, fileExtOverrides, classicInstanceCount, loadedCallback); } } else { FailedToLoad = true; Dispose(); if (loadedCallback != null) loadedCallback(this, false); } }); }
protected override void init(DisposableI parent, Stream stream, int instanceCount, bool looped, Loader.LoadedCallbackMethod loadedCallback) { base.init(parent, stream, instanceCount, looped, loadedCallback); try { audio = parent.FindParentOrSelfWithException<Audio>(); audio.UpdateCallback += Update; this.data = base.data; this.channels = base.channels; this.bitDepth = base.bitDepth; desc = AudioUnitUtils.AUCanonicalASBD(sampleRate, channels); desc.FormatFlags = (AudioFormatFlags)((int)AudioFormatFlags.IsSignedInteger | (int)AudioFormatFlags.IsPacked | (int)AudioFormatFlags.IsNonInterleaved); for (int i = 0; i != instanceCount; ++i) { inactiveInstances.AddLast(new SoundWAVInstance(this, looped)); } } catch (Exception e) { FailedToLoad = true; Loader.AddLoadableException(e); Dispose(); if (loadedCallback != null) loadedCallback(this, false); return; } Loaded = true; if (loadedCallback != null) loadedCallback(this, true); }
public static ITexture2D New(VideoTypes videoType, IDisposableResource parent, Image image, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback) { ITexture2D api = null; #if WIN32 if (videoType == VideoTypes.D3D9) api = new D3D9.Texture2D(parent, image, width, height, generateMipmaps, multiSampleType, surfaceFormat, renderTargetUsage, usage, loadedCallback); #endif #if WIN32 || WINRT || WP8 if (videoType == VideoTypes.D3D11) api = new D3D11.Texture2D(parent, image, width, height, generateMipmaps, multiSampleType, surfaceFormat, renderTargetUsage, usage, loadedCallback); #endif #if WIN32 || OSX || LINUX || iOS || ANDROID || NaCl if (videoType == VideoTypes.OpenGL) api = new OpenGL.Texture2D(parent, image, width, height, generateMipmaps, multiSampleType, surfaceFormat, renderTargetUsage, usage, loadedCallback); #endif #if XNA if (videoType == VideoTypes.XNA) api = new XNA.Texture2D(parent, image, width, height, generateMipmaps, multiSampleType, surfaceFormat, renderTargetUsage, usage, loadedCallback); #endif #if VITA if (videoType == VideoTypes.Vita) api = new Vita.Texture2D(parent, image, width, height, generateMipmaps, multiSampleType, surfaceFormat, renderTargetUsage, usage, loadedCallback); #endif if (api == null) Debug.ThrowError("Texture2DAPI", "Unsuported InputType: " + videoType); return api; }
protected override void init(IDisposableResource parent, Stream stream, int instanceCount, bool looped, Loader.LoadedCallbackMethod loadedCallback) { base.init(parent, stream, instanceCount, looped, loadedCallback); try { audio = parent.FindParentOrSelfWithException<Audio>(); audio.UpdateCallback += Update; com = new SoundWAVCom(); var error = com.Init(audio.com, data, formatCode, channels, sampleRate, formatAvgBytesPerSec, formatBlockAlign, bitDepth, formatExtraSize); data = null; for (int i = 0; i != instanceCount; ++i) { inactiveInstances.AddLast(new SoundWAVInstance(this, looped)); } } catch (Exception e) { FailedToLoad = true; Loader.AddLoadableException(e); Dispose(); if (loadedCallback != null) loadedCallback(this, false); return; } Loaded = true; if (loadedCallback != null) loadedCallback(this, true); }
protected override void init(Stream stream, bool flip, Loader.LoadedCallbackMethod loadedCallback) { ImageType = ImageTypes.BMP; ImageFormat = ImageFormats.BMP; SurfaceFormat = SurfaceFormats.RGBAx8; base.init(stream, flip, loadedCallback); }
protected virtual void init(IDisposableResource parent, Stream stream, int instanceCount, bool looped, Loader.LoadedCallbackMethod loadedCallback) { using (stream) using (var reader = new BinaryReader(stream)) { readMetaData(stream, reader); data = reader.ReadBytes(dataSize); } }
public SoundWAV(IDisposableResource parent, string filename, int instanceCount, bool looped, Loader.LoadedCallbackMethod loadedCallback) : base(parent) { for (int i = 0; i != instanceCount; ++i) { inactiveInstances.AddLast(new SoundWAVInstance(this, looped)); } Loaded = true; if (loadedCallback != null) loadedCallback(this, true); }
protected override void init(Stream stream, bool flip, Loader.LoadedCallbackMethod loadedCallback) { this.flip = flip; this.loadedCallback = loadedCallback; ((SilverlightApplication)OS.CurrentApplication).MainUserControl.Dispatcher.BeginInvoke(delegate { var image = new BitmapImage(); image.ImageOpened += bs_ImageOpened; image.ImageFailed += bs_ImageFailed; image.SetSource(stream); }); }
protected unsafe override void init(DisposableI parent, Stream stream, int instanceCount, bool looped, Loader.LoadedCallbackMethod loadedCallback) { base.init(parent, stream, instanceCount, looped, loadedCallback); try { audio = parent.FindParentOrSelfWithException<Audio>(); audio.UpdateCallback += Update; // Gen buffer uint bufferTEMP = 0; AL.GenBuffers(1, &bufferTEMP); buffer = bufferTEMP; if (buffer == 0) Debug.ThrowError("SoundWAV", "Failed to create buffer"); // load wav data int format = 0; if (bitDepth == 16) { if (channels == 2) format = AL.FORMAT_STEREO16; else format = AL.FORMAT_MONO16; } else { if (channels == 2) format = AL.FORMAT_STEREO8; else format = AL.FORMAT_MONO8; } fixed (byte* dataPtr = data) { AL.BufferData(buffer, format, dataPtr, data.Length, sampleRate); } data = null; // create instances for (int i = 0; i != instanceCount; ++i) { inactiveInstances.AddLast(new SoundWAVInstance(this, looped)); } } catch (Exception e) { FailedToLoad = true; Loader.AddLoadableException(e); Dispose(); if (loadedCallback != null) loadedCallback(this, false); return; } Loaded = true; if (loadedCallback != null) loadedCallback(this, true); }
public static void Init(DisposableI parent, string contentPath, string tag, ShaderVersions shaderVersion, Loader.LoadedCallbackMethod loadedCallback) { Shader = ShaderAPI.New(parent, contentPath + tag + "QuickDraw3Color.rs", shaderVersion, delegate(object sender, bool succeeded) { if (succeeded) { init((ShaderI)sender, loadedCallback); } else { FailedToLoad = true; if (loadedCallback != null) loadedCallback(null, false); } }); }
public ImageOSX(string fileName, bool flip, Loader.LoadedCallbackMethod loadedCallback) { new StreamLoader(fileName, delegate(object sender, bool succeeded) { if (succeeded) { init(((StreamLoader)sender).LoadedStream, flip, loadedCallback); } else { FailedToLoad = true; if (loadedCallback != null) loadedCallback(this, false); } }); }
public SoundWAV(IDisposableResource parent, string filename, int instanceCount, bool looped, Loader.LoadedCallbackMethod loadedCallback) : base(parent) { new StreamLoader(filename, delegate(object sender, bool succeeded) { if (succeeded) { init(parent, ((StreamLoader)sender).LoadedStream, instanceCount, looped, loadedCallback); } else { FailedToLoad = true; Dispose(); if (loadedCallback != null) loadedCallback(this, false); } }); }
public Font(DisposableI parent, ShaderI shader, Texture2DI texture, string metricsFileName, Loader.LoadedCallbackMethod loadedCallback) : base(parent) { new StreamLoader(metricsFileName, delegate(object sender, bool succeeded) { if (succeeded) { init(shader, texture, ((StreamLoader)sender).LoadedStream, metricsFileName, loadedCallback); } else { FailedToLoad = true; Dispose(); if (loadedCallback != null) loadedCallback(this, false); } }); }
public Model(IDisposableResource parent, string filename, string contentDirectory, Dictionary<string,Type> materialTypes, List<MaterialFieldBinder> value1BinderTypes, List<MaterialFieldBinder> value2BinderTypes, List<MaterialFieldBinder> value3BinderTypes, List<MaterialFieldBinder> value4BinderTypes, List<MaterialFieldBinder> textureBinderTypes, Dictionary<string,string> fileExtOverrides, int classicInstanceCount, Loader.LoadedCallbackMethod loadedCallback) : base(parent) { Loader.AddLoadable(this); new StreamLoader(filename, delegate(object sender, bool succeeded) { if (succeeded) { init(filename, ((StreamLoader)sender).LoadedStream, contentDirectory, materialTypes, value1BinderTypes, value2BinderTypes, value3BinderTypes, value4BinderTypes, textureBinderTypes, fileExtOverrides, classicInstanceCount, loadedCallback); } else { FailedToLoad = true; Dispose(); if (loadedCallback != null) loadedCallback(this, false); } }); }
public SoftwareModel(string filename, Loader.LoadedCallbackMethod loadedCallback) { string fileType = Streams.GetFileExt(filename).ToLower(); if (fileType != ".rmx") Debug.ThrowError("SoftwareModel", "Unsuported file type: " + fileType); new StreamLoader(filename, delegate(object sender, bool succeeded) { if (succeeded) { init(((StreamLoader)sender).LoadedStream, loadedCallback); } else { FailedToLoad = true; if (loadedCallback != null) loadedCallback(this, false); } }); }
public Texture2D(IDisposableResource parent, string filename, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback) : base(parent) { Image.New(filename, false, delegate (object sender, bool succeeded) { if (succeeded) { var image = (Image)sender; init(parent, image, image.Size.Width, image.Size.Height, generateMipmaps, MultiSampleTypes.None, image.SurfaceFormat, RenderTargetUsage.PlatformDefault, usage, false, loadedCallback); } else { FailedToLoad = true; Dispose(); if (loadedCallback != null) loadedCallback(this, false); } }); }
private void init(string filename, Stream stream, Loader.LoadedCallbackMethod loadedCallback) #endif { try { if (filename != null) { fromFile = true; #if WINRT || WP8 LoadedStream = await Streams.OpenFile(filename); #elif NaCl this.loadedCallback = loadedCallback; filename = filename.Replace('\\', '/'); file = new NaClFile(filename); Streams.NaClFileLoadedCallback += fileLoaded; Streams.addPendingFile(file); Loader.AddLoadable(this); return; #else LoadedStream = Streams.OpenFile(filename); #endif } else { fromFile = false; LoadedStream = stream; } } catch (Exception e) { FailedToLoad = true; Loader.AddLoadableException(e); Dispose(); if (loadedCallback != null) loadedCallback(this, false); return; } Loaded = true; if (loadedCallback != null) loadedCallback(this, true); }
protected override void init(Stream stream, bool flip, Loader.LoadedCallbackMethod loadedCallback) { try { using (var bitmap = Android.Graphics.BitmapFactory.DecodeStream(stream)) { int width = bitmap.Width; int height = bitmap.Height; Mipmaps = new Mipmap[1]; Size = new Size2(bitmap.Width, bitmap.Height); var pixels = new int[width * height]; bitmap.GetPixels(pixels, 0, width, 0, 0, width, height); // Convert to bytes var data = new byte[pixels.Length * 4]; int i3 = 0; for (int i2 = 0; i2 != pixels.Length; ++i2) { data[i3] = (byte)Color.GetRedComponent(pixels[i2]); data[i3+1] = (byte)Color.GetGreenComponent(pixels[i2]); data[i3+2] = (byte)Color.GetBlueComponent(pixels[i2]); data[i3+3] = (byte)Color.GetAlphaComponent(pixels[i2]); i3 += 4; } Mipmaps[0] = new Mipmap(data, width, height, 1, 4); if (flip) Mipmaps[0].FlipVertical(); } } catch (Exception e) { FailedToLoad = true; Loader.AddLoadableException(e); if (loadedCallback != null) loadedCallback(this, false); return; } Loaded = true; if (loadedCallback != null) loadedCallback(this, true); }
public Shader(IDisposableResource parent, string filename, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback) : base(parent) { #if WINRT || WP8 Loader.AddLoadable(this); filename = Streams.StripFileExt(filename) + ".mrs"; #endif new StreamLoader(filename, delegate(object sender, bool succeeded) { if (succeeded) { init(filename, ((StreamLoader)sender).LoadedStream, shaderVersion, vsQuality, psQuality, loadedCallback); } else { FailedToLoad = true; Dispose(); if (loadedCallback != null) loadedCallback(this, false); } }); }
public Shader(DisposableI parent, string fileName, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback) : base(parent) { #if SILVERLIGHT new StreamLoader(Streams.StripFileExt(fileName) + ".mrs", delegate(object sender, bool succeeded) { if (succeeded) { init(fileName, ((StreamLoader)sender).LoadedStream, shaderVersion, loadedCallback); } else { FailedToLoad = true; Dispose(); if (loadedCallback != null) loadedCallback(this, false); } }); #else init(fileName, null, shaderVersion, loadedCallback); #endif }
protected override bool init(IDisposableResource parent, Image image, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, bool isRenderTarget, Loader.LoadedCallbackMethod loadedCallback) { initSuccess = base.init(parent, image, width, height, generateMipmaps, multiSampleType, surfaceFormat, renderTargetUsage, usage, true, loadedCallback); if (!initSuccess) return false; try { if (usage == BufferUsages.Write) Debug.ThrowError("RenderTarget", "Only Textures may be writable"); if (image != null) { width = image.Size.Width; height = image.Size.Height; surfaceFormat = image.SurfaceFormat; } renderTargetCom = new RenderTargetCom(); var error = renderTargetCom.Init(video.com, width, height, com, 0, video.surfaceFormat(surfaceFormat), usage == BufferUsages.Read); switch (error) { case RenderTargetError.RenderTargetView: Debug.ThrowError("RenderTarget", "Failed to create RenderTargetView"); break; case RenderTargetError.StagingTexture: Debug.ThrowError("RenderTarget", "Failed to create Staging Texture"); break; } } catch (Exception e) { FailedToLoad = true; Loader.AddLoadableException(e); Dispose(); if (loadedCallback != null) loadedCallback(this, false); return false; } Loaded = true; if (loadedCallback != null) loadedCallback(this, true); return true; }
public Texture2D(DisposableI parent, string fileName, bool generateMipmaps, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback) : base(parent) { #if SILVERLIGHT Image.New(fileName, false, delegate(object sender, bool succeeded) { if (succeeded) { var image = (Image)sender; init(parent, null, image, image.Size.Width, image.Size.Height, generateMipmaps, MultiSampleTypes.None, SurfaceFormats.Unknown, RenderTargetUsage.PlatformDefault, usage, false, loadedCallback); } else { FailedToLoad = true; Dispose(); if (loadedCallback != null) loadedCallback(this, false); } }); #else init(parent, fileName, null, 0, 0, generateMipmaps, MultiSampleTypes.None, SurfaceFormats.Unknown, RenderTargetUsage.PlatformDefault, usage, false, loadedCallback); #endif }
protected override async void init(Stream stream, bool flip, Loader.LoadedCallbackMethod loadedCallback) { try { using (var memoryStream = new InMemoryRandomAccessStream()) { await RandomAccessStream.CopyAsync(stream.AsInputStream(), memoryStream); var decoder = await BitmapDecoder.CreateAsync(memoryStream); var frame = await decoder.GetFrameAsync(0); var transform = new BitmapTransform(); transform.InterpolationMode = BitmapInterpolationMode.NearestNeighbor; transform.Rotation = BitmapRotation.None; var dataProvider = await decoder.GetPixelDataAsync(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Straight, transform, ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.ColorManageToSRgb); var data = dataProvider.DetachPixelData(); int width = (int)decoder.PixelWidth; int height = (int)decoder.PixelHeight; Mipmaps = new Mipmap[1]; Size = new Size2(width, height); Mipmaps[0] = new Mipmap(data, width, height, 1, 4); if (flip) Mipmaps[0].FlipVertical(); } } catch (Exception e) { FailedToLoad = true; Loader.AddLoadableException(e); if (loadedCallback != null) loadedCallback(this, false); return; } Loaded = true; if (loadedCallback != null) loadedCallback(this, true); }
private async void init(string filename, Stream stream, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback)
protected override bool init(DisposableI parent, string fileName, Image image, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, bool isRenderTarget, Loader.LoadedCallbackMethod loadedCallback) { if (!base.init(parent, fileName, image, width, height, false, multiSampleType, surfaceFormat, renderTargetUsage, usage, true, loadedCallback)) return false; try { if (usage == BufferUsages.Write) Debug.ThrowError("RenderTarget", "Only Textures may be writable"); if (fileName == null) { // TODO: handle multiSampleType types #if SILVERLIGHT var xUsage = X.RenderTargetUsage.PreserveContents; #else var xUsage = X.RenderTargetUsage.PlatformContents; #endif switch (renderTargetUsage) { case RenderTargetUsage.PlatformDefault: #if SILVERLIGHT xUsage = X.RenderTargetUsage.PreserveContents; #else xUsage = X.RenderTargetUsage.PlatformContents; #endif break; case RenderTargetUsage.PreserveContents: xUsage = X.RenderTargetUsage.PreserveContents; break; case RenderTargetUsage.DiscardContents: xUsage = X.RenderTargetUsage.DiscardContents; break; } X.DepthFormat format = X.DepthFormat.None; if (initDepthStencilFormat != DepthStencilFormats.None) { switch (initDepthStencilFormat) { case DepthStencilFormats.Defualt: format = X.DepthFormat.Depth24; break; case DepthStencilFormats.Depth24Stencil8: format = X.DepthFormat.Depth24Stencil8; break; case DepthStencilFormats.Depth16: format = X.DepthFormat.Depth16; break; case DepthStencilFormats.Depth24: format = X.DepthFormat.Depth24; break; default: Debug.ThrowError("RenderTarget", "Unsuported DepthStencilFormat type"); break; } } renderTarget = new X.RenderTarget2D(video.Device, width, height, false, Video.surfaceFormat(surfaceFormat), format, 0, xUsage); } else { Debug.ThrowError("RenderTarget", "(Load image data into RenderTarget Texture) -- Not implemented yet..."); } texture = renderTarget; } catch (Exception e) { FailedToLoad = true; Loader.AddLoadableException(e); Dispose(); if (loadedCallback != null) loadedCallback(this, false); return false; } Loaded = true; if (loadedCallback != null) loadedCallback(this, true); return true; }