d3d11 copy pass implementation + filling in more APIs

src/Refresh_Driver_D3D11.c

@@ -437,7 +437,8 @@ typedef struct D3D11Buffer
 
 typedef struct D3D11TransferBuffer
 {
-	D3D11Buffer buffer;
+	uint8_t *data;
+	uint32_t size;
 	SDL_atomic_t referenceCount;
 } D3D11TransferBuffer;
 
@@ -1850,10 +1851,8 @@ static D3D11TransferBuffer* D3D11_INTERNAL_CreateTransferBuffer(
 	ERROR_CHECK_RETURN("Could not create buffer", NULL);
 
 	transferBuffer = (D3D11TransferBuffer*) SDL_malloc(sizeof(D3D11TransferBuffer));
-	transferBuffer->buffer.handle = bufferHandle;
+	transferBuffer->data = (uint8_t*) SDL_malloc(sizeInBytes);
-	transferBuffer->buffer.size = sizeInBytes;
+	transferBuffer->size = sizeInBytes;
-	transferBuffer->buffer.uav = NULL;
-
 	SDL_AtomicSet(&transferBuffer->referenceCount, 0);
 
 	return transferBuffer;
@@ -1896,7 +1895,7 @@ static void D3D11_INTERNAL_DiscardActiveTransferBuffer(
 
 	container->activeBuffer = D3D11_INTERNAL_CreateTransferBuffer(
 		renderer,
-		container->activeBuffer->buffer.size
+		container->activeBuffer->size
 	);
 
 	EXPAND_ARRAY_IF_NEEDED(
@@ -1923,8 +1922,6 @@ static void D3D11_SetTransferData(
 	D3D11Renderer *renderer = (D3D11Renderer*) driverData;
 	D3D11TransferBufferContainer *container = (D3D11TransferBufferContainer*) transferBuffer;
 	D3D11TransferBuffer *buffer = container->activeBuffer;
-	D3D11_MAPPED_SUBRESOURCE mappedSubresource;
-	HRESULT res;
 
 	/* Rotate the transfer buffer if necessary */
 	if (
@@ -1938,38 +1935,11 @@ static void D3D11_SetTransferData(
 		buffer = container->activeBuffer;
 	}
 
-	res = ID3D11DeviceContext_Map(
-		renderer->immediateContext,
-		buffer->buffer.handle,
-		0,
-		D3D11_MAP_WRITE,
-		D3D11_MAP_FLAG_DO_NOT_WAIT,
-		&mappedSubresource
-	);
-	if (FAILED(res))
-	{
-		D3D11_INTERNAL_LogError(
-			renderer->device,
-			"Failed to map transfer buffer for write!",
-			res
-		);
-		return;
-	}
-
-	uint8_t *bufferPointer =
-		(uint8_t*) mappedSubresource.pData + copyParams->dstOffset;
-
 	SDL_memcpy(
-		bufferPointer,
+		(uint8_t*) buffer->data + copyParams->dstOffset,
 		((uint8_t*) data) + copyParams->srcOffset,
 		copyParams->size
 	);
-
-	ID3D11DeviceContext_Unmap(
-		renderer->immediateContext,
-		buffer->buffer.handle,
-		0
-	);
 }
 
 static void D3D11_GetTransferData(
@@ -1981,41 +1951,12 @@ static void D3D11_GetTransferData(
 	D3D11Renderer *renderer = (D3D11Renderer*) driverData;
 	D3D11TransferBufferContainer *container = (D3D11TransferBufferContainer*) transferBuffer;
 	D3D11TransferBuffer *buffer = container->activeBuffer;
-	D3D11_MAPPED_SUBRESOURCE mappedSubresource;
-	HRESULT res;
-
-	res = ID3D11DeviceContext_Map(
-		renderer->immediateContext,
-		buffer->buffer.handle,
-		0,
-		D3D11_MAP_READ,
-		0,
-		&mappedSubresource
-	);
-	if (FAILED(res))
-	{
-		D3D11_INTERNAL_LogError(
-			renderer->device,
-			"Failed to map transfer buffer for read!",
-			res
-		);
-		return;
-	}
-
-	uint8_t *bufferPointer =
-		(uint8_t*) mappedSubresource.pData + copyParams->srcOffset;
 
 	SDL_memcpy(
 		((uint8_t*) data) + copyParams->dstOffset,
-		bufferPointer,
+		(uint8_t*) buffer->data + copyParams->srcOffset,
 		copyParams->size
 	);
-
-	ID3D11DeviceContext_Unmap(
-		renderer->immediateContext,
-		buffer->buffer.handle,
-		0
-	);
 }
 
 /* Copy Pass */
@@ -2040,8 +1981,6 @@ static void D3D11_UploadToTexture(
 	D3D11TransferBufferContainer *container = (D3D11TransferBufferContainer*) transferBuffer;
 	D3D11TransferBuffer *d3d11TransferBuffer = container->activeBuffer;
 	D3D11Texture *d3d11Texture = (D3D11Texture*) textureRegion->textureSlice.texture;
-	D3D11_MAPPED_SUBRESOURCE mappedSubresource;
-	HRESULT res;
 
 	int32_t w = textureRegion->w;
 	int32_t h = textureRegion->h;
@@ -2053,85 +1992,28 @@ static void D3D11_UploadToTexture(
 		h = (h + blockSize - 1) & ~(blockSize - 1);
 	}
 
-	if (
+	D3D11_BOX dstBox;
-		(copyParams->bufferStride == 0 || copyParams->bufferStride == BytesPerRow(w, d3d11Texture->format)) &&
+	dstBox.left = textureRegion->x;
-		(copyParams->bufferImageHeight == 0 || copyParams->bufferImageHeight == h )
+	dstBox.top = textureRegion->y;
-	) {
+	dstBox.front = textureRegion->d;
-		/* Fast path */
+	dstBox.right = textureRegion->x + w;
-		D3D11_BOX srcBox;
+	dstBox.bottom = textureRegion->y + h;
-		srcBox.left = copyParams->bufferOffset;
+	dstBox.back = textureRegion->d + 1;
-		srcBox.top = 0;
-		srcBox.front = 0;
-		srcBox.right = copyParams->bufferOffset + BytesPerImage(w, h, d3d11Texture->format);
-		srcBox.bottom = 1;
-		srcBox.back = 1;
 
-		ID3D11DeviceContext1_CopySubresourceRegion1(
+	ID3D11DeviceContext1_UpdateSubresource1(
-			d3d11CommandBuffer->context,
+		d3d11CommandBuffer->context,
-			d3d11Texture->handle,
+		d3d11Texture->handle,
-			D3D11_INTERNAL_CalcSubresource(
+		D3D11_INTERNAL_CalcSubresource(
-				textureRegion->textureSlice.mipLevel,
+			textureRegion->textureSlice.mipLevel,
-				textureRegion->textureSlice.layer,
+			textureRegion->textureSlice.layer,
-				1
+			1
-			),
+		),
-			textureRegion->x,
+		&dstBox,
-			textureRegion->y,
+		(uint8_t*) d3d11TransferBuffer->data + copyParams->bufferOffset,
-			textureRegion->z,
+		copyParams->bufferStride,
-			d3d11TransferBuffer->buffer.handle,
+		copyParams->bufferStride * copyParams->bufferImageHeight,
-			0,
+		writeOption == REFRESH_WRITEOPTIONS_SAFEDISCARD ? D3D11_COPY_DISCARD : 0
-			&srcBox,
+	);
-			writeOption == REFRESH_WRITEOPTIONS_SAFEDISCARD ? D3D11_COPY_DISCARD : 0
-		);
-	}
-	else
-	{
-		D3D11_BOX dstBox;
-		dstBox.left = textureRegion->x;
-		dstBox.top = textureRegion->y;
-		dstBox.front = textureRegion->d;
-		dstBox.right = textureRegion->x + w;
-		dstBox.bottom = textureRegion->y + h;
-		dstBox.back = textureRegion->d + 1;
-
-		res = ID3D11DeviceContext1_Map(
-			d3d11CommandBuffer->context,
-			d3d11TransferBuffer->buffer.handle,
-			0,
-			D3D11_MAP_READ,
-			D3D11_MAP_FLAG_DO_NOT_WAIT,
-			&mappedSubresource
-		);
-		if (FAILED(res))
-		{
-			D3D11_INTERNAL_LogError(
-				renderer->device,
-				"Failed to map transfer buffer for read!",
-				res
-			);
-			return;
-		}
-
-		ID3D11DeviceContext1_UpdateSubresource1(
-			d3d11CommandBuffer->context,
-			d3d11Texture->handle,
-			D3D11_INTERNAL_CalcSubresource(
-				textureRegion->textureSlice.mipLevel,
-				textureRegion->textureSlice.layer,
-				1
-			),
-			&dstBox,
-			(uint8_t*) mappedSubresource.pData + copyParams->bufferOffset,
-			copyParams->bufferStride,
-			copyParams->bufferStride * copyParams->bufferImageHeight,
-			writeOption == REFRESH_WRITEOPTIONS_SAFEDISCARD ? D3D11_COPY_DISCARD : 0
-		);
-
-		ID3D11DeviceContext1_Unmap(
-			renderer->immediateContext,
-			d3d11TransferBuffer->buffer.handle,
-			0
-		);
-	}
 
 	D3D11_INTERNAL_TrackTransferBuffer(d3d11CommandBuffer, d3d11TransferBuffer);
 }
@@ -2157,7 +2039,7 @@ static void D3D11_UploadToBuffer(
 		copyParams->dstOffset,
 		0,
 		0,
-		d3d11TransferBuffer->buffer.handle,
+		d3d11TransferBuffer->data,
 		0,
 		&srcBox,
 		writeOption == REFRESH_WRITEOPTIONS_SAFEDISCARD ? D3D11_COPY_DISCARD : 0
@@ -2176,7 +2058,94 @@ static void D3D11_DownloadFromTexture(
 ) {
 	D3D11Renderer *renderer = (D3D11Renderer*) driverData;
 	D3D11CommandBuffer *d3d11CommandBuffer = (D3D11CommandBuffer*) commandBuffer;
+	D3D11TransferBufferContainer *container = (D3D11TransferBufferContainer*) transferBuffer;
+	D3D11TransferBuffer *d3d11TransferBuffer = container->activeBuffer;
+	D3D11Texture *d3d11Texture = (D3D11Texture*) textureRegion->textureSlice.texture;
+	D3D11_TEXTURE2D_DESC stagingDesc;
+	ID3D11Resource *stagingTexture;
+	uint32_t subresourceIndex = D3D11_INTERNAL_CalcSubresource(
+		textureRegion->textureSlice.mipLevel,
+		textureRegion->textureSlice.layer,
+		d3d11Texture->levelCount
+	);
+	int32_t formatSize = Texture_GetFormatSize(d3d11Texture->format);
+	D3D11_BOX srcBox = {textureRegion->x, textureRegion->y, textureRegion->z, textureRegion->x + textureRegion->w, textureRegion->y + textureRegion->h, 1};
+	D3D11_MAPPED_SUBRESOURCE subresource;
+	HRESULT res;
 
+	/* Rotate the transfer buffer if necessary */
+	if (
+		transferOption == REFRESH_TRANSFEROPTIONS_SAFEDISCARD &&
+		SDL_AtomicGet(&container->activeBuffer->referenceCount) > 0
+	) {
+		D3D11_INTERNAL_DiscardActiveTransferBuffer(
+			renderer,
+			container
+		);
+		d3d11TransferBuffer = container->activeBuffer;
+	}
+
+	stagingDesc.Width = textureRegion->w;
+	stagingDesc.Height = textureRegion->h;
+	stagingDesc.MipLevels = 1;
+	stagingDesc.ArraySize = 1;
+	stagingDesc.Format = RefreshToD3D11_TextureFormat[d3d11Texture->format];
+	stagingDesc.SampleDesc.Count = 1;
+	stagingDesc.SampleDesc.Quality = 0;
+	stagingDesc.Usage = D3D11_USAGE_STAGING;
+	stagingDesc.BindFlags = 0;
+	stagingDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+	stagingDesc.MiscFlags = 0;
+
+	res = ID3D11Device_CreateTexture2D(
+		renderer->device,
+		&stagingDesc,
+		NULL,
+		(ID3D11Texture2D**) &stagingTexture
+	);
+	ERROR_CHECK_RETURN("Staging texture creation failed",)
+
+	ID3D11DeviceContext1_CopySubresourceRegion1(
+		d3d11CommandBuffer->context,
+		stagingTexture,
+		0,
+		0,
+		0,
+		0,
+		d3d11Texture->handle,
+		subresourceIndex,
+		&srcBox,
+		D3D11_COPY_NO_OVERWRITE
+	);
+
+	/* Read from the staging texture */
+	res = ID3D11DeviceContext1_Map(
+		d3d11CommandBuffer->context,
+		stagingTexture,
+		subresourceIndex,
+		D3D11_MAP_READ,
+		0,
+		&subresource
+	);
+	ERROR_CHECK_RETURN("Could not map texture for reading",)
+
+	uint8_t* dataPtr = (uint8_t*) d3d11TransferBuffer->data + copyParams->bufferOffset;
+	for (int32_t row = textureRegion->y; row < copyParams->bufferImageHeight; row += 1)
+	{
+		SDL_memcpy(
+			dataPtr,
+			(uint8_t*) subresource.pData + (row * copyParams->bufferStride) + (textureRegion->x * formatSize),
+			textureRegion->w * formatSize
+		);
+	}
+
+	ID3D11DeviceContext1_Unmap(
+		d3d11CommandBuffer->context,
+		stagingTexture,
+		0
+	);
+
+	ID3D11Texture2D_Release(stagingTexture);
 }
 
 static void D3D11_DownloadFromBuffer(
@@ -2192,7 +2161,11 @@ static void D3D11_DownloadFromBuffer(
 	D3D11TransferBufferContainer *container = (D3D11TransferBufferContainer*) transferBuffer;
 	D3D11TransferBuffer *d3d11TransferBuffer = container->activeBuffer;
 	D3D11Buffer *d3d11Buffer = (D3D11Buffer*) gpuBuffer;
-	D3D11_BOX srcBox = { copyParams->srcOffset, 0, 0, copyParams->srcOffset + copyParams->size, 1, 1 };
+	D3D11_BOX srcBox = { copyParams->srcOffset, 0, 0, copyParams->size, 1, 1 };
+	ID3D11Resource *stagingBuffer;
+	D3D11_MAPPED_SUBRESOURCE mappedSubresource;
+	D3D11_BUFFER_DESC stagingBufferDesc;
+	HRESULT res;
 
 	/* Rotate the transfer buffer if necessary */
 	if (
@@ -2206,90 +2179,8 @@ static void D3D11_DownloadFromBuffer(
 		d3d11TransferBuffer = container->activeBuffer;
 	}
 
-	ID3D11DeviceContext1_CopySubresourceRegion1(
-		d3d11CommandBuffer->context,
-		d3d11TransferBuffer->buffer.handle,
-		0,
-		copyParams->dstOffset,
-		0,
-		0,
-		d3d11Buffer->handle,
-		0,
-		&srcBox,
-		D3D11_COPY_NO_OVERWRITE
-	);
-
-	D3D11_INTERNAL_TrackTransferBuffer(d3d11CommandBuffer, d3d11TransferBuffer);
-}
-
-static void D3D11_CopyTextureToTexture(
-	Refresh_Renderer *driverData,
-	Refresh_CommandBuffer *commandBuffer,
-	Refresh_TextureSlice *sourceTextureSlice,
-	Refresh_TextureSlice *destinationTextureSlice,
-	Refresh_Filter filter
-) {
-	NOT_IMPLEMENTED
-}
-
-static void D3D11_CopyTextureToBuffer(
-	Refresh_Renderer *driverData,
-	Refresh_CommandBuffer *commandBuffer,
-	Refresh_TextureSlice *textureSlice,
-	Refresh_Buffer *buffer
-) {
-	NOT_IMPLEMENTED
-}
-
-static void D3D11_EndCopyPass(
-	Refresh_Renderer *driverData,
-	Refresh_CommandBuffer *commandBuffer
-) {
-	/* no-op */
-}
-
-/* Buffer Data */
-
-static void D3D11_SetBufferData(
-	Refresh_Renderer *driverData,
-	Refresh_CommandBuffer *commandBuffer,
-	Refresh_Buffer *buffer,
-	uint32_t offsetInBytes,
-	void* data,
-	uint32_t dataLength
-) {
-	D3D11CommandBuffer *d3d11CommandBuffer = (D3D11CommandBuffer*) commandBuffer;
-	D3D11Buffer *d3d11Buffer = (D3D11Buffer*) buffer;
-	D3D11_BOX dstBox = { offsetInBytes, 0, 0, offsetInBytes + dataLength, 1, 1 };
-
-	ID3D11DeviceContext1_UpdateSubresource1(
-		d3d11CommandBuffer->context,
-		(ID3D11Resource*) d3d11Buffer->handle,
-		0,
-		&dstBox,
-		data,
-		dataLength,
-		1,
-		dataLength == d3d11Buffer->size ? D3D11_COPY_DISCARD : 0
-	);
-}
-
-static void D3D11_GetBufferData(
-	Refresh_Renderer *driverData,
-	Refresh_Buffer *buffer,
-	void* data,
-	uint32_t dataLengthInBytes
-) {
-	D3D11Renderer *renderer = (D3D11Renderer*) driverData;
-	D3D11Buffer *d3d11Buffer = (D3D11Buffer*) buffer;
-	D3D11_BUFFER_DESC stagingBufferDesc;
-	ID3D11Resource *stagingBuffer;
-	D3D11_BOX srcBox = { 0, 0, 0, dataLengthInBytes, 1, 1 };
-	D3D11_MAPPED_SUBRESOURCE mappedSubresource;
-	HRESULT res;
-
 	/* Create staging buffer */
-	stagingBufferDesc.ByteWidth = dataLengthInBytes;
+	stagingBufferDesc.ByteWidth = copyParams->size;
 	stagingBufferDesc.Usage = D3D11_USAGE_STAGING;
 	stagingBufferDesc.BindFlags = 0;
 	stagingBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
@@ -2304,23 +2195,22 @@ static void D3D11_GetBufferData(
 	);
 	ERROR_CHECK_RETURN("Could not create staging buffer for readback", );
 
-	/* Copy data into staging buffer */
+	ID3D11DeviceContext1_CopySubresourceRegion1(
-	SDL_LockMutex(renderer->contextLock);
+		d3d11CommandBuffer->context,
-	ID3D11DeviceContext_CopySubresourceRegion(
-		renderer->immediateContext,
 		stagingBuffer,
 		0,
 		0,
 		0,
 		0,
-		(ID3D11Resource*) d3d11Buffer->handle,
+		d3d11Buffer->handle,
 		0,
-		&srcBox
+		&srcBox,
+		D3D11_COPY_NO_OVERWRITE
 	);
 
 	/* Read from the staging buffer */
-	res = ID3D11DeviceContext_Map(
+	res = ID3D11DeviceContext1_Map(
-		renderer->immediateContext,
+		d3d11CommandBuffer->context,
 		stagingBuffer,
 		0,
 		D3D11_MAP_READ,
@@ -2335,21 +2225,95 @@ static void D3D11_GetBufferData(
 			res
 		);
 		ID3D11Buffer_Release(stagingBuffer);
-		SDL_UnlockMutex(renderer->contextLock);
 		return;
 	}
 
-	SDL_memcpy(data, mappedSubresource.pData, dataLengthInBytes);
+	SDL_memcpy(
+		d3d11TransferBuffer->data + copyParams->dstOffset,
+		mappedSubresource.pData,
+		copyParams->size
+	);
 
-	ID3D11DeviceContext_Unmap(
+	ID3D11DeviceContext1_Unmap(
-		renderer->immediateContext,
+		d3d11CommandBuffer->context,
 		stagingBuffer,
 		0
 	);
-	SDL_UnlockMutex(renderer->contextLock);
+
+	D3D11_INTERNAL_TrackTransferBuffer(d3d11CommandBuffer, d3d11TransferBuffer);
 
 	/* Clean up the staging buffer */
-	ID3D11Resource_Release(stagingBuffer);
+	ID3D11Buffer_Release(stagingBuffer);
+}
+
+static void D3D11_CopyTextureToTexture(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer,
+	Refresh_TextureRegion *source,
+	Refresh_TextureRegion *destination,
+	Refresh_WriteOptions writeOption
+) {
+	D3D11CommandBuffer *d3d11CommandBuffer = (D3D11CommandBuffer*) commandBuffer;
+	D3D11Texture *srcTexture = source->textureSlice.texture;
+	uint32_t srcSubresourceIndex = D3D11_INTERNAL_CalcSubresource(
+		source->textureSlice.mipLevel,
+		source->textureSlice.layer,
+		srcTexture->levelCount
+	);
+	D3D11Texture *dstTexture = destination->textureSlice.texture;
+	uint32_t dstSubresourceIndex = D3D11_INTERNAL_CalcSubresource(
+		destination->textureSlice.mipLevel,
+		destination->textureSlice.layer,
+		dstTexture->levelCount
+	);
+	D3D11_BOX srcBox = { source->x, source->y, source->z, source->x + source->w, source->y + source->w, 1 };
+
+	ID3D11DeviceContext1_CopySubresourceRegion1(
+		d3d11CommandBuffer->context,
+		dstTexture->handle,
+		dstSubresourceIndex,
+		destination->x,
+		destination->y,
+		destination->z,
+		srcTexture->handle,
+		srcSubresourceIndex,
+		&srcBox,
+		writeOption == REFRESH_WRITEOPTIONS_SAFEDISCARD ? D3D11_COPY_DISCARD : 0
+	);
+}
+
+static void D3D11_CopyBufferToBuffer(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer,
+	Refresh_GpuBuffer *source,
+	Refresh_GpuBuffer *destination,
+	Refresh_BufferCopy *copyParams,
+	Refresh_WriteOptions writeOption
+) {
+	D3D11CommandBuffer *d3d11CommandBuffer = (D3D11CommandBuffer*) commandBuffer;
+	D3D11Buffer *srcBuffer = (D3D11Buffer*) source;
+	D3D11Buffer *dstBuffer = (D3D11Buffer*) destination;
+	D3D11_BOX srcBox = { copyParams->srcOffset, 0, 0, copyParams->srcOffset + copyParams->size, 1, 1 };
+
+	ID3D11DeviceContext1_CopySubresourceRegion1(
+		d3d11CommandBuffer->context,
+		dstBuffer->handle,
+		0,
+		copyParams->dstOffset,
+		0,
+		0,
+		srcBuffer->handle,
+		0,
+		&srcBox,
+		writeOption == REFRESH_WRITEOPTIONS_SAFEDISCARD ? D3D11_COPY_DISCARD : 0
+	);
+}
+
+static void D3D11_EndCopyPass(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer
+) {
+	/* no-op */
 }
 
 /* Uniforms */
@@ -2701,11 +2665,11 @@ static void D3D11_QueueDestroySampler(
 	SDL_free(d3d11Sampler);
 }
 
-static void D3D11_QueueDestroyBuffer(
+static void D3D11_QueueDestroyGpuBuffer(
 	Refresh_Renderer *driverData,
-	Refresh_Buffer *buffer
+	Refresh_GpuBuffer *gpuBuffer
 ) {
-	D3D11Buffer *d3d11Buffer = (D3D11Buffer*) buffer;
+	D3D11Buffer *d3d11Buffer = (D3D11Buffer*) gpuBuffer;
 
 	if (d3d11Buffer->uav)
 	{
@@ -2932,22 +2896,23 @@ static ID3D11RenderTargetView* D3D11_INTERNAL_FetchRTV(
 	D3D11Renderer *renderer,
 	Refresh_ColorAttachmentInfo *info
 ) {
-	D3D11Texture *texture = (D3D11Texture*) info->texture;
+	D3D11Texture *texture = (D3D11Texture*) info->textureSlice.texture;
 	D3D11TargetView *targetView;
 	uint8_t isMultisample = texture->msaaHandle != NULL;
 	D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
 	ID3D11RenderTargetView *rtv;
 	HRESULT res;
 
+	/* FIXME: what about 3D textures */
 	/* Does this target already exist? */
 	for (uint32_t i = 0; i < texture->targetViewCount; i += 1)
 	{
 		targetView = &texture->targetViews[i];
 
-		if (	targetView->depth == info->depth &&
+		if (
-			targetView->layer == info->layer &&
+			targetView->layer == info->textureSlice.layer &&
-			targetView->level == info->level	)
+			targetView->level == info->textureSlice.mipLevel
-		{
+		) {
 			return (ID3D11RenderTargetView*) targetView->view;
 		}
 	}
@@ -2957,16 +2922,16 @@ static ID3D11RenderTargetView* D3D11_INTERNAL_FetchRTV(
 	if (texture->isCube && !isMultisample)
 	{
 		rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY;
-		rtvDesc.Texture2DArray.FirstArraySlice = info->layer;
+		rtvDesc.Texture2DArray.FirstArraySlice = info->textureSlice.layer;
 		rtvDesc.Texture2DArray.ArraySize = 1;
-		rtvDesc.Texture2DArray.MipSlice = info->level;
+		rtvDesc.Texture2DArray.MipSlice = info->textureSlice.mipLevel;
 	}
 	else if (texture->depth > 1)
 	{
 		rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE3D;
-		rtvDesc.Texture3D.MipSlice = info->level;
+		rtvDesc.Texture3D.MipSlice = info->textureSlice.mipLevel;
-		rtvDesc.Texture3D.FirstWSlice = info->depth;
+		rtvDesc.Texture3D.FirstWSlice = 0;
-		rtvDesc.Texture3D.WSize = 1;
+		rtvDesc.Texture3D.WSize = texture->depth;
 	}
 	else
 	{
@@ -2977,7 +2942,7 @@ static ID3D11RenderTargetView* D3D11_INTERNAL_FetchRTV(
 		else
 		{
 			rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
-			rtvDesc.Texture2D.MipSlice = info->level;
+			rtvDesc.Texture2D.MipSlice = info->textureSlice.mipLevel;
 		}
 	}
 
@@ -3001,8 +2966,8 @@ static ID3D11RenderTargetView* D3D11_INTERNAL_FetchRTV(
 
 	targetView = &texture->targetViews[texture->targetViewCount];
 	targetView->depth = info->depth;
-	targetView->layer = info->layer;
+	targetView->layer = info->textureSlice.layer;
-	targetView->level = info->level;
+	targetView->level = info->textureSlice.mipLevel;
 	targetView->view = (ID3D11View*) rtv;
 
 	texture->targetViewCount += 1;
@@ -3401,16 +3366,17 @@ static void D3D11_BindVertexBuffers(
 	Refresh_CommandBuffer *commandBuffer,
 	uint32_t firstBinding,
 	uint32_t bindingCount,
-	Refresh_Buffer **pBuffers,
+	Refresh_BufferBinding *pBindings
-	uint64_t *pOffsets
 ) {
 	D3D11Renderer *renderer = (D3D11Renderer*) driverData;
 	D3D11CommandBuffer *d3d11CommandBuffer = (D3D11CommandBuffer*) commandBuffer;
 	ID3D11Buffer *bufferHandles[MAX_BUFFER_BINDINGS];
+	UINT bufferOffsets[MAX_BUFFER_BINDINGS];
 
 	for (uint32_t i = 0; i < bindingCount; i += 1)
 	{
-		bufferHandles[i] = ((D3D11Buffer*) pBuffers[i])->handle;
+		bufferHandles[i] = ((D3D11Buffer*) pBindings[i].gpuBuffer)->handle;
+		bufferOffsets[i] = pBindings[i].offset;
 	}
 
 	ID3D11DeviceContext_IASetVertexBuffers(
@@ -3419,26 +3385,25 @@ static void D3D11_BindVertexBuffers(
 		bindingCount,
 		bufferHandles,
 		&d3d11CommandBuffer->graphicsPipeline->vertexStrides[firstBinding],
-		(UINT*) pOffsets
+		bufferOffsets
 	);
 }
 
 static void D3D11_BindIndexBuffer(
 	Refresh_Renderer *driverData,
 	Refresh_CommandBuffer *commandBuffer,
-	Refresh_Buffer *buffer,
+	Refresh_BufferBinding *pBinding,
-	uint64_t offset,
 	Refresh_IndexElementSize indexElementSize
 ) {
 	D3D11Renderer *renderer = (D3D11Renderer*) driverData;
 	D3D11CommandBuffer *d3d11CommandBuffer = (D3D11CommandBuffer*) commandBuffer;
-	D3D11Buffer *d3d11Buffer = (D3D11Buffer*) buffer;
+	D3D11Buffer *d3d11Buffer = (D3D11Buffer*) pBinding->gpuBuffer;
 
 	ID3D11DeviceContext_IASetIndexBuffer(
 		d3d11CommandBuffer->context,
 		d3d11Buffer->handle,
 		RefreshToD3D11_IndexType[indexElementSize],
-		(UINT) offset
+		(UINT) pBinding->offset
 	);
 }
 
@@ -3477,10 +3442,11 @@ static void D3D11_BindComputePipeline(
 	);
 }
 
+/* D3D11 can't discard when setting a UAV, so just ignore writeOption */
 static void D3D11_BindComputeBuffers(
 	Refresh_Renderer *driverData,
 	Refresh_CommandBuffer *commandBuffer,
-	Refresh_Buffer **pBuffers
+	Refresh_ComputeBufferBinding *pBindings
 ) {
 	D3D11Renderer *renderer = (D3D11Renderer*) driverData;
 	D3D11CommandBuffer *d3d11CommandBuffer = (D3D11CommandBuffer*) commandBuffer;
@@ -3490,7 +3456,7 @@ static void D3D11_BindComputeBuffers(
 
 	for (int32_t i = 0; i < numBuffers; i += 1)
 	{
-		uavs[i] = ((D3D11Buffer*) pBuffers[i])->uav;
+		uavs[i] = ((D3D11Buffer*) pBindings[i].gpuBuffer)->uav;
 	}
 
 	ID3D11DeviceContext_CSSetUnorderedAccessViews(
@@ -3502,10 +3468,12 @@ static void D3D11_BindComputeBuffers(
 	);
 }
 
+/* FIXME: need to pre-generate UAVs per subresource */
+/* D3D11 can't discard when setting a UAV, so just ignore writeOption */
 static void D3D11_BindComputeTextures(
 	Refresh_Renderer *driverData,
 	Refresh_CommandBuffer *commandBuffer,
-	Refresh_Texture **pTextures
+	Refresh_ComputeTextureBinding *pBindings
 ) {
 	D3D11Renderer *renderer = (D3D11Renderer*) driverData;
 	D3D11CommandBuffer *d3d11CommandBuffer = (D3D11CommandBuffer*) commandBuffer;
@@ -3515,7 +3483,7 @@ static void D3D11_BindComputeTextures(
 
 	for (int32_t i = 0; i < numTextures; i += 1)
 	{
-		uavs[i] = ((D3D11Texture*) pTextures[i])->unorderedAccessView;
+		uavs[i] = ((D3D11Texture*) pBindings[i].textureSlice.texture)->unorderedAccessView;
 	}
 
 	ID3D11DeviceContext_CSSetUnorderedAccessViews(