Other JMO assets for Unity:
Cartoon FX 1 Cartoon FX 2 Cartoon FX 3 Cartoon FX 4 Shape FX War FX MatCap Shaders (Free)

Toony Colors Pro+Mobile 2

Documentation

Thank you for your interest in Toony Colors Pro+Mobile 2!
This document will explain and provide examples for each feature of Toony Colors Pro 2.

Note that topics of this documentation can be accessed directly from Unity by clicking on the   icons.


About

Toony Colors Pro 2 (abbreviated TCP2) is a set of shaders and scripts used to help you give a stylized look to your Unity game or application.

As of version 2.2, there are two main workflows to choose from:

The Physically-Based Shaders are only available in Unity 5.3 and greater versions

The Legacy shaders come with two main features:

Here are some examples on a basic sphere:

Unity Diffuse Shader
Toony Colors Pro 2
TCP2 with no Ramp Smoothing
TCP2 with Texture Ramp
Sketch Overlay and Outline
Texture Ramp and Textured Threshold
Detail texture and Halftone Sketch
Rim Reflection and black Outline
Bump, Rim, Outline and Colored Shadows
Legacy or Physically-Based?

Choosing between the two workflows might not be as easy as it seems: because TCP2 is used to get stylized visuals, there may be some cases where you want to avoid replicating the physical reality of light interaction.
In such cases, using PBS shaders should be avoided in favor of the Legacy ones.

Here is a pros/cons list that can help choosing between either workflow:

Standard PBS Legacy Shaders
PROS CONS PROS CONS
Easier material setup similar to Unity's Standard shader, with additional stylization options Less stylization options: features like sketch or textured threshold are not supported in the PBS shaders More control: you can precisely tweak all values to get the exact look wanteds Longer material setup: more control means more settings to adjust!
Works in all lighting settings: no need to do further tweaks to materials once they're properly configured Limited value ranges: you can't go too much outside the "physical" values and get extreme results (that's actually the whole point of PBS!) More Stylization: e.g. comic-book like visuals using features like halftone or sketch features Less consistency: you may have to readjust material settings so that they fit in each environment
Automatic mobile version: the correct shader is loaded internally depending on the target platform Higher Cost: the Standard shader generally requires more GPU power than the Legacy ones (even though there's also a mobile version) Better Performance: e.g. unlike Standard where everything has specular and reflections, you can entirely disable these features in Legacy thus resulting in a faster shader
Stylization in 1 click: the shader will get settings defined for a material using the default Standard shader Shader Generator: more features to choose from, and get the ultimate stripped-down shader with just the code you need
Getting Started

Physically Based Workflow

Assign the following shaders depending on the wanted workflow:

From there, similarly to Unity's Standard shader, the correct subshader will be used based on the texture maps and features used, as well as the target platform (meaning that the mobile version of the shaders will automatically be loaded when targetting mobile devices).
TCP2 will additionnally load the relevant Outline shader if that feature is enabled.

Legacy Workflow

Assign one of the Unified Shader to your material(s) depending on the device you target:

You can then select the options you want for your material (bump, specular, rim lighting, outlines...) and it will automatically choose the correct shader, making sure you don't have any unused feature loaded.

Internally the shader selection works in two steps:
- it chooses the correct high-level .shader file depending on the selected features (outlines for example)
- Unity then loads an internal shader variation based on the settings choosed, just as it regularly does to turn lightmaps on or off for example (using multi_compile directive)

Each .shader file has up to 928 internal variations, which is why the compilation may take a little longer for some of the shaders!
The compilation only happens once when first importing the pack.
At Build Time, the compilation can take a lot of time depending on how many shaders are used. This is because Unity will fully compile each variation in each shader file.
These compiled shaders are then cached, so this will only happen during the first build of your application, as long as you don't modify the shaders afterwards.
PBS Material Inspector / Standard PBS Shader

The Standard PBS Material Inspector is based on Unity's Standard material interface, with additional stylization options.

The Standard Properties are the same that you will find on the Standard shader:

Please refer to the Unity manual for more information about the Standard Properties.


The Toony Colors Pro 2 properties control the following features:


 

Main and Additional Lights Ramp Control

When not using a ramp texture, you have an additional setting to define a separate smoothing for the main directional light and additional lights.

  • Threshold: defines the separation between shadows and highlights
  • Main Light Smoothing: smoothing of the separation between shadows and highlights for the main directional light
  • Other Lights Smoothing: smoothing of the separation between shadows and highlights for additional lights
Main Light = 0.1
Additional Lights = 0.1
Main Light = 1.0
Additional Lights = 0.1
Main Light = 0.1
Additional Lights = 1.0
 

Stylized Specular

Will add a smoothing value allowing to get a crisper specular term. You can also blend between the regular and the stylized specular to get an hybrid look.

  • Specular Smoothing: defines how crisp the specular highlights should look
  • Specular Blend: blending value between the Standard and Stylized specular visuals
Stylized Specular disabled
Stylized Specular enabled
Stylized Specular with 0.5 blending
 

Stylized Fresnel

Will add an enhanced Fresnel effect linked to lights around the model.

  • Fresnel Strength: defines how visible is the enhanced Fresnel effect (note that the strength is also dependent on the Smoothness of the material)
  • Fresnel Min/Max: defines the threshold values for the Fresnel effect (similar to the Rim effect)
Stylized Fresnel enabled
Stylized Fresnel disabled
Unified Material Inspector / Unified Shader

The Unified Material Inspector allows you to toggle features on and off and let Unity pick and compile the right shader for you. This will ensure that only the features you care about are included in the compiled shader, so that it runs as fast as possible.

There are two versions of the Unified Shader included with Toony Colors Pro 2:

Note that the desktop version can work smoothly on some high-end mobile devices, so it can make sense to use it for mobile on your main character for example.
Toony Colors Pro 2
Unified Material Inspector

FEATURES

Base Properties

There are 3 colors in the base properties:

  • Color is the regular tint Color multiplied with the whole model
  • Highlight Color is the a tint Color only applied to the lit parts of the model
  • Shadow Color is the a tint Color only applied to the unlit parts of the model

Examples:

Default Colors
Green Color
Green Highlight Color
Green Shadow Color

The Base texture is the main one. Its alpha channel can be used as a gloss map when Specular is enabled.

Wrapped Lighting with one point light
Wrapped Lighting disabled
  • Disable Wrapped Lighting will change how diffuse lights cover the models, meaning lighting will appear more focused.
    It can also help when real-time shadow artifacts become too aparent on the model.
 

Ramp Style

The slider ramp style allows you to define the lit/unlit threshold value, as well as its smoothness (hard or soft line separating shadows from highlights).

The texture ramp style allows you to use a 1D texture (horizontal texture with 1 pixel height) defining the shading from lit to unlit.

Slider Ramp Examples:

Threshold = 0.5
Smoothness = 0.2
Threshold = 0.3
Smoothness = 0.5
Threshold = 0.75
Smoothness = 0.01

Texture Ramp Examples:

Unity toon ramp
Old school ramp using point filtering mode
Backlit ramp
 

Normal/Bump Map

Enables normal map support.

Stars normal map
Ramp Smoothing = 0.1
Granular normal map
Ramp Smoothing = 0.4
 

Specular

Enables Blinn-Phong specular.

  • Regular: default Blinn-Phong specular
  • Cartoon: allows you to define the smoothness of the specular highlight
Regular Specular
Shininess = 0.1
Cartoon Specular
Smoothness = 0.1
 

Reflection (Desktop)

Enables cubemap-based reflections.

  • Global: applies the reflection on the whole model
  • Masked: uses the main texture's alpha channel to mask parts of the reflection
  • Reflection Color (RGB): tint color applied to the reflection
  • Reflection Color (Alpha): defines the reflection intensity
  • Use Reflection Probes: will take reflection data from Reflection Probes
Global Reflection
Masked Reflection
 

MatCap (Mobile)

Enables texture-based fixed reflections, using a simple square texture. See my free MatCap Shader Pack for more examples!

  • Global: applies the reflection on the whole model
  • Masked: uses the main texture's alpha channel to mask parts of the reflection
  • Reflection Color (RGB): tint color applied to the reflection
  • Reflection Color (Alpha): defines the reflection intensity
Additive MatCap
MatCap texture used
Multiplicative MatCap
MatCap texture used
 

Rim Effects

Enables rim effects, where intensity depends on the view direction and the face normal.

  • Lighting: adds a color based on the rim factor (a.k.a. rim lighting)
  • Outline: multiplies a color based on the rim factor
  • Rim Color (RGB): defines the rim color
  • Rim Color (Alpha): defines the rim intensity
  • Rim Min/Max: define the thresholds based on the rim value
  • Directional Rim (XY): allows control of the rim direction (e.g. only coming from top)
Red rim lighting
Min = 0.3, Max = 1
Red rim lighting
Min = 0.6, Max = 0
Directional rim lighting
Direction Y = 0.5
Black rim outline
Min = 0.2, Max = 0.8
Red rim outline
Min = 0.5, Max = 0.55
 

Outline

Adds a mesh-based outline to the model. Note that this will add 1 draw call.

The outline works as follow:
- an extruded version of the mesh (based on its normals) is rendered with a full unlit color, and with its faces flipped
- the regular model is rendered on top of it, creating the illusion of outlines

The outline may show incorrectly for meshes with hard edges. In this case you can use TCP2's Smoothed Normals Utility to correct the artefacts.
Regular hard edge normals
Smoothed normals stored in UV2
(hard edge shading is preserved)
  • Opaque: solid color outlines
  • Blended: allows you to set a blending mode to the outlines, to make them transparent for example
  • Outline Color: alpha can control opacity depending on the blending mode selected with Blended Outlines
  • Outline Width: defines how much to extrude the mesh from the vertex normals to draw the outline
  • Outline Color From Texture (Desktop only): takes the outline color from the main texture (averaged and multiplied with the outline color)
    • Texture Outline LOD: defines the mip map level from which to sample the texture color (higher = more blurring)
  • Constant Size Outline: outline size will stay the same relatively to the screen
  • Correct Z Artefacts: allows you to tweak the outline extrusion to correct artefacts from complex models
  • Outline Normals
  • Regular: use the regular vertex normals
  • Vertex Colors: use the vertex colors as normals
  • Tangents: use the vertex tangents as normals (will prevent bump maps and anisotropic specular from working)
  • UV2: use the vertex second texture coordinates as normals
Change this setting when you use TCP2's Smoothed Normals Utility to correct hard-edged models.
    Outline Blending
  • Source Factor: hardware blending source factor
  • Destination Factor: hardware blending destination factor
Blending modes examples:
SrcAlpha / OneMinusSrcAlpha: alpha transparency
DstColor / Zero: multiplicative
One / One: additive
OneMinusDstColor / One: soft additive
Black opaque outlines
Width = 1.5
Outline color from texture
Additive blended outline
Shader Generator options
  • Outline behind model: will make the outline appear behind the model (sorting may not work correctly with other objects)
 
Shader Generator

The Shader Generator allows you to generate your own shader files with even more features than in the Unified Material Inspector. Indeed each on/off feature in the Unified Shader doubles the number of internal variants, which quickly adds up to lots of internal shader programs. Moreover, Unity's shader_feature directive has its limits.

Thus generating your own shader files with no variants and exactly the features you need allows for faster compilation and iteration.

USAGE

There are a lot of additional features available, however if you select too many at the same times the shader might not be able to compile. This is generally due to the limitations of vertex interpolators in Shader Model 3.

You can open a generated shader for modification directly in the Shader Generator by clicking on the   icon in the Material Inspector!
The Shader Generator relies on the ShaderImporter.userData string to store information about the features so that they show correctly in the Inspector. Be careful if you also use it in your scripts.

TEMPLATES

You can load other templates to generate different types of shaders.
List of included templates:

By default the template files are in the JMO Assets/Toony Colors Pro/Editor/Shader Templates/ folder.


ADDITIONAL FEATURES (only available with the Shader Generator)

Textured Threshold

This is a powerful feature to achieve a hand-painted look directly on the shading.

The regular shading is defined on a continuous line, more or less smooth depending on the Ramp Smoothing (or Ramp Texture if using one).
Textured Threshold allows you to add a texture pattern along this line.

Properties
  • Threshold Texture (Alpha): offset the lit/unlit threshold based on the alpha channel
Only the Alpha channel is used: values > 128 will add to the threshold, values < 128 will subtract from it (a value of 128 has no effect)

Examples:

Using a texture ramp (no threshold texture)
Achieving a hand-painted look
Texture used for the hand-painted look
Using a noise-based threshold texture
Noise texture used for the previous look
 

Diffuse Tint

Adds a smooth tint to the model, based on the non-ramped diffuse term.
Can be used to add subtle color fringing in the transition between highlights and shadows for example.

Properties
  • Diffuse Tint: the tint color

Examples:

Regular look
With a blue diffuse tint
 

Detail Texture

Adds another texture on top of the main one, with its own tiling and offset values.

Properties
  • Detail (RGB): the detail texture
Options (Shader Generator)
  • Use UV2 coordinates: use second UV coordinates for the detail texture

Example:

Rock detail texture over main checker texture
 

Color Mask

Enables main color masking. Can be useful if you want to create a customizable color based on the main texture's alpha channel, for example.

 

Vertex Colors

Tints the whole model according to its vertex colors.
Can be used to simulate ambient occlusion, vertex-based lightmap, or regular tinting to add color variations on the same texture while keeping dynamic batching.

Example:

Simple vertex-based color tinting
 

Vertex Texture Blending

Blends two textures based on the vertex colors alpha value. 0 = first texture, 1 = second texture, values in-between = blend between the two.

Options (Shader Generator)
  • Normal Map Blending: also blend between two normal map textures

Example:

Blend between two textures
 

Emission (Self-Illumination)

Adds emission based on a mask, a color, or both.

Properties
  • Emission Color: tint color for the emission light (RGB) and emission strength (Alpha)
Options (Shader Generator)
  • Emission Map: uses a mask for emission
  • Emission Color: enables the Emission Color property
  • HDR Color: makes the Emission Color an HDR color that can go outside the [0:1] range (useful for effects like bloom)

Example:

Simple emission
Color tinted emission
 

Normal/Bump Map (Shader Generator)

Enables normal map support.

Properties
  • Normal Map (RGB): normal map texture
  • Heightmap (Alpha): heightmap controlling the parallax effect (alpha channel only, can be the same texture defined in the normal map)
  • Height: strength of the height parallax effect
Options (Shader Generator)
  • Bump Scale: adds a float value to control the bump strength, like Unity's Standard shader
  • Parallax/Height Map: enables the Parallax/Height map support
Stars normal map
Ramp Smoothing = 0.1
Granular normal map
Ramp Smoothing = 0.4
 

Independent Shadows

Prevents dynamic shadows (the ones that appear when you enable Hard or Soft Shadows in your light settings) from being merged with shadows from direct lighting.

In the example below, a cube is projecting its shadow on the sphere:

Default: dynamic shadow merged with lighting
Independant shadow: dynamic shadows are separate
 

Specular (Shader Generator)

Enables specular highlights.

Options (Shader Generator)
  • Regular: default Blinn-Phong specular
  • Anisotropic: Ward anisotropic specular
  • Specular Mask: uses a mask for specular (aka gloss map)
  • Shininess Mask: uses a mask for shininess (allows variable shininess on the same material)
  • Cartoon Specular: allows you to define the smoothness of the specular highlight
Regular Specular
Shininess = 0.1
Cartoon Specular
Smoothness = 0.1
Anisotropic Specular
Aniso. Spread = 0.65
 

Reflection (Shader Generator)

Enables cubemap-based reflections.

Options (Shader Generator)
  • Reflection Mask: uses a mask for reflection
  • Reflection Color: tints the reflection color (RGB) and sets its strength (Alpha)
  • Reflection Roughness: defines the MipMap level at which to sample the texture, to simulate blurry reflections
  • Rim Reflection/Fresnel: the reflection will only appear according to the rim settings (i.e. at grazing angles on the model)
MipMaps need to be enabled on the Cubemap texture for Roughness to work!

Global Reflection
Masked Reflection
Blurry Reflection
Roughness = 6
Rim/Fresnel Reflection
 

Subsurface Scattering

Enables subsurface scattering, i.e. light that scatters inside the model.

Options (Shader Generator)
  • Subsurface Lights: defines which lights will affect subsurface scattering
  • Subsurface Mask: mask for the subsurface effect (typically a thickness map)
  • Subsurface Color: colors the subsurface effect (back lighting only)
  • Subsurface Ambient Color: adds an ambient subsurface color, affecting both back and front lighting
  • Multiplicative: makes the subsurface effect multiplied with the diffuse color, instead of added to it
Here's an easy way to generate an approximative thickness map in most 3D modeling software:
  • Flip your model's normals (i.e. flip faces)
  • Bake the ambient occlusion map
  • Invert the colors on the resulting texture
  • Use it as a mask for subsurface scattering

Point light is behind the sphere, with orange subsurface color
 

Cubemap Ambient

Enables cubemap-based ambient lighting. Think of it as directional ambient colors (for example, ambient light from the top will be blue like the sky, ambient light coming from the bottom will be brown like the ground).
The effect is very subtle but really helps to anchor your dynamic objects in your scene.

Properties
  • Ambient Cubemap: the cubemap from which to sample colors
It is recommended to use a blurred version of the skybox cubemap as your Ambient Cubemap!

Default
Cubemap Ambient
 

Directional Ambient

Enables directional ambient lighting, using 6 user-defined colors. This is cheaper than Cubemap Ambient and colors can be easily interpolated to simulate dynamic ambient lighting for example.
The effect can be very subtle but really helps to anchor your dynamic objects in your scene.

Properties
  • Right, Left, Top, Bottom, Front, Back: the 6 colors corresponding to the 6 world axis (positive and negative XYZ)

Default
Directional Ambient
with strong colors
 

Rim Effects (Shader Generator)

Enables rim effects, where intensity depends on the view direction and the face normal.

Properties
  • Rim Color (RGB): defines the rim color
  • Rim Color (Alpha): defines the rim intensity
  • Rim Min/Max: define the thresholds based on the rim value
  • Rim Direction (XY): allows control of the rim direction (e.g. only coming from top)
Options (Shader Generator)
  • Rim Lighting: adds a color based on the rim factor (a.k.a. rim lighting)
  • Rim Outline: multiplies a color based on the rim factor
  • Vertex Rim: calculates the rim term per-vertex rather than per-pixel (less accurate but much faster)
  • Directional Rim: enables the Rim Direction property
  • Rim Mask: uses a mask for the rim effect
  • Light-based Mask: masks the rim effect based on nearby lights
Red rim lighting
Min = 0.3, Max = 1
Red rim lighting
Min = 0.6, Max = 0
Directional rim lighting
Direction Y = 0.5
Black rim outline
Min = 0.2, Max = 0.8
Red rim outline
Min = 0.5, Max = 0.55
 

MatCap (Shader Generator)

Enables texture-based fixed reflections, using a simple square texture. See my free MatCap Shader Pack for more examples!

Properties
  • MatCap Texture (RGB): the MatCap texture
  • MatCap Color (RGB): tints the MatCap
  • MatCap Color (Alpha): sets the strength of the MatCap
Options (Shader Generator)
  • MatCap Add: MatCap will be added
  • MatCap Multiply: MatCap will be multiplied
  • MatCap Mask: uses a mask for the MatCap effect
  • Pixel MatCap: compute MatCap effect per-pixel, useful if you are using normal maps
  • MatCap Color: enable the MatCap Color property
Additive MatCap
MatCap texture used
Multiplicative MatCap
MatCap texture used
 

Sketch

Adds a screen-space overlay texture on the shadowed areas. Allows a hand-painted stroke effect for example.

Properties
  • Sketch (Alpha): the overlay texture
  • Sketch Anim Speed: animation speed when enabled
An easy way to make an alpha texture is to set the Import Settings to 'Advanced', enable 'Alpha from Grayscale' and set the format to 'Alpha 8'
By default the screen-space texture is offset by the object's position, to remove the 'shower door' artefact (seeing that the texture is an overlay on the whole screen)

This effect doesn't work correctly in the Scene View: the vertical offset is inverted there.
Options (Shader Generator)
  • Sketch Overlay: adds a screen-space overlay texture on the shadowed areas
  • Sketch Gradient: binary overlay texture based on min/max values (allows half-tone effects)
  • Sketch Blending: defines how to blend the sketch texture with the model's color
  • Animated Sketch: animates the texture coordinates
  • Vertex Coords: calculate screen-space coordinates per-vertex rather than per-pixel (less accurate but faster)
  • Disable Obj-Space Offset: disables offsetting the texture from the object's position (the texture will stay fixed relative to the screen, i.e. each pixel on the screen will always map to the same texture color)
Sketch Overlay with strokes texture
Sketch Gradient with strokes texture
Sketch Gradient with halftone texture
Textured Sphere with regular Sketch Overlay
Textured Sphere with
Color Burn blending
 

Alpha Blending

Enables blending on the model. Allows soft transparency but may cause sorting issues with other semi-transparent objects.

Alpha Blending will be enabled by default, but you can change the source and destination blend factors to create other effects such as additive blending. See Unity's manual about blending for more information.

Properties
  • Source Factor: source blending factor
  • Destination Factor: destination blending factor
Alpha blending over blue background

You can define other blending modes than regular alpha-based transparency.
The following examples are in the form Source Factor / Destination Factor > Result

  • Src Alpha / One Minus Src Alpha > Alpha Blending (regular transparency)
  • One / One > Additive Blending
  • One Minus Dst Color / One > Soft Additive Blending
  • Dst Color / Zero > Multiplicative Blending
 

Alpha Testing (Cutout)

Enables alpha testing on the model. Allows binary transparency with proper depth sorting.

See Unity's manual about alpha testing for more information.

Properties
  • Alpha cutoff: threshold at which alpha value becomes transparent
Alpha testing over blue background
 

Shader Target

Defines the shader target level to compile for.

Shader Model 3.0 is the default value and should work for most GPUs (desktop and mobile).
Shader Model 2.5 is recommended to maximize mobile device compatibility (only available in Unity 5.4+).
Shader Model 2.0 can be used to target very old devices but will limit the complexity of the generated shader.

See Unity's manual about shader compilation target levels for more information.

 

Double-Sided

To get double-sided rendering, use these options:

  • Set Culling to Off (double-sided) so that backfaces are rendered.
  • (optional) Enable Backface lighting to get accurate lighting calculation for backfaces (Shader Target 3.0+)

See Unity's manual about shader compilation target levels for more information.

Shader Generator : Masks

Some features can be masked using vertex colors or a texture.

Usage is pretty simple:

The mask UV settings are the same for each mask, so if you change it for Mask 1 anywhere it will be reflected everywhere Mask 1 is used.

For example, if you want to use the main texture's alpha channel as a gloss map, in the Specular Mask feature choose Main Texture and Alpha.

Smoothed Normals Utility

The Smoothed Normals Utility allows you to solve this situation:

Regular hard edge normals
Smoothed normals stored in UV2
(hard edge shading is preserved)

HOW IT WORKS

The outlining technique is based on the mesh normals. When a vertex has multiple normals (aka hard edge shading), it can break the outline as shown above.
The Smoothed Normals Utility will calculate the average normals for each vertex of your mesh, and assign them to an unused part of your mesh data (vertex colors, tangents, or second UV coordinates)

By enabling the corresponding option in the Outline properties, the shader will take this data as the new normals to draw the outline.
This way you get a correctly outlined mesh with hard-edge shading preserved.

USAGE

Open the utility via the menu: Tools > Toony Colors Pro 2 > Smoothed Normals Utility

In Unity, select:

The meshes ready to be processed should appear in the Smoothed Normals Utility when it gets the focus.
Select the mesh data where you want to store the smoothed normals: Click on "Generate Smoothed Mesh" to generate a copy of the mesh with smoothed normals in the selected mesh data.
The new mesh will automatically be assigned if you had MeshFilters or SkinnedMeshRenderers selected.

Smoothed Normals will only be stored in Tangents for skinned meshes.
This is because normals need to be affected by bones, and in the 3 options available only tangents are affected by bones (vertex colors and UV2 data are not). Thus smoothed normals can only work stored in tangents for skinned meshes.
This means that smoothed normals can't work with normal/bump maps or anisotropic specular on skinned meshes.
If a copy of the mesh has already been made, it will be overwritten with the new settings defined.
You can recognize the generated meshes with the [TCP2 Smoothed] suffix, and they are all stored in the 'Smoothed Meshes' folder by default.
Ramp Generator

The Ramp Generator allows you to create a ramp texture (to be used with the texture ramp feature) very easily from a gradient.
Simply edit the gradient and set a texture width size. The texture height will always be 4 pixels tall.

Ramp Generator

The Ramp Generator can also edit back ramps generated with it, allowing you to edit the gradient and see the results in real-time on your models/materials.

You can edit a gradient ramp either by:

Ramp Editor
Unpack Shaders

To avoid very long loading times when Toony Colors Pro 2 is imported in Unity, some of its shaders are packed in an archive.
You can unpack these shaders by category (reflection, rim effects...) if you ever need them.
Depending on your machine, the importing process can be more or less long.

You can unpack shaders via the menu: Tools > Toony Colors Pro 2 > Unpack Shaders > ...

Further Help
You can take a look at the FAQ page for specific issues.
If you still have questions, bug reports or suggestions please contact me by email: jean.moreno.public+unity@gmail.com
Using Curved World
You can use the Curved World system by Davit Naskidashvili with Toony Colors Pro 2 as of version 2.12.
This feature requires the Curved World package from the Asset Store.

Open the Shader Generator, and replace the template file with the specific Curved World version (located at JMO Assets/Toony Colors Pro/Editor/Shader Templates/TCP2_User_Unity5_CurvedWorld.txt by default).
The generated shaders will now be compatible with Curved World and react to its settings.
About Deferred Shading

Toony Colors Pro 2 only supports Forward rendering currently.
It will work if your player settings are set to Deferred Shading, although materials using TCP2 will be rendered in Forward on top of the Deferred scene.

Deferred Shading support is being considered, but it is a difficult task to achieve for multiple reasons:

Ideally I think it should have:


I have only had very few requests for Deferred Shading support so far, so if you would like it to be supported please send me an email!
I'd also be interested in hearing your thoughts on how it could be handled user-wise.




Other JMO assets for Unity:
Cartoon FX 1 Cartoon FX 2 Cartoon FX 3 Cartoon FX 4 Shape FX War FX MatCap Shaders (Free)