spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

HLSL-Quelltext

#version 120

varying vec3 v_texCoord3D;

void main( void )
{
    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
    gl_TexCoord[0] = gl_MultiTexCoord0;

    const int seed =99;
    v_texCoord3D = normalize(gl_Vertex).xyz + seed; 
}

HLSL-Quelltext

// basierend auf: 
//
// Description : Array and textureless GLSL 3D simplex noise function.
//      Author : Ian McEwan, Ashima Arts.
//  Maintainer : ijm
//     Lastmod : 20110409 (stegu)
//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.
//               Distributed under the MIT License. See LICENSE file.
//

#version 120

varying vec3 v_texCoord3D;

float f_lacunarity;
float f_persistence;

struct GradientColor
{
    float pos;
    vec4 color;
};

//libnoise helper

vec4 LinearInterpColor (vec4 color0, vec4 color1, float alpha)
{
    return (color1 * alpha) + (color0 * (1.0 - alpha));
}
int clampi(int x, int minVal, int maxVal) 
{
    if(x < minVal) return minVal;
    else if (x > maxVal) return maxVal;
    else return x;
}
// noise helper
vec4 permute(vec4 x) {return mod(((x*34.0)+1.0)*x, 289.0);}
vec4 taylorInvSqrt(vec4 r) {return 1.79284291400159 - 0.85373472095314 * r;}
vec3 fade(vec3 t) {return t*t*t*(t*(t*6.0-15.0)+10.0);}

float snoise(vec3 v)
  { 
  const vec2  C = vec2(1.0/6.0, 1.0/3.0) ;
  const vec4  D = vec4(0.0, 0.5, 1.0, 2.0);

// First corner
  vec3 i  = floor(v + dot(v, C.yyy) );
  vec3 x0 =   v - i + dot(i, C.xxx) ;

// Other corners
  vec3 g = step(x0.yzx, x0.xyz);
  vec3 l = 1.0 - g;
  vec3 i1 = min( g.xyz, l.zxy );
  vec3 i2 = max( g.xyz, l.zxy );

  //  x0 = x0 - 0. + 0.0 * C 
  vec3 x1 = x0 - i1 + 1.0 * C.xxx;
  vec3 x2 = x0 - i2 + 2.0 * C.xxx;
  vec3 x3 = x0 - 1. + 3.0 * C.xxx;

// Permutations
  i = mod(i, 289.0 ); 
  vec4 p = permute( permute( permute( 
             i.z + vec4(0.0, i1.z, i2.z, 1.0 ))
           + i.y + vec4(0.0, i1.y, i2.y, 1.0 )) 
           + i.x + vec4(0.0, i1.x, i2.x, 1.0 ));

// Gradients
// ( N*N points uniformly over a square, mapped onto an octahedron.)
  float n_ = 1.0/7.0; // N=7
  vec3  ns = n_ * D.wyz - D.xzx;

  vec4 j = p - 49.0 * floor(p * ns.z *ns.z);  //  mod(p,N*N)

  vec4 x_ = floor(j * ns.z);
  vec4 y_ = floor(j - 7.0 * x_ );    // mod(j,N)

  vec4 x = x_ *ns.x + ns.yyyy;
  vec4 y = y_ *ns.x + ns.yyyy;
  vec4 h = 1.0 - abs(x) - abs(y);

  vec4 b0 = vec4( x.xy, y.xy );
  vec4 b1 = vec4( x.zw, y.zw );

  //vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
  //vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
  vec4 s0 = floor(b0)*2.0 + 1.0;
  vec4 s1 = floor(b1)*2.0 + 1.0;
  vec4 sh = -step(h, vec4(0.0));

  vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
  vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;

  vec3 p0 = vec3(a0.xy,h.x);
  vec3 p1 = vec3(a0.zw,h.y);
  vec3 p2 = vec3(a1.xy,h.z);
  vec3 p3 = vec3(a1.zw,h.w);

//Normalise gradients
  vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
  p0 *= norm.x;
  p1 *= norm.y;
  p2 *= norm.z;
  p3 *= norm.w;

// Mix final noise value
  vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
  m = m * m;
  return 42.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1), 
                                dot(p2,x2), dot(p3,x3) ) );
  }
float sOctaveNoise(vec3 p, float frequenzy, int octaveCount)
{
    float value = 0.0;
    float curPersistence = 1.0;
//  cnoise(p*frequenzy);
    for(int curOctave = 0; curOctave < octaveCount; curOctave++)
    {
        value += snoise(p*frequenzy) * curPersistence;
        p *= f_lacunarity;
        curPersistence *= f_persistence;
    }
    return value;
}

vec4 gradientColor(float value, GradientColor points[10], int pointsCount)
{
  // Find the first element in the control point array that has a value
  // larger than the output value from the source module.
  int indexPos;
  for (indexPos = 0; indexPos < pointsCount; indexPos++) {
    if (value < points[indexPos].pos) {
      break;
    }
  }

  // Find the two nearest control points so that we can map their values
  // onto a quadratic curve.
  ivec2 index = ivec2(clampi(indexPos - 1, 0, pointsCount - 1),
                      clampi(indexPos    , 0, pointsCount - 1));

  // If some control points are missing (which occurs if the output value from
  // the source module is greater than the largest value or less than the
  // smallest value of the control point array), get the value of the nearest
  // control point and exit now.
  if (index.x == index.y) 
    return points[index.y].color;

  // Compute the alpha value used for linear interpolation.
  vec2 inputv = vec2(points[index.x].pos, points[index.y].pos);
  float alpha = (value - inputv.x) / (inputv.y - inputv.x);

  vec4 color0 = points[index.x].color;
  vec4 color1 = points[index.y].color;

  // Now perform the linear interpolation given the alpha value.
  return LinearInterpColor (color0, color1, alpha);
}

void main( void )
{
    //Default
    const float DEFAULT_LACUNARTITY = 2.0;

    f_lacunarity = DEFAULT_LACUNARTITY;
    f_persistence = 0.5;

    vec2 curveTemp[10];
    float terraceTemp[6];
    float n = 0;
    
    f_lacunarity = 2.208984375;
    float baseContinentDef_pe0 = sOctaveNoise(v_texCoord3D, 1.0, 14);


    if(n == 0.0)
        n = baseContinentDef_pe0;
    float seaLevel = 0.0;
    GradientColor gradient[10];
    gradient[0] =  GradientColor(-2.0           + seaLevel, vec4(0.0,     0.0,     0.0,     1.0));
    gradient[1] =  GradientColor(-0.03125       + seaLevel, vec4(0.02353, 0.22745, 0.49804, 1.0));
    gradient[2] =  GradientColor(-0.0001220703  + seaLevel, vec4(0.05490, 0.43922, 0.75294, 1.0));
    gradient[3] =  GradientColor( 0.0           + seaLevel, vec4(0.27451, 0.47059, 0.23529, 1.0));
    gradient[4] =  GradientColor( 0.125         + seaLevel, vec4(0.43137, 0.54902, 0.29412, 1.0));
    gradient[5] =  GradientColor( 0.25          + seaLevel, vec4(0.62745, 0.54902, 0.43529, 1.0));
    gradient[6] =  GradientColor( 0.375         + seaLevel, vec4(0.72157, 0.63921, 0.55294, 1.0));
    gradient[7] =  GradientColor( 0.5           + seaLevel, vec4(1.0));
    gradient[8] =  GradientColor( 0.75          + seaLevel, vec4(0.5,     1.0,     1.0,     1.0));
    gradient[9] =  GradientColor( 2.0           + seaLevel, vec4(0.0,     0.0,     1.0,     1.0));

    gl_FragColor = gradientColor(n, gradient, 10);//vec4(0.5 + 0.5*vec3(n, n, n), 1.0);
//  gl_FragColor = vec4(0.5 + 0.5*vec3(n,n,n), 1.0);
}

HLSL-Quelltext

struct GradientColor
{
    float pos;
    vec4 color;
}; 

vec4 gradientColor(float value, GradientColor points[10], int pointsCount)
{
//Funktion
}

HLSL-Quelltext

//float n = ...

    GradientColor gradient[10];
    gradient[0] =  GradientColor(-2.0           , vec4(0.0,        0.0,        0.0,        1.0));
    gradient[1] =  GradientColor(-0.03125       , vec4(0.02353, 0.22745, 0.49804, 1.0));
    gradient[2] =  GradientColor(-0.0001220703  , vec4(0.05490, 0.43922, 0.75294, 1.0));
    gradient[3] =  GradientColor( 0.0           , vec4(0.27451, 0.47059, 0.23529, 1.0));
    gradient[4] =  GradientColor( 0.125         , vec4(0.43137, 0.54902, 0.29412, 1.0));
    gradient[5] =  GradientColor( 0.25          , vec4(0.62745, 0.54902, 0.43529, 1.0));
    gradient[6] =  GradientColor( 0.375         , vec4(0.72157, 0.63921, 0.55294, 1.0));
    gradient[7] =  GradientColor( 0.5           , vec4(1.0));
    gradient[8] =  GradientColor( 0.75          , vec4(0.5,     1.0,     1.0,     1.0));
    gradient[9] =  GradientColor( 2.0           , vec4(0.0,     0.0,     1.0,     1.0));

   gl_FragColor = gradientColor(n, gradient, 10);

HLSL-Quelltext

vec4 gradientColor(float value, GradientColor points[], int pointsCount)
{
//funktion
}

HLSL-Quelltext

GradientColor points[];

HLSL-Quelltext

float alpha = clamp((value - inputv.x) / (inputv.y - inputv.x), 0.0, 1.0);

HLSL-Quelltext

vec4 gradientColor(float value, GradientColor points[10], int pointsCount)
{

  // Find the first element in the control point array that has a value
  // larger than the output value from the source module.
  int indexPos;
  for (indexPos = 0; indexPos < pointsCount; indexPos++) {
    if (value < points[indexPos].pos) {
      break;
    }
  }


  // Find the two nearest control points so that we can map their values
  // onto a quadratic curve.
  ivec2 index = ivec2(clampi(indexPos - 1, 0, pointsCount - 1),
                      clampi(indexPos    , 0, pointsCount - 1));

  // If some control points are missing (which occurs if the output value from
  // the source module is greater than the largest value or less than the
  // smallest value of the control point array), get the value of the nearest
  // control point and exit now.
 if (index.x == index.y) 
    return points[index.y].color;

  // Compute the alpha value used for linear interpolation.
  vec2 inputv = vec2(points[index.x].pos, points[index.y].pos);
  float alpha = clamp((value - inputv.x) / (inputv.y - inputv.x), 0.0, 1.0);
  

  vec4 color0 = points[index.x].color;
  vec4 color1 = points[index.y].color;

  // Now perform the linear interpolation given the alpha value.
  return LinearInterpColor (color0, color1, alpha);
}