abledbody [Lexaloffle Blog Feed]

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.

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("f64",3,#obj.f)
local uv_indices = userdata("f64",3,#obj.f)
local material_indices = userdata("f64",#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

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

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

Instrument names:

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