Awesome

haxe-glm

Native Haxe version of the fantastic GLM library (https://github.com/g-truc/glm). For those unaware of the GLM library, it is basically a toolset for using 2, 3, and 4 dimensional vectors and matrices, as well as quaternions. This tends to be rather useful when working with OpenGL, which is largely all about rasterizing primitives using vectors and matrices.

Contributing

Issues, forks, and pull requests are gladly welcomed!

Documentation

Manual

This library provides several classes (actually, abstracts over floating point arrays) which enable vector, matrix, and quaternion mathematical operations (Vec2, Vec3, Vec4, Mat2, Mat3, Mat4, and Quat). The library also includes static utilities for generating transformation and projection matrices (GLM).

The library includes static extensions and gives you the flexibility to instantiate or reuse objects as desired using destination arguments.

Motivation

I decided to create this library for Haxe after seeing project after project write their own code for dealing with vectors, matrices, and quaternions. This has resulted in a lot of duplicated effort by developers who all seem to write their own classes to deal with this.

Hopefully the creation of this [fully cross-target and cross-platform] library, some of this duplicated effort can be minimized in the future.

API

API documentation is available here: http://fuzzywuzzie.github.io/haxe-glm/

Samples

// create a new perspective projection matrix
var P:Mat4 = GLM.perspective(
    45 * Math.PI / 180, // field of view (radians)
    640 / 480, // aspect ratio
    0.1, 100, // near, far
    new Mat4() // where to store the result
);

using glm.Quat;

// transform components
var pos:Vec3 = new Vec3(0, 0, 1.5);
var rot:Quat = new Quat().identity();
var sca:Vec3 = new Vec3(1, 1, 1);
var modelMatrix:Mat4 = new Mat4();

// ...

// update the model matrix
GLM.transform(pos, rot, sca, modelMatrix);

Underlying Types

This library is written using abstract types over simple base object. When used on its own, the library uses basic classes containing each type's data. For example, Vec4s are implemented as:

class Vec4Base {
    function new(){}
    var x:Float;
    var y:Float;
    var z:Float;
    var w:Float;
}

abstract Vec4(Vec4Base) {
    // ...
}

Since there are a plethora of libraries out there that each have their own internal format, when the library detects a supported library, it changes to become an abstract over that library's type. For example, if Kha is detected, Vec4 becomes an abstract over Kha's FastVector4 type with implicit casts to and from FastVector4s. This enables you to use the functionality in this library without taking performance hits converting to and from the types your library expects.

Implemented underlying types:

• Standalone
• Kha ('Fast' versions—(32-bit floats on cpp, 64-bit doubles everywhere else))
• Heaps
• lime
• OpenFL
• HaxeFlixel
• luxe

Calculations / Features

• :heavy_check_mark:—The calculation is currently available
• :x:—The calculation is planned but not yet available

GLM

Vectors

Quaternions

Matrices