gl3n - linear algebra and more for D

[Timon Gehr]

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".