TheGameCreators - CodeBase - Noise Library Part 3: Modules.dba

Return to the CodeBase listing

Category: Libraries

Version: 1.2

Information

Uploaded: 31st Oct 2010 10:14

Modified: 5th Nov 2010 12:18

Author: The Sab

Summary

All of the Noise Modules in one include file, for use with NoiseGen.dba

Full Description

1.2 Fixed sort errors in Curve and Terrace control point functions. 1.1 Fixed various errors in the Transformer Modules. -removed the constants RADTODEG from the calculation in RotatePoint. DBPro uses degree calculations natively. C++ apparently uses radians. -re-ordered how variables are assigned in Turbulence. The internal Perlin values were being over-written. 1.0 The original, no doubt error-ridden code.

DarkBASIC Professional Source Code

` This code was downloaded from The Game Creators

` It is reproduced here with full permission

` http://www.thegamecreators.com

#constant DEFAULT_BILLOW_FREQUENCY 1.0

#constant DEFAULT_BILLOW_LACUNARITY 2.0

#constant DEFAULT_BILLOW_QUALITY QUALITY_STD

#constant DEFAULT_BILLOW_OCTAVE_COUNT 6

#constant DEFAULT_BILLOW_PERSISTENCE 0.5

#constant DEFAULT_BILLOW_SEED 0

#constant DEFAULT_CLAMP_LOWER_BOUND -1.0

#constant DEFAULT_CLAMP_UPPER_BOUND 1.0

#constant DEFAULT_CONST_VALUE 0.0

#constant DEFAULT_CYLINDERS_FREQUENCY 1.0

#constant DEFAULT_EXPONENT 1.0

#constant DEFAULT_PERLIN_FREQUENCY 1.0

#constant DEFAULT_PERLIN_LACUNARITY 2.0

#constant DEFAULT_PERLIN_OCTAVE_COUNT 6

#constant DEFAULT_PERLIN_PERSISTENCE 0.5

#constant DEFAULT_PERLIN_QUALITY QUALITY_STD

#constant DEFAULT_PERLIN_SEED 0

#constant PERLIN_MAX_OCTAVE 30

#constant DEFAULT_RIDGED_FREQUENCY 1.0

#constant DEFAULT_RIDGED_LACUNARITY 2.0

#constant DEFAULT_RIDGED_QUALITY QUALITY_STD

#constant DEFAULT_RIDGED_OCTAVE_COUNT 6

#constant DEFAULT_RIDGED_SEED 0

#constant RIDGED_MAX_OCTAVE 30

#constant DEFAULT_ROTATE_X 0.0

#constant DEFAULT_ROTATE_Y 0.0

#constant DEFAULT_ROTATE_Z 0.0

#constant DEFAULT_BIAS 0.0

#constant DEFAULT_SCALE 1.0

#constant DEFAULT_SCALE_POINT_X 1.0

#constant DEFAULT_SCALE_POINT_Y 1.0

#constant DEFAULT_SCALE_POINT_Z 1.0

#constant DEFAULT_SELECT_EDGE_FALLOFF 0.0

#constant DEFAULT_SELECT_LOWER_BOUND -1.0

#constant DEFAULT_SELECT_UPPER_BOUND 1.0

#constant DEFAULT_SPHERES_FREQUENCY = 1.0

#constant DEFAULT_TRANSLATE_POINT_X 0.0

#constant DEFAULT_TRANSLATE_POINT_Y 0.0

#constant DEFAULT_TRANSLATE_POINT_Z 0.0

#constant DEFAULT_TURBULENCE_POWER 1.0

#constant DEFAULT_TURBULENCE_SEED 0

#constant DEFAULT_TURBULENCE_FREQUENCY 1.0

#constant DEFAULT_TURBULENCE_ROUGHNESS 3

#constant DEFAULT_VORONOI_DISPLACEMENT 1.0

#constant DEFAULT_VORONOI_FREQUENCY 1.0

#constant DEFAULT_VORONOI_SEED 0

function Abs_GetValue(index as integer, x as float, y as float, z as float)

if module_sets(index).source0 = -1

ExceptionNoModule(index)

endif

result as float

result = abs(Module_GetValue(module_sets(index).source0, x, y, z))

endfunction result

function Add_GetValue(index as integer, x as float, y as float, z as float)

if module_sets(index).source0 = -1 or module_sets(index).source1 = -1

ExceptionNoModule(index)

endif

result as float

result = Module_GetValue(module_sets(index).source0, x, y, z) + Module_GetValue(module_sets(index).source1, x, y, z)

endfunction result

function Billow_Setup(index as integer)

module_sets(index).frequency = DEFAULT_BILLOW_FREQUENCY

module_sets(index).lacunarity = DEFAULT_BILLOW_LACUNARITY

module_sets(index).noiseQuality = DEFAULT_BILLOW_QUALITY

module_sets(index).octaveCount = DEFAULT_BILLOW_OCTAVE_COUNT

module_sets(index).persistence = DEFAULT_BILLOW_PERSISTENCE

module_sets(index).seed = DEFAULT_BILLOW_SEED

endfunction

function Billow_GetValue(index as integer, x as float, y as float, z as float)

value as float

signal as float

curPersistence as float

nx as float

ny as float

nz as float

seed as integer

value = 0.0

signal = 0.0

curPersistence = 1.0

x = x * module_sets(index).frequency

y = y * module_sets(index).frequency

z = z * module_sets(index).frequency

for curOctave = 0 to module_sets(index).octaveCount - 1

`Make sure that these floating-point values have the same range as a 32-

`bit integer so that we can pass them to the coherent-noise functions.

nx = MakeInt32Range(x)

ny = MakeInt32Range(y)

nz = MakeInt32Range(z)

`Get the coherent-noise value from the input value and add it to the

`final result.

seed = (module_sets(index).seed + curOctave) && 0xffffffff

signal = GradientCoherentNoise3D(index, nx, ny, nz, seed)

signal = 2.0 * abs(signal) - 1.0

value = value + signal * curPersistence

`Prepare the next octave.

x = x * module_sets(index).lacunarity

y = y * module_sets(index).lacunarity

z = z * module_sets(index).lacunarity

curPersistence = curPersistence * module_sets(index).persistence

next curOctave

value = value + 0.5

endfunction value

function Blend_GetValue(index as integer, x as float, y as float, z as float)

if module_sets(index).source0 = -1 or module_sets(index).source1 = -1 or module_sets(index).control = -1

ExceptionNoModule(index)

endif

result as float

v0 as float

v1 as float

alpha as float

v0 = Module_GetValue(module_sets(index).source0, x, y, z)

v1 = Module_GetValue(module_sets(index).source1, x, y, z)

alpha = (Module_GetValue(module_sets(index).control, x, y, z) + 1.0) / 2.0

result = LinearInterp(v0, v1, alpha)

endfunction result

function Checkerboard_GetValue(index as integer, x as float, y as float, z as float)

result as float

ix = int(floor(MakeInt32Range(x)))

iy = int(floor(MakeInt32Range(y)))

iz = int(floor(MakeInt32Range(z)))

if (ix && 1 ~~ iy && 1 ~~ iz && 1)

result = -1.0

else

result = 1.0

endif

endfunction result

function Clamp_Setup(index as integer)

module_sets(index).lowerBound = DEFAULT_CLAMP_LOWER_BOUND

module_sets(index).upperBound = DEFAULT_CLAMP_UPPER_BOUND

endfunction

function Clamp_GetValue(index as integer, x as float, y as float, z as float)

if module_sets(index).source0 = -1

ExceptionNoModule(index)

endif

result as float

result = Module_GetValue(module_sets(index).source0, x, y, z)

if result < module_sets(index).lowerBound

result = module_sets(index).lowerBound

endif

if result > module_sets(index).upperBound

result = module_sets(index).upperBound

endif

endfunction result

function Const_Setup(index as integer)

module_sets(index).constValue = DEFAULT_CONST_VALUE

endfunction

function Const_GetValue(index as integer)

result as float

result = module_sets(index).constValue

endfunction result

function Curve_Setup(index as integer)

module_sets(index).controlPointCount = 0

module_sets(index).controlPointsSet = controlPointsSetCount

inc controlPointsSetCount

endfunction

function Curve_AddControlPoint(index as integer, inputValue as float, outputValue as float)

`Find the insertion point for the new control point and insert the new

`point at that position.  The control point array will remain sorted by

`input value.

insertionPos = Curve_FindInsertionPos(index, inputValue)

Curve_InsertAtPos(index, insertionPos, inputValue, outputValue)

endfunction

function Curve_ClearAllControlPoints(index as integer)

module_sets(index).controlPointCount = 0

endfunction

function Curve_FindInsertionPos(index as integer, inputValue as float)

insertionPos as integer

if module_sets(index).controlPointCount = 0

insertionPos = 0

exitfunction insertionPos

endif

insertionPos = module_sets(index).controlPointCount

for i = 0 to module_sets(index).controlPointCount - 1

if inputValue < ControlPoints(module_sets(index).controlPointsSet, i).inputValue

insertionPos = i

exitfunction insertionPos

else

if inputValue = ControlPoints(module_sets(index).controlPointsSet, i).inputValue

ExceptionInvalidParam(index)

endif

next i

endfunction insertionPos

function Curve_GetValue(index as integer, x as float, y as float, z as float)

if module_sets(index).source0 = -1

ExceptionNoModule(index)

endif

result as float

sourceModuleValue as float

sourceModuleValue = Module_GetValue(module_sets(index).source0, x, y, z)

if module_sets(index).controlPointCount >= 4

`Find the first element in the control point array that has an input value

`larger than the output value from the source module.

for indexPos = 0 to module_sets(index).controlPointCount - 1

if sourceModuleValue < ControlPoints(module_sets(index).controlPointsSet, indexPos).inputValue

exit

endif

next indexPos

`Find the four nearest control points so that we can perform cubic

`interpolation.

index0 = ClampValue(indexPos - 2, 0, module_sets(index).controlPointCount - 1)

index1 = ClampValue(indexPos - 1, 0, module_sets(index).controlPointCount - 1)

index2 = ClampValue(indexPos, 0, module_sets(index).controlPointCount - 1)

index3 = ClampValue(indexPos + 1, 0, module_sets(index).controlPointCount - 1)

`If some control points are missing (which occurs if the value from the

`source module is greater than the largest input value or less than the

`smallest input value of the control point array), get the corresponding

`output value of the nearest control point and exit now.

if index1 = index2

result = ControlPoints(module_sets(index).controlPointsSet, index1).outputValue

exitfunction result

endif

`Compute the alpha value used for cubic interpolation.

input0 as float

input1 as float

alpha as float

input0 = ControlPoints(module_sets(index).controlPointsSet, index1).inputValue

input1 = ControlPoints(module_sets(index).controlPointsSet, index2).inputValue

alpha = (sourceModuleValue - input0) / (input1 - input0)

`Now perform the cubic interpolation given the alpha value.

out0# = ControlPoints(module_sets(index).controlPointsSet, index0).outputValue

out1# = ControlPoints(module_sets(index).controlPointsSet, index1).outputValue

out2# = ControlPoints(module_sets(index).controlPointsSet, index2).outputValue

out3# = ControlPoints(module_sets(index).controlPointsSet, index3).outputValue

result = CubicInterp(out0#, out1#, out2#, out3#, alpha)

else

ExceptionInvalidParam(index)

endif

endfunction result

function Curve_InsertAtPos(index as integer, insertionPos as integer, inputValue as float, outputValue as float)

`Make room for the new control point at the specified position within the

`control point array.  The position is determined by the input value of

`the control point; the control points must be sorted by the input value

`within that array.

if module_sets(index).controlPointCount > 0

for i = module_sets(index).controlPointCount to insertionPos + 1 step -1

ControlPoints(module_sets(index).controlPointsSet, i).inputValue = ControlPoints(module_sets(index).controlPointsSet, i - 1).inputValue

ControlPoints(module_sets(index).controlPointsSet, i).outputValue = ControlPoints(module_sets(index).controlPointsSet, i - 1).outputValue

next i

endif

ControlPoints(module_sets(index).controlPointsSet, insertionPos).inputValue = inputValue

ControlPoints(module_sets(index).controlPointsSet, insertionPos).outputValue = outputValue

inc module_sets(index).controlPointCount

endfunction

function Cylinders_Setup(index as integer)

module_sets(index).frequency = DEFAULT_CYLINDERS_FREQUENCY

endfunction

function Cylinders_GetValue(index as integer, x as float, y as float, z as float)

result as float

x = x * module_sets(index).frequency

z = z * module_sets(index).frequency

distFromCenter as float

distFromSmallerSphere as float

distFromLargerSphere as float

nearestDist as float

distFromCenter = sqrt(x * x + z * z)

distFromSmallerSphere = distFromCenter - floor(distFromCenter)

distFromLargerSphere = 1.0 - distFromSmallerSphere

nearestDist = GetMin(distFromSmallerSphere, distFromLargerSphere)

result = 1.0 - (nearestDist * 4.0) `Puts it in the -1.0 to +1.0 range.

endfunction result

function Displace_GetValue(index as integer, x as float, y as float, z as float)

if module_sets(index).source0 = -1 or module_sets(index).source1 = -1 or module_sets(index).source2 = -1 or module_sets(index).source3 = -1

ExceptionNoModule(index)

endif

result as float

xDisplace as float

yDisplace as float

zDisplace as float

xDisplace = x + (Module_GetValue(module_sets(index).source1, x, y, z))

yDisplace = y + (Module_GetValue(module_sets(index).source2, x, y, z))

zDisplace = z + (Module_GetValue(module_sets(index).source3, x, y, z))

result = Module_GetValue(module_sets(index).source0, xDisplace, yDisplace, zDisplace)

endfunction result

function Exponent_Setup(index as integer)

module_sets(index).exponent = DEFAULT_EXPONENT

endfunction

function Exponent_GetValue(index as integer, x as float, y as float, z as float)

if module_sets(index).source0 = -1

ExceptionNoModule(index)

endif

result as float

value as float

value = Module_GetValue(module_sets(index).source0, x, y, z)

result = (abs((value + 1.0) / 2.0) ^ module_sets(index).exponent) * 2.0 - 1.0

endfunction result

function Invert_GetValue(index as integer, x as float, y as float, z as float)

if module_sets(index).source0 = -1

ExceptionNoModule(index)

endif

result as float

result = -(Module_GetValue(module_sets(index).source0, x, y, z))

endfunction result

function Max_GetValue(index as integer, x as float, y as float, z as float)

if module_sets(index).source0 = -1 or module_sets(index).source1 = -1

ExceptionNoModule(index)

endif

result as float

v0# = Module_GetValue(module_sets(index).source0, x, y, z)

v1# = Module_GetValue(module_sets(index).source1, x, y, z)

result = GetMax(v0#, v1#)

endfunction result

function Min_GetValue(index as integer, x as float, y as float, z as float)

if module_sets(index).source0 = -1 or module_sets(index).source1 = -1

ExceptionNoModule(index)

endif

result as float

v0# = Module_GetValue(module_sets(index).source0, x, y, z)

v1# = Module_GetValue(module_sets(index).source1, x, y, z)

result = GetMin(v0#, v1#)

endfunction result

function Multiply_GetValue(index as integer, x as float, y as float, z as float)

if module_sets(index).source0 = -1 or module_sets(index).source1 = -1

ExceptionNoModule(index)

endif

result as float

v0# = Module_GetValue(module_sets(index).source0, x, y, z)

v1# = Module_GetValue(module_sets(index).source1, x, y, z)

result = v0# * v1#

endfunction result

function Perlin_Setup(index as integer)

module_sets(index).frequency = DEFAULT_PERLIN_FREQUENCY

module_sets(index).lacunarity = DEFAULT_PERLIN_LACUNARITY

module_sets(index).noiseQuality = DEFAULT_PERLIN_QUALITY

module_sets(index).octaveCount = DEFAULT_PERLIN_OCTAVE_COUNT

module_sets(index).persistence = DEFAULT_PERLIN_PERSISTENCE

module_sets(index).seed = DEFAULT_PERLIN_SEED

endfunction

function Perlin_GetValue(index as integer, x as float, y as float, z as float)

value as float

signal as float

curPersistence as float

nx as float

ny as float

nz as float

seed as integer

value = 0.0

signal = 0.0

curPersistence = 1.0

x = x * module_sets(index).frequency

y = y * module_sets(index).frequency

z = z * module_sets(index).frequency

for curOctave = 0 to module_sets(index).octaveCount - 1

`Make sure that these floating-point values have the same range as a 32-

`bit integer so that we can pass them to the coherent-noise functions.

nx = MakeInt32Range(x)

ny = MakeInt32Range(y)

nz = MakeInt32Range(z)

`Get the coherent-noise value from the input value and add it to the

`final result.

seed = (module_sets(index).seed + curOctave) && 0xffffffff

signal = GradientCoherentNoise3D(index, nx, ny, nz, seed)

value = value + signal * curPersistence

`Prepare the next octave.

x = x * module_sets(index).lacunarity

y = y * module_sets(index).lacunarity

z = z * module_sets(index).lacunarity

curPersistence = curPersistence * module_sets(index).persistence

next curOctave

endfunction value

function Power_GetValue(index as integer, x as float, y as float, z as float)

if module_sets(index).source0 = -1 or module_sets(index).source1 = -1

ExceptionNoModule(index)

endif

result as float

v0# = Module_GetValue(module_sets(index).source0, x, y, z)

v1# = Module_GetValue(module_sets(index).source1, x, y, z)

result = v0# ^ v1#

endfunction result

function RidgedMulti_Setup(index as integer)

module_sets(index).frequency = DEFAULT_RIDGED_FREQUENCY

module_sets(index).lacunarity = DEFAULT_RIDGED_LACUNARITY

module_sets(index).noiseQuality = DEFAULT_RIDGED_QUALITY

module_sets(index).octaveCount = DEFAULT_RIDGED_OCTAVE_COUNT

module_sets(index).seed = DEFAULT_RIDGED_SEED

dim m_pSpectralWeights(RIDGED_MAX_OCTAVE - 1) as float

RidgedMulti_CalcSpectralWeights(index)

endfunction

`Calculates the spectral weights for each octave.

function RidgedMulti_CalcSpectralWeights(index as integer)

`This exponent parameter should be user-defined; it may be exposed in a

`future version of libnoise.

h as float

h = 1.0

frequency as float

frequency = 1.0

for i = 0 to RIDGED_MAX_OCTAVE - 1

`Compute weight for each frequency.

m_pSpectralWeights(i) = frequency ^ -h

frequency = frequency * module_sets(index).lacunarity

next i

endfunction

`Multifractal code originally writeen by F. Kenton "Doc Mojo" Musgrave,

`1998.  Modified by jas for use with libnoise.

function RidgedMulti_GetValue(index as integer, x as float, y as float, z as float)

result as float

nx as float

ny as float

nz as float

signal as float

value as float

weight as float

offset as float

gain as float

x = x * module_sets(index).frequency

y = y * module_sets(index).frequency

z = z * module_sets(index).frequency

signal = 0.0

value = 0.0

weight = 1.0

`These parameters should be user-defined; they may be exposed in a

`future version of libnoise

offset = 1.0

gain = 2.0

for curOctave = 0 to module_sets(index).octaveCount - 1

`Make sure that these floating-point values have the same range as a 32-

`bit integer so that we can pass them to the coherent-noise functions.

nx = MakeInt32Range(x)

ny = MakeInt32Range(y)

nz = MakeInt32Range(z)

`Get the coherent-noise value.

seed = (module_sets(index).seed + curOctave) && 0x7fffffff

signal = GradientCoherentNoise3D(index, nx, ny, nz, seed)

`Make the ridges

signal = abs(signal)

signal = offset - signal

`Square the signal to increase the sharpness of the ridges.

signal = signal ^ 2

`The weighting from the previous octave is applied to the signal.

`Larger values have higher weights, producing sharp points along the

`ridges.

signal = signal * weight

`Weight successive contributions by the previous signal.

weight = signal * gain

if weight > 1.0

weight = 1.0

endif

if weight < 0.0

weight = 0.0

endif

`Add the signal to the output value.

value = value + (signal * m_pSpectralWeights(curOctave))

`Go to the next octave.

x = x * module_sets(index).lacunarity

y = y * module_sets(index).lacunarity

z = z * module_sets(index).lacunarity

next curOctave

result = (value * 1.25) - 1.0

endfunction result

function RotatePoint_Setup(index as integer)

RotatePoint_SetAngles(index, DEFAULT_ROTATE_X, DEFAULT_ROTATE_Y, DEFAULT_ROTATE_Z)

endfunction

function RotatePoint_GetValue(index as integer, x as float, y as float, z as float)

if module_sets(index).source0 = -1

ExceptionNoModule(index)

endif

result as float

nx as float

ny as float

nz as float

nx = (module_sets(index).x1Matrix * x) + (module_sets(index).y1Matrix * y) + (module_sets(index).z1Matrix * z)

ny = (module_sets(index).x2Matrix * x) + (module_sets(index).y2Matrix * y) + (module_sets(index).z2Matrix * z)

nz = (module_sets(index).x3Matrix * x) + (module_sets(index).y3Matrix * y) + (module_sets(index).z3Matrix * z)

result = Module_GetValue(module_sets(index).source0, nx, ny, nz)

endfunction result

function RotatePoint_SetAngles(index as integer, xAngle as float, yAngle as float, zAngle as float)

xCos as float

yCos as float

zCos as float

xSin as float

ySin as float

zSin as float

xCos = cos(xAngle)` * DEG_TO_RAD)

yCos = cos(yAngle)` * DEG_TO_RAD)

zCos = cos(zAngle)` * DEG_TO_RAD)

xSin = sin(xAngle)` * DEG_TO_RAD)

ySin = sin(yAngle)` * DEG_TO_RAD)

zSin = sin(zAngle)` * DEG_TO_RAD)

module_sets(index).x1Matrix = ySin * xSin * zSin + yCos * zCos

module_sets(index).y1Matrix = xCos * zSin

module_sets(index).z1Matrix = ySin * zCos - yCos * xSin * zSin

module_sets(index).x2Matrix = ySin * xSin * zCos - yCos * zSin

module_sets(index).y2Matrix = xCos * zCos

module_sets(index).z2Matrix = -yCos * xSin * zCos - ySin * zSin

module_sets(index).x3Matrix = -ySin * xCos

module_sets(index).y3Matrix = xSin

module_sets(index).z3Matrix = yCos * xCos

module_sets(index).xAngle = xAngle

module_sets(index).yAngle = yAngle

module_sets(index).zAngle = zAngle

endfunction

function ScaleBias_Setup(index as integer)

module_sets(index).bias = DEFAULT_BIAS

module_sets(index).scale = DEFAULT_SCALE

endfunction

function ScaleBias_GetValue(index as integer, x as float, y as float, z as float)

if module_sets(index).source0 = -1

ExceptionNoModule(index)

endif

result as float

result = Module_GetValue(module_sets(index).source0, x, y, z) * module_sets(index).scale + module_sets(index).bias

endfunction result

function ScalePoint_Setup(index as integer)

module_sets(index).xScale = DEFAULT_SCALE_POINT_X

module_sets(index).yScale = DEFAULT_SCALE_POINT_Y

module_sets(index).zScale = DEFAULT_SCALE_POINT_Z

endfunction

function ScalePoint_GetValue(index as integer, x as float, y as float, z as float)

if module_sets(index).source0 = -1

ExceptionNoModule(index)

endif

result as float

result = Module_GetValue(module_sets(index).source0, x * module_sets(index).xScale, y * module_sets(index).yScale, z * module_sets(index).zScale)

endfunction result

function ScalePoint_SetXYZ(index as integer, x as float, y as float, z as float)

module_sets(index).xScale = x

module_sets(index).yScale = y

module_sets(index).zScale = z

endfunction

function Select_Setup(index as integer)

module_sets(index).edgeFallOff = DEFAULT_SELECT_EDGE_FALLOFF

module_sets(index).lowerBound = DEFAULT_SELECT_LOWER_BOUND

module_sets(index).upperBound = DEFAULT_SELECT_UPPER_BOUND

endfunction

function Select_GetValue(index as integer, x as float, y as float, z as float)

if module_sets(index).source0 = -1 or module_sets(index).source1 = -1 or module_sets(index).control = -1

ExceptionNoModule(index)

endif

result as float

controlValue as float

alpha as float

controlValue = Module_GetValue(module_sets(index).control, x, y, z)

if module_sets(index).edgeFalloff > 0.0

if controlValue < module_sets(index).lowerBound - module_sets(index).edgeFalloff

`The output value from the control module is below the selector

`threshold; return the output value from the first source module.

exitfunction Module_GetValue(module_sets(index).source0, x, y, z)

else

if controlValue < module_sets(index).lowerBound + module_sets(index).edgeFalloff

`The output value from the control module is near the lower end of the

`selector threshold and within the smooth curve.  Interpolate between

`the output values from the first and second source modules.

lowerCurve as float

upperCurve as float

lowerCurve = module_sets(index).lowerBound - module_sets(index).edgeFalloff

upperCurve = module_sets(index).lowerBound + module_sets(index).edgeFalloff

alpha = SCurve3((controlValue - lowerCurve) / (upperCurve - lowerCurve))

result = LinearInterp(Module_GetValue(module_sets(index).source0, x, y, z), Module_GetValue(module_sets(index).source1, x, y, z), alpha)

exitfunction result

else

if controlValue < (module_sets(index).upperBound - module_sets(index).edgeFalloff)

`The output value from the control module is within the selector

`threshold; return the output value from the second source module.

result = Module_GetValue(module_sets(index).source1, x, y, z)

exitfunction result

else

if controlValue < (module_sets(index).upperBound + module_sets(index).edgeFalloff)

`The output value from the control module is near the upper end of the

`selector threshold and with the smooth curve.  Interpolate between

`the output values from the first and second source modules.

lowerCurve as float

upperCurve as float

lowerCurve = module_sets(index).upperBound - module_sets(index).edgeFalloff

upperCurve = module_sets(index).upperBound + module_sets(index).edgeFalloff

alpha = SCurve3((controlValue - lowerCurve) / (upperCurve - lowerCurve))

result = LinearInterp(Module_GetValue(module_sets(index).source1, x, y, z), Module_GetValue(module_sets(index).source0, x, y, z), alpha)

exitfunction result

else

`Output value from the control module is above the selector threshold;

`return the output value from the first source module.

result = Module_GetValue(module_sets(index).source0, x, y, z)

exitfunction result

endif

else

if controlValue < module_sets(index).lowerBound or controlValue > module_sets(index).upperBound

result = Module_GetValue(module_sets(index).source0, x, y, z)

exitfunction result

else

result = Module_GetValue(module_sets(index).source1, x, y, z)

exitfunction result

endif

endfunction result

function Select_SetBounds(index as integer, lowerBound as float, upperBound as float)

if lowerBound < upperBound

module_sets(index).lowerBound = lowerBound

module_sets(index).upperBound = upperBound

`Make sure that the edge falloff curves do not overlap.

Select_SetEdgeFalloff(index, module_sets(index).edgeFalloff)

endif

endfunction

function Select_SetEdgeFalloff(index as integer, edgeFalloff as float)

`Make sure that the edge falloff curves do not overlap.

boundSize as float

boundSize = module_sets(index).upperBound - module_sets(index).lowerBound

if edgeFalloff > boundSize / 2

module_sets(index).edgeFalloff = boundSize / 2

else

module_sets(index).edgeFalloff = edgeFalloff

endif

endfunction

function Spheres_Setup(index as integer)

module_sets(index).frequency = DEFAULT_SPHERES_FREQUENCY

endfunction

function Spheres_GetValue(index as integer, x as float, y as float, z as float)

result as float

distFromCenter as float

distFromSmallerSphere as float

distFromLargerSphere as float

nearestDist as float

x = x * module_sets(index).frequency

y = y * module_sets(index).frequency

z = z * module_sets(index).frequency

distFromCenter = sqrt(x * x + y * y + z * z)

distFromSmallerSphere = distFromCenter - floor(distFromCenter)

distFromLargerSphere = 1.0 - distFromSmallerSphere

nearestDist = GetMin(distFromSmallerSphere, distFromLargerSphere)

result = 1.0 - (nearestDist * 4.0) `Puts it in the -1.0 to +1.0 range.

endfunction result

function Terrace_Setup(index as integer)

module_sets(index).controlPointCount = 0

module_sets(index).invertTerraces = false

module_sets(index).controlPointsSet = controlPointsSetCount

inc controlPointsSetCount

endfunction

function Terrace_AddControlPoint(index as integer, value as float)

`Find the insertion point for the new control point and insert the new

`point at that position.  The control point array will remain sorted by

`value.

insertPos = Terrace_FindInsertionPos(index, value)

Terrace_InsertAtPos(index, insertPos, value)

endfunction

function Terrace_ClearAllControlPoints(index as integer)

module_sets(index).controlPointCount = 0

endfunction

function Terrace_FindInsertionPos(index as integer, value as float)

insertionPos as integer

if module_sets(index).controlPointCount = 0

insertionPos = 0

exitfunction insertionPos

endif

insertionPos = module_sets(index).controlPointCount

for i = 0 to module_sets(index).controlPointCount - 1

if value < ControlPoints(module_sets(index).controlPointsSet, i).inputValue

insertionPos = i

exitfunction insertionPos

else

if value = ControlPoints(module_sets(index).controlPointsSet, i).inputValue

ExceptionInvalidParam(index)

endif

next i

endfunction insertionPos

function Terrace_InsertAtPos(index as integer, insertionPos as integer, value as float)

`Make room for the new control point at the specified position within

`the control point array.  The position is determined by the value of

`the control point; the control points must be sorted by value within

`that array.

if module_sets(index).controlPointCount > 0

for i = module_sets(index).controlPointCount to insertionPos + 1 step -1

ControlPoints(module_sets(index).controlPointsSet, i).inputValue = ControlPoints(module_sets(index).controlPointsSet, i - 1).inputValue

next i

endif

ControlPoints(module_sets(index).controlPointsSet, insertionPos).inputValue = value

inc module_sets(index).controlPointCount

endfunction

function Terrace_GetValue(index as integer, x as float, y as float, z as float)

if module_sets(index).source0 = -1

ExceptionNoModule(index)

endif

result as float

sourceModuleValue as float

sourceModuleValue = Module_GetValue(module_sets(index).source0, x, y, z)

if module_sets(index).controlPointCount >= 2

`Find the first element in the control point array that has a value

`larger than the output value from the source module.

for indexPos = 0 to module_sets(index).controlPointCount - 1

if sourceModuleValue < ControlPoints(module_sets(index).controlPointsSet, indexPos).inputValue

exit

endif

next indexPos

`Find the four nearest control points so that we can map their values

`onto a quadratic curve.

index0 = ClampValue(indexPos - 1, 0, module_sets(index).controlPointCount - 1)

index1 = ClampValue(indexPos, 0, module_sets(index).controlPointCount - 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 index0 = index1

result = ControlPoints(module_sets(index).controlPointsSet, index1).inputValue

exitfunction result

endif

`Compute the alpha value used for linear interpolation.

value0 as float

value1 as float

alpha as float

value0 = ControlPoints(module_sets(index).controlPointsSet, index0).inputValue

value1 = ControlPoints(module_sets(index).controlPointsSet, index1).inputValue

alpha = (sourceModuleValue - value0) / (value1 - value0)

if m_invertTerraces

alpha = 1.0 - alpha

temp# = value0

value0 = value1

value1 = temp#

endif

`Now perform the linear interpolation given the alpha value.

result = LinearInterp(value0, value1, alpha)

else

ExceptionInvalidParam(index)

endif

endfunction result

function Terrace_MakeControlPoints(index as integer)

controlPointCount = module_sets(index).controlPointCount

if controlPointCount < 2

ExceptionInvalidParam(index)

endif

Terrace_ClearAllControlPoints(index)

terraceStep as float

curValue as float

terraceStep = 2.0 / (controlPointCount - 1.0)

curValue = -1.0

for i = 0 to controlPointCount - 1

Terrace_AddControlPoint(index, curValue)

curValue = curValue + terraceStep

next i

endfunction

function TranslatePoint_Setup(index as integer)

module_sets(index).xTranslation = DEFAULT_TRANSLATE_POINT_X

module_sets(index).yTranslation = DEFAULT_TRANSLATE_POINT_Y

module_sets(index).zTranslation = DEFAULT_TRANSLATE_POINT_Z

endfunction

function TranslatePoint_GetValue(index as integer, x as float, y as float, z as float)

if module_sets(index).source0 = -1

ExceptionNoModule(index)

endif

result as float

result = Module_GetValue(module_sets(index).source0, x + module_sets(index).xTranslation, y + module_sets(index).yTranslation, z + module_sets(index).zTranslation)

endfunction result

function TranslatePoint_SetXYZ(index as integer, x as float, y as float, z as float)

module_sets(index).xTranslation = x

module_sets(index).yTranslation = y

module_sets(index).zTranslation = z

endfunction

function Turbulence_Setup(index as integer)

xDistort = Create_Module(MOD_PERLIN)

yDistort = Create_Module(MOD_PERLIN)

zDistort = Create_Module(MOD_PERLIN)

Set_Source1(index, xDistort)

Set_Source2(index, yDistort)

Set_Source3(index, zDistort)

module_sets(index).power = DEFAULT_TURBULENCE_POWER

Turbulence_SetSeed(index, DEFAULT_TURBULENCE_SEED)

Turbulence_SetFrequency(index, DEFAULT_TURBULENCE_FREQUENCY)

Turbulence_SetRoughness(index, DEFAULT_TURBULENCE_ROUGHNESS)

endfunction

function Turbulence_GetFrequency()

result as float

result = module_sets(module_sets(index).source1).frequency

endfunction result

function Turbulence_GetSeed()

result as float

result = module_sets(module_sets(index).source1).seed

endfunction result

function Turbulence_GetValue(index as integer, x as float, y as float, z as float)

if module_sets(index).source0 = -1

ExceptionNoModule(index)

endif

result as float

`Get the values from the three noise::module::Perlin noise modules and

`add each value to each coordinate of the input value.  There are also

`some offsets added to the coordinates of the input values.  This prevents

`the distortion modules from returning zero if the (x, y, z) coordinates,

`when multiplied by the frequency, are near an integer boundary.  This is

`due to a property of gradient coherent noise, which returns zero at

`integer boundaries.

x0 as float

y0 as float

z0 as float

x1 as float

y1 as float

z1 as float

x2 as float

y2 as float

z2 as float

xDistort as float

yDistort as float

zDistort as float

x0 = x + (12414.0 / 65536.0)

y0 = y + (65124.0 / 65536.0)

z0 = z + (31337.0 / 65536.0)

x1 = x + (26519.0 / 65536.0)

y1 = y + (18128.0 / 65536.0)

z1 = z + (60493.0 / 65536.0)

x3 = x + (53820.0 / 65536.0)

y3 = y + (11213.0 / 65536.0)

z3 = z + (44845.0 / 65536.0)

xDistort = x + (Module_GetValue(module_sets(index).source1, x0, y0, z0) * module_sets(index).power)

yDistort = y + (Module_GetValue(module_sets(index).source2, x1, y1, z1) * module_sets(index).power)

zDistort = z + (Module_GetValue(module_sets(index).source3, x2, y2, z2) * module_sets(index).power)

`Retrieve the output value at the offsetted input value instead of the

`original input value.

result = Module_GetValue(module_sets(index).source0, xDistort, yDistort, zDistort)

endfunction result

function Turbulence_SetSeed(index as integer, seed as integer)

`Set the seed of each noise::module::Perlin noise modules.  To prevent any

`sort of weird artifacting, use a slightly different seed for each noise

`module.

Set_Seed(module_sets(index).source1, seed)

Set_Seed(module_sets(index).source2, seed + 1)

Set_Seed(module_sets(index).source3, seed + 2)

endfunction

function Turbulence_SetRoughness(index as integer, roughness as integer)

Set_OctaveCount(module_sets(index).source1, roughness)

Set_OctaveCount(module_sets(index).source2, roughness)

Set_OctaveCount(module_sets(index).source3, roughness)

endfunction

function Turbulence_SetFrequency(index as integer, frequency as integer)

Set_Frequency(module_sets(index).source1, frequency)

Set_Frequency(module_sets(index).source2, frequency)

Set_Frequency(module_sets(index).source3, frequency)

endfunction

function Voronoi_Setup(index as integer)

module_sets(index).displacement = DEFAULT_VORONOI_DISPLACEMENT

module_sets(index).enableDistance = false

module_sets(index).frequency = DEFAULT_VORONOI_FREQUENCY

module_sets(index).seed = DEFAULT_VORONOI_SEED

endfunction

function Voronoi_GetValue(index as integer, x as float, y as float, z as float)

result as float

`This method could be more efficient by caching the seed values.  Fix

`later.

x = x * module_sets(index).frequency

y = y * module_sets(index).frequency

if x > 0.0

xInt = int(x)

else

xInt = int(x - 1)

endif

if y > 0.0

yInt = int(y)

else

yInt = int(y - 1)

endif

if z > 0.0

zInt = int(z)

else

zInt = int(z - 1)

endif

minDist as float

xCandidate as float

yCandidate as float

zCandidate as float

xPos as float

yPos as float

zPos as float

xDist as float

yDist as float

zDist as float

dist as float

minDist = 2147483647.0

xCandidate = 0.0

yCandidate = 0.0

zCandidate = 0.0

`Inside each unit cube, there is a seed point at a random position.  Go

`through each of the nearby cubes until we find a cube with a seed point

`that is closest to the specified position.

for zCur = zInt - 2 to zInt + 2

for yCur = yInt - 2 to yInt + 2

for xCur = xInt - 2 to xInt + 2

`Calculate the position and distance to the seed point inside of

`this unit cube.

xPos = xCur + ValueNoise3D(xCur, yCur, zCur, module_sets(index).seed)

yPos = yCur + ValueNoise3D(xCur, yCur, zCur, module_sets(index).seed + 1)

zPos = zCur + ValueNoise3D(xCur, yCur, zCur, module_sets(index).seed + 2)

xDist = xPos - x

yDist = yPos - y

zDist = zPos - z

dist = xDist ^ 2 + yDist ^ 2 + zDist ^ 2

if dist < minDist

`This seed point is closer to any others found so far, so record

`this seed point

minDist = dist

xCandidate = xPos

yCandidate = yPos

zCandidate = zPos

endif

next xCur

next yCur

next zCur

value as float

if module_sets(index).enableDistance

`Determine the distance to the nearest seed point.

xDist = xCandidate - x

yDist = yCandidate - y

zDist = zCandidate - z

value = (sqrt(xDist ^ 2 + yDist ^ 2 + zDist ^ 2)) * SQRT_3 - 1.0

else

value = 0.0

endif

`Return the calculated distance with the displacement value applied.

result = value + (module_sets(index).displacement * ValueNoise3D(int(floor(xCandidate)), int(floor(yCandidate)), int(floor(zCandidate)), m_seed))

CodeBase - Noise Library Part 3: Modules.dba

Information

Summary

Full Description

DarkBASIC Professional Source Code

Download

Screen Shot

Author

Comments

Author Name:	The Sab
CodeBase Entries:	10