Chouette ! Je teste ton patch (je suis tombé ya pas longtemps sur des codes de morphing glsl mais utilisant des .geom me semble t'il...)

ok je regarde la compat 'normales'

pour le morphing, ci dessous un quote de l'orange book (et j'avais vu une version avec des .geom aussi mais je retrouve pas...) :

orange book a écrit:

You can blend between the geometry of two objects to create a tweened (inbetween) version or
do a linear blend between two colors, two textures, two procedural patterns, and so on. All it
takes is a shader that uses a control value that is the ratio of the two items being blended and
that is updated each frame by the application. In some cases, a linear blend is sufficient. For an
oscillating effect, you'll probably want to have the application compute the interpolation factor
by using a spline function to avoid jarring discontinuities in the animation. (You could have the
shader compute the interpolation value, but it's better to have the application compute it once
per frame rather than have the vertex shader compute it once per vertex or have the fragment
shader compute it needlessly at every fragment.)
For instance, using generic vertex attributes, you can actually pass the geometry for two
objects at a time. The geometry for the first object would be passed through the usual OpenGL
calls (glVertex, glColor, glNormal, etc.). A second set of vertex information can be passed by
means of generic vertex attributes 0, 1, 2, etc. The application can provide a blending factor
through a uniform variable, and the vertex shader can use this blending factor to do a weighted
average of the two sets of vertex data. The tweened vertex position is the one that actually
gets transformed, the tweened normal is the one actually used for lighting calculations, and so
on.

16.4.1. Sphere Morph Vertex Shader
The shader in Listing 16.2, developed by Philip Rideout, morphs between two objectsa square
that is generated by the application and a sphere that is procedurally generated in the vertex
shader. The sphere is defined entirely by a single valueits radiusprovided by the application
through a uniform variable. The application passes the geometry defining the square to the
vertex shader with the standard built-in attributes gl_Normal and gl_Vertex. The vertex shader
computes the corresponding vertex and normal on the sphere with a subroutine called sphere.
The application provides a time-varying variable (Blend) for morphing between these two
objects. Because we are using the two input vertex values to compute a third, inbetween,
value, we cannot use the ftransform function. We'll transform the computed vertex directly within
the vertex shader.

Listing 16.2. Vertex shader for morphing between a plane and a sphere

varying vec4 Color;
uniform vec3 LightPosition;
uniform vec3 SurfaceColor;
const float PI = 3.14159;
const float TWO_PI = PI * 2.0;
uniform float Radius;
uniform float Blend;
vec3 sphere(vec2 domain)
{
vec3 range;
range.x = Radius * cos(domain.y) * sin(domain.x);
range.y = Radius * sin(domain.y) * sin(domain.x);
range.z = Radius * cos(domain.x);
return range;
}
void main()
{
vec2 p0 = gl_Vertex.xy * TWO_PI;
vec3 normal = sphere(p0);;
vec3 r0 = Radius * normal;
vec3 vertex = r0;
normal = mix(gl_Normal, normal, Blend);
vertex = mix(gl_Vertex.xyz, vertex, Blend);
normal = normalize(gl_NormalMatrix * normal);
vec3 position = vec3(gl_ModelViewMatrix * vec4(vertex, 1.0));
vec3 lightVec = normalize(LightPosition - position);
float diffuse = max(dot(lightVec, normal), 0.0);
if (diffuse < 0.125)
diffuse = 0.125;
Color = vec4(SurfaceColor * diffuse, 1.0);
gl_Position = gl_ModelViewProjectionMatrix * vec4(vertex,1.0);

bien sur, on utilise une texture externe et on récupère les coordonées couleur; le principe qu heightMap, ou bien dans les exemples de pureData fetching...

c'est l'exemple 6 de GLSL.
Sinon, pour faire apparaitre le dindon, si tu as le .obj, j'ai deux petites idées :
la première est de créer un .frag qui auraient pour valeur de gl_FragColor les valeurs des gl_Vertex du dindon, enregistrer l'image, et faire une interpolation entre les coordonées texture du 'heightMap" (bien que ce n'est plus vraiment une heightMap) du dindon et celle du singe.
sinon il suffit de faire l'interpolation en CPU par la formule [x * ( 1 − a ) + y * a] entre les tableaux de coordonées vertex (même chose que mix en glsl)
Bref pas simple mais faisable!

Super chouette !
C'est à ma connaissance le premier patch de morphing gem !

Une grande victoire

Ouais nononononono c'est vrai, mais ce premier résultat est encourageant !
Genre ça donne la motivation pour s'attaquer à la version pure glsl

Héhé dwan
Dans le même genre les contrib de nononono m'ont poussé à réessayer (avec succès cette fois ci) l'external pyext