• General syntax
• Constants
  • Constant Types
  • Sub-Constant Types
    • Tweak()
    • Image()
• Techniques
• Shaders
  • VertexShader()
  • PixelShader()
  • GeometryShader()
  • ComputeShader()
  • 'Code' Resources
• States
  • BlendState()
  • StencilState()
  • State()
• Misc
  • Globals()
  • Usage()
  • RenderFlags()
  • PrimitiveType()

The syntax for techsets seems really weird and I'm not entirely sure how it works. It seems like names placed inside <> are evaluated to GDT values, stuff placed inside "" are evaluated to the proper type for the field in question, arrays or lists are made with "item1", "item2", .... and various other odd things. There even seems to be a select few mathematical expressions and functions that can be placed into "" along with other data to make various calculations. See rest of docs for more details.

Constants define values and resources for the shader. The constants are stored in the GDT file.

Note: Primitive values stored in the GDT are accessed exactly like <property_name>. An example of this is:

tile = <tileColor>

which accesses the value tileColor from the GDT. Otherwise some unmodifiable constants can be hardcoded into the techset.

Note: It seems like the mod tools will evaluate some strings containing more complicated stuff such as:

// /include/flag_base.techsetdef
float2( "wind1Parms" )
{
    value = "float2( cos( radians( <gFoamScrollAngle0> ) ), sin( radians( <gFoamScrollAngle0> ) ) )"
}
// or
// /include/micro_tile_mix_base.techsetdef
Color( "colorTint1" )
{
    value = "srgb_to_linear( <colorTint1> )"
}
// or
// /include/water_shore_base.techsetdef
float4("controlVar0")
{
    x = "2.0 / (<cg14_x> * <cg14_x>) - 2.0"
    y = "2.0 / (<cg14_y> * <cg14_y>) - 2.0"
    z = "((1.000293 - <cg14_w>) / (1.000293 + <cg14_w>))*((1.000293 - <cg14_w>) / (1.000293 + <cg14_w>))"
    w = "1.0 - (((1.000293 - <cg14_w>) / (1.000293 + <cg14_w>))*((1.000293 - <cg14_w>) / (1.000293 + <cg14_w>)))"
}

I'm not really sure what the full syntax on that is or what is really allowed though.

ConstantType("constant name")
{ 
    property0 = j
    property1 = k
}

ConstantType("constant name").property0 = j
ConstantType("constant name").property1 = k

ConstantType("propertyValue0", "propertyValue1", "propertyValue2", ...)      ??? Unsure about this one

Base type, all constant types inherit these features.
Available Properties:

• tweak
  Defines a tweak to visually represent the property in the editor. (Tweak())
• value
  Directly sets the value to something

Texture sampler
Available Properties:

• tile
  Tiling mode (String)
• filter
  Filtering mode (String)
• nobias
  Unknown (Boolean)

Texture resource
Available Properties:

• ref
  Unknown (Boolean)
• image
  Image (Image())
• semantic
  Unknown (String)
• usage
  Image asset type that is allowed (String)

Color value
Available Properties:

• value
  Linear color values separated by spaces or srgb values with srgb_to_linear("1.0 0.5 0.1 1") (String)

Boolean value
Available Properties:

• value
  Value (Boolean)

Int value
Available Properties:

• value
  Value (Integer)

Single uint
Available Properties:

• value
  Value (UInt)

2 uints
Available Properties:

• x
  Value (UInt)
• y
  Value (UInt)

3 uints
Available Properties:

• x
  Value (UInt)
• y
  Value (UInt)
• z
  Value (UInt)

4 uints
Available Properties:

• x
  Value (UInt)
• y
  Value (UInt)
• z
  Value (UInt)
• w
  Value (UInt)

Single float
Available Properties:

• x
  Value (Float)

2 floats
Available Properties:

• x
  Value (Float)
• y
  Value (Float)

3 floats
Available Properties:

• x
  Value (Float)
• y
  Value (Float)
• z
  Value (Float)

4 floats
Available Properties:

• x
  Value (Float)
• y
  Value (Float)
• z
  Value (Float)
• w
  Value (Float)

Contains information for displaying the tweak. Tweaks are the sliders, fields and text boxes in APE which allow you to modify the constants from the mod tools.

Tweak() {}
Tweak("Category", "Title", "Sort Index (int)") {}

Available Properties:

• category
  Which category to place under (String)
• title
  Display name (String)
• sortindex
  Position in category to place tweak (Int)
• range
  Limits input min and max amount and increment amount. Multiple comma separated strings with the corresponding type e.x. (for float type) range = "0.0, "1.0", "0.1" for min of 0, max of 1 and 0.1 increments.
• color
  Not sure but probably adds a color wheel (Boolean)
• default
  Default values for the tweak (String array)
  Example:

// /sw4/sw4_2d_heatmap.techsetdef
float4( "HeatmapColor" )
{
    x     = <cg05_x>
    y     = <cg05_y>
    z     = <cg05_z>
    w     = <cg05_w>
    tweak = Tweak()
    {
        title     = "HeatmapColor"
        sortindex = "0"
        default   = "0.214286", "0.678571", "1.000000", "1.000000"
        range     = "-1e+009", "1e+009", "0.01"
        color     = false
    }
}

Contains image information for textures

Alternate Syntax:

Image( "primaryImage", "fallbackImage" )
// e.x.
image = Image( <colorMap05, $white_diffuse> )
// for no fallback
image = Image( <colorMap05> )
// or
image = Image( "$default" )

Available Properties:

• map
  Main image path (String)

Techniques are what determine which shaders are used during different lighting states. Not too sure how this works, specifically which lighting states go to what and how multiple states in one technique works...

Technique("state1 state2 state3....")
{
   property0 = j
   ...
}
Technique("state1", "state2", "state3", ....)  // This might actually try to use state 1 and then fall back to the next state? And example I found has both lit and unlit in 'fullscreen/cinematic_mp4_add.techsetdef'....
{
   property0 = j
   ...
}
Technique("state1 state2 state3....") : "state1 state2 state3...."    // This either makes it extend or fallback to the states in the second half, not sure which.
{
   property0 = j
   ...
}

Available Properties:

• source
  The base name for a shader to be used e.g. no ps or vs or anything (String)
• vs
  The Vertex Shader (String) or (VertexShader())
• ps
  The Pixel Shader (String) or (PixelShader())
• gs
  The Geometry Shader (String) or (GeometryShader())
• defines
  Defines preprocessor directors to compile the shader with (String array)
  Example: defines += "GENERATE_MOTION_VECTOR" sets the directive GENERATE_MOTION_VECTOR
  Example: defines = "USE_COLOR_SPEC", "USE_COLOR_TINT", "CHARACTER_CUSTOMIZATION", "NO_VERT_COLOR"
  Example: defines = "USE_VERTCOL 1"
  NOTE: Modifying the defines will change the shader that mod tools looks for when compiling. This is important for an example, if you change the defines on a base-game shader that you do not posses and there is not a compiled version of it for the defines in the shader cache, then the mod tools will say that it could not find the shader.
• state
  Unknown. Sets the next state maybe?
  Example: state = "replace + depth"
• pragmas
  Unknown. Sets pragmas for the shader. No examples of it being used.

Not sure what this is used for but it seems to have the same syntax and properties as Techniques. Just it is called TechniqueTemplate

All the shader types share the same syntax and some properties (excluding compute shaders)

Shader() {}
Shader("decl name") {}  // e.x.  PixelShader("ps_sky") {}
Shader() : "decl name" {}  // e.x.  VertexShader() : "vs_sky" {}

An important thing to note is that I think some constant properties can be defined inside the shader rather than outside the technique. For an example:

// /include/extracam_base.techsetdef
ps = PixelShader()
{
#if TOOLSGFX != "1"
    extracamTexture1 = CodeTexture( "extracamTexture1" )
    extracamTexture2 = CodeTexture( "extracamTexture2" )
    extracamTexture3 = CodeTexture( "extracamTexture3" )
    extracamTexture4 = CodeTexture( "extracamTexture4" )
#endif

    extracamSampler = Sampler( "no tile", "nomip bilinear" )
}

In this example extracamTexture1 through 4 and extracamSampler are available for use in the shader.

Available Properties:

• source
  The base name for a shader to be used e.g. no ps or vs or anything (String)
• defines
  I think it defines preprocessor directors to compile the shader with. Not sure how it works in the context of the shader type. (String array?)
  Example: defines += "GENERATE_MOTION_VECTOR" sets the directive GENERATE_MOTION_VECTOR
  Example: defines = "USE_COLOR_SPEC", "USE_COLOR_TINT", "CHARACTER_CUSTOMIZATION", "NO_VERT_COLOR"
  Example: defines = "USE_VERTCOL 1"
  NOTE: Modifying the defines will change the shader that mod tools looks for when compiling. This is important for an example, if you change the defines on a base-game shader that you do not posses and there is not a compiled version of it for the defines in the shader cache, then the mod tools will say that it could not find the shader.

• vertexDecl
  The decl name for the shader (String)
  Example: vertexDecl = "generic"
  Known decl types: generic, sky

Compute shaders are in files similar to techsets called .csdef files. I think the only thing allowed is a ComputeShader() definition which behaves like and has similar properties to VertexShader() and PixelShader() but, it is not placed in a technique. Instead it inherits some properties from techniques like defines.

ComputeShader("shader name??")
{
    source = "shader name.hlsl"
    defines = ....
}

I think code resources are references to abstract resources in the game i.e. ones that are created at runtime. These are specified in the Technique's shader definition like in the extracam_base example above.

An example of this is the extra cam CodeTexture which is treated as a texture but is actually the output of a camera in memory and is constantly updated. If you are familiar with Unity, a CodeTexture here would be like a Render Texture.

Could not find any examples of this in use so I have no clue how it works.

States seem to choose the overall rendering flags depending on the states selected

Chooses the blending flags
Available Properties:

• colorBlendFunc
  Blending function can be one of [disable, add, ] (Incomplete?, needs more values)
• colorBlendSrc
  Blending function source, can be one of [srcAlpha, One, Zero, DestAlpha] (Incomplete?, needs more values)
• colorBlendDst
  Blending function destination, can be one of [invSrcAlpha, One, Zero, SrcColor, invSrc1Alpha, ] (Incomplete?, needs more values)
• alphaBlendFunc
  Alpha blend function, can be one of [disable, add, ] (Incomplete?, needs more values)
• alphaBlendSrc
  Alpha blend function source, can be one of [srcAlpha, One, Zero, DestAlpha, ] (Incomplete?, needs more values)
• alphaBlendDst
  Alpha blend function destination, can be one of [invSrcAlpha, One, Zero, SrcColor, invSrc1Alpha, ] (Incomplete?, needs more values)
• writeChannels
  Channels to blend (String)
  Example: writeChannels = "rba"

States for stencils

StencilState() {}
StencilState("flags list") {}

Available Properties:

• enable
  Probably enables the stencil feature (Boolean)
• func
  Stencil function to use. One of [Equal, Always, NotEqual] (Incomplete, needs more values)
• opFail
  Result fail. One of [Keep, Replace, ] (Incomplete, needs more values)
• opPass
  Result pass. One of [Keep, Replace, ] (Incomplete, needs more values)
• opZFail
  Result Zfail. One of [Keep, Replace, ] (Incomplete, needs more values)

State contains some base properties. States also allow to have one of the other sub-state types such as BlendState() or StencilState() inside of them.

// /specialty/hud_outline_model_zonly.techsetdef
State( "state" )
{
    blendState = BlendState()
    {
        // Replace
        colorBlendFunc = add
        colorBlendSrc  = One
        colorBlendDst  = Zero
        alphaBlendFunc = add
        alphaBlendSrc  = One
        alphaBlendDst  = Zero
        writeChannels  = ""
    }
    depthWrite  = true
    depthTest   = LessEqual
    cull        = "Back"
}

Available Properties:

• rez
  Unknown (Boolean)
• cull
  Faces to cull (String) Sides: ["None", "back", "front"] or [None, back, front] (Incomplete, needs more values)
  Example: cull = "back"
• polygonOffset
  Unknown (String)
  Example: polygonOffset = "static decal"
• depthTest
  Depth test value. One of: [less, Always, Disable, LessEqual, Equal] (Incomplete, needs more values)
• depthWrite
  Turn on depth write (Boolean)
• stencilFront
  Unknown (String)
  Example: stencilFront = "write stencil"
• stencilBack
  Unknown (String)
  Example: stencilBack = "match ref"
• stencilRef
  Probably the stencil id (int)
• wireframe
  Unknown (Boolean)
• blendState0
  Unknown (String), Example: blendState0 = "gbuffer albedo blend"
• blendState1
  Unknown (String), Example: blendState1 = "gbuffer normal gloss blend"
• blendState2
  Unknown (String), Example: blendState2 = "gbuffer reflectance occlusion blend"
• blendState3
  Unknown (String)
• blendState4
  Unknown (String)
• blendState5
  Unknown (String)
• blendState6
  Unknown (String)
• blendState7
  Unknown (String)

Globals are needed at the top of your techset in order for them to appear in the mod tools. It also provides some access to some high level properties
Available Properties:

• displayName
  Display name of material in mod tools
• category
  Category to place material under in mod tools
• renderFlags
  Unknown (Space separated string) or (RenderFlags()).
  Example: renderFlags = "lit transparent distortion"
• availablePrefixes
  Unknown, something to do with material type (String)
  Example: availablePrefixes = "mc/ mcs/ wc/"
  Full list: mc/, mcs/, wc/, vd/, vdd/, ei/, el/, ec/ (the / is also interchangeable with _)
• gameOnly
  Only allows it to be rendered in-game (Boolean)
• radiantOnly
  Only allows it to be rendered in mod tools (Boolean)
• deprecated
  Unknown (Boolean)
• url
  Unknown (String)

Not sure what Usage does or how it works. It must be specifying what types of texture maps are needed to something.
Available Properties:

• colorMap
  Unknown (Boolean)
• normalMap
  Unknown (Boolean)
• specularMap
  Unknown (Boolean)
• glossMap
  Unknown (Boolean)
• aoMap
  Unknown (Boolean)
• detailMap
  Unknown (Boolean)
• camoMaskMap
  Unknown (Boolean)
• doNotDrop
  Unknown (Boolean)
• normalOverrideMap
  Unknown (Boolean)
• glossOverrideMap
  Unknown (Boolean)
• overrideMap
  Unknown (Boolean)
• flowMap
  Unknown (Boolean)
• effectMap
  Unknown (Boolean)
• revealMap
  Unknown (Boolean)

Render flags probably provide a higher level way of adjusting the rendering states

RenderFlags()
{
    property0 = j
    ....
}
RenderFlags() : "spaced list of flags"
{
    property0 = j
    ....
}
// e.x. renderFlags = RenderFlags() : "lit deferred opaque" { isOccluder = false }

Known list of flags:

• none
• lit
• deferred
• forward
• semi
• opaque
• nocull
• animating
• transparent
• emissive
• sss
• distortion
• decal
• noduplicate
• fx

Available Properties:

• is2D
  Unknown (Boolean)
• forFX
  Unknown (Boolean)
• isEmissive
  Unknown (Boolean)
• isTransparent
  Unknown (Boolean)
• isOpaque
  Unknown (Boolean)
• needCurrentResolve
  Unknown (Boolean)
• needCurrentDepthResolve
  Unknown (Boolean)
• needOpaqueResolve
  Unknown (Boolean)
• needOpaqueDepthResolve
  Unknown (Boolean)
• isOccluder
  Unknown (Boolean)
• requiresPrepass
  Unknown (Boolean)
• castsShadows
  Unknown (Boolean)
• noDuplicate
  Unknown (Boolean)
• postBlur
  Unknown (Boolean)
• isWater
  Unknown (Boolean)
• platformOrbis
  Unknown (Boolean)
• isGbuffer
  Unknown (Boolean)
• isAnimating
  Unknown (Boolean)
• isDoubleSided
  Unknown (Boolean)
• isDecal
  Unknown (Boolean)
• isSubSurfaceScattering
  Unknown (Boolean)
• noBspCollision
  Unknown (Boolean)
• shouldSortIndices
  Unknown (Boolean)

As far as I know this is only seen at the bottom of state.techsetdef. No clue what it does.
Available Properties:

• value
  Unknown (String)
• indexCount
  Number of vertices (int) From state.techsetdef

PrimitiveType ("trilist")
{
    value = "TriList"
    indexCount = 3
}

PrimitiveType ("patch")
{
    value = "Patch"
    indexCount = 1
}

PrimitiveType ("pointlist")
{
    value = "PointList"
    indexCount = 3
}

PrimitiveType ("rectlist")
{
    value = "RectList"
    indexCount = 3
}

#if PLAT_ORBIS == "1" 
PrimitiveType ("quadlist")
{
    value = "QuadList"
    indexCount = 4
}
#endif