410 lines
18 KiB
Text
410 lines
18 KiB
Text
# ============================================================================
|
|
# atlas.ludic — a namespaced spritesheet / atlas API (#81).
|
|
#
|
|
# Sprite loading used to be a bare png_load("assets/sprites/floor0.png") — one
|
|
# file per 16x16 sprite, and no way to load one sheet and address a cell by grid
|
|
# coords or by name. This adds:
|
|
#
|
|
# Sprite.sheet(path, cellw, cellh) -> handle load a sheet, remember its grid
|
|
# Sprite.cell(sheet, col, row) -> id one cell, addressed by grid coords
|
|
# Sprite.cell_span(sheet, col, row, cols, rows) a sprite spanning >1 cell (tall/wide)
|
|
# Sprite.define(name, sheet, col, row) -> id name a cell for later lookup
|
|
# Sprite.named(name) -> id look a named sprite up
|
|
# Sprite.draw(id, x, y) / draw_scaled(id,x,y,sc) blit an atlas sprite
|
|
# Sprite.width(id) / height(id) its pixel size
|
|
# Assets.image(path) -> id a whole file as one sprite
|
|
# Assets.load(path) -> id alias of Assets.image
|
|
# Assets.get(name) -> id alias of Sprite.named
|
|
#
|
|
# It stands on the variable-size image loader in image.ludic (rt_image_load keeps
|
|
# the whole decoded PNG; a cell is a sub-rect of it), so a sprite is NOT restricted
|
|
# to the 16x16 sprite table — a cell (and a multi-cell span) can be any size. Draws
|
|
# go through rt_put_px, so the camera, zoom (#78) and clip all apply, exactly like
|
|
# Screen.sprite. Spliced on demand when a program uses Sprite.sheet / Assets.*.
|
|
# ============================================================================
|
|
|
|
const ATLAS_MAX_SHEET: int = 32
|
|
const ATLAS_MAX_SPR: int = 1024
|
|
const ATLAS_MAX_NAME: int = 512
|
|
|
|
export state RtAtlasState {
|
|
at_sheet_img: words = null # image id per sheet
|
|
at_sheet_cw: words = null # cell width per sheet
|
|
at_sheet_ch: words = null # cell height per sheet
|
|
at_nsheet: int = 0
|
|
at_spr_sheet: words = null # owning sheet per atlas sprite
|
|
at_spr_sx: words = null # source x/y (px) of the sub-rect
|
|
at_spr_sy: words = null
|
|
at_spr_w: words = null # sub-rect width/height (px)
|
|
at_spr_h: words = null
|
|
at_nspr: int = 0
|
|
at_name_str: pointers = null # name per named sprite
|
|
at_name_id: words = null # atlas id per name
|
|
at_nname: int = 0
|
|
at_q_name: pointers = null # name to register the loaded sprite under
|
|
at_q_path: pointers = null # file path to load
|
|
at_q_n: int = 0 # how many enqueued
|
|
at_q_pos: int = 0 # how many loaded so far
|
|
at_q_announced: bool = false
|
|
at_font_name: pointers = null
|
|
at_font_id: words = null
|
|
at_font_n: int = 0
|
|
}
|
|
|
|
|
|
|
|
# #82 — an incremental preload queue: enqueue named image files, then load a
|
|
# bounded number per frame (Assets.pump) so a loading scene stays responsive and
|
|
# a game only enters play once Assets.ready(). Deterministic: the same enqueue +
|
|
# pump order loads the same assets in the same order on every run.
|
|
import "audio.ludic" # the preload queue feeds .wav/.mp3 into the sound bank
|
|
|
|
const ATLAS_MAX_QUEUE: int = 512
|
|
|
|
function atlas_init(rt_atlas_st: mut RtAtlasState) -> void {
|
|
if rt_atlas_st.at_sheet_img != null { return }
|
|
rt_atlas_st.at_sheet_img = words(ATLAS_MAX_SHEET)
|
|
rt_atlas_st.at_sheet_cw = words(ATLAS_MAX_SHEET)
|
|
rt_atlas_st.at_sheet_ch = words(ATLAS_MAX_SHEET)
|
|
rt_atlas_st.at_spr_sheet = words(ATLAS_MAX_SPR)
|
|
rt_atlas_st.at_spr_sx = words(ATLAS_MAX_SPR)
|
|
rt_atlas_st.at_spr_sy = words(ATLAS_MAX_SPR)
|
|
rt_atlas_st.at_spr_w = words(ATLAS_MAX_SPR)
|
|
rt_atlas_st.at_spr_h = words(ATLAS_MAX_SPR)
|
|
rt_atlas_st.at_name_str = pointers(ATLAS_MAX_NAME) # a pointer (8 bytes) per name slot
|
|
rt_atlas_st.at_name_id = words(ATLAS_MAX_NAME)
|
|
rt_atlas_st.at_q_name = pointers(ATLAS_MAX_QUEUE)
|
|
rt_atlas_st.at_q_path = pointers(ATLAS_MAX_QUEUE)
|
|
}
|
|
|
|
# register (name -> atlas id) in the name table so Assets.get / Sprite.named find it.
|
|
function atlas_register_name(rt_atlas_st: mut RtAtlasState, name: pointer, id: int) -> void {
|
|
atlas_init(rt_atlas_st)
|
|
if rt_atlas_st.at_nname >= ATLAS_MAX_NAME { return }
|
|
rt_atlas_st.at_name_str[rt_atlas_st.at_nname] = name
|
|
rt_atlas_st.at_name_id[rt_atlas_st.at_nname] = id
|
|
rt_atlas_st.at_nname += 1
|
|
}
|
|
|
|
# load a spritesheet PNG whose cells are cw x ch px; returns a sheet handle (>= 0).
|
|
function atlas_sheet(rt_atlas_st: mut RtAtlasState, rt_image_st: mut RtImageState, rt_inflate_st: mut RtInflateState, path: pointer, cw: int, ch: int) -> int {
|
|
atlas_init(rt_atlas_st)
|
|
if rt_atlas_st.at_nsheet >= ATLAS_MAX_SHEET { return -1 }
|
|
let img = rt_image_load(rt_image_st, rt_inflate_st, path)
|
|
if img < 0 { return -1 }
|
|
let h = rt_atlas_st.at_nsheet
|
|
rt_atlas_st.at_sheet_img[h] = img
|
|
rt_atlas_st.at_sheet_cw[h] = cw
|
|
rt_atlas_st.at_sheet_ch[h] = ch
|
|
rt_atlas_st.at_nsheet += 1
|
|
return h
|
|
}
|
|
|
|
# register an atlas sprite for a sub-rect (px) of a sheet's image.
|
|
function atlas_make(rt_atlas_st: mut RtAtlasState, sheet: int, sx: int, sy: int, w: int, h: int) -> int {
|
|
atlas_init(rt_atlas_st)
|
|
if rt_atlas_st.at_nspr >= ATLAS_MAX_SPR { return -1 }
|
|
let id = rt_atlas_st.at_nspr
|
|
rt_atlas_st.at_spr_sheet[id] = sheet
|
|
rt_atlas_st.at_spr_sx[id] = sx
|
|
rt_atlas_st.at_spr_sy[id] = sy
|
|
rt_atlas_st.at_spr_w[id] = w
|
|
rt_atlas_st.at_spr_h[id] = h
|
|
rt_atlas_st.at_nspr += 1
|
|
return id
|
|
}
|
|
|
|
# one cell (col, row) of a sheet, addressed by grid coords.
|
|
function atlas_cell(rt_atlas_st: mut RtAtlasState, sheet: int, col: int, row: int) -> int {
|
|
if (sheet < 0) or (sheet >= rt_atlas_st.at_nsheet) { return -1 }
|
|
let cw = rt_atlas_st.at_sheet_cw[sheet]
|
|
let ch = rt_atlas_st.at_sheet_ch[sheet]
|
|
return atlas_make(rt_atlas_st, sheet, col * cw, row * ch, cw, ch)
|
|
}
|
|
|
|
# a sprite spanning cols x rows cells from (col, row) — some sprites cover more
|
|
# than one cell (a tall character, a wide object).
|
|
function atlas_cell_span(rt_atlas_st: mut RtAtlasState, sheet: int, col: int, row: int, cols: int, rows: int) -> int {
|
|
if (sheet < 0) or (sheet >= rt_atlas_st.at_nsheet) { return -1 }
|
|
let cw = rt_atlas_st.at_sheet_cw[sheet]
|
|
let ch = rt_atlas_st.at_sheet_ch[sheet]
|
|
return atlas_make(rt_atlas_st, sheet, col * cw, row * ch, cols * cw, rows * ch)
|
|
}
|
|
|
|
# name a cell so a game can look it up by name; returns the atlas id.
|
|
function atlas_define(rt_atlas_st: mut RtAtlasState, name: pointer, sheet: int, col: int, row: int) -> int {
|
|
atlas_init(rt_atlas_st)
|
|
let id = atlas_cell(rt_atlas_st, sheet, col, row)
|
|
if id < 0 { return -1 }
|
|
if rt_atlas_st.at_nname < ATLAS_MAX_NAME {
|
|
rt_atlas_st.at_name_str[rt_atlas_st.at_nname] = name
|
|
rt_atlas_st.at_name_id[rt_atlas_st.at_nname] = id
|
|
rt_atlas_st.at_nname += 1
|
|
}
|
|
return id
|
|
}
|
|
|
|
# look up a named sprite's atlas id (names compare by content), or -1.
|
|
function atlas_named(rt_atlas_st: mut RtAtlasState, name: pointer) -> int {
|
|
atlas_init(rt_atlas_st)
|
|
var i = 0
|
|
while i < rt_atlas_st.at_nname {
|
|
if rt_atlas_st.at_name_str[i] == name { return rt_atlas_st.at_name_id[i] }
|
|
i += 1
|
|
}
|
|
return -1
|
|
}
|
|
|
|
# load a whole image file as one atlas sprite (a 1x1 sheet the size of the image).
|
|
function atlas_image(rt_atlas_st: mut RtAtlasState, rt_image_st: mut RtImageState, rt_inflate_st: mut RtInflateState, path: pointer) -> int {
|
|
atlas_init(rt_atlas_st)
|
|
if rt_atlas_st.at_nsheet >= ATLAS_MAX_SHEET { return -1 }
|
|
let img = rt_image_load(rt_image_st, rt_inflate_st, path)
|
|
if img < 0 { return -1 }
|
|
let w = rt_image_st.img_w[img]
|
|
let h = rt_image_st.img_h[img]
|
|
let sh = rt_atlas_st.at_nsheet
|
|
rt_atlas_st.at_sheet_img[sh] = img
|
|
rt_atlas_st.at_sheet_cw[sh] = w
|
|
rt_atlas_st.at_sheet_ch[sh] = h
|
|
rt_atlas_st.at_nsheet += 1
|
|
return atlas_make(rt_atlas_st, sh, 0, 0, w, h)
|
|
}
|
|
|
|
# blit an atlas sprite at (dx, dy) through rt_put_px (camera / zoom / clip apply).
|
|
# Only sufficiently-opaque pixels are drawn (the sprite's transparent border is
|
|
# skipped), matching Screen.sprite.
|
|
function atlas_draw(rt_atlas_st: mut RtAtlasState, rt_core_st: mut RtCoreState, rt_image_st: RtImageState, id: int, dx: int, dy: int) -> void {
|
|
atlas_init(rt_atlas_st)
|
|
if (id < 0) or (id >= rt_atlas_st.at_nspr) { return }
|
|
let sheet = rt_atlas_st.at_spr_sheet[id]
|
|
let img = rt_atlas_st.at_sheet_img[sheet]
|
|
let iw = rt_image_st.img_w[img]
|
|
let ih = rt_image_st.img_h[img]
|
|
let s: words = rt_image_st.img_px[img]
|
|
let sx = rt_atlas_st.at_spr_sx[id]
|
|
let sy = rt_atlas_st.at_spr_sy[id]
|
|
let w = rt_atlas_st.at_spr_w[id]
|
|
let h = rt_atlas_st.at_spr_h[id]
|
|
var y = 0
|
|
while y < h {
|
|
let srcy = sy + y
|
|
if (srcy >= 0) and (srcy < ih) {
|
|
var x = 0
|
|
while x < w {
|
|
let srcx = sx + x
|
|
if (srcx >= 0) and (srcx < iw) {
|
|
let px = s[srcy * iw + srcx]
|
|
if ((px >> 24) & 255) >= 128 { rt_put_px(rt_core_st, dx + x, dy + y, px & 16777215) }
|
|
}
|
|
x += 1
|
|
}
|
|
}
|
|
y += 1
|
|
}
|
|
}
|
|
|
|
# blit an atlas sprite scaled by an integer factor (through rt_fill_rect blocks).
|
|
function atlas_draw_scaled(rt_atlas_st: mut RtAtlasState, rt_core_st: mut RtCoreState, rt_image_st: RtImageState, id: int, dx: int, dy: int, sc: int) -> void {
|
|
atlas_init(rt_atlas_st)
|
|
if (id < 0) or (id >= rt_atlas_st.at_nspr) { return }
|
|
if sc < 1 { return }
|
|
let sheet = rt_atlas_st.at_spr_sheet[id]
|
|
let img = rt_atlas_st.at_sheet_img[sheet]
|
|
let iw = rt_image_st.img_w[img]
|
|
let ih = rt_image_st.img_h[img]
|
|
let s: words = rt_image_st.img_px[img]
|
|
let sx = rt_atlas_st.at_spr_sx[id]
|
|
let sy = rt_atlas_st.at_spr_sy[id]
|
|
let w = rt_atlas_st.at_spr_w[id]
|
|
let h = rt_atlas_st.at_spr_h[id]
|
|
var y = 0
|
|
while y < h {
|
|
let srcy = sy + y
|
|
if (srcy >= 0) and (srcy < ih) {
|
|
var x = 0
|
|
while x < w {
|
|
let srcx = sx + x
|
|
if (srcx >= 0) and (srcx < iw) {
|
|
let px = s[srcy * iw + srcx]
|
|
if ((px >> 24) & 255) >= 128 { rt_fill_rect(rt_core_st, dx + x * sc, dy + y * sc, sc, sc, px & 16777215) }
|
|
}
|
|
x += 1
|
|
}
|
|
}
|
|
y += 1
|
|
}
|
|
}
|
|
|
|
# blit an atlas sprite with the full Sprite-component treatment (#90): integer scale,
|
|
# horizontal flip, and a solid tint (non-zero = every opaque pixel in that colour).
|
|
# This is what the engine sprite-render system calls for `Sprite { atlas: 1 }`.
|
|
function atlas_draw_ex(rt_atlas_st: mut RtAtlasState, rt_core_st: mut RtCoreState, rt_image_st: RtImageState, id: int, dx: int, dy: int, sc0: int, flip: int, tint: int) -> void {
|
|
atlas_init(rt_atlas_st)
|
|
if (id < 0) or (id >= rt_atlas_st.at_nspr) { return }
|
|
var sc = sc0
|
|
if sc < 1 { sc = 1 }
|
|
let sheet = rt_atlas_st.at_spr_sheet[id]
|
|
let img = rt_atlas_st.at_sheet_img[sheet]
|
|
let iw = rt_image_st.img_w[img]
|
|
let ih = rt_image_st.img_h[img]
|
|
let s: words = rt_image_st.img_px[img]
|
|
let sx = rt_atlas_st.at_spr_sx[id]
|
|
let sy = rt_atlas_st.at_spr_sy[id]
|
|
let w = rt_atlas_st.at_spr_w[id]
|
|
let h = rt_atlas_st.at_spr_h[id]
|
|
var y = 0
|
|
while y < h {
|
|
let srcy = sy + y
|
|
if (srcy >= 0) and (srcy < ih) {
|
|
var x = 0
|
|
while x < w {
|
|
var rx = x
|
|
if flip != 0 { rx = w - 1 - x }
|
|
let srcx = sx + rx
|
|
if (srcx >= 0) and (srcx < iw) {
|
|
let px = s[srcy * iw + srcx]
|
|
if ((px >> 24) & 255) >= 128 {
|
|
var col = px & 16777215
|
|
if tint != 0 { col = tint & 16777215 }
|
|
if sc == 1 { rt_put_px(rt_core_st, dx + x, dy + y, col) }
|
|
else { rt_fill_rect(rt_core_st, dx + x * sc, dy + y * sc, sc, sc, col) }
|
|
}
|
|
}
|
|
x += 1
|
|
}
|
|
}
|
|
y += 1
|
|
}
|
|
}
|
|
|
|
# a strip of `count` frames starting at (col,row), each `rows` cells tall, registered
|
|
# as consecutive ids so `first + SpriteAnim.frame` addresses the current frame.
|
|
function atlas_strip(rt_atlas_st: mut RtAtlasState, sheet: int, col: int, row: int, count: int, rows: int) -> int {
|
|
var first = -1
|
|
var i = 0
|
|
while i < count {
|
|
let id = atlas_cell_span(rt_atlas_st, sheet, col + i, row, 1, rows)
|
|
if first < 0 { first = id }
|
|
i += 1
|
|
}
|
|
return first
|
|
}
|
|
|
|
# an atlas sprite's pixel size — handy for centering / layout.
|
|
function atlas_width(rt_atlas_st: mut RtAtlasState, id: int) -> int { atlas_init(rt_atlas_st); if (id < 0) or (id >= rt_atlas_st.at_nspr) { return 0 }; return rt_atlas_st.at_spr_w[id] }
|
|
function atlas_height(rt_atlas_st: mut RtAtlasState, id: int) -> int { atlas_init(rt_atlas_st); if (id < 0) or (id >= rt_atlas_st.at_nspr) { return 0 }; return rt_atlas_st.at_spr_h[id] }
|
|
|
|
# Sprite.draw_meter: `value` of `max` as a row of icons — full, half or empty per
|
|
# `per_icon` points (hearts, stars, ammo pips), `spacing` px apart
|
|
function atlas_draw_meter(rt_atlas_st: mut RtAtlasState, rt_core_st: mut RtCoreState, rt_image_st: RtImageState, x: int, y: int, value: int, max: int, per_icon: int, spacing: int, full: int, half: int, empty: int) -> void {
|
|
if per_icon <= 0 { return }
|
|
var i = 0
|
|
while i < max / per_icon {
|
|
var id = empty
|
|
if value >= i * per_icon + per_icon / 2 { id = half }
|
|
if value >= (i + 1) * per_icon { id = full }
|
|
atlas_draw(rt_atlas_st, rt_core_st, rt_image_st, id, x + i * spacing, y)
|
|
i += 1
|
|
}
|
|
}
|
|
|
|
# Assets.enqueue_dir: every file of a directory, named by its file name without the
|
|
# extension (assets/audio/hit.wav -> "hit"); the queue sorts by extension as usual
|
|
function assets_enqueue_dir(rt_atlas_st: mut RtAtlasState, dir: pointer) -> void {
|
|
let names = Fs.list(dir)
|
|
if names == null { return }
|
|
var i = 0
|
|
while i < len(names) {
|
|
let file = names[i]
|
|
var dot = len(file) - 1
|
|
while (dot > 0) and (file[dot] != '.') { dot -= 1 }
|
|
if dot > 0 { assets_enqueue(rt_atlas_st, file[0..dot], dir + ("/") + file) }
|
|
i += 1
|
|
}
|
|
}
|
|
|
|
# ---- incremental preload (#82) --------------------------------------------
|
|
# Enqueue a named image file to load later (does not load it now).
|
|
function assets_enqueue(rt_atlas_st: mut RtAtlasState, name: pointer, path: pointer) -> void {
|
|
atlas_init(rt_atlas_st)
|
|
if rt_atlas_st.at_q_n >= ATLAS_MAX_QUEUE { return }
|
|
rt_atlas_st.at_q_name[rt_atlas_st.at_q_n] = name
|
|
rt_atlas_st.at_q_path[rt_atlas_st.at_q_n] = path
|
|
rt_atlas_st.at_q_n += 1
|
|
}
|
|
|
|
# Load up to `max` queued assets this frame, registering each under its name, and
|
|
# return how many were loaded by this call. Call it each frame in a loading scene
|
|
# (a small `max` keeps the frame short); Assets.ready() flips true when done.
|
|
event AssetsReady { } # fired once, the frame the queue finishes
|
|
function assets_pump(rt_atlas_st: mut RtAtlasState, rt_audio_st: mut RtAudioState, rt_image_st: mut RtImageState, rt_inflate_st: mut RtInflateState, rt_truetype_st: mut RtTruetypeState, max: int) -> int {
|
|
atlas_init(rt_atlas_st)
|
|
var done = 0
|
|
while (done < max) and (rt_atlas_st.at_q_pos < rt_atlas_st.at_q_n) {
|
|
assets_load_one(rt_atlas_st, rt_audio_st, rt_image_st, rt_inflate_st, rt_truetype_st, rt_atlas_st.at_q_name[rt_atlas_st.at_q_pos], rt_atlas_st.at_q_path[rt_atlas_st.at_q_pos])
|
|
rt_atlas_st.at_q_pos += 1
|
|
done += 1
|
|
}
|
|
if (rt_atlas_st.at_q_pos >= rt_atlas_st.at_q_n) and (not rt_atlas_st.at_q_announced) { rt_atlas_st.at_q_announced = true; emit AssetsReady() }
|
|
return done
|
|
}
|
|
# the default loading bar of a `scene X loads then Y`: centred, a fifth of the screen wide
|
|
function assets_draw_progress(rt_atlas_st: mut RtAtlasState, rt_core_st: mut RtCoreState) -> void {
|
|
let w = rt_fbw / 2
|
|
let x = rt_fbw / 4
|
|
let y = rt_fbh / 2 - 4
|
|
rt_fill_rect(rt_core_st, x, y, w, 8, 0x303030)
|
|
rt_fill_rect(rt_core_st, x, y, w * assets_progress(rt_atlas_st) / 100, 8, 0xffcc44)
|
|
}
|
|
|
|
# what kind of asset a path is, by its extension: sounds and fonts go to their own
|
|
# managers (Audio.play(name:), Assets.font(name)); everything else is an image
|
|
function path_has_suffix(path: pointer, suffix: pointer) -> bool {
|
|
let n = len(path)
|
|
let m = len(suffix)
|
|
if m > n { return false }
|
|
var i = 0
|
|
while i < m {
|
|
if path[n - m + i] != suffix[i] { return false }
|
|
i += 1
|
|
}
|
|
return true
|
|
}
|
|
const ATLAS_MAX_FONT: int = 16
|
|
function assets_load_one(rt_atlas_st: mut RtAtlasState, rt_audio_st: mut RtAudioState, rt_image_st: mut RtImageState, rt_inflate_st: mut RtInflateState, rt_truetype_st: mut RtTruetypeState, name: pointer, path: pointer) -> void {
|
|
if path_has_suffix(path, ".wav") or path_has_suffix(path, ".mp3") or path_has_suffix(path, ".ogg") {
|
|
audio_define(rt_audio_st, name, path)
|
|
return
|
|
}
|
|
if path_has_suffix(path, ".ttf") or path_has_suffix(path, ".ttc") {
|
|
if rt_atlas_st.at_font_name == null { rt_atlas_st.at_font_name = pointers(ATLAS_MAX_FONT); rt_atlas_st.at_font_id = words(ATLAS_MAX_FONT) }
|
|
if rt_atlas_st.at_font_n < ATLAS_MAX_FONT {
|
|
rt_atlas_st.at_font_name[rt_atlas_st.at_font_n] = name
|
|
rt_atlas_st.at_font_id[rt_atlas_st.at_font_n] = rt_font_load(rt_image_st, rt_truetype_st, path)
|
|
rt_atlas_st.at_font_n += 1
|
|
}
|
|
return
|
|
}
|
|
atlas_register_name(rt_atlas_st, name, atlas_image(rt_atlas_st, rt_image_st, rt_inflate_st, path))
|
|
}
|
|
# the font handle registered under `name` (Assets.font), or 0
|
|
function assets_font(rt_atlas_st: RtAtlasState, name: pointer) -> int {
|
|
var i = 0
|
|
while i < rt_atlas_st.at_font_n {
|
|
if rt_atlas_st.at_font_name[i] == name { return rt_atlas_st.at_font_id[i] }
|
|
i += 1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
function assets_total(rt_atlas_st: mut RtAtlasState) -> int { atlas_init(rt_atlas_st); return rt_atlas_st.at_q_n }
|
|
function assets_loaded(rt_atlas_st: mut RtAtlasState) -> int { atlas_init(rt_atlas_st); return rt_atlas_st.at_q_pos }
|
|
function assets_ready(rt_atlas_st: mut RtAtlasState) -> bool { atlas_init(rt_atlas_st); return rt_atlas_st.at_q_pos >= rt_atlas_st.at_q_n }
|
|
|
|
# loading progress as a whole-number percent (0..100); an empty queue is 100.
|
|
function assets_progress(rt_atlas_st: mut RtAtlasState) -> int {
|
|
atlas_init(rt_atlas_st)
|
|
if rt_atlas_st.at_q_n <= 0 { return 100 }
|
|
return rt_atlas_st.at_q_pos * 100 / rt_atlas_st.at_q_n
|
|
}
|