Problem generating perlin noise using HLSL shader - c++

Question

I'm relatively new to HLSL and shaders in general, I've been trying to get a perlin noise shader working and I think I'm almost there, however the rendered noise is covered in banding or seam artifacts and I can't figure out why. heres a picture of the problem http://www.sharpoblunto.com/resources/news/perlin.jpg
I'm using c++ and directx 9, I'm generating a noise permutation texture and a gradient texture as inputs to the shader on the CPU using the following code
IDirect3DTexture9 *ImprovedPerlinNoise::GeneratePermTexture(IDirect3DDevice9 *device)
{
IDirect3DTexture9 *tex;
device->CreateTexture(256,256,1,NULL,D3DFMT_A8R8G8B8,D3DPOOL_MANAGED,&tex,NULL);
D3DSURFACE_DESC surfaceDesc;
tex->GetLevelDesc(0,&surfaceDesc);
D3DLOCKED_RECT lockedRect;
tex->LockRect(0,&lockedRect,NULL,NULL);
DWORD *imageData = (DWORD*)lockedRect.pBits;
for (int y=0;y<surfaceDesc.Height;++y)
{
for (int x=0;x<surfaceDesc.Width;++x)
{
int A = Perm2d(x) + y;
int AA = Perm2d(A);
int AB = Perm2d(A + 1);
int B = Perm2d(x + 1) + y;
int BA = Perm2d(B);
int BB = Perm2d(B + 1);
int index =y*lockedRect.Pitch / 4 + x;
imageData[index] = D3DCOLOR_ARGB(BB,BA,AB,AA);
}
}
tex->UnlockRect(0);
return tex;
}
IDirect3DTexture9 *ImprovedPerlinNoise::GenerateGradientTexture(IDirect3DDevice9 *device)
{
IDirect3DTexture9 *tex;
device->CreateTexture(256,1,1,NULL,D3DFMT_Q8W8V8U8,D3DPOOL_MANAGED,&tex,NULL);
D3DSURFACE_DESC surfaceDesc;
tex->GetLevelDesc(0,&surfaceDesc);
D3DLOCKED_RECT lockedRect;
tex->LockRect(0,&lockedRect,NULL,NULL);
DWORD *imageData = (DWORD*)lockedRect.pBits;
for (int y=0;y<surfaceDesc.Height;++y)
{
for (int x=0;x<surfaceDesc.Width;++x)
{
int index =y*lockedRect.Pitch / 4 + x;
int q = _gradients[_permutation[x] % 16][0] * 127;
int w = _gradients[_permutation[x] % 16][1] * 127;
int v = _gradients[_permutation[x] % 16][2] * 127;
int u = 1 * 127;
imageData[index] = D3DCOLOR_ARGB(q,w,v,u);
}
}
tex->UnlockRect(0);
return tex;
}
The actual shader code is as follows
float4x4 World;
float4x4 View;
float4x4 Projection;
struct VertexShaderInput
{
float4 Position : POSITION0;
float2 texCoord : TEXCOORD0;
};
struct VertexShaderOutput
{
float4 Position : POSITION0;
float2 texCoord : TEXCOORD0;
float4 wPosition: TEXCOORD1;
};
VertexShaderOutput VertexShaderFunction(VertexShaderInput input)
{
VertexShaderOutput output;
float4 worldPosition = mul(input.Position, World);
float4 viewPosition = mul(worldPosition, View);
output.Position = mul(viewPosition, Projection);
output.wPosition = mul(input.Position, World);
output.texCoord = input.texCoord;
return output;
}
texture permTexture2d;
texture permGradTexture;
sampler permSampler2d = sampler_state
{
texture = <permTexture2d>;
AddressU = Wrap;
AddressV = Wrap;
MAGFILTER = POINT;
MINFILTER = POINT;
MIPFILTER = NONE;
};
sampler permGradSampler = sampler_state
{
texture = <permGradTexture>;
AddressU = Wrap;
AddressV = Clamp;
MAGFILTER = POINT;
MINFILTER = POINT;
MIPFILTER = NONE;
};
float3 fade(float3 t)
{
return t * t * t * (t * (t * 6 - 15) + 10); // new curve
}
float4 perm2d(float2 p)
{
return tex2D(permSampler2d, p);
}
float gradperm(float x, float3 p)
{
float3 sample = tex1D(permGradSampler, x);
return dot(sample, p);
}
float inoise(float3 p)
{
float3 P = fmod(floor(p), 256.0); // FIND UNIT CUBE THAT CONTAINS POINT
p -= floor(p); // FIND RELATIVE X,Y,Z OF POINT IN CUBE.
float3 f = fade(p); // COMPUTE FADE CURVES FOR EACH OF X,Y,Z.
P = P / 256.0;
const float one = 1.0 / 256.0;
// HASH COORDINATES OF THE 8 CUBE CORNERS
float4 AA = perm2d(P.xy) + P.z;
// AND ADD BLENDED RESULTS FROM 8 CORNERS OF CUBE
return lerp( lerp( lerp( gradperm(AA.x, p ),
gradperm(AA.z, p + float3(-1, 0, 0) ), f.x),
lerp( gradperm(AA.y, p + float3(0, -1, 0) ),
gradperm(AA.w, p + float3(-1, -1, 0) ), f.x), f.y),
lerp( lerp( gradperm(AA.x+one, p + float3(0, 0, -1) ),
gradperm(AA.z+one, p + float3(-1, 0, -1) ), f.x),
lerp( gradperm(AA.y+one, p + float3(0, -1, -1) ),
gradperm(AA.w+one, p + float3(-1, -1, -1) ), f.x), f.y), f.z);
}
float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0
{
float3 p = input.wPosition;
float inz = inoise(p)*0.5+0.5;
return float4(inz,inz,inz,1);
}
technique PerlinNoise
{
pass Pass1
{
VertexShader = compile vs_3_0 VertexShaderFunction();
PixelShader = compile ps_3_0 PixelShaderFunction();
}
}
If anyone could point me in the right direction that would be fantastic, I really would like to be able to generate 3d noise in hlsl as its so much faster than doing it on the CPU (I have a working CPU implementation but it takes around 10 seconds to render a perlin cubemap for an object, the shader as I have it renders at 60FPS no problems at all)
Thanks in advance