package main

import (
	"os"
	"fmt"
	"math"
	"image"
	"runtime" // Dodany import runtime w celu zrównoleglenia renderowania
	"image/png"
)

const NCPU = 2 // Liczba procesorów

const ResX = 1024
const ResY = 768
const MaxPrimCount = 64
const MaxLightCount = 10
const MaxThreads = 4

type Vector3D struct {
	x, y, z, w float64
}
type Material struct {
	Specular, Diffusive, Reflective float64
	Color                           Vector3D
}

type PrimSphere struct {
	Position Vector3D
	Radius   float64
	m        *Material
}

type Ray struct {
	Direction, Origin Vector3D
}

type Light struct {
	Position, Color Vector3D
}


type GlobalsStr struct {
	img *image.RGBA

	PrimitiveCount int
	PrimitiveList  [MaxPrimCount]*PrimSphere

	LightCount int
	LightList  [MaxLightCount]*Light
}

var Globals GlobalsStr


func main() {
	runtime.GOMAXPROCS(NCPU)
	fmt.Printf("Simple RT by gynvael.coldwind//vx (http://gynvael.coldwind.pl)\n")

	fmt.Printf("Creating scene...\n")

	Globals.img = image.NewRGBA(ResX, ResY)

	var Mirror, Green, Red Material
	{
		Mirror.Color.x = 0.6
		Mirror.Color.y = 0.6
		Mirror.Color.z = 0.6
	}
	Mirror.Specular = 0.3
	Mirror.Diffusive = 0.2
	Mirror.Reflective = 0.8

	{
		Green.Color.x = 0.1
		Green.Color.y = 1.0
		Green.Color.z = 0.1
	}
	Green.Specular = 0.1
	Green.Diffusive = 0.3
	Green.Reflective = 0.4

	{
		Red.Color.x = 1.0
		Red.Color.y = 0.1
		Red.Color.z = 0.1
	}
	Red.Specular = 0.1
	Red.Diffusive = 0.3
	Red.Reflective = 0.4

	var SpherePosMap string

	SpherePosMap =
		"........." +
			".ggg....." +
			".g...rrr." +
			".g.g.r.r." +
			".ggg.rrr." +
			"........."

	SpherePosMap = SpherePosMap
	p := 0

	var SpherePos Vector3D
	for j := 0; j < 6; j++ {
		for i := 0; i < 9; i++ {
			m := &Mirror

			z := float64(2.0)
			sn := math.Sin(float64(i+j)) * 0.8

			switch {
			case SpherePosMap[p] == 'g':
				z += -0.5
				m = &Green
			case SpherePosMap[p] == 'r':
				z += -0.5
				m = &Red
			default:
				z += sn
			}

			{
				SpherePos.x = -2.0 + float64(i)*0.5
				SpherePos.y = 1.25 - float64(j)*0.5
				SpherePos.z = z
			}
			AddSphere(&SpherePos, 0.25, m)
			p++
		}
	}

	var LightPos Vector3D
	LightPos.x = 0.0
	LightPos.y = 0.0
	LightPos.z = 0.0

	var LightColor Vector3D
	LightColor.x = 2.0
	LightColor.y = 2.0
	LightColor.z = 2.0

	AddLight(&LightPos, &LightColor)

	fmt.Printf("Rendering...\n")

	c := make(chan int)
	for i := 0; i < MaxThreads; i++ {
		fmt.Printf("[%d] Thread start\n", i)
		go Render(Globals.img, MaxThreads, i, c)
	}

	for i := 0; i < MaxThreads; i++ {
		fmt.Printf("[%d] Thread finished\n", <-c)
	}

	fmt.Printf("Writing test.png image...\n")
	fd, err := os.Open("test.png", os.O_WRONLY|os.O_CREATE, 0666)

	if err != nil {
		fmt.Printf("error: %s\n", err.String())
		return
	}

	png.Encode(fd, Globals.img)

	fmt.Printf("Done.\n")
}

func AddLight(Pos, Color *Vector3D) {
	if Globals.LightCount < MaxLightCount {
		l := new(Light)
		{
			l.Position.x = Pos.x
			l.Position.y = Pos.y
			l.Position.z = Pos.z
		}
		{
			l.Color.x = Color.x
			l.Color.y = Color.y
			l.Color.z = Color.z
		}
		Globals.LightList[Globals.LightCount] = l
		Globals.LightCount++
	}
}


func AddSphere(Pos *Vector3D, Rad float64, m *Material) {
	if Globals.PrimitiveCount < MaxPrimCount {
		p := new(PrimSphere)
		{
			p.Position.x = Pos.x
			p.Position.y = Pos.y
			p.Position.z = Pos.z
		}
		p.Radius = Rad
		p.m = m
		Globals.PrimitiveList[Globals.PrimitiveCount] = p
		Globals.PrimitiveCount++
	}
}

func (this *PrimSphere) Intersect(ray *Ray, dist *float64) int {
	var v_precalc Vector3D
	var det_precalc, b, det, i1, i2 float64

	{
		v_precalc.x = ray.Origin.x
		v_precalc.y = ray.Origin.y
		v_precalc.z = ray.Origin.z
	}
	{
		v_precalc.x -= this.Position.x
		v_precalc.y -= this.Position.y
		v_precalc.z -= this.Position.z
	}
	det_precalc = this.Radius*this.Radius - (v_precalc.x*v_precalc.x + v_precalc.y*v_precalc.y + v_precalc.z*v_precalc.z)

	b = -(v_precalc.x*ray.Direction.x + v_precalc.y*ray.Direction.y + v_precalc.z*ray.Direction.z)

	det = b*b + det_precalc

	retval := int(0)

	if det > 0 {
		det = math.Sqrt(det)
		i1 = b - det
		i2 = b + det
		switch {
		case i2 > 0 && i1 < 0:
			retval = -1
			*dist = i2
		case i2 > 0 && i1 >= 0:
			retval = 1
			*dist = i1
		}
	}

	return retval
}

func (this *PrimSphere) Normal(Ret, pos *Vector3D) {
	{
		Ret.x = pos.x
		Ret.y = pos.y
		Ret.z = pos.z
	}
	{
		Ret.x -= this.Position.x
		Ret.y -= this.Position.y
		Ret.z -= this.Position.z
	}
	f := float64(1.0 / this.Radius)
	{
		Ret.x *= f
		Ret.y *= f
		Ret.z *= f
	}
	{
		_l := float64(1.0 / (math.Sqrt(Ret.x*Ret.x + Ret.y*Ret.y + Ret.z*Ret.z)))
		Ret.x *= _l
		Ret.y *= _l
		Ret.z *= _l
	}
}


func Trace(RetVector *Vector3D, ray *Ray, refl_depth int) {
	var color Vector3D
	color.x = 0.02
	color.y = 0.1
	color.z = 0.17


	dist := float64(1000000000.0)
	var prim *PrimSphere = nil

	for i := int(0); i < Globals.PrimitiveCount; i++ {
		var temp_dist float64

		p := Globals.PrimitiveList[i]

		res := p.Intersect(ray, &temp_dist)

		if res == 0 {
			continue
		}

		if temp_dist < dist {
			prim = p
			dist = temp_dist

		}
	}

	dist = dist
	prim = prim

	if prim == nil {
		{
			RetVector.x = color.x
			RetVector.y = color.y
			RetVector.z = color.z
		}
		return
	}

	var pi Vector3D
	{
		pi.x = ray.Direction.x
		pi.y = ray.Direction.y
		pi.z = ray.Direction.z
	}
	{
		pi.x *= dist
		pi.y *= dist
		pi.z *= dist
	}
	{
		pi.x += ray.Origin.x
		pi.y += ray.Origin.y
		pi.z += ray.Origin.z
	}

	var prim_color Vector3D
	{
		prim_color.x = prim.m.Color.x
		prim_color.y = prim.m.Color.y
		prim_color.z = prim.m.Color.z
	}

	for i := 0; i < Globals.LightCount; i++ {
		lightiter := Globals.LightList[i]

		var L, N Vector3D
		{
			L.x = lightiter.Position.x
			L.y = lightiter.Position.y
			L.z = lightiter.Position.z
		}
		{
			L.x -= pi.x
			L.y -= pi.y
			L.z -= pi.z
		}

		{
			_l := float64(1.0 / (math.Sqrt(L.x*L.x + L.y*L.y + L.z*L.z)))
			L.x *= _l
			L.y *= _l
			L.z *= _l
		}

		prim.Normal(&N, &pi)

		if prim.m.Diffusive > 0.0 {
			dot := (L.x*N.x + L.y*N.y + L.z*N.z)
			if dot > 0.0 {
				diff := dot * prim.m.Diffusive

				var color_add Vector3D
				{
					color_add.x = lightiter.Color.x
					color_add.y = lightiter.Color.y
					color_add.z = lightiter.Color.z
				}
				{
					color_add.x *= prim_color.x
					color_add.y *= prim_color.y
					color_add.z *= prim_color.z
				}
				{
					color_add.x *= diff
					color_add.y *= diff
					color_add.z *= diff
				}
				{
					color.x += color_add.x
					color.y += color_add.y
					color.z += color_add.z
				}

			}
		}

		if prim.m.Specular > 0.0 {

			var R1, R Vector3D

			{
				R1.x = N.x
				R1.y = N.y
				R1.z = N.z
			}
			R2 := (L.x*N.x + L.y*N.y + L.z*N.z) * 2.0
			{
				R1.x *= R2
				R1.y *= R2
				R1.z *= R2
			}
			{
				R.x = L.x
				R.y = L.y
				R.z = L.z
			}
			{
				R.x -= R1.x
				R.y -= R1.y
				R.z -= R1.z
			}

			dot := (ray.Direction.x*R.x + ray.Direction.y*R.y + ray.Direction.z*R.z)
			if dot > 0 {

				dot *= dot
				dot *= dot
				dot *= dot
				spec := dot * prim.m.Specular

				var color_add Vector3D
				{
					color_add.x = lightiter.Color.x
					color_add.y = lightiter.Color.y
					color_add.z = lightiter.Color.z
				}
				{
					color_add.x *= spec
					color_add.y *= spec
					color_add.z *= spec
				}
				{
					color.x += color_add.x
					color.y += color_add.y
					color.z += color_add.z
				}
			}
		}

		refl := prim.m.Reflective
		if refl > 0.0 && refl_depth < 4 {

			var N, R, R1, newPi Vector3D
			prim.Normal(&N, &pi)

			{
				R.x = ray.Direction.x
				R.y = ray.Direction.y
				R.z = ray.Direction.z
			}
			{
				R1.x = N.x
				R1.y = N.y
				R1.z = N.z
			}

			R2 := (ray.Direction.x*N.x + ray.Direction.y*N.y + ray.Direction.z*N.z) * 2.0
			{
				R1.x *= R2
				R1.y *= R2
				R1.z *= R2
			}
			{
				R.x -= R1.x
				R.y -= R1.y
				R.z -= R1.z
			}

			var rcol Vector3D
			rcol.x = 0.0
			rcol.y = 0.0
			rcol.z = 0.0


			{
				newPi.x = R.x
				newPi.y = R.y
				newPi.z = R.z
			}
			{
				newPi.x *= 0.0001
				newPi.y *= 0.0001
				newPi.z *= 0.0001
			}
			{
				newPi.x += pi.x
				newPi.y += pi.y
				newPi.z += pi.z
			}

			var tempr Ray
			{
				tempr.Origin.x = newPi.x
				tempr.Origin.y = newPi.y
				tempr.Origin.z = newPi.z
			}
			{
				tempr.Direction.x = R.x
				tempr.Direction.y = R.y
				tempr.Direction.z = R.z
			}

			Trace(&rcol, &tempr, refl_depth+1)

			{
				rcol.x *= refl
				rcol.y *= refl
				rcol.z *= refl
			}
			{
				rcol.x *= prim_color.x
				rcol.y *= prim_color.y
				rcol.z *= prim_color.z
			}
			{
				color.x += rcol.x
				color.y += rcol.y
				color.z += rcol.z
			}
		}

	}

	{
		RetVector.x = color.x
		RetVector.y = color.y
		RetVector.z = color.z
	}
}

func Render(img *image.RGBA, ThreadCount, ThreadId int, c chan int) {
	var CameraPos Vector3D
	CameraPos.x = 0.0
	CameraPos.y = 0.0
	CameraPos.z = -5.0

	var WX1, WX2, WY1, WY2 float64 = -2.0, 2.0, 1.5, -1.5
	var b = img.Bounds()

	DX := float64((WX2 - WX1) / float64(b.Max.X))
	DY := float64((WY2 - WY1) / float64(b.Max.Y))

	SX := WX1
	SY := WY1 + DY*float64(ThreadId)

	var x, y int

	for y = ThreadId; y < b.Max.Y; y += ThreadCount {
		SX = WX1

		for x = b.Min.X; x < b.Max.X; x++ {
			var CameraTarget Vector3D
			CameraTarget.x = SX
			CameraTarget.y = SY
			CameraTarget.z = 0.0


			var ray Ray
			{
				ray.Origin.x = CameraPos.x
				ray.Origin.y = CameraPos.y
				ray.Origin.z = CameraPos.z
			}
			{
				ray.Direction.x = CameraTarget.x
				ray.Direction.y = CameraTarget.y
				ray.Direction.z = CameraTarget.z
			}
			{
				ray.Direction.x -= ray.Origin.x
				ray.Direction.y -= ray.Origin.y
				ray.Direction.z -= ray.Origin.z
			}
			{
				_l := float64(1.0 / (math.Sqrt(ray.Direction.x*ray.Direction.x + ray.Direction.y*ray.Direction.y + ray.Direction.z*ray.Direction.z)))
				ray.Direction.x *= _l
				ray.Direction.y *= _l
				ray.Direction.z *= _l
			}

			var color Vector3D
			Trace(&color, &ray, 0)

			var r, g, b int
			r = int(color.x * 255.0)
			g = int(color.y * 255.0)
			b = int(color.z * 255.0)

			switch {
			case r > 255:
				r = 255
			case r < 0:
				r = 0
			}

			switch {
			case g > 255:
				g = 255
			case g < 0:
				g = 0
			}

			switch {
			case b > 255:
				b = 255
			case b < 0:
				b = 0
			}

			var cl image.RGBAColor

			cl.R = uint8(r)
			cl.G = uint8(g)
			cl.B = uint8(b)
			cl.A = 255

			img.Pix[y*img.Stride+x] = cl

			SX += DX
		}
		SY += DY * float64(ThreadCount)
	}

	c <- ThreadId
}