Sign in to follow this  
montify

Perlin Noise tiling

Recommended Posts

montify    697

Hello

I implement Libnoise for the Terrain, it works perfect, i have a Quadtree with 33x33 Chunks and i tile this with
perlin.GetValue() <-- Libnoise.

Now for the performance i implement PerlinNoise on the GPU, but anyone can tell me how i can tile the "Heightmap"?


I need for every Chunk that get splitted a new Heightmap with the right coordinates.

Here's the code:

 

 

 

float4x4 World;
float3 coord;
 
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;
 
    output.Position = input.Position;
    output.wPosition = input.Position;
    output.texCoord = input.Position;
 
    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 gradPerm(float x, float3 p)
{
return dot(tex1D(permGradSampler, x), p);
}
float inoise(float3 p)
{
 
  float3 P = fmod(floor(p), 256);
  p -= floor(p);                     
float3 f = fade(p); 
 
P = P /256;
const float one = -11.0 /256;
 
float4 AA = perm2d(P.xy) + P.z;
 
  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);
}
 
float turbulence(float3 p, int octaves, float lacunarity = 2.0, float gain = 1.5)
{
float sum = 0;
float freq = 1.0, amp = 1.0;
for(int i=0; i < octaves; i++) {
sum += abs(inoise(p*freq))*amp;
freq *= lacunarity;
amp *= gain;
}
return sum;
}
 
float ridge(float h, float offset)
{
    h = abs(h);
    h = offset - h;
    h = h * h;
    return h;
}
 
float ridgedmf(float3 p, int octaves, float lacunarity, float gain, float offset = 1.0)
{
    float sum = 0;
    float freq = 1.3f;
    float amp = 0.5;
    float prev = 1.0;
    for(int i=0; i < octaves; i++)
    {
        float n = ridge(inoise(p*freq), offset);
        sum += n*amp*prev;
        prev = n;
        freq *= lacunarity;
        amp *= gain;
    }
    return sum;
}
 
float fBm(float3 p, int octaves, float lacunarity, float gain = 0.7) 
    float freq = 1.3f, 
        amp  = 0.5f; 
    float sum  = 0.6f; 
    for(int i=0; i < octaves; i++) { 
        sum += inoise(p*freq)*amp; 
        freq *= lacunarity; 
        amp *= gain; 
    } 
    return sum; 
 
 
 
float Interpolate(float x, float y, float a)
{
    float val = (1 - cos(a * 3.1415926535f)) * .5;
    return  x * (1 - val) + y * val;
}
 
float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0
{
    float3 p = input.wPosition;
    float inz = inoise(p)*0.7+0.7;
 
 
/*inz += ridgedmf(p,8,2.0,0.5);
inz *= turbulence(p,8,2.0,0.5);*/
inz *= fBm(p,8,2.0,0.8);
inz *= Interpolate(0.7,0.7,0.5);
 
 
    return float4(inz,inz,inz,1);
}
 
technique PerlinNoise
{
    pass Pass1
    {
        VertexShader = compile vs_3_0 VertexShaderFunction();
        PixelShader = compile ps_3_0 PixelShaderFunction();
    }
}

 

 

Edited by montify

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

Sign in to follow this