Archive for the ‘GLSL’ Category

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és

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

Visualisation de Molécules

Tombé par hasard sur VMD – Visual Molecular Dynamics, un logiciel scientifique Open Source disponible sur Windows, Linux et MacOS-X. Il permet de visualiser en 3D temps réel des molécules complexes et se combine avec de nombreux plugins et autres logiciels pour réaliser des rendus assez spectaculaires :

La modélisation des molécules demande énormément de puissance de calcul car il faut simuler les attractions/répulsions électrostatiques entre de très nombreux atomes pour trouver les positions de chacun. L’équipe de développement de VMD a beaucoup utilisé les GPU pour accélérer ces simulations, et CUDA en particulier (seulement sur Linux pour l’instant).

L’article « GPGPUs: Neat Idea or Disruptive Technology? » sur ce sujet est très intéressant : l’auteur montre que les GPU peuvent apporter un gain d’un facteur 10 en puissance de calcul, mais que ce n’est pas suffisant pour changer radicalement la face de l’informatique.

VMD supporte une ribambelle de formats de fichier de représentation des molécules dont certains, comme PDB, sont des fichiers textes, donc potentiellement importables dans d’autres logiciels …

Fractales IFS, Flame, Moutons Electriques et GPU

Un « système de fonctions itérées » ou « Iterated function system » (IFS) permet de produire des « fractales autosimilaires » ressemblant parfois à des feuilles, comme cette fougère calculée par Paul Nylander en Mathematica.

Les fractales « flamme » sont une généralisation des IFS inventée par Scott Draves. Son algorithme est décrit en détail ici. Ils produisent des motifs plus abstraits mais plus colorés, qu’il est possible de faire varier progressivement pour créer des animations spectaculaires.

Les « flame fractals » ont été popularisées par le superbe screen saver « Electric Sheep » que j’ai utilisé un temps avant de me rendre compte que c’était en réalité un simple player de vidéos téléchargées munies d’un système de vote. En effet, le calcul des « moutons électriques » est très lent même sur un processeur puissant, et c’est un autre logiciel, Apophysis qui est utilisé pour les générer.

Serait-il possible de calculer des « flame fractals » sur un GPU, voire même en temps réel ? Jusqu’ici, trois tentatives ont été faites:

  1. Simon G. Green, de nVidia, a présenté « GPUflame – a GPU-accelerated IFS fractal renderer« au SIGGraph 2005. Son executable pour Windows avec un shader en Cg (ne fonctionnant donc pas avec une carte ATI…) est disponible. Sur une GeForce 6600, il tourne à 2 fps environ. Exemple de résultat:
  2. RapidMind a réalisé un « Electric Sheep » sur GPU sur la base de leur framework C++ dont j’ai parlé ici. Il fonctionne à 10 fps environ sur une GeForce 8800, soit 60x plus vite que sur un Intel Duo 6700. Ce programme n’est hélas pas disponible, on ne peut qu’admirer la video:
  3. Christopher Emory Moore a codé « GPU Flame Fractal » en GLSL + LUA, sur la base de son surprenant GL Lua Shell qui lui permet de tourner sur Mac, PC, et Linux. Et le code source est disponible! Il produit des flammes de 16’000 points à 85fps en faisant 20 itérations par frame. Le résultat est un peu brut, mais quand ça bouge c’est très joli:

reste plus qu’à en faire une version pour Demoniak3D

Ensembles de Julia calculés en temps réel par GPU

Retrouvé par hasard un travail très intéressant de Keenan Crane (dont on a déjà parlé ici) datant de 2005 sur cette page et dans cet article. Il s’agit d’un véritable tutoriel sur le ray-tracing en temps réel d’un objet mathématique particulier, l’ensemble de Julia, le tout calculé sur un GPU. Comme le dit Keenan, il y a deux problèmes avec l’ensemble de Julia:

  1. il prend des siècles à calculer
  2. il est totalement inutile

mais il est très beau, comme on le voit sur ces captures :

En fait, l’ensemble de Julia est un objet à 4 dimensions que l’on visualise par « tranche en 3 dimensions ». En coupant une tranche en 2 dimensions dans une direction particulière, on obtient d’ailleurs l’ensemble de Mandelbrot plus connu, que Demoniak3D calcule sur GPU de façon spectaculaire.

Un exécutable avec son code source sont disponible sur la page « Ray Tracing Quaternion Julia Sets on the GPU » de Keenan Crane. Il utilise

Le problème, c’est que ce dernier code n’a plus l’air de fonctionner avec le tout récent Cg 2.0… Avant que je m’attaque à porter tout ceci en GLSL + LUa sur Demoniak 3D, est-ce que quelqu’un qui connait le Cg pourrait me dire ce qui cloche, voire corriger la version actuelle ?