abledbody [Lexaloffle Blog Feed]

Rainbow Tylenol

Sun, 22 Jun 2025 23:41:04 UTC

A cover of Kitsune^2's Rainbow Tylenol for Picotron.

rainbow_tylenol

by abledbody

[Click to Play]

Abledbody's External Development Template

Wed, 21 May 2025 19:10:49 UTC

Repository: https://github.com/abledbody/picotron-external-template
Direct download: https://github.com/abledbody/picotron-external-template/archive/refs/heads/main.zip

How to use

Copy this directory to wherever you want the project to be.
Rename the directory and template.p64 to match the name of the project.
Open template.p64/main.lua and...
- Change this line: cd("/projects/template") to point at the directory of your project, keeping the leading slash.
- Change this line: DATP = "template.p64/" to match the name of the cartridge, keeping the trailing slash.

If you're using Visual Studio Code and would like to use LuaCATS definitions for Picotron, you can either put them in C:\lualib\picotron-definitions, or you can edit settings.json to point to the directory of your choice. I personally recommend cloning Rayquaza01's definition files, but bear in mind that at time of writing, there are no fully complete and accurate definitions for Picotron, and Picotron itself is still in active development, so you may occasionally see warnings for things that are actually valid in Picotron.

Important stuff

The entry point for your project's code is src/main.lua, rather than template.p64/main.lua. All scripts go into src/ so that they are unaffected by Picotron's metadata management, and can live outside of ram/cart so that iterating on them does not require loading the cartridge more than once. When you are ready to distribute the cartridge, all you need to do is make sure there is a copy of your src directory at the root of the cartridge in ram/cart before you save or export it.

Whenever you want to refer to a file that lives in the cartridge, use DATP.. as a prefix, such as fetch(DATP.."gfx/0.gfx"). This is because the working directory is different depending on where your src directory is. If src is at the root of the cartridge, the working directory will be ram/cart. Otherwise, it will be whatever you set it to in main.lua. DATP compensates for this by always pointing to the cartridge root.

Trivia

This template is designed to be used with Sumneko's Lua language server extension for VSCode, and the Lua Comments And Type System (LuaCATS) annotations it provides.

This template comes with:

Kira's Error Explorer (with thanks), because I find it invaluable, since as of 0.2.0d, Picotron's error handling is garbage.
A require function, to work around how the lua language server does not recognize Picotron's include function. It's also just nicer for dependency management than include.

Picotron-specific operators such as a \ b, a ..= b, and ?x are completely unrecognized by the Lua language server, and so will show errors, even if Picotron itself recognizes them. Each has a simple substitute. a // b, a = a .. b, and print(x), respectively. One-line if statements such as if (x) print(y) are also unrecognized.

The ruler setting in .vscode/settings.json indicates where the horizontal boundary of the code.p64 app is when using its monospace font, in case that's something you care about.

Scrub: That animation tool

Thu, 10 Apr 2025 05:21:10 UTC

Scrub is an animation data editor which allows you to make and preview .anm files.

load #scrub

scrub

by abledbody

[Click to Play]

File format

The .anm file format consists of a table with string keys and values containing animations. Each animation contains string keys with arrays of data, each the same length. The only required key in an animation is duration, which is a series of numbers indicating the amount of time it takes for each frame to elapse. There is an optional events key, where the values are a dictionary of strings keys and arbitrary values, representing each event that occurs at the start of its respective frame.

Within the Scrub cart, the script src/animation.lua contains everything you need to play the animations in the .anm files in your own projects.

Features

Scrub will automatically detect the properties sprite and pivot, and will show a sprite in the viewport that reflects them.

Scrub supports properties and events with values that are:

numbers, such as 3.5
userdata vectors, such as (3.5,8)
strings, such as foo
booleans, written as true or false
nil, written as nil (properties only)

Scrub supports custom palettes in the same format that OkPal uses.

Hotkeys

Space - Play
Left - Select last frame
Right - Select next frame
Insert - Insert a new frame
Delete - Delete selected frames
Shift+Click - Frame multi-select

Planned features

Allow previewing sprites from files other than 0.gfx
Automatic sprite sequences
Show 2D vectors, and be able to edit them and the pivot in the viewport
Undo
Buttons on the transport for last frame, next frame, start, end, and playback speed
Specify which properties are the sprite/pivot
Show multiple sprites on the same frame

Known bugs

None at the moment.

Changelog

v2

Added frame events

v1.1

Fixed spaces being added when you click on properties
Fixed program crashing when it can't find ram/cart/gfx/gfx.0 (probably)
Fixed left/right hotkeys causing the properties window to lag behind the selection
Added support for boolean properties
Added whitespace tolerance for all non-string property values

Advanced f64 userdata arithmetic (0.1.1D)

Tue, 24 Dec 2024 08:42:42 UTC

f64 userdatas have the following arithmetic operations:
add, sub, mul, div, mod, min, max, idiv
We can create a few additional useful operations using just these.

local function ud_floor(x) return x-x:mod(1) end
local function ud_floor(x) return x:idiv(1) end -- Alternative. Faster for userdatas smaller than ~270 elements.
local function ud_round(x)
  x += 0.5
  return x-x:mod(1)
end
local function ud_ceil(x) return (0-x):mod(1)-x end
local function ud_abs(x) return x:max(0-x) end
local function ud_sign(x) return x/(x:max(0-x)) end -- Not zero-safe.
local function ud_positive(x) return x:max(0)/x end -- Not zero-safe.
local function ud_negative(x) return x:min(0)/x end -- Not zero-safe.
local function ud_tern(c,a,b) return a*c+b*(1-c) end

Here are some other useful userdata math tricks:

local function sum(x)
  return vec(0):add(x,true,0,0,1,1,0,#x)[0]
end
local function prod(x)
  return vec(1):mul(x,true,0,0,1,1,0,#x)[0]
end

-- If you have a matrix with a vector in each row, and you'd like to get their dot products
-- with a single vector, you can do so like this:
local function dot_all(v,m)
  return m:matmul(v:transpose())
end

-- luchak discovered this prefix sum operation.
local function psum(v)
  return v:add(v,true,0,1,1,1,1,#v-1)
end
-- which is useful for creating a linear sequence with a specific slope.
-- v[n] = init+n*step
local function linstep(v,init,step)
  return v:copy(step,true):copy(init,true,0,0,1):add(v,true,0,1,1,1,1,#v-1)
end

Sphere Impostor Demo

Wed, 11 Dec 2024 10:02:58 UTC

It's like a circle, but in three dimensions, but without the third dimension.

sphere_impostor

by abledbody

[Click to Play]

Blade3D Teapot Demo

Thu, 05 Sep 2024 19:16:08 UTC

I made this demo to quickly demonstrate how to use Blade3D, a 3D rendering API I'm working on. It doesn't make full use of the API, but it does give you a starting point if you want to make your own projects using (this version of) Blade3D. Hopefully I can make a slightly more comprehensive introduction to the API with full documentation in the near future, but for anyone willing to look at the underlying code, it should be pretty easy to accomplish whatever you need with just this template.

b3d_teapot

by abledbody

[Click to Play]

Something that isn't included in the template is a .obj to .ptm converter, which is provided here. It expects the .obj to include material references (not the .mtl file itself) and for the mesh to be triangulated.

--[[pod_format="raw",created="2024-06-23 21:43:33",modified="2024-07-03 20:32:21",revision=46]]
local path = env().argv[1]
local output_path = string.sub(path,1,string.find(path,".obj$")).."ptm"

local material_lookup = {}

local material = nil

local obj = {
	v = {},
	vt = {},
	vp = {},
	f = {},
}

-- Each element in an obj starts with an identifier.
-- We can use this identifier to determine how to interpret
-- the rest of the line.
local interps = {
	v = function(ln)
		add(obj.v,vec(ln[2],ln[3],ln[4],1))
	end,
	vt = function(ln)
		add(obj.vt,vec(ln[2],ln[3]))
	end,
	vp = function(ln)
		add(obj.vp,vec(ln[2],ln[3],ln[4]))
	end,
	usemtl = function(ln)
		material = ln[2]
	end,
	f = function(ln)
		local f = {}
		if material_lookup[material] then
			f.mat_index = material_lookup[material]
		else
			add(material_lookup,material)
			material_lookup[material] = #material_lookup
			f.mat_index = #material_lookup
		end

		for i = #ln,2,-1 do
			local indices = split(ln[i],"/")
			local v = {}

			v.v = indices[1]
			if indices[2] ~= "" then v.vt = indices[2] end
			v.vn = indices[3]

			add(f,v)
		end

		add(obj.f,f)
	end,
}

for l in all(split(fetch(path),"\n")) do
	local tokens = split(l," ")
	local interpreter = interps[tokens[1] ]
	if interpreter then interpreter(tokens) end
end

local pts = userdata("f64",4,#obj.v)
for i = 1,#obj.v do
	local v = obj.v[i]
	pts:set(0,i-1,v[0],v[1],v[2],v[3])
end

local uvs = userdata("f64",2,#obj.vt)
for i = 1,#obj.vt do
	local vt = obj.vt[i]
	uvs:set(0,i-1,vt[0],1-vt[1]) -- Top to bottom instead of bottom to top.
end

local materials = {}
for i = 1,#material_lookup do
	add(materials,material_lookup[i])
end

local pt_indices = userdata("i32",3,#obj.f)
local uv_indices = userdata("i32",3,#obj.f)
local material_indices = userdata("i32",#obj.f)

for i = 1,#obj.f do
	local face = obj.f[i]
	material_indices[i-1] = face.mat_index
	local v1,v2,v3 = face[1],face[2],face[3]

	-- Subtract 1 from each index to convert to 0-based.
	pt_indices:set(0,i-1,v1.v-1,v2.v-1,v3.v-1)
	uv_indices:set(0,i-1,v1.vt-1,v2.vt-1,v3.vt-1)
end

local output = {
	pts = pts,
	uvs = uvs,
	materials = materials,

	pt_indices = pt_indices,
	uv_indices = uv_indices,
	material_indices = material_indices,
}

local icon = userdata("u8",16,16,"000000000000010101010000000000000000000000010707070701000000000000000000010707070101070100000000000000010707070107070107010000000000010707070707010701070701000000010d0707010107070107070706010000010d0701070101070707070706010000010d0d07070701070707070606010000010d0d0d070107070707060606010000010d0d0d0d0707070706060606010000010d0d0d0d0d0606060606060601000000010d0d0d0d0d0606060606010000000000010d0d0d0d060606060100000000000000010d0d0d06060601000000000000000000010d0d060601000000000000000000000001010101000000000000")

store(output_path,pod(output,0b111),{icon = icon})

abledbody's instrument pack 2

Sat, 24 Aug 2024 02:12:15 UTC

An additional 32 synthesized instruments for your composing pleasure.
#able_ipack_02

Available under the Creative Commons 0 license.

If you've got requests for the next instrument pack, let me know!

Second order dynamics demo

Tue, 16 Jul 2024 00:36:42 UTC

Arrow keys to edit the variables.
Click (and hold, if you like,) to set the target position.

sod_demo

by abledbody

[Click to Play]

If you're just interested in the API, you can grab it here:

Sort Our Ship

Fri, 17 May 2024 03:02:05 UTC

A clone of The Sound of Sorting I made just to test and diagnose my QuickSort algorithm.
It may sound a little ridiculous on web, since the array access sounds tend to get lumped together into far fewer frames.

Press z to step
Hold z to disable step mode
Press x to switch sorting algorithm
Use up and down to control the number of entries.
Use left and right to control the speed.

sort_our_ship

by abledbody

[Click to Play]

The Lab Grows prototype

Wed, 01 May 2024 00:41:11 UTC

The response to this has been pretty positive, so I'm throwing this demo up here on the forums.
This cart is a prototype for a point and click adventure with pre-rendered 3D graphics and a custom palette.

the_lab_grows

by abledbody

[Click to Play]

Included in this cart are elgopher's require module and snowkittykira's error explorer module

abledbody's instrument pack 1

Fri, 26 Apr 2024 21:42:19 UTC

32 synthesized instruments for your composing pleasure.

#able_ipack_01

Available under the Creative Commons 0 license.

If you've got requests for the next instrument pack, let me know!

00 - Wist
01 - Industrial Guitar
02 - Bell
03 - Industrial Bass
04 - Farout
05 - Closed Hat
06 - Open Hat
07 - Retro Snare
08 - Flat Kick
09 - Dial
10 - Glass Piano
11 - Flute
12 - Vibran
13 - Horn
14 - Grind Pad
15 - Smack Tom
16 - State Approved
17 - Disturbation
18 - Acoustic Snare
19 - Sweep Bass
20 - Bell 2
21 - Tropic Pan
22 - Funky Bass
23 - Crack
24 - Steel Guitar
25 - Saxophone
26 - Anchor
27 - Undercurrent Pad
28 - Sidestick
29 - Pop Bass
30 - Everywhere
31 - True Synth

able's ECS framework

Sat, 13 Apr 2024 04:37:05 UTC

I made it as easy to use and as performant as I could. You certainly won't be getting the performance boost normally associated with an ECS, since that particular optimization doesn't exist in picotron, but you'll still get the architecture.

Here's a demo which showcases its use.

able_ecs

by abledbody

[Click to Play]

You can find the latest version and the documentation on github.
https://github.com/abledbody/picotron-ECS-framework/releases/
https://github.com/abledbody/picotron-ECS-framework/blob/main/README.md

abledbody's Profiler

Fri, 12 Apr 2024 04:30:18 UTC

Does what it says on the tin. Lets you see what's eating up your CPU time. If you make an extension to this, I'd love to see it.

API:

profile.enabled(detailed,cpu) Turns on and off profiling tools.
detailed: Whether or not to display results of profile calls.
cpu: Whether or not to display total CPU usage.

profile(name,linger) Starts or stops a profile. Accumulates between profile.draw calls. Extremely cheap when profiling is disabled.
name: Arbitrary display name indicating which profile to start or stop.
linger: Whether or not the profile should linger even if the profile is never called between draws.

profile.draw() Draws profile and CPU information to the screen if they are enabled. Extremely cheap when profiling is disabled.

profile.clear_lingers() Clears any lingering profile information.

Example:

include("profiler.lua")

profile.enabled(true,true)

local frames = 0

function _update()
  profile("_update")
  frames = frames+1
  profile("_update")
end

function _draw()
  profile("_draw")
  if frames%2 == 0 then
    profile("displaying frame count",true)
    print(frames,80,0,7)
    profile("displaying frame count",true)
  end
  profile.draw()
  profile("_draw")
end

Full script:

--[[pod_format="raw",created="2024-04-09 22:52:04",modified="2024-04-11 17:26:16",revision=1003]]
-- abledbody's profiler v1.1

local function do_nothing() end

-- The metatable here is to make profile() possible.
-- Why use a table at all? Because otherwise lua will try to cache the function call,
-- which by default is do_nothing.
local profile_meta = {__call = do_nothing}
profile = {draw = do_nothing}
setmetatable(profile,profile_meta)

local running = {} -- All incomplete profiles
 -- All complete profiles. Note that if the profiles haven't been drawn yet, it will
 -- not be cleared, and further profiles of the same name will add to the usage metric.
local profiles = {}
-- All completed lingering profiles. These are never automatically cleared.
local lingers = {}

-- start_profile, stop_profile, and stop_linger are all internal functions,
-- serving as paths for _profile to take. Lingers share start_profile.
local function start_profile(name,linger)
	local source = profiles[name]
	running[name] = {
		linger = linger,
	}
	local active = running[name]
	active.start = stat(1) --Delaying CPU usage grab until the last possible second.
end

local function stop_profile(name,active,delta)
	local profile = profiles[name]
	if profile then
		profile.time = delta+profile.time
	else
		profiles[name] = {
			time = delta,
			name = name,
		}
		add(profiles,profiles[name])
	end
end

local function stop_linger(name,active,delta)
	local profile = lingers[name]
	if profile then
		profile.time = profile.this_frame and delta+profile.time or delta
		profile.this_frame = true
	else
		lingers[name] = {
			time = delta,
			this_frame = true,
		}
	end
end

-- The main functionality lives here.
-- Takes in the name of what you're profiling, and whether or not to
-- make the profile linger.
local function _profile(_,name,linger)
	local t = stat(1)
	local active = running[name]
	if active then
		local delta = t-active.start

		if active.linger then stop_linger(name,active,delta)
		else stop_profile(name,active,delta) end

		running[name] = nil
	else
		start_profile(name,linger)
	end
end

-- Clears all lingering profiles.
function profile.clear_lingers()
	lingers = {}
end

local function draw_cpu()
	print("cpu:"..string.sub(stat(1)*100,1,5).."%",1,1,7)
end

-- This draws the profiles, and then resets everything for the next frame.
-- If it is not called, usage metrics will accumulate.
-- Lingering profiles are always displayed after persistent profiles.
local function display_profiles()
	local i = 1
	for prof in all(profiles) do
		local usage = string.sub(prof.time*100,1,5).."%"
		local to_print = prof.name..":"..usage
		print(to_print,1,1+i*9,7)
		i = i+1
	end
	for name,prof in pairs(lingers) do
		local usage = string.sub(prof.time*100,1,5).."%"
		local to_print = name..(prof.this_frame and "[X]:" or "[ ]:")..usage
		print(to_print,1,1+i*9,7)
		prof.this_frame = false
		i = i+1
	end
	profiles = {}
end

local function display_both()
	draw_cpu()
	display_profiles()
end

-- This swaps out function calls depending on whether or not you want to have
-- profiling. This is to make it as much as possible so that you don't have to
-- think about cleaning up profile calls for efficiency.
-- The first boolean is for detailed profiling, the second is for CPU usage.
function profile.enabled(detailed,cpu)
	profile_meta.__call = detailed and _profile or do_nothing
	profile.draw = detailed and (cpu and display_both or display_profiles)
		or (cpu and draw_cpu or do_nothing)
end