Jump to content

  • Log In with Google      Sign In   
  • Create Account

rtclawson

Member Since 16 Jan 2013
Offline Last Active Oct 22 2013 10:58 AM

Topics I've Started

ImmediateContext.MapSubresource out of memory error

25 July 2013 - 12:46 PM

I am writing to a 3D texture with the format SlimDX.DXGI.Format.R16_UNorm, and using the following call:

 

DataBox b = _device.ImmediateContext.MapSubresource(_volumeTexture, 0, 0, MapMode.WriteDiscard, MapFlags.None);

 

For a texture that is 512x512x512, I get an E_OUTOFMEMORY error.  512 * 512 * 512 * 2 = 268 435 456 bytes.

 

The only other graphics objects that have been created are two small buffers for vertex lists, and a 2D texture that is 512x512.

 

My graphics card is the AMD FirePro V5900 (FireGL V), which should have at least 2GB of available video memory, and my system has 4GB of RAM. In short, I don't see how it is possible to be out of memory in this case.

 

How shall I go about debugging this problem? Any common errors I should be looking for?


Profiling Directx for comparison

25 July 2013 - 12:27 PM

The following code is used in our tests of Directx 9 to profile the time it takes to complete a task. My question is, what would be the equivalent in Directx 11?
 
 
SlimDX, Directx 9
/// <summary>
/// Flushes the queue of rendering commands. This is implemented as a blocking call.
/// </summary>
public void Flush() {
// From DirectX SDK Documentation "Accurately Profiling direct3D API Calls (Direct3D 9)" 
// Create an Event query from the current device
using ( Query q = new Query( _device, QueryType.Event ) ) {
 
// Add an end marker to the command buffer queue.
q.Issue( Issue.End );
 
// Empty the command buffer and wait until the GPU is idle.
 
while ( q.GetData<bool>( true ) == false ) {
// CPU spinning
//NOTE: device could be lost while querying driver
}
}
}
 
 
Here is my attempt. I have tried different combinations of calls, but nothing seems to work. Specifically, I get the error "DXGI_ERROR_INVALID_CALL"  on the GetData call. If I uncomment the begin, flush, and end calls, then I get the error "D3D11 ERROR: ID3D11DeviceContext::Begin: Begin is not supported and cannot be invoked for the D3D11_QUERY"
SlimDX, Directx 11
public void Flush() {
QueryDescription qd = new QueryDescription() {
Flags = QueryFlags.None,
Type = QueryType.Event
};
 
using (Query q = new Query(_device, qd)) {
 
//_device.ImmediateContext.Begin(q);
//_device.ImmediateContext.Flush();
//_device.ImmediateContext.End(q);
 
 
while (_device.ImmediateContext.GetData<bool>(q,AsynchronousFlags.DoNotFlush) == false) {
// CPU spinning
//NOTE: device could be lost while querying driver
}
}
}
 
 
 
Any help?
 
 

Calculating gradients during fast third order interpolation

19 April 2013 - 09:39 AM

I am using a method described in the GPU Gems book (http://http.developer.nvidia.com/GPUGems2/gpugems2_chapter20.html) for Fast Third-Order Texture Filtering. I have it working well for filtering volume textures. I would now like to calculate 3D gradients for use as surface normals for shading.

 

The article states that this is possible as part of the filtering step, and offers an example in one dimension. They hand wave the possibility of extending the process to multiple dimensions, but it isn't at all clear how this leap should be made. Here is the relevant sentence:

 

"To compute the gradient in higher dimensions, we obtain the corresponding filter kernels via the tensor product of a 1D derived cubic B-spline for the axis of derivation, and 1D (nonderived) cubic B-splines for the other axes."

 

Any ideas on how to accomplish this? Obviously I could just sample the texture a few more times and calculate the gradient on my own, but since I already have the samples from the filtering, it would be faster if I could calculate the gradient from them.

 

Thanks for your help!

 

Note: this post also appears in the Graphics Programming and Theory forum. I am not sure in which I will find the right person to reply.


Calculating gradients during fast third order interpolation

18 April 2013 - 04:13 PM

I am using a method described in the GPU Gems book (http://http.developer.nvidia.com/GPUGems2/gpugems2_chapter20.html) for Fast Third-Order Texture Filtering. I have it working well for filtering volume textures. I would now like to calculate 3D gradients for use as surface normals for shading.

 

The article states that this is possible as part of the filtering step, and offers an example in one dimension. They hand wave the possibility of extending the process to multiple dimensions, but it isn't at all clear how this leap should be made. Here is the relevant sentence:

 

"To compute the gradient in higher dimensions, we obtain the corresponding filter kernels via the tensor product of a 1D derived cubic B-spline for the axis of derivation, and 1D (nonderived) cubic B-splines for the other axes."

 

Any ideas on how to accomplish this? Obviously I could just sample the texture a few more times and calculate the gradient on my own, but since I already have the samples from the filtering, it would be faster if I could calculate the gradient from them.

 

Thanks for your help!


Artifacts from TriCubic Interpolation shader code

28 February 2013 - 09:40 AM

I am doing tricubic interpolation of a volume texture. The result is much smoother than nearest neighbor interpolation, but there are artifacts along gradients in the image. I'm in Direct3D 9 and SlimDX, with Shader Model 3. I am pretty sure I am taking into account the half pixel shift between pixel coordinates and texel coordinates. Any ideas? I've posted the code as well. You can assume the pixel shader calls tricubic_naive and returns the result.

 

EDIT: I Should have mentioned also that the dimensions of the volume are not the same. The volume is 512x512x87. This is a slice in the y-z plane, and similar artifacts occur in the x-z plane. However, the x-y plane is fine.

 

YXuC2v7.png

 

float cubic_interpolate_onedim(float4 p, float i)
{
	//Bezier cubic interpolation
	float om = 1.0-i;
	return om*om*om*p.x + 3*om*om*i*p.y + 3*om*i*i*p.z + i*i*i*p.w; 
}

float4 cubic_interpolate(float4x4 pixels, float interpolant) {
	pixels = transpose(pixels);

	float grayVal = cubic_interpolate_onedim(pixels[0],interpolant);
	return float4(grayVal,//r
                      grayVal,//g
                      grayVal,//b
                      1);//a
}

float4 xInt(sampler3D tex, float x, float y, float z, float3 incs,float3 interpolants)
{
	float dx = incs.x;

	float4x4 row = float4x4(tex3D(tex, float3(x,          y,z)),
                                tex3D(tex, float3(x+dx,       y,z)),
                                tex3D(tex, float3(x+dx+dx,    y,z)),
                                tex3D(tex, float3(x+dx+dx+dx, y,z)));
	return cubic_interpolate(row, interpolants.x);
}

float4 yInt(sampler3D tex, float x, float y, float z, float3 incs,float3 interpolants)
{
	float dy = incs.y;

	float4 r0 = xInt(tex,x,y			,z,incs,interpolants);
	float4 r1 = xInt(tex,x,y+dy		,z,incs,interpolants);
	float4 r2 = xInt(tex,x,y+dy+dy		,z,incs,interpolants);
	float4 r3 = xInt(tex,x,y+dy+dy+dy	,z,incs,interpolants);

	return cubic_interpolate(float4x4(r0,r1,r2,r3),interpolants.y);
}

float4 zInt(sampler3D tex, float x, float y, float z, float3 incs,float3 interpolants)
{
	float dz = incs.z;

	float4 r0 = yInt(tex,x,y,z		,incs,interpolants);
	float4 r1 = yInt(tex,x,y,z+dz		,incs,interpolants);
	float4 r2 = yInt(tex,x,y,z+dz+dz         ,incs,interpolants);
	float4 r3 = yInt(tex,x,y,z+dz+dz+dz	,incs,interpolants);

	return cubic_interpolate(float4x4(r0,r1,r2,r3),interpolants.z);
}

float4 tricubic_naive(sampler3D tex, float3 coord_grid, float3 size_grid)
{
	float3 index     = floor(coord_grid);
	index -= float3(0.5,0.5,0.5);
	float3 fraction  = frac(coord_grid);
	//interpolants should be [0..1]
	float3 interpolants = (float3(1.0,1.0,1.0) + fraction)/3;

	//bc = bottom corner
	float3 bc = index/size_grid;
	float3 incs = float3(1.0/size_grid.x,
	                     1.0/size_grid.y,
		             1.0/size_grid.z);

	return zInt(tex,bc.x,bc.y,bc.z,incs,interpolants);
}

PARTNERS