/// <summary>
/// Maps the data contained in a subresource to a memory pointer, and denies the GPU access to that subresource.
/// </summary>
/// <param name="resource">The resource.</param>
/// <param name="mode">The mode.</param>
/// <param name="flags">The flags.</param>
/// <param name="stream">The output stream containing the pointer.</param>
/// <returns>
/// The locked <see cref="SharpDX.DataBox"/>
/// </returns>
/// <unmanaged>HRESULT ID3D11DeviceContext::Map([In] ID3D11Resource* pResource,[In] unsigned int Subresource,[In] D3D11_MAP MapType,[In] D3D11_MAP_FLAG MapFlags,[Out] D3D11_MAPPED_SUBRESOURCE* pMappedResource)</unmanaged>
public DataBox MapSubresource(Buffer resource, MapMode mode, MapFlags flags, out DataStream stream)
{
var box = MapSubresource(resource, 0, mode, flags);
stream = new DataStream(box.DataPointer, resource.Description.SizeInBytes, true, true);
return(box);
}
public Details(JToken j)
{
Flags = j[nameof(Flags)].EnumValue <MapFlags>();
Section = j[nameof(Section)].EnumValue <MapSection>();
Weather = j[nameof(Weather)].EnumValue <MapWeather>();
Music = j[nameof(Music)].EnumValue <Song>();
}
public static extern ErrorCode EnqueueSVMMap(IntPtr commandQueue,
int blockingMap,
MapFlags mapFlags,
IntPtr svmPtr,
IntPtr size,
uint numEventsInWaitList,
[In][MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.SysUInt, SizeParamIndex = 6)] Event[] eventWaitList,
[Out][MarshalAs(UnmanagedType.Struct)] out Event e);
internal static extern IntPtr clEnqueueMapBuffer(IntPtr commandQueue,
IntPtr buffer,
uint blockingMap,
MapFlags mapFlags,
IntPtr offset,
IntPtr cb,
uint numEventsInWaitList, [In][MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.SysUInt, SizeParamIndex = 6)] Event[] eventWaitList, [Out] out Event e,
out ErrorCode errCodeRet);
internal static extern IntPtr clEnqueueMapImage(IntPtr commandQueue,
IntPtr image,
uint blockingMap,
MapFlags mapFlags, [In][MarshalAs(UnmanagedType.LPArray, SizeConst = 3)] IntPtr[] origin, [In][MarshalAs(UnmanagedType.LPArray, SizeConst = 3)] IntPtr[] region,
out IntPtr imageRowPitch,
out IntPtr imageSlicePitch,
uint numEventsInWaitList, [In][MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.SysUInt, SizeParamIndex = 8)] Event[] eventWaitList, [Out] out Event e,
out ErrorCode errCodeRet);
public Details(EndianBinaryReader r)
{
Flags = r.ReadEnum <MapFlags>();
Section = r.ReadEnum <MapSection>();
Weather = r.ReadEnum <MapWeather>();
Music = r.ReadEnum <Song>();
BurmyForm = r.ReadEnum <PBEForm>();
}
public Details(JToken j)
{
Flags = j[nameof(Flags)].ReadFlagsEnumValue <MapFlags>();
Section = j[nameof(Section)].ReadEnumValue <MapSection>();
Weather = j[nameof(Weather)].ReadEnumValue <MapWeather>();
Music = j[nameof(Music)].ReadEnumValue <Song>();
BurmyForm = j[nameof(BurmyForm)].ReadEnumValue <PBEForm>();
}
public void Map <T>(DeviceContext4 context4,
T[] data,
MapMode mapMode = MapMode.WriteDiscard,
MapFlags mapFlags = MapFlags.None)
where T : unmanaged
{
Map(context4, 0, data, 0, data.Length, mapMode, mapFlags);
}
/// <summary>
/// 文字列を変換する（LCMapStringWのラッパ)
/// </summary>
/// <param name="s">string : 変換元の文字列</param>
/// <param name="flags">MapFlags : 変換条件</param>
/// <returns>string</returns>
public static string StringConvert(this string s, MapFlags flags)
{
var ci = CultureInfo.CurrentCulture;
var result = new string(' ', s.Length);
LCMapStringW(ci.LCID, (uint)flags, s, s.Length, result, result.Length);
return(result);
}
IntPtr MappingAsync(bool blocking, Memory buffer, MapFlags flags, int offset, int cb)
{
int errcode;
IntPtr ptr = Native.clEnqueueMapBuffer(_handle, buffer.Handle, blocking ? CL_Bool.True : CL_Bool.False,
flags, new IntPtr(offset), new IntPtr(cb), 0, null, IntPtr.Zero, out errcode);
OpenCLException.Check(errcode);
return(ptr);
}
/// <summary>
/// Maps the texture, providing CPU access to its contents.
/// </summary>
/// <param name="mipSlice">The mip slice to map.</param>
/// <param name="mode">The IO operations to enable on the CPU.</param>
/// <param name="flags">Flags indicating how the CPU should respond when the GPU is busy.</param>
/// <returns>
/// A databox containing the mapped data. This data stream is invalidated when the buffer is unmapped.
/// </returns>
public DataBox Map(int mipSlice, MapMode mode, MapFlags flags)
{
var desc = Description;
int subresource = CalculateSubResourceIndex(mipSlice, 0, desc.MipLevels);
DataBox mappedTexture3D;
Map(subresource, mode, flags, out mappedTexture3D);
return mappedTexture3D;
}
public extern static IntPtr clEnqueueMapBuffer(
IntPtr command_queue,
IntPtr buffer,
CL_Bool blocking_map,
MapFlags map_flags,
IntPtr offset,
IntPtr cb,
uint num_events_in_wait_list,
IntPtr[] event_wait_list,
IntPtr event_wait,
out int errcode_ret);
public unsafe IntPtr Map(CommandQueue queue, MapFlags flags, IntPtr offset, IntPtr size)
{
ErrorCode errorCode = ErrorCode.Success;
IntPtr result = Native.EnqueueMapBuffer(queue.Handle, this.Handle, true, flags, offset, size, 0, null, null, &errorCode);
if (errorCode != ErrorCode.Success)
{
throw new OpenCLCallFailedException(errorCode);
}
return(result);
}
public Map()
{
Id = 0;
Height = 0;
Width = 0;
ExpModifier = 0;
DropModifier = 0;
Flags = 0;
Weather = WeatherType.None;
Portals = new Dictionary <int, Portal>();
Entities = new ConcurrentDictionary <int, YiObj>();
}
public Map()
{
Id = 0;
Height = 0;
Width = 0;
ExpModifier = 0;
DropModifier = 0;
Flags = 0;
SpawnVector2 = new Vector2(0, 0);
Weather = WeatherType.None;
Entities = new ConcurrentDictionary <int, YiObj>();
}
public Event EnqueueMapBuffer(Buffer buffer, bool blocking, MapFlags mapFlags, long offset, long size, out IntPtr mappedPointer, params Event[] eventWaitList)
{
EventSafeHandle[] eventHandles = null;
if (eventWaitList != null)
{
eventHandles = Array.ConvertAll(eventWaitList, @event => @event.Handle);
}
EventSafeHandle handle = UnsafeNativeMethods.EnqueueMapBuffer(Handle, buffer.Handle, blocking, mapFlags, (IntPtr)offset, (IntPtr)size, out mappedPointer, eventHandles);
return(new Event(handle));
}
public Map(string name, int id, int variant, MapType type, MapFlags flags)
{
Name = name;
MapID = id;
VariantID = variant;
Type = type;
Flags = flags;
Clients = new List <Client>();
GenerationArgs = new GenParam();
Objects = ObjectManager.Instance.GetObjectsForZone(Name);
NPCs = ObjectManager.Instance.getNPCSForZone(Name);
}
public Map(string name, int id, int variant, MapType type, MapFlags flags)
{
Name = name;
MapID = id;
VariantID = variant;
Type = type;
Flags = flags;
Clients = new List<Client>();
GenerationArgs = new GenParam();
Objects = ObjectManager.Instance.GetObjectsForZone(Name);
NPCs = ObjectManager.Instance.getNPCSForZone(Name);
}
public override System.Collections.Generic.Queue <Moonfish.Tags.BlamPointer> ReadFields(System.IO.BinaryReader binaryReader)
{
System.Collections.Generic.Queue <Moonfish.Tags.BlamPointer> pointerQueue = new System.Collections.Generic.Queue <Moonfish.Tags.BlamPointer>(base.ReadFields(binaryReader));
this.ContrailFlags = ((Flags)(binaryReader.ReadInt16()));
this.ContrailScaleFlags = ((ScaleFlags)(binaryReader.ReadInt16()));
this.PointGenerationRate = binaryReader.ReadSingle();
this.PointVelocity = binaryReader.ReadRange();
this.PointVelocityConeAngle = binaryReader.ReadSingle();
this.InheritedVelocityFraction = binaryReader.ReadSingle();
this.RenderType = ((RenderTypeEnum)(binaryReader.ReadInt16()));
this.fieldpad = binaryReader.ReadBytes(2);
this.TextureRepeatsU = binaryReader.ReadSingle();
this.TextureRepeatsV = binaryReader.ReadSingle();
this.TextureAnimationU = binaryReader.ReadSingle();
this.TextureAnimationV = binaryReader.ReadSingle();
this.AnimationRate = binaryReader.ReadSingle();
this.Bitmap = binaryReader.ReadTagReference();
this.FirstSequenceIndex = binaryReader.ReadInt16();
this.SequenceCount = binaryReader.ReadInt16();
this.fieldpad0 = binaryReader.ReadBytes(40);
this.ContrailShaderFlags = ((ShaderFlags)(binaryReader.ReadInt16()));
this.FramebufferBlendFunction = ((FramebufferBlendFunctionEnum)(binaryReader.ReadInt16()));
this.FramebufferFadeMode = ((FramebufferFadeModeEnum)(binaryReader.ReadInt16()));
this.ContrailMapFlags = ((MapFlags)(binaryReader.ReadInt16()));
this.fieldpad1 = binaryReader.ReadBytes(28);
this.Bitmap0 = binaryReader.ReadTagReference();
this.Anchor = ((AnchorEnum)(binaryReader.ReadInt16()));
this.ContrailContrailFlags0 = ((ContrailFlags0)(binaryReader.ReadInt16()));
this.fieldpad2 = binaryReader.ReadBytes(2);
this.UanimationFunction = ((UanimationFunctionEnum)(binaryReader.ReadInt16()));
this.UanimationPeriod = binaryReader.ReadSingle();
this.UanimationPhase = binaryReader.ReadSingle();
this.UanimationScale = binaryReader.ReadSingle();
this.fieldpad3 = binaryReader.ReadBytes(2);
this.VanimationFunction = ((VanimationFunctionEnum)(binaryReader.ReadInt16()));
this.VanimationPeriod = binaryReader.ReadSingle();
this.VanimationPhase = binaryReader.ReadSingle();
this.VanimationScale = binaryReader.ReadSingle();
this.fieldpad4 = binaryReader.ReadBytes(2);
this.RotationanimationFunction = ((RotationanimationFunctionEnum)(binaryReader.ReadInt16()));
this.RotationanimationPeriod = binaryReader.ReadSingle();
this.RotationanimationPhase = binaryReader.ReadSingle();
this.RotationanimationScale = binaryReader.ReadSingle();
this.RotationanimationCenter = binaryReader.ReadVector2();
this.fieldpad5 = binaryReader.ReadBytes(4);
this.ZspriteRadiusScale = binaryReader.ReadSingle();
this.fieldpad6 = binaryReader.ReadBytes(20);
pointerQueue.Enqueue(binaryReader.ReadBlamPointer(64));
return(pointerQueue);
}
public Event EnqueueMapBuffer(
Buffer buffer, bool blocking, MapFlags flags,
long offset, long size, Event[] events, out IntPtr pointer)
{
if (offset < 0)
{
throw new ArgumentOutOfRangeException("offset", offset, "offset is less than zero.");
}
if (size < 0)
{
throw new ArgumentOutOfRangeException("size", size, "size is less than zero.");
}
return(EnqueueMapBuffer(buffer, blocking, flags, (ulong)offset, (ulong)size, events, out pointer));
}
/// <summary>
/// Maps the texture, providing CPU access to its contents.
/// </summary>
/// <param name="mipSlice">The mip slice to map.</param>
/// <param name="mode">The IO operations to enable on the CPU.</param>
/// <param name="flags">Flags indicating how the CPU should respond when the GPU is busy.</param>
/// <returns>A data stream containing the mapped data. This data stream is invalidated
/// when the buffer is unmapped.</returns>
public DataStream Map(int mipSlice, MapMode mode, MapFlags flags)
{
var desc = Description;
int subresource = CalculateSubResourceIndex( mipSlice, 0, desc.MipLevels );
int mipWidth = GetMipSize( mipSlice, desc.Width );
int bufferSize = (int)(mipWidth * FormatHelper.SizeOfInBytes(desc.Format));
IntPtr dataPointer;
Map(subresource, mode, flags, out dataPointer);
bool canRead = mode == MapMode.Read || mode == MapMode.ReadWrite;
bool canWrite = mode != MapMode.Read;
return new DataStream(dataPointer, bufferSize, canRead, canWrite);
}
/// <summary>
/// LCMapStringのwrapper
/// ref. http://d.hatena.ne.jp/deraw/20060831/1156992224
/// sourceがnullのとき、nullを返す
/// </summary>
/// <param name="source">ソース文字列</param>
/// <param name="mapFlags">変換フラグ</param>
/// <returns>変換後の文字列</returns>
public static String LCMapString(string source, MapFlags mapFlags)
{
if (source == null)
{
return(null);
}
char[] buffer = new char[source.Length * 2];
int len = _LCMapString(System.Threading.Thread.CurrentThread.CurrentCulture.LCID, (uint)mapFlags, source, source.Length, buffer, buffer.Length);
if (len < 0)
{
throw new ArgumentException("\"LCMAP_SORTKEY\" is not support ");
}
return(new String(buffer, 0, len));
}
public Event EnqueueMapImage(Image image, bool blocking, MapFlags mapFlags, BufferCoordinates origin, BufferSize region, out long rowPitch, out long slicePitch, out IntPtr mappedPointer, params Event[] eventWaitList)
{
EventSafeHandle[] eventHandles = null;
if (eventWaitList != null)
{
eventHandles = Array.ConvertAll(eventWaitList, @event => @event.Handle);
}
IntPtr imageRowPitch;
IntPtr imageSlicePitch;
EventSafeHandle handle = UnsafeNativeMethods.EnqueueMapImage(Handle, image.Handle, blocking, mapFlags, ref origin, ref region, out imageRowPitch, out imageSlicePitch, out mappedPointer, eventHandles);
rowPitch = imageRowPitch.ToInt64();
slicePitch = imageSlicePitch.ToInt64();
return(new Event(handle));
}
/// <summary>
/// Maps the texture, providing CPU access to its contents.
/// </summary>
/// <param name="mipSlice">The mip slice to map.</param>
/// <param name="mode">The IO operations to enable on the CPU.</param>
/// <param name="flags">Flags indicating how the CPU should respond when the GPU is busy.</param>
/// <returns>A data stream containing the mapped data. This data stream is invalidated
/// when the buffer is unmapped.</returns>
public DataStream Map(int mipSlice, MapMode mode, MapFlags flags)
{
var desc = Description;
int subresource = CalculateSubResourceIndex(mipSlice, 0, desc.MipLevels);
int mipWidth = GetMipSize(mipSlice, desc.Width);
int bufferSize = (int)(mipWidth * FormatHelper.SizeOfInBytes(desc.Format));
IntPtr dataPointer;
Map(subresource, mode, flags, out dataPointer);
bool canRead = mode == MapMode.Read || mode == MapMode.ReadWrite;
bool canWrite = mode != MapMode.Read;
return(new DataStream(dataPointer, bufferSize, canRead, canWrite));
}
/// <summary>
/// Maps the texture, providing CPU access to its contents.
/// </summary>
/// <param name="mipSlice">The mip slice to map.</param>
/// <param name="mode">The IO operations to enable on the CPU.</param>
/// <param name="flags">Flags indicating how the CPU should respond when the GPU is busy.</param>
/// <param name="dataStream">The data stream.</param>
/// <returns>
/// A databox containing the mapped data. This data stream is invalidated when the buffer is unmapped.
/// </returns>
public DataBox Map(int mipSlice, MapMode mode, MapFlags flags, out DataStream dataStream)
{
var desc = Description;
int subresource = CalculateSubResourceIndex(mipSlice, 0, desc.MipLevels);
DataBox mappedTexture3D;
Map(subresource, mode, flags, out mappedTexture3D);
bool canRead = mode == MapMode.Read || mode == MapMode.ReadWrite;
bool canWrite = mode != MapMode.Read;
int mipDepth = GetMipSize(mipSlice, desc.Depth);
dataStream = new DataStream(mappedTexture3D.DataPointer, mipDepth * mappedTexture3D.SlicePitch, canRead, canWrite);
return(mappedTexture3D);
}
private Map()
{
level = 0;
name = "<insert name here>";
description = "<insert desc here>";
flags = new MapFlags(128);
InitialScore = 0;
InitialLivesCount = 5;
InitialWeapon = new MachineGun();
events = new List <Event>();
EnemyRessourcesToLoad = new List <BadGuy>();
MusicRessourcesToLoad = new List <MySong>();
Ended = EndMode.None;
StartTime = 0.0f;
}
public unsafe void Map <T>(DeviceContext4 context4,
int offset,
T[] data,
int dataOffset,
int dataLength,
MapMode mapMode = MapMode.WriteDiscard,
MapFlags mapFlags = MapFlags.None)
where T : unmanaged
{
DataBox box = context4.MapSubresource(_buffer, 0, mapMode, mapFlags);
T * vpctPtr = (T *)box.DataPointer;
for (int i = 0; i < dataLength; i++)
{
*(vpctPtr + offset + i) = data[i + dataOffset];
}
context4.UnmapSubresource(_buffer, 0);
}
public IntPtr Map(CommandQueue queue, MapFlags flags, Offset2D origin, Dim2D region, out IntPtr pitch)
{
Offset3D origin_buf = new Offset3D(origin.X, origin.Y, (IntPtr)0);
Dim3D region_buf = new Dim3D(region.X, region.Y, (IntPtr)1);
IntPtr tempPitch = IntPtr.Zero;
ErrorCode errorCode;
IntPtr result = IntPtr.Zero;
unsafe {
result = Native.EnqueueMapImage(queue.Handle, this.Handle, true, flags, &origin_buf, ®ion_buf, &tempPitch, null, 0, null, null, &errorCode);
pitch = tempPitch;
}
if (errorCode != ErrorCode.Success)
{
throw new OpenCLCallFailedException(errorCode);
}
return(result);
}
public Event EnqueueMapBuffer(
Buffer buffer, bool blocking, MapFlags flags,
ulong offset, ulong size, Event[] events, out IntPtr pointer)
{
ClHelper.ThrowNullException(Handle);
if (buffer == Buffer.Null)
{
throw new ArgumentNullException("buffer");
}
unsafe
{
int num_events_in_wait_list = events == null ? 0 : events.Length;
IntPtr *wait_list = stackalloc IntPtr[num_events_in_wait_list];
for (int i = 0; i < num_events_in_wait_list; ++i)
{
wait_list[i] = events[i].Handle;
}
if (events == null)
{
wait_list = null;
}
IntPtr event_ptr = IntPtr.Zero;
int error;
void *result = Cl.EnqueueMapBuffer(Handle,
buffer.Handle, blocking ? 1u : 0u, (ulong)flags,
new UIntPtr(offset), new UIntPtr(size),
(uint)num_events_in_wait_list, wait_list, &event_ptr, &error);
ClHelper.GetError(error);
pointer = new IntPtr(result);
return(new Event(event_ptr));
}
}
public IntPtr EnqueueMap(CommandQueue queue, MapFlags flags, Offset2D origin, Dim2D region, out IntPtr pitch, Event[] waitList, out Event evt)
{
Offset3D origin_buf = new Offset3D(origin.X, origin.Y, (IntPtr)0);
Dim3D region_buf = new Dim3D(region.X, region.Y, (IntPtr)1);
IntPtr tempPitch = IntPtr.Zero;
uint waitCount = (waitList == null ? 0 : (uint)waitList.Length);
IntPtr[] wlh = CLObject.GetHandles(waitList);
IntPtr evtHandle = IntPtr.Zero;
ErrorCode errorCode;
IntPtr result = IntPtr.Zero;
unsafe {
result = Native.EnqueueMapImage(queue.Handle, this.Handle, true, flags, &origin_buf, ®ion_buf, &tempPitch, null, waitCount, wlh, &evtHandle, &errorCode);
}
if (errorCode != ErrorCode.Success)
{
throw new OpenCLCallFailedException(errorCode);
}
pitch = tempPitch;
evt = new Event(evtHandle);
return(result);
}
public IntPtr EnqueueMapBuffer(Mem buffer, bool blockingMap, MapFlags map_flags, long offset, long cb)
{
void* pMappedPtr;
ErrorCode result;
pMappedPtr = OpenCL.EnqueueMapBuffer(CommandQueueID, buffer, blockingMap ? (uint)Bool.TRUE : (uint)Bool.FALSE, (ulong)map_flags, offset, cb, 0, null, null, out result);
if (result != ErrorCode.SUCCESS)
throw new OpenCLException("EnqueueMapBuffer failed with error code " + result, result);
return (IntPtr)pMappedPtr;
}
public IntPtr EnqueueMapBuffer(Mem buffer, bool blockingMap, MapFlags map_flags, IntPtr offset, IntPtr cb)
{
ErrorCode result;
IntPtr ptr;
ptr = (IntPtr)OpenCL.EnqueueMapBuffer(CommandQueueID,
buffer.MemID,
(uint)(blockingMap ? Bool.TRUE : Bool.FALSE),
(ulong)map_flags,
offset,
cb,
(uint)0,
null,
null,
out result);
if (result != ErrorCode.SUCCESS)
throw new OpenCLException("EnqueueMapBuffer failed with error code " + result, result);
return ptr;
}
/// <summary>
/// Maps the texture, providing CPU access to its contents.
/// </summary>
/// <param name="mipSlice">The mip slice to map.</param>
/// <param name="mode">The IO operations to enable on the CPU.</param>
/// <param name="flags">Flags indicating how the CPU should respond when the GPU is busy.</param>
/// <param name="dataStream">The data stream.</param>
/// <returns>
/// A databox containing the mapped data. This data stream is invalidated when the buffer is unmapped.
/// </returns>
public DataBox Map(int mipSlice, MapMode mode, MapFlags flags, out DataStream dataStream)
{
var desc = Description;
int subresource = CalculateSubResourceIndex(mipSlice, 0, desc.MipLevels);
DataBox mappedTexture3D;
Map(subresource, mode, flags, out mappedTexture3D);
bool canRead = mode == MapMode.Read || mode == MapMode.ReadWrite;
bool canWrite = mode != MapMode.Read;
int mipDepth = GetMipSize(mipSlice, desc.Depth);
dataStream = new DataStream(mappedTexture3D.DataPointer, mipDepth * mappedTexture3D.SlicePitch, canRead, canWrite);
return mappedTexture3D;
}
internal extern static unsafe IntPtr EnqueueMapImage(IntPtr command_queue, IntPtr image, bool blocking_map, MapFlags map_flags, IntPtr** origin, IntPtr** region, IntPtr* image_row_pitch, IntPtr* image_slice_pitch, uint num_events_in_wait_list, IntPtr* event_wait_list, IntPtr* @event, [OutAttribute] int* errcode_ret);
/// <summary>
/// Acquires access to the surface data.
/// </summary>
/// <param name="flags">Flags specifying CPU access permissions.</param>
/// <returns>A <see cref="T:SharpDX.DataRectangle" /> for accessing the mapped data, or <c>null</c> on failure.</returns>.
public DataRectangle Map(MapFlags flags)
{
MappedRectangle mappedRect;
Map(out mappedRect, (int) flags);
return new DataRectangle(mappedRect.PBits, mappedRect.Pitch);
}
public Event EnqueueMapImage(Image image, bool blocking, MapFlags mapFlags, BufferCoordinates origin, BufferSize region, out long rowPitch, out long slicePitch, out IntPtr mappedPointer, params Event[] eventWaitList)
{
EventSafeHandle[] eventHandles = null;
if (eventWaitList != null)
eventHandles = Array.ConvertAll(eventWaitList, @event => @event.Handle);
IntPtr imageRowPitch;
IntPtr imageSlicePitch;
EventSafeHandle handle = UnsafeNativeMethods.EnqueueMapImage(this.Handle, image.Handle, blocking, mapFlags, ref origin, ref region, out imageRowPitch, out imageSlicePitch, out mappedPointer, eventHandles);
rowPitch = imageRowPitch.ToInt64();
slicePitch = imageSlicePitch.ToInt64();
return new Event(handle);
}
public Event EnqueueMapBuffer(Buffer buffer, bool blocking, MapFlags mapFlags, long offset, long size, out IntPtr mappedPointer, params Event[] eventWaitList)
{
EventSafeHandle[] eventHandles = null;
if (eventWaitList != null)
eventHandles = Array.ConvertAll(eventWaitList, @event => @event.Handle);
EventSafeHandle handle = UnsafeNativeMethods.EnqueueMapBuffer(this.Handle, buffer.Handle, blocking, mapFlags, (IntPtr)offset, (IntPtr)size, out mappedPointer, eventHandles);
return new Event(handle);
}
public IntPtr EnqueueMapImage(Mem image, bool blockingMap, MapFlags map_flags, long[] origin, long[] region, out long image_row_pitch, out long image_slice_pitch)
{
void* pMappedPtr;
ErrorCode result;
IntPtr* repackedOrigin = stackalloc IntPtr[3];
IntPtr* repackedRegion = stackalloc IntPtr[3];
InteropTools.A3ToIntPtr3(origin, repackedOrigin);
InteropTools.A3ToIntPtr3(region, repackedRegion);
pMappedPtr = OpenCL.EnqueueMapImage(CommandQueueID, image, (uint)(blockingMap ? Bool.TRUE : Bool.TRUE), (ulong)map_flags, repackedOrigin, repackedRegion, out image_row_pitch, out image_slice_pitch, 0, null, null, out result);
if (result != ErrorCode.SUCCESS)
throw new OpenCLException("EnqueueMapImage failed with error code " + result, result);
return (IntPtr)pMappedPtr;
}
public IntPtr EnqueueMapBuffer(Mem buffer, bool blockingMap, MapFlags map_flags, long offset, long cb, int num_events_in_wait_list, Event[] event_wait_list)
{
void* pMappedPtr;
ErrorCode result;
IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
if (num_events_in_wait_list == 0)
repackedEvents = null;
InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
pMappedPtr = OpenCL.EnqueueMapBuffer(CommandQueueID, buffer, blockingMap ? (uint)Bool.TRUE : (uint)Bool.FALSE, (ulong)map_flags, offset, cb, num_events_in_wait_list, repackedEvents, null, out result);
if (result != ErrorCode.SUCCESS)
throw new OpenCLException("EnqueueMapBuffer failed with error code " + result, result);
return (IntPtr)pMappedPtr;
}
public IntPtr EnqueueMapBuffer(Mem buffer, bool blockingMap, MapFlags map_flags, IntPtr offset, IntPtr cb, int num_events_in_wait_list, Event[] event_wait_list)
{
ErrorCode result;
IntPtr ptr;
ptr = (IntPtr)OpenCL.EnqueueMapBuffer(CommandQueueID,
buffer.MemID,
(uint)(blockingMap ? Bool.TRUE : Bool.FALSE),
(ulong)map_flags,
offset,
cb,
(uint)num_events_in_wait_list,
InteropTools.ConvertEventsToEventIDs(event_wait_list),
null,
out result);
if (result != ErrorCode.SUCCESS)
throw new OpenCLException("EnqueueMapBuffer failed with error code " + result, result);
return ptr;
}
public IntPtr EnqueueMapImage(Mem image, bool blockingMap, MapFlags map_flags, IntPtr[] origin, IntPtr[] region, out IntPtr image_row_pitch, out IntPtr image_slice_pitch, int num_events_in_wait_list, Event[] event_wait_list)
{
IntPtr ptr;
ErrorCode result;
ptr = (IntPtr)OpenCL.EnqueueMapImage(CommandQueueID,
image.MemID,
(uint)(blockingMap ? Bool.TRUE : Bool.FALSE),
(ulong)map_flags,
origin,
region,
out image_row_pitch,
out image_slice_pitch,
(uint)num_events_in_wait_list,
InteropTools.ConvertEventsToEventIDs(event_wait_list),
null,
out result);
if (result != ErrorCode.SUCCESS)
throw new OpenCLException("EnqueueMapImage failed with error code " + result, result);
return ptr;
}
/// <summary>
/// Maps the texture, providing CPU access to its contents.
/// </summary>
/// <param name="mipSlice">The mip slice to map.</param>
/// <param name="mode">The IO operations to enable on the CPU.</param>
/// <param name="flags">Flags indicating how the CPU should respond when the GPU is busy.</param>
/// <param name="dataStream">The data stream.</param>
/// <returns>
/// A data rectangle containing the mapped data. This data stream is invalidated when the buffer is unmapped.
/// </returns>
public DataRectangle Map(int mipSlice, MapMode mode, MapFlags flags, out DataStream dataStream)
{
var desc = Description;
int subresource = CalculateSubResourceIndex(mipSlice, 0, desc.MipLevels);
int mipHeight = GetMipSize(mipSlice, desc.Height);
DataRectangle mappedTexture2D;
Map(subresource, mode, flags, out mappedTexture2D);
bool canRead = mode == MapMode.Read || mode == MapMode.ReadWrite;
bool canWrite = mode != MapMode.Read;
dataStream = new DataStream(mappedTexture2D.DataPointer, mipHeight * mappedTexture2D.Pitch, canRead, canWrite);
return mappedTexture2D;
}
public IntPtr EnqueueMapImage(Mem image, bool blockingMap, MapFlags map_flags, long[] origin, long[] region, out long image_row_pitch, out long image_slice_pitch, int num_events_in_wait_list, Event[] event_wait_list)
{
void* pMappedPtr;
ErrorCode result;
IntPtr* repackedOrigin = stackalloc IntPtr[3];
IntPtr* repackedRegion = stackalloc IntPtr[3];
IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
if (num_events_in_wait_list == 0)
repackedEvents = null;
InteropTools.A3ToIntPtr3(origin, repackedOrigin);
InteropTools.A3ToIntPtr3(region, repackedRegion);
InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
pMappedPtr = OpenCL.EnqueueMapImage(CommandQueueID, image, (uint)(blockingMap ? Bool.TRUE : Bool.TRUE), (ulong)map_flags, repackedOrigin, repackedRegion, out image_row_pitch, out image_slice_pitch, num_events_in_wait_list, repackedEvents, null, out result);
if (result != ErrorCode.SUCCESS)
throw new OpenCLException("EnqueueMapImage failed with error code " + result, result);
return (IntPtr)pMappedPtr;
}
public static extern int LCMapStringW(int Local, MapFlags dwMapFlags, [MarshalAs(UnmanagedType.LPWStr)]string lpSrcStr, int cchSrc, [MarshalAs(UnmanagedType.LPWStr)]string lpDestStr, int cchDest);
/// <summary>
/// Acquires access to the surface data.
/// </summary>
/// <param name="flags">Flags specifying CPU access permissions.</param>
/// <param name="dataStream">Stream to contain the surface data.</param>
/// <returns>A <see cref="T:SharpDX.DataRectangle" /> for accessing the mapped data, or <c>null</c> on failure.</returns>.
public DataRectangle Map(MapFlags flags, out DataStream dataStream)
{
var dataRectangle = Map(flags);
dataStream = new DataStream(dataRectangle.DataPointer, Description.Height * dataRectangle.Pitch, true, true);
return dataRectangle;
}
internal extern static unsafe IntPtr EnqueueMapBuffer(IntPtr command_queue, IntPtr buffer, bool blocking_map, MapFlags map_flags, IntPtr offset, IntPtr cb, uint num_events_in_wait_list, IntPtr* event_wait_list, IntPtr* @event, [OutAttribute] int* errcode_ret);
public IntPtr EnqueueMapImage(Mem image, bool blockingMap, MapFlags map_flags, IntPtr[] origin, IntPtr[] region, out IntPtr image_row_pitch, out IntPtr image_slice_pitch)
{
IntPtr ptr;
ErrorCode result;
ptr = (IntPtr)OpenCL.EnqueueMapImage(CommandQueueID,
image.MemID,
(uint)(blockingMap ? Bool.TRUE : Bool.FALSE),
(ulong)map_flags,
origin,
region,
out image_row_pitch,
out image_slice_pitch,
(uint)0,
null,
null,
out result);
if (result != ErrorCode.SUCCESS)
throw new OpenCLException("EnqueueMapImage failed with error code " + result, result);
return ptr;
}
public extern static IntPtr clEnqueueMapBuffer ( IntPtr command_queue, IntPtr buffer, CL_Bool blocking_map, MapFlags map_flags, IntPtr offset, IntPtr cb, uint num_events_in_wait_list, IntPtr[] event_wait_list, IntPtr event_wait, out int errcode_ret);
