gl3n - linear algebra and more for D

[David]

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.