meta data for this page
  •  

This is an old revision of the document!

Texture Packing

During game format exporting, the process of texture packing converts the artist-friendly material maps into the final game-formatted textures. For example, a common thing to do is have the color and opacity placed into one 4-channel RGBA texture.

The Modeler comes with a number of different texture packers for various engines, depending on which version of the Modeler you are using. You can edit these or even make your own if you need something different.

Structure

All texture packers are stored on disk in the <apps install>/texture_packing/ directory. Each one consists of two files: an XML file describing the packer and the output, and a small shader that is run to fill the final textures up using the map information from the materials.

<SpeedTreeTexturePacker> Shader - name of the shader file to use
ForceTextures - Sets whether a texture is to be written even if it is empty or a solid color. This will make a very tiny texture instead of full-res to save of texture memory. If false, the color will be saved into the mesh, if possible.
<Texture*> Suffix - suffix added to the filename for this texture
MipGenerationFlag - Can be “None”, “AlphaIsOpacity”, or “RgbIsNormal”. These are flags to help the generation of mips be better for texture formats that store mips (DDS).
Skip - Skip this texture entirely. Omitting a Texture* tag will also skip it.

The shader file is similar to a render mode shader, where you are writing a single function called by a bigger shader. However, for texture packing you will implement a TexturePacking() function whose input and output is a little different. The input consists of all of the maps from the material, already with texture/color adjustments applied, along with a few extra pieces of information and utilities (like noise). 

  struct STexturePackingInput
  {
      float3		m_vColor;
      float		m_fOpacity;
      float3		m_vNormal;
      float		m_fGloss;
      float3		m_vSpecularColor;
      float		m_fMetallic;
      float3		m_vSubsurfaceColor;
      float		m_fSubsurfaceAmount;
      float		m_fAmbientOcclusion;
      float		m_fHeight;
      float3 		m_vCustom;
      float3 		m_vCustom2;
      
      float		m_fNoise;
      
      bool 		m_bTwoSided;
      bool 		m_bAtlas;
      bool 		m_bBillboards;
      
      float2		m_vTexcoord;
  };

The output structure simply contains all of the possible RGBA outputs (up to 16). The packing process tries to be as smart as possible when writing out the textures. If you only write .r, you will get a grayscale/luminance texture. If you only write .rgb you will get a 3 channel texture. And finally, if you write all .rgba, you will get a full 4 channel texture on disk. 

  struct STexturePackingOutput
  {
      float4 		m_vTexture0;
      float4 		m_vTexture1;
      float4 		m_vTexture2;
      float4 		m_vTexture3;
      float4 		m_vTexture4;
      float4 		m_vTexture5;
      float4 		m_vTexture6;
      float4 		m_vTexture7;
      float4 		m_vTexture8;
      float4 		m_vTexture9;
      float4 		m_vTexture10;
      float4 		m_vTexture11;
      float4 		m_vTexture12;
      float4 		m_vTexture13;
      float4 		m_vTexture14;
      float4 		m_vTexture15;
  };

Custom Example