/// <summary>
/// Discard is valid only for dynamic buffers
/// </summary>
public static void SetData <T>(this IndexBuffer indexBuffer, T[] data, LockFlags flags = LockFlags.None)
where T : struct
{
int itemSize = Utilities.SizeOf <T>();
var ptr = indexBuffer.LockToPointer(0, itemSize * data.Length, flags);
Utilities.Write(ptr, data, 0, data.Length);
indexBuffer.Unlock();
}
/// <summary>
/// Locks the specified index buffer.
/// </summary>
/// <param name="offsetToLock">The offset in the buffer.</param>
/// <param name="sizeToLock">The size of the buffer to lock.</param>
/// <param name="lockFlags">The lock flags.</param>
/// <returns>A <see cref="System.IntPtr" /> containing the locked index buffer.</returns>
public IntPtr LockToPointer(int offsetToLock, int sizeToLock, LockFlags lockFlags = LockFlags.None)
{
if (sizeToLock == 0)
{
sizeToLock = Description.SizeInBytes;
}
return(Lock(offsetToLock, sizeToLock, lockFlags));
}
public LockedRegion Lock(PixelFormat format, LockFlags flags)
{
var ptr = Allegro5.al_lock_bitmap(Ptr, format, flags);
if (ptr == IntPtr.Zero)
{
return null;
}
return new LockedRegion(ptr, this);
}
public LockData(string Tag = null)
: base(Tag)
{
Level = new Byte();
Unused = new byte[3];
Key = new FormID();
Flags = new LockFlags();
Unknown = new byte[11];
}
/// <summary>
/// Locks a box on a volume resource.
/// </summary>
/// <param name="box">The box.</param>
/// <param name="flags">The flags.</param>
/// <returns>The locked region of this resource</returns>
/// <unmanaged>HRESULT IDirect3DVolume9::LockBox([Out] D3DLOCKED_BOX* pLockedVolume,[In] const void* pBox,[In] D3DLOCK Flags)</unmanaged>
public DataBox LockBox(Box box, LockFlags flags)
{
unsafe
{
LockedBox lockedBox;
LockBox(out lockedBox, new IntPtr(&box), flags);
return(new DataBox(lockedBox.PBits, lockedBox.RowPitch, lockedBox.SlicePitch));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="FairReaderWriterLock"/> class.
/// </summary>
public FairReaderWriterLock(int lockTimeout)
{
_uMainLock = new SpinLock(true);
_uLockFlags = LockFlags.None;
_uSharedCount = 0;
ReadLock = new CommonReadLock(this, lockTimeout);
WriteLock = new CommonWriteLock(this, lockTimeout);
}
/// <summary>
/// Locks the specified region for direct access.
/// </summary>
/// <param name="rect">The area to lock</param>
/// <param name="readOnly">Specifies that the lock is read-only</param>
/// <returns>An array containing the 32-bit pixel values of the canvas</returns>
public GraphicsStream LockToGraphicsStream(bool readOnly)
{
LockFlags flags = LockFlags.None;
if (readOnly)
{
flags |= LockFlags.ReadOnly;
}
return(tex.LockRectangle(0, flags));
}
/// <summary>
/// Locks the entire canvas for direct access.
/// </summary>
/// <param name="readOnly">Specifies that the lock is read-only.</param>
/// <returns>An array containing the 32-bit pixel values of the canvas.</returns>
public int[] Lock(bool readOnly)
{
LockFlags flags = LockFlags.None;
if (readOnly)
{
flags |= LockFlags.ReadOnly;
}
return(tex.LockRectangle(typeof(int), 0, flags, size) as int[]);
}
/// <summary>
/// Locks the specified index buffer.
/// </summary>
/// <param name="offsetToLock">The offset in the buffer.</param>
/// <param name="sizeToLock">The size of the buffer to lock.</param>
/// <param name="lockFlags">The lock flags.</param>
/// <returns>A <see cref="SharpDX.DataStream" /> containing the locked index buffer.</returns>
/// <msdn-id>bb205867</msdn-id>
/// <unmanaged>HRESULT IDirect3DIndexBuffer9::Lock([In] unsigned int OffsetToLock,[In] unsigned int SizeToLock,[Out] void** ppbData,[In] D3DLOCK Flags)</unmanaged>
/// <unmanaged-short>IDirect3DIndexBuffer9::Lock</unmanaged-short>
public SharpDX.DataStream Lock(int offsetToLock, int sizeToLock, LockFlags lockFlags)
{
IntPtr pOut;
if (sizeToLock == 0)
sizeToLock = Description.Size;
Lock(offsetToLock, sizeToLock, out pOut, lockFlags);
return new DataStream(pOut, sizeToLock, true, (lockFlags & LockFlags.ReadOnly) == 0);
}
public unsafe Span <T> Lock <T>(int offsetToLock, int sizeToLock, LockFlags lockFlags = LockFlags.None) where T : unmanaged
{
if (sizeToLock == 0)
{
sizeToLock = Description.SizeInBytes;
}
Lock(offsetToLock, sizeToLock, out var pOut, lockFlags);
return(new Span <T>(pOut.ToPointer(), sizeToLock));
}
public LockedRectangle LockRectangle(int level, D3DRect rect, LockFlags flags)
{
LockedRectangle lockedRect = new LockedRectangle();
int res = Interop.Calli(comPointer, level, (IntPtr)(void *)&lockedRect, (IntPtr)(void *)&rect, (int)flags, (*(IntPtr **)comPointer)[19]);
if (res < 0)
{
throw new SharpDXException(res);
}
return(lockedRect);
}
public unsafe static class DataBuffser { // Either 'VertexBuffer' or 'IndexBuffer
public static IntPtr Lock(IntPtr ptr, int offsetToLock, int sizeToLock, LockFlags flags)
{
IntPtr data;
int res = Interop.Calli(ptr, offsetToLock, sizeToLock, (IntPtr)(void *)&data, (int)flags, (*(IntPtr **)ptr)[11]);
if (res < 0)
{
throw new SharpDXException(res);
}
return(data);
}
public static LockedRectangle LockRectangle(IntPtr ptr, int level, LockFlags flags)
{
LockedRectangle rect = new LockedRectangle();
int res = Interop.Calli(ptr, level, (IntPtr)(void *)&rect, IntPtr.Zero, (int)flags, (*(IntPtr **)ptr)[19]);
if (res < 0)
{
throw new SharpDXException(res);
}
return(rect);
}
public IntPtr Lock(int offsetToLock, int sizeToLock, LockFlags flags)
{
IntPtr pOut;
int res = Interop.Calli(comPointer, offsetToLock, sizeToLock, (IntPtr)(void *)&pOut, (int)flags, (*(IntPtr **)comPointer)[11]);
if (res < 0)
{
throw new SharpDXException(res);
}
return(pOut);
}
/// <summary>
/// Locks the specified index buffer.
/// </summary>
/// <param name="offsetToLock">The offset in the buffer.</param>
/// <param name="sizeToLock">The size of the buffer to lock.</param>
/// <param name="lockFlags">The lock flags.</param>
/// <returns>A <see cref="SharpDX.DataStream" /> containing the locked index buffer.</returns>
/// <msdn-id>bb205867</msdn-id>
/// <unmanaged>HRESULT IDirect3DIndexBuffer9::Lock([In] unsigned int OffsetToLock,[In] unsigned int SizeToLock,[Out] void** ppbData,[In] D3DLOCK Flags)</unmanaged>
/// <unmanaged-short>IDirect3DIndexBuffer9::Lock</unmanaged-short>
public IntPtr LockToPointer(int offsetToLock, int sizeToLock, LockFlags lockFlags)
{
IntPtr pOut;
if (sizeToLock == 0)
{
sizeToLock = Description.Size;
}
Lock(offsetToLock, sizeToLock, out pOut, lockFlags);
return(pOut);
}
/// <summary>
/// Locks the specified index buffer.
/// </summary>
/// <param name="offsetToLock">The offset in the buffer.</param>
/// <param name="sizeToLock">The size of the buffer to lock.</param>
/// <param name="lockFlags">The lock flags.</param>
/// <returns>A <see cref="SharpDX.DataStream" /> containing the locked index buffer.</returns>
/// <msdn-id>bb205867</msdn-id>
/// <unmanaged>HRESULT IDirect3DIndexBuffer9::Lock([In] unsigned int OffsetToLock,[In] unsigned int SizeToLock,[Out] void** ppbData,[In] D3DLOCK Flags)</unmanaged>
/// <unmanaged-short>IDirect3DIndexBuffer9::Lock</unmanaged-short>
public SharpDX.DataStream Lock(int offsetToLock, int sizeToLock, LockFlags lockFlags)
{
IntPtr pOut;
if (sizeToLock == 0)
{
sizeToLock = Description.Size;
}
Lock(offsetToLock, sizeToLock, out pOut, lockFlags);
return(new DataStream(pOut, sizeToLock, true, (lockFlags & LockFlags.ReadOnly) == 0));
}
/// <summary>
/// Discard is valid only for dynamic buffers
/// </summary>
public static void SetData <T>(this VertexBuffer vertexBuffer, T[] data, LockFlags flags = LockFlags.None, int numDataToWrite = -1)
where T : struct
{
if (numDataToWrite == -1)
{
numDataToWrite = data.Length;
}
int itemSize = Utilities.SizeOf <T>();
var ptr = vertexBuffer.LockToPointer(0, itemSize * numDataToWrite, flags);
Utilities.Write(ptr, data, 0, numDataToWrite);
vertexBuffer.Unlock();
}
/// <summary>
/// Writes data to the buffer.
/// </summary>
/// <returns />
public void Read <T>(T[] data, int startIndex, int count, int bufferOffset, LockFlags flags) where T : struct
{
DataStream stream2 = null;
//Utilities.CheckArrayBounds(data, startIndex, ref count);
int bytes = Utilities.SizeOf <T>() * count;
DataStream stream1 = this.Lock(bufferOffset, bytes, flags, out stream2);
int count1 = (int)(((long)((int)stream1.Length)) / (Utilities.SizeOf <T>()));
stream1.ReadRange(data, startIndex, count1);
if ((stream2 != null) && (count > count1))
{
stream2.ReadRange <T>(data, count1 + startIndex, count - count1);
}
Unlock(stream1, stream2);
}
/// <summary>
/// The Lock method locks a portion of the buffer. Locking the buffer returns references into the buffer, allowing the application to read or write audio data into memory.
/// </summary>
/// <param name="offset">Offset, in bytes, from the start of the buffer to the point where the lock begins. </param>
/// <param name="sizeBytes">Size, in bytes, of the portion of the buffer to lock. Because the buffer is conceptually circular, this number can exceed the number of bytes between dwOffset and the end of the buffer. </param>
/// <param name="flags"> Flags modifying the lock event. The following flags are defined: ValueDescription DSBLOCK_FROMWRITECURSORStart the lock at the write cursor. The dwOffset parameter is ignored. DSBLOCK_ENTIREBUFFERLock the entire buffer. The dwBytes parameter is ignored. </param>
/// <param name="secondPart"> Address of a variable that receives a pointer to the second locked part of the capture buffer. If NULL is returned, the ppvAudioPtr1 parameter points to the entire locked portion of the capture buffer. </param>
/// <returns>Address of a variable that receives a pointer to the first locked part of the buffer.</returns>
/// <unmanaged>HRESULT IDirectSoundCaptureBuffer::Lock([None] int dwOffset,[None] int dwBytes,[Out] void** ppvAudioPtr1,[Out] int* pdwAudioBytes1,[Out] void** ppvAudioPtr2,[Out, Optional] int* pdwAudioBytes2,[None] int dwFlags)</unmanaged>
public DataStream Lock(int offset, int sizeBytes, LockFlags flags, out DataStream secondPart)
{
IntPtr dataPart1;
int sizePart1;
IntPtr dataPart2;
int sizePart2;
Lock(offset, sizeBytes, out dataPart1, out sizePart1, out dataPart2, out sizePart2, (int)flags);
secondPart = null;
if (dataPart2 != IntPtr.Zero)
{
secondPart = new DataStream(dataPart2, sizePart2, true, true);
}
return(new DataStream(dataPart1, sizePart1, true, true));
}
/// <summary>
/// Acceder al VertexBuffer del mesh.
/// Una vez que se termina de trabajar con el buffer se debe invocar siempre a unlock.
/// </summary>
/// <param name="lockFlags">Flags de lectura del buffer</param>
/// <returns>array de elementos</returns>
public Array lockVertexBuffer(LockFlags lockFlags)
{
switch (renderType)
{
case MeshRenderType.VERTEX_COLOR:
return((TgcSceneLoader.VertexColorVertex[])d3dMesh.LockVertexBuffer(
typeof(TgcSceneLoader.VertexColorVertex), lockFlags, d3dMesh.NumberVertices));
case MeshRenderType.DIFFUSE_MAP:
return((TgcSceneLoader.DiffuseMapVertex[])d3dMesh.LockVertexBuffer(
typeof(TgcSceneLoader.DiffuseMapVertex), lockFlags, d3dMesh.NumberVertices));
case MeshRenderType.DIFFUSE_MAP_AND_LIGHTMAP:
return((TgcSceneLoader.DiffuseMapAndLightmapVertex[])d3dMesh.LockVertexBuffer(
typeof(TgcSceneLoader.DiffuseMapAndLightmapVertex), lockFlags, d3dMesh.NumberVertices));
}
return(null);
}
public void SetPartData(int level, LockFlags flags, IntPtr data, int x, int y, int width, int height)
{
D3DRect partRect;
partRect.Left = x; partRect.Top = y;
partRect.Right = x + width; partRect.Bottom = y + height;
LockedRectangle rect = LockRectangle(level, partRect, flags);
// We need to copy scanline by scanline, as generally rect.stride != data.stride
byte *src = (byte *)data, dst = (byte *)rect.DataPointer;
for (int yy = 0; yy < height; yy++)
{
MemUtils.memcpy((IntPtr)src, (IntPtr)dst, width * 4);
src += width * 4;
dst += rect.Pitch;
}
UnlockRectangle(level);
}
/// <summary>
/// Writes data to the buffer.
/// </summary>
/// <returns />
public void Read <T>(T[] data, int bufferOffset, LockFlags flags) where T : struct
{
this.Read <T>(data, 0, 0, bufferOffset, flags);
}
public DataRectangle LockRectangle(int level, Rectangle rectangle, LockFlags flags, out DataStream stream)
{
return _texture.LockRectangle(level, rectangle, flags, out stream);
}
/// <summary>
/// Locks a box on a volume resource.
/// </summary>
/// <param name="flags">The lock flags.</param>
/// <returns>The locked region of this resource.</returns>
public DataBox LockBox(LockFlags flags)
{
LockBox(out LockedBox lockedBox, IntPtr.Zero, flags);
return(new DataBox(lockedBox.PBits, lockedBox.RowPitch, lockedBox.SlicePitch));
}
public unsafe Array LockVertexBuffer(Type typeVertex, LockFlags flags, params int[] ranks)
{
throw new NotImplementedException();
}
internal static extern int /* HRESULT */ Lock(
System.Windows.Media.SafeMILHandle /* IWICBitmap */ THIS_PTR,
ref Int32Rect prcLock,
LockFlags flags,
out SafeMILHandle /* IWICBitmapLock* */ ppILock);
/// <summary>
/// Locks a box on a volume resource.
/// </summary>
/// <param name="box">The box.</param>
/// <param name="flags">The flags.</param>
/// <returns>The locked region of this resource</returns>
/// <unmanaged>HRESULT IDirect3DVolume9::LockBox([Out] D3DLOCKED_BOX* pLockedVolume,[In] const void* pBox,[In] D3DLOCK Flags)</unmanaged>
public DataBox LockBox(Box box, LockFlags flags)
{
unsafe
{
LockedBox lockedBox;
LockBox(out lockedBox, new IntPtr(&box), flags);
return new DataBox(lockedBox.PBits, lockedBox.RowPitch, lockedBox.SlicePitch);
}
}
public void LockVector(int locker, LockFlags flags, LockRequest[] list) {
DbRetVal ret;
int failedIndx;
// allocate the arguments we need to pass
DBT* objs = stackalloc DBT[list.Length];
DB_LOCKREQ* lockReqs = stackalloc DB_LOCKREQ[list.Length];
// calculate object buffer size and allocate on stack
int objSize = 0;
for (int indx = 0; indx < list.Length; indx++)
objSize += list[indx].Obj.Size;
byte* objBuf = stackalloc byte[objSize];
// configure all DB_LOCKREQ instances
DBT* currObjp = objs;
byte* currObjBuf = objBuf;
for (int indx = 0; indx < list.Length; indx++) {
lockReqs[indx] = list[indx].PrepareLockReq(currObjp, ref currObjBuf);
currObjp++;
}
// perform call into BDB
lock (rscLock) {
DB_ENV* evp = CheckDisposed();
DB_LOCKREQ* lastp;
ret = evp->LockVector(evp, unchecked((uint)locker), unchecked((UInt32)flags),
lockReqs, list.Length, out lastp);
if (ret != DbRetVal.SUCCESS)
failedIndx = (int)(lastp - lockReqs);
else
failedIndx = list.Length;
}
// assign the acquired locks back to the initial LockRequest instances
for (int indx = 0; indx < failedIndx; indx++) {
LockOperation op = list[indx].Op;
if (op == LockOperation.Acquire || op == LockOperation.AcquireTimeout)
list[indx].lck = new Lock(lockReqs[indx].dblock);
}
if (ret != DbRetVal.SUCCESS)
ThrowLockException(ret, failedIndx);
}
public unsafe virtual LockData Lock(LockFlags flags)
{
Texture texture = this.CoreGetSurface();
if (texture == null)
{
return new LockData();
}
LockFlags flags2 = 0x800;
if (flags == LockFlags.ReadOnly)
{
flags2 |= 0x10;
}
int num = 0;
GraphicsStream stream = texture.LockRectangle(0, flags2, ref num);
LockData data = new LockData {
Pitch = num,
pvSrc = (void*) stream.get_InternalData(),
Height = this.Height,
Width = this.Width
};
this.m_LockStream = stream;
return data;
}
public Array LockRectangle(Type typeLock, LockFlags flags, params int[] ranks)
{
throw new NotImplementedException();
}
public GraphicsStream LockRectangle(LockFlags flags)
{
throw new NotImplementedException();
}
/// <summary>
/// Acceder al VertexBuffer del mesh.
/// Una vez que se termina de trabajar con el buffer se debe invocar siempre a unlock.
/// </summary>
/// <param name="lockFlags">Flags de lectura del buffer</param>
/// <returns>array de elementos</returns>
public Array lockVertexBuffer(LockFlags lockFlags)
{
switch (renderType)
{
case MeshRenderType.VERTEX_COLOR:
return (TgcSceneLoader.VertexColorVertex[])d3dMesh.LockVertexBuffer(
typeof(TgcSceneLoader.VertexColorVertex), lockFlags, d3dMesh.NumberVertices);
case MeshRenderType.DIFFUSE_MAP:
return (TgcSceneLoader.DiffuseMapVertex[])d3dMesh.LockVertexBuffer(
typeof(TgcSceneLoader.DiffuseMapVertex), lockFlags, d3dMesh.NumberVertices);
case MeshRenderType.DIFFUSE_MAP_AND_LIGHTMAP:
return (TgcSceneLoader.DiffuseMapAndLightmapVertex[])d3dMesh.LockVertexBuffer(
typeof(TgcSceneLoader.DiffuseMapAndLightmapVertex), lockFlags, d3dMesh.NumberVertices);
}
return null;
}
public Array LockIndexBuffer(Type typeIndex, LockFlags flags, params int[] ranks)
{
throw new NotImplementedException();
}
/// <summary>
/// Locks the specified index buffer.
/// </summary>
/// <param name="offsetToLock">The offset in the buffer.</param>
/// <param name="sizeToLock">The size of the buffer to lock.</param>
/// <param name="lockFlags">The lock flags.</param>
/// <returns>A <see cref="SharpDX.DataStream" /> containing the locked index buffer.</returns>
/// <msdn-id>bb205867</msdn-id>
/// <unmanaged>HRESULT IDirect3DIndexBuffer9::Lock([In] unsigned int OffsetToLock,[In] unsigned int SizeToLock,[Out] void** ppbData,[In] D3DLOCK Flags)</unmanaged>
/// <unmanaged-short>IDirect3DIndexBuffer9::Lock</unmanaged-short>
public IntPtr LockToPointer(int offsetToLock, int sizeToLock, LockFlags lockFlags)
{
IntPtr pOut;
if (sizeToLock == 0)
sizeToLock = Description.Size;
Lock(offsetToLock, sizeToLock, out pOut, lockFlags);
return pOut;
}
public DataRectangle LockRectangle(int level, Rectangle rectangle, LockFlags flags)
{
return _texture.LockRectangle(level, rectangle, flags);
}
/// <summary>
/// Locks a box on a volume resource.
/// </summary>
/// <param name="flags">The flags.</param>
/// <returns>
/// The locked region of this resource
/// </returns>
/// <unmanaged>HRESULT IDirect3DVolume9::LockBox([Out] D3DLOCKED_BOX* pLockedVolume,[In] const void* pBox,[In] D3DLOCK Flags)</unmanaged>
public DataBox LockBox(LockFlags flags)
{
LockedBox lockedBox;
LockBox(out lockedBox, IntPtr.Zero, flags);
return new DataBox(lockedBox.PBits, lockedBox.RowPitch, lockedBox.SlicePitch);
}
public GraphicsStream LockVertexBuffer(LockFlags flags)
{
throw new NotImplementedException();
}
public int[] LockAttributeBufferArray(LockFlags flags)
{
throw new NotImplementedException();
}
public void SetIndexBufferData(object data, LockFlags flags)
{
throw new NotImplementedException();
}
public GraphicsStream LockRectangle(Rectangle rect, LockFlags flags, out int pitch)
{
throw new NotImplementedException();
}
public GraphicsStream LockAttributeBuffer(LockFlags flags)
{
throw new NotImplementedException();
}
public Lock AcquireLock(int locker, LockFlags flags, ref DbEntry obj, LockMode mode) {
DbRetVal ret;
Lock lck = new Lock();
lock (rscLock) {
DB_ENV* evp = CheckDisposed();
fixed (byte* objBufP = obj.Buffer) {
obj.dbt.data = objBufP + obj.Start;
ret = evp->LockGet(evp, unchecked((uint)locker), unchecked((uint)flags), ref obj.dbt, (DB_LOCKMODE)mode, ref lck.dblck);
}
}
if (ret != DbRetVal.SUCCESS)
ThrowLockException(ret, -1);
return lck;
}
