Support for WebAssembly SIMD Intrinsics (v128) and Rust Integration

DirectXMath supports SIMD on architectures such as SSE2 but does not support WebAssembly SIMD intrinsics using the v128 type.
As a header-only library that compiles with any standard C++20 compiler, I successfully compiled it with Clang targeting WebAssembly but found no intrinsic support for WebAssembly SIMD.

I prefer DirectXMath over other libraries (such as GLM) because it is released under the MIT License, supports major SIMD instruction sets, and offers useful functions for software rendering.

My main use case for DirectXMath is software-based rendering (rasterization and ray tracing) targeting outputs such as:

Win32 (GDI)

Direct2D

HTML Canvas via WebAssembly

BMP files

Could you consider adding support for WebAssembly SIMD intrinsics using the v128 type?
Also, with Microsoft’s recent focus on Rust, are there any plans for official Rust support or bindings in DirectXMath?

Thank you for your consideration.

[vbsp-exe]

I actually did port this to WebAssembly in my repository and this is pretty simple to do

[walbourn]

Can you provide a PR as to what you had to change for reference?

[RohithPariki]

Hi, I’m interested in working on WebAssembly SIMD support and/or Rust bindings for DirectXMath. Is anyone else working on this? Any tips before I dive in?

[vbsp-exe]

Can you provide a PR as to what you had to change for reference?

Sure, I'd do that as soon as I can.

I use DirectXMath and build my project as a WebAssembly binary inside WSL with Clang/LLVM and its WebAssembly linker (wasm-ld).

Compilation:

$clang++ -c --target=wasm32 -Wall -I./DirectXMath/Inc Hello.cpp -o Hello.o

Linking:

wasm-ld --no-entry --initial-memory=393216 --max-memory=393216 --export-all --allow-undefined Hello.o -o Hello.wasm

Workarounds:

// ...

#ifndef sinf
#define sinf(x) __builtin_sinf(x)
#endif

// ...

Example:

#define _XM_NO_INTRINSICS_

#include <DirectXMath.h>

__attribute__((export_name("Vector3Cross")))
void Vector3Cross(float (*Destination)[3], const float (*V1)[3], const float (*V2)[3]) {
  auto A = XMVectorSet((*V1)[0], (*V1)[1], (*V1)[2], 0.0f);
  auto B = XMVectorSet((*V2)[0], (*V2)[1], (*V2)[2], 0.0f);
  auto C = XMVector3Cross(A, B);
  (*Destination)[0] = XMVectorGetX(C);
  (*Destination)[1] = XMVectorGetY(C);
  (*Destination)[2] = XMVectorGetZ(C);
}

WebAssembly.instantiateStreaming(fetch("Hello.wasm")).then(
   (results) => {

	const buffer = instance.exports.memory.buffer;
	const values = new Float32Array(buffer);

        // V1 = [1, 0, 0]
        values[0] = 1.0;
        values[1] = 0.0;
        values[2] = 0.0;

        // V2 = [0, 1, 0]
        values[3] = 0.0;
        values[4] = 1.0;
        values[5] = 0.0;

        // Destination = [0, 0, 0]
        values[6] = 0.0;
        values[7] = 0.0;
        values[8] = 0.0;
	
	// Use offsets (pointers)
	instance.exports.Vector3Cross(24, 0, 12);
	
	// Show result
	console.log([values[6], values[7], values[8]]);
});

The Clang/LLVM toolchain integrated with Microsoft Visual Studio 2022 shall also support WebAssembly as a compilation target.

The Visual Studio compiler team may consider adding support for WebAssembly as a compilation target, similar to how LLVM does.

I use clang++ and wasm-ld within Ubuntu (WSL).
To statisfy DirectXMath, I did:

// assert.h
#pragma once

#define assert(condition) \
  if (!(condition)) {   \
    __builtin_trap();     \
  }

// math.h
#pragma once

#ifdef __cplusplus
extern "C" {
#endif

float modff(float x, float* iptr);

// ...

#ifdef __cplusplus
}
#endif

// math.cc
#include "math.h"

#ifdef __cplusplus
extern "C" {
#endif

float modff(float x, float* iptr) { return __builtin_modff(x, iptr); }
// ...

#ifdef __cplusplus
}
#endif

// stdint.h
#pragma once

using size_t = unsigned long;
using uint8_t = unsigned char;
using int32_t = int;
using uint32_t = unsigned int;
// ...

Compile it with something akin to this:

clang++ -std=c++17 --target=wasm32 -nostdlib -Wl,--no-entry -Wl,--export-all -D_XM_NO_INTRINSICS_ -I. -isystem ./external/ -isystem
 ./external/DirectXMath/Inc/ -o demo.wasm demo.cc math.cc

The sal.h is inside external/ and my math.h, assert.h, stdint.h are inside my root directory.

With WebAssembly as a target, you are in a freestanding environment basically, and you can use the builtins that Clang provides.
For the other headers like DirectXPackedVector.h, you may need to add other type aliases and mappings to the respective builtin functions that Clang provides.

Oh, and if you want to avoid dealing with the C++ headers like compare and type_traits, then maybe don't use a standard above C++17.
Otherwise, you need to statisfy DirectXMath with your own C++ standard header "mockups" for compare, type_traits and the like.

Not sure, if you can build "real things" such as a software renderer with DirectXMath, if you target a freestanding environment (i.e., WebAssembly).

Links:

• https://clang.llvm.org/docs/LanguageExtensions.html
• https://raw.githubusercontent.com/JoltWorksIO/cpp-wasm-starter/refs/heads/master/Makefile
• https://surma.dev/things/c-to-webassembly/
• https://en.cppreference.com/cpp/numeric/math/isnan