gl3n - linear algebra and more for D

[dsimcha]

I don't know much about computer graphics but I take it that a sane 
design for a matrix/vector library geared towards graphics is completely 
different from one geared towards general numerics/scientific computing? 
  I'm trying to understand whether SciD (which uses BLAS/LAPACK and 
expression templates) overlaps with this at all.

On 12/2/2011 5:36 PM, David wrote:
> Hello,
>
> I am currently working on gl3n - https://bitbucket.org/dav1d/gl3n - gl3n
> provides all the math you need to work with OpenGL, DirectX or just
> vectors and matrices (it's mainly targeted at graphics - gl3n will never
> be more then a pure math library). What it supports:
>
>   * vectors
>   * matrices
>   * quaternions
>   * interpolation (lerp, slerp, hermite, catmull rom, nearest)
>   * nearly all glsl functions (according to spec 4.1)
>   * some more cool features, like templated types (vectors, matrices,
>     quats), cool ctors, dynamic swizzling
>
> And the best is, it's MIT licensed ;). Unfortunatly there's no
> documentation yet, but it shouldn't be hard to understand how to use it,
> if you run anytime into troubles just take a look into the source, I did
> add to every part of the lib unittests, so you can see how it works when
> looking at the unittests, furthermore I am very often at #D on freenode.
> But gl3n isn't finished! My current plans are to add more interpolation
> functions and the rest of the glsl defined functions, but I am new to
> graphics programming (about 4 months I am now into OpenGL), so tell me
> what you're missing, the chances are good that I'll implement and add
> it. So let me know what you think about it.
>
> Before I forget it, a bit of code to show you how to use gl3n:
>
> ------------------------------------------------------------------------
> vec4 v4 = vec4(1.0f, vec3(2.0f, 3.0f, 4.0f));
> vec4 v4 = vec4(1.0f, vec4(1.0f, 2.0f, 3.0f, 4.0f).xyz)); // "dynamic"
> swizzling with opDispatch
> vec3 v3 = my_3dvec.rgb;
> float[] foo = v4.xyzzzwzyyxw // not useful but possible!
> glUniformMatrix4fv(location, 1, GL_TRUE, mat4.translation(-0.5f, -0.54f,
> 0.42f).rotatex(PI).rotatez(PI/2).value_ptr); // yes they are row major!
> mat3 inv_view = view.rotation;
> mat3 inv_view = mat3(view);
> mat4 m4 = mat4(vec4(1.0f, 2.0f, 3.0f, 4.0f), 5.0f, 6.0f, 7.0f, 8.0f,
> vec4(…) …);
>
> struct Camera {
>      vec3 position = vec3(0.0f, 0.0f, 0.0f);
>      quat orientation = quat.identity;
>
>      Camera rotatex(real alpha) { orientation.rotatex(alpha); return this; }
>      Camera rotatey(real alpha) { orientation.rotatey(alpha); return this; }
>      Camera rotatez(real alpha) { orientation.rotatez(alpha); return this; }
>
>      Camera move(float x, float y, float z) {
>          position += vec3(x, y, z);
>          return this;
>      }
>      Camera move(vec3 s) {
>          position += s;
>          return this;
>      }
>
>      @property camera() {
>          //writefln("yaw: %s, pitch: %s, roll: %s",
> degrees(orientation.yaw), degrees(orientation.pitch),
> degrees(orientation.roll));
>          return mat4.translation(position.x, position.y, position.z) *
> orientation.to_matrix!(4,4);
>      }
> }
>
>          glUniformMatrix4fv(programs.main.view, 1, GL_TRUE,
> cam.camera.value_ptr);
>          glUniformMatrix3fv(programs.main.inv_rot, 1, GL_TRUE,
> cam.orientation.to_matrix!(3,3).inverse.value_ptr);
> ------------------------------------------------------------------------
>
> I hope this gave you a little introduction of gl3n.
>
> - dav1d