Render To Texture (also known as Texture Baking) is a procedure for capturing various aspects of 3ds Max geometry scene objects' surfaces to bitmaps using the production renderer. The Default Scanline renderer supports this functionality.

The actual 3ds Max Render To Texture tool available through the Main Menu>Rendering>Render To Texture menu item is implemented as a scripted tool. Its source code can be found in the following subfolder of the 3ds Max installation:

..\MacroScripts\Macro_BakeTextures.mcr

In addition, some Render To Texture methods used by the network version of the tool can be found in the file

..\stdplugs\stdscripts\RTT_methods.ms

Render To Texture Components

Here is a short overview of the MAXScript classes, interfaces, properties and methods used in the process and how to use them to create your own texture baking tools:

Bake Elements

The main object class involved in the texture baking process is the Bake Element.

It implements an object capable of capturing a specific channel out of the production renderer, for example Diffuse, Lighting, Ambient Occlusion, Normals, Shadows and so on.

INodeBakeProperties Interface

The geometry objects whose surfaces will be baked have to be set up for the process using the INodeBakeProperties Interface exposed by all scene nodes.

This interface is used to add one or more Bake Elements to specific nodes, enable the baking and control some other related parameters.

Production Renderer

The production renderer, including the Default Scanline renderer, has to be called via MAXScript in a special mode invoked via

render rendertype:#bakeSelected

Unwrap UVW

For the baked texture to be usable, the object being rendered has to provide good texture coordinates without any overlapping.

The Render To Texture script shipping with 3ds Max provides controls over the automatic application and setup of Unwrap_UVW Modifiers to ensure the texture coordinates are usable for baking. You might have to ensure the same in your own script, unless your object has good UV coordinates to work with.

Projection Mapping

In some cases, especially when generating Normal Maps, the surface being rendered is a high-resolution version of an object, while the target object being mapped is a lower-resolution version. In this case, the texture coordinates of the low-resolution object have to be generated by projecting from the high-resolution one.

The Interface: INodeBakeProjProperties, the Projection Modifier and the Project_Mapping ReferenceTarget are the main elements of the Projection Mapping system of 3ds Max.

Shell Material

The Shell Material has been specifically designed to be used together with the Render To Texture tools. It can hold two different materials, typically the original material and the baked material. Either one can be used in the Viewport or in the Renderer.

Developing a Simple Render To Texture Script

The following example shows the basic steps to create a custom Render To Texture script.

The script creates a simple scene containing a textured sphere on a textured plane lit by a shadow-casting omni light.

Then it bakes the Diffuse and Lighting Elements of both objects to TGA files on disk and creates a Shell Material containing the old material in the one slot and the baked material in the other.

The Baked material uses a Composite map to combine the diffuse and the lighting information into a single diffuse map.

In this simple case, the texture coordinates of both objects are procedurally generated by the geometry primitives and are usable for baking. Also, no projection mapping is required in this simple case.

SCRIPT

fn BakeDiffuseAndLighting obj size =
(
--Clear all render elements 
obj.iNodeBakeProperties.removeAllBakeElements() 
--Preparing the Bake Elements:
be1 = diffusemap() --instance of the bake element class
be1.outputSzX = be1.outputSzY = size --set the size of the baked map
--specifythe full file path, name and type:
be1.fileType = (getDir #image+"\\"+obj.name+"_diffuse.tga")
be1.fileName = filenameFromPath be1.fileType
be1.filterOn = true --enable filtering
be1.shadowsOn = false --disable shadows
be1.lightingOn = false --disable lighting
be1.enabled = true --enable baking
be2 = LightingMap() -- instance of the bake element class
be2.outputSzX =be2.outputSzY = size --set the size of the baked map
--specifythe full file path, name and type:
be2.fileType = (getDir #image+"\\"+obj.name+"_lighting.tga")
be2.fileName = filenameFromPath be2.fileType
be2.filterOn = true --enable filtering
be2.shadowsOn =true --enable shadows
be2.enabled = true --enable baking
--Preparing theobjectfor baking:
obj.INodeBakeProperties.addBakeElement be1 --add first element
obj.INodeBakeProperties.addBakeElement be2 --add second element
obj.INodeBakeProperties.bakeEnabled = true --enabling baking
obj.INodeBakeProperties.bakeChannel = 1 --channel to bake
obj.INodeBakeProperties.nDilations = 1 --expand the texturea bit
select obj --we are baking the selection, so we select the object
--Call the renderer to bake both elements:
render rendertype:#bakeSelected vfb:off progressBar:true outputSize:[size,size]
theComp = CompositeTextureMap() --create a composite map
theComp.add() --add a second layer
theComp.blendMode = #(0,5) --set second layer to Multiply 
--Create two maps, one with the diffuse, one with the lighting map
theMap1 =bitmaptexture filename:be1.fileType
theMap2=bitmaptexture filename:be2.fileType
theComp.mapList = #(theMap1,theMap2) --composite the two maps
theComp.opacity = #(100,70) --set the lighting map to 70% opacity
--Create a standard self-illum material using the Composite map
bakedMat = standard diffusemap:theComp selfIllumAmount:100
--Assign a Shell Material to the object,
--keep the old material as original material,
--set the new bakedMat as the baked material:
obj.material = Shell_Material originalMaterial:obj.material\
bakedMaterial:bakedMat viewportMtlIndex:1 renderMtlIndex:1
--Show the textures of the baked material in the viewport
showTextureMap obj.material obj.material.bakedMaterial true
)--end fn

resetMaxFile #noprompt--reset the scene to start from scratch
--Set renderer to scanline
renderers.current = Default_Scanline_Renderer()
--Create a shadow casting white Omni light
theLight = omniLight pos:[0,-60,100] rgb:white
theLight.baseobject.castshadows = true
--Create a mapped sphere object above the ground plane
theObject = Sphere segs:32 mapcoords:true pos:[0,0,25]
--Create a Cellular map and assign via Standard material to object
theMap = cellular cellColor:blue divColor1:red divColor2:yellow size:15
theObject.material = standard diffusemap:theMap
--Call the Bake function with the object and the desired size
BakeDiffuseAndLighting theObject 256
--Create a mappedplaneobjecton theground plane
theObject = Plane width:200 length:200 mapcoords:true
--Create a checker map and set the tiling to 4x4, then assign to object
theMap = checker Color1:green Color2:orange
theMap.coordinates.uTiling = theMap.coordinates.vTiling = 4
theObject.material = standard diffusemap:theMap
--Call the Bake function with the object and the desired size
BakeDiffuseAndLighting theObject 256
--Delete the light from the scene and deselect everything
delete theLight
max select none

RESULTS

After running the script, the following four baked textures will be written to the Images folder and will appear on the scene objects in the viewports: