481 lines
13 KiB
Plaintext
481 lines
13 KiB
Plaintext
var prosperon = {}
|
|
|
|
var os = use('os');
|
|
var io = use('io');
|
|
var rasterize = use('rasterize');
|
|
var time = use('time')
|
|
var tilemap = use('tilemap')
|
|
var geometry = use('geometry')
|
|
var res = use('resources')
|
|
|
|
var video = arg[0]
|
|
var graphics = use('graphics', arg[0])
|
|
|
|
var camera = {}
|
|
|
|
function updateCameraMatrix(cam) {
|
|
def win_w = logical.width
|
|
def win_h = logical.height
|
|
def view_w = (cam.size?.[0] ?? win_w) / cam.zoom
|
|
def view_h = (cam.size?.[1] ?? win_h) / cam.zoom
|
|
|
|
def ox = cam.pos[0] - view_w * (cam.anchor?.[0] ?? 0)
|
|
def oy = cam.pos[1] - view_h * (cam.anchor?.[1] ?? 0)
|
|
|
|
def vx = (cam.viewport?.x ?? 0) * win_w
|
|
def vy = (cam.viewport?.y ?? 0) * win_h
|
|
def vw = (cam.viewport?.width ?? 1) * win_w
|
|
def vh = (cam.viewport?.height ?? 1) * win_h
|
|
|
|
def sx = vw / view_w
|
|
def sy = vh / view_h // flip-Y later
|
|
|
|
/* affine matrix that SDL wants (Y going down) */
|
|
cam.a = sx
|
|
cam.c = vx - sx * ox
|
|
cam.e = -sy // <-- minus = flip Y
|
|
cam.f = vy + vh + sy * oy
|
|
|
|
/* convenience inverses */
|
|
cam.ia = 1 / cam.a
|
|
cam.ic = -cam.c / cam.a
|
|
cam.ie = 1 / cam.e
|
|
cam.if = -cam.f / cam.e
|
|
|
|
camera = cam
|
|
}
|
|
|
|
//---- forward transform ----
|
|
function worldToScreenPoint([x,y], camera) {
|
|
return {
|
|
x: camera.a * x + camera.c,
|
|
y: camera.e * y + camera.f
|
|
};
|
|
}
|
|
|
|
//---- inverse transform ----
|
|
function screenToWorldPoint(pos, camera) {
|
|
return {
|
|
x: camera.ia * pos[0] + camera.ic,
|
|
y: camera.ie * pos[1] + camera.if
|
|
};
|
|
}
|
|
|
|
//---- rectangle (two corner) ----
|
|
function worldToScreenRect({x,y,width,height}, camera) {
|
|
// map bottom-left and top-right
|
|
def x1 = camera.a * x + camera.c;
|
|
def y1 = camera.e * y + camera.f;
|
|
def x2 = camera.a * (x + width) + camera.c;
|
|
def y2 = camera.e * (y + height) + camera.f;
|
|
|
|
return {
|
|
x:Math.min(x1,x2),
|
|
y:Math.min(y1,y2),
|
|
width:Math.abs(x2-x1),
|
|
height:Math.abs(y2-y1)
|
|
}
|
|
}
|
|
|
|
var gameactor
|
|
|
|
var images = {}
|
|
|
|
var renderer_commands = []
|
|
|
|
var win_size = {width:500,height:500}
|
|
var logical = {width:500,height:500}
|
|
|
|
// Convert high-level draw commands to low-level renderer commands
|
|
function translate_draw_commands(commands) {
|
|
if (!graphics) return
|
|
|
|
renderer_commands.length = 0
|
|
|
|
commands.forEach(function(cmd) {
|
|
if (cmd.material && cmd.material.color) {
|
|
renderer_commands.push({
|
|
op: "set",
|
|
prop: "drawColor",
|
|
value: cmd.material.color
|
|
})
|
|
}
|
|
switch(cmd.cmd) {
|
|
case "camera":
|
|
updateCameraMatrix(cmd.camera, win_size.width, win_size.height)
|
|
break
|
|
|
|
case "draw_rect":
|
|
cmd.rect = worldToScreenRect(cmd.rect, camera)
|
|
// Handle rectangles with optional rounding and thickness
|
|
if (cmd.opt && cmd.opt.radius && cmd.opt.radius > 0) {
|
|
// Rounded rectangle
|
|
var thickness = (cmd.opt.thickness == 0) ? 0 : (cmd.opt.thickness || 1)
|
|
var raster_result = rasterize.round_rect(cmd.rect, cmd.opt.radius, thickness)
|
|
|
|
if (raster_result.type == 'rect') {
|
|
renderer_commands.push({
|
|
op: "fillRect",
|
|
data: {rect: raster_result.data}
|
|
})
|
|
} else if (raster_result.type == 'rects') {
|
|
raster_result.data.forEach(function(rect) {
|
|
renderer_commands.push({
|
|
op: "fillRect",
|
|
data: {rect: rect}
|
|
})
|
|
})
|
|
}
|
|
} else if (cmd.opt && cmd.opt.thickness && cmd.opt.thickness > 0) {
|
|
// Outlined rectangle
|
|
var raster_result = rasterize.outline_rect(cmd.rect, cmd.opt.thickness)
|
|
|
|
if (raster_result.type == 'rect') {
|
|
renderer_commands.push({
|
|
op: "fillRect",
|
|
data: {rect: raster_result.data}
|
|
})
|
|
} else if (raster_result.type == 'rects') {
|
|
renderer_commands.push({
|
|
op: "rects",
|
|
data: {rects: raster_result.data}
|
|
})
|
|
}
|
|
} else {
|
|
renderer_commands.push({
|
|
op: "fillRect",
|
|
data: {rect: cmd.rect}
|
|
})
|
|
}
|
|
break
|
|
|
|
case "draw_circle":
|
|
case "draw_ellipse":
|
|
cmd.pos = worldToScreenPoint(cmd.pos, camera)
|
|
// Rasterize ellipse to points or rects
|
|
var radii = cmd.radii || [cmd.radius, cmd.radius]
|
|
var raster_result = rasterize.ellipse(cmd.pos, radii, cmd.opt || {})
|
|
|
|
if (raster_result.type == 'points') {
|
|
renderer_commands.push({
|
|
op: "point",
|
|
data: {points: raster_result.data}
|
|
})
|
|
} else if (raster_result.type == 'rects') {
|
|
// Use 'rects' operation for multiple rectangles
|
|
renderer_commands.push({
|
|
op: "rects",
|
|
data: {rects: raster_result.data}
|
|
})
|
|
}
|
|
break
|
|
|
|
case "draw_line":
|
|
renderer_commands.push({
|
|
op: "line",
|
|
data: {points: cmd.points.map(p => {
|
|
var pt = worldToScreenPoint(p, camera)
|
|
return [pt.x, pt.y]
|
|
})}
|
|
})
|
|
break
|
|
|
|
case "draw_point":
|
|
cmd.pos = worldToScreenPoint(cmd.pos, camera)
|
|
renderer_commands.push({
|
|
op: "point",
|
|
data: {points: [cmd.pos]}
|
|
})
|
|
break
|
|
|
|
case "draw_image":
|
|
var img = graphics.texture(cmd.image)
|
|
var gpu = img.gpu
|
|
if (!gpu) break
|
|
|
|
if (!cmd.scale) cmd.scale = {x:1,y:1}
|
|
cmd.rect.width ??= img.width
|
|
cmd.rect.height ??= img.height
|
|
cmd.rect.width = cmd.rect.width * cmd.scale.x
|
|
cmd.rect.height = cmd.rect.height * cmd.scale.y
|
|
cmd.rect = worldToScreenRect(cmd.rect, camera)
|
|
|
|
renderer_commands.push({
|
|
op: "texture",
|
|
data: {
|
|
texture_id: gpu,
|
|
dst: cmd.rect,
|
|
src: img.rect
|
|
}
|
|
})
|
|
|
|
break
|
|
|
|
case "draw_text":
|
|
if (!cmd.text) break
|
|
if (!cmd.pos) break
|
|
|
|
// Get font from the font string (e.g., "smalle.16")
|
|
var font = graphics.get_font(cmd.font)
|
|
if (!font || !font.texture || !font.texture.id) break
|
|
|
|
// Create text geometry buffer
|
|
var text_mesh = graphics.make_text_buffer(
|
|
cmd.text,
|
|
{x: cmd.pos.x, y: cmd.pos.y},
|
|
[cmd.material.color.r, cmd.material.color.g, cmd.material.color.b, cmd.material.color.a],
|
|
cmd.wrap || 0,
|
|
font
|
|
)
|
|
|
|
if (!text_mesh) break
|
|
|
|
if (text_mesh.xy.length == 0) break
|
|
|
|
// Transform XY coordinates using camera matrix
|
|
var camera_params = [camera.a, camera.c, camera.e, camera.f]
|
|
var transformed_xy = geometry.transform_xy_blob(text_mesh.xy, camera_params)
|
|
|
|
// Create transformed geometry object
|
|
var transformed_geom = {
|
|
xy: transformed_xy,
|
|
xy_stride: text_mesh.xy_stride,
|
|
uv: text_mesh.uv,
|
|
uv_stride: text_mesh.uv_stride,
|
|
color: text_mesh.color,
|
|
color_stride: text_mesh.color_stride,
|
|
indices: text_mesh.indices,
|
|
num_vertices: text_mesh.num_vertices,
|
|
num_indices: text_mesh.num_indices,
|
|
size_indices: text_mesh.size_indices,
|
|
texture_id: font.texture.id
|
|
}
|
|
|
|
renderer_commands.push({
|
|
op: "geometry_raw",
|
|
data: transformed_geom
|
|
})
|
|
break
|
|
|
|
case "draw_slice9":
|
|
var img = graphics.texture(cmd.image)
|
|
var gpu = img.gpu
|
|
if (!gpu) break
|
|
|
|
cmd.rect = worldToScreenRect(cmd.rect, camera)
|
|
|
|
renderer_commands.push({
|
|
op: "texture9Grid",
|
|
data: {
|
|
texture_id: gpu,
|
|
src: img.rect,
|
|
leftWidth: cmd.slice,
|
|
rightWidth: cmd.slice,
|
|
topHeight: cmd.slice,
|
|
bottomHeight: cmd.slice,
|
|
scale: 1.0,
|
|
dst: cmd.rect
|
|
}
|
|
})
|
|
break
|
|
|
|
case "tilemap":
|
|
// Get cached geometry commands from tilemap
|
|
var geometryCommands = cmd.tilemap.draw()
|
|
|
|
// Process each geometry command (one per texture)
|
|
for (var geomCmd of geometryCommands) {
|
|
var img = graphics.texture(geomCmd.image)
|
|
var gpu = img.gpu
|
|
if (!gpu) continue
|
|
|
|
// Transform geometry through camera and send to renderer
|
|
var geom = geomCmd.geometry
|
|
|
|
// Transform XY coordinates using camera matrix
|
|
var camera_params = [camera.a, camera.c, camera.e, camera.f]
|
|
var transformed_xy = geometry.transform_xy_blob(geom.xy, camera_params)
|
|
|
|
// Create new geometry object with transformed coordinates
|
|
var transformed_geom = {
|
|
xy: transformed_xy,
|
|
xy_stride: geom.xy_stride,
|
|
uv: geom.uv,
|
|
uv_stride: geom.uv_stride,
|
|
color: geom.color,
|
|
color_stride: geom.color_stride,
|
|
indices: geom.indices,
|
|
num_vertices: geom.num_vertices,
|
|
num_indices: geom.num_indices,
|
|
size_indices: geom.size_indices,
|
|
texture_id: gpu
|
|
}
|
|
|
|
renderer_commands.push({
|
|
op: "geometry_raw",
|
|
data: transformed_geom
|
|
})
|
|
}
|
|
break
|
|
|
|
case "geometry":
|
|
var texture_id
|
|
if (cmd.texture_id) {
|
|
// Use the provided texture ID directly
|
|
texture_id = cmd.texture_id
|
|
} else {
|
|
// Fall back to looking up by image path
|
|
var img = graphics.texture(cmd.image)
|
|
var gpu = img.gpu
|
|
if (!gpu) break
|
|
texture_id = gpu
|
|
}
|
|
|
|
// Transform geometry through camera and send to renderer
|
|
var geom = cmd.geometry
|
|
|
|
// Transform XY coordinates using camera matrix
|
|
var camera_params = [camera.a, camera.c, camera.e, camera.f]
|
|
var transformed_xy = geometry.transform_xy_blob(geom.xy, camera_params)
|
|
|
|
// Create new geometry object with transformed coordinates
|
|
var transformed_geom = {
|
|
xy: transformed_xy,
|
|
xy_stride: geom.xy_stride,
|
|
uv: geom.uv,
|
|
uv_stride: geom.uv_stride,
|
|
color: geom.color,
|
|
color_stride: geom.color_stride,
|
|
indices: geom.indices,
|
|
num_vertices: geom.num_vertices,
|
|
num_indices: geom.num_indices,
|
|
size_indices: geom.size_indices,
|
|
texture_id: texture_id
|
|
}
|
|
|
|
renderer_commands.push({
|
|
op: "geometry_raw",
|
|
data: transformed_geom
|
|
})
|
|
break
|
|
}
|
|
})
|
|
|
|
return renderer_commands
|
|
}
|
|
|
|
///// input /////
|
|
var input = use('input')
|
|
var input_cb
|
|
var input_rate = 1/60
|
|
function poll_input() {
|
|
send(video, {kind:'input', op:'get'}, evs => {
|
|
for (var ev of evs) {
|
|
if (ev.type == 'window_pixel_size_changed') {
|
|
win_size.width = ev.width
|
|
win_size.height = ev.height
|
|
}
|
|
|
|
if (ev.type == 'quit')
|
|
$_.stop()
|
|
|
|
if (ev.type.includes('key')) {
|
|
if (ev.key)
|
|
ev.key = input.keyname(ev.key)
|
|
}
|
|
|
|
if (ev.type.startsWith('mouse_'))
|
|
ev.pos.y = -ev.pos.y + logical.height
|
|
}
|
|
|
|
input_cb(evs)
|
|
})
|
|
$_.delay(poll_input, input_rate)
|
|
}
|
|
|
|
prosperon.input = function(fn)
|
|
{
|
|
input_cb = fn
|
|
poll_input()
|
|
}
|
|
|
|
// 2) helper to build & send a batch, then call done()
|
|
prosperon.create_batch = function create_batch(draw_cmds, done) {
|
|
def batch = [
|
|
{op:'set', prop:'drawColor', value:{r:0.1,g:0.1,b:0.15,a:1}},
|
|
{op:'clear'}
|
|
]
|
|
if (draw_cmds && draw_cmds.length)
|
|
batch.push(...translate_draw_commands(draw_cmds))
|
|
|
|
batch.push(
|
|
{op:'set', prop:'drawColor', value:{r:1,g:1,b:1,a:1}},
|
|
{op:'imgui_render'},
|
|
{op:'present'}
|
|
)
|
|
|
|
send(video, {kind:'renderer', op:'batch', data:batch}, done)
|
|
}
|
|
|
|
////////// dmon hot reload ////////
|
|
function poll_file_changes() {
|
|
dmon.poll(e => {
|
|
if (e.action == 'modify' || e.action == 'create') {
|
|
// Check if it's an image file
|
|
var ext = e.file.split('.').pop().toLowerCase()
|
|
var imageExts = ['png', 'jpg', 'jpeg', 'gif', 'bmp', 'tga', 'webp', 'qoi', 'ase', 'aseprite']
|
|
|
|
if (imageExts.includes(ext)) {
|
|
// Try to find the full path for this image
|
|
var possiblePaths = [
|
|
e.file,
|
|
e.root + e.file,
|
|
res.find_image(e.file.split('/').pop().split('.')[0])
|
|
].filter(p => p)
|
|
|
|
for (var path of possiblePaths) {
|
|
graphics.tex_hotreload(path)
|
|
}
|
|
}
|
|
}
|
|
})
|
|
|
|
// Schedule next poll in 0.5 seconds
|
|
$_.delay(poll_file_changes, 0.5)
|
|
}
|
|
|
|
var dmon = use('dmon')
|
|
prosperon.dmon = function()
|
|
{
|
|
dmon.watch('.')
|
|
poll_file_changes()
|
|
}
|
|
|
|
var window_cmds = {
|
|
size(size) {
|
|
send(video, {kind: 'window', op:'set', data: {property: 'size', value: size}})
|
|
},
|
|
}
|
|
|
|
prosperon.set_window = function(config)
|
|
{
|
|
for (var c in config)
|
|
if (window_cmds[c]) window_cmds[c](config[c])
|
|
}
|
|
|
|
var renderer_cmds = {
|
|
resolution(e) {
|
|
logical.width = e.width
|
|
logical.height = e.height
|
|
send(video, {kind:"renderer", op:'set', prop:'logicalPresentation', value: {...e}})
|
|
}
|
|
}
|
|
|
|
prosperon.set_renderer = function(config)
|
|
{
|
|
for (var c in config)
|
|
if (renderer_cmds[c]) renderer_cmds[c](config[c])
|
|
}
|
|
|
|
return prosperon
|