v0.0.1

Author: sammy-ette

.gitignore

@@ -0,0 +1,4 @@
+*.ttf
+*.cpp
+*.h
+*.hpp

README.md

@@ -1,2 +1,23 @@
 # Pinwheel
-🍭 An awesome little fantasy computer designed to be simple.
+> 🍭 An awesome little fantasy computer designed to be simple.
+
+Pinwheel is an all new fantasy computer, developed in Go and designed for ease of use and simplicity,
+and highly customizable where applicable (and wanted..!).  
+It is currently in the VERY early prototype-ish stage, and isn't meant for normal use yet.  
+Stay tuned though, I'm spending my entire holiday to work on this little thing as much I can.
+
+# Planned Features 
+- Customizable Palette of 64 COLORS (by program and/or user)
+- Easily scriptable 
+- Simplicity 
+- Joypad, keyboard and mouse input
+
+# Documentation
+## Functions
+**Expected to change A LOT during development.**  
+
+- `Spin()` - Called every CPU cycle  
+
+- `termprint(text)` - Print text to the terminal
+- `vpoke(address, value)` - Write `value` to VRAM `address`
+- `plot(x, y, color)` - Place pixel at `x, y` with palette color number `color`

TODO.md

@@ -0,0 +1,136 @@
+package main
+
+import (
+	"math/rand"
+	"fmt"
+
+	"github.com/veandco/go-sdl2/sdl"
+	//"github.com/veandco/go-sdl2/ttf"
+	"github.com/yuin/gopher-lua"
+)
+
+const version = "v0.0.1"
+const res int = 128 // Resolution of the *screen* ("internal") . Might change later in development. (res x res, 128 x 128)
+const scale = 4 // Resolution scale (contributes to the size of the *window*)
+var palette [][]uint8 = make([][]uint8, 64) // Array of array of RGB values ([[R, G, B], [R, G, B], ...])
+var pixelbuf []byte = make([]byte, res * res * 4) // Pixel backbuffer (basically our VRAM)
+
+func main() {
+	for i := uint8(0); i < 64; i++ {
+		// Generate a palette
+		palette[i] = []uint8{i*4%255, i*4%255, i*4%255}
+	}
+	
+	L := lua.NewState()
+
+	// Load Lua standard library
+	L.OpenLibs()
+	// Register our functions
+	L.SetGlobal("vpoke", L.NewFunction(PWvPoke))
+	L.SetGlobal("plot", L.NewFunction(PWplot))
+	L.SetGlobal("termprint", L.NewFunction(PWtermPrint))
+
+	if err := sdl.Init(sdl.INIT_EVERYTHING); err != nil {
+		panic(err)
+	}
+	defer sdl.Quit()
+
+	wintitle := "Pinwheel " + version
+
+	window, err := sdl.CreateWindow(wintitle, sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, int32(res * scale), int32(res * scale), sdl.WINDOW_SHOWN)
+	if err != nil {
+		panic(err)
+	}
+	defer window.Destroy()
+
+	renderer, err := sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED)
+	if err != nil {
+		panic(err)
+	}
+	defer renderer.Destroy()
+
+	screen, err := renderer.CreateTexture(sdl.PIXELFORMAT_ARGB8888, sdl.TEXTUREACCESS_STREAMING, int32(res), int32(res))
+	if err != nil {
+		panic(err)
+	}
+	defer screen.Destroy()
+
+	if err := L.DoFile("program.lua"); err != nil {
+		panic(err)
+	}
+	defer L.Close()
+
+	// "CPU Cycle," our main loop
+	running := true
+	for running {
+		for event := sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
+			switch event.(type) {
+				case *sdl.QuitEvent:
+					running = false
+					break
+			}
+		}
+
+		renderer.SetDrawColor(0, 0, 0, 0)
+		renderer.Clear()
+
+		// Call the Spin function from Lua
+		if err := L.CallByParam(lua.P{
+			Fn: L.GetGlobal("Spin"),
+			NRet: 0,
+			Protect: true,
+		}); err != nil {
+			panic(err)
+		}
+
+		// Update the screen with our pixel backbuffer
+		screen.Update(nil, pixelbuf, res * 4)
+		renderer.Copy(screen, nil, nil)
+
+		// Flush screen
+		renderer.Present()
+	}
+}
+
+func randf(r int) int {
+	return rand.Intn(r)
+}
+
+// vpoke(addr, val)
+func PWvPoke(L *lua.LState) int {
+	addr := L.ToInt(1)
+	val := L.ToInt(2)
+
+	pixelbuf[addr] = byte(val)
+
+	return 1
+}
+
+// plot(x, y, color)
+func PWplot(L *lua.LState) int {
+	x := L.ToInt(1)
+	y := L.ToInt(2)
+	color := L.ToInt(3)
+
+	c := palette[color]
+	setpixel(x, y, int(c[0]), int(c[0]), int(c[0]))
+
+	return 1
+}
+
+// termprint(text)
+func PWtermPrint(L *lua.LState) int {
+	text := L.ToString(1)
+
+	fmt.Println(text)
+
+	return 1
+}
+
+func setpixel(x, y, r, g, b int) {
+	offset := ( res * 4 * y ) + x * 4;
+	pixelbuf[offset + 0] = byte(b)
+	pixelbuf[offset + 1] = byte(g)
+	pixelbuf[offset + 2] = byte(r)
+	pixelbuf[offset + 3] = sdl.ALPHA_OPAQUE;
+}

main.go

@@ -0,0 +1,17 @@
+function Spin()
+	--[[for i = 1000, 0, -1 do
+		x = math.random(127)
+		y = math.random(127)
+
+		offset = ( 128 * 4 * y ) + x * 4
+		vpoke(offset + 0, math.random(255))
+		vpoke(offset + 1, math.random(255))
+		vpoke(offset + 2, math.random(255))
+		vpoke(offset + 3, 255)
+	end]]--
+	-- Ignore above, pixel noise for initial testing
+
+	for i = 128, 0, -1 do
+		plot(i, 64, i % 64)
+	end
+end