matthewjberger

struct Emulator {
    register: [u8; 2], // Two general-purpose registers
    program_counter: usize,
    memory: [u8; 256], // Simplified memory
}

enum Instruction {
    Load(u8, u8),    // Load a value into a register
    Add,             // Add two registers
    Subtract,        // Subtract two registers

matthewjberger

use std::convert::TryFrom;
use std::num::ParseIntError;

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
struct SemanticVersion {
    major: u32,
    minor: u32,
    patch: u32,
}

matthewjberger

use petgraph::graphmap::DiGraphMap;
use serde::{Deserialize, Serialize};
use std::{collections::HashMap, error::Error, fmt, hash::Hash};

#[derive(Debug)]
pub struct NodeGraphError {
    details: String,
}

impl NodeGraphError {

matthewjberger

fn contains_single_num_in_range(s: &str, section_index: usize, min: u8, max: u8) -> Option<u8> {
    s.split('/')
        .nth(section_index)?
        .split('-')
        .filter_map(|part| part.parse::<u8>().ok())
        .find(|&num| (min..=max).contains(&num))
}

#[cfg(test)]
mod tests {

matthewjberger

use petgraph::{graph::NodeIndex, prelude::*};
use std::ops::{Index, IndexMut};

pub trait Aggregatable: Clone + PartialEq + std::fmt::Debug {
    fn aggregate(&self, parent: &Self) -> Self;
}

// The SceneGraph is now generic over the type of the transform
#[derive(Default)]
pub struct SceneGraph<T: Aggregatable>(pub Graph<T, ()>);

matthewjberger

// ===========================
// Approach 1: Direct Function
// ===========================

struct DirectProcessor {
    process: fn() -> &'static str,
}

impl DirectProcessor {
    fn process_data() -> &'static str {

matthewjberger

Does it build in wasm?

cargo build --target wasm32-unknown-unknown

How do I specify crates just for the wasm target?

Here's an example using legion:

matthewjberger

//! Tokio Async Topic-based Pub/Sub Messaging
//!
//! This module provides a broker-client communication system where
//! multiple clients can communicate with each other through a central broker.
//! The broker is responsible for routing messages between clients based on topics.
//! 
//! # Structures
//! 
//! - `Broker`: Represents the central message router. It manages topics and routes messages between subscribers.
//! - `Client`: Represents a client that can subscribe to topics, send, and receive messages through the broker.

matthewjberger

// From: https://github.com/serde-rs/serde/issues/1465#issuecomment-800686252
use common::serde::{self, Deserialize, Serialize}

#[derive(Copy, Clone, Debug, Deserialize, Serialize)]
#[serde(crate = "self::serde")] // must be below the derive attribute
struct Vertex {
    position: [u32; 3],
}

matthewjberger

#[derive(Default, Debug, Clone, Copy, PartialEq)]
struct Point {
    x: f64,
    y: f64,
}

impl Point {
    fn lerp(self, other: Self, t: f64) -> Self {
        Self {
            x: (1.0 - t) * self.x + t * other.x,