librairie GLua

GLua est une librairie open source qui offre au programmeurs LUA des classes et functions qui singent celles disponibles en GLSL, le « OpenGL Shading Language ».

GLua a été spécialement conçue comme librairie de base pour Demoniak3D, pour fournir un ensemble cohérent avec les shaders GLSL.

Contenu:

• vec3.lua : vecteurs et arithmétique 3D
• mat3.lua : matrice et arithmétique 3D
• vec4.lua : vecteurs et arithmétique 3D
• glsl.lua : fonctions génériques suivant les prototypes glsl comme définis dans le livre « OpenGL Shading Language » by Randi J. Rost
• test.X.lua : tests unitaires du module X

Utilisation et exemples:

L’utilisation des classes et fonctions est relativement simple.

Regardez les fichiers test.X.lua pour plus de détails et d’exemples.

Téléchargement:

GLua est disponible sur http://luaforge.net/projects/glua/ sous licence LGPL.

Détails d’implémentation:

• les classes sont basées sur class.lua, décrite ici: http://lua-users.org/wiki/SimpleLuaClasses
• glsl.lua offre des fonctions génériques fonctionnant sur les nombres et tables LUA, et donc avec toutes les classes matrice/vecteur. Elle utilise intensivement la « programmation fonctionnelle » pour ce faire:
  • la fonction « apply » est définie comme suit:
    --- applies a function to a table of parameters
-- @param f : function to apply to each element in v
-- @param v : (vector of) parameter(s) to f function
-- @return : (vector of) result(s) of f(v)
function apply(f,v)
if type(v)=="number" then return f(v) end
if type(v)=="table" then
local res={}
for i,x in ipairs(v) do res[i]=f(x) end
return res
end
error("apply "..f.."("..type(v)..") not implemented")
end
  • ainsi, les fonctions peuvent facilement être définies pour accepter des nombres, vecteurs et tables:
function sin(rad)
return apply(math.sin,rad)
end
• le produit scalaire est implanté de 2 manières distinctes :
  • dans l’opérateur « exposant » ^ des classes
  • comme fonction générique dot(p1,p2) dans glsl.lua

Publicité

GLua library

GLua is an open source library which provides LUA programmers with classes and functions that mimic those available in GLSL, the OpenGL Shading Language.

GLua was especially designed as a base library for the Demoniak3D real-time engine, as it provides a consistent framework with GLSL shaders.

Contents:

• vec3.lua : 3D vectors and arithmetic
• mat3.lua : 3D matrix and arithmetic
• vec4.lua : 4D vectors and arithmetic
• glsl.lua : generic functions following glsl prototypes as defined in book « OpenGL Shading Language » by Randi J. Rost
• test.X.lua : unit test of module X

Usage & Samples:

Usage of the classes and functions is pretty straightforward.

Check the test.X.lua modules for more details or examples

Download:

GLua is available on http://luaforge.net/projects/glua/ under LGPL licence.

Implementation details:

• the classes are based on class.lua, described on http://lua-users.org/wiki/SimpleLuaClasses
• glsl.lua offers generic function that work on LUA numbers and tables, and therefore all vector / matrix classes. It makes extensive use of functional programming to achieve this:
  • the « apply » function is defined as follows:
    --- applies a function to a table of parameters
-- @param f : function to apply to each element in v
-- @param v : (vector of) parameter(s) to f function
-- @return : (vector of) result(s) of f(v)
function apply(f,v)
if type(v)=="number" then return f(v) end
if type(v)=="table" then
local res={}
for i,x in ipairs(v) do res[i]=f(x) end
return res
end
error("apply "..f.."("..type(v)..") not implemented")
end
  • then, functions can easily be defined to support numbers, vectors, or matrices:
function sin(rad)
return apply(math.sin,rad)
end
• dot product is implemented in 2 different ways :
  • through the « power » ^ operator in classes
  • as a generic dot(p1,p2) function in glsl.lua

Hyperion 3D devient Demoniak 3D

Suite à une sombre histoire, Hyperion3D s’appelle dorénavant Demoniak 3D.

JegX nous a pondu à la vitesse de la lumière une version 1.17 en renommant tout sur son passage.

En passant, bravo à Steph3D pour le logo.

 

 

Flower Power Demo

C’est un peu long à expliquer pourquoi, mais Thierry a suggéré de faire pousser des tulipes avec Hyperion… Je me suis attaqué à une petite démo en partant du code sample 84 qui fait bouger de l’herbe avec un shader GLSL, le but étant de faire balancer les tulipes dans le vent virtuel aussi plus tard.

Voilà où ça en est pour l’instant:

L’idée de base pour faire pousser une fleur est de manipuler l’échelle d’un modèle 3D de la tulipe en temps réel. Dans une première phase on fait pousser la fleur en hauteur avec

HYP_Object.SetScale(tulip,h/3,h,h/3)

puis on fait éclore la tulipe en agissant sur les facteurs d’échelle x et z. Le paragraphe suivant présente une manière élégante de faire ceci tout en traitant le cas de nombreuses fleurs.

En effet, la difficulté essentielle consiste à faire pousser les fleurs « presque » en même temps, « presque » à la même vitesse, « presque » à la même hauteur et « presque » verticalement, puis à les faire « presque » éclore en même temps.

Pour faire ceci, j’ai développé une petite librairie d’animation en LUA dont je suis très fier, car elle permet de faire de très nombreuses autres choses, pour ne pas dire tout ! (et encore, je suis modeste…)

Animate

Simulation de Galaxie Spirale

Poursuivant ma découverte (*) du génial Hyperion 3D, je me suis attaqué à simuler une Galaxie Spirale.

Il faut dire que la formation des bras spiraux des galaxies n’a été comprise que récemment parce qu’il fallait « penser différemment ». Bien que je l’aie un peu expliqué ici, je voulais le voir pour le croire. Et voilà, c’est fait, admirez !