internal static SurfaceFormat surfaceFormat(SurfaceFormats surfaceFormat)
{
switch (surfaceFormat)
{
case SurfaceFormats.Defualt: return(SurfaceFormat.Color);
case SurfaceFormats.RGBx565: return(SurfaceFormat.Bgr565);
case SurfaceFormats.RGBAx4: return(SurfaceFormat.Bgra4444);
case SurfaceFormats.RGBx5_Ax1: return(SurfaceFormat.Bgra5551);
case SurfaceFormats.RGBAx8: return(SurfaceFormat.Color);
#if !SILVERLIGHT
case SurfaceFormats.RGBx10_Ax2: return(SurfaceFormat.Rgba1010102);
case SurfaceFormats.RGBAx16f: return(SurfaceFormat.HalfVector4);
case SurfaceFormats.RGBAx32f: return(SurfaceFormat.Vector4);
#endif
default:
Debug.ThrowError("RenderTarget", "Unsuported SurfaceFormat");
return(SurfaceFormat.Color);
}
}
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;
}
internal REIGN_D3DFORMAT surfaceFormat(SurfaceFormats surfaceFormat)
{
switch (surfaceFormat)
{
case SurfaceFormats.Defualt: return(REIGN_D3DFORMAT.A8R8G8B8);
case SurfaceFormats.DXT1: return(REIGN_D3DFORMAT.DXT1);
case SurfaceFormats.DXT3: return(REIGN_D3DFORMAT.DXT3);
case SurfaceFormats.DXT5: return(REIGN_D3DFORMAT.DXT5);
case SurfaceFormats.RGBx565: return(REIGN_D3DFORMAT.R5G6B5);
case SurfaceFormats.RGBAx4: return(REIGN_D3DFORMAT.A4R4G4B4);
case SurfaceFormats.RGBx5_Ax1: return(REIGN_D3DFORMAT.A1R5G5B5);
case SurfaceFormats.RGBAx8: return(REIGN_D3DFORMAT.A8R8G8B8);
case SurfaceFormats.RGBx10_Ax2: return(REIGN_D3DFORMAT.A2R10G10B10);
case SurfaceFormats.RGBAx16f: return(REIGN_D3DFORMAT.A16B16G16R16F);
case SurfaceFormats.RGBAx32f: return(REIGN_D3DFORMAT.A32B32G32R32F);
default:
Debug.ThrowError("Video", "Unsuported SurfaceFormat: " + surfaceFormat);
return(REIGN_D3DFORMAT.A8R8G8B8);
}
}
internal static int surfaceFormat(SurfaceFormats surfaceFormat, out uint pixelOrder, out uint byteSizes)
{
switch (surfaceFormat)
{
case SurfaceFormats.Defualt:
pixelOrder = GL.RGBA;
#if iOS || ANDROID || NaCl || RPI
byteSizes = GL.UNSIGNED_SHORT_4_4_4_4;
return((int)GL.RGBA4);
#else
byteSizes = GL.UNSIGNED_BYTE;
return(GL.RGBA8);
#endif
case SurfaceFormats.RGBx565:
pixelOrder = GL.RGB;
byteSizes = GL.UNSIGNED_SHORT_5_6_5;
return(GL.RGB565);
case SurfaceFormats.RGBAx4:
pixelOrder = GL.RGBA;
byteSizes = GL.UNSIGNED_SHORT_4_4_4_4;
return(GL.RGBA4);
case SurfaceFormats.RGBx5_Ax1:
pixelOrder = GL.RGBA;
byteSizes = GL.UNSIGNED_SHORT_5_5_5_1;
return(GL.RGB5_A1);
case SurfaceFormats.RGBAx8:
pixelOrder = GL.RGBA;
byteSizes = GL.UNSIGNED_BYTE;
return(GL.RGBA8);
case SurfaceFormats.RGBx10_Ax2:
pixelOrder = GL.RGBA;
byteSizes = GL.UNSIGNED_INT_10_10_10_2;
return(GL.RGB10_A2);
case SurfaceFormats.RGBAx16f:
pixelOrder = GL.RGBA;
byteSizes = GL.FLOAT;
return(GL.RGBA16F);
case SurfaceFormats.RGBAx32f:
pixelOrder = GL.RGBA;
byteSizes = GL.FLOAT;
return(GL.RGBA32F);
default:
Debug.ThrowError("Video", "Unsuported SurfaceFormat: " + surfaceFormat);
pixelOrder = 0;
byteSizes = 0;
return(0);
}
}
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);
}
});
}
public static int CalculatePixelByteSize(SurfaceFormats surfaceFormat, int width, int height)
{
switch (surfaceFormat)
{
case SurfaceFormats.RGBx565: return(width * height * 2);
case SurfaceFormats.RGBAx4: return(width * height * 2);
case SurfaceFormats.RGBx5_Ax1: return(width * height * 2);
case SurfaceFormats.RGBAx8: return(width * height * 4);
case SurfaceFormats.RGBx10_Ax2: return(width * height * 4);
case SurfaceFormats.RGBAx16f: return((width * height * 4) * 2);
case SurfaceFormats.RGBAx32f: return((width * height * 4) * 4);
case SurfaceFormats.DXT1: return((width * height) / 2);
case SurfaceFormats.DXT3: return(width * height);
case SurfaceFormats.DXT5: return(width * height);
case SurfaceFormats.ATC_RGB: return((width * height) / 2);
case SurfaceFormats.ATC_RGBA_Explicit: return(width * height);
case SurfaceFormats.ATC_RGBA_Interpolated: return(width * height);
case SurfaceFormats.PVR_RGB_2: return((width * height) / 4);
case SurfaceFormats.PVR_RGB_4: return((width * height) / 2);
case SurfaceFormats.PVR_RGBA_2: return((width * height) / 4);
case SurfaceFormats.PVR_RGBA_4: return((width * height) / 2);
default: Debug.ThrowError("Image", string.Format("Unsuported surface format: {0}", surfaceFormat)); break;
}
return(-1);
}
internal static PixelFormat surfaceFormat(SurfaceFormats surfaceFormat)
{
switch (surfaceFormat)
{
case SurfaceFormats.Defualt: return(PixelFormat.Rgba4444);
case SurfaceFormats.RGBx565: return(PixelFormat.Rgb565);
case SurfaceFormats.RGBAx4: return(PixelFormat.Rgba4444);
case SurfaceFormats.RGBx5_Ax1: return(PixelFormat.Rgba5551);
case SurfaceFormats.RGBAx8: return(PixelFormat.Rgba);
case SurfaceFormats.RGBAx16f: return(PixelFormat.RgbaH);
default:
Debug.ThrowError("RenderTarget", "Unsuported SurfaceFormat");
return(PixelFormat.Rgba);
}
}
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;
}
internal REIGN_DXGI_FORMAT surfaceFormat(SurfaceFormats surfaceFormat)
{
switch (surfaceFormat)
{
case SurfaceFormats.Defualt:
#if ARM
return(REIGN_DXGI_FORMAT.B4G4R4A4_UNORM);
#else
return(REIGN_DXGI_FORMAT.R8G8B8A8_UNORM);
#endif
case SurfaceFormats.DXT1: return(REIGN_DXGI_FORMAT.BC1_UNORM);
case SurfaceFormats.DXT3: return(REIGN_DXGI_FORMAT.BC2_UNORM);
case SurfaceFormats.DXT5: return(REIGN_DXGI_FORMAT.BC3_UNORM);
case SurfaceFormats.RGBx565: return(REIGN_DXGI_FORMAT.B5G6R5_UNORM);
#if WINRT || WP8
case SurfaceFormats.RGBAx4: return(REIGN_DXGI_FORMAT.B4G4R4A4_UNORM);
#endif
case SurfaceFormats.RGBx5_Ax1: return(REIGN_DXGI_FORMAT.B5G5R5A1_UNORM);
case SurfaceFormats.RGBAx8: return(REIGN_DXGI_FORMAT.R8G8B8A8_UNORM);
case SurfaceFormats.RGBx10_Ax2: return(REIGN_DXGI_FORMAT.R10G10B10A2_UNORM);
case SurfaceFormats.RGBAx16f: return(REIGN_DXGI_FORMAT.R16G16B16A16_FLOAT);
case SurfaceFormats.RGBAx32f: return(REIGN_DXGI_FORMAT.R32G32B32A32_FLOAT);
default:
Debug.ThrowError("Video", "Unsuported SurfaceFormat: " + surfaceFormat);
return(REIGN_DXGI_FORMAT.R8G8B8A8_UNORM);
}
}
protected unsafe virtual 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)
{
try
{
if (usage == BufferUsages.Read && !isRenderTarget) Debug.ThrowError("Texture2D", "Only RenderTargets may be readable");
video = parent.FindParentOrSelfWithException<Video>();
if (isRenderTarget) generateMipmaps = false;
uint texturesTEMP = 0;
GL.GenTextures(1, &texturesTEMP);
Texture = texturesTEMP;
if (Texture == 0) Debug.ThrowError("Texture2D", "Failed to Generate Texture");
GL.BindTexture(GL.TEXTURE_2D, Texture);
if (!generateMipmaps) GL.TexParameteri(GL.TEXTURE_2D, GL.TEXTURE_MIN_FILTER, GL.LINEAR);
else GL.TexParameteri(GL.TEXTURE_2D, GL.TEXTURE_MIN_FILTER, GL.LINEAR_MIPMAP_LINEAR);
GL.TexParameteri(GL.TEXTURE_2D, GL.TEXTURE_MAG_FILTER, GL.LINEAR);
hasMipmaps = false;
if (image != null)
{
var imageType = image.GetType();
#if NaCl
if (imageType == typeof(ImageBMPC))
#else
if (imageType == typeof(ImagePNG) || imageType == typeof(ImageJPG) || imageType == typeof(ImageBMP) || imageType == typeof(ImageBMPC))
#endif
{
uint pixelOrder, byteSizes;
int format = Video.surfaceFormat(surfaceFormat, out pixelOrder, out byteSizes);
var mipmap = image.Mipmaps[0];
fixed (byte* data = mipmap.Data)
{
GL.TexImage2D(GL.TEXTURE_2D, 0, format, mipmap.Size.Width, mipmap.Size.Height, 0, pixelOrder, byteSizes, data);
if (generateMipmaps)
{
hasMipmaps = true;
GL.GenerateMipmap(GL.TEXTURE_2D);
}
}
}
else if (imageType == typeof(ImageDDS) || imageType == typeof(ImagePVR))
{
if (image.Mipmaps.Length != Image.Mipmap.CalculateMipmapLvls(image.Size.Width, image.Size.Height))
{
Debug.ThrowError("Texture2D", "Compressed Textures require full mipmap chain");
}
GL.TexParameteri(GL.TEXTURE_2D, GL.TEXTURE_MIN_FILTER, GL.LINEAR_MIPMAP_LINEAR);
hasMipmaps = true;
bool compressed = false;
uint format = 0;
string errorType = null;
if (imageType == typeof(ImageDDS))
{
var imageDDS = (ImageDDS)image;
compressed = imageDDS.Compressed;
format = imageDDS.FormatGL;
errorType = "DDS";
}
else if (imageType == typeof(ImagePVR))
{
var imagePVR = (ImagePVR)image;
compressed = imagePVR.Compressed;
format = imagePVR.FormatGL;
errorType = "PVR";
}
if (compressed)
{
for (int i = 0; i < image.Mipmaps.Length; ++i)
{
var mipmap = image.Mipmaps[i];
fixed (byte* data = mipmap.Data)
{
// look up:: libtxc_dxtn.so for linux with mesa
GL.CompressedTexImage2D(GL.TEXTURE_2D, i, format, mipmap.Size.Width, mipmap.Size.Height, 0, mipmap.Data.Length, data);
}
}
}
else
{
Debug.ThrowError("Texture2D", "Loading uncompresed " + errorType + " textures not supported");
}
}
Size = image.Size;
PixelByteSize = image.CalculatePixelByteSize();
}
else
{
//GL.TexImage2D(GL.TEXTURE_2D, 0, Video.surfaceFormat(surfaceFormat), width, height, 0, GL.RGBA, GL.UNSIGNED_BYTE, IntPtr.Zero.ToPointer());
uint pixelOrder, byteSizes;
int format = Video.surfaceFormat(surfaceFormat, out pixelOrder, out byteSizes);
GL.TexImage2D(GL.TEXTURE_2D, 0, format, width, height, 0, pixelOrder, byteSizes, IntPtr.Zero.ToPointer());
if (generateMipmaps)
{
hasMipmaps = true;
GL.GenerateMipmap(GL.TEXTURE_2D);
}
Size = new Size2(width, height);
PixelByteSize = Image.CalculatePixelByteSize((surfaceFormat == SurfaceFormats.Defualt ? Video.DefaultSurfaceFormat() : surfaceFormat), width, height);
}
SizeF = Size.ToVector2();
uint error;
string errorName;
if (Video.checkForError(out error, out errorName))
{
Debug.ThrowError("Texture2D", string.Format("{0} {1}: Failed to load/create texture", error, errorName));
}
}
catch (Exception e)
{
FailedToLoad = true;
Loader.AddLoadableException(e);
Dispose();
if (loadedCallback != null) loadedCallback(this, false);
return false;
}
if (!isRenderTarget)
{
Loaded = true;
if (loadedCallback != null) loadedCallback(this, true);
}
return true;
}
public Texture2D(IDisposableResource parent, Image image, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback)
: base(parent)
{
init(parent, image, width, height, generateMipmaps, multiSampleType, surfaceFormat, renderTargetUsage, usage, false, loadedCallback);
}
protected virtual bool init(IDisposableResource parent, Image image, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, bool isRenderTarget, bool lockable, Loader.LoadedCallbackMethod loadedCallback)
{
byte[][] mipmaps = null;
int[] mipmapSizes = null, mipmapPitches = null;
try
{
video = parent.FindParentOrSelfWithException <Video>();
if (isRenderTarget)
{
generateMipmaps = false;
}
// load image data
if (image != null)
{
mipmaps = new byte[image.Mipmaps.Length][];
mipmapSizes = new int[image.Mipmaps.Length];
mipmapPitches = new int[image.Mipmaps.Length];
for (int i = 0; i != mipmaps.Length; ++i)
{
var imageMipmap = image.Mipmaps[i];
mipmaps[i] = image.Compressed ? imageMipmap.Data : imageMipmap.SwapRBColorChannels();
mipmapSizes[i] = imageMipmap.Data.Length;
mipmapPitches[i] = imageMipmap.Pitch;
}
Size = image.Size;
surfaceFormat = image.SurfaceFormat;
PixelByteSize = image.CalculatePixelByteSize();
}
else
{
if (width == 0 || height == 0)
{
Debug.ThrowError("Texture2D", "Width or Height cannot be 0");
}
Size = new Size2(width, height);
PixelByteSize = Image.CalculatePixelByteSize((surfaceFormat == SurfaceFormats.Defualt ? Video.DefaultSurfaceFormat() : surfaceFormat), width, height);
}
TexelOffset = (1 / Size.ToVector2()) * .5f;
SizeF = Size.ToVector2();
// init texture
REIGN_D3DUSAGE nativeUsage = isRenderTarget ? REIGN_D3DUSAGE.RENDERTARGET : REIGN_D3DUSAGE.NONE;
REIGN_D3DPOOL nativePool = (mipmaps != null && !video.Caps.ExDevice) ? REIGN_D3DPOOL.MANAGED : REIGN_D3DPOOL.DEFAULT;
if (usage == BufferUsages.Read)
{
if (!isRenderTarget)
{
Debug.ThrowError("Texture2D", "Only RenderTargets may be readable");
}
// NOTE: Staging texture and states will be created in the RenderTarget
}
if (usage == BufferUsages.Write)
{
if (mipmaps != null)
{
if (video.Caps.ExDevice)
{
nativeUsage |= REIGN_D3DUSAGE.DYNAMIC;
}
}
else
{
nativeUsage |= REIGN_D3DUSAGE.DYNAMIC;
}
}
com = new Texture2DCom();
var error = com.Init(video.com, Size.Width, Size.Height, generateMipmaps, mipmaps, mipmapSizes, mipmapPitches, 0, nativePool, nativeUsage, video.surfaceFormat(surfaceFormat), isRenderTarget);
switch (error)
{
case TextureError.Texture: Debug.ThrowError("Texture2D", "Failed to create Texture2D"); break;
case TextureError.SystemTexture: Debug.ThrowError("Texture2D", "Failed to create System Texture2D"); break;
}
if (!video.Caps.ExDevice && nativePool != REIGN_D3DPOOL.MANAGED)
{
LostDevice_image = image;
LostDevice_width = width;
LostDevice_height = height;
LostDevice_generateMipmaps = generateMipmaps;
LostDevice_multiSampleType = multiSampleType;
LostDevice_surfaceFormat = surfaceFormat;
LostDevice_renderTargetUsage = renderTargetUsage;
LostDevice_usage = usage;
LostDevice_isRenderTarget = isRenderTarget;
LostDevice_lockable = lockable;
LostDevice_pool = nativePool;
}
if (nativePool == REIGN_D3DPOOL.DEFAULT && !video.Caps.ExDevice && !video.deviceReseting)
{
video.DeviceLost += deviceLost;
video.DeviceReset += deviceReset;
}
}
catch (Exception e)
{
FailedToLoad = true;
Loader.AddLoadableException(e);
Dispose();
if (loadedCallback != null)
{
loadedCallback(this, false);
}
return(false);
}
if (!isRenderTarget)
{
Loaded = true;
if (loadedCallback != null)
{
loadedCallback(this, true);
}
}
return(true);
}
protected virtual bool init(DisposableI parent, string fileName, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, bool isRenderTarget, Loader.LoadedCallbackMethod loadedCallback)
{
try
{
if (usage == BufferUsages.Read && !isRenderTarget) Debug.ThrowError("Texture2D", "Only RenderTargets may be readable");
video = parent.FindParentOrSelfWithException<Video>();
if (isRenderTarget) generateMipmaps = false;
if (fileName != null)
{
texture = new G.Texture2D("/Application/" + fileName, generateMipmaps);
}
else
{
texture = new G.Texture2D(width, height, generateMipmaps, Video.surfaceFormat(surfaceFormat), isRenderTarget ? G.PixelBufferOption.Renderable : G.PixelBufferOption.None);
}
}
catch (Exception e)
{
FailedToLoad = true;
Loader.AddLoadableException(e);
Dispose();
if (loadedCallback != null) loadedCallback(this, false);
return false;
}
if (!isRenderTarget)
{
Loaded = true;
if (loadedCallback != null) loadedCallback(this, true);
}
return true;
}
public RenderTarget(IDisposableResource parent, Image image, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, DepthStencilFormats depthStencilFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback)
: base(parent, image, width, height, generateMipmaps, multiSampleType, surfaceFormat, renderTargetUsage, usage, loadedCallback)
{
if (initSuccess)
{
initDepthStencil(width, height, depthStencilFormat);
}
}
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, false, loadedCallback);
}
else
{
FailedToLoad = true;
Dispose();
if (loadedCallback != null)
{
loadedCallback(this, false);
}
}
});
}
public Texture2D(DisposableI parent, int width, int height, SurfaceFormats surfaceFormat, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback)
: base(parent)
{
init(parent, null, null, width, height, false, MultiSampleTypes.None, surfaceFormat, RenderTargetUsage.PlatformDefault, usage, false, loadedCallback);
}
public Texture2D(DisposableI parent, int width, int height, SurfaceFormats surfaceFormat, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback)
: base(parent)
{
init(parent, null, null, width, height, false, MultiSampleTypes.None, surfaceFormat, RenderTargetUsage.PlatformDefault, usage, false, loadedCallback);
}
protected virtual bool init(DisposableI parent, string fileName, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, bool isRenderTarget, Loader.LoadedCallbackMethod loadedCallback)
{
try
{
if (usage == BufferUsages.Read && !isRenderTarget)
{
Debug.ThrowError("Texture2D", "Only RenderTargets may be readable");
}
video = parent.FindParentOrSelfWithException <Video>();
if (isRenderTarget)
{
generateMipmaps = false;
}
if (fileName != null)
{
texture = new G.Texture2D("/Application/" + fileName, generateMipmaps);
}
else
{
texture = new G.Texture2D(width, height, generateMipmaps, Video.surfaceFormat(surfaceFormat), isRenderTarget ? G.PixelBufferOption.Renderable : G.PixelBufferOption.None);
}
}
catch (Exception e)
{
FailedToLoad = true;
Loader.AddLoadableException(e);
Dispose();
if (loadedCallback != null)
{
loadedCallback(this, false);
}
return(false);
}
if (!isRenderTarget)
{
Loaded = true;
if (loadedCallback != null)
{
loadedCallback(this, true);
}
}
return(true);
}
protected unsafe 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, false, multiSampleType, surfaceFormat, renderTargetUsage, usage, true, loadedCallback);
if (!initSuccess) return false;
try
{
if (usage == BufferUsages.Write) Debug.ThrowError("RenderTarget", "Only Textures may be writable");
uint frameBufferTEMP = 0;
GL.GenFramebuffers(1, &frameBufferTEMP);
frameBuffer = frameBufferTEMP;
uint error;
string errorName;
if (Video.checkForError(out error, out errorName)) Debug.ThrowError("RenderTarget", string.Format("{0} {1}: Failed to create renderTarget", error, errorName));
}
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;
}
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);
}
public RenderTarget(DisposableI parent, int width, int height, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, DepthStencilFormats depthStencilFormat, BufferUsages usage, RenderTargetUsage renderTargetUsage, Loader.LoadedCallbackMethod loadedCallback)
: base(parent, width, height, surfaceFormat, usage, loadedCallback)
{
initDepthStencilFormat = depthStencilFormat;
}
public static RenderTarget New(DisposableI parent, int width, int height, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, DepthStencilFormats depthStencilFormat, BufferUsages usage, RenderTargetUsage renderTargetUsage, Loader.LoadedCallbackMethod loadedCallback)
{
return(new RenderTarget(parent, width, height, multiSampleType, surfaceFormat, depthStencilFormat, usage, renderTargetUsage, loadedCallback));
}
internal static PixelFormat surfaceFormat(SurfaceFormats surfaceFormat)
{
switch (surfaceFormat)
{
case SurfaceFormats.Defualt: return PixelFormat.Rgba4444;
case SurfaceFormats.RGBx565: return PixelFormat.Rgb565;
case SurfaceFormats.RGBAx4: return PixelFormat.Rgba4444;
case SurfaceFormats.RGBx5_Ax1: return PixelFormat.Rgba5551;
case SurfaceFormats.RGBAx8: return PixelFormat.Rgba;
case SurfaceFormats.RGBAx16f: return PixelFormat.RgbaH;
default:
Debug.ThrowError("RenderTarget", "Unsuported SurfaceFormat");
return PixelFormat.Rgba;
}
}
protected virtual 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)
{
try
{
if (usage == BufferUsages.Read && !isRenderTarget)
{
Debug.ThrowError("Texture2D", "Only RenderTargets may be readable");
}
video = parent.FindParentOrSelfWithException <Video>();
if (!isRenderTarget)
{
if (fileName != null || image != null)
{
#if SILVERLIGHT
texture = new X.Texture2D(video.Device, image.Size.Width, image.Size.Height, image.Mipmaps.Length != 0, Video.surfaceFormat(surfaceFormat));
for (int i = 0; i != image.Mipmaps.Length; ++i)
{
var mipmap = image.Mipmaps[i];
texture.SetData <byte>(i, null, mipmap.Data, 0, mipmap.Data.Length);
}
#else
texture = parent.FindParentOrSelfWithException <RootDisposable>().Content.Load <X.Texture2D>(Streams.StripFileExt(fileName));
loadedFromContentManager = true;
#endif
}
else
{
texture = new X.Texture2D(video.Device, width, height, generateMipmaps, Video.surfaceFormat(surfaceFormat));
}
Size = new Size2(texture.Width, texture.Height);
PixelByteSize = Image.CalculatePixelByteSize(surfaceFormat, texture.Width, texture.Height);
}
else
{
Size = new Size2(width, height);
PixelByteSize = Image.CalculatePixelByteSize(surfaceFormat, width, height);
}
TexelOffset = (1 / Size.ToVector2()) * .5f;
SizeF = Size.ToVector2();
}
catch (Exception e)
{
FailedToLoad = true;
Loader.AddLoadableException(e);
Dispose();
if (loadedCallback != null)
{
loadedCallback(this, false);
}
return(false);
}
if (!isRenderTarget)
{
Loaded = true;
if (loadedCallback != null)
{
loadedCallback(this, true);
}
}
return(true);
}
protected override bool init(DisposableI parent, string fileName, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, bool isRenderTarget, Loader.LoadedCallbackMethod loadedCallback)
{
if (!base.init(parent, fileName, width, height, false, multiSampleType, surfaceFormat, renderTargetUsage, usage, true, loadedCallback))
{
return(false);
}
try
{
if (usage == BufferUsages.Write)
{
Debug.ThrowError("RenderTarget", "Only Textures may be writable");
}
frameBuffer = new G.FrameBuffer();
frameBuffer.SetColorTarget(texture, 0);
}
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 static Texture2D New(DisposableI parent, int width, int height, SurfaceFormats surfaceFormat, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback)
{
return(new Texture2D(parent, width, height, surfaceFormat, usage, loadedCallback));
}
public static IRenderTarget New(IDisposableResource parent, int width, int height, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, DepthStencilFormats depthStencilFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback)
{
return New(VideoAPI.DefaultAPI, parent, (Image)null, width, height, false, multiSampleType, surfaceFormat, depthStencilFormat, renderTargetUsage, usage, loadedCallback);
}
protected virtual 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)
{
long[] mipmaps = null;
int[] mipmapSizes = null, mipmapPitches = null;
try
{
video = parent.FindParentOrSelfWithException<Video>();
if (isRenderTarget) generateMipmaps = false;
// load image data
if (image != null)
{
mipmaps = new long[image.Mipmaps.Length];
mipmapSizes = new int[image.Mipmaps.Length];
mipmapPitches = new int[image.Mipmaps.Length];
for (int i = 0; i != mipmaps.Length; ++i)
{
var imageMipmap = image.Mipmaps[i];
IntPtr mipmapPtr = Marshal.AllocHGlobal(imageMipmap.Data.Length);
Marshal.Copy(imageMipmap.Data, 0, mipmapPtr, imageMipmap.Data.Length);
mipmapSizes[i] = imageMipmap.Data.Length;
mipmapPitches[i] = imageMipmap.Pitch;
mipmaps[i] = mipmapPtr.ToInt64();
}
Size = image.Size;
surfaceFormat = image.SurfaceFormat;
PixelByteSize = image.CalculatePixelByteSize();
}
else
{
if (width == 0 || height == 0) Debug.ThrowError("Texture2D", "Width or Height cannot be 0");
Size = new Size2(width, height);
PixelByteSize = Image.CalculatePixelByteSize((surfaceFormat == SurfaceFormats.Defualt ? Video.DefaultSurfaceFormat() : surfaceFormat), width, height);
}
SizeF = Size.ToVector2();
// init texture
REIGN_D3D11_USAGE usageType = REIGN_D3D11_USAGE.DEFAULT;
REIGN_D3D11_CPU_ACCESS_FLAG cpuAccessFlags = (REIGN_D3D11_CPU_ACCESS_FLAG)0;
if (usage == BufferUsages.Read)
{
if (!isRenderTarget) Debug.ThrowError("Texture2D", "Only RenderTargets may be readable");
// NOTE: Staging texture and states will be created in the RenderTarget
//usageType = REIGN_D3D11_USAGE.STAGING;
//cpuAccessFlags = REIGN_D3D11_CPU_ACCESS_FLAG.READ;
}
if (usage == BufferUsages.Write)
{
usageType = REIGN_D3D11_USAGE.DYNAMIC;
cpuAccessFlags = REIGN_D3D11_CPU_ACCESS_FLAG.WRITE;
}
com = new Texture2DCom();
var error = com.Init(video.com, Size.Width, Size.Height, generateMipmaps, mipmaps != null, mipmaps, mipmapSizes, mipmapPitches, 0, video.surfaceFormat(surfaceFormat), usageType, cpuAccessFlags, isRenderTarget);
switch (error)
{
case TextureError.Texture: Debug.ThrowError("Texture2D", "Failed to create Texture2D"); break;
case TextureError.ShaderResourceView: Debug.ThrowError("Texture2D", "Failed to create ShaderResourceView"); break;
}
}
catch (Exception e)
{
FailedToLoad = true;
Loader.AddLoadableException(e);
Dispose();
if (loadedCallback != null) loadedCallback(this, false);
return false;
}
finally
{
if (mipmaps != null)
{
for (int i = 0; i != mipmaps.Length; ++i)
{
if (mipmaps[i] != 0) Marshal.FreeHGlobal(new IntPtr(mipmaps[i]));
}
}
}
if (!isRenderTarget)
{
Loaded = true;
if (loadedCallback != null) loadedCallback(this, true);
}
return true;
}
protected override bool init(IDisposableResource parent, Image image, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, bool isRenderTarget, bool lockable, Loader.LoadedCallbackMethod loadedCallback)
{
initSuccess = base.init(parent, image, width, height, generateMipmaps, multiSampleType, surfaceFormat, renderTargetUsage, usage, true, lockable, 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, com, width, height, 0, video.surfaceFormat(surfaceFormat), usage == BufferUsages.Read, lockable);
switch (error)
{
case RenderTargetError.RenderTarget: Debug.ThrowError("RenderTarget", "Failed to create RenderTarget"); 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 static IRenderTarget New(IDisposableResource parent, int width, int height, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, DepthStencilFormats depthStencilFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback)
{
return(New(VideoAPI.DefaultAPI, parent, (Image)null, width, height, false, multiSampleType, surfaceFormat, depthStencilFormat, renderTargetUsage, usage, loadedCallback));
}
public Texture2D(IDisposableResource parent, Image image, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback)
: base(parent)
{
init(parent, image, width, height, generateMipmaps, multiSampleType, surfaceFormat, renderTargetUsage, usage, false, false, loadedCallback);
}
public RenderTarget(IDisposableResource parent, Image image, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, DepthStencilFormats depthStencilFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback)
: base(parent, image, width, height, generateMipmaps, multiSampleType, surfaceFormat, renderTargetUsage, usage, loadedCallback)
{
if (initSuccess) initDepthStencil(width, height, depthStencilFormat);
}
public static ITexture2D New(IDisposableResource parent, Image image, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback)
{
return New(VideoAPI.DefaultAPI, parent, image, width, height, generateMipmaps, multiSampleType, surfaceFormat, renderTargetUsage, usage, loadedCallback);
}
protected virtual 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)
{
long[] mipmaps = null;
int[] mipmapSizes = null, mipmapPitches = null;
try
{
video = parent.FindParentOrSelfWithException <Video>();
if (isRenderTarget)
{
generateMipmaps = false;
}
// load image data
if (image != null)
{
mipmaps = new long[image.Mipmaps.Length];
mipmapSizes = new int[image.Mipmaps.Length];
mipmapPitches = new int[image.Mipmaps.Length];
for (int i = 0; i != mipmaps.Length; ++i)
{
var imageMipmap = image.Mipmaps[i];
IntPtr mipmapPtr = Marshal.AllocHGlobal(imageMipmap.Data.Length);
Marshal.Copy(imageMipmap.Data, 0, mipmapPtr, imageMipmap.Data.Length);
mipmapSizes[i] = imageMipmap.Data.Length;
mipmapPitches[i] = imageMipmap.Pitch;
mipmaps[i] = mipmapPtr.ToInt64();
}
Size = image.Size;
surfaceFormat = image.SurfaceFormat;
PixelByteSize = image.CalculatePixelByteSize();
}
else
{
if (width == 0 || height == 0)
{
Debug.ThrowError("Texture2D", "Width or Height cannot be 0");
}
Size = new Size2(width, height);
PixelByteSize = Image.CalculatePixelByteSize((surfaceFormat == SurfaceFormats.Defualt ? Video.DefaultSurfaceFormat() : surfaceFormat), width, height);
}
SizeF = Size.ToVector2();
// init texture
REIGN_D3D11_USAGE usageType = REIGN_D3D11_USAGE.DEFAULT;
REIGN_D3D11_CPU_ACCESS_FLAG cpuAccessFlags = (REIGN_D3D11_CPU_ACCESS_FLAG)0;
if (usage == BufferUsages.Read)
{
if (!isRenderTarget)
{
Debug.ThrowError("Texture2D", "Only RenderTargets may be readable");
}
// NOTE: Staging texture and states will be created in the RenderTarget
//usageType = REIGN_D3D11_USAGE.STAGING;
//cpuAccessFlags = REIGN_D3D11_CPU_ACCESS_FLAG.READ;
}
if (usage == BufferUsages.Write)
{
usageType = REIGN_D3D11_USAGE.DYNAMIC;
cpuAccessFlags = REIGN_D3D11_CPU_ACCESS_FLAG.WRITE;
}
com = new Texture2DCom();
var error = com.Init(video.com, Size.Width, Size.Height, generateMipmaps, mipmaps != null, mipmaps, mipmapSizes, mipmapPitches, 0, video.surfaceFormat(surfaceFormat), usageType, cpuAccessFlags, isRenderTarget);
switch (error)
{
case TextureError.Texture: Debug.ThrowError("Texture2D", "Failed to create Texture2D"); break;
case TextureError.ShaderResourceView: Debug.ThrowError("Texture2D", "Failed to create ShaderResourceView"); break;
}
}
catch (Exception e)
{
FailedToLoad = true;
Loader.AddLoadableException(e);
Dispose();
if (loadedCallback != null)
{
loadedCallback(this, false);
}
return(false);
}
finally
{
if (mipmaps != null)
{
for (int i = 0; i != mipmaps.Length; ++i)
{
if (mipmaps[i] != 0)
{
Marshal.FreeHGlobal(new IntPtr(mipmaps[i]));
}
}
}
}
if (!isRenderTarget)
{
Loaded = true;
if (loadedCallback != null)
{
loadedCallback(this, true);
}
}
return(true);
}
protected virtual bool init(IDisposableResource parent, Image image, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, bool isRenderTarget, bool lockable, Loader.LoadedCallbackMethod loadedCallback)
{
byte[][] mipmaps = null;
int[] mipmapSizes = null, mipmapPitches = null;
try
{
video = parent.FindParentOrSelfWithException<Video>();
if (isRenderTarget) generateMipmaps = false;
// load image data
if (image != null)
{
mipmaps = new byte[image.Mipmaps.Length][];
mipmapSizes = new int[image.Mipmaps.Length];
mipmapPitches = new int[image.Mipmaps.Length];
for (int i = 0; i != mipmaps.Length; ++i)
{
var imageMipmap = image.Mipmaps[i];
mipmaps[i] = image.Compressed ? imageMipmap.Data : imageMipmap.SwapRBColorChannels();
mipmapSizes[i] = imageMipmap.Data.Length;
mipmapPitches[i] = imageMipmap.Pitch;
}
Size = image.Size;
surfaceFormat = image.SurfaceFormat;
PixelByteSize = image.CalculatePixelByteSize();
}
else
{
if (width == 0 || height == 0) Debug.ThrowError("Texture2D", "Width or Height cannot be 0");
Size = new Size2(width, height);
PixelByteSize = Image.CalculatePixelByteSize((surfaceFormat == SurfaceFormats.Defualt ? Video.DefaultSurfaceFormat() : surfaceFormat), width, height);
}
TexelOffset = (1 / Size.ToVector2()) * .5f;
SizeF = Size.ToVector2();
// init texture
REIGN_D3DUSAGE nativeUsage = isRenderTarget ? REIGN_D3DUSAGE.RENDERTARGET : REIGN_D3DUSAGE.NONE;
REIGN_D3DPOOL nativePool = (mipmaps != null && !video.Caps.ExDevice) ? REIGN_D3DPOOL.MANAGED : REIGN_D3DPOOL.DEFAULT;
if (usage == BufferUsages.Read)
{
if (!isRenderTarget) Debug.ThrowError("Texture2D", "Only RenderTargets may be readable");
// NOTE: Staging texture and states will be created in the RenderTarget
}
if (usage == BufferUsages.Write)
{
if (mipmaps != null)
{
if (video.Caps.ExDevice) nativeUsage |= REIGN_D3DUSAGE.DYNAMIC;
}
else
{
nativeUsage |= REIGN_D3DUSAGE.DYNAMIC;
}
}
com = new Texture2DCom();
var error = com.Init(video.com, Size.Width, Size.Height, generateMipmaps, mipmaps, mipmapSizes, mipmapPitches, 0, nativePool, nativeUsage, video.surfaceFormat(surfaceFormat), isRenderTarget);
switch (error)
{
case TextureError.Texture: Debug.ThrowError("Texture2D", "Failed to create Texture2D"); break;
case TextureError.SystemTexture: Debug.ThrowError("Texture2D", "Failed to create System Texture2D"); break;
}
if (!video.Caps.ExDevice && nativePool != REIGN_D3DPOOL.MANAGED)
{
LostDevice_image = image;
LostDevice_width = width;
LostDevice_height = height;
LostDevice_generateMipmaps = generateMipmaps;
LostDevice_multiSampleType = multiSampleType;
LostDevice_surfaceFormat = surfaceFormat;
LostDevice_renderTargetUsage = renderTargetUsage;
LostDevice_usage = usage;
LostDevice_isRenderTarget = isRenderTarget;
LostDevice_lockable = lockable;
LostDevice_pool = nativePool;
}
if (nativePool == REIGN_D3DPOOL.DEFAULT && !video.Caps.ExDevice && !video.deviceReseting)
{
video.DeviceLost += deviceLost;
video.DeviceReset += deviceReset;
}
}
catch (Exception e)
{
FailedToLoad = true;
Loader.AddLoadableException(e);
Dispose();
if (loadedCallback != null) loadedCallback(this, false);
return false;
}
if (!isRenderTarget)
{
Loaded = true;
if (loadedCallback != null) loadedCallback(this, true);
}
return true;
}
public static ITexture2D New(IDisposableResource parent, Image image, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback)
{
return(New(VideoAPI.DefaultAPI, parent, image, width, height, generateMipmaps, multiSampleType, surfaceFormat, renderTargetUsage, usage, loadedCallback));
}
protected override bool init(DisposableI parent, string fileName, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, bool isRenderTarget, Loader.LoadedCallbackMethod loadedCallback)
{
if (!base.init(parent, fileName, width, height, false, multiSampleType, surfaceFormat, renderTargetUsage, usage, true, loadedCallback)) return false;
try
{
if (usage == BufferUsages.Write) Debug.ThrowError("RenderTarget", "Only Textures may be writable");
frameBuffer = new G.FrameBuffer();
frameBuffer.SetColorTarget(texture, 0);
}
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 RenderTarget(DisposableI parent, int width, int height, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, DepthStencilFormats depthStencilFormat, BufferUsages usage, RenderTargetUsage renderTargetUsage, Loader.LoadedCallbackMethod loadedCallback)
: base(parent, width, height, surfaceFormat, usage, loadedCallback)
{
initDepthStencilFormat = depthStencilFormat;
}
protected unsafe 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, false, multiSampleType, surfaceFormat, renderTargetUsage, usage, true, loadedCallback);
if (!initSuccess)
{
return(false);
}
try
{
if (usage == BufferUsages.Write)
{
Debug.ThrowError("RenderTarget", "Only Textures may be writable");
}
uint frameBufferTEMP = 0;
GL.GenFramebuffers(1, &frameBufferTEMP);
frameBuffer = frameBufferTEMP;
uint error;
string errorName;
if (Video.checkForError(out error, out errorName))
{
Debug.ThrowError("RenderTarget", string.Format("{0} {1}: Failed to create renderTarget", error, errorName));
}
}
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);
}
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;
}
internal REIGN_DXGI_FORMAT surfaceFormat(SurfaceFormats surfaceFormat)
{
switch (surfaceFormat)
{
case SurfaceFormats.Defualt:
#if ARM
return REIGN_DXGI_FORMAT.B4G4R4A4_UNORM;
#else
return REIGN_DXGI_FORMAT.R8G8B8A8_UNORM;
#endif
case SurfaceFormats.DXT1: return REIGN_DXGI_FORMAT.BC1_UNORM;
case SurfaceFormats.DXT3: return REIGN_DXGI_FORMAT.BC2_UNORM;
case SurfaceFormats.DXT5: return REIGN_DXGI_FORMAT.BC3_UNORM;
case SurfaceFormats.RGBx565: return REIGN_DXGI_FORMAT.B5G6R5_UNORM;
#if WINRT || WP8
case SurfaceFormats.RGBAx4: return REIGN_DXGI_FORMAT.B4G4R4A4_UNORM;
#endif
case SurfaceFormats.RGBx5_Ax1: return REIGN_DXGI_FORMAT.B5G5R5A1_UNORM;
case SurfaceFormats.RGBAx8: return REIGN_DXGI_FORMAT.R8G8B8A8_UNORM;
case SurfaceFormats.RGBx10_Ax2: return REIGN_DXGI_FORMAT.R10G10B10A2_UNORM;
case SurfaceFormats.RGBAx16f: return REIGN_DXGI_FORMAT.R16G16B16A16_FLOAT;
case SurfaceFormats.RGBAx32f: return REIGN_DXGI_FORMAT.R32G32B32A32_FLOAT;
default:
Debug.ThrowError("Video", "Unsuported SurfaceFormat: " + surfaceFormat);
return REIGN_DXGI_FORMAT.R8G8B8A8_UNORM;
}
}
protected virtual 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)
{
try
{
if (usage == BufferUsages.Read && !isRenderTarget) Debug.ThrowError("Texture2D", "Only RenderTargets may be readable");
video = parent.FindParentOrSelfWithException<Video>();
if (!isRenderTarget)
{
if (fileName != null || image != null)
{
#if SILVERLIGHT
texture = new X.Texture2D(video.Device, image.Size.Width, image.Size.Height, image.Mipmaps.Length != 0, Video.surfaceFormat(surfaceFormat));
for (int i = 0; i != image.Mipmaps.Length; ++i)
{
var mipmap = image.Mipmaps[i];
texture.SetData<byte>(i, null, mipmap.Data, 0, mipmap.Data.Length);
}
#else
texture = parent.FindParentOrSelfWithException<RootDisposable>().Content.Load<X.Texture2D>(Streams.StripFileExt(fileName));
loadedFromContentManager = true;
#endif
}
else
{
texture = new X.Texture2D(video.Device, width, height, generateMipmaps, Video.surfaceFormat(surfaceFormat));
}
Size = new Size2(texture.Width, texture.Height);
PixelByteSize = Image.CalculatePixelByteSize(surfaceFormat, texture.Width, texture.Height);
}
else
{
Size = new Size2(width, height);
PixelByteSize = Image.CalculatePixelByteSize(surfaceFormat, width, height);
}
TexelOffset = (1 / Size.ToVector2()) * .5f;
SizeF = Size.ToVector2();
}
catch (Exception e)
{
FailedToLoad = true;
Loader.AddLoadableException(e);
Dispose();
if (loadedCallback != null) loadedCallback(this, false);
return false;
}
if (!isRenderTarget)
{
Loaded = true;
if (loadedCallback != null) loadedCallback(this, true);
}
return 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 unsafe virtual 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)
{
try
{
if (usage == BufferUsages.Read && !isRenderTarget)
{
Debug.ThrowError("Texture2D", "Only RenderTargets may be readable");
}
video = parent.FindParentOrSelfWithException <Video>();
if (isRenderTarget)
{
generateMipmaps = false;
}
uint texturesTEMP = 0;
GL.GenTextures(1, &texturesTEMP);
Texture = texturesTEMP;
if (Texture == 0)
{
Debug.ThrowError("Texture2D", "Failed to Generate Texture");
}
GL.BindTexture(GL.TEXTURE_2D, Texture);
if (!generateMipmaps)
{
GL.TexParameteri(GL.TEXTURE_2D, GL.TEXTURE_MIN_FILTER, GL.LINEAR);
}
else
{
GL.TexParameteri(GL.TEXTURE_2D, GL.TEXTURE_MIN_FILTER, GL.LINEAR_MIPMAP_LINEAR);
}
GL.TexParameteri(GL.TEXTURE_2D, GL.TEXTURE_MAG_FILTER, GL.LINEAR);
hasMipmaps = false;
if (image != null)
{
var imageType = image.GetType();
#if NaCl
if (imageType == typeof(ImageBMPC))
#else
if (imageType == typeof(ImagePNG) || imageType == typeof(ImageJPG) || imageType == typeof(ImageBMP) || imageType == typeof(ImageBMPC))
#endif
{
uint pixelOrder, byteSizes;
int format = Video.surfaceFormat(surfaceFormat, out pixelOrder, out byteSizes);
var mipmap = image.Mipmaps[0];
fixed(byte *data = mipmap.Data)
{
GL.TexImage2D(GL.TEXTURE_2D, 0, format, mipmap.Size.Width, mipmap.Size.Height, 0, pixelOrder, byteSizes, data);
if (generateMipmaps)
{
hasMipmaps = true;
GL.GenerateMipmap(GL.TEXTURE_2D);
}
}
}
else if (imageType == typeof(ImageDDS) || imageType == typeof(ImagePVR))
{
if (image.Mipmaps.Length != Image.Mipmap.CalculateMipmapLvls(image.Size.Width, image.Size.Height))
{
Debug.ThrowError("Texture2D", "Compressed Textures require full mipmap chain");
}
GL.TexParameteri(GL.TEXTURE_2D, GL.TEXTURE_MIN_FILTER, GL.LINEAR_MIPMAP_LINEAR);
hasMipmaps = true;
bool compressed = false;
uint format = 0;
string errorType = null;
if (imageType == typeof(ImageDDS))
{
var imageDDS = (ImageDDS)image;
compressed = imageDDS.Compressed;
format = imageDDS.FormatGL;
errorType = "DDS";
}
else if (imageType == typeof(ImagePVR))
{
var imagePVR = (ImagePVR)image;
compressed = imagePVR.Compressed;
format = imagePVR.FormatGL;
errorType = "PVR";
}
if (compressed)
{
for (int i = 0; i < image.Mipmaps.Length; ++i)
{
var mipmap = image.Mipmaps[i];
fixed(byte *data = mipmap.Data)
{
// look up:: libtxc_dxtn.so for linux with mesa
GL.CompressedTexImage2D(GL.TEXTURE_2D, i, format, mipmap.Size.Width, mipmap.Size.Height, 0, mipmap.Data.Length, data);
}
}
}
else
{
Debug.ThrowError("Texture2D", "Loading uncompresed " + errorType + " textures not supported");
}
}
Size = image.Size;
PixelByteSize = image.CalculatePixelByteSize();
}
else
{
//GL.TexImage2D(GL.TEXTURE_2D, 0, Video.surfaceFormat(surfaceFormat), width, height, 0, GL.RGBA, GL.UNSIGNED_BYTE, IntPtr.Zero.ToPointer());
uint pixelOrder, byteSizes;
int format = Video.surfaceFormat(surfaceFormat, out pixelOrder, out byteSizes);
GL.TexImage2D(GL.TEXTURE_2D, 0, format, width, height, 0, pixelOrder, byteSizes, IntPtr.Zero.ToPointer());
if (generateMipmaps)
{
hasMipmaps = true;
GL.GenerateMipmap(GL.TEXTURE_2D);
}
Size = new Size2(width, height);
PixelByteSize = Image.CalculatePixelByteSize((surfaceFormat == SurfaceFormats.Defualt ? Video.DefaultSurfaceFormat() : surfaceFormat), width, height);
}
SizeF = Size.ToVector2();
uint error;
string errorName;
if (Video.checkForError(out error, out errorName))
{
Debug.ThrowError("Texture2D", string.Format("{0} {1}: Failed to load/create texture", error, errorName));
}
}
catch (Exception e)
{
FailedToLoad = true;
Loader.AddLoadableException(e);
Dispose();
if (loadedCallback != null)
{
loadedCallback(this, false);
}
return(false);
}
if (!isRenderTarget)
{
Loaded = true;
if (loadedCallback != null)
{
loadedCallback(this, true);
}
}
return(true);
}
public static RenderTarget New(DisposableI parent, int width, int height, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, DepthStencilFormats depthStencilFormat, BufferUsages usage, RenderTargetUsage renderTargetUsage, Loader.LoadedCallbackMethod loadedCallback)
{
return new RenderTarget(parent, width, height, multiSampleType, surfaceFormat, depthStencilFormat, usage, renderTargetUsage, loadedCallback);
}
public static Texture2D New(DisposableI parent, int width, int height, SurfaceFormats surfaceFormat, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback)
{
return new Texture2D(parent, width, height, surfaceFormat, usage, loadedCallback);
}
internal REIGN_D3DFORMAT surfaceFormat(SurfaceFormats surfaceFormat)
{
switch (surfaceFormat)
{
case SurfaceFormats.Defualt: return REIGN_D3DFORMAT.A8R8G8B8;
case SurfaceFormats.DXT1: return REIGN_D3DFORMAT.DXT1;
case SurfaceFormats.DXT3: return REIGN_D3DFORMAT.DXT3;
case SurfaceFormats.DXT5: return REIGN_D3DFORMAT.DXT5;
case SurfaceFormats.RGBx565: return REIGN_D3DFORMAT.R5G6B5;
case SurfaceFormats.RGBAx4: return REIGN_D3DFORMAT.A4R4G4B4;
case SurfaceFormats.RGBx5_Ax1: return REIGN_D3DFORMAT.A1R5G5B5;
case SurfaceFormats.RGBAx8: return REIGN_D3DFORMAT.A8R8G8B8;
case SurfaceFormats.RGBx10_Ax2: return REIGN_D3DFORMAT.A2R10G10B10;
case SurfaceFormats.RGBAx16f: return REIGN_D3DFORMAT.A16B16G16R16F;
case SurfaceFormats.RGBAx32f: return REIGN_D3DFORMAT.A32B32G32R32F;
default:
Debug.ThrowError("Video", "Unsuported SurfaceFormat: " + surfaceFormat);
return REIGN_D3DFORMAT.A8R8G8B8;
}
}
public static int CalculatePixelByteSize(SurfaceFormats surfaceFormat, int width, int height)
{
switch (surfaceFormat)
{
case SurfaceFormats.RGBx565: return width * height * 2;
case SurfaceFormats.RGBAx4: return width * height * 2;
case SurfaceFormats.RGBx5_Ax1: return width * height * 2;
case SurfaceFormats.RGBAx8: return width * height * 4;
case SurfaceFormats.RGBx10_Ax2: return width * height * 4;
case SurfaceFormats.RGBAx16f: return (width * height * 4) * 2;
case SurfaceFormats.RGBAx32f: return (width * height * 4) * 4;
case SurfaceFormats.DXT1: return (width * height) / 2;
case SurfaceFormats.DXT3: return width * height;
case SurfaceFormats.DXT5: return width * height;
case SurfaceFormats.ATC_RGB: return (width * height) / 2;
case SurfaceFormats.ATC_RGBA_Explicit: return width * height;
case SurfaceFormats.ATC_RGBA_Interpolated: return width * height;
case SurfaceFormats.PVR_RGB_2: return (width * height) / 4;
case SurfaceFormats.PVR_RGB_4: return (width * height) / 2;
case SurfaceFormats.PVR_RGBA_2: return (width * height) / 4;
case SurfaceFormats.PVR_RGBA_4: return (width * height) / 2;
default: Debug.ThrowError("Image", string.Format("Unsuported surface format: {0}", surfaceFormat)); break;
}
return -1;
}
