Dann hab' ich was für dich

SuperStrict
SeedRnd MilliSecs()

Rem
=========================
	Wassertextur
-------------------------
	Erstellt kachelbare Wassertexturen

	Features:
	> Normalmap
	> Heightmap
	> Animierte Textur
	> Animierte Textur mit referenz-Sky Texture
	> Ganzer Strip speichern
	> Einzelne Frames speichern

	von Holzchopf
-------------------------
End Rem


'========================
' SETUP
'------------------------
	' Grösse der Textur
	Const cWidth:Int	= 128
	Const cHeight:Int	= 128
	
	' Anzahl Frames
	Const cFrames:Int	= 16

	' Wellen
	Const cWaves:Int	= 200
	Const cWaveSizeMin:Int	= 16
	Const cWaveSizeMax:Int	= 64
	Const cWaveSpeedMin:Double	= 2
	Const cWaveSpeedMax:Double	= 6
	Const cWaveDirectionL:Int	= 0
	Const cWaveDirectionH:Int	= 360
	Const cWaveMaxHeight:Double	= 1
	Const cWaveMaxDeviation:Double	= 1
	
	' Reflektionsverhalten
	' (wird ignoriert, wenn mit einer SkyBox gerendert wird)
	Const cReflectionXOffset:Double	= 0.0	' X-Verschiebung des Lichtpunktes
	Const cReflectionYOffset:Double	= 0.4	' Das selbe für Y
	Const cReflectionStrength:Double	= 4		' invertierte Stärke des Lichtpunktes
	Const cReflectionAmbient:Int		= $FF0b6ec2	' Umgebungslicht
	Const cReflectionHighLight:Int	= $FFFFFFFF	' Lichtpunkt
'------------------------

' Phasenverschiebung pro Frame
Const cPhasePerFrame:Double = 360.0 /Double(cFrames)

' Grundfarbe zerlegen
Const cAmbAlpha:Byte	= (cReflectionAmbient Shr 24) & $FF
Const cAmbRed:Byte	= (cReflectionAmbient Shr 16) & $FF
Const cAmbGreen:Byte	= (cReflectionAmbient Shr 08) & $FF
Const cAmbBlue:Byte	= (cReflectionAmbient       ) & $FF
' Lichtfarbe zerlegen
Const cHiAlpha:Byte	= (cReflectionHighLight Shr 24) & $FF
Const cHiRed:Byte	= (cReflectionHighLight Shr 16) & $FF
Const cHiGreen:Byte	= (cReflectionHighLight Shr 08) & $FF
Const cHiBlue:Byte	= (cReflectionHighLight       ) & $FF
' Lichtunterschied
Const cDeltaAlpha:Int	= cHiAlpha	-cAmbAlpha
Const cDeltaRed:Int		= cHiRed		-cAmbRed
Const cDeltaGreen:Int	= cHiGreen	-cAmbGreen
Const cDeltaBlue:Int	= cHiBlue		-cAmbBlue


'========================
' MAIN
'------------------------
Graphics 400,300
Global TIMER:TTimer = CreateTimer(60)

Local Texture:TWaterTexture = TWaterTexture.Create()
Texture.Render()

'Texture.DrawHeightmap()
'Texture.DrawNormalMap()
'Texture.DrawReflection()
Local SkyTex:TImage = LoadImage( "skybox2.png", DYNAMICIMAGE )
Texture.DrawReflection( SkyTex )

Texture.SaveStrip( "water1" )
'Texture.SaveFrames( "water4_" )

Local Frame:Int = 0, FrameTime:Int = MilliSecs() +100
While Not KeyDown( KEY_ESCAPE )
	Cls
	
	If MilliSecs() > FrameTime
		FrameTime = FrameTime +100
		Frame = ( Frame +1 ) Mod cFrames
	EndIf
	
	For Local y:Int = 0 To 1
		For Local x:Int = 0 To 2
			DrawImage Texture.Image, x *cWidth, y*cHeight, Frame
		Next
	Next

	Flip 0
	WaitTimer( TIMER )
Wend
End
'------------------------

' Wassertextur
Type TWaterTexture	
	' Frames
	Field Frame:TFrame[]
	' Wellen
	Field Wave:TWave[]
	
	Field Image:TImage
	Field MaxHeight:Double
	Field MaxDeviation:Double
	
	' Erstellt eine Instanz einer Textur
	' (Die Textur wird noch nicht gerendert!)
	Function Create:TWaterTexture()
		Local Texture:TWaterTexture = New TWaterTexture
		
		' Bild erstellen
		Texture.Image = CreateImage( cWidth, cHeight, cFrames )

		' Alle Wellen erstellen
		Texture.Wave = New TWave[ cWaves ]
		For Local a:Int = 0 To cWaves -1
			Texture.Wave[a] = New TWave
			Texture.Wave[a].Texture = Texture
		Next

		' Alle Frames erstellen
		Texture.Frame = New TFrame[ cFrames ]
		For Local a:Int = 0 To cFrames -1
			Texture.Frame[a] = New TFrame
			Texture.Frame[a].Texture = Texture
			Texture.Frame[a].Index = a
		Next
		
		Return Texture
	End Function
	
	' Heightmap und Reflectionmap rendern
	Method Render()
		' Rendern
		For Local a:Int = 0 To cFrames -1
			Self.Frame[a].RenderHeightmap
			Self.Frame[a].RenderDeviationmap
		Next
	End Method
	
	' Heightmap zeichnen
	Method DrawHeightmap()
		For Local a:Int = 0 To cFrames -1
			Self.Frame[a].DrawHeightmap
		Next
	End Method
	' Normalmap zeichnen
	Method DrawNormalMap()
		For Local a:Int = 0 To cFrames -1
			Self.Frame[a].DrawDeviationmapAsNormalMap
		Next
	End Method
	' Reflektion zeichnen
	Method DrawReflection( pTexture:TImage = Null )
		For Local a:Int = 0 To cFrames -1
			' Nach Werten
			If pTexture = Null
				Self.Frame[a].DrawDeviationmapByValues
			' Nach Bild
			Else
				Self.Frame[a].DrawDeviationmapByTexture( pTexture )
			EndIf
		Next
	End Method
	
	' Als Strip speichern (für LoadAnim...)
	Method SaveStrip( pName:String )
		Local Strip:TPixmap = CreatePixmap( cWidth *cFrames, cHeight, PF_RGBA8888 )
		For Local a:Int = 0 To cFrames -1
			Local Pixmap:TPixmap = LockImage( Self.Image, a )
				Strip.Paste( Pixmap, a *cWidth, 0 )
			UnlockImage( Self.Image, a )
		Next
		SavePixmapPNG( Strip, pName +".png" )
	End Method
	' Frames einzeln speichern
	Method SaveFrames( pName:String )
		For Local a:Int = 0 To cFrames -1
			Local Pixmap:TPixmap = LockImage( Self.Image, a )
				SavePixmapPNG( Pixmap, pName +Right("0" +a,2) +".png" )
			UnlockImage( Self.Image, a )
		Next
	End Method
End Type

' Einzelner Frame der Textur
Type TFrame
	' Parent
	Field Texture:TWaterTexture
	
	Field Index:Int
	Field Heightmap:Double[,]
	Field Deviationmap:Double[,,]
	
	Method New()
		Self.Heightmap		= New Double[ cWidth, cHeight ]
		Self.Deviationmap	= New Double[ cWidth, cHeight, 2 ]
	End Method
	
	' Rendert die Heightmap
	Method RenderHeightmap()
		For Local a:Int = 0 To cWaves -1
			Self.Texture.Wave[a].Render( Self )
		Next
	End Method
	' Heightmap zeichnen
	Method DrawHeightmap()
		Local Pixmap:TPixmap = LockImage( Self.Texture.Image, Self.Index )
			For Local y:Int = 0 To cHeight -1
				For Local x:Int = 0 To cWidth -1
					' Höhe auslesen (und normalisieren)
					Local Height:Double = Self.Heightmap[x,y] /Self.Texture.MaxHeight
					' Farbe berechnen
					Local Brightness:Byte = 255 *Height
					Local Color:Int = (Brightness Shl 16) | (Brightness Shl 08) | Brightness
					' Pixel einzeichnen
					WritePixel( Pixmap, x, y, $ff000000 | Color )
				Next
			Next
		UnlockImage( Self.Texture.Image )
	End Method
	
	' Rendert die Reflectionmap
	Method RenderDeviationmap()
		For Local y:Int = 0 To cHeight -1
			For Local x:Int = 0 To cWidth -1
				' Referenzhöhen auslesen
				Local HeightP0:Double = Self.Heightmap[x,y]
				Local HeightPx:Double = Self.Heightmap[(x+1)Mod cWidth,y]
				Local HeightPy:Double = Self.Heightmap[x,(y+1)Mod cHeight]
				' Ablenkungen
				Local DeviationX:Double = HeightP0 -HeightPx
				Local DeviationY:Double = HeightP0 -HeightPy
				Self.Deviationmap[x,y,0] = DeviationX
				Self.Deviationmap[x,y,1] = DeviationY
				' Maximale Ablenkung aufzeichnen
				If Max(DeviationX, DeviationY) > Self.Texture.MaxDeviation
					Self.Texture.MaxDeviation = Max(DeviationX, DeviationY) /cWaveMaxDeviation
				EndIf
			Next
		Next
	End Method
	
	' Zeichnet die Reflectionmap als Normal Map
	Method DrawDeviationmapAsNormalMap()
		Local Pixmap:TPixmap = LockImage( Self.Texture.Image, Self.Index )
			For Local y:Int = 0 To cHeight -1
				For Local x:Int = 0 To cWidth -1
					' Ablenkungen auslesen (und normalisieren)
					Local DeviationX:Double = Self.Deviationmap[x,y,0] /Self.Texture.MaxDeviation
					Local DeviationY:Double = Self.Deviationmap[x,y,1] /Self.Texture.MaxDeviation
					' Normale berechnen
					Local NormX:Double = -DeviationX /Sqr(2.0)
					Local NormY:Double = -DeviationY /Sqr(2.0)
					Local NormZ:Double = Sqr(1 -NormX *NormX -NormY *NormY )
					' Farbe berechnen
					Local Red:Byte		= 127 +NormX *127
					Local Green:Byte	= 127 +NormY *127
					Local Blue:Byte	= 127 +NormZ *127
					Local Color:Int = (Red Shl 16) | (Green Shl 08) | Blue
					' Pixel einzeichnen
					WritePixel( Pixmap, x, y, $ff000000 | Color )
				Next
			Next
		UnlockImage( Self.Texture.Image )
	End Method
	
	' Zeichnet die Reflectionmap mit den gegebenen Werten
	Method DrawDeviationmapByValues()
		Local Pixmap:TPixmap = LockImage( Self.Texture.Image, Self.Index )
			For Local y:Int = 0 To cHeight -1
				For Local x:Int = 0 To cWidth -1
					' Ablenkungen auslesen (und normalisieren)
					Local DeviationX:Double = Self.Deviationmap[x,y,0] /Self.Texture.MaxDeviation
					Local DeviationY:Double = Self.Deviationmap[x,y,1] /Self.Texture.MaxDeviation
					' Distanz zum Lichtpunkt
					Local DeltaX:Double = DeviationX -cReflectionXOffset
					Local DeltaY:Double = DeviationY -cReflectionYOffset
					Local Distance:Double = Sqr( DeltaX *DeltaX +DeltaY *DeltaY )
					' Lichtstärke berechnen
					Local Brightness:Double = 0
					If Distance <= 1
						Brightness = (1 -Cos( (1 -Distance) ^cReflectionStrength *180.0)) *0.5
					EndIf
					' Farbe berechnen
					Local Alpha:Byte	= cAmbAlpha +cDeltaAlpha *Brightness
					Local Red:Byte		= cAmbRed	+cDeltaRed *Brightness
					Local Green:Byte	= cAmbGreen +cDeltaGreen *Brightness
					Local Blue:Byte	= cAmbBlue +cDeltaBlue *Brightness
					Local Color:Int = (Alpha Shl 24) | (Red Shl 16) | (Green Shl 08) | Blue
					' Pixel einzeichnen
					WritePixel( Pixmap, x, y, Color )
				Next
			Next
		UnlockImage( Self.Texture.Image )
	End Method
	
	' Zeichnet die Reflectionmap anhand eines Bildes
	Method DrawDeviationmapByTexture( pTexture:TImage )
		Local RefWidth:Int = pTexture.width -1
		Local RefHeight:Int = pTexture.height -1
		
		Local RefPixmap:TPixmap = LockImage( pTexture )
		Local Pixmap:TPixmap = LockImage( Self.Texture.Image, Self.Index )
			For Local y:Int = 0 To cHeight -1
				For Local x:Int = 0 To cWidth -1
					' Ablenkungen auslesen (und normalisieren), [-1,1] > [0,1]
					Local DeviationX:Double = (Self.Deviationmap[x,y,0] /Self.Texture.MaxDeviation +1) /2
					Local DeviationY:Double = (Self.Deviationmap[x,y,1] /Self.Texture.MaxDeviation +1) /2
					If DeviationX < 0 DeviationX = 0
					If DeviationX > 1 DeviationX = 1
					If DeviationY < 0 DeviationY = 0
					If DeviationY > 1 DeviationY = 1
					' Koordinaten auf der Referenztextur
					Local RefX:Int = DeviationX *RefWidth
					Local RefY:Int = DeviationY *RefHeight
					If RefX < 0 Or RefX => pTexture.width DebugStop
					If RefY < 0 Or RefY => pTexture.height DebugStop
					' Pixel kopieren
					Local Color:Int = ReadPixel( RefPixmap, RefX, RefY )
					WritePixel( Pixmap, x, y, Color )
				Next
			Next
		UnlockImage( Self.Texture.Image )
		UnlockImage( pTexture )
	End Method
End Type

' Einzelne Welle auf einer Textur
Type TWave
	Global gMaxHeight:Double
	
	' Parent
	Field Texture:TWaterTexture
	
	Field PosX:Int
	Field PosY:Int
	Field Offset:Double
	Field Size:Int
	Field Direction:Int
	Field Speed:Double
	
	Method New()
		Self.PosX		= Rand( 0, cWidth -1 )
		Self.PosY		= Rand( 0, cHeight -1 )
		Self.Offset	= Rnd( 0, 1 )
		Self.Size		= Rand( cWaveSizeMin, cWaveSizeMax )
		Self.Direction	= Rand( cWaveDirectionL, cWaveDirectionH )
		Self.Speed	= Rnd( cWaveSpeedMin, cWaveSpeedMax )
	End Method
	
	' Eine einzelne Welle in die Heightmap
	' des angegebenen Frames rendern.
	Method Render( pFrame:TFrame )
		' Grösse der Welle abarbeiten
		For Local x:Int = -Self.Size /2 To Self.Size /2
			For Local y:Int = -Self.Size /2 To Self.Size /2
				' Distanz zum Wellenzentrum
				Local Distance:Double = Sqr( x *x +y *y )
				If Distance <= Self.Size /2
					' Distanz über einen Cosinus strecken. L=[0,180]
					Distance = Distance /( Self.Size /2 ) *180.0
					' Und Höhe berechnen. L=[0,1]
					Local Height:Double = (Cos( Distance ) +1) *0.5
					Height = Height /Double(cWaveSizeMax) *Double(Self.Size) *cWaveMaxHeight
					' Wellenbewegung einrechnen. L=[0,1]
					Local DeltaHeight:Double = Height *(1 -Cos( pFrame.Index *cPhasePerFrame +Self.Offset *360 )) *0.5
					
					' Punkt eintragen
					Local xEff:Int = ( Self.PosX +x +cWidth *2  +Cos(Self.Direction) *((pFrame.Index +Self.Offset *cFrames) Mod cFrames) *Self.Speed) Mod cWidth
					Local yEff:Int = ( Self.PosY +y +cHeight *2 +Sin(Self.Direction) *((pFrame.Index +Self.Offset *cFrames) Mod cFrames) *Self.Speed) Mod cHeight

					pFrame.HeightMap[ xEff, yEff ]:+ DeltaHeight
					' Maximalhöhe aufzeichnen
					If pFrame.HeightMap[ xEff, yEff ] > Self.Texture.MaxHeight
						Self.Texture.MaxHeight = pFrame.HeightMap[ xEff, yEff ]
					EndIf
				EndIf
			Next
		Next
	End Method
End Type

1. Es wird ein Texturgrosser Array erzeugt, der mit Höhenwerten gefüllt wird. Dabei wird für jeden Frame jede Welle abgearbeitet, die einfach mehr oder weniger Kugelförmig eine Höhe addiert.
   
2. Diese "Heightmap" wird ggf weichgezeichnet und normalisiert. Sprich: Die Höhenwerte werden auf einen Bereich von 0 -1 gestaucht.
   
3. Erst jetzt kann aus den Punktinformationen ein Bild gemacht werden. Entweder direkt eine Heightmap, oder eben eine Textur.