gromandClaude Opus 5
81d96af35d
This checkout had no git history at all, so this one commit carries the whole
of the Everwood work as a single import on top of chairmanpow/benilla-octo's
`main` (706cd71). The two trees have genuinely diverged — each has files the
other does not — so this is a fork point, not a catch-up.
Today's work, which is the reason a baseline exists at all:
- Booth previews no longer cast world shadows (`NO_BOOTH_SHADOW`). Portrait
characters were entering the sun's shadow cascades, so every skinned-rig
shadow specialization compiled live mid-frame; the hitch detector logged
"main thread blocked 1316 ms" beside a `compiled LIVE` warning. This was
the Fashion/Tmog stutter.
- Per-pane dress-up: each `DressUpModel` pane assembles and stages its own
tried-on look instead of every pane mirroring the live player.
- Item template cache is append-only JSONL written on the IO pool, replacing
an 11.6 MB whole-map JSON rewrite on the main thread every 10 s.
- `WOW_SYSTEM_TIMING` rebuilt per-thread: it took 2 mutexes per system enter
and 4 per exit, costing 15 ms a frame (590 fps -> 60) and corrupting the
measurements it was taken to produce.
- The visibility-churn sweep moved to its own `WOW_FLASH_CHURN` switch, so a
frame-cost reading no longer pays 2.7 ms a frame for it.
Local state (`benilla-config/`, `logs/`, `target/`) is excluded by the
existing .gitignore; the account credential it holds is not in this commit.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01SgstFWtn1RxEJ5kVrpgYwn
114 lines
3.2 KiB
Rust
114 lines
3.2 KiB
Rust
//! Contains definitions from `luacode.h`.
|
|
|
|
use std::marker::{PhantomData, PhantomPinned};
|
|
use std::os::raw::{c_char, c_int, c_void};
|
|
use std::{ptr, slice};
|
|
|
|
#[repr(C)]
|
|
#[non_exhaustive]
|
|
pub struct lua_CompileOptions {
|
|
pub optimizationLevel: c_int,
|
|
pub debugLevel: c_int,
|
|
pub typeInfoLevel: c_int,
|
|
pub coverageLevel: c_int,
|
|
pub vectorLib: *const c_char,
|
|
pub vectorCtor: *const c_char,
|
|
pub vectorType: *const c_char,
|
|
pub mutableGlobals: *const *const c_char,
|
|
pub userdataTypes: *const *const c_char,
|
|
pub librariesWithKnownMembers: *const *const c_char,
|
|
pub libraryMemberTypeCallback: Option<lua_LibraryMemberTypeCallback>,
|
|
pub libraryMemberConstantCallback: Option<lua_LibraryMemberConstantCallback>,
|
|
pub disabledBuiltins: *const *const c_char,
|
|
}
|
|
|
|
impl Default for lua_CompileOptions {
|
|
fn default() -> Self {
|
|
Self {
|
|
optimizationLevel: 1,
|
|
debugLevel: 1,
|
|
typeInfoLevel: 0,
|
|
coverageLevel: 0,
|
|
vectorLib: ptr::null(),
|
|
vectorCtor: ptr::null(),
|
|
vectorType: ptr::null(),
|
|
mutableGlobals: ptr::null(),
|
|
userdataTypes: ptr::null(),
|
|
librariesWithKnownMembers: ptr::null(),
|
|
libraryMemberTypeCallback: None,
|
|
libraryMemberConstantCallback: None,
|
|
disabledBuiltins: ptr::null(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
pub struct lua_CompileConstant {
|
|
_data: [u8; 0],
|
|
_marker: PhantomData<(*mut u8, PhantomPinned)>,
|
|
}
|
|
|
|
/// Type table tags
|
|
#[doc(hidden)]
|
|
#[repr(i32)]
|
|
#[non_exhaustive]
|
|
pub enum luau_BytecodeType {
|
|
Nil = 0,
|
|
Boolean,
|
|
Number,
|
|
String,
|
|
Table,
|
|
Function,
|
|
Thread,
|
|
UserData,
|
|
Vector,
|
|
Buffer,
|
|
|
|
Any = 15,
|
|
}
|
|
|
|
pub type lua_LibraryMemberTypeCallback =
|
|
unsafe extern "C-unwind" fn(library: *const c_char, member: *const c_char) -> c_int;
|
|
|
|
pub type lua_LibraryMemberConstantCallback = unsafe extern "C-unwind" fn(
|
|
library: *const c_char,
|
|
member: *const c_char,
|
|
constant: *mut lua_CompileConstant,
|
|
);
|
|
|
|
unsafe extern "C" {
|
|
pub fn luau_set_compile_constant_nil(cons: *mut lua_CompileConstant);
|
|
pub fn luau_set_compile_constant_boolean(cons: *mut lua_CompileConstant, b: c_int);
|
|
pub fn luau_set_compile_constant_number(cons: *mut lua_CompileConstant, n: f64);
|
|
pub fn luau_set_compile_constant_vector(cons: *mut lua_CompileConstant, x: f32, y: f32, z: f32, w: f32);
|
|
pub fn luau_set_compile_constant_string(cons: *mut lua_CompileConstant, s: *const c_char, l: usize);
|
|
}
|
|
|
|
unsafe extern "C-unwind" {
|
|
#[link_name = "luau_compile"]
|
|
pub fn luau_compile_(
|
|
source: *const c_char,
|
|
size: usize,
|
|
options: *mut lua_CompileOptions,
|
|
outsize: *mut usize,
|
|
) -> *mut c_char;
|
|
}
|
|
|
|
unsafe extern "C" {
|
|
fn free(p: *mut c_void);
|
|
}
|
|
|
|
pub unsafe fn luau_compile(source: &[u8], mut options: lua_CompileOptions) -> Vec<u8> {
|
|
let mut outsize = 0;
|
|
let data_ptr = luau_compile_(
|
|
source.as_ptr() as *const c_char,
|
|
source.len(),
|
|
&mut options,
|
|
&mut outsize,
|
|
);
|
|
assert!(!data_ptr.is_null(), "luau_compile failed");
|
|
let data = slice::from_raw_parts(data_ptr as *mut u8, outsize).to_vec();
|
|
free(data_ptr as *mut c_void);
|
|
data
|
|
}
|