public PrimitiveBuffer(BufferFrequencies frequency, BufferUsages usage, out uint bufferId,
out uint indexId, uint bufferCapacity = 0, uint indexCapacity = 0) :
this(frequency, usage, bufferCapacity, indexCapacity)
{
bufferId = this.bufferId;
indexId = this.indexId;
}
public static IVertexBuffer New(VideoTypes videoType, IDisposableResource parent, IBufferLayoutDesc bufferLayoutDesc, BufferUsages usage, VertexBufferTopologys topology, float[] vertices, int[] indices)
{
IVertexBuffer api = null;
#if WIN32
if (videoType == VideoTypes.D3D9) api = new D3D9.VertexBuffer(parent, bufferLayoutDesc, usage, topology, vertices, indices);
#endif
#if WIN32 || WINRT || WP8
if (videoType == VideoTypes.D3D11) api = new D3D11.VertexBuffer(parent, bufferLayoutDesc, usage, topology, vertices, indices);
#endif
#if WIN32 || OSX || LINUX || iOS || ANDROID || NaCl
if (videoType == VideoTypes.OpenGL) api = new OpenGL.VertexBuffer(parent, bufferLayoutDesc, usage, topology, vertices, indices);
#endif
#if XNA
if (videoType == VideoTypes.XNA) api = new XNA.VertexBuffer(parent, bufferLayoutDesc, usage, topology, vertices, indices);
#endif
#if VITA
if (videoType == VideoTypes.Vita) api = new Vita.VertexBuffer(parent, bufferLayoutDesc, usage, topology, vertices, indices);
#endif
if (api == null) Debug.ThrowError("VertexBufferAPI", "Unsuported InputType: " + videoType);
return api;
}
// Note that buffer capacity is given in bytes while index capacity is given in unsigned shorts.
public unsafe PrimitiveBuffer(BufferFrequencies frequency, BufferUsages usage, uint bufferCapacity = 0,
uint indexCapacity = 0)
{
this.usage = (uint)frequency + (uint)usage;
GLUtilities.GenerateBuffers(out bufferId, out indexId);
buffer = new byte[bufferCapacity];
indexBuffer = new ushort[indexCapacity];
maxIndex = -1;
if (bufferCapacity > 0)
{
allocatedBufferCapacity = bufferCapacity;
glBindBuffer(GL_ARRAY_BUFFER, bufferId);
glBufferData(GL_ARRAY_BUFFER, bufferCapacity, (void *)0, this.usage);
}
if (indexCapacity > 0)
{
allocatedIndexCapacity = sizeof(ushort) * indexCapacity;
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexId);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, allocatedIndexCapacity, (void *)0, this.usage);
}
}
internal HostBuffer(
Device logicalDevice,
Pool memoryPool,
BufferUsages usages,
long size)
{
if (logicalDevice == null)
{
throw new ArgumentNullException(nameof(logicalDevice));
}
if (memoryPool == null)
{
throw new ArgumentNullException(nameof(memoryPool));
}
this.size = size;
//Create the buffer
buffer = logicalDevice.CreateBuffer(new BufferCreateInfo(
size: size,
usages: usages,
flags: BufferCreateFlags.None,
sharingMode: SharingMode.Exclusive
));
//Allocate memory for this buffer
memory = memoryPool.AllocateAndBind(buffer, Chunk.Location.Host);
}
public VKBuffer(
string name, Graphics graphics, long count, BufferUsages usages, MemoryProperties memoryProperties,
BufferCreateFlags flags = BufferCreateFlags.None, SharingMode sharingMode = SharingMode.Exclusive,
int[] queueFamilyIndices = null
)
{
Name = name;
Graphics = graphics;
Count = count;
Size = count * Interop.SizeOf <T>();
Usages = usages;
Buffer = Graphics.Device.CreateBuffer(new BufferCreateInfo(
size: Size,
usages: usages,
flags: flags,
sharingMode: sharingMode,
queueFamilyIndices: queueFamilyIndices
));
var reqs = Buffer.GetMemoryRequirements();
DeviceMemory = Graphics.Device.AllocateMemory(new MemoryAllocateInfo(
reqs.Size,
graphics.GetMemoryTypeIndex(reqs.MemoryTypeBits, memoryProperties)
));
Buffer.BindMemory(DeviceMemory);
}
internal static DeviceBuffer UploadData <T>(
ReadOnlyMemory <T> data,
RenderScene scene,
BufferUsages usages) where T : struct
{
return(UploadData <T>(data.Span, scene, usages));
}
internal DeviceBuffer(
Device logicalDevice,
Pool memoryPool,
BufferUsages usages,
long size)
{
if (logicalDevice == null)
{
throw new ArgumentNullException(nameof(logicalDevice));
}
if (memoryPool == null)
{
throw new ArgumentNullException(nameof(memoryPool));
}
this.size = size;
//Create the buffer
buffer = logicalDevice.CreateBuffer(new BufferCreateInfo(
size: size,
//Adding 'TransferDst' otherwise we can never copy data to it
usages: usages | BufferUsages.TransferDst,
flags: BufferCreateFlags.None,
sharingMode: SharingMode.Exclusive
));
//Bind memory from our pool to this buffer
memory = memoryPool.AllocateAndBind(buffer, Chunk.Location.Device);
}
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
}
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 IVertexBuffer(IDisposableResource parent, IBufferLayoutDesc bufferLayoutDesc, BufferUsages usage, float[] vertices)
: base(parent)
{
this.usage = usage;
vertexByteSize = bufferLayoutDesc.ByteSize;
vertexFloatArraySize = bufferLayoutDesc.FloatCount;
vertexCount = vertices.Length / vertexFloatArraySize;
}
protected IVertexBuffer(IDisposableResource parent, IBufferLayoutDesc bufferLayoutDesc, BufferUsages usage, float[] vertices)
: base(parent)
{
this.usage = usage;
vertexByteSize = bufferLayoutDesc.ByteSize;
vertexFloatArraySize = bufferLayoutDesc.FloatCount;
vertexCount = vertices.Length / vertexFloatArraySize;
}
protected IIndexBuffer(IDisposableResource parent, BufferUsages usage, int[] indices)
: base(parent)
{
this.usage = usage;
indexByteSize = sizeof(short);
indexCount = indices.Length;
_32BitIndices = indexCount > short.MaxValue;
indexByteSize = _32BitIndices ? sizeof(int) : sizeof(short);
}
protected IIndexBuffer(IDisposableResource parent, BufferUsages usage, int[] indices)
: base(parent)
{
this.usage = usage;
indexByteSize = sizeof(short);
indexCount = indices.Length;
_32BitIndices = indexCount > short.MaxValue;
indexByteSize = _32BitIndices ? sizeof(int) : sizeof(short);
}
public void CreateBuffer(int sizeInBytes, string name,
BufferUsages usage, SharingMode sm, int [] famIndexes = null)
{
BufferCreateInfo bci = new BufferCreateInfo(sizeInBytes,
usage, BufferCreateFlags.None,
sm, famIndexes);
Buffer buf = mLogical.CreateBuffer(bci);
mBuffers.Add(name, buf);
}
internal static DeviceBuffer UploadData <T>(
ReadOnlySpan <T> data,
RenderScene scene,
BufferUsages usages) where T : struct
{
return(UploadData <T>(
data,
scene.LogicalDevice,
scene.MemoryPool,
usages,
scene.StagingBuffer,
scene.Executor));
}
public unsafe IndexBuffer(IDisposableResource parent, BufferUsages bufferUsage, int[] indices)
: base(parent, bufferUsage, indices)
{
try
{
video = parent.FindParentOrSelfWithException <Video>();
uint vPtr = 0;
GL.GenBuffers(1, &vPtr);
indexBuffer = vPtr;
if (indexBuffer == 0)
{
Debug.ThrowError("IndexBuffer", "Failed to create IndexBuffer");
}
GL.BindBuffer(GL.ELEMENT_ARRAY_BUFFER, indexBuffer);
if (_32BitIndices)
{
fixed(int *indicesPtr = indices)
{
var bufferSize = new IntPtr(indexByteSize * indexCount);
GL.BufferData(GL.ELEMENT_ARRAY_BUFFER, bufferSize, indicesPtr, GL.STATIC_DRAW);
}
}
else
{
var indices16Bit = new short[indices.Length];
for (int i = 0; i != indices.Length; ++i)
{
indices16Bit[i] = (short)indices[i];
}
fixed(short *indicesPtr = indices16Bit)
{
var bufferSize = new IntPtr(indexByteSize * indexCount);
GL.BufferData(GL.ELEMENT_ARRAY_BUFFER, bufferSize, indicesPtr, GL.STATIC_DRAW);
}
}
Video.checkForError();
}
catch (Exception e)
{
Dispose();
throw e;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BufferCreateInfo"/> structure.
/// </summary>
/// <param name="size">The size in bytes of the buffer to be created.</param>
/// <param name="usages">The bitmask describing the allowed usages of the buffer.</param>
/// <param name="flags">Additional parameters of the buffer.</param>
/// <param name="sharingMode">
/// The sharing mode of the buffer when it will be accessed by multiple queue families.
/// </param>
/// <param name="queueFamilyIndices">
/// A list of queue families that will access this buffer (ignored if <see
/// cref="SharingMode"/> is not <see cref="VulkanCore.SharingMode.Concurrent"/>).
/// </param>
/// <param name="next">
/// Is <see cref="IntPtr.Zero"/> or a pointer to an extension-specific structure.
/// </param>
public BufferCreateInfo(
long size,
BufferUsages usages,
BufferCreateFlags flags = 0,
SharingMode sharingMode = SharingMode.Exclusive,
int[] queueFamilyIndices = null,
IntPtr next = default(IntPtr))
{
Next = next;
Size = size;
Usages = usages;
Flags = flags;
SharingMode = sharingMode;
QueueFamilyIndices = queueFamilyIndices;
}
private void init(DisposableI parent, BufferLayoutDescI bufferLayoutDesc, BufferUsages bufferUsage, VertexBufferTopologys vertexBufferTopology, float[] vertices, int[] indices)
{
try
{
video = parent.FindParentOrSelfWithException <Video>();
Topology = vertexBufferTopology;
var format = new G.VertexFormat[bufferLayoutDesc.Elements.Count];
for (int i = 0; i != bufferLayoutDesc.Elements.Count; ++i)
{
switch (bufferLayoutDesc.Elements[i].FloatCount)
{
case 1: format[i] = G.VertexFormat.Float; break;
case 2: format[i] = G.VertexFormat.Float2; break;
case 3: format[i] = G.VertexFormat.Float3; break;
case 4: format[i] = G.VertexFormat.Float4; break;
}
}
if (indices != null && indices.Length != 0)
{
vertexBuffer = new G.VertexBuffer(vertexCount, indices.Length, format);
indexCount = indices.Length;
var indicesShort = new ushort[indexCount];
for (int i = 0; i != indexCount; ++i)
{
indicesShort[i] = (ushort)indices[i];
}
vertexBuffer.SetIndices(indicesShort);
}
else
{
vertexBuffer = new G.VertexBuffer(vertexCount, format);
}
vertexBuffer.SetVertices(vertices);
}
catch (Exception e)
{
Dispose();
throw e;
}
}
public IndexBuffer(IDisposableResource parent, BufferUsages usage, int[] indices)
: base(parent, usage, indices)
{
try
{
var video = parent.FindParentOrSelfWithException<Video>();
com = new IndexBufferCom(video.com);
var bufferUsage = (usage == BufferUsages.Write) ? REIGN_D3D11_USAGE.DYNAMIC : REIGN_D3D11_USAGE.DEFAULT;
var cpuUsage = (usage == BufferUsages.Write) ? REIGN_D3D11_CPU_ACCESS_FLAG.WRITE : (REIGN_D3D11_CPU_ACCESS_FLAG)0;
var error = com.Init(indices, indexCount, indexByteSize, bufferUsage, cpuUsage, _32BitIndices);
if (error == IndexBufferErrors.Buffer) Debug.ThrowError("IndexBuffer", "Failed to create Buffer");
}
catch (Exception e)
{
Dispose();
throw e;
}
}
public unsafe IndexBuffer(IDisposableResource parent, BufferUsages bufferUsage, int[] indices)
: base(parent, bufferUsage, indices)
{
try
{
video = parent.FindParentOrSelfWithException<Video>();
uint vPtr = 0;
GL.GenBuffers(1, &vPtr);
indexBuffer = vPtr;
if (indexBuffer == 0) Debug.ThrowError("IndexBuffer", "Failed to create IndexBuffer");
GL.BindBuffer(GL.ELEMENT_ARRAY_BUFFER, indexBuffer);
if (_32BitIndices)
{
fixed(int* indicesPtr = indices)
{
var bufferSize = new IntPtr(indexByteSize * indexCount);
GL.BufferData(GL.ELEMENT_ARRAY_BUFFER, bufferSize, indicesPtr, GL.STATIC_DRAW);
}
}
else
{
var indices16Bit = new short[indices.Length];
for (int i = 0; i != indices.Length; ++i)
{
indices16Bit[i] = (short)indices[i];
}
fixed(short* indicesPtr = indices16Bit)
{
var bufferSize = new IntPtr(indexByteSize * indexCount);
GL.BufferData(GL.ELEMENT_ARRAY_BUFFER, bufferSize, indicesPtr, GL.STATIC_DRAW);
}
}
Video.checkForError();
}
catch (Exception e)
{
Dispose();
throw e;
}
}
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 IndexBuffer(IDisposableResource parent, BufferUsages usage, int[] indices)
: base(parent, usage, indices)
{
try
{
var video = parent.FindParentOrSelfWithException <Video>();
com = new IndexBufferCom(video.com);
var error = com.Init(indices, indexCount, indexByteSize, REIGN_D3DUSAGE.WRITEONLY, _32BitIndices);
if (error == IndexBufferErrors.IndexBuffer)
{
Debug.ThrowError("IndexBuffer", "Failed to create IndexBuffer");
}
}
catch (Exception e)
{
Dispose();
throw e;
}
}
public IndexBuffer(DisposableI parent, BufferUsages bufferUsage, int[] indices)
: base(parent, bufferUsage, indices)
{
try
{
video = parent.FindParentOrSelfWithException<Video>();
#if SILVERLIGHT
X.IndexElementSize elementSize = X.IndexElementSize.SixteenBits;
#else
X.IndexElementSize elementSize = _32BitIndices ? X.IndexElementSize.ThirtyTwoBits : X.IndexElementSize.SixteenBits;
#endif
indexBuffer = new X.IndexBuffer(video.Device, elementSize, indices.Length, X.BufferUsage.WriteOnly);
Update(indices, indexCount);
}
catch (Exception e)
{
Dispose();
throw e;
}
}
public IndexBuffer(DisposableI parent, BufferUsages bufferUsage, int[] indices)
: base(parent, bufferUsage, indices)
{
try
{
video = parent.FindParentOrSelfWithException <Video>();
#if SILVERLIGHT
X.IndexElementSize elementSize = X.IndexElementSize.SixteenBits;
#else
X.IndexElementSize elementSize = _32BitIndices ? X.IndexElementSize.ThirtyTwoBits : X.IndexElementSize.SixteenBits;
#endif
indexBuffer = new X.IndexBuffer(video.Device, elementSize, indices.Length, X.BufferUsage.WriteOnly);
Update(indices, indexCount);
}
catch (Exception e)
{
Dispose();
throw e;
}
}
public IndexBuffer(IDisposableResource parent, BufferUsages usage, int[] indices)
: base(parent, usage, indices)
{
try
{
var video = parent.FindParentOrSelfWithException <Video>();
com = new IndexBufferCom(video.com);
var bufferUsage = (usage == BufferUsages.Write) ? REIGN_D3D11_USAGE.DYNAMIC : REIGN_D3D11_USAGE.DEFAULT;
var cpuUsage = (usage == BufferUsages.Write) ? REIGN_D3D11_CPU_ACCESS_FLAG.WRITE : (REIGN_D3D11_CPU_ACCESS_FLAG)0;
var error = com.Init(indices, indexCount, indexByteSize, bufferUsage, cpuUsage, _32BitIndices);
if (error == IndexBufferErrors.Buffer)
{
Debug.ThrowError("IndexBuffer", "Failed to create Buffer");
}
}
catch (Exception e)
{
Dispose();
throw e;
}
}
private void init(DisposableI parent, BufferLayoutDescI bufferLayoutDesc, BufferUsages bufferUsage, VertexBufferTopologys vertexBufferTopology, float[] vertices, int[] indices)
{
try
{
video = parent.FindParentOrSelfWithException <Video>();
Topology = vertexBufferTopology;
bufferLayout = new BufferLayout(this, null, bufferLayoutDesc, true);
vertexBuffer = new X.VertexBuffer(video.Device, bufferLayout.layout, vertexCount, X.BufferUsage.WriteOnly);
Update(vertices, vertexCount);
if (indices != null && indices.Length != 0)
{
indexBuffer = new IndexBuffer(this, usage, indices);
}
}
catch (Exception e)
{
Dispose();
throw e;
}
}
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 static IIndexBuffer New(VideoTypes videoType, IDisposableResource parent, BufferUsages usage, int[] indices)
{
IIndexBuffer api = null;
#if WIN32
if (videoType == VideoTypes.D3D9) api = new D3D9.IndexBuffer(parent, usage, indices);
#endif
#if WIN32 || WINRT || WP8
if (videoType == VideoTypes.D3D11) api = new D3D11.IndexBuffer(parent, usage, indices);
#endif
#if WIN32 || OSX || LINUX || iOS || ANDROID || NaCl
if (videoType == VideoTypes.OpenGL) api = new OpenGL.IndexBuffer(parent, usage, indices);
#endif
#if XNA
if (videoType == VideoTypes.XNA) api = new XNA.IndexBuffer(parent, usage, indices);
#endif
if (api == null) Debug.ThrowError("IndexBufferAPI", "Unsuported InputType: " + videoType);
return api;
}
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
}
internal static DeviceBuffer UploadData <T>(
ReadOnlySpan <T> data,
Device logicalDevice,
Pool memoryPool,
BufferUsages usages,
HostBuffer stagingBuffer,
TransientExecutor executor) where T : struct
{
//First write the data to the staging buffer
int size = stagingBuffer.Write <T>(data, offset: 0);
//Then create a device buffer with that size
DeviceBuffer targetBuffer = new DeviceBuffer(logicalDevice, memoryPool, usages, size);
//Then copy the data from the staging buffer to the devicebuffer
executor.ExecuteBlocking(commandBuffer =>
{
commandBuffer.CmdCopyBuffer(
srcBuffer: stagingBuffer.VulkanBuffer,
dstBuffer: targetBuffer.VulkanBuffer,
new BufferCopy(size: size, srcOffset: 0, dstOffset: 0));
});
return(targetBuffer);
}
public static IIndexBuffer New(VideoTypes videoType, IDisposableResource parent, BufferUsages usage, int[] indices)
{
IIndexBuffer api = null;
#if WIN32
if (videoType == VideoTypes.D3D9)
{
api = new D3D9.IndexBuffer(parent, usage, indices);
}
#endif
#if WIN32 || WINRT || WP8
if (videoType == VideoTypes.D3D11)
{
api = new D3D11.IndexBuffer(parent, usage, indices);
}
#endif
#if WIN32 || OSX || LINUX || iOS || ANDROID || NaCl
if (videoType == VideoTypes.OpenGL)
{
api = new OpenGL.IndexBuffer(parent, usage, indices);
}
#endif
#if XNA
if (videoType == VideoTypes.XNA)
{
api = new XNA.IndexBuffer(parent, usage, indices);
}
#endif
if (api == null)
{
Debug.ThrowError("IndexBufferAPI", "Unsuported InputType: " + videoType);
}
return(api);
}
public static Texture2D New(DisposableI parent, string fileName, bool generateMipmaps, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback)
{
return new Texture2D(parent, fileName, generateMipmaps, 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);
}
public RenderTarget(DisposableI parent, string fileName, MultiSampleTypes multiSampleType, BufferUsages usage, RenderTargetUsage renderTargetUsage, Loader.LoadedCallbackMethod loadedCallback)
: base(parent, fileName, false, usage, loadedCallback)
{
}
public static IVertexBuffer New(VideoTypes videoType, IDisposableResource parent, IBufferLayoutDesc bufferLayoutDesc, BufferUsages usage, VertexBufferTopologys topology, float[] vertices, int[] indices)
{
IVertexBuffer api = null;
#if WIN32
if (videoType == VideoTypes.D3D9)
{
api = new D3D9.VertexBuffer(parent, bufferLayoutDesc, usage, topology, vertices, indices);
}
#endif
#if WIN32 || WINRT || WP8
if (videoType == VideoTypes.D3D11)
{
api = new D3D11.VertexBuffer(parent, bufferLayoutDesc, usage, topology, vertices, indices);
}
#endif
#if WIN32 || OSX || LINUX || iOS || ANDROID || NaCl
if (videoType == VideoTypes.OpenGL)
{
api = new OpenGL.VertexBuffer(parent, bufferLayoutDesc, usage, topology, vertices, indices);
}
#endif
#if XNA
if (videoType == VideoTypes.XNA)
{
api = new XNA.VertexBuffer(parent, bufferLayoutDesc, usage, topology, vertices, indices);
}
#endif
#if VITA
if (videoType == VideoTypes.Vita)
{
api = new Vita.VertexBuffer(parent, bufferLayoutDesc, usage, topology, vertices, indices);
}
#endif
if (api == null)
{
Debug.ThrowError("VertexBufferAPI", "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;
}
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(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);
}
public static ITexture2D New(IDisposableResource parent, string filename, bool generateMipmaps, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback)
{
return New(VideoAPI.DefaultAPI, parent, filename, 0, 0, generateMipmaps, MultiSampleTypes.None, SurfaceFormats.Defualt, RenderTargetUsage.PlatformDefault, 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, 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 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 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 static IIndexBuffer New(IDisposableResource parent, BufferUsages usage, int[] indices)
{
return(New(VideoAPI.DefaultAPI, parent, usage, indices));
}
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 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 VertexBuffer(IDisposableResource parent, IBufferLayoutDesc bufferLayoutDesc, BufferUsages usage, VertexBufferTopologys topology, float[] vertices, int[] indices)
: base(parent, bufferLayoutDesc, usage, vertices)
{
init(parent, bufferLayoutDesc, usage, topology, vertices, indices);
}
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 RenderTarget New(DisposableI parent, string fileName, MultiSampleTypes multiSampleType, BufferUsages usage, RenderTargetUsage renderTargetUsage, Loader.LoadedCallbackMethod loadedCallback)
{
return new RenderTarget(parent, fileName, multiSampleType, usage, renderTargetUsage, loadedCallback);
}
private void init(IDisposableResource parent, IBufferLayoutDesc bufferLayoutDesc, BufferUsages usage, VertexBufferTopologys topology, float[] vertices, int[] indices)
{
try
{
var video = parent.FindParentOrSelfWithException<Video>();
this.topology = topology;
REIGN_D3D_PRIMITIVE_TOPOLOGY topologyType = REIGN_D3D_PRIMITIVE_TOPOLOGY.TRIANGLELIST;
switch (topology)
{
case VertexBufferTopologys.Triangle: topologyType = REIGN_D3D_PRIMITIVE_TOPOLOGY.TRIANGLELIST; break;
case VertexBufferTopologys.Line: topologyType = REIGN_D3D_PRIMITIVE_TOPOLOGY.LINELIST; break;
case VertexBufferTopologys.Point: topologyType = REIGN_D3D_PRIMITIVE_TOPOLOGY.POINTLIST; break;
}
com = new VertexBufferCom(video.com, topologyType);
var bufferUsage = (usage == BufferUsages.Write) ? REIGN_D3D11_USAGE.DYNAMIC : REIGN_D3D11_USAGE.DEFAULT;
var cpuUsage = (usage == BufferUsages.Write) ? REIGN_D3D11_CPU_ACCESS_FLAG.WRITE : (REIGN_D3D11_CPU_ACCESS_FLAG)0;
var error = com.Init(vertices, vertexCount, vertexByteSize, bufferUsage, cpuUsage);
if (error == VertexBufferErrors.Buffer) Debug.ThrowError("VertexBuffer", "Failed to create Buffer");
if (indices != null && indices.Length != 0) indexBuffer = new IndexBuffer(this, usage, indices);
}
catch (Exception e)
{
Dispose();
throw e;
}
}
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 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 VertexBuffer(IDisposableResource parent, IBufferLayoutDesc bufferLayoutDesc, BufferUsages usage, VertexBufferTopologys topology, float[] vertices, int[] indices)
: base(parent, bufferLayoutDesc, usage, vertices)
{
init(parent, bufferLayoutDesc, usage, topology, vertices, indices);
}
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;
}
private void init(IDisposableResource parent, IBufferLayoutDesc bufferLayoutDesc, BufferUsages usage, VertexBufferTopologys topology, float[] vertices, int[] indices)
{
try
{
var video = parent.FindParentOrSelfWithException <Video>();
this.topology = topology;
REIGN_D3D_PRIMITIVE_TOPOLOGY topologyType = REIGN_D3D_PRIMITIVE_TOPOLOGY.TRIANGLELIST;
switch (topology)
{
case VertexBufferTopologys.Triangle: topologyType = REIGN_D3D_PRIMITIVE_TOPOLOGY.TRIANGLELIST; break;
case VertexBufferTopologys.Line: topologyType = REIGN_D3D_PRIMITIVE_TOPOLOGY.LINELIST; break;
case VertexBufferTopologys.Point: topologyType = REIGN_D3D_PRIMITIVE_TOPOLOGY.POINTLIST; break;
}
com = new VertexBufferCom(video.com, topologyType);
var bufferUsage = (usage == BufferUsages.Write) ? REIGN_D3D11_USAGE.DYNAMIC : REIGN_D3D11_USAGE.DEFAULT;
var cpuUsage = (usage == BufferUsages.Write) ? REIGN_D3D11_CPU_ACCESS_FLAG.WRITE : (REIGN_D3D11_CPU_ACCESS_FLAG)0;
var error = com.Init(vertices, vertexCount, vertexByteSize, bufferUsage, cpuUsage);
if (error == VertexBufferErrors.Buffer)
{
Debug.ThrowError("VertexBuffer", "Failed to create Buffer");
}
if (indices != null && indices.Length != 0)
{
indexBuffer = new IndexBuffer(this, usage, indices);
}
}
catch (Exception e)
{
Dispose();
throw e;
}
}
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 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 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(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 IVertexBuffer New(IDisposableResource parent, IBufferLayoutDesc bufferLayoutDesc, BufferUsages usage, VertexBufferTopologys topology, float[] vertices)
{
return(New(VideoAPI.DefaultAPI, parent, bufferLayoutDesc, usage, topology, vertices, null));
}
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);
}