The name “LaGrande” means “the great” in (BAD) Spanish, and it historically arose from the naive idea that a single, gargantuous node network might do it all… Do what? Well, the purpose of LaGrande is to help artists (texturers) produce CineMut shader-compatible texture sets for 3D models. As it turns out, Blender node networks (also known as “noodles”), tend to crash the application quite easily if they use a lot of textures or have too many nodes. Therefore, LaGrande is evolving as a very large set of many small noodles.

In its fully evolved form, besides computing bump-modulated bent normals and packing material channels, LaGrande will have such features as adding dirt streaks, scratches, and other surface wear such as reentry heat “burn” marks, exposure-dependent color fading for paints, etceteras. Working prototypes for these noodles already exist and work, but will need some cleaning up and optimization before release.

Well, in its fully evolved form, LaGrande will probably become a single executable, or a set of executables called from a batch or script.

Unlike programs such as Gimp and Photoshop, Blender3D nodes work with floating point precision per-channel; but splitting the work into a long chain of small noodles requires us to save a lot of intermediate results to textures. This is why, as you'll see, LaGrande typically outputs to texture files with a .exr extension. Those are OpenEXR format files, where colors are specified with 32-bit IEEE floating point precision per channel and no compression. A 2k x 2k texture takes 64 megabytes of disk space, in that format; so a machine with lots of disk space (as well as RAM) is recommended for working with LaGrande.

Right now the noodles are in too much flux to warrant uploading them to a server. As a teaser, here is the my most current version of the README file:

This README was first written on July 25, 2009. Revisions: (non yet)

Copyright © 2009 by “chuck_starchaser” (Dan W.) Released under strict GPL (“CopyLeft”) public license. Cannot be used or distributed with, whether modified or not, except with strict GPL (“CopyLeft”) -licenced projects or derivatives, except by special, written permission.

The LaGrande Noodle System is a collection of Blender 3D compositor node networks designed to ease production of textures for 3D models targeted to the CineMut family of GLSL shaders. We're talking artists' tools here.

As of this writing, there is no official download. I don't know how you came around this document, if you're reading this; but then again, chances are you aren't :) But IF you are, it's probably that you found a “copy” of LaGrande in a sub-folder of a 3D model's master texturing work, somehow.

And why would there be “copies” of LaGrande all over the place? Well, the truth is that LaGrande hasn't even been born yet; it is in a 'fetal growth' stage. CineMut shaders are also unborn, pre-alpha, and their texture packing requirments are changing often, making for a moving target for LaGrande. So there's not even a point in trying to have an official “master copy” of LaGrande, or official repository. The copy found under the last 3D model worked on IS the latest version. But you have no way to tell you if this is it. Your best bet is to check out what's happening in PU's modeling and texturing, and figure out, or just ask, what the latest 3D model –with the latest LaGrande– is. http://wcjunction.com/phpBB2/viewforum.php?f=7

Having said that, even when LaGrande matures enough to deserve a central repository to get “it” from, copying the whole thing into a subfolder of every project will be the recommended modus operandi. Why? Because the purpose of keeping modeling and texturing process masters is to be able to “maintain” the art –i.e.: be able to change, perhaps a “small thing”, and get updated outputs. The only way to guarantee you'd get the same outputs as before, except for the “small change”, is to keep a copy of the version of the tools used originally. Not only because LaGrande will continue to evolve, but because LaGrande noodles (node networks) are highly customizable, and you will likely make custom changes or adjustments to it for particular models. And the noodles aren't particularly large, as file sizes go; nowhere near as large as the textures you work with; so might as well keep copies. This modus operandi will result in one (serious) problem, however: When evolutions in LaGrande are tied to evolutions in CineMut texture packing specifications, this will invalidate previous copies of LaGrande. Not sure what the solution is. I think it is up to you to document any customizations you make, so that you can later update the noodles to the latest version and re-apply your customizations.

The following is NOT instructions, or a how-to. Those will be found in the wcpedia.com modeling and texturing wiki, when they are done. What's below is simply a list of LaGrande noodles in order of usage, each with an indented list of input and output filenames. This list is highly mutable, and may be obsolete even if you happen to be reading the latest version of this document.

AO_PRT_exports_for_touchup.blend (DO NOT RUN except the first time, unless you have new bakes and really want to over-write your touch-up's!!!!)

inputs:
  /bakes/UAO.exr
  /bakes/prtP.exr
  /bakes/prtN.exr
  /bakes/CAO.exr
outputs:
  /touchup/UAO_tu0001.png
  /touchup/prtP_tu0001.png
  /touchup/prtN_tu0001.png
  /touchup/CAO_tu0001.png

After running the above noodle, you'd typically spend some time touching up the bakes, such as selecting black blotches by color and blurring, to get rid of too dark texels showing next to interpenetrating geometries. All Gimp work. That's why we exported .png's. Note that the import noodles below will try to keep the full, 32-bit precision of the original OpenEXR files, except for the areas you touched up in the png's. How do the input noodles know? They just use a difference threshold to tell a texel's been deliberately modified.

UPON INPUT UPDATES, YOU CAN RE-RUN NODES STARTING AS EARLY AS HERE

UAO_import_from_touchup.blend

inputs:
  /bakes/UAO.exr
  /touchup/UAO_tu0001.png
outputs:
  /bakes/UAO_fixed0001.exr

prtP_import_from_touchup.blend

inputs:
  /bakes/prtP.exr
  /touchup/prtP_tu0001.png
output:
  /bakes/prtP_fixed0001.exr

prtN_import_from_touchup.blend

inputs:
  /bakes/prtN.exr
  /touchup/prtN_tu0001.png
output:
  /bakes/prtN_fixed0001.exr

CAO_import_from_touchup.blend

inputs:
  /bakes/CAO.exr
  /touchup/CAO_tu0001.png
output:
  /bakes/CAO_fixed0001.exr

UVN_to_XYZ_vec.blend

inputs:
  /bakes/U_vec.exr
  /bakes/V_vec.exr
  /bakes/N_vec.exr
outputs:
  /temp/X_vec.exr
  /temp/Y_vec.exr
  /temp/Z_vec.exr

prt_normalizer_1.blend

inputs:
  /bakes/UAO_fixed0001.exr
  /bakes/prtP_fixed0001.exr
  /bakes/prtN_fixed0001.exr
outputs:
  /temp/renormalized_prtP0001.exr
  /temp/renormalized_prtN0001.exr

PRT_to_bent_normal_1.blend

inputs:
  /temp/renormalized_prtP0001.exr
  /temp/renormalized_prtN0001.exr
output:
  /temp/bent_normal_model_space0001.exr

bent_normal_to_tan_sp_1R.blend

inputs:
  /bakes/U_vec.exr
  /temp/bent_normal_model_space0001.exr
output:
  /temp/bent_normal_tangent_spaceR0001.exr

bent_normal_to_tan_sp_1G.blend

inputs:
  /bakes/V_vec.exr
  /temp/bent_normal_model_space0001.exr
output:
  /temp/bent_normal_tangent_spaceG0001.exr

bent_normal_to_tan_sp_1B.blend

inputs:
  /bakes/N_vec.exr
  /temp/bent_normal_model_space0001.exr
output:
  /temp/bent_normal_tangent_spaceB0001.exr

bent_normal_to_tan_sp_1.blend

inputs:
  /temp/bent_normal_tangent_spaceR0001.exr
  /temp/bent_normal_tangent_spaceG0001.exr
  /temp/bent_normal_tangent_spaceB0001.exr
output:
  /temp/bent_normal_tangent_space0001.exr

bent_prtPNX.blend

inputs:
  /temp/X_vec.exr
  /temp/bent_normal_tangent_space0001.exr
output:
  /temp/bent_prtPX0001.exr
  /temp/bent_prtNX0001.exr

bent_prtPNY.blend

inputs:
  /temp/Y_vec.exr
  /temp/bent_normal_tangent_space0001.exr
output:
  /temp/bent_prtPY0001.exr
  /temp/bent_prtNY0001.exr

bent_prtPNZ.blend

inputs:
  /temp/Z_vec.exr
  /temp/bent_normal_tangent_space0001.exr    /bump/normalGimp.png

output:
  /temp/bent_prtPZ0001.exr
  /temp/bent_prtNZ0001.exr

bump_expander_thinner.blend (not implemented yet; do it with Gimp)

UAO_bump_splitter.blend

input:
  /bump/bump.png
output:
  /temp/bump_top_level0001.png
  /temp/bump_bot_level0001.png

UAO_top_shadows.blend

input:
  /temp/bump_top_level0001.png
output:
  /temp/UAO_top_shadows0001.exr

UAO_bot_shadows.blend

input:
  /temp/bump_bot_level0001.png
output:
  /temp/UAO_bot_shadows0001.exr

UAO_bump_shadows.blend

input:
  /temp/UAO_top_shadows0001.exr
  /temp/UAO_bot_shadows0001.exr
output:
  /bump/UAO_bump_shadows0001.exr

CAO_bump_shadows.blend

input:
  /bump/bump.png
output:
  /bump/CAO_bump_shadows0001.exr

CAO_bump_tilt_mod.blend

input:
  /temp/bent_normal_tangent_space0001.exr
  /bump/normalGimp.png
output:
  /bump/CAO_bump_tilt0001.exr

CAO_final_bumper.blend

input:
  /bakes/CAO_fixed0001.exr
  /bump/CAO_bump_tilt0001.exr
  /bump/CAO_bump_shadows0001.exr
output:
  /bump/CAO_bumped0001.exr

UAO_final_bumper.blend

input:
  /bakes/UAO_fixed0001.exr
  /bump/CAO_bump_tilt0001.exr (that's right; it just square roots the CAO's bump tilt)
  /bump/UAO_bump_shadows0001.exr
output:
  /bump/UAO_bumped0001.exr

modulate_prtPX.blend

inputs:
  /temp/bent_prtPX0001.exr
  /bump/normalGimp.png
output:
  /temp/bumped_prtPX0001.exr

modulate_prtPY.blend

inputs:
  /temp/bent_prtPY0001.exr
  /bump/normalGimp.png
output:
  /temp/bumped_prtPY0001.exr

modulate_prtPZ.blend

inputs:
  /temp/bent_prtPZ0001.exr
  /bump/normalGimp.png
output:
  /temp/bumped_prtPZ0001.exrback

modulate_prtNX.blend

inputs:
  /temp/bent_prtNX0001.exr
  /bump/normalGimp.png
output:
  /temp/bumped_prtNX0001.exr

modulate_prtNY.blend

inputs:
  /temp/bent_prtNY0001.exr
  /bump/normalGimp.png
output:
  /temp/bumped_prtNY0001.exr

modulate_prtNZ.blend

inputs:
  /temp/bent_prtNZ0001.exr
  /bump/normalGimp.png
output:
  /temp/bumped_prtNZ0001.exr

modulate_prtP.blend

inputs:
  /temp/bumped_prtPX0001.exr
  /temp/bumped_prtPY0001.exr
  /temp/bumped_prtPZ0001.exr
  /bump/prtP_fixed0001.exr
output:
  /temp/bumped_prtP0001.exr

modulate_prtN.blend

inputs:
  /temp/bumped_prtNX0001.exr
  /temp/bumped_prtNY0001.exr
  /temp/bumped_prtNZ0001.exr
  /bump/prtN_fixed0001.exr
output:
  /temp/bumped_prtN0001.exr

shadow_prtPX.blend

inputs:
  /temp/bent_prtPX0001.exr
  /bump/UAO_bump_shadows0001.exr
ouput:
  /temp/shadowed_prtPX0001.exr

shadow_prtPY.blend

inputs:
  /temp/bent_prtPY0001.exr
  /bump/UAO_bump_shadows0001.exr
ouput:
  /temp/shadowed_prtPY0001.exr

shadow_prtPZ.blend

inputs:
  /temp/bent_prtPZ0001.exr
  /bump/UAO_bump_shadows0001.exr
ouput:
  /temp/shadowed_prtPZ0001.exr

shadow_prtNX.blend

inputs:
  /temp/bent_prtNX0001.exr
  /bump/UAO_bump_shadows0001.exr
ouput:
  /temp/shadowed_prtNX0001.exr

shadow_prtNY.blend

inputs:
  /temp/bent_prtNY0001.exr
  /bump/UAO_bump_shadows0001.exr
ouput:
  /temp/shadowed_prtNY0001.exr

shadow_prtNZ.blend

inputs:
  /temp/bent_prtNZ0001.exr
  /bump/UAO_bump_shadows0001.exr
ouput:
  /temp/shadowed_prtNZ0001.exr

shadow_prtP.blend

inputs:
  /temp/shadowed_prtPX0001.exr
  /temp/shadowed_prtPY0001.exr
  /temp/shadowed_prtPZ0001.exr
  /temp/bumped_prtP0001.exr
output:
  /temp/bumpshadowed_prtP0001.exr

shadow_prtN.blend

inputs:
  /temp/shadowed_prtNX0001.exr
  /temp/shadowed_prtNY0001.exr
  /temp/shadowed_prtNZ0001.exr
  /temp/bumped_prtN0001.exr
output:
  /temp/bumpshadowed_prtN0001.exr

prt_normalizer_2.blend

inputs:
  /bump/UAO_bumped0001.exr
  /temp/bumpshadowed_prtP0001.exr
  /temp/bumpshadowed_prtN0001.exr
outputs:
  /bump/final_bumped_prtP0001.exr
  /bump/final_bumped_prtN0001.exr

prt_to_bent_normal_2

inputs:
  /bump/final_bumped_prtP0001.exr
  /bump/final_bumped_prtN0001.exr
output:
  /temp/bumped_bent_normal_model_space0001.exr

bent_normal_to_tan_sp_2R.blend

inputs:
  /bakes/U_vec.exr
  /temp/bumped_bent_normal_model_space0001.exr
output:
  /temp/bumped_bent_normal_tangent_spaceR0001.exr

bent_normal_to_tan_sp_2G.blend

inputs:
  /bakes/V_vec.exr
  /temp/bumped_bent_normal_model_space0001.exr
output:
  /temp/bumped_bent_normal_tangent_spaceG0001.exr

bent_normal_to_tan_sp_2B.blend

inputs:
  /bakes/N_vec.exr
  /temp/bumped_bent_normal_model_space0001.exr
output:
  /temp/bumped_bent_normal_tangent_spaceB0001.exr

bent_normal_to_tan_sp_2.blend

inputs:
  /temp/bumped_bent_normal_tangent_spaceR0001.exr
  /temp/bumped_bent_normal_tangent_spaceG0001.exr
  /temp/bumped_bent_normal_tangent_spaceB0001.exr
output:
  /bump/final_bent_normal_tangent_space0001.exr

JsnMtth asked,

How did LaGrande get started?

I don't remember anymore. I think the idea of using blender noodles just opened up so many possibilities it caused CineMut to evolve. The original CM began from just using a standard texture packing, with un-processed bakes thrown in some channels. The idea of doing complex processing on image data was out of the question because of precision losses in trying to do so in Gimp. Once Blender nodes came out, working at 32-bit per color channel precision, that limitation was removed: We could now do anything we wanted, and as much as we wanted, without precision losses, so the paradigm shifted: Anything that's too costly for the shader to compute and warrants a texture channel, we can provide for its off-line computation in LaGrande.
But that came later, actually; the first LaGrande noodles I did were for mixing and compositing textures, and add effects like scratches and burns and dirt-streaks; –things I was already doing with Gimp, albeit with precision-related artifacts.