Framework BRL.Pixmap
Import BRL.BMPLoader
Import BRL.JPGLoader
Import BRL.PNGLoader
Import BRL.FileSystem
Import BRL.StandardIO

If AppArgs.length >= 2
	Local InputFile:String = AppArgs[1]
	Local OutputFile:String = StripExt(InputFile) + "_n2h.png"
	
	FixPath InputFile
	FixPath OutputFile
	
	If FileType(InputFile) = FILETYPE_NONE Then 'User did an error
		Print "Couldn't find file '"+InputFile+"'."
	Else
		PrintEx "Loading '"+InputFile+"'... "
		Local InputPixmap:TPixmap = LoadPixmap(InputFile)
		If (Not InputPixmap) Then 'Unknown format
			Print "Failed."
		Else
			Print "Done."
			
			'Process Input
			PrintEx "Processing... "
			Local procStart:Int = MilliSecs()
			Local HeightArray:Double[InputPixmap.width, InputPixmap.height, 4]
			Local highPX:Double, highPY:Double
			Local lowPX:Double, lowPY:Double
			For Local pX:Int = 0 Until InputPixmap.width
				For Local pY:Int = 0 Until InputPixmap.height
					Local hX:Double, hY:Double
					Local dX:Double, dY:Double
					
					'Read Height Values
					If (pX > 0) Then hX = HeightArray[pX-1, pY, 0] Else hX = 0
					If (pY > 0) Then hY = HeightArray[pX, pY-1, 1] Else hY = 0
					
					'Read Color Value
					Local ARGB:Int = InputPixmap.ReadPixel(pX,pY)
					dX = -((ARGB Shl 8 Shr 24) / 127.0 - 1) 'Extract R and invert (x axis is positive footprint)
					dY = ((ARGB Shl 16 Shr 24) / 127.0 - 1) 'Extract G (y axis is negative footprint)
					
					'Assign Values
					HeightArray[pX, pY, 0] = hX + dX
					HeightArray[pX, pY, 1] = hY + dY
					
					'Check for lowP and highP
					If HeightArray[pX, pY, 0] > highPX Then highPX = HeightArray[pX, pY, 0]
					If HeightArray[pX, pY, 1] > highPY Then highPY = HeightArray[pX, pY, 1]
					If HeightArray[pX, pY, 0] < lowPX Then lowPX = HeightArray[pX, pY, 0]
					If HeightArray[pX, pY, 1] < lowPY Then lowPY = HeightArray[pX, pY, 1]
				Next
			Next
			Print "Done in " + (MilliSecs() - procStart) + "ms."
			
			'Create a memory representation of the output.
			PrintEx "Creating pixelmap of size " + InputPixmap.width + "*" + InputPixmap.height + "@24bpp... "
			Local OutputPixmap:TPixmap = CreatePixmap(InputPixmap.width, InputPixmap.height, PF_A8, 1)
			OutputPixmap.ClearPixels(0)
			?Debug
			Local OutputPixmapX:TPixmap = CreatePixmap(InputPixmap.width, InputPixmap.height, PF_A8, 1)
			Local OutputPixmapY:TPixmap = CreatePixmap(InputPixmap.width, InputPixmap.height, PF_A8, 1)
			OutputPixmapX.ClearPixels(0)
			OutputPixmapY.ClearPixels(0)
			?
			If Not OutputPixmap Then 
				Print "Failed."
			Else
				Print "Done."
				
				'Process the Data we've gathered.
				PrintEx "Writing data to pixelmap... "
				Local dataStart:Int = MilliSecs()
				Local mulX:Double = (255.0/(highPX - lowPX))
				Local mulY:Double = (255.0/(highPY - lowPY))
				Local smoothRad:Int = (AppArgs.length >= 3 And Int(AppArgs[2]) Or 0)
				Local smoothRadDiv:Int = ((smoothRad + smoothRad + 1) * (smoothRad + smoothRad + 1))
				mulX :/ smoothRadDiv;mulY :/ smoothRadDiv
				
				Local pixelPtr:Byte Ptr = OutputPixmap.pixels
				Local intTotal:Byte, zX:Int, zY:Int
				?Debug
				Local pixelPtrX:Byte Ptr = OutputPixmapX.pixels, pixelPtrY:Byte Ptr = OutputPixmapY.pixels
				?
				
				For pY:Int = 0 Until InputPixmap.height
					For pX:Int = 0 Until InputPixmap.width
						If smoothRad > 0
							hX = 0; hY = 0
							For tX:Int = -smoothRad To smoothRad
								For ty:Int = -smoothRad To smoothRad
									zX = pX + tX;zY = pY + tY
									If zX > 0
										If zX > InputPixmap.width-1
											zX = InputPixmap.width-1
										EndIf
									Else
										zX = 0
									EndIf
									If zY > 0
										If zY > InputPixmap.height-1
											zY = InputPixmap.height-1
										EndIf
									Else
										zY = 0
									EndIf
									hX :+ (HeightArray[zX,zY,0] - lowPX) * mulX
									hY :+ (HeightArray[zX,zY,1] - lowPY) * mulY
								Next
							Next
						Else
							hX = (HeightArray[pX,pY,0] - lowPX) * mulX
							hY = (HeightArray[pX,pY,1] - lowPY) * mulY
						EndIf
						
						pixelPtr[pY * OutputPixmap.pitch + pX] = ((hX+hY) / 2) 'Don't touch this magic. 60 milliseconds work time depend on this. Don't even try to optimize it.
						
						?Debug
						pixelPtrX[pY*OutputPixmapX.pitch + pX] = hX
						pixelPtrY[pY*OutputPixmapY.pitch + pX] = hY
						?
					Next
				Next
				Print "Done in " + (MilliSecs() - dataStart) + "ms."
				
				'Save the memory representation to file.
				PrintEx "Saving pixelmap to '"+OutputFile+"'... "
				SavePixmapPNG(OutputPixmap, OutputFile, 9)
				?Debug
				SavePixmapPNG(OutputPixmapX, StripExt(OutputFile)+"-x.png", 9)
				SavePixmapPNG(OutputPixmapY, StripExt(OutputFile)+"-y.png", 9)
				?
				Print "Done."
			EndIf
		EndIf
	EndIf
Else
	Print "normal2height 'path/to/normalmap.imageformat' (blurradius=0)"
	Print "  Supported formats: BMP, JPG, PNG"
EndIf

Function PrintEx( text:String )
	StandardIOStream.WriteString(text)
	StandardIOStream.Flush
End Function