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

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


I looked at your project yesterday (found it on derelict forums) and it looks really good. Currently I'm using my own code for vectors/matrices but a dedicated library could be better.


My comments:

Not sure if DMD will do a good job optimizing your code atm
(probably no way around this but to wait - uglifying the code would serve
no purpose)

In the future, SSE support would be nice (maybe will be easier to do if we
ever get SSE intrinsics)

Seems like most of the code is in linalg.d - wouldn't it be more maintainable to have it separated for each struct, and then public import it through one module for easy usage?

I'm doing a lot of 2D work, and could use at least a rectangle/aabbox struct
(if I use your lib, I'll implement rectangles on top of it anyway).
Some other structs might also be useful (3D aabbox, circle, sphere?)
Although, if you want to be as close to GLSL as possible, this might
not be a good idea.

Most D projects are under the Boost license.
If you want to get this to Phobos,
(I'd like something like this in Phobos :P)
I recommend using that license
(IANAL, but I don't see much difference between MIT and Boost)

The GLSL style is good if you want it as close to GLSL as possible,
but it'd be good to have more D-style aliases (again hinting at Phobos).
(Personally I'd probably use the GLSL style, though)

Am 03.12.2011 22:32, schrieb Kiith-Sa:
> 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
>
>
> I looked at your project yesterday (found it on derelict forums)
> and it looks really good. Currently I'm using my own code for
> vectors/matrices but a dedicated library could be better.
>
>
> My comments:
>
> Not sure if DMD will do a good job optimizing your code atm
> (probably no way around this but to wait - uglifying the code would serve
> no purpose)
>
> In the future, SSE support would be nice (maybe will be easier to do if we
> ever get SSE intrinsics)
>
> Seems like most of the code is in linalg.d - wouldn't it be more maintainable
> to have it separated for each struct, and then public import it through one
> module for easy usage?
>
> I'm doing a lot of 2D work, and could use at least a rectangle/aabbox struct
> (if I use your lib, I'll implement rectangles on top of it anyway).
> Some other structs might also be useful (3D aabbox, circle, sphere?)
> Although, if you want to be as close to GLSL as possible, this might
> not be a good idea.
>
> Most D projects are under the Boost license.
> If you want to get this to Phobos,
> (I'd like something like this in Phobos :P)
> I recommend using that license
> (IANAL, but I don't see much difference between MIT and Boost)
>
> The GLSL style is good if you want it as close to GLSL as possible,
> but it'd be good to have more D-style aliases (again hinting at Phobos).
> (Personally I'd probably use the GLSL style, though)
>
Hi,

Thanks for your feedback. SSE is planed, but it will be the last step, optimization at the end. Well gl3n shouldn't be the bottleneck anyways, because it's normally the GPU.
I've already thought about splitting linalg into 3 different files (also it was suggested by some people), but I dont like how D(md) handles imports, something like this would be cool:

import gl3n.linalg.matrix;
import gl3n.linalg.vector;
import gl3n.linalg.quaternion;
import gl3n.linalg; // this would import gl3n.linalg.matrix/vector/quaternion publically

Like __init__.py in Python, unfortunatly this isn't supported (yet?).

It is also planed to add some useful stuff for graphics programming, like as you mentioned spheres or AABB (axis aligned bounding boxes). Well I dont want it to be GLSL conform (then it would be glm), because I dont like all of the GLSL design choices and D is much more poweful!

I am glad you like it :)

 - dav1d

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

Am 04.12.2011 01:38, schrieb 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
>
We talked yesterday about this topic a bit (freenode.#D):


klickverbot	dav1d: Just to clear up the confusion, scientific linear algebra stuff is a completely different beast than game math. Games is fast 4x4 matrices, numerics is intricate algorithms for 1000x1000 matrices (read: larger than you ever need in gamedev, even when your game uses string theory)

klickverbot	dav1d: I don't know gl3n specifically, but trust me, no gaming linear algebra lib is ever going to be a viable choice for science-y things and vice versa

klickverbot	dav1d:  I mean, a gaming lib would e.g. never have LU, Cholesky, and all other different kinds of decomposition algorithms


Well, I don't know a lot about this topic (scientific linear algebra), but it seems that they have different aims.

On 4/12/11 12:56 AM, David wrote:
> Am 04.12.2011 01:38, schrieb 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.
> klickverbot dav1d: Just to clear up the confusion, scientific linear
> algebra stuff is a completely different beast than game math. Games is
> fast 4x4 matrices, numerics is intricate algorithms for 1000x1000
> matrices (read: larger than you ever need in gamedev, even when your
> game uses string theory)
>
> klickverbot dav1d: I don't know gl3n specifically, but trust me, no
> gaming linear algebra lib is ever going to be a viable choice for
> science-y things and vice versa
>
> klickverbot dav1d: I mean, a gaming lib would e.g. never have LU,
> Cholesky, and all other different kinds of decomposition algorithms
>
>
> Well, I don't know a lot about this topic (scientific linear algebra),
> but it seems that they have different aims.

That's right. Game maths revolves around small vectors and matrices, typically never above 4x4.

On 03-12-2011 23:36, David wrote:
> Am 03.12.2011 22:32, schrieb Kiith-Sa:
>> 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
>>
>>
>> I looked at your project yesterday (found it on derelict forums)
>> and it looks really good. Currently I'm using my own code for
>> vectors/matrices but a dedicated library could be better.
>>
>>
>> My comments:
>>
>> Not sure if DMD will do a good job optimizing your code atm
>> (probably no way around this but to wait - uglifying the code would serve
>> no purpose)
>>
>> In the future, SSE support would be nice (maybe will be easier to do
>> if we
>> ever get SSE intrinsics)
>>
>> Seems like most of the code is in linalg.d - wouldn't it be more
>> maintainable
>> to have it separated for each struct, and then public import it
>> through one
>> module for easy usage?
>>
>> I'm doing a lot of 2D work, and could use at least a rectangle/aabbox
>> struct
>> (if I use your lib, I'll implement rectangles on top of it anyway).
>> Some other structs might also be useful (3D aabbox, circle, sphere?)
>> Although, if you want to be as close to GLSL as possible, this might
>> not be a good idea.
>>
>> Most D projects are under the Boost license.
>> If you want to get this to Phobos,
>> (I'd like something like this in Phobos :P)
>> I recommend using that license
>> (IANAL, but I don't see much difference between MIT and Boost)
>>
>> The GLSL style is good if you want it as close to GLSL as possible,
>> but it'd be good to have more D-style aliases (again hinting at Phobos).
>> (Personally I'd probably use the GLSL style, though)
>>
> Hi,
>
> Thanks for your feedback. SSE is planed, but it will be the last step,
> optimization at the end. Well gl3n shouldn't be the bottleneck anyways,
> because it's normally the GPU.
> I've already thought about splitting linalg into 3 different files (also
> it was suggested by some people), but I dont like how D(md) handles
> imports, something like this would be cool:
>
> import gl3n.linalg.matrix;
> import gl3n.linalg.vector;
> import gl3n.linalg.quaternion;
> import gl3n.linalg; // this would import
> gl3n.linalg.matrix/vector/quaternion publically
>
> Like __init__.py in Python, unfortunatly this isn't supported (yet?).
>
> It is also planed to add some useful stuff for graphics programming,
> like as you mentioned spheres or AABB (axis aligned bounding boxes).
> Well I dont want it to be GLSL conform (then it would be glm), because I
> dont like all of the GLSL design choices and D is much more poweful!
>
> I am glad you like it :)
>
> - dav1d

You can make a gl3n.linalg.all modules that goes like:

public import gl3n.linalg.matrix;
public import gl3n.linalg.vector;

etc...

- Alex

Am 04.12.2011 14:16, schrieb Alex Rønne Petersen:
> On 03-12-2011 23:36, David wrote:
>> Am 03.12.2011 22:32, schrieb Kiith-Sa:
>>> 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
>>>
>>>
>>> I looked at your project yesterday (found it on derelict forums)
>>> and it looks really good. Currently I'm using my own code for
>>> vectors/matrices but a dedicated library could be better.
>>>
>>>
>>> My comments:
>>>
>>> Not sure if DMD will do a good job optimizing your code atm
>>> (probably no way around this but to wait - uglifying the code would
>>> serve
>>> no purpose)
>>>
>>> In the future, SSE support would be nice (maybe will be easier to do
>>> if we
>>> ever get SSE intrinsics)
>>>
>>> Seems like most of the code is in linalg.d - wouldn't it be more
>>> maintainable
>>> to have it separated for each struct, and then public import it
>>> through one
>>> module for easy usage?
>>>
>>> I'm doing a lot of 2D work, and could use at least a rectangle/aabbox
>>> struct
>>> (if I use your lib, I'll implement rectangles on top of it anyway).
>>> Some other structs might also be useful (3D aabbox, circle, sphere?)
>>> Although, if you want to be as close to GLSL as possible, this might
>>> not be a good idea.
>>>
>>> Most D projects are under the Boost license.
>>> If you want to get this to Phobos,
>>> (I'd like something like this in Phobos :P)
>>> I recommend using that license
>>> (IANAL, but I don't see much difference between MIT and Boost)
>>>
>>> The GLSL style is good if you want it as close to GLSL as possible,
>>> but it'd be good to have more D-style aliases (again hinting at Phobos).
>>> (Personally I'd probably use the GLSL style, though)
>>>
>> Hi,
>>
>> Thanks for your feedback. SSE is planed, but it will be the last step,
>> optimization at the end. Well gl3n shouldn't be the bottleneck anyways,
>> because it's normally the GPU.
>> I've already thought about splitting linalg into 3 different files (also
>> it was suggested by some people), but I dont like how D(md) handles
>> imports, something like this would be cool:
>>
>> import gl3n.linalg.matrix;
>> import gl3n.linalg.vector;
>> import gl3n.linalg.quaternion;
>> import gl3n.linalg; // this would import
>> gl3n.linalg.matrix/vector/quaternion publically
>>
>> Like __init__.py in Python, unfortunatly this isn't supported (yet?).
>>
>> It is also planed to add some useful stuff for graphics programming,
>> like as you mentioned spheres or AABB (axis aligned bounding boxes).
>> Well I dont want it to be GLSL conform (then it would be glm), because I
>> dont like all of the GLSL design choices and D is much more poweful!
>>
>> I am glad you like it :)
>>
>> - dav1d
>
> You can make a gl3n.linalg.all modules that goes like:
>
> public import gl3n.linalg.matrix;
> public import gl3n.linalg.vector;
>
> etc...
>
> - Alex
Yeah I know, but that's the reason why I don't do it, I don't like the all part. Maybe it's just a personal dislike.

On 04-12-2011 14:22, David wrote:
> Am 04.12.2011 14:16, schrieb Alex Rønne Petersen:
>> On 03-12-2011 23:36, David wrote:
>>> Am 03.12.2011 22:32, schrieb Kiith-Sa:
>>>> 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
>>>>
>>>>
>>>> I looked at your project yesterday (found it on derelict forums)
>>>> and it looks really good. Currently I'm using my own code for
>>>> vectors/matrices but a dedicated library could be better.
>>>>
>>>>
>>>> My comments:
>>>>
>>>> Not sure if DMD will do a good job optimizing your code atm
>>>> (probably no way around this but to wait - uglifying the code would
>>>> serve
>>>> no purpose)
>>>>
>>>> In the future, SSE support would be nice (maybe will be easier to do
>>>> if we
>>>> ever get SSE intrinsics)
>>>>
>>>> Seems like most of the code is in linalg.d - wouldn't it be more
>>>> maintainable
>>>> to have it separated for each struct, and then public import it
>>>> through one
>>>> module for easy usage?
>>>>
>>>> I'm doing a lot of 2D work, and could use at least a rectangle/aabbox
>>>> struct
>>>> (if I use your lib, I'll implement rectangles on top of it anyway).
>>>> Some other structs might also be useful (3D aabbox, circle, sphere?)
>>>> Although, if you want to be as close to GLSL as possible, this might
>>>> not be a good idea.
>>>>
>>>> Most D projects are under the Boost license.
>>>> If you want to get this to Phobos,
>>>> (I'd like something like this in Phobos :P)
>>>> I recommend using that license
>>>> (IANAL, but I don't see much difference between MIT and Boost)
>>>>
>>>> The GLSL style is good if you want it as close to GLSL as possible,
>>>> but it'd be good to have more D-style aliases (again hinting at
>>>> Phobos).
>>>> (Personally I'd probably use the GLSL style, though)
>>>>
>>> Hi,
>>>
>>> Thanks for your feedback. SSE is planed, but it will be the last step,
>>> optimization at the end. Well gl3n shouldn't be the bottleneck anyways,
>>> because it's normally the GPU.
>>> I've already thought about splitting linalg into 3 different files (also
>>> it was suggested by some people), but I dont like how D(md) handles
>>> imports, something like this would be cool:
>>>
>>> import gl3n.linalg.matrix;
>>> import gl3n.linalg.vector;
>>> import gl3n.linalg.quaternion;
>>> import gl3n.linalg; // this would import
>>> gl3n.linalg.matrix/vector/quaternion publically
>>>
>>> Like __init__.py in Python, unfortunatly this isn't supported (yet?).
>>>
>>> It is also planed to add some useful stuff for graphics programming,
>>> like as you mentioned spheres or AABB (axis aligned bounding boxes).
>>> Well I dont want it to be GLSL conform (then it would be glm), because I
>>> dont like all of the GLSL design choices and D is much more poweful!
>>>
>>> I am glad you like it :)
>>>
>>> - dav1d
>>
>> You can make a gl3n.linalg.all modules that goes like:
>>
>> public import gl3n.linalg.matrix;
>> public import gl3n.linalg.vector;
>>
>> etc...
>>
>> - Alex
> Yeah I know, but that's the reason why I don't do it, I don't like the
> all part. Maybe it's just a personal dislike.

It's the only way you can do it in D. gl3n.linalg will always conflict because that's the name of the package.

- Alex

On 12/04/2011 02:27 PM, Alex Rønne Petersen wrote:
> On 04-12-2011 14:22, David wrote:
>> Am 04.12.2011 14:16, schrieb Alex Rønne Petersen:
>>> On 03-12-2011 23:36, David wrote:
>>>> Am 03.12.2011 22:32, schrieb Kiith-Sa:
>>>>> 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
>>>>>
>>>>>
>>>>> I looked at your project yesterday (found it on derelict forums)
>>>>> and it looks really good. Currently I'm using my own code for
>>>>> vectors/matrices but a dedicated library could be better.
>>>>>
>>>>>
>>>>> My comments:
>>>>>
>>>>> Not sure if DMD will do a good job optimizing your code atm
>>>>> (probably no way around this but to wait - uglifying the code would
>>>>> serve
>>>>> no purpose)
>>>>>
>>>>> In the future, SSE support would be nice (maybe will be easier to do
>>>>> if we
>>>>> ever get SSE intrinsics)
>>>>>
>>>>> Seems like most of the code is in linalg.d - wouldn't it be more
>>>>> maintainable
>>>>> to have it separated for each struct, and then public import it
>>>>> through one
>>>>> module for easy usage?
>>>>>
>>>>> I'm doing a lot of 2D work, and could use at least a rectangle/aabbox
>>>>> struct
>>>>> (if I use your lib, I'll implement rectangles on top of it anyway).
>>>>> Some other structs might also be useful (3D aabbox, circle, sphere?)
>>>>> Although, if you want to be as close to GLSL as possible, this might
>>>>> not be a good idea.
>>>>>
>>>>> Most D projects are under the Boost license.
>>>>> If you want to get this to Phobos,
>>>>> (I'd like something like this in Phobos :P)
>>>>> I recommend using that license
>>>>> (IANAL, but I don't see much difference between MIT and Boost)
>>>>>
>>>>> The GLSL style is good if you want it as close to GLSL as possible,
>>>>> but it'd be good to have more D-style aliases (again hinting at
>>>>> Phobos).
>>>>> (Personally I'd probably use the GLSL style, though)
>>>>>
>>>> Hi,
>>>>
>>>> Thanks for your feedback. SSE is planed, but it will be the last step,
>>>> optimization at the end. Well gl3n shouldn't be the bottleneck anyways,
>>>> because it's normally the GPU.
>>>> I've already thought about splitting linalg into 3 different files
>>>> (also
>>>> it was suggested by some people), but I dont like how D(md) handles
>>>> imports, something like this would be cool:
>>>>
>>>> import gl3n.linalg.matrix;
>>>> import gl3n.linalg.vector;
>>>> import gl3n.linalg.quaternion;
>>>> import gl3n.linalg; // this would import
>>>> gl3n.linalg.matrix/vector/quaternion publically
>>>>
>>>> Like __init__.py in Python, unfortunatly this isn't supported (yet?).
>>>>
>>>> It is also planed to add some useful stuff for graphics programming,
>>>> like as you mentioned spheres or AABB (axis aligned bounding boxes).
>>>> Well I dont want it to be GLSL conform (then it would be glm),
>>>> because I
>>>> dont like all of the GLSL design choices and D is much more poweful!
>>>>
>>>> I am glad you like it :)
>>>>
>>>> - dav1d
>>>
>>> You can make a gl3n.linalg.all modules that goes like:
>>>
>>> public import gl3n.linalg.matrix;
>>> public import gl3n.linalg.vector;
>>>
>>> etc...
>>>
>>> - Alex
>> Yeah I know, but that's the reason why I don't do it, I don't like the
>> all part. Maybe it's just a personal dislike.
>
> It's the only way you can do it in D. gl3n.linalg will always conflict
> because that's the name of the package.
>
> - Alex

I usually use "_" instead of "all".