Retopology (manual and automated)

Retopology is the process of converting high-resolution models into something much smaller that can be used for animation. It can be a difficult process, but the basic idea is to create another mesh that simplifies the original HD asset.


This process is usually done manually with tools like Retopoflow, a superb addon for blender. The source code is available on github.
The result is perfect if you are ready to spend several hours to redraw all the geometry.

wip in blender

Even if the retoplogy was not as good as the one below, it is was good enough for game engine.

Stylized Topology – Universal Mesh, by Rafael Juarez Jr


This process is time consuming and must be done once the mesh is finalised. This does not fit fast prototyping requirements.
To test high density meshes (scans for instance) in a game engine for instance, it’s far too slow to redraw the surface of each object.
Instant Meshes is a life savior in this scenario: even if the simplified mesh is not as good as a manual one, the time improvement is enormous. In 10 to 15 minutes, the software will generate a relatively good mesh.

3d scan to quad, minimal edition

Instant meshes uses a smooth algorithm that optimises edge alignments, represented in the UI as strokes running along the mesh.

edge flow on a HD rock mesh


when pixar opens its code

it ends up with opensubdiv, running on all desktop platforms! SUPER easy to install and to compile!

git clone
cd OpenSubdiv/
mkdri bin
cd bin
cmake -G Xcode -D NO_PTEX=1 -D NO_DOC=1 \
       -D NO_OMP=1 -D NO_TBB=1 -D NO_CUDA=1 -D NO_OPENCL=1 -D NO_CLEW=1 \

enter in the bin directory and launch the demos 🙂
[ok, i have all the libs to compile this installed, but who will try this with being used to compilation :)]



Green logic for a case & Radio for the daydreamers

Design & animation test with softskin, a shiv integer model by Julien Deswaef & Matthew Plummer-Fernandez and a track by Clément Parmentier

bits & pieces

B&W Valley

generated with the valley benchmark from unigine.

godot softskin

Softskinned & articulated platypus

After several hours of adjustments in blender, platypus has now more control points. As shown in the image above, mesh is controlled by invisible edges, acting as rubber bands.

Playing a bit longer with group shrink and control points, and the model is really changing shape

Model used is the Platypus from William Reynish under CC-BY

godot softskin

Softskinned platypus

After nearly 9 month of inactivity, the development of softskin is back on tracks. Softskin is a module inspired by tensegrity for godot engine (what else?). Demo video:

Model used is the Platypus from William Reynish under CC-BY

bookmarks portrait

Lu Yang, baroque manga

uterus man

A crazy asian human. Here is some of his shit.

uterus man, my favorite

main website:


Ray Marching implementaion

Demo of an implementation of ray marching by SebLague. Possibilities are tremendous, especially for boolean operations and object blending. Definitely something to test in Godot!


futari-app godot

UI for rotation editing #2

First prototype of a widget to edit 3d rotation via a 2d plane. The 3 buttons below the gradient allows plane selection ( XY, YZ or ZX ).
The black area in the Y axis is a constrain ( between 90° and 270° ).

Still a lot of stuff to be done, like the processing of the shortest path (it is wrong from time to time) + better transition of the gradient (the constrains are glitching when animated…).


UI for rotation editing #1

I wanted to enable rotation editing via a simplified 2D UI for futari-app. I have started by the most obvious way: 3 concentric circles (XYZ axis).

Even if the design was cool and super simple, there was a huge problem with this widget: NOTHING is circular in the UI! Obviously this appeared once the graphical and functional research was nearly over.

I decided to trash the whole design and start from scratch, and rebase the widget on an element already present in the interface: the color picker. It is easy to modify 2 axis of rotation at the same time by representing the rotation as a 2d gradient. It was only missing the plane selection, the display of axis constrains, current and target values (rotation will be smoothed on the object).

The visual impact is better, it is confusing at first sight but i’m quite sure it will be intuitive to use and will remove the usual difficulty to set rotations (all 3d guys are using shortcuts instead of UI to rotate their objects, as it is always tricky to click on the right axis). Starting the implementation now.


Futari walls, attractors, winds & vortex demo

At last, a visually decent demo of all the modifiers included in the addon futari for Godot.

walls or floor collider
attractors (positive and negative)

And, obviously, it would not be fun without a video!


Godot wireframe primitives

A set of meshes and scripts to add wireframe primitives to a godot project.


Atomontage, a voxel game engine

“The currently dominant 3D graphics and simulation paradigm, based on triangle/polygon meshes, is fundamentally flawed. Meshes only model surfaces – a hollow and thus very incomplete approximation of reality. Mesh content creation is complex and technically demanding; costly with high barriers of entry. Many layers of “hacks” (e.g. UVs) make editing and distributing mesh assets prohibitively cumbersome.”

The atomontage engine is shifting the paradigm of 3D from surfaces to volumes. A super interesting point of view. I will start a research on libre project have the same approach!


Hey The first polymorph production is available on…

Hey! The first polymorph production is available on!

The page of the game.


Trigonometry hell Finishing the day with cool code…

Trigonometry hell.

Finishing the day with cool code running:

  • World coordinates to camera coordinates, especially usefull for sound sources. Indeed, top, right and front depends on the relative position of the source in the camera space, not the global one.
  • Transformation of the sticks direction into world coordinates relative to camera, once again. This time, calculation is based on the lookat location, keeping the system centered on the screen.

Second point was trickier but solved first… Finding the position of an object in the camera space is basically a conversion of reference: center of the world is not (0,0,0) anymore, but camera world location + up is not (0,1,0) anymore, but camera orientation.

A bit of code, it can help to understand the trick:

// creation of the camera matrix, not sure it’s possible to retrieve it easier…
Matrix4 cam_mat = Matrix4( cam->getDerivedOrientation() );
cam_mat.setTrans( cam->getDerivedPosition() );
// inversion of the cam matrix
Matrix4 cam_mat_inverse = cam_mat.inverse();
// for a given vector expressed in global
Vector3 v( 10, 5, -45 );
// construction of a matrix representing this translation
Matrix4 m = Matrix4::IDENTITY;
m.setTrans( rel );
// MAGIC! > conversion to camera space
m = cam_mat_inverse * m * cam_mat;
// and, finally, getting back the coordinates in camera space
v = relm.getTrans();