protected override PixelBox LockImpl(BasicBox lockBox, BufferLocking options) { //Entering critical section LockDeviceAccess(); // Check for misuse if (((int)usage & (int)TextureUsage.RenderTarget) != 0) { throw new AxiomException( "DirectX does not allow locking of or directly writing to RenderTargets. Use BlitFromMemory if you need the contents."); } // Set locking flags according to options var flags = D3D9Helper.ConvertEnum(options, usage); if (this.mapDeviceToBufferResources.Count == 0) { throw new AxiomException("There are no resources attached to this pixel buffer !!"); } lockedBox = lockBox; this.lockFlags = flags; var bufferResources = this.mapDeviceToBufferResources.First().Value; // Lock the source buffer. var lockedBuf = LockBuffer(bufferResources, lockBox, flags); //Leaving critical section UnlockDeviceAccess(); return(lockedBuf); }
protected override IntPtr LockImpl(int offset, int length, BufferLocking locking) { //Debug.Assert( !handle.IsAllocated, "Internal error, data being pinned twice." ); // return the offset into the array as a pointer return(GetDataPointer(offset)); }
/// <summary> /// Used to lock a vertex buffer in hardware memory in order to make modifications. /// </summary> /// <param name="offset">Starting index in the buffer to lock.</param> /// <param name="length">Nunber of bytes to lock after the offset.</param> /// <param name="locking">Specifies how to lock the buffer.</param> /// <returns>An array of the <code>System.Type</code> associated with this VertexBuffer.</returns> public virtual IntPtr Lock(int offset, int length, BufferLocking locking) { Debug.Assert(!isLocked, "Cannot lock this buffer because it is already locked."); IntPtr data = IntPtr.Zero; if (useShadowBuffer) { if (locking != BufferLocking.ReadOnly) { // we have to assume a read / write lock so we use the shadow buffer // and tag for sync on Unlock() shadowUpdated = true; } data = shadowBuffer.Lock(offset, length, locking); } else { // lock the real deal and flag it as locked data = this.LockImpl(offset, length, locking); isLocked = true; } lockStart = offset; lockSize = length; return(data); }
protected override IntPtr LockImpl(int offset, int length, BufferLocking locking) { isLocked = true; // return the offset into the array as a pointer return(Marshal.UnsafeAddrOfPinnedArrayElement(data, offset)); }
public virtual BufferBase Lock(int offset, int length, BufferLocking locking) { Debug.Assert(!IsLocked, "Cannot lock this buffer because it is already locked."); Debug.Assert(offset >= 0 && (offset + length) <= this.sizeInBytes, "The data area to be locked exceeds the buffer."); BufferBase ret; // = IntPtr.Zero; if (this.useShadowBuffer) { if (locking != BufferLocking.ReadOnly) { // we have to assume a read / write lock so we use the shadow buffer // and tag for sync on Unlock() this.shadowUpdated = true; } ret = this.shadowBuffer.Lock(offset, length, locking); } else { // lock the real deal and flag it as locked ret = LockImpl(offset, length, locking); this.isLocked = true; } this.lockStart = offset; this.lockSize = length; return(ret); }
public static D3D.LockFlags ConvertEnum(BufferLocking locking, BufferUsage usage) { D3D.LockFlags d3dLockFlags = 0; if (locking == BufferLocking.Discard) { // D3D doesn't like discard or no_overwrite on non-dynamic buffers if ((usage & BufferUsage.Dynamic) != 0) { d3dLockFlags |= D3D.LockFlags.Discard; } } else if (locking == BufferLocking.ReadOnly) { // D3D debug runtime doesn't like you locking managed buffers readonly // when they were created with write-only (even though you CAN read // from the software backed version) if ((usage & BufferUsage.WriteOnly) == 0) { d3dLockFlags |= D3D.LockFlags.ReadOnly; } } else if (locking == BufferLocking.NoOverwrite) { // D3D doesn't like discard or no_overwrite on non-dynamic buffers if ((usage & BufferUsage.Dynamic) != 0) { d3dLockFlags |= D3D.LockFlags.NoOverwrite; } } return(d3dLockFlags); }
///<summary> /// Internal implementation of <see cref="HardwareBuffer.Lock"/>. ///</summary> protected override PixelBox LockImpl(BasicBox lockBox, BufferLocking options) { _lockedBox = lockBox; // Set extents and format var rval = new PixelBox(lockBox, Format); var sizeInBytes = PixelUtil.GetMemorySize(lockBox.Width, lockBox.Height, lockBox.Depth, XnaHelper.Convert(surface.Format)); if (_bufferBytes == null || _bufferBytes.Length != sizeInBytes) { _bufferBytes = new byte[sizeInBytes]; #if !SILVERLIGHT if (surface != null) { surface.GetData(mipLevel, XnaHelper.ToRectangle(lockBox), _bufferBytes, 0, _bufferBytes.Length); } else if (cube != null) { cube.GetData(face, mipLevel, XnaHelper.ToRectangle(lockBox), _bufferBytes, 0, _bufferBytes.Length); } else { volume.GetData(mipLevel, lockBox.Left, lockBox.Top, lockBox.Right, lockBox.Bottom, lockBox.Front, lockBox.Back, _bufferBytes, 0, _bufferBytes.Length); } #endif } rval.Data = BufferBase.Wrap(_bufferBytes); return(rval); }
/// <summary> /// /// </summary> /// <param name="offset"></param> /// <param name="length"></param> /// <param name="locking"></param> /// <returns></returns> protected override BufferBase LockImpl(int offset, int length, BufferLocking locking) { _offset = offset; _length = length; _locking = locking; return(BufferBase.Wrap(_bufferBytes).Offset(offset)); }
public override IntPtr Lock(int offset, int length, BufferLocking locking) { //Debug.Assert( !isLocked, "Cannot lock this buffer because it is already locked." ); Debug.Assert(offset >= 0 && (offset + length) <= sizeInBytes, "The data area to be locked exceeds the buffer."); isLocked = true; return(LockImpl(offset, length, locking)); }
protected override IntPtr LockImpl(int offset, int length, BufferLocking locking) { isLocked = true; // return the offset into the array as a pointer // return Marshal.UnsafeAddrOfPinnedArrayElement(data, offset); handle = GCHandle.Alloc(data, GCHandleType.Pinned); return(handle.AddrOfPinnedObject()); }
protected override BufferBase LockImpl(int offset, int length, BufferLocking options) { Debug.Assert(!IsLocked, "Cannot lock this buffer, it is already locked!"); Debug.Assert(offset == 0 && length == sizeInBytes, "Cannot lock memory region, must lock box or entire buffer"); var myBox = new BasicBox(0, 0, 0, Width, Height, Depth); var rv = Lock(myBox, options); return(rv.Data); }
/// <summary> /// </summary> /// <param name="lockBox"> </param> /// <param name="options"> </param> /// <returns> </returns> protected override PixelBox LockImpl(BasicBox lockBox, BufferLocking options) { AllocateBuffer(); if (options != BufferLocking.Discard && (Usage & BufferUsage.WriteOnly) == 0) { // Download the old contents of the texture Download(this._buffer); } this._currentLocking = options; return(this._buffer.GetSubVolume(lockBox)); }
protected override Media.PixelBox LockImpl(Media.BasicBox lockBox, BufferLocking options) { this.AllocateBuffer(); if (options != BufferLocking.Discard && (usage & BufferUsage.WriteOnly) == 0) { //Downoad the old contents of the texture this.Download(this.Buffer); } this.CurrentLockOptions = options; lockedBox = lockBox; return(this.Buffer.GetSubVolume(lockBox)); }
/// <summary> /// /// </summary> /// <param name="offset"></param> /// <param name="length"></param> /// <param name="locking"></param> /// <returns></returns> protected override IntPtr LockImpl(int offset, int length, BufferLocking locking) { int access = 0; if (isLocked) { throw new Exception("Invalid attempt to lock an index buffer that has already been locked."); } // bind this buffer Gl.glBindBufferARB(Gl.GL_ELEMENT_ARRAY_BUFFER_ARB, bufferID); if (locking == BufferLocking.Discard) { // commented out to fix ATI issues /*Gl.glBufferDataARB(Gl.GL_ELEMENT_ARRAY_BUFFER_ARB, * sizeInBytes, * IntPtr.Zero, * GLHelper.ConvertEnum(usage)); */ // find out how we shall access this buffer access = (usage == BufferUsage.Dynamic) ? Gl.GL_READ_WRITE_ARB : Gl.GL_WRITE_ONLY_ARB; } else if (locking == BufferLocking.ReadOnly) { if (usage == BufferUsage.WriteOnly) { LogManager.Instance.Write("Invalid attempt to lock a write-only vertex buffer as read-only."); } access = Gl.GL_READ_ONLY_ARB; } else if (locking == BufferLocking.Normal || locking == BufferLocking.NoOverwrite) { access = (usage == BufferUsage.Dynamic) ? Gl.GL_READ_WRITE_ARB : Gl.GL_WRITE_ONLY_ARB; } IntPtr ptr = Gl.glMapBufferARB(Gl.GL_ELEMENT_ARRAY_BUFFER_ARB, access); if (ptr == IntPtr.Zero) { throw new Exception("GL Vertex Buffer: Out of memory"); } isLocked = true; return(new IntPtr(ptr.ToInt32() + offset)); }
public static D3D.LockFlags ConvertEnum(BufferLocking locking, BufferUsage usage) { D3D.LockFlags ret = 0; if (locking == BufferLocking.Discard) { #if !NO_OGRE_D3D_MANAGE_BUFFERS // Only add the discard flag for dynamic usgae and default pool if ((usage & BufferUsage.Dynamic) != 0 && (usage & BufferUsage.Discardable) != 0) { ret |= D3D.LockFlags.Discard; } #else // D3D doesn't like discard or no_overwrite on non-dynamic buffers if ((usage & BufferUsage.Dynamic) != 0) { ret |= D3D.LockFlags.Discard; } #endif } if (locking == BufferLocking.ReadOnly) { // D3D debug runtime doesn't like you locking managed buffers readonly // when they were created with write-only (even though you CAN read // from the software backed version) if ((usage & BufferUsage.WriteOnly) == 0) { ret |= D3D.LockFlags.ReadOnly; } } if (locking == BufferLocking.NoOverwrite) { #if !NO_OGRE_D3D_MANAGE_BUFFERS // Only add the nooverwrite flag for dynamic usgae and default pool if ((usage & BufferUsage.Dynamic) != 0 && (usage & BufferUsage.Discardable) != 0) { ret |= D3D.LockFlags.NoOverwrite; } #else // D3D doesn't like discard or no_overwrite on non-dynamic buffers if ((usage & BufferUsage.Dynamic) != 0) { ret |= D3D.LockFlags.NoOverwrite; } #endif } return(ret); }
protected override BufferBase LockImpl(int offset, int length, BufferLocking options) { //Entering critical section this.LockDeviceAccess(); if (options != BufferLocking.ReadOnly) { foreach (var it in this._mapDeviceToBufferResources) { var bufferResources = it.Value; bufferResources.IsOutOfDate = true; if (bufferResources.LockLength > 0) { var highPoint = Math.Utility.Max(offset + length, bufferResources.LockOffset + bufferResources.LockLength); bufferResources.LockOffset = Math.Utility.Min(bufferResources.LockOffset, offset); bufferResources.LockLength = highPoint - bufferResources.LockOffset; } else { if (offset < bufferResources.LockOffset) { bufferResources.LockOffset = offset; } if (length > bufferResources.LockLength) { bufferResources.LockLength = length; } } if (bufferResources.LockOptions != BufferLocking.Discard) { bufferResources.LockOptions = options; } } } //Leaving critical section this.UnlockDeviceAccess(); return(this._systemMemoryBuffer + offset); }
public static D3D.LockFlags ConvertEnum(BufferLocking locking) { D3D.LockFlags d3dLockFlags = 0; if (locking == BufferLocking.Discard) { d3dLockFlags |= D3D.LockFlags.Discard; } if (locking == BufferLocking.ReadOnly) { d3dLockFlags |= D3D.LockFlags.ReadOnly; } if (locking == BufferLocking.NoOverwrite) { d3dLockFlags |= D3D.LockFlags.NoOverwrite; } return(d3dLockFlags); }
public virtual PixelBox Lock(BasicBox lockBox, BufferLocking options) { if (useShadowBuffer) { if (options != BufferLocking.ReadOnly) { // we have to assume a read / write lock so we use the shadow buffer // and tag for sync on unlock() shadowUpdated = true; } this.currentLock = ((HardwarePixelBuffer)shadowBuffer).Lock(lockBox, options); } else { // Lock the real buffer if there is no shadow buffer this.currentLock = LockImpl(lockBox, options); isLocked = true; } return(this.currentLock); }
///<summary> /// Copies a box from another PixelBuffer to a region of the /// this PixelBuffer. ///</summary> ///<param name="src">Source/dest pixel buffer</param> ///<param name="srcBox">Image.BasicBox describing the source region in this buffer</param> ///<param name="dstBox">Image.BasicBox describing the destination region in this buffer</param> ///<remarks> /// The source and destination regions dimensions don't have to match, in which /// case scaling is done. This scaling is generally done using a bilinear filter in hardware, /// but it is faster to pass the source image in the right dimensions. /// Only call this function when both buffers are unlocked. ///</remarks> public virtual void Blit(HardwarePixelBuffer src, BasicBox srcBox, BasicBox dstBox) { if (IsLocked || src.IsLocked) { throw new Exception("Source and destination buffer may not be locked! In HardwarePixelBuffer.Blit"); } if (src == this) { throw new Exception("Source must not be the same object, in HardwarePixelBuffer.Blit"); } PixelBox srclock = src.Lock(srcBox, BufferLocking.ReadOnly); BufferLocking method = BufferLocking.Normal; if (dstBox.Left == 0 && dstBox.Top == 0 && dstBox.Front == 0 && dstBox.Right == width && dstBox.Bottom == height && dstBox.Back == depth) { // Entire buffer -- we can discard the previous contents method = BufferLocking.Discard; } PixelBox dstlock = Lock(dstBox, method); if (dstlock.Width != srclock.Width || dstlock.Height != srclock.Height || dstlock.Depth != srclock.Depth) { // Scaling desired throw new Exception("Image scaling not yet implemented; in HardwarePixelBuffer.Blit"); } // Image.Scale(srclock, dstlock); else { // No scaling needed PixelUtil.BulkPixelConversion(srclock, dstlock); } Unlock(); src.Unlock(); }
/// <summary> /// Updates the real buffer from the shadow buffer, if required. /// </summary> protected void UpdateFromShadow() { if (useShadowBuffer && shadowUpdated && !suppressHardwareUpdate) { // do this manually to avoid locking problems IntPtr src = shadowBuffer.LockImpl(lockStart, lockSize, BufferLocking.ReadOnly); // Lock with discard if the whole buffer was locked, otherwise normal BufferLocking locking = (lockStart == 0 && lockSize == sizeInBytes) ? BufferLocking.Discard : BufferLocking.Normal; IntPtr dest = this.LockImpl(lockStart, lockSize, locking); // copy the data in directly Memory.Copy(src, dest, lockSize); // unlock both buffers to commit the write this.UnlockImpl(); shadowBuffer.UnlockImpl(); shadowUpdated = false; } }
protected abstract PixelBox LockImpl(BasicBox lockBox, BufferLocking options);
/// <summary> /// /// </summary> /// <param name="offset"></param> /// <param name="length"></param> /// <param name="locking"></param> /// <returns></returns> protected override IntPtr LockImpl(int offset, int length, BufferLocking locking) { D3D.LockFlags d3dLocking = D3DHelper.ConvertEnum(locking, usage); Microsoft.DirectX.GraphicsStream s = d3dBuffer.Lock(offset, length, d3dLocking); return s.InternalData; }
/// <summary> /// </summary> /// <param name="offset"> </param> /// <param name="length"> </param> /// <param name="locking"> </param> /// <returns> </returns> protected override BufferBase LockImpl( int offset, int length, BufferLocking locking ) { return this._dataPtr + offset; }
public override IntPtr Lock( int offset, int length, BufferLocking locking ) { Debug.Assert( !isLocked ); isLocked = true; var ret = Memory.PinObject( _mpData ); unsafe { var v = (byte*)ret.ToPointer(); v += offset; ret = new IntPtr(v); } return ret; }
protected override IntPtr LockImpl(int offset, int length, BufferLocking locking) { isLocked = true; // return the offset into the array as a pointer return Marshal.UnsafeAddrOfPinnedArrayElement(data, offset); }
///<summary> /// Internal implementation of <see cref="HardwareBuffer.Lock"/>. ///</summary> protected override PixelBox LockImpl( BasicBox lockBox, BufferLocking options ) { _lockedBox = lockBox; // Set extents and format var rval = new PixelBox( lockBox, Format ); var sizeInBytes = PixelUtil.GetMemorySize( lockBox.Width, lockBox.Height, lockBox.Depth, XnaHelper.Convert( surface.Format ) ); if ( _bufferBytes == null || _bufferBytes.Length != sizeInBytes ) { _bufferBytes = new byte[sizeInBytes]; #if !SILVERLIGHT if ( surface != null ) surface.GetData( mipLevel, XnaHelper.ToRectangle( lockBox ), _bufferBytes, 0, _bufferBytes.Length ); else if ( cube != null ) cube.GetData( face, mipLevel, XnaHelper.ToRectangle( lockBox ), _bufferBytes, 0, _bufferBytes.Length ); else volume.GetData( mipLevel, lockBox.Left, lockBox.Top, lockBox.Right, lockBox.Bottom, lockBox.Front, lockBox.Back, _bufferBytes, 0, _bufferBytes.Length ); #endif } rval.Data = BufferBase.Wrap( _bufferBytes ); return rval; }
protected override BufferBase LockImpl( int offset, int length, BufferLocking options ) { Debug.Assert( !IsLocked, "Cannot lock this buffer, it is already locked!" ); Debug.Assert( offset == 0 && length == sizeInBytes, "Cannot lock memory region, must lock box or entire buffer" ); var myBox = new BasicBox( 0, 0, 0, Width, Height, Depth ); var rv = Lock( myBox, options ); return rv.Data; }
/// <summary> /// Internal implementation of Lock, which will be overridden by subclasses to provide /// the core locking functionality. /// </summary> /// <param name="offset">Offset into the buffer (in bytes) to lock.</param> /// <param name="length">Length of the portion of the buffer (int bytes) to lock.</param> /// <param name="locking">Locking type.</param> /// <returns>IntPtr to the beginning of the locked portion of the buffer.</returns> protected abstract IntPtr LockImpl(int offset, int length, BufferLocking locking);
protected override BufferBase LockImpl( int offset, int length, BufferLocking locking ) { if ( IsLocked ) { throw new AxiomException( "Invalid attempt to lock an index buffer that has already been locked." ); } BufferBase retPtr; var glBufManager = ( HardwareBufferManager.Instance as GLESHardwareBufferManager ); //Try to use scratch buffers for smaller buffers if ( length < glBufManager.MapBufferThreshold ) { retPtr = glBufManager.AllocateScratch( length ); if ( retPtr != null ) { this._lockedToScratch = true; this._scratchOffset = offset; this._scratchSize = length; this._scratchPtr = retPtr; this._scratchUploadOnUnlock = ( locking != BufferLocking.ReadOnly ); if ( locking != BufferLocking.Discard ) { //have to read back the data before returning the pointer this.ReadData( offset, length, retPtr ); } } } else { throw new AxiomException( "Invalid Buffer lockSize" ); } if ( retPtr == null ) { GLenum access = GLenum.Zero; ( Root.Instance.RenderSystem as GLESRenderSystem ).BindGLBuffer( GLenum.ArrayBuffer, this._bufferID ); if ( locking == BufferLocking.Discard ) { //Discard the buffer GL.BufferData( GLenum.ArrayBuffer, new IntPtr( sizeInBytes ), IntPtr.Zero, GLESHardwareBufferManager.GetGLUsage( usage ) ); GLESConfig.GlCheckError( this ); } if ( ( usage & BufferUsage.WriteOnly ) == BufferUsage.WriteOnly ) { access = GLenum.WriteOnlyOes; } var pbuffer = GL.Oes.MapBuffer( GLenum.ArrayBuffer, access ); GLESConfig.GlCheckError( this ); if ( pbuffer == IntPtr.Zero ) { throw new AxiomException( "Vertex Buffer: Out of memory" ); } //return offsetted retPtr = BufferBase.Wrap( pbuffer, sizeInBytes ) + offset; this._lockedToScratch = false; } isLocked = true; return retPtr; }
/// <summary> /// Used to lock a vertex buffer in hardware memory in order to make modifications. /// </summary> /// <param name="offset">Starting index in the buffer to lock.</param> /// <param name="length">Nunber of bytes to lock after the offset.</param> /// <param name="locking">Specifies how to lock the buffer.</param> /// <returns>An array of the <code>System.Type</code> associated with this VertexBuffer.</returns> public virtual IntPtr Lock(int offset, int length, BufferLocking locking) { Debug.Assert(!isLocked, "Cannot lock this buffer because it is already locked."); IntPtr data = IntPtr.Zero; if(useShadowBuffer) { if(locking != BufferLocking.ReadOnly) { // we have to assume a read / write lock so we use the shadow buffer // and tag for sync on Unlock() shadowUpdated = true; } data = shadowBuffer.Lock(offset, length, locking); } else { // lock the real deal and flag it as locked data = this.LockImpl(offset, length, locking); isLocked = true; } lockStart = offset; lockSize = length; return data; }
public BufferStream LockStream(BufferLocking locking) { return new BufferStream(this, Lock(locking)); }
/// <summary> /// Convenient overload to allow locking the entire buffer with only having /// to supply the locking type. /// </summary> /// <param name="locking">Locking options.</param> /// <returns>IntPtr to the beginning of the locked region of buffer memory.</returns> public IntPtr Lock(BufferLocking locking) { return Lock(0, sizeInBytes, locking); }
protected override BufferBase LockImpl(int offset, int length, BufferLocking locking) { Debug.Assert(!isLocked); base.isLocked = true; return(Memory.PinObject(_mpData).Offset(offset)); }
/// <summary> /// </summary> /// <param name="offset"> </param> /// <param name="length"> </param> /// <param name="locking"> </param> /// <returns> </returns> protected override BufferBase LockImpl( int offset, int length, BufferLocking locking ) { All access = 0; if ( isLocked ) { throw new AxiomException( "Invalid attempt to lock an index buffer that has already been locked" ); } BufferBase retPtr = null; if ( length < MapBufferThreshold ) { retPtr = ( (GLESHardwareBufferManager) HardwareBufferManager.Instance ).AllocateScratch( length ); if ( retPtr != null ) { this._lockedToScratch = true; this._scratchOffset = offset; this._scratchSize = length; this._scratchPtr = retPtr; this._scratchUploadOnUnlock = ( locking != BufferLocking.ReadOnly ); if ( locking != BufferLocking.Discard ) { this.ReadData( offset, length, retPtr ); } } } else { throw new AxiomException( "Invalid Buffer lockSize" ); } if ( retPtr == null ) { OpenGL.BindBuffer( All.ElementArrayBuffer, this._bufferId ); GLESConfig.GlCheckError( this ); // Use glMapBuffer if ( locking == BufferLocking.Discard ) { OpenGL.BufferData( All.ElementArrayBuffer, new IntPtr( sizeInBytes ), IntPtr.Zero, GLESHardwareBufferManager.GetGLUsage( usage ) ); GLESConfig.GlCheckError( this ); } if ( ( usage & BufferUsage.WriteOnly ) != 0 ) { access = All.WriteOnlyOes; } IntPtr pBuffer = OpenGLOES.MapBuffer( All.ElementArrayBuffer, access ); GLESConfig.GlCheckError( this ); if ( pBuffer == IntPtr.Zero ) { throw new AxiomException( "Index Buffer: Out of memory" ); } unsafe { // return offset retPtr = BufferBase.Wrap( pBuffer, sizeInBytes ); } this._lockedToScratch = false; } isLocked = true; return retPtr; }
protected override IntPtr LockImpl(int offset, int length, BufferLocking locking) { return(GetDataPointer(offset)); }
///<summary> /// Internal implementation of <see cref="HardwareBuffer.Lock"/>. ///</summary> unsafe protected override PixelBox LockImpl( BasicBox lockBox, BufferLocking options ) { _lockedBox = lockBox; // Set extents and format PixelBox rval = new PixelBox( lockBox, Format ); int sizeInBytes = PixelUtil.GetMemorySize( lockBox.Width, lockBox.Height, lockBox.Depth, XnaHelper.Convert( surface.Format ) ); _bufferBytes = new byte[ sizeInBytes ]; surface.GetData( mipLevel, XnaHelper.ToRectangle( lockBox ), _bufferBytes, 0, _bufferBytes.Length ); fixed ( byte* bytes = &_bufferBytes[ 0 ] ) { rval.Data = new IntPtr( bytes ); } return rval; }
protected override BufferBase LockImpl( int offset, int length, BufferLocking options ) { //Entering critical section this.LockDeviceAccess(); if ( options != BufferLocking.ReadOnly ) { foreach ( var it in this._mapDeviceToBufferResources ) { var bufferResources = it.Value; bufferResources.IsOutOfDate = true; if ( bufferResources.LockLength > 0 ) { var highPoint = Math.Utility.Max( offset + length, bufferResources.LockOffset + bufferResources.LockLength ); bufferResources.LockOffset = Math.Utility.Min( bufferResources.LockOffset, offset ); bufferResources.LockLength = highPoint - bufferResources.LockOffset; } else { if ( offset < bufferResources.LockOffset ) { bufferResources.LockOffset = offset; } if ( length > bufferResources.LockLength ) { bufferResources.LockLength = length; } } if ( bufferResources.LockOptions != BufferLocking.Discard ) { bufferResources.LockOptions = options; } } } //Leaving critical section this.UnlockDeviceAccess(); return this._systemMemoryBuffer + offset; }
///<summary> /// Internal implementation of lock(), must be overridden in subclasses ///</summary> public abstract PixelBox LockImpl(BasicBox lockBox, BufferLocking options);
protected abstract PixelBox LockImpl( BasicBox lockBox, BufferLocking options );
public static D3D.LockFlags ConvertEnum( BufferLocking locking, BufferUsage usage ) { D3D.LockFlags ret = 0; if ( locking == BufferLocking.Discard ) { #if !NO_AXIOM_D3D_MANAGE_BUFFERS // Only add the discard flag for dynamic usgae and default pool if ( ( usage & BufferUsage.Dynamic ) != 0 && ( usage & BufferUsage.Discardable ) != 0 ) ret |= D3D.LockFlags.Discard; #else // D3D doesn't like discard or no_overwrite on non-dynamic buffers if ((usage & BufferUsage.Dynamic) != 0) ret |= D3D.LockFlags.Discard; #endif } if ( locking == BufferLocking.ReadOnly ) { // D3D debug runtime doesn't like you locking managed buffers readonly // when they were created with write-only (even though you CAN read // from the software backed version) if ( ( usage & BufferUsage.WriteOnly ) == 0 ) ret |= D3D.LockFlags.ReadOnly; } if ( locking == BufferLocking.NoOverwrite ) { #if !NO_AXIOM_D3D_MANAGE_BUFFERS // Only add the nooverwrite flag for dynamic usgae and default pool if ( ( usage & BufferUsage.Dynamic ) != 0 && ( usage & BufferUsage.Discardable ) != 0 ) ret |= D3D.LockFlags.NoOverwrite; #else // D3D doesn't like discard or no_overwrite on non-dynamic buffers if ((usage & BufferUsage.Dynamic) != 0) ret |= D3D.LockFlags.NoOverwrite; #endif } return ret; }
public virtual PixelBox Lock( BasicBox lockBox, BufferLocking options ) { if ( useShadowBuffer ) { if ( options != BufferLocking.ReadOnly ) { // we have to assume a read / write lock so we use the shadow buffer // and tag for sync on unlock() shadowUpdated = true; } this.currentLock = ( (HardwarePixelBuffer)shadowBuffer ).Lock( lockBox, options ); } else { // Lock the real buffer if there is no shadow buffer this.currentLock = LockImpl( lockBox, options ); isLocked = true; } return this.currentLock; }
/// <summary> /// </summary> /// <param name="offset"> </param> /// <param name="length"> </param> /// <param name="locking"> </param> /// <returns> </returns> protected override BufferBase LockImpl( int offset, int length, BufferLocking locking ) { // Only for use internally, no 'locking' as such return this._dataPtr + offset; }
protected override IntPtr LockImpl( int offset, int length, BufferLocking locking ) { throw new NotImplementedException(); }
protected override BufferBase LockImpl(int offset, int length, BufferLocking locking) { if (IsLocked) { throw new AxiomException("Invalid attempt to lock an index buffer that has already been locked."); } BufferBase retPtr; var glBufManager = (HardwareBufferManager.Instance as GLES2HardwareBufferManager); //Try to use scratch buffers for smaller buffers if (length < glBufManager.MapBufferThreshold) { retPtr = glBufManager.AllocateScratch(length); if (retPtr != null) { this._lockedToScratch = true; this._scratchOffset = offset; this._scratchSize = length; this._scratchPtr = retPtr; this._scratchUploadOnUnlock = (locking != BufferLocking.ReadOnly); if (locking != BufferLocking.Discard) { //have to read back the data before returning the pointer this.ReadData(offset, length, retPtr); } } } else { throw new AxiomException("Invalid Buffer lockSize"); } if (retPtr == null) { GLenum access = GLenum.Zero; (Root.Instance.RenderSystem as GLES2RenderSystem).BindGLBuffer(GLenum.ArrayBuffer, this._bufferID); if (locking == BufferLocking.Discard) { //Discard the buffer GL.BufferData(GLenum.ArrayBuffer, new IntPtr(sizeInBytes), IntPtr.Zero, GLES2HardwareBufferManager.GetGLUsage(usage)); GLES2Config.GlCheckError(this); } if ((usage & BufferUsage.WriteOnly) == BufferUsage.WriteOnly) { access = GLenum.WriteOnlyOes; } var pbuffer = GL.Oes.MapBuffer(GLenum.ArrayBuffer, access); GLES2Config.GlCheckError(this); if (pbuffer == IntPtr.Zero) { throw new AxiomException("Vertex Buffer: Out of memory"); } //return offsetted retPtr = BufferBase.Wrap(pbuffer, sizeInBytes) + offset; this._lockedToScratch = false; } isLocked = true; return(retPtr); }
protected override IntPtr LockImpl(int offset, int length, BufferLocking locking) { isLocked = true; // return the offset into the array as a pointer // return Marshal.UnsafeAddrOfPinnedArrayElement(data, offset); handle = GCHandle.Alloc(data, GCHandleType.Pinned); return handle.AddrOfPinnedObject(); }
/// <summary> /// /// </summary> /// <param name="offset"></param> /// <param name="length"></param> /// <param name="locking"></param> /// <returns></returns> protected override IntPtr LockImpl( int offset, int length, BufferLocking locking ) { int access = 0; if ( isLocked ) { throw new Exception( "Invalid attempt to lock an index buffer that has already been locked." ); } // bind this buffer Gl.glBindBufferARB( Gl.GL_ELEMENT_ARRAY_BUFFER_ARB, bufferID ); if ( locking == BufferLocking.Discard ) { // commented out to fix ATI issues /*Gl.glBufferDataARB(Gl.GL_ELEMENT_ARRAY_BUFFER_ARB, sizeInBytes, IntPtr.Zero, GLHelper.ConvertEnum(usage)); */ // find out how we shall access this buffer access = ( usage == BufferUsage.Dynamic ) ? Gl.GL_READ_WRITE_ARB : Gl.GL_WRITE_ONLY_ARB; } else if ( locking == BufferLocking.ReadOnly ) { if ( usage == BufferUsage.WriteOnly ) { LogManager.Instance.Write( "Invalid attempt to lock a write-only vertex buffer as read-only." ); } access = Gl.GL_READ_ONLY_ARB; } else if ( locking == BufferLocking.Normal || locking == BufferLocking.NoOverwrite ) { access = ( usage == BufferUsage.Dynamic ) ? Gl.GL_READ_WRITE_ARB : Gl.GL_WRITE_ONLY_ARB; } IntPtr ptr = Gl.glMapBufferARB( Gl.GL_ELEMENT_ARRAY_BUFFER_ARB, access ); if ( ptr == IntPtr.Zero ) { throw new Exception( "GL Vertex Buffer: Out of memory" ); } isLocked = true; return new IntPtr( ptr.ToInt64() + offset ); }
/// <summary> /// /// </summary> /// <param name="offset"></param> /// <param name="length"></param> /// <param name="locking"></param> /// <returns></returns> protected override IntPtr LockImpl( int offset, int length, BufferLocking locking ) { _offset = offset; _length = length; fixed ( byte* bytes = &_bufferBytes[ offset ] ) { return new IntPtr( bytes ); } }
/// <summary> /// /// </summary> /// <param name="offset"></param> /// <param name="length"></param> /// <param name="locking"></param> /// <returns></returns> protected override BufferBase LockImpl( int offset, int length, BufferLocking locking ) { _offset = offset; _length = length; _locking = locking; return BufferBase.Wrap( _bufferBytes ).Offset( offset ); }
/// <summary> /// </summary> /// <param name="offset"> </param> /// <param name="length"> </param> /// <param name="locking"> </param> /// <returns> </returns> public override BufferBase Lock( int offset, int length, BufferLocking locking ) { isLocked = true; return this._dataPtr + offset; }
/// <summary> /// </summary> /// <param name="offset"> </param> /// <param name="length"> </param> /// <param name="locking"> </param> /// <returns> </returns> protected override BufferBase LockImpl(int offset, int length, BufferLocking locking) { return(this._dataPtr + offset); }
/// <summary> /// </summary> /// <param name="offset"> </param> /// <param name="length"> </param> /// <param name="locking"> </param> /// <returns> </returns> protected override BufferBase LockImpl(int offset, int length, BufferLocking locking) { // Only for use internally, no 'locking' as such return(this._dataPtr + offset); }
///<summary> /// @copydoc HardwareBuffer.Lock ///</summary> //public virtual IntPtr Lock(int offset, int length, BasicBox lockBox, BufferLocking options) { // Debug.Assert(!IsLocked, "Cannot lock this buffer, it is already locked!"); // Debug.Assert(offset == 0 && length == sizeInBytes, "Cannot lock memory region, must lock box or entire buffer"); // BasicBox myBox = new BasicBox(0, 0, 0, width, height, depth); // PixelBox rv = Lock(myBox, options); // return rv.Data; //} ///<summary> /// Internal implementation of lock(), do not override or call this /// for HardwarePixelBuffer implementations, but override the previous method ///</summary> protected override IntPtr LockImpl(int offset, int length, BufferLocking options) { throw new NotImplementedException("HardwarePixelBuffer does not support this variant of LockImpl"); }
/// <summary> /// /// </summary> /// <param name="lockBox"></param> /// <param name="options"></param> /// <returns></returns> protected override PixelBox LockImpl( BasicBox lockBox, BufferLocking options ) { AllocateBuffer(); if ( options != BufferLocking.Discard && ( Usage & BufferUsage.WriteOnly ) == 0 ) { // Download the old contents of the texture Download( _buffer ); } _currentLocking = options; return _buffer.GetSubVolume( lockBox ); }
/// <summary> /// </summary> /// <param name="offset"> </param> /// <param name="length"> </param> /// <param name="locking"> </param> /// <returns> </returns> public override BufferBase Lock(int offset, int length, BufferLocking locking) { isLocked = true; return(this._dataPtr + offset); }
protected override PixelBox LockImpl( BasicBox lockBox, BufferLocking options ) { //Entering critical section LockDeviceAccess(); // Check for misuse if ( ( (int)usage & (int)TextureUsage.RenderTarget ) != 0 ) { throw new AxiomException( "DirectX does not allow locking of or directly writing to RenderTargets. Use BlitFromMemory if you need the contents." ); } // Set locking flags according to options var flags = D3D9Helper.ConvertEnum( options, usage ); if ( this.mapDeviceToBufferResources.Count == 0 ) { throw new AxiomException( "There are no resources attached to this pixel buffer !!" ); } lockedBox = lockBox; this.lockFlags = flags; var bufferResources = this.mapDeviceToBufferResources.First().Value; // Lock the source buffer. var lockedBuf = LockBuffer( bufferResources, lockBox, flags ); //Leaving critical section UnlockDeviceAccess(); return lockedBuf; }
///<summary> /// Lock a box ///</summary> protected override PixelBox LockImpl( BasicBox lockBox, BufferLocking options ) { // Check for misuse if ( ( (int)usage & (int)TextureUsage.RenderTarget ) != 0 ) throw new Exception( "DirectX does not allow locking of or directly writing to RenderTargets. Use BlitFromMemory if you need the contents." ); // Set extents and format PixelBox rval = new PixelBox( lockBox, Format ); // Set locking flags according to options D3D.LockFlags flags = D3D.LockFlags.None; switch ( options ) { case BufferLocking.Discard: // D3D only likes D3D.LockFlags.Discard if you created the texture with D3DUSAGE_DYNAMIC // debug runtime flags this up, could cause problems on some drivers if ( ( usage & BufferUsage.Dynamic ) != 0 ) flags |= D3D.LockFlags.Discard; break; case BufferLocking.ReadOnly: flags |= D3D.LockFlags.ReadOnly; break; default: break; } if ( surface != null ) { // Surface DX.DataRectangle data = null; try { if ( lockBox.Left == 0 && lockBox.Top == 0 && lockBox.Right == Width && lockBox.Bottom == Height ) { // Lock whole surface data = surface.LockRectangle( flags ); } else { System.Drawing.Rectangle prect = ToD3DRectangle( lockBox ); // specify range to lock data = surface.LockRectangle( prect, flags ); } } catch ( Exception e ) { throw new Exception( "Surface locking failed.", e ); } FromD3DLock( rval, data ); } else { // Volume D3D.Box pbox = ToD3DBox( lockBox ); // specify range to lock DX.DataBox data = volume.LockBox( pbox, flags ); FromD3DLock( rval, data ); } return rval; }
protected override BufferBase LockImpl( int offset, int length, BufferLocking locking ) { Debug.Assert( !isLocked ); base.isLocked = true; return Memory.PinObject( _mpData ).Offset( offset ); }
/// <summary> /// </summary> /// <param name="offset"> </param> /// <param name="length"> </param> /// <param name="locking"> </param> /// <returns> </returns> protected override BufferBase LockImpl(int offset, int length, BufferLocking locking) { All access = 0; if (isLocked) { throw new AxiomException("Invalid attempt to lock an index buffer that has already been locked"); } BufferBase retPtr = null; if (length < MapBufferThreshold) { retPtr = ((GLESHardwareBufferManager)HardwareBufferManager.Instance).AllocateScratch(length); if (retPtr != null) { this._lockedToScratch = true; this._scratchOffset = offset; this._scratchSize = length; this._scratchPtr = retPtr; this._scratchUploadOnUnlock = (locking != BufferLocking.ReadOnly); if (locking != BufferLocking.Discard) { this.ReadData(offset, length, retPtr); } } } else { throw new AxiomException("Invalid Buffer lockSize"); } if (retPtr == null) { OpenGL.BindBuffer(All.ElementArrayBuffer, this._bufferId); GLESConfig.GlCheckError(this); // Use glMapBuffer if (locking == BufferLocking.Discard) { OpenGL.BufferData(All.ElementArrayBuffer, new IntPtr(sizeInBytes), IntPtr.Zero, GLESHardwareBufferManager.GetGLUsage(usage)); GLESConfig.GlCheckError(this); } if ((usage & BufferUsage.WriteOnly) != 0) { access = All.WriteOnlyOes; } IntPtr pBuffer = OpenGLOES.MapBuffer(All.ElementArrayBuffer, access); GLESConfig.GlCheckError(this); if (pBuffer == IntPtr.Zero) { throw new AxiomException("Index Buffer: Out of memory"); } unsafe { // return offset retPtr = BufferBase.Wrap(pBuffer, sizeInBytes); } this._lockedToScratch = false; } isLocked = true; return(retPtr); }