Implement packcolor and unpackcolor

Author: object-Object

src/logic/ast.rs

@@ -37,6 +37,20 @@ pub enum Instruction {
         to: Value,
         from: Value,
     },
+    PackColor {
+        result: Value,
+        r: Value,
+        g: Value,
+        b: Value,
+        a: Value,
+    },
+    UnpackColor {
+        r: Value,
+        g: Value,
+        b: Value,
+        a: Value,
+        value: Value,
+    },
     // flow control
     Noop,
     Wait {

src/logic/grammar.lalrpop

@@ -19,6 +19,8 @@ match {
     "printchar",
     "format",
     "set",
+    "packcolor",
+    "unpackcolor",
     "noop",
     "wait",
     "stop",
@@ -131,6 +133,12 @@ Instruction: Instruction = {
     "set" <to:Value> <from:Value> =>
         Instruction::Set { <> },
 
+    "packcolor" <result:Value> <r:Value> <g:Value> <b:Value> <a:Value> =>
+        Instruction::PackColor { <> },
+
+    "unpackcolor" <r:Value> <g:Value> <b:Value> <a:Value> <value:Value> =>
+        Instruction::UnpackColor { <> },
+
     // flow control
 
     "noop" =>
@@ -277,6 +285,8 @@ Symbol = {
     "printchar",
     "format",
     "set",
+    "packcolor",
+    "unpackcolor",
     "noop",
     "wait",
     "stop",

src/logic/vm/instructions.rs

@@ -5,7 +5,10 @@ use super::{
     processor::{MAX_TEXT_BUFFER, ProcessorState},
     variables::{LValue, LVar},
 };
-use crate::logic::ast::{self, ConditionOp};
+use crate::{
+    logic::ast::{self, ConditionOp},
+    types::colors::{f32_to_double_bits, f64_from_double_bits},
+};
 
 const MAX_IPT: usize = 1000;
 const EQUALITY_EPSILON: f64 = 0.000001;
@@ -67,6 +70,20 @@ pub fn parse_instruction(
             to: lvar(to),
             from: lvar(from),
         }),
+        ast::Instruction::PackColor { result, r, g, b, a } => Box::new(PackColor {
+            result: lvar(result),
+            r: lvar(r),
+            g: lvar(g),
+            b: lvar(b),
+            a: lvar(a),
+        }),
+        ast::Instruction::UnpackColor { r, g, b, a, value } => Box::new(UnpackColor {
+            r: lvar(r),
+            g: lvar(g),
+            b: lvar(b),
+            a: lvar(a),
+            value: lvar(value),
+        }),
 
         // flow control
         ast::Instruction::Noop => Box::new(Noop),
@@ -222,6 +239,47 @@ impl SimpleInstruction for Set {
     }
 }
 
+struct PackColor {
+    result: LVar,
+    r: LVar,
+    g: LVar,
+    b: LVar,
+    a: LVar,
+}
+
+impl SimpleInstruction for PackColor {
+    fn execute(&self, state: &mut ProcessorState, _: &LogicVM) {
+        self.result.set(
+            state,
+            f32_to_double_bits(
+                self.r.get(state).numf().clamp(0., 1.),
+                self.g.get(state).numf().clamp(0., 1.),
+                self.b.get(state).numf().clamp(0., 1.),
+                self.a.get(state).numf().clamp(0., 1.),
+            )
+            .into(),
+        )
+    }
+}
+
+struct UnpackColor {
+    r: LVar,
+    g: LVar,
+    b: LVar,
+    a: LVar,
+    value: LVar,
+}
+
+impl SimpleInstruction for UnpackColor {
+    fn execute(&self, state: &mut ProcessorState, _: &LogicVM) {
+        let (r, g, b, a) = f64_from_double_bits(self.value.get(state).num());
+        self.r.set(state, r.into());
+        self.g.set(state, g.into());
+        self.b.set(state, b.into());
+        self.a.set(state, a.into());
+    }
+}
+
 // flow control
 
 struct Noop;

src/logic/vm/mod.rs

@@ -172,7 +172,7 @@ mod tests {
 
     use crate::{
         logic::vm::variables::{LValue, LVar},
-        types::{Object, PackedPoint2, ProcessorConfig},
+        types::{Object, PackedPoint2, ProcessorConfig, colors::COLORS},
     };
 
     use super::{processor::Processor, *};
@@ -716,4 +716,60 @@ mod tests {
             assert_eq!(p.state.decode_printbuffer(), r#"4 aa {/}  {:} {10} abcde"#);
         });
     }
+
+    #[test]
+    fn test_pack_unpack_color() {
+        let mut vm = single_processor_vm(
+            BlockType::HyperProcessor,
+            "
+            packcolor packed1 0 0.5 0.75 1
+            unpackcolor r1 g1 b1 a1 packed1
+            unpackcolor r2 g2 b2 a2 %[royal]
+            packcolor packed2 r2 g2 b2 a2
+            stop
+            ",
+        );
+
+        run(&mut vm, 1, true);
+
+        let state = take_processor(&mut vm, 0).state;
+
+        assert_eq!(
+            state.variables["packed1"].get(&state),
+            LValue::Number(f64::from_bits(0x00_7f_bf_ffu64))
+        );
+
+        assert_eq!(state.variables["r1"].get(&state), LValue::Number(0.));
+        assert_eq!(
+            state.variables["g1"].get(&state),
+            LValue::Number(127. / 255.)
+        );
+        assert_eq!(
+            state.variables["b1"].get(&state),
+            LValue::Number(191. / 255.)
+        );
+        assert_eq!(state.variables["a1"].get(&state), LValue::Number(1.));
+
+        assert_eq!(
+            state.variables["r2"].get(&state),
+            LValue::Number((0x41 as f64) / 255.)
+        );
+        assert_eq!(
+            state.variables["g2"].get(&state),
+            LValue::Number((0x69 as f64) / 255.)
+        );
+        assert_eq!(
+            state.variables["b2"].get(&state),
+            LValue::Number((0xe1 as f64) / 255.)
+        );
+        assert_eq!(
+            state.variables["a2"].get(&state),
+            LValue::Number((0xff as f64) / 255.)
+        );
+
+        assert_eq!(
+            state.variables["packed2"].get(&state),
+            LValue::Number(COLORS["royal"])
+        );
+    }
 }

src/logic/vm/variables.rs

@@ -111,6 +111,10 @@ impl LValue {
         }
     }
 
+    pub fn numf(&self) -> f32 {
+        self.num() as f32
+    }
+
     pub fn isobj(&self) -> bool {
         !matches!(self, Self::Number(_))
     }

src/types/colors.rs

@@ -104,10 +104,39 @@ lazy_static! {
     };
 }
 
+pub fn f32_to_double_bits(r: f32, g: f32, b: f32, a: f32) -> f64 {
+    to_double_bits(
+        (r * 255.) as i32,
+        (g * 255.) as i32,
+        (b * 255.) as i32,
+        (a * 255.) as i32,
+    )
+}
+
 pub fn to_double_bits(r: i32, g: i32, b: i32, a: i32) -> f64 {
     rgba8888_to_double_bits(((r << 24) | (g << 16) | (b << 8) | a) as u32)
 }
 
 pub fn rgba8888_to_double_bits(value: u32) -> f64 {
     f64::from_bits(value as u64)
 }
+
+pub fn from_double_bits(value: f64) -> (u8, u8, u8, u8) {
+    let value = value.to_bits();
+    (
+        (value >> 24) as u8,
+        (value >> 16) as u8,
+        (value >> 8) as u8,
+        value as u8,
+    )
+}
+
+pub fn f64_from_double_bits(value: f64) -> (f64, f64, f64, f64) {
+    let (r, g, b, a) = from_double_bits(value);
+    (
+        (r as f64) / 255.,
+        (g as f64) / 255.,
+        (b as f64) / 255.,
+        (a as f64) / 255.,
+    )
+}