molive/tape-drive
4
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

cargo update

Browse Source
This commit is contained in:
Molive
2025-06-24 19:15:03 +01:00
parent 0c8ef953cc
commit 11ee139f43
2 changed files with 170 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/interpreter.rs
+38 -36
View File
@@ -5,31 +5,33 @@ use crate::{
ssa::{SSAInput, SSAInstruction, SSAOpcode},
};
type Value = f32;
#[derive(Clone, Debug)]
pub(crate) struct Interpreter<'csg> {
value_map: Vec<f32>,
value_map: Vec<Value>,
csg: &'csg CSG,
}
impl Interpreter<'_> {
fn load(&self, consider: SSAInput) -> f32 {
fn load(&self, consider: SSAInput) -> Value {
match consider {
SSAInput::Register(r) => self.value_map[r as usize],
SSAInput::Constant(c) => c,
}
}
fn store(&mut self, location: u32, value: f32) {
fn store(&mut self, location: u32, value: Value) {
self.value_map[location as usize] = value;
}
}
//imitate glsl, not rust
fn sign(f: f32) -> f32 {
fn sign(f: Value) -> Value {
if f == 0. { f } else { f.signum() }
}
fn fract(f: f32) -> f32 {
fn fract(f: Value) -> Value {
f - f.floor()
}
@@ -45,14 +47,14 @@ impl<'csg> Interpreter<'csg> {
self.value_map = vec![0.; self.csg.parts.last_output as usize];
}
fn param_one(&mut self, instruction: &SSAInstruction, func: impl Fn(f32) -> f32) {
fn param_one(&mut self, instruction: &SSAInstruction, func: impl Fn(Value) -> Value) {
for i in 0..instruction.opcode.size as usize {
let val_a = self.load(instruction.inputs[i]);
self.store(instruction.outputs[i], func(val_a));
}
}
fn param_two(&mut self, instruction: &SSAInstruction, func: impl Fn(f32, f32) -> f32) {
fn param_two(&mut self, instruction: &SSAInstruction, func: impl Fn(Value, Value) -> Value) {
for i in 0..instruction.opcode.size as usize {
let val_a = self.load(instruction.inputs[i]);
let val_b = self.load(instruction.inputs[i + instruction.opcode.size as usize]);
@@ -60,7 +62,7 @@ impl<'csg> Interpreter<'csg> {
}
}
fn param_three(&mut self, instruction: &SSAInstruction, func: impl Fn(f32, f32, f32) -> f32) {
fn param_three(&mut self, instruction: &SSAInstruction, func: impl Fn(Value, Value, Value) -> Value) {
for i in 0..instruction.opcode.size as usize {
let val_a = self.load(instruction.inputs[i]);
let val_b = self.load(instruction.inputs[i + instruction.opcode.size as usize]);
@@ -72,7 +74,7 @@ impl<'csg> Interpreter<'csg> {
fn param_four(
&mut self,
instruction: &SSAInstruction,
func: impl Fn(f32, f32, f32, f32) -> f32,
func: impl Fn(Value, Value, Value, Value) -> Value,
) {
for i in 0..instruction.opcode.size as usize {
let val_a = self.load(instruction.inputs[i]);
@@ -83,7 +85,7 @@ impl<'csg> Interpreter<'csg> {
}
}
pub(crate) fn scene(&mut self, p: glam::Vec3) -> f32 {
pub(crate) fn scene(&mut self, p: glam::Vec3) -> Value {
self.clear_stacks();
for instruction in &self.csg.parts.tape {
@@ -113,14 +115,14 @@ impl<'csg> Interpreter<'csg> {
self.param_two(instruction, |val_a, val_b| val_a % val_b);
},
SSAAtan2 => {
self.param_two(instruction, |val_a: f32, val_b| val_a.atan2(val_b));
self.param_two(instruction, |val_a, val_b| val_a.atan2(val_b));
},
SSAMin => {
self.param_two(instruction, |val_a: f32, val_b| val_a.min(val_b));
self.param_two(instruction, |val_a, val_b| val_a.min(val_b));
},
SSAMinMaterial => todo!(),
SSAMax => {
self.param_two(instruction, |val_a: f32, val_b| val_a.max(val_b));
self.param_two(instruction, |val_a, val_b| val_a.max(val_b));
},
SSAMaxMaterial => todo!(),
SSACross => {
@@ -217,55 +219,55 @@ impl<'csg> Interpreter<'csg> {
};
},
SSANegate => {
self.param_one(instruction, |val_a: f32| -val_a);
self.param_one(instruction, |val_a| -val_a);
},
SSARound => {
self.param_one(instruction, |val_a: f32| val_a.round());
self.param_one(instruction, |val_a| val_a.round());
},
SSAAbs => {
self.param_one(instruction, |val_a: f32| val_a.abs());
self.param_one(instruction, |val_a| val_a.abs());
},
SSAFloor => {
self.param_one(instruction, |val_a: f32| val_a.floor());
self.param_one(instruction, |val_a| val_a.floor());
},
SSACeil => {
self.param_one(instruction, |val_a: f32| val_a.ceil());
self.param_one(instruction, |val_a| val_a.ceil());
},
SSAFract => {
self.param_one(instruction, |val_a: f32| fract(val_a));
self.param_one(instruction, |val_a| fract(val_a));
},
SSASin => {
self.param_one(instruction, |val_a: f32| val_a.sin());
self.param_one(instruction, |val_a| val_a.sin());
},
SSACos => {
self.param_one(instruction, |val_a: f32| val_a.cos());
self.param_one(instruction, |val_a| val_a.cos());
},
SSATan => {
self.param_one(instruction, |val_a: f32| val_a.tan());
self.param_one(instruction, |val_a| val_a.tan());
},
SSAAsin => {
self.param_one(instruction, |val_a: f32| val_a.asin());
self.param_one(instruction, |val_a| val_a.asin());
},
SSAAcos => {
self.param_one(instruction, |val_a: f32| val_a.acos());
self.param_one(instruction, |val_a| val_a.acos());
},
SSAAtan => {
self.param_one(instruction, |val_a: f32| val_a.atan());
self.param_one(instruction, |val_a| val_a.atan());
},
SSAExp => {
self.param_one(instruction, |val_a: f32| val_a.exp());
self.param_one(instruction, |val_a| val_a.exp());
},
SSALog => {
self.param_one(instruction, |val_a: f32| val_a.ln());
self.param_one(instruction, |val_a| val_a.ln());
},
SSASqrt => {
self.param_one(instruction, |val_a: f32| val_a.sqrt());
self.param_one(instruction, |val_a| val_a.sqrt());
},
SSASquare => {
self.param_one(instruction, |val_a: f32| val_a * val_a);
self.param_one(instruction, |val_a| val_a * val_a);
},
SSACube => {
self.param_one(instruction, |val_a: f32| val_a * val_a * val_a);
self.param_one(instruction, |val_a| val_a * val_a * val_a);
},
SSASmoothMin => {
self.param_three(instruction, |d1, d2, k| {
@@ -326,7 +328,7 @@ impl<'csg> Interpreter<'csg> {
self.store(instruction.outputs[0], q.length() - radius2);
},
SSACompare => {
self.param_two(instruction, |val_a: f32, val_b: f32| {
self.param_two(instruction, |val_a, val_b| {
match val_a.total_cmp(&val_b) {
std::cmp::Ordering::Less => -1.,
std::cmp::Ordering::Equal => 0.,
@@ -337,24 +339,24 @@ impl<'csg> Interpreter<'csg> {
SSAAnd => {
self.param_two(
instruction,
|val_a: f32, val_b: f32| if val_a == 0. { val_a } else { val_b },
|val_a, val_b| if val_a == 0. { val_a } else { val_b },
);
},
SSAOr => {
self.param_two(
instruction,
|val_a: f32, val_b: f32| if val_a == 0. { val_b } else { val_a },
|val_a, val_b| if val_a == 0. { val_b } else { val_a },
);
},
SSARecip => {
self.param_one(instruction, |val_a: f32| val_a.recip());
self.param_one(instruction, |val_a| val_a.recip());
},
SSANot => {
self.param_one(instruction, |val_a: f32| if val_a == 0. { 1. } else { 0. });
self.param_one(instruction, |val_a| if val_a == 0. { 1. } else { 0. });
},
SSAStop => return 0.,
}
}
return f32::NAN;
return Value::NAN;
}
}