Step 1

Any GameObject that has a MeshFilter + MeshRenderer or SkinnedMeshRenderer can be painted.

Once the CwPaintableMesh component has been added, you can click the Analyze Mesh button to see if your mesh is suitable for painting.

Step 2

Next, you need to pick which textures you want to paint.

Your MeshRenderer or SkinnedMeshRenderer component has the Materials array, which usually has one material. Each material is rendered using a shader, and each shader has a list of textures that it uses. Most shaders have the Albedo/Color texture, but some more advanced shaders can have a Normal Map texture, Emission texture, etc.

You should now see the CwPaintableMeshTexture component added to your GameObject.

Inside this component, you can see the Slot setting. Next to this setting is a dropdown arrow button which you can click, and this allows you to pick from a list of all textures in your renderer.

For most objects, the default 0, _MainTex setting is all you need. But if you have multiple materials or need to do advanced painting you may need to change this. For example, to paint normal maps you may need to choose 0, _BumpMap or similar, the exact texture name depends on the shader/material.

The rest of the settings should be OK at their default values for now.

Step 3

Paint in 3D comes with many ways to paint objects.

One simple method is to make a new GameObject, and add the CwHitScreen and CwPaintDecal components. These components will automatically work together, allowing you to paint using the mouse (or your finger if you run it on a mobile device).

You can now adjust the CwPaintDecal settings to your liking. I recommend you at least change the Color or Texture, because the default paint color is white, and if you paint on a white texture then it may look like nothing is happening!

Once done, press play. You should now be able to click on your object in the Game window, and have the decal you paint on your object under the mouse.

For more advanced ways to paint I recommend you go through the demo scenes in the PaintIn3D/Examples folder and see how they're put together!

Presets

To save time, you can skip Step 1 & 2 by using the Presets system.

Paintable UV Maps

If your mesh is suitable for painting, it should look something like this.

As you can see, there are few overlapping triangles, few out of bounds triangles, few triangles with no UV, and the texture space is fairly well utilized.

Unsuitable UV Maps

If your mesh is NOT suitable for painting, it will look something like this.

As you can see, there are large areas of overlap in red, or many out of bounds triangles, or many triangles with no UV map.

In any of these scenarios, your mesh will need to be UV unwrapped before you can paint it.

Mesh Fixer

It's best to manually UV unwrap your meshes in your favorite 3D modeling software (e.g. Blender), because you will have full control over how it is unwrapped and can therefore give priority to certain areas and perhaps make better use of the texture space.

However, Paint in 3D comes with a tool to perform this UV unwrap for you.

To use it, click the Fix button at the top right of the Mesh Analysis window, and read the next tutorial section HERE.

Coord

This setting allows you to choose which UV channel/coordinate you want to fix. For most meshes this should be set to First.

Recenter UV

For a mesh to be paintable, the UV data must be within the standard 0..1 range on the X and Y axes. However, some assets or mesh workflows put the meshes in slightly different ranges like 1..2 or 2..3, typically across the X axis.

When the UVs are recentered, it detects this scenario, and shifts the UVs to the typical 0..1 range.

Generate UV

If you enable this setting, then your mesh will have entirely new UV data generated.

Fix Seams

If you enable this setting, then the UV island edges of your mesh will be extended so they can be painted without seams appearing.

Generate

Once you're happy with your mesh fixer settings, you can click the Generate button.

This will make duplicates of all meshes in the Meshes list, process them based on your settings, and then save them as child assets of the mesh fixer.

Next to your mesh, you can click the Analyze New button to see what the new fixed UV map looks like.

Swap Meshes

If your scene contains CwPaintableMesh components that still use the old non-fixed meshes, then they will show up at the bottom of the mesh fixer under the SWAP MESHES list, allowing you to quickly update them.

Remap Texture

If you enable GenerateUV, then your meshes will have their UV data completely replaced with an entirely new layout.

This is fine if your meshes will then be painted from scratch. However, if your meshes originally had a texture, then those textures must be remapped to the new UV data.

To remap them, simply drag and drop your textures into the Remap Texture field one at a time. This will reveal a list of meshes you can use for the remapping, and once chosen you will be prompted to save the texture.

This remapping feature is very useful with low-poly style meshes, which are typically colored using an atlas style color palette, where the UV data for each triangle is flattened to a point on a specific color.

Does Paint in 3D come with shaders that use the second UV channel?

Yes, Paint in 3D comes with several shaders designed to solve this issue.

If you want to keep your original shader/material that uses the first UV channel, then you can use the Paint in 3D / Overlay shader on top of your base material. Paint in 3D already comes with a pre-configured material called Overlay (Second UV Coord), which you can add on top of your base material. Keep in mind you will now be painting the second material (index 1), so you must update your CwPaintableMeshTexture component settings to target the second material slot index (1).

This technique is demonstrated in the UV Requirements / Automatic Overlay demo scene.

If you don't mind replacing your original shader/material, then the Paint in 3D / Solid shader can be used instead. This shader uses the first UV channel for base textures, and then allows you to override the albedo/opacity/smoothness/etc using secondary textures that use the second UV channel.

This technique is demonstrated in the UV Requirements / Automatic Secondary demo scene.

Can I use the second UV channel with the Standard shader?

Kind of. Using the following steps you can get it working using the detail texture. Just keep in mind this isn't the best solution, because it doesn't replace the albedo exactly.

How can I use the second UV channel with a different shader?

Most shaders only the first UV channel, so you will need to make an alternative shader that uses the second.

For example, instead of using uv_MainTex you use uv2_MainTex, or instead of using texcoord0 : TEXCOORD0, you use texcoord1 : TEXCOORD1.

Paint in 3D comes with a range of shaders that allow you to specify the UV channel used (e.g. PaintIn3D/Opaque).

Step 1

Select the Window/CW/Paintable Objects menu option.

This will open the Paintable Objects window.

Step 2

You can now select some GameObjects in the Scene or Hierarchy window.

Any GameObject or child GameObject you select that has a MeshFilter + MeshRenderer or SkinnedMeshRenderer will appear as a list in this window.

Step 3

Next to each GameObject will be the Make Paintable button.

If you click this, it will list all possible presets for this Renderer and Material's Shader type.

You can then choose one.

Custom Shader

Paint in 3D comes with presets for most of Unity's built-in shaders. However, if you've made your own shaders, or you have another asset with custom shaders, then you will have to add them to an existing preset.

All presets can be found in the Plugins/CW/PaintIn3D/Extras/Presets folder.

For example, the Basic - AA preset allows you to paint the _MainTex, which is usually the albedo (+ optional Alpha/Opacity). If you want to add your custom shader to this preset, then you can add it to the Shader Paths list.

If you're unsure what your shader is called, or want to add multiple shaders to this preset, then you can click the Find Shaders button, which will find all shaders in the current project that have all textures used by the preset (in this case of the Basic - AA preset, all shaders with _MainTex will be listed).

Custom Preset

If the presets that come with Paint in 3D aren't suitable for your project, then feel free to right click in the Project window, and select the Create/CW/Paint in 3D/Preset option.

This will add a new prefab to your project with the CwPreset, MeshFilter, MeshRenderer, and CwPaintableMesh components attached.

You must then set the ShaderPaths to include your shader, add all the CwPaintableMeshTexture components you want for this preset, and configure their Slot settings.

You can now use this preset from the Make Paintable button in the Paintable Objects window.

How do we fix them?

To fix these UV seams, Paint in 3D comes with a tool that can convert a normal mesh with UV seams into a fixed mesh without UV seams.

To access the tool, select any mesh in your project, click the context menu icon (⋮ button) at the top right, and select Fix Mesh (Paint in 3D).

This creates a seam fixer in your project, and automatically sets the Source mesh to the one you picked.

You can now press the Generate button to generate the fixed mesh.

If it was successful, you should see something like this in your Scene window:

Where the green lines are the original seams, and the blue lines are the new fixed seams. The blue lines should be outside of your original green lines. If your blue lines are overlapping then try reducing the Border setting a little, or the Threshold setting.

How do we use the fixed mesh?

The generated mesh will be placed as a child of the seam fixer in your Project window.

To use it, just drag and drop it from here into your MeshFilter or SkinnedMeshRenderer that uses this mesh.

Auto Seam Fixer

If the above steps seem too tedious for you, then you can let Paint in 3D automatically do the seam fixing for you.

Your mesh will now be auto seam fixed just before you paint it for the first time.

If either of these caveats is an issue, then I recommend you follow the previous section and manually seam fix the mesh.

UndoRedo Setting

The first step is to select your CwPaintableMeshTexture components, and enable the UndoRedo setting.

If you're painting animated objects then you should set this to FullTextureCopy, but for most scenarios you can use LocalCommandCopy.

If you use the FullTextureCopy state mode then you must also set the State Limit setting. A value of 10 means you can undo paint operations 10 times, and then redo them 10 times. If you paint 11 times with this setting then your initial paint state will be deleted, and you will only be able to undo 10 times to your first paint operation.

You can read the CwPaintableMeshTexture documentation for more details.

Store States

The next step is to find your painting components, and enable the Store States setting.

This setting will automatically call the StoreState method on each CwPaintableMeshTexture in your scene, letting Paint in 3D know that you're about to paint on them.

For example, the CwHitScreen component has the StoreStates setting, as well as CwToggleParticles, and CwTapThrow.

Buttons

Finally, you can add the CwUndoAll and CwRedoAll components to your UI elements, and they will automatically be set up so when you click them they perform an undo or redo operation.

And that's it, your game should now have Undo & Redo paint functionality!

Memory Usage

Keep in mind that when using the FullTextureCopy mode, each undo/redo state is stored as a full texture state. This means that if your texture is 1024x1024 using the RGBA32 format, then each undo/redo state will consume 1024x1024x4 bytes of memory, or 4 megabytes.

If your game requires a lot of undo states and you want to reduce memory usage, then you should use the LocalCommandCopy mode instead, which will store a list of all paint commands (e.g. decal texture + paint orientation). This approach can reduce memory usage a lot, and it allows unlimited undo levels, but performing an undo requires rebuilding the texture from scratch, which can be slow if you have a lot of undo states. It also may not work correctly if your mesh is animated, because the paint will apply to different areas if your mesh has changed.

Manual Undo & Redo

The undo & redo functionality listed above works well for most games, but it's not suitable for all scenarios. To get full control you can manage it yourself using the following methods in the CwPaintableMeshTexture class:

Call StoreState before you apply paint to your objects.

Call Undo/Redo after, when you want to undo or redo.

These methods can also be accessed from the CwPaintableMeshTexture inspector context menu (⋮ button at top right), so you can test it from the editor.

Alpha Blend

This blend mode increases the alpha channel of your texture, and blends the RGB channels of your texture toward the color of your paint, based on the opacity of your paint.

Alpha Blend Inverse

This blend mode works similar to Alpha Blend, but it applies the blending in reverse.

This allows you to paint 'behind' the current painted areas, or fill them in.

Alpha Blend RGB

This blend mode works similar to Alpha Blend, but the alpha channel is not modified. This is ideal when you want to paint on only the solid parts of an already transparent texture.

Additive

This blend mode works by increasing the RGBA values of your texture based on the paint color.

Additive Soft

This blend mode works similar to Additive, but the strength of the blending fades based on how bright the texture already is.

Subtractive

This works by decreasing the RGBA values of your texture based on the paint color.

Subtractive Soft

This blend mode works similar to Subtractive, but the strength of the blending fades based on how dark the texture already is.

Replace

This blending mode works like Alpha Blend, but the alpha channel of the texture will transition toward the paint alpha channel value, rather than just increase. In effect, this blends all channels toward the paint color at the same rate.

This is useful for painting advanced textures (e.g PBR), where you want to paint a specific alpha channel value.

Replace Original

This blending mode works similar to Replace, but instead of transitioning to the paint color, the paint color will be based on the original color of the texture.

This color is defined by the CwPaintableMeshTexture component's Texture and Color settings.

Replace Custom

This blending mode works similar to Replace Original, but instead of transitioning to the original texture color, you can specify a custom texture and color to transition to.

Multiply Inverse RGB

This blend mode allows you to darken your texture based on the paint color.

To make it easier to use, the blending is inversed. This means your decal should be white where you want the color to be multiplied, and black where you want no change.

Blur

This blend mode allows you to blur your texture based on the paint opacity.

Normal Blend

This blend mode allows you to paint a normal map with another, and both normal maps will combine together.

Normal Replace

This blend mode allows you to paint a normal map on top of another, and the original normal map will be replaced by the new one.

Flow

This blend mode allows you to move the pixels in the texture you're painting. The direction and distance the pixels will move is based on the normal map you specify.

Colliders

Normal non-skinned meshes are usually static, so you can just add a MeshCollider. However, skinned meshes usually bend and deform such that you cannot use a MeshCollider, because as soon as it animates, the collider surface will not match the visual mesh, which causes the paint to apply to the wrong area.

While the collider doesn't have to match the visual mesh, it needs to be close enough relative to the size/radius of your paint tool (e.g. CwPaintDecal's Radius & Scale settings). If you have a complex skinned mesh, this usually means you must add many colliders to your object (e.g. BoxColliders and CapsuleColliders, perhaps one per bone).

However, if your game doesn't require precise painting (e.g. bullet wounds only), then there is one alternative strategy that is simpler to configure that is shown in the "PaintIn3D/Examples/Zombie Blood" demo scene. In this scene, the skinned zombie mesh is given one large BoxCollider, that encapsulates the whole zombie animation cycle. The CwHitScreen component's RotateTo setting is set to Normal, and RotateTo/Direction is set to RayDirection. The CwPaintDecal component's Scale.z setting is then set to 15 (the exact value depends on the size of the skinned mesh). With this configuration, the paint is aligned to and stretched along the hit direction, so it goes through the skinned mesh.

Include Scale

Inside the CwPaintableMesh component is the IncludeScale setting. Depending on your skinned mesh, you may need to enable this setting for the painting to work.

I wasn't able to identify exactly when this setting needs to be enabled or disabled, so it can't be automatically set. I think it has something to do with the software used to export the mesh, or the export settings, so for now you must manually try toggling this if you find your mesh can't be painted even if every other setting looks correct.

Overlap Points

When using connected hits, the connected lines are drawn separately, which causes the overlapping corners to receive double the paint. This is an issue with semi-transparent painting, because they will appear stronger than the main line body.

To fix this, you must enable the Advanced / Clip Connected setting, which eliminates this issue in most scenarios.

Texture Resolution

The easiest way to optimize painting performance is to reduce the size of your CwPaintableMeshTexture. If you halve the width & height of your texture, then there are now only 1/4 of the pixels being painted, which means your paint will apply up to 4x faster.

I recommend you reduce the texture resolution as much as possible, until you find the perfect balance between performance and visual quality.

Paint Framerate

Another easy way to optimize your painting is to paint less often.

For example, the CwHitScreen component has the Interval setting, which allows you to choose the pixel distance between each paint hit. If you set this to 3 pixels and move your mouse/finger 300 pixels in one frame, then this will result in your scene being painted 100 times. If you increase this to 6 pixels, then it will result in the scene being painted 50 times, or a 2x optimization. You can also set the Frequency to OnceEveryFrame, which will paint the scene no more than once per frame.

For example, the CwHitParticles component by default paints every time a particle hits something. This can be optimized using the Advanced / Skip setting, which allows you to paint once every n times.

Split Meshes

If your object has a large texture and you cannot reduce its resolution, then you can still optimize the painting without a loss in detail. This is done by splitting your mesh up into smaller parts, and setting them up as separate objects. If done correctly, when you paint your object only a small area of it will be painted, and thus less pixels will be processed overall.

The easiest example of this is painting a large wall. Instead of having one wall mesh, you can split it up into a grid of smaller sections. If done correctly you will still have the same overall texture resolution, but when painting you will only every paint a small number of meshes in this grid, and thus your painting performance will be greatly improved.

_MainTex & URP/HDRP

If you're using URP or HDRP, then you may notice painting _MainTex (Albedo) doesn't work, even though it shows up in the inspector list.

This is because these shaders seem to have a 'fake' _MainTex slot that doesn't do anything.

To fix this, you must instead paint the _BaseMap, which is the 'real' albedo texture.

Galaxy S6 / Mali-T760MP8

This device can incorrectly paint on Android 7 with the OpenGL ES3 graphics API. Previously painted pixels are observed to randomly become transparent and otherwise change.

If you need to support this device:

This should allow you to paint properly again.

VR Tools

While the painting features can work with any VR asset/toolkit, the Paint in 3D VR examples are only configured to work with Unity's legacy XR system.

Better Shaders

This compatibility was made possible using the Better Shaders system (not required).

The Better Shaders asset generates multiple variants of each shader ahead of time, so even if you don't have this asset, you will still be able to have full render pipeline compatibility with Paint in 3D.

BetterShaders (and therefore this asset) currently supports:

Standard Rendering Pipeline from Unity 2019 on

URP7.x in Unity 2019.3LTS

URP10.x in Unity 2020.3LTS

URP12.x in Unity 2021.2

URP14.x in Unity 2022.2->2022.3LTS

HDRP7.x in Unity 2019.3LTS

HDRP10.x in Unity 2020.3LTS

HDRP12.x in Unity 2021.3LTS

HDRP14.x in Unity 2022.2->2022.3LTS

Support for newer versions will appear when it does in this asset.

Lights

Each rendering pipeline handles lighting differently. To make the scenes look consistent, each light has the CwLight component attached to it, which overrides the light intensity for each pipeline.

If you don't like this behavior then you can set the values (for example IntensityInHDRP) to -1.

Opaque Texture (URP only)

If you want to use the SgtBlackHole feature, then you must enable the Opaque Texture setting in your pipeline settings asset.

Volume (HDRP only)

To make HDRP compatibility seamless, each demo scene contains the CwSceneManager GameObject, which adds the Volume component in HDRP.

This volume will adjust the scene exposure, disable the visual environment, and disable fog. These are all done to make the scenes look consistent with the other rendering pipelines. If you want to adjust these settings yourself then delete this GameObject, and create your own volume.

However, for your own scenes you may want to remove this volume component and use your own exposure settings.

Paint Hits

Paint hits are the high-level data used to paint your scene (e.g. the CwHitScreen component sends hit data to components like CwPaintDecal). Depending on the paint hit type, this just stores the world space position, rotation, seed, and other basic data.

This is the easiest data to send, but since the data is handled in world space and applied to everything in the scene, it's not suitable for moving objects.

To listen for paint hits you can create a new component and add it to the GameObject that has your CwHit___ component. You can then implement any of the IHit___ interfaces, to get specific hit data. For example, the CwHitScreen component can send point and line hit data, so you can implement the IHitPoint and IHitLine interfaces.

When a hit occurs, the HandleHitPoint and HandleHitLine and methods from these interfaces will be invoked. You can then store the given parameters to a file, or send it over the network.

Once this data is loaded/received, you can then broadcast it again using code like this:

// Loop through all components that implement IHitPoint
foreach (var hitPoint in GetComponentsInChildren())
{
	// Ignore this one so we don't recursively paint
	if ((Object)hitPoint != this)
	{
		// Submit the hit point
		hitPoint.HandleHitPoint(preview, priority, pressure, seed, position, rotation);
	}
}

You can see the CwPaintMultiplayer.cs code for an example of this.

Paint Commands

Paint commands are the low-level data used to paint each individual paintable texture. These store everything about the paint that was applied (e.g. texture references), so it's not as simple to serialize it all.

To allow for de/serialization of this data, you must first provide unique hash codes to the CwPaintableMeshAtlas, CwPaintableMesh, and CwPaintableMeshTexture components. This is done via the Advanced / Hash setting.

In addition to these hashes, you must provide hashes for all textures used by your paint commands. For example, if you use decal painting then the decal texture must have a hash.

Since the Texture class is made by Unity and can't be modified, you must assign a hash to a texture using the CwTextureHash component. You can add this component to your scene, assign the texture, and assign a hash code.

You can now listen for paint commands using the static CwPaintableTexture.OnAddCommandGlobal event, or the instance OnAddCommand event. These events will give you every paint command for a specific paintable texture.

The paint command can then be stored or sent over the network using JsonUtility serialization, or similar.

Once this data is loaded/received, you can apply it using your paintable texture component's AddCommand() method.

You can see the CwCommandSerialization.cs code for an example of this.

Basic Setup

This shows you how the Spaceship GameObject can be made paintable. This is done by adding the CwPaintableMesh and CwPaintableMeshTexture components. You can then paint the spaceship using the mouse/finger with the Paint GameObject, which has the CwHitScreen and CwPaintSphere components. Keep in mind that CwHitScreen uses raycasts, so your mesh must have a collider to work.

Seam Fixer

This shows you how to remove painting seams from your mesh using the Mesh Fixer tool. Seams are caused by gaps/islands in the mesh UV data, which are usually present at the edges of complex meshes. To use the mesh fixer, simply click the context menu button (⋮ icon) at the top right of your mesh inspector window. You can then select Fix Mesh (Paint in 3D), adjust the settings, and click Generate. You can double click the Spaceship GameObject's MeshFilter.Mesh setting to see it in action.

Auto Seam Fix

This shows you how to automatically fix seams in your mesh without using the Seam Fixer tool. This is done by changing the CwPaintableMesh component''s Advanced / UseMesh setting to AutoSeamFix. Keep in mind this mode doesn''t give you control over the seam fix settings (the defaults should be suitable for most meshes). Also keep in mind there will be a small performance hit the first time you paint your object when its seam fixed mesh is generated.

Unsuitable UV

This shows you what happens when you paint a mesh that isn''t suitable for painting. For a mesh to be paintable, it shouldn''t have overlapping UV, or UV areas that exceed the 0..1 range (e.g. tiling). Notice the paint appears in unexpected areas on this mesh, because it contains both tiling UV, and overlapping areas.

Cube

This shows you how painting meshes with overlapping UV data can cause unexpected results. The left shows you what painting the standard Unity Cube mesh looks like, and the right shows what painting the Separated Cube mesh that comes with Paint in 3D looks like.

Cylinder

This shows you how painting the standard Unity Cylinder mesh can give unexpected results, and how the Separated Cylinder mesh that comes with Paint in 3D can avoid these issues.

Auto UV

This shows you how a mesh with UV data unsuitable for painting can still be painted. This is done by enabling the Generate Lightmap UVs setting in the mesh import settings. This setting will generate new UV data in the second UV channel/coord, which can be used by custom shaders. The Paint in 3D / Solid shader has this feature if you enable the Use Second UV setting. If you use this configuration then make sure the CwPaintableMeshTexture.Coord is set to the Second UV channel.

Overlay

This shows you how the Unsuitable UV demo scene can be modified to allow correct painting on top. This is done by generating mesh data for the second UV channel/coord as seen in the Auto UV demo scene, and using a second transparent material layer on top of the base material. This second material uses the Paint in 3D / Overlay shader, which allows you to paint on top of the base material using the second UV channel. If you use this configuration then make sure the CwPaintableMeshTexture.Coord is set to the Second UV channel.

Override

This shows you an alternative way to paint objects using secondary UV data. The overlay approach requires multiple materials, which may not be suitable for your project. In this scenario, you can use a shader that is specifically designed to allow you to paint on both the first and second UV channels. The P3D Solid shader has the basic albedo/metallic/etc textures that use the first UV channel, but you can also override these using secondary albedo/metallic/etc textures that use the second UV channel. This is done by painting the _AlbedoTex/_MetallicTex/etc, which will override the base texture based on the opacity of the secondary paint. Keep in mind this shader requires you to paint the override textures using the Premultiplied blending mode.

Base Color

This shows you what happens when you paint objects that have materials with different color settings (top row). Notice how the color tint also applies to the paint, because the material color is multiplied with the painted texture color. To make the painted color apply without tinting you can set the material color to white, and instead change the CwPaintableMeshTexture.Color setting to the base color you want (middle row). You can also set the material color to white, and instead change the default texture (e.g. Albedo texture) to the color you want (bottom row).

Dots

This shows you how decreasing the CwPaintSphere.Radius setting and/or increasing the CwHitScreen.Interval setting allows you to draw dotted lines.

Connect Hits

This shows you how the CwHitScreen component''s Advanced / ConnectHits setting can be enabled, allowing paint dots to be joined together. A similar result can also be achieved using a lower Interval setting, but that has a performance penalty.

Clear Texture

This shows you how the CwButtonClearAll component can be added to a UI element, which makes it clear the paint of all textures in your scene. This also shows you how you can clear the texture of a specific texture by connecting the OnClick event to the CwPaintableMeshTexture.Clear method.

Isolate Tools

This shows you how the CwButtonIsolate component can be added to UI elements. This turns them into buttons that can enable a GameObject, and disable its siblings. This allows you to switch between different painting tools.

Tiled Painting

This shows you how the CwPaintSphere component''s Advanced / Tile settings can be used to paint seamless textures across your objects. This is done using triplanar mapping.

Blur Painting

This shows you how the paint component''s BlendMode setting can be changed to Blur. This blending mode blurs the pixels of the paintable texture.

Mask

This shows you how to prevent the Blur blending mode from causing the pixels outside the edges of your mesh UV islands from ''bleeding'' into your main texture. This is done by setting the CwPaintableMeshTexture component''s Advanced / LocalMask texture. This texture can be created using Paint in 3D if you begin with a black paintable texture, paint it white, and then export the painted texture via the main Paint in 3D window.

Generate

This shows you how the CwPaintableMeshTexture component''s Advanced / LocalMask texture can be automatically generated with a mask suitable for use with the Blur blending mode. This is done by adding the CwGenerateMask component alongside your CwPaintableMeshTexture component, and setting its Mesh setting to be the non-seam-fixed (original) version of your mesh. Automatically generating the mask like this means your build size doesn''t increase.

Decal

This shows you how the CwHitScreen and CwPaintDecal components can be combined to paint decals. Decals allow you to paint a custom texture on an object at a specific location. The CwPaintDecal settings give you control over the angle, size, opacity, etc.

Wrapping

This shows you how the CwPaintDecal component''s Wrapping setting can be used to control how the decal is applied to curved surfaces. When set to 0, the decal is applied using planar projection without any wrapping. When set to 1 the decal is wrapped around curved surfaces.

UV

This shows you how the CwHitScreen component''s Emit setting can be set to PointsOnUV, allowing you to apply decals directly to your paintable texture in UV space. This is useful when painting complex curved surfaces, because the texture can apply without distortion if your mesh is suitably UV mapped. Keep in mind this mode requires a non-convex MeshCollider for UV data, and for your objects to all have consistent texel sizes. Keep in mind this mode does not support painting between UV seams, and you may get paint bleeding if your UV islands are too close together. This scene also makes use of the Group setting (works like Layers) to avoid cross painting.

Normal

This shows you how the CwHitScreen component''s Advanced / Normal settings can be used to control the visibility of the decal based on to the the angle between the decal and the surface being painted. This allows you to enable or disable painting of steep angles, behind surfaces, etc.

Normal Front

This shows you how the CwPaintDecal component''s Advanced / NormalFront setting can be used to force paint to only appear on surfaces that have a surface normal (direction) similar to the surface normal of the hit point (mouse point).

Normal Fade

This shows you how the CwPaintDecal component''s Advanced / NormalFade setting can be used to control the sharpness of the normal cut-off transition.

Settings

This shows you how the CwPaintDecal settings can be modified from UI buttons by calling the various functions like IncrementAngle, FlipVertical, etc.

Mirror

This shows you how the Mirror GameObject has the CwCloneMirror component attached. This automatically mirrors all paint across a 3D plane defined by its Transform position and rotation. If you select the Mirror GameObject then you can see a preview of the mirror plane in the Scene view.

Flip

This shows you how the Mirrored Painting demo scene can be modified to prevent decals from appearing backwards when mirrored. This is done by enabling the CwCloneMirror.Flip setting, which makes the decals appear the same on both sides.

Multiple

This shows you how mirrors can combine together, creating interesting symmetries.

Collision Painting

This shows you how to apply paint when a Rigidbody collides with something. The CwTapThrow component can be used to spawn and throw the Ball prefab when you click or tap the screen. The ball then paints the spaceship on impact using the CwHitCollisions and CwPaintDecal components.

Destroyer

This shows you how to automatically destroy a GameObject itself when it hits something. This is done by adding the CwDestroyer component alongside the CwHitCollisions component.

Spawner

This shows you how to spawn an explosion effect when a Rigidbody hits something. This is done by adding the CwSpawner component alongside the CwHitCollisions component. The spawned prefab contains a ParticleSystem, and uses the CwDestroyAfterTime component to destroy itself.

Between Painting

This shows you how the CwHitBetween component can be used to paint between two Transform points. The CwHitBetween.Line can be used to visualize the current beam, and the CwHitBetween.Point setting can be used to vislize the hit point with particles.

Center Screen

This shows you how to paint everything at the center of the screen directly in front of the camera, like a laser eye beam. This is done using the CwHitBetween component, which is set to hit between the Main Camera Transform, and the In Front Of Camera Transform, which is a child GameObject placed in front. This will then automatically call CwPaintSphere on the first hit point it finds between these two points, and paint them red. The camera can then be rotated using the CwPitchYaw component.

Through Points

This shows you how the CwHitThrough component can be used to paint trhough two Transform points. The CwHitThrough.Line setting can be used to visualize the current beam. Unlike CwHitBetween, this component paints all surfaces between the two points.

Particle Painting

This shows you how the CwHitParticles component can be added to your ParticleSystem GameObjects. This allows you to paint with components like CwPaintSphere when particles hit objects in the scene. Keep in mind you must enable collision in your particle system for this to work.

Optimization

This shows you how particle painting can be greatly optimized. By default, the CwHitParticles component paints once per particle collision. However, this can be incredibly slow if you emit too many particles. To optimize this, you can use the CwHitParticles component's Advanced / Skip setting, which allows you to paint once every 'Skip' particles. In this scene Skip = 10, which means for every particle collision that would result in a call to CwPaintSphere, 9 calls are skipped.

Nearby Painting

This shows you how the CwHitNearby and CwPaintSphere components can be combined to paint any surfaces within the specified sphere shape.

Throw

This shows you how the CwTapThrow component can spawn and throw the Ball prefab. This prefab has the CwHitNearby component, which can paint surfaces near the current Transform position. This effect can be used to create fireballs that pass through objects, and paint them on the way.

Auto Save Load

This shows you how the CwPaintableMeshTexture.SaveName setting can be used to enable automatic save/load. Paint something, then run the scene again to see it in action. Keep in mind these save names should be unique, so using the same name with multiple prefabs may not work as expected.

Undo Redo

This shows you how the CwPaintableMeshTexture.UndoRedo setting can be used to store undo and redo states. You can then add the CwButtonUndoAll and CwButtonRedoAll components to UI elements to cycle through them. Keep in mind storing of states requires the StoreStates setting to be enabled, this is on components like CwHitScreen.

Paint Modifiers

This shows you how the paint settings can be randomly adjusted before the paint is applied. This is done by clicking the Add Modifier button inside the paint component (e.g. CwPaintDecal), and selecting a value to modify (e.g. Angle), and then the type of modification (e.g. Random). Keep in mind these modifiers can be combined together to make even more interesting results.

Gradually Fade

This shows you how to gradually fade a texture back to its original state after you paint it. This is done using the CwGraduallyFade component, and dragging and dropping the texture you want to have fade into the PaintableTexture setting. You can then set the BlendMode setting to ReplaceOriginal, and it will gradually fade to its original state as defined by the CwPaintableMeshTexture component''s Texture and Color settings.

Blur

This shows you how the Gradually Fade demo scene can be modified to blur the texture over time.

Normal

This shows you how the Gradually Fade demo scene can be modified to fade a normal map to its original state. This is done by using the Normal Replace blending mode and the DefaultNormal texture. Keep in mind the ReplaceOriginal blending mode can''t be used with normal maps, because the original texture and color are converted into normal maps, and this would cause them to be replaced by their non-converted state.

Painting Holes

This shows you how to paint holes in your paintable objects. This is done using the Subtractive blending mode, which allows you to reduce the alpha/opacity of the pixels in your texture. Keep in mind this requires you to use a shader/material that supports transparency, like the P3d Solid one used here. Keep in mind the underlying mesh still remains, so you can''t paint through the holes you create.

Replace Painting

This shows you how the CwPaintReplace component can be used to replace every pixel in the currently painting texture. Keep in mind the GameObject with the CwPaintableMeshTexture must have a collider for this to work, and CwHitScreen.Emit must be set to PointsOnUV.

Fill Painting

This shows you how the CwPaintFill component can be used to blend every pixel in the painted texture. This allows you to gradually change it, rather than instantly like CwPaintReplace does. Keep in mind the GameObject with the CwPaintableMeshTexture must have a collider for this to work, and CwHitScreen.Emit must be set to PointsOnUV.

Paint From Invisible

This shows you how to paint an object in from an invisible state. This is done by changing the CwPaintableMeshTexture.Color setting''s alpha/opacity value to 0, which causes the texture to initialize as invisible. You can then reveal the object by painting the alpha/opacity back in, which is automatically done when using the Alpha Blend blending mode. Keep in mind this requires you to use a transparent material/shader like the Paint in 3D / Solid one used here.

Reveal Original

This shows you how a textured mesh can be hidden, and then revealed by painting on it. This is done by changing the CwPaintableMeshTexture.Color alpha/opacity value to 0. The texture can then be revealed by painting with the Additive blending mode, with a color of RGBA 0,0,0,1. Keep in mind this requires your mesh to use a transparent (e.g. cutout) shader/material.

Glass Painting

This shows you how to paint on top of a transparent material. This is done using the Alpha Blend blending mode. Notice how the erase tool erases both the paint, and the original dirt.

Override

This shows you how the Glass Painting demo scene can be modified so the paint is applied to secondary albedo and opacity textures that override the base values. Notice how the erase tool only erases the new paint, and keeps the original dirt. This technique also allows you to paint at a lower resolution, but keep the original higher resolution texture, allowing you to optimize performance. Keep in mind this configuration requires you to use a special mater/shader designed to override the base texture values (the Paint in 3D / Alpha shader is used here). Keep in mind the override textures use premultiplied alpha, so you must set your paint tools to use the Premultiplied blending mode (though erasing can use the subtractive blending mode).

Channel Counter

This shows you how the CwChannelCounter component can be used to count the total pixels in the specified CwPaintableMeshTexture that exceed the threshold value in each R/G/B/A channel. The CwChannelCounterText component can then be used to display these in the UI.

Percentage

This shows you how the Channel Counter demo scene can be modified to accurately display how much of a mesh you have painted. This is done by setting the Spaceship GameObject\u2019s CwChannelCounter.Mesh setting to the original non-seam-fixed mesh. The paint percentage can then be displayed using the CwChannelCounterText and CwChannelCounterFill components. To make the paint work with any color this spaceship paint uses a second layer on top, similar to the Paint On Top demo scene.

Color Counter

This shows you how the CwColorCounter component can be used to count the total pixels in the specified CwPaintableMeshTexture that are within the threshold color of a CwColor. The CwColorCounterText component can then be used to display these in the UI.

Change Counter

This shows you how the CwChangeCounter component can be used to count how many pixels in the specified texture are different to a reference state. The reference state can be set using the CwChangeCounter component''s Texture and Color settings.

Paint Remaining

This shows you how the Alpha Blend Inverse blending mode can be used to paint transparent areas of your texture. This gives the effect of painting undernearth your existing paint.

Replace Original

This shows you how the Replace Original blending mode can be used to paint your object back to its original state based on the CwPaintableMeshTexture component''s Texture and Color settings.

Replace Custom

This shows you how the Replace Custom blending mode can be used. This works similar to Replace Revert, but you can specify custom Texture and Color values per paint tool.

Dynamic Decal

This shows you how to paint decals with dynamically changing content. This is done using a RenderTexture, making a second camera, and changing its TargetTexture setting to the RenderTexture. Keep in mind you must correctly set up your layers and Camera.CullingMask values to keep each camera isolated. Also keep in mind dynamic decals can''t be undone using the CwPaintableMeshTexture.State = LocalCommandCopy setting.

Live Painting

This shows you how to create live paint that can be repositioned in game. This is done using the CwHitNearby component with the Preview setting enabled. You can control the draw order of these decals using the Priority setting.

Apply

This shows you how live paint can be applied to your objects when you press a button. This is done by linking the button's OnClick event to the CwHitNearby component's ManuallyHitNow function.

Translate

This shows you how the CwTranslate component can be used to move a live decal around the scene using UI button events that call the CwTranslate.TranslateX/Y/Z functions.

LOD Painting

This shows you how to optimize painting speed using different LOD meshes for visuals and painting. The Knot_High GameObject is used to render the high poly visual mesh. The Knot_Low GameObject is used for the low poly MeshCollider, and for painting. To make the paint apply on the high poly mesh, the CwPaintableMesh.OtherRenderers list contains the Knot_High MeshRenderer.

Atlas Painting

This shows you how to paint multiple separate objects that share the same texture. This is done by setting up one paintable object normally, and then dragging and dropping the other objects into the CwPaintableMesh component's Advanced / OtherRenderers list. You must then add the CwPaintableMeshAtlas component to the other objects, and drag and drop the first object into the CwPaintableMeshAtlas.Parent setting.

Fill Painting

This shows you how to paint filled in polygon shapes. This is done by replacing the CwHitScreen component with the CwHitScreenFill component. This causes the polygon shape you draw to be filled in with a grid of points. Keep in mind the points are drawn in screen space, so the resolution depends on the camera distance to the paint surface.

Mask

This shows you how the CwMask component can be added to the scene. This allows you to define an area where paint will be blocked, allowing you to paint within a specific shape. You can see the location of the mask in the Scene window after you select the mask.

Stretch

This shows you how the CwMask component''s Stretch setting can be used to extend the edges of the mask without modifying the mask texture. This allows you to more easily block painting across a large area without requiring a high resolution mask texture.

Normal Painting

This shows you how normal maps can be painted. This is done by opening the advanced settings for the CwPaintableMeshTexture component, and changing the Conversion setting to Normal, as well as changing the Slot to _BumpMap. You can then paint using the Normal Blend blending mode. Keep in mind the normal maps use all four RGBA channels to store data, so you must set the shape of the decal separately with the Shape setting.

Read Color

This shows you how to read the paint pixel color under the mouse/finger. This is done using the CwReadColor component, which can be added alongside any CwHit___ component that works using raycasts like CwHitScreen and CwHitBetween. Keep in mind the hit component must be set to emit PointsOnUV. The OnColor event is then used to change the UI Image color to the read color.

Event

This shows you how to detect when a specific color has been read, and trigger an action from it. This is done using the CwReadColorEvent component, which can be added alongside the CwReadColor component. When you read a color within the Threshold distance of your specified Color, it will trigger the OnColor event, which can be used to perform any action.

Under

This shows you how the CwReadColor and CwPaintBetween components can be combined, allowing you to read the color under a specific GameObject, and display that color in the UI.

Simulated Multiplayer

This shows you how the CwPaintMultiplayer component can be added to your paint tool to simulate painting over a network. To make this work using actual multiplayer, the SimulateNetworkTransmission coroutine must be replaced with actual network transmission code, which will differ depending on the network solution you''re using.

Procedural Setup

This shows you how to set up a GameObject to be paintable from scratch using C# code. See the CwProceduralSetup script in the PaintIn3D/Examples/Scripts folder for more details.

Triangle Painting

This shows you how to paint the underlying triangles of your mesh. This is done by changing the CwHitScreen component's Emit setting to TrianglesIn3D.

Reveal Graffiti

This shows you how basic painting can be used to reveal a complex design. This is done using the ReplaceOriginal blending mode on your paint tool, which will revert a CwPaintableMeshTexture to its current Texture and Color settings. The texture that will be revealed is first hidden using the CwPaintableMeshTexture.Color setting with 0 alpha. The CwPaintableMesh.OnActivated event is then used to reset this back to full alpha using the CwPaintableMesh.SetColor event, with a hex color of #FFFF.

Counter

This shows you how the Graffiti scene can be modified to count the % of the design you have painted. This is done using the CwChangeCounter component, which monitors the graffiti texture. This component''s MaskTexture is set to read the final graffiti design''s alpha channel so it ignores pixels outside of the design. The Texture setting is then set to the final design, so the currently painted/revealed graffiti texture is compared against the final design.

Draw Angle

This shows you how to make painted decals change direction based on the angle of your mouse/finger as you paint. This is done by changing the CwHitScreen component''s RelativeTo setting to DrawAngle when RotateTo = Normal. Keep in mind the draw angle isn''t known on the first frame your mouse/finger touches the screen, so the first paint hit is skipped.

Local Mask

This shows you how to mask specific areas of your texture using your mesh UV, rather than being in 3D like with CwMask. This is done using the CwPaintableMeshTexture component''s LocalMask setting inside the Advanced settings.

Paint From Code

This shows you how to paint decals under the mouse from code. Check out the PaintIn3D/Examples/Scripts/CwPaintFromCode.cs code to see how it works!

Flow

This shows you how the Flow blend mode can be used to move the pixels in the texture you paint using a normal map that defines which direction and how far they should move. The maximum distance of the flow samples can be controlled from the Kernel setting.

Gradually

This shows you how to make paint flow across the surface of your object over time. This is done using the CwGraduallyFade component with BlendMode = Flow. This allows you to set a normal map in the Texture setting that allows you to control how the paint should flow.

Time

This shows you how the Flow / Gradually demo scene can be modified so the paint begins at full speed, but gradually slows down until it stops. This is done by adding a second paintable ''Speed'' texture to your object. Since this speed texture isn''t applied to the material, you must enable the Advanced / IsDummy setting. Like the albedo texture, this speed texture uses CwGraduallyFade to twist the texture around, but it also has a second CwGraduallyFade to fade it to black to slow down the speed. The albedo texture''s CwGraduallyFade.MaskPaintableTexture is then set to this speed texture, which will cause its flow speed to depend on the speed texture''s red channel. You can then paint both the albedo and speed textures at the same time to make the effect work. Keep in mind both of these textures must use a different CwGraduallyFadeGroup setting.

Liquefy

This shows you how to make a liquefy paint effect, where the painted pixels will move based on the direction you move the mouse/finger when painting. This is done using the Flow blend mode with a normal map pointing up. The flow is rotated using the CwHitScreen component''s RotateTo / Relative To = DrawAngle setting.

Primitive Painting

This shows you how to configure the four basic primitives to be paintable, so that any paintable pixels that enter them get painted. This is done using a combination of CwHitNearby and CwHitThrough components with the CwPaintSphere and CwPaintDecal components to continuously paint any pixels that enter the current volume. Keep in mind the CwPaintDecal.NormalFront setting should be set to 2 to apply paint even if it's applying to steep or back faces.

Line Painting

This shows you how to paint points or lines between the mouse/finger start and end positions. This is done using the CwHitScreenLine component, which can be combined with the CwPaintSphere/Decal component. This component''s Frequency setting can be used to control how many and where the points/lines are drawn. The ConnectHits setting can also be used to switch between drawing points and lines. Keep in mind painting lines on complex geometry requires you to paint many points, otherwise they will go through the geometry.

Arrows

This shows you how the CwHitScreen and CwHitScreenLine components can be used together to draw lines. This is using a combination of other settings, like Frequency, and setting Rotate To / Relative To to Draw Angle.

Debug Painting

This shows you how the CwPaintDebug component can be added alongside your other paint components. This will show you where Paint in 3D is applying the paint in the Scene view. This allows you to easily diagnose painting problems. Keep in mind this feature requires you to enable Gizmos.

Delayed Appearance

This shows you how to make paint gradually appear after you paint it, rather than instantly. This is done by configuring two CwPaintableMeshTexture components as normal. However, the first should have its Group setting changed to an unused group (e.g. DUMMY), and the second should have its Advanced/IsDummy setting enabled to prevent it from applying to the object''s material. A CwGraduallyFade component is then used on the first paintable texture with the Replace blend mode, and the BlendPaintableTexture set to the second paintable texture. In effect this means your paint will apply to the second paintable texture, and this paint will be gradually copied over to the first. The other settings are just to prevent paint from applying directly to the first paintable texture.

Command Serialization

This shows you how to listen for and store paint commands that get added to any CwPaintableMeshTexture component in the scene. You can then click a button to reset all paintable textures, and randomly apply one of the recorded paint commands. See the PaintIn3D/Examples/Scripts/CwCommandSerialization.cs code to see how this works. Keep in mind this is an advanced technique that requires good C# knowledge.

Clip Connected

This shows you how to eliminate the overlap points from transparent painting when using the Advanced / Connect Hits setting. This is done by enabling the Advanced / Clip Connected setting, which blends connected lines together.

Dynamic Mask

This shows you how to make a mask texture at runtime from a camera. This is done by making a new camera with its TargetTexture set to a RenderTexture in your project. A separate Screen Space - Camera UI is used to render to this camera (you could also render 3D objects). The RenderTexture is then added to a CwMask in the scene. In this example only the Red channel of the mask is used, so the RenderTexture uses the R8 format to save memory.

Initial Tiling

This shows you how to initialize a paintable texture with texture tiling. This is done using the CwHitNearby component with the PaintIn setting set to Start. The CwPaintSphere component is then used to apply the paint. This component's Advanced/TileTransform can be set to any GameObject/Transform that has scaling, and you can set the Advanced/TileTexture to your desired texture. When you enter play mode, these components will activate and apply the paint to your scene. Make sure the CwPaintSphere.Radius setting is large enough to encompass your object. To isolate painting to just one paintable texture you can drag and drop your object into the CwPaintSphere component's Advanced/TargetModel setting.

Depth Mask

This shows you how to mask paint behind foreground objects. This is done with the CwRenderDepth component, which can render the scene depth from the perspective of a camera. All paint components with the Advanced / FindDepthMask enabled (it''s enabled by default) will then be depth masked.

Expanding Paint

This shows you how to make paint that expands or rotates over time. This is done using the CwHitScreen and CwSpawner components, which will spawn a prefab under the mouse/finger when you click/tap the screen. The spawned prefab has the CwHitNearby and CwPaintDecal components, which make the spawned prefab paint every frame/Update. The prefab also has the CwPaintAction component, which is used to call the CwPaintDecal.MultiplyScale or CwPaintDecal.IncrementAngle functions to animate the paint. Finally, the CwDestroyAfterTime component is used to destroy the prefab after some time.

Bullet Dents

This shows you how to paint holes and dents on a transparent target object. The bullet mark ignores transparent areas using the Alpha Blend blending mode, with only the RGB channels (1, 1, 1, 0), skipping modifications to the alpha channel.

Car Decals

This shows you how the Undo Redo demo scene can be combined with Sphere and Decal painting so you can paint on a car.

Chalk Board

This shows you how the Seamless Painting and Blur Painting demo scenes can be combined to create a chalkboard you can draw on and erase from in a realistic way.

Clean Dirt

This shows you how to apply dirt to an object using the P3D/Solid shader''s albedo override texture. You can then clear the paint by changing your brush to the Replace blending mode, with a color of transparent black (RGBA = 0000). The CwColorCounter/Fill/Event components can then be used to show how much has been cleaned, and show the "CLEAN" text when it''s below 2%.

Dripping Paint

This shows you how the Collision Painting and Flow / Time demo scenes can be combined to create a paint dripping effect that slows to a stop over time. Unlike the Flow / Time demo scene, this uses a downward facing flow texture, so the albedo and speed textures flow down the wall.

Fireball Holes

This shows you how the Nearby Painting / Throw demo scene can be modified to cut holes through an object.

Paint Ball Throwing

This shows you how the Color Counter demo scene can be modified to paint splats of color.

PBR Painting

This shows you how to paint the Albedo, Normal, and PBR (Metallic + AO + Smoothness) textures at the same time using the Group feature. You can assign a texture group using the CwPaintableMeshTexture.Group setting, and to paint these textures a matching CwPaintSphere.Group/CwPaintDecal.Group setting can be used.

Rock Engraving

This shows you how the albedo and normals can be painted at the same time, creating a rock engraving effect.

Rock Throwing

This shows you how two CwPaintCollisions components can be used with different layer filtering and different Root settings, allowing you to apply different kinds of paint to different objects. The CwPaintDecal component and CwPaintableTexture''s GameObject must have matching layers for this to work.

Shield Impacts

This shows you how CwHitCollisions and CwPaintSphere can be added to a Rigidbody GameObject. This allows them to paint the Spaceship_Shield GameObject with a special impact pattern. The CwGraduallyFade component is then used to gradually fade the texture back to transparent black, simulating a spaceship shield effect.

Skybox Painting

This shows you how to paint a background skybox without seams or distortion. Notice the skybox mesh is a subdivided cube turned into a sphere with cube mapped UV coordinates. The mesh is then run through the Seam Fixer tool.

Splat Map Painting

This shows you how to paint an RGBA splat map. This is done using the Splat (R, G, B, A) group, with the Replace blending mode. Each paint tool replaces the splat texture with a specific channel color (e.g. 0,1,0,0 for green). It''s also possible to use the Additive & Subtractive blending modes on each channel instead. Keep in mind splat maps require your object to have a special material/shader that implements splat maps.

Spray Paint

This shows you how to paint an object using a spray can that emits paint particles. This is done using the CwToggleParticles component.

Transparent Object Painting

This shows you how the albedo of a transparent object with overlapping UV data can be painted using auto generated UVs and secondary textures.

VR HVLP

This shows you how PBR spray painting can be implemented in VR using Unity''s XR library. Make sure to enable Virtual Reality Supported in your project settings. Also, make sure to select the VR Manager GameObject, and check to see if each input axis is set up. If you''re using the new InputSystem, then please read the documentation for it.

VR Pen

This shows you how VR pen painting can be implemented in VR using Unity''s XR library. Make sure to enable Virtual Reality Supported in your project settings. Also, make sure to select the VR Manager GameObject, and check to see if each input axis is set up. If you''re using the new InputSystem, then please read the documentation for it.

Wheel Dirt

This shows you how to particle collision painting can be used to apply dirt to a car as its wheel kick up dust.

Zombie Blood

This shows you how to paint dynamic blood decals on an animated SkinnedMeshRenderer GameObject. These decals are painted using the Multiply RGB blending mode, which causes them to stack and get darker. Keep in mind the zombie uses a big BoxCollider, so the decal must extend quite far into the zombie to paint it. This is done using a high CwPaintDecal.Scale.z setting, and with the CwHitScreen.Normal = RayDirection setting, to rotate the depth so it faces the paint direction.

UnityEvent
Action

The event that will be invoked.

int
Index

This is the index of the currently selected blending mode.

Color
Color

When using the ReplaceCustom blending mode, this allows you to specify the replacement color.

Texture
Texture

When using the ReplaceCustom blending mode, this allows you to specify the replacement texture.

float
Kernel

When using the Blur or Flow blending modes, this allows you to set the maximum pixel distance of samples.

Vector4
Channels

This allows you to control which channels will be modified by this blending mode.

1,1,1,1 = All channels will be modified.

1,0,0,0 = Only red will be modified.

bool
ClearStates

When clearing a texture, should its undo states be cleared too?

Renderer
TargetRenderer

The renderer whose color will be changed.

int
TargetMaterial

The material index in the target renderer.

string
TargetProperty

The material property that will be changed.

ApplyType
Apply

How should the new color be applied to the target renderer?

void
Recolor

If you want to manually trigger Recolor, then call this function.

void
RedoAll

If you want to manually trigger RedoAll, then call this function.

void
UndoAll

If you want to manually trigger UndoAll, then call this function.

static LinkedList<CwChangeCounter>
Instances

This stores all active and enabled instances.

float
Threshold

The RGBA values must be within this range of a color for it to be counted.

Texture
Texture

The texture we want to compare change to.

None/null = white.

Color
Color

The color we want to compare change to.

int
Count

The previously counted amount of pixels with a RGBA value difference above the threshold.

float
Ratio

The Count / Total value.

bool
HasRead

This will return true once this counter has updated at least once.

static long
GetTotal
ICollection<CwChangeCounter> counters = null

The Total of the specified counters.

static long
GetCount
ICollection<CwChangeCounter> counters = null

The Count of the specified counters.

static float
GetRatio
ICollection<CwChangeCounter> counters = null

The Ratio of the specified counters.

List<CwChangeCounter>
Counters

This allows you to specify the counters that will be used.

None = All active and enabled counters in the scene.

Vector2
Range

This paint ratio must be inside this range to be considered inside.

bool
Inside

This tells you if the paint ratio is within the current Range.

UnityEvent
OnInside

This event will be called on the first frame Inside becomes true.

UnityEvent
OnOutside

This event will be called on the first frame Inside becomes false.

float
Ratio

This tells you the current paint ratio of the specified Color, where 0 is no paint, and 1 is fully painted.

List<CwChangeCounter>
Counters

This allows you to specify the counters that will be used.

Zero = All active and enabled counters in the scene.

bool
Inverse

Inverse the fill?

List<CwChangeCounter>
Counters

This allows you to specify the counters that will be used.

Zero = All active and enabled counters in the scene.

bool
Inverse

Inverse the Count and Percent values?

int
DecimalPlaces

This allows you to set the amount of decimal places when using the percentage output.

string
Format

This allows you to set the format of the team text. You can use the following tokens:

{TOTAL} = Total amount of pixels that can be painted.

{COUNT} = Total amount of pixel that have been painted.

{PERCENT} = Percentage of pixels that have been painted.

StringEvent
OnString

The color count will be output via this event.

static LinkedList<CwChannelCounter>
Instances

This stores all active and enabled instances.

float
Threshold

The RGBA value must be higher than this for it to be counted.

int
CountR

The previously counted amount of pixels with a red channel value above the threshold.

int
CountG

The previously counted amount of pixels with a green channel value above the threshold.

int
CountB

The previously counted amount of pixels with a blue channel value above the threshold.

int
CountA

The previously counted amount of pixels with a alpha channel value above the threshold.

float
RatioR

The CountR/Total value, allowing you to easily see how much % of the red channel is above the threshold.

float
RatioG

The CountG/Total value, allowing you to easily see how much % of the green channel is above the threshold.

float
RatioB

The CountB/Total value, allowing you to easily see how much % of the blue channel is above the threshold.

float
RatioA

The CountA/Total value, allowing you to easily see how much % of the alpha channel is above the threshold.

Vector4
RatioRGBA

The RatioR/G/B/A values packed into a Vector4.

bool
HasRead

This will return true once this counter has updated at least once.

static long
GetTotal
ICollection<CwChannelCounter> counters = null

The Total of the specified counters.

static long
GetCountR
ICollection<CwChannelCounter> counters = null

The CountR of the specified counters.

static long
GetCountG
ICollection<CwChannelCounter> counters = null

The CountG of the specified counters.

static long
GetCountB
ICollection<CwChannelCounter> counters = null

The CountB of the specified counters.

static long
GetCountA
ICollection<CwChannelCounter> counters = null

The CountA of the specified counters.

static float
GetRatioR
ICollection<CwChannelCounter> counters = null

The CountR / Total of the specified counters.

static float
GetRatioG
ICollection<CwChannelCounter> counters = null

The CountG / Total of the specified counters.

static float
GetRatioB
ICollection<CwChannelCounter> counters = null

The CountB / Total of the specified counters.

static float
GetRatioA
ICollection<CwChannelCounter> counters = null

The CountA / Total of the specified counters.

static Vector4
GetRatioRGBA
ICollection<CwChannelCounter> counters = null

The GetCountR/G/B/A / GetTotal of the specified counters stored in a Vector4.

List<CwChannelCounter>
Counters

This allows you to specify the counters that will be used.

None = All active and enabled counters in the scene.

ChannelType
Channel

This allows you to choose which channel will be output to the UI Text.

Vector2
Range

This paint ratio must be inside this range to be considered inside.

bool
Inside

This tells you if the paint ratio is within the current Range.

UnityEvent
OnInside

This event will be called on the first frame Inside becomes true.

UnityEvent
OnOutside

This event will be called on the first frame Inside becomes false.

float
Ratio

This tells you the current paint ratio of the specified Channel, where 0 is no paint, and 1 is fully painted.

List<CwChannelCounter>
Counters

This allows you to specify the counters that will be used.

Zero = All active and enabled counters in the scene.

ChannelType
Channel

This allows you to choose which channel will be output to the UI Image.

bool
Inverse

Inverse the fill?

List<CwChannelCounter>
Counters

This allows you to specify the counters that will be used.

Zero = All active and enabled counters in the scene.

ChannelType
Channel

This allows you to choose which channel will be output to the UI Text.

bool
Inverse

Inverse the Count and Percent values?

int
DecimalPlaces

This allows you to set the amount of decimal places when using the percentage output.

string
Format

This allows you to set the format of the team text. You can use the following tokens:

{TOTAL} = Total amount of pixels that can be painted.

{COUNT} = Total amount of pixel that have been painted.

{PERCENT} = Percentage of pixels that have been painted.

StringEvent
OnString

The color count will be output via this event.

static LinkedList<CwClone>
Instances

This stores all active and enabled instances in the open scenes.

bool
Flip

When a decal is mirrored it will appear backwards, should it be flipped back around?

Color
Color

The color associated with this component and GameObject name.

static LinkedList<CwColor>
Instances

This stores all active and enabled instances in the open scenes.

int
Total

This tells you how many pixels this color could be painted on.

int
Solid

This tells you how many pixels this color has been painted on.

float
Ratio

This is Solid/Total, allowing you to quickly see the percentage of paintable pixels that have been painted by this color.

static LinkedList<CwColorCounter>
Instances

This stores all active and enabled instances.

float
Threshold

The RGBA values must be within this range of a color for it to be counted.

List<Contribution>
Contributions

Each color contribution will be stored in this list.

bool
HasRead

This will return true once this counter has updated at least once.

static long
GetTotal
ICollection<CwColorCounter> counters = null

The Total of the specified counters.

static long
GetCount
CwColor color, ICollection<CwColorCounter> counters = null

The Count of the specified counters.

static float
GetRatio
CwColor color, ICollection<CwColorCounter> counters = null

The Ratio of the specified counters.

int
Count
CwColor color

This tells you how many pixels of the specified color are in the current PaintableTexture.

List<CwColorCounter>
Counters

This allows you to specify the counters that will be used.

None = All active and enabled counters in the scene.

CwColor
Color

This allows you to set which color will be handled by this component.

Vector2
Range

This paint ratio must be inside this range to be considered inside.

bool
Inside

This tells you if the paint ratio is within the current Range.

UnityEvent
OnInside

This event will be called on the first frame Inside becomes true.

UnityEvent
OnOutside

This event will be called on the first frame Inside becomes false.

float
Ratio

This tells you the current paint ratio of the specified Color, where 0 is no paint, and 1 is fully painted.

List<CwColorCounter>
Counters

This allows you to specify the counters that will be used.

Zero = All active and enabled counters in the scene.

CwColor
Color

This allows you to set which color will be handled by this component.

bool
Inverse

Inverse the fill?

List<CwColorCounter>
Counters

This allows you to specify the counters that will be used.

Zero = All active and enabled counters in the scene.

CwColor
Color

This allows you to set which color will be handled by this component.

bool
Inverse

Inverse the Count and Percent values?

int
DecimalPlaces

This allows you to set the amount of decimal places when using the percentage output.

string
Format

This allows you to set the format of the team text. You can use the following tokens:

{TOTAL} = Total amount of pixels that can be painted.

{COUNT} = Total amount of pixel that have been painted.

{PERCENT} = Percentage of pixels that have been painted.

StringEvent
OnString

The color count will be output via this event.

int
Index

This is the original array index, used to stable sort between two commands if they have the same priority.

bool
Preview

Is this preview painting, or real painting?

int
Priority

The draw order priority of this command for this frame.

CwHashedMaterial
Material

The hash of the Material used to apply this paint command.

int
Pass

The material pass that will be used.

CwHashedModel
Model

The hash of the Model used to apply this paint command.

int
Submesh

The mesh submesh that will be painted.

CwHashedTexture
LocalMaskTexture

The LocalMask that will be used when painting.

Vector4
LocalMaskChannel

The channel of the LocalMaskTexture that will be used.

void
SetShape
Quaternion rotation, Vector3 size, float angle

This method allows you to set the shape and rotation of the decal.

bool
Listening

Should this component listen for added commands?

void
Clear

This method will pool and clear all commands.

void
RebuildRandomCommand

This method will clear all paintable textures, and apply one random paint command that was recorded.

static void
SaveBytes
string saveName, byte[] data, bool save = true

This method allows you to save a byte array to PlayerPrefs, and is used by the texture saving system.

If you want to save to files instead then just modify this.

static byte[]
LoadBytes
string saveName

This method allows you to load a byte array from PlayerPrefs, and is used by the texture loading system.

If you want to save to files instead then just modify this.

static bool
SaveExists
string saveName

This method tells if you if there exists save data at the specified save name.

static void
ClearSave
string saveName, bool save = true

This method allows you to clear save data at the specified save name.

Mesh
Source

The original mesh whose UV seams you want to fix.

Coord
First

The coord that will be copied into the first UV channel of the output mesh.

Coord
Second

The coord that will be copied into the second UV channel of the output mesh.

Coord
Third

The coord that will be copied into the third UV channel of the output mesh.

Coord
Fourth

The coord that will be copied into the fourth UV channel of the output mesh.

float
Seconds

If this component has been active for this many seconds, the current GameObject will be destroyed.

-1 = DestroyNow must be manually called.

GameObject
Target

This GameObject will be destroyed.

Transform
Tools

Rotation will be active if all of these tools are deactivated.

KeyCode
Key

The key that must be held for this component to activate on desktop platforms.

None = Any mouse button.

LayerMask
GuiLayers

Fingers that began touching the screen on top of these UI layers will be ignored.

float
Pitch

The target pitch angle in degrees.

float
PitchSensitivity

The speed the pitch changed relative to the mouse/finger drag distance.

float
PitchMin

The minimum value of the pitch value.

float
PitchMax

The maximum value of the pitch value.

float
Yaw

The target yaw angle in degrees.

float
YawSensitivity

The speed the yaw changed relative to the mouse/finger drag distance.

float
Dampening

How quickly the rotation transitions from the current to the target value (-1 = instant).

CwPaintableTexture
PaintableTexture

This allows you to choose which paintable texture will be modified by this component.

float
Threshold

Once this component has accumulated this amount of fade, it will be applied to the PaintableTexture. The lower this value, the smoother the fading will appear, but also the higher the performance cost.

float
Speed

The speed of the fading.

1 = 1 Second.

2 = 0.5 Seconds.

CwBlendMode
BlendMode

This component will paint using this blending mode.

Texture
BlendTexture

The texture that will be faded toward.

CwPaintableTexture
BlendPaintableTexture

The paintable texture that will be faded toward.

Color
BlendColor

The color that will be faded toward.

Texture
MaskTexture

If you want the gradually fade effect to be masked by a texture, then specify it here.

CwPaintableTexture
MaskPaintableTexture

If you want the gradually fade effect to be masked by a paintable texture, then specify it here.

CwChannel
MaskChannel

This allows you to specify the channel of the mask.

int
Index

This allows you to set the ID of this group (e.g. 100).

static List<CwGroupData>
CachedInstances

This static property returns a list of all cached CwGroupData instances.

string
GetName
bool prefixNumber

This method allows you to get the name of the current group, with an optional prefix of the Index (e.g. "100: Albedo").

static string
GetGroupName
int index, bool prefixNumber

This static method calls GetAlias on the CwGroupData with the specified Index setting, or null.

static CwGroupData
GetGroupData
int index

This static method returns the CwGroupData with the specified Index setting, or null.

static void
UpdateCachedInstances

This static method forces the cached instance list to update.

Vector3
Position

The world position that was hit.

Vector3
Normal

The world normal that was hit.

Transform
Transform

The Transform that was hit.

int
TriangleIndex

The triangle index that was hit.

float
Distance

The world distance that was hit.

Collider
Collider

The Collider that was hit.

PhaseType
PaintIn

Where in the game loop should this component hit?

float
Interval

The time in seconds between each raycast.

0 = Every frame.

-1 = Manual only.

Transform
PointA

The start point of the raycast.

Transform
PointB

The end point of the raycast.

float
Fraction

The end point of the raycast.

LayerMask
Layers

The layers you want the raycast to hit.

OrientationType
Orientation

How should the hit point be oriented?

WorldUp = It will be rotated to the normal, where the up vector is world up.

CameraUp = It will be rotated to the normal, where the up vector is world up.

ThisRotation = The current Transform.rotation will be used.

ThisLocalRotation = The current Transform.localRotation will be used.

CustomRotation = The specified CustomTransform.rotation will be used.

CustomLocalRotation = The specified CustomTransform.localRotation will be used.

Camera
Camera

Orient to a specific camera?

None = MainCamera.

Transform
CustomTransform

If you use Orientation = CustomRotation/CustomLocalRotation, this allows you to set the transform.

NormalType
Normal

Which normal should the hit point rotation be based on?

float
Offset

If you want the raycast hit point to be offset from the surface a bit, this allows you to set by how much in world space.

bool
Preview

Should the applied paint be applied as a preview?

int
Priority

This allows you to override the order this paint gets applied to the object during the current frame.

float
Pressure

This allows you to control the pressure of the painting. This could be controlled by a VR trigger or similar for more advanced effects.

EmitType
Draw

This allows you to control the hit data this component sends out.

PointsIn3D = Point drawing in 3D.

PointsOnUV = Point drawing on UV (requires non-convex MeshCollider).

TrianglesIn3D = Triangle drawing in 3D.

Transform
Point

If you want to display something at the hit point (e.g. particles), you can specify the Transform here.

LineRenderer
Line

If you want to draw a line between the start point and the his point then you can set the line here.

CwPointConnector
Connector

This allows you to connect the hit points together to form lines.

void
ManuallyHitNow

This method will immediately submit a non-preview hit. This can be used to apply real paint to your objects.

void
ClearHitCache

This component sends hit events to a cached list of components that can receive them. If this list changes then you must manually call this method.

void
ResetConnections

If this GameObject has teleported and you have ConnectHits or HitSpacing enabled, then you can call this to prevent a line being drawn between the previous and current points.

EmitType
Emit

This allows you to control the hit data this component sends out.

PointsIn3D = Point drawing in 3D.

PointsOnUV = Point drawing on UV (requires non-convex MeshCollider).

TrianglesIn3D = Triangle drawing in 3D.

float
RaycastDistance

When emitting PointsOnUV or TrianglesIn3D, this setting allows you to specify the world space distance from the hit point a raycast will be fired. This is necessary because collisions by themselves don't provide the necessary information.

LayerMask
Layers

This allows you to filter collisions to specific layers.

bool
OnlyUseFirstContact

If there are multiple contact points, skip them?

float
Delay

If this component is generating too many hits, then you can use this setting to ignore hits for the specified amount of seconds.

0 = Unlimited.

OrientationType
Orientation

How should the hit point be oriented?

WorldUp = It will be rotated to the normal, where the up vector is world up.

CameraUp = It will be rotated to the normal, where the up vector is world up.

Camera
Camera

Orient to a specific camera?

None = MainCamera.

bool
Preview

Should the applied paint be applied as a preview?

float
Threshold

If the collision impact speed is below this value, then the collision will be ignored.

PressureType
PressureMode

This allows you to set how the pressure value will be calculated.

Constant = The PressureConstant value will be directly used.

ImpactSpeed = The pressure will be 0 when the collision impact speed is PressureMin, and 1 when the impact speed is or exceeds PressureMax.

float
PressureMin

The impact strength required for a hit to occur with a pressure of 0.

float
PressureMax

The impact strength required for a hit to occur with a pressure of 1.

float
PressureConstant

The pressure value used when PressureMode is set to Constant.

float
PressureMultiplier

The calculated pressure value will be multiplied by this.

float
Offset

If you want the raycast hit point to be offset from the surface a bit, this allows you to set by how much in world space.

int
Priority

This allows you to override the order this paint gets applied to the object during the current frame.

GameObject
Root

Hit events are normally sent to all components attached to the current GameObject, but this setting allows you to override that. This is useful if you want to use multiple CwHitCollisions components with different settings and results.

void
ClearHitCache

This component sends hit events to a cached list of components that can receive them. If this list changes then you must manually call this method.

PhaseType
PaintIn

Where in the game loop should this component hit?

float
Interval

The time in seconds between each hit.

0 = Every frame.

bool
Preview

Should the applied paint be applied as a preview?

int
Priority

This allows you to override the order this paint gets applied to the object during the current frame.

float
Pressure

This allows you to control the pressure of the painting. This could be controlled by a VR trigger or similar for more advanced effects.

CwPointConnector
Connector

This allows you to connect the hit points together to form lines.

void
ManuallyHitNow

This method will immediately submit a non-preview hit. This can be used to apply real paint to your objects.

void
ClearHitCache

This component sends hit events to a cached list of components that can receive them. If this list changes then you must manually call this method.

void
ResetConnections

If this GameObject has teleported and you have ConnectHits or HitSpacing enabled, then you can call this to prevent a line being drawn between the previous and current points.

EmitType
Emit

This allows you to control the hit data this component sends out.

PointsIn3D = Point drawing in 3D.

PointsOnUV = Point drawing on UV (requires non-convex MeshCollider).

TrianglesIn3D = Triangle drawing in 3D.

float
RaycastDistance

When emitting PointsOnUV or TrianglesIn3D, this setting allows you to specify the world space distance from the hit point a raycast will be fired. This is necessary because particles by themselves don't provide the necessary information.

LayerMask
Layers

This allows you to filter collisions to specific layers.

OrientationType
Orientation

How should the hit point be oriented?

WorldUp = It will be rotated to the normal, where the up vector is world up.

CameraUp = It will be rotated to the normal, where the up vector is world up.

Camera
Camera

Orient to a specific camera?

None = MainCamera.

NormalType
Normal

Which normal should the hit point rotation be based on?

float
Offset

If you want the raycast hit point to be offset from the surface a bit, this allows you to set by how much in world space.

int
Skip

If you have too many particles, then painting can slow down. This setting allows you to reduce the amount of particles that actually cause hits.

0 = Every particle will hit.

5 = Skip 5 particles, then hit using the 6th.

bool
Preview

Should the particles paint preview paint?

int
Priority

This allows you to override the order this paint gets applied to the object during the current frame.

PressureType
PressureMode

This allows you to set how the pressure value will be calculated.

Constant = The PressureConstant value will be directly used.

Distance = A value will be calculated based on the distance between this emitter and the particle hit point.

Speed = A value will be calculated based on the hit speed of the particle.

float
PressureMin

This allows you to specify the distance/speed that gives 0.0 pressure.

float
PressureMax

This allows you to specify the distance/speed that gives 1.0 pressure.

float
PressureConstant

The pressure value used when PressureMode is set to Constant.

float
PressureMultiplier

The calculated pressure value will be multiplied by this.

GameObject
Root

Hit events are normally sent to all components attached to the current GameObject, but this setting allows you to override that. This is useful if you want to use multiple CwHitParticles components with different settings and results.

void
ClearHitCache

This component sends hit events to a cached list of components that can receive them. If this list changes then you must manually call this method.

LayerMask
GuiLayers

Fingers that began touching the screen on top of these UI layers will be ignored.

FrequencyType
Frequency

This allows you to control how often the screen is painted.

PixelInterval = Once every Interval pixels.

ScaledPixelInterval = Like PixelInterval, but scaled to the screen DPI.

TimeInterval = Once every Interval seconds.

OnceOnRelease = When the finger/mouse goes down a preview will be shown, and when it goes up the paint will apply.

OnceOnPress = When the finger/mouse goes down the paint will apply.

OnceEveryFrame = Every frame the paint will apply.

float
Interval

This allows you to set the pixels/seconds between each hit point based on the current Frequency setting.

CwPointConnector
Connector

This allows you to connect the hit points together to form lines.

void
ClearHitCache

This component sends hit events to a cached list of components that can receive them. If this list changes then you must manually call this method.

void
ResetConnections

If this GameObject has teleported and you have ConnectHits or HitSpacing enabled, then you can call this to prevent a line being drawn between the previous and current points.

Camera
Camera

Orient to a specific camera?

None = MainCamera.

LayerMask
Layers

The layers you want the raycast to hit.

EmitType
Emit

This allows you to control the hit data this component sends out.

PointsIn3D = Point drawing in 3D.

PointsOnUV = Point drawing on UV (requires non-convex MeshCollider).

TrianglesIn3D = Triangle drawing in 3D (requires non-convex MeshCollider).

RotationType
RotateTo

This allows you to control how the paint is rotated.

Normal = The rotation will be based on a normal direction, and rolled relative to an up axis.

World = The rotation will be aligned to the world, or given no rotation.

ThisRotation = The current Transform.rotation will be used.

ThisLocalRotation = The current Transform.localRotation will be used.

CustomRotation = The specified CustomTransform.rotation will be used.

CustomLocalRotation = The specified CustomTransform.localRotation will be used.

DirectionType
NormalDirection

Which direction should the hit point rotation be based on?

RelativeType
NormalRelativeTo

Based on the normal direction, what should the rotation be rolled relative to?

WorldUp = It will be rolled so the up vector is world up.

CameraUp = It will be rolled so the up vector is camera up.

DrawAngle = It will be rolled according to the mouse/finger movement on screen.

Transform
CustomTransform

This allows you to specify the Transform when using RotateTo = CustomRotation/CustomLocalRotation.

bool
StoreStates

Should painting triggered from this component be eligible for being undone?

int
Priority

This allows you to override the order this paint gets applied to the object during the current frame.

float
NormalOffset

If you want the raycast hit point to be offset from the surface a bit, this allows you to set by how much in world space.

float
FillSpacing

This allows you to set the pixel distance between each grid point.

FrequencyType
Frequency

This allows you to control how many hit points will be generated along the drawn line.

StartAndEnd = Once at the start, and once at the end.

PixelInterval = Once at the start, and then every Interval pixels.

ScaledPixelInterval = Once at the start, and then every Interval scaled pixels.

StretchedPixelInterval = Like ScaledPixelInterval, but the hits are stretched to reach the end.

StretchedScaledPixelInterval = Like ScaledPixelInterval, but the hits are stretched to reach the end.

Once = Once at the specified Position and PixelOffset along the line.

float
Interval

This allows you to set the pixels between each hit point based on the current Frequency setting.

float
Position

When using Frequency = Once, this allows you to set the 0..1 position along the line.

float
PixelOffset

When using Frequency = Once, this allows you to set the pixel offset along the line.

CwPointConnector
Connector

This allows you to connect the hit points together to form lines.

void
ClearHitCache

This component sends hit events to a cached list of components that can receive them. If this list changes then you must manually call this method.

void
ResetConnections

If this GameObject has teleported and you have ConnectHits or HitSpacing enabled, then you can call this to prevent a line being drawn between the previous and current points.

PhaseType
PaintIn

Where in the game loop should this component hit?

float
Interval

The time in seconds between each hit.

0 = Every frame.

-1 = Manual only.

Transform
PointA

The start point of the raycast.

Transform
PointB

The end point of the raycast.

OrientationType
Orientation

How should the hit point be oriented?

WorldUp = It will be rotated to the normal, where the up vector is world up.

CameraUp = It will be rotated to the normal, where the up vector is world up.

Camera
Camera

Orient to a specific camera?

None = MainCamera.

float
Pressure

This allows you to control the pressure of the painting. This could be controlled by a VR trigger or similar for more advanced effects.

bool
Preview

Should the applied paint be applied as a preview?

int
Priority

This allows you to override the order this paint gets applied to the object during the current frame.

LineRenderer
Line

If you want to draw a line between the start point and the his point then you can set the line here.

CwLineConnector
Connector

This allows you to connect the hit points together to form lines.

void
ManuallyHitNow

This method will immediately submit a non-preview hit. This can be used to apply real paint to your objects.

void
ClearHitCache

This component sends hit events to a cached list of components that can receive them. If this list changes then you must manually call this method.

void
ResetConnections

If this GameObject has teleported and you have ConnectHits or HitSpacing enabled, then you can call this to prevent a line being drawn between the previous and current points.

string
AxisName

The name of the input axis in the Project Settings.

int
AxisIndex

The index of the input axis in the Project Settings.

float
HitSpacing

The world space distance between each paint point.

0 = No spacing.

int
HitLimit

When using HitSpacing, this prevents scenarios where something goes wrong and you attempt to paint too many times per frame.

bool
ConnectHits

If you enable this then the hit lines generated by this component will be connected into quads, allowing you to paint continuously.

bool
ClipConnected

If you enable ConnectHits, then each connected quad will overlap with the next. When using semi-transparent painting, this causes the overlap to become double opacity and look obvious. If you enable this setting, then this overlapping area will be removed.

void
ClearHitCache

This component sends hit events to a cached list of components that can receive them. If this list changes then you must manually call this method.

void
ResetConnections

If this GameObject has teleported and you have ConnectHits or HitSpacing enabled, then you can call this to prevent a quad being drawn between the previous and current lines.

Texture
Texture

The mask will use this texture shape.

CwChannel
Channel

The mask will use pixels from this texture channel.

bool
Invert

By default, opaque/white parts of the mask are areas you can paint, and transparent/black parts are parts that are masked. Invert this?

Vector2
Stretch

If you want the sides of the mask to extend farther out, then this allows you to set the scale of the boundary.

1 = Default.

2 = Double size.

static LinkedList<CwMask>
Instances

This stores all active and enabled instances in the open scenes.

int
Index

The material index that will be cloned. This matches the Materials list in your MeshRenderer/SkinnedMeshRenderer, where 0 is the first material.

string
ShaderKeyword

If this shader needs specific keywords enabled, you can add them here.

List<External>
Externals

The cloned material also belongs to these external GameObjects. This is used with texture atlasing.

bool
Activated

This lets you know if this component has already been activated and has executed.

void
Activate

This allows you to manually activate this component, cloning the specified material.

void
Deactivate

This reverses the material cloning.

Mesh
Source

The original mesh.

Mesh
Output

The fixed mesh.

List<Pair>
Meshes

The meshes we will fix.

CwCoord
Coord

The UV channel whose seams will be fixed.

bool
GenerateUV

Generate UV data for the meshes?

float
AngleError

Maximum allowed angle distortion (0..1).

float
AreaError

Maximum allowed area distortion (0..1).

float
HardAngle

This angle (in degrees) or greater between triangles will cause seam to be created.

float
PackMargin

How much uv-islands will be padded.

bool
FixOverflow

If UV data is shifted out of the 0..1 range (e.g. 3..4), it will be wrapped back to 0..1.

However, if these wrapped triangles still go outside the 0..1 range, should they be wrapped to the other side so it can still be fully painted?

bool
FixSeams

Fix the seams of the meshes?

float
Border

The thickness of the UV borders in the fixed mesh.

void
AddMesh
Mesh mesh

This allows you to add a mesh to the seam fixer.

static void
Generate
Mesh source, Mesh output, bool generateUV, bool fixOverflow, bool fixSeams, CwCoord coord, float border

This static method allows you to fix any mesh at runtime.

bool
IncludeScale

Transform the mesh with its position, rotation, and scale? Some skinned mesh setups require this to be disabled.

UseMeshType
UseMesh

This allows you to choose how the Mesh attached to the current Renderer is used when painting.

AsIs = Use what is currently set in the renderer.

AutoSeamFix = Use (or automatically generate) a seam-fixed version of the mesh currently set in the renderer.

void
DirtyMaterials

Materials will give you a cached CachedRenderer.sharedMaterials array. If you have updated this array externally then call this to force the cache to update next them it's accessed.

CwHash
Hash

The hash code for this model used for de/serialization of this instance.

Vector3
BaseScale

If you want the paintable texture width/height to be multiplied by the scale of this GameObject, this allows you to set the scale where you want the multiplier to be 1.

static LinkedList<CwModel>
Instances

This stores all active and enabled instances in the open scenes.

static List<CwModel>
FindOverlap
Vector3 position, float radius, int layerMask

This will return a list of all paintables that overlap the specified bounds

void
ScaleSize
ref int width, ref int height

This will scale the specified width and height values based on the current BaseScale setting.

bool
Preview

Should this modifier apply to preview paint as well?

bool
Unique

Should this modifier use a unique seed?

int
Count

The amount of modifiers in the list.

List<CwModifier>
Instances

This stores all modifiers in this list.

float
Min

This is the minimum random angle that will be picked.

float
Max

This is the maximum random angle that will be picked.

BlendType
Blend

The way the picked angle value will be blended with the current one.

Gradient
Gradient

This is the gradient containing all the possible colors. A color will be randomly picked from this.

BlendType
Blend

The way the picked color value will be blended with the current one.

float
Hardness

The paint component's Hardness value will be modified using this value based on the current Blend setting.

BlendType
Blend

This allows you to control how this new Hardness value will modify the old value in the paint component.

Replace = Transition between [old, new] based on pressure.

Multiply = Transition between [old, old*new] based on pressure.

Increment = Transition between [old, old+new] based on pressure.

float
Min

This is the minimum random hardness that will be picked.

float
Max

This is the maximum random hardness that will be picked.

BlendType
Blend

The way the picked hardness value will be blended with the current one.

float
Opacity

The paint component's Opacity value will be modified using this value based on the current Blend setting.

BlendType
Blend

This allows you to control how this new Opacity value will modify the old value in the paint component.

Replace = Transition between [old, new] based on pressure.

Multiply = Transition between [old, old*new] based on pressure.

Increment = Transition between [old, old+new] based on pressure.

float
Min

This is the minimum random opacity that will be picked.

float
Max

This is the maximum random opacity that will be picked.

BlendType
Blend

The way the picked opacity value will be blended with the current one.

float
Radius

The position will be offset up to this radius away in world space.

float
Radius

The paint component's Radius value will be modified using this value based on the current Blend setting.

BlendType
Blend

This allows you to control how this new Radius value will modify the old value in the paint component.

Replace = Transition between [old, new] based on pressure.

Multiply = Transition between [old, old*new] based on pressure.

Increment = Transition between [old, old+new] based on pressure.

float
Min

This is the minimum random radius that will be picked.

float
Max

This is the maximum random radius that will be picked.

BlendType
Blend

The way the picked radius value will be blended with the current one.

Vector3
Min

This is the minimum random scale that will be picked.

Vector3
Max

This is the maximum random scale that will be picked.

BlendType
Blend

The way the picked scale value will be blended with the current one.

bool
Uniform

If you disable this then each x, y, and z value will be scaled separately.

Texture
Texture

The painting texture will be changed to this.

float
PressureMin

The paint pressure must be at least this value.

float
PressureMax

The paint pressure must be at most this value.

List<Texture>
Textures

A random texture will be picked from this list.

static LinkedList<CwPaintableManager>
Instances

This stores all active and enabled instances in the open scenes.

int
ReadPixelsBudget

If the current GPU doesn't support async texture reading, this setting allows you to limit how many pixels are read per frame to reduce lag.

static event System.Action<object>
OnBeginPainting

This event is called before a component paints something, where 'object' is a reference to the component or link that will do the painting.

static object
LastPaintingObject

Before a component submits paint hits/commands, it will register the 'object' reference to track the painting.

static void
MarkActivelyPainting

If a component is currently painting, it can call this method.

ActivationType
Activation

This allows you to control when this component actually activates and becomes ready for painting. You probably don't need to change this.

MaterialApplicationType
MaterialApplication

This allows you to specify how the paintable textures will be applied to this paintable object.

PropertyBlock = Using MaterialSetPropertyBlock feature.

ClonerAndTextures = Using (Optional) CwMaterialCloner and Material.SetTexture calls.

List<Renderer>
OtherRenderers

If this material is used in multiple renderers, you can specify them here. This usually happens with different LOD levels.

UnityEvent
OnActivating

This event will be invoked before this component is activated.

UnityEvent
OnActivated

This event will be invoked after this component is activated.

UnityEvent
OnDeactivating

This event will be invoked before this component is deactivated.

UnityEvent
OnDeactivated

This event will be invoked after this component is deactivated.

bool
IsActivated

This lets you know if this paintable has been activated.

Being activated means each associated CwMaterialCloner and CwPaintableTexture has been Activated.

HashSet<CwPaintableMeshTexture>
PaintableTextures

This gives you all CwPaintableTexture components that have been activated with this paintable mesh.

void
RemoveComponents

This method will remove all CwPaintableMesh and CwPaintableTexture and CwMaterialCloner components from this GameObject.

void
Activate

This allows you to manually activate all attached CwMaterialCloner and CwPaintableTexture components.

void
Deactivate

This reverses the material cloning.

void
ClearAll
Color color

This allows you to clear the pixels of all activated CwPaintableTexture components associated with this CwPaintable with the specified color.

void
ClearAll
Texture texture, Color color

This allows you to clear the pixels of all activated CwPaintableTexture components associated with this CwPaintable with the specified color and texture.

void
Register
CwPaintableMeshTexture paintableTexture

This allows you to manually register a CwPaintableTexture.

void
Unregister
CwPaintableMeshTexture paintableTexture

This allows you to manually unregister a CwPaintableTexture.

CwPaintableMesh
Parent

The paintable mesh this atlas mesh is associated with.

CwPaintableTexture
PaintableTexture

This is the paintable texture whose pixels we will count.

bool
WaitUntilNotPainting

Should this counter only read when you're not currently painting?

float
Interval

This allows you to specify the minimum delay between when your texture is painted, and when the data is read.

0 = As fast as possible.

1 = Once a second.

bool
Async

If you disable this, then the texture will be updated immediately, which may cause slowdown.

bool
ReadAtStart

If you enable this, then the reader will update as soon as it starts. If not, you must manually populate it with default data.

int
DownsampleSteps

Testing all the pixels of a texture can be slow, so you can pick how many times the texture is downsampled. One downsample = half width & height or 1/4 of the pixels.

event System.Action
OnUpdated

This event is invoked each time this texture monitor updates its pixel counts.

bool
Registered

This will be true after Register is successfully called.

void
Register

This forces the specified CwPaintableTexture to be registered.

void
Unregister

This forces the specified CwPaintableTexture to be unregistered.

Mesh
MaskMesh

If you want this component to accurately count pixels relative to a mask mesh, then specify it here.

int
MaskSubmesh

If you have a MaskMesh set, then this allows you to choose which submesh of it will be used for the mask.

Texture
MaskTexture

If you want this component to accurately count pixels relative to a mask texture, then specify it here.

CwChannel
MaskChannel

This allows you to specify which channel of the MaskTexture will be used to define the mask.

int
Total

The previously counted total amount of pixels.

UnityEvent
Action

The event that will be invoked.

Color
Color

The color of the debug.

float
Duration

The duration of the debug.

float
Size

The size of the debug.

LayerMask
Layers

Only the CwPaintable___ GameObjects whose layers are within this mask will be eligible for painting.

CwPaintableMeshAtlas
TargetModel

If this is set, then only the specified CwPaintable___ will be painted, regardless of the layer setting.

CwGroup
Group

Only the CwPaintableTexture components with a matching group will be painted by this component.

CwPaintableTexture
TargetTexture

If this is set, then only the specified CwPaintableTexture will be painted, regardless of the layer or group setting.

CwBlendMode
BlendMode

This allows you to choose how the paint from this component will combine with the existing pixels of the textures you paint.

Texture
Texture

The decal that will be painted.

Texture
Shape

This allows you to specify the shape of the decal. This is optional for most blending modes, because they usually derive their shape from the RGB or A values. However, if you're using the Replace blending mode, then you must manually specify the shape.

CwChannel
ShapeChannel

This allows you specify the texture channel used when sampling Shape.

Color
Color

The color of the paint.

float
Opacity

The opacity of the brush.

float
Angle

The angle of the decal in degrees.

Vector3
Scale

This allows you to control the mirroring and aspect ratio of the decal.

1, 1 = No scaling.

-1, 1 = Horizontal Flip.

float
Radius

The radius of the paint brush.

float
Hardness

This allows you to control the sharpness of the near+far depth cut-off point.

float
Wrapping

This allows you to control how much the decal can wrap around uneven paint surfaces.

float
NormalFront

This allows you to control how much the paint can wrap around the front of surfaces.

For example, if you want paint to wrap around curved surfaces then set this to a higher value.

float
NormalBack

This works just like Normal Front, except for back facing surfaces.

float
NormalFade

This allows you to control the smoothness of the normal cut-off point.

Texture
TileTexture

This allows you to apply a tiled detail texture to your decals. This tiling will be applied in world space using triplanar mapping.

Transform
TileTransform

This allows you to adjust the tiling position + rotation + scale using a Transform.

float
TileOpacity

This allows you to control the triplanar influence.

0 = No influence.

1 = Full influence.

float
TileTransition

This allows you to control how quickly the triplanar mapping transitions between the X/Y/Z planes.

bool
FindMask

If your scene contains a CwMask, should this paint component use it?

bool
FindDepthMask

If your scene contains a CwRenderDepth, should this paint component use it?

CwModifierList
Modifiers

This stores a list of all modifiers used to change the way this component applies paint (e.g. CwModifyColorRandom).

void
FlipHorizontal

This method will invert the scale.x value.

void
FlipVertical

This method will invert the scale.y value.

void
IncrementAngle
float degrees

This method increments the angle by the specified amount of degrees, and wraps it to the -180..180 range.

void
MultiplyOpacity
float multiplier

This method multiplies the Opacity by the specified value.

void
IncrementOpacity
float delta

This method increments the Opacity by the specified value.

void
MultiplyRadius
float multiplier

This method multiplies the Radius by the specified value.

void
IncrementRadius
float delta

This method increases the Radius by the specified value.

void
MultiplyScale
float multiplier

This method multiplies the Scale by the specified value.

void
IncrementScale
float multiplier

This method increases the Scale by the specified value.

void
HandleHitPoint
bool preview, int priority, float pressure, int seed, Vector3 position, Quaternion rotation

This method paints all pixels at the specified point using the shape of a decal.

void
HandleHitLine
bool preview, int priority, float pressure, int seed, Vector3 position, Vector3 endPosition, Quaternion rotation, bool clip

This method paints all pixels between the two specified points using the shape of a decal.

void
HandleHitTriangle
bool preview, int priority, float pressure, int seed, Vector3 positionA, Vector3 positionB, Vector3 positionC, Quaternion rotation

This method paints all pixels between three points using the shape of a decal.

void
HandleHitQuad
bool preview, int priority, float pressure, int seed, Vector3 position, Vector3 endPosition, Vector3 position2, Vector3 endPosition2, Quaternion rotation, bool clip

This method paints all pixels between two pairs of points using the shape of a decal.

void
HandleHitCoord
bool preview, int priority, float pressure, int seed, CwHit hit, Quaternion rotation

This method paints the scene using the current component settings at the specified CwHit.

CwGroup
Group

Only the CwPaintableTexture components with a matching group will be painted by this component.

CwBlendMode
BlendMode

This allows you to choose how the paint from this component will combine with the existing pixels of the textures you paint.

Texture
Texture

The color of the paint.

Color
Color

The color of the paint.

float
Opacity

The opacity of the brush.

float
Minimum

The minimum RGBA value change. This is useful if you're doing very subtle color changes over time.

CwModifierList
Modifiers

This stores a list of all modifiers used to change the way this component applies paint (e.g. CwModifyColorRandom).

void
IncrementOpacity
float delta

This method increments Opacity by the specified value.

float
Delay

This allows you to specify the simulated delay between painting across the network in seconds.

CwGroup
Group

Only the CwPaintableTexture components with a matching group will be painted by this component.

Texture
Texture

The texture that will be painted.

Color
Color

The color of the paint.

CwModifierList
Modifiers

This stores a list of all modifiers used to change the way this component applies paint (e.g. CwModifyColorRandom).

CwGroup
Group

Only the CwPaintableTexture components with a matching group will be painted by this component.

LayerMask
Layers

Only the CwPaintable___ GameObjects whose layers are within this mask will be eligible for painting.

CwGroup
Group

Only the CwPaintableTexture components with a matching group will be painted by this component.

CwMeshModel
TargetModel

If this is set, then only the specified model will be painted, regardless of the layer setting.

CwPaintableTexture
TargetTexture

If this is set, then only the specified CwPaintableTexture will be painted, regardless of the layer or group setting.

CwBlendMode
BlendMode

This allows you to choose how the paint from this component will combine with the existing pixels of the textures you paint.

Color
Color

The color of the paint.

float
Opacity

The opacity of the brush.

float
Angle

The angle of the paint in degrees.

Vector3
Scale

By default this component paints using a sphere shape, but you can override this here to paint an ellipsoid.

float
Radius

The radius of the paint brush.

float
Hardness

The hardness of the paint brush.

Texture
TileTexture

This allows you to apply a tiled detail texture to your decals. This tiling will be applied in world space using triplanar mapping.

Transform
TileTransform

This allows you to adjust the tiling position + rotation + scale using a Transform.

float
TileOpacity

This allows you to control the triplanar influence.

0 = No influence.

1 = Full influence.

float
TileTransition

This allows you to control how quickly the triplanar mapping transitions between the X/Y/Z planes.

bool
FindMask

If your scene contains a CwMask, should this paint component use it?

bool
FindDepthMask

If your scene contains a CwRenderDepth, should this paint component use it?

CwModifierList
Modifiers

This stores a list of all modifiers used to change the way this component applies paint (e.g. CwModifyColorRandom).

void
IncrementAngle
float degrees

This method increments the angle by the specified amount of degrees, and wraps it to the -180..180 range.

void
MultiplyOpacity
float multiplier

This method multiplies the Opacity by the specified value.

void
IncrementOpacity
float delta

This method increments the Opacity by the specified value.

void
MultiplyRadius
float multiplier

This method multiplies the Radius by the specified value.

void
IncrementRadius
float delta

This method increases the Radius by the specified value.

void
MultiplyScale
float multiplier

This method multiplies the Scale by the specified value.

void
IncrementScale
float multiplier

This method increases the Scale by the specified value.

void
HandleHitPoint
bool preview, int priority, float pressure, int seed, Vector3 position, Quaternion rotation

This method paints all pixels at the specified point using the shape of a sphere.

void
HandleHitLine
bool preview, int priority, float pressure, int seed, Vector3 position, Vector3 endPosition, Quaternion rotation, bool clip

This method paints all pixels between the two specified points using the shape of a sphere.

void
HandleHitTriangle
bool preview, int priority, float pressure, int seed, Vector3 positionA, Vector3 positionB, Vector3 positionC, Quaternion rotation

This method paints all pixels between three points using the shape of a sphere.

void
HandleHitQuad
bool preview, int priority, float pressure, int seed, Vector3 position, Vector3 endPosition, Vector3 position2, Vector3 endPosition2, Quaternion rotation, bool clip

This method paints all pixels between two pairs of points using the shape of a sphere.

void
HandleHitCoord
bool preview, int priority, float pressure, int seed, CwHit hit, Quaternion rotation

This method paints the scene using the current component settings at the specified CwHit.

float
HitSpacing

The world space distance between each paint point.

0 = No spacing.

int
HitLimit

When using HitSpacing, this prevents scenarios where something goes wrong and you attempt to paint too many times per frame.

bool
ConnectHits

If you enable this then the hit points generated by this component will be connected into lines, allowing you to paint continuously.

bool
ClipConnected

If you enable ConnectHits, then each connected line will overlap with the next. When using semi-transparent painting, this causes the overlap to become double opacity and look obvious. If you enable this setting, then this overlapping area will be removed.

void
ClearHitCache

This component sends hit events to a cached list of components that can receive them. If this list changes then you must manually call this method.

void
ResetConnections

If this GameObject has teleported and you have ConnectHits or HitSpacing enabled, then you can call this to prevent a line being drawn between the previous and current points.

bool
Preview

If you enable this, then a paint preview will be shown under the mouse as long as the RequiredKey is not pressed.

List<KeyCode>
Keys

This component will paint while any of the specified mouse buttons or keyboard keys are held.

bool
Preview

If you enable this, then a paint preview will be shown under the pen as long as the tip is not pressed.

float
Offset

If you want the paint to appear above the pen, then you can set this number to something positive.

float
Offset

If you want the paint to appear above the finger, then you can set this number to something positive.

string
Title

This allows you to name this preset.

None/null = The GameObject name will be used.

List<string>
ShaderPaths

This preset is designed to work with the specified shaders.

static List<CwPreset>
CachedPresets

This gives you a list of all presets in the project.

void
AddTo
Renderer root

This method applies the preset components to the specified paintable.

Material
Material

The Material applied to the renderer.

float
Size

The size of the generated quad in local space.

CwGroup
Group

Only the CwPaintableTexture components with a matching group will be painted by this component.

bool
Preview

Should the color be read during preview painting too?

ReadType
Read

How should the texture be read?

Immediate = The reading method will block until the pixel is fetched from the GPU.

Async = The pixel value will be read after some time, giving you better performance.

Color
Color

The last read color value.

ColorEvent
OnColor

When a color is read, this event will be invoked.

Color = The color that was read.

Color
Color

This color we want to detect.

float
Threshold

The RGBA values must be within this range of a color for it to be counted.

ColorEvent
OnColor

When the expected color is read, this event will be invoked.

Color = The expected color.

Camera
SourceCamera

The camera whose depth information will be read.

Matrix4x4
SourceMatrix

The transformation matrix of the camera when the depth texture was generated.

int
ResizeAndDownscale

If this is 0, the RenderTexture size will match the viewport. If it's above 0, then the RenderTexture size will be set to the viewport size divided by this value.

float
Bias

The rendered depth must be at least this mant units different from the painted surface for the paint to be masked out.

bool
Multitap

If you enable this, then the depth mask will be sampled multiple times per pixel, allowing you to paint both foreground and background objects with little to no edge seams.

bool
ReadInStart

Should the scene depth be rendered in Start?

bool
ReadInUpdate

Should the scene depth be rendered every frame in Update?

static LinkedList<CwRenderDepth>
Instances

This stores all active and enabled instances in the open scenes.

void
ReadNow

This method will update the TargetTexture with what the SourceCamera currently sees.

Space
Space

This allows you to set the coordinate space the movement will use.

Vector3
PerSecond

The position will be incremented by this each second.

static Dictionary<int, Material>
HashToMaterial

This stores an association between a Material hash code and the Material instance, so it can be de/serialized.

static Dictionary<Material, int>
MaterialToHash

This stores an association between a Material instance and the Material hash code, so it can be de/serialized.

static Dictionary<CwHash, CwModel>
HashToModel

This stores an association between a CwModel hash code and the CwModel instance, so it can be de/serialized.

static Dictionary<CwModel, CwHash>
ModelToHash

This stores an association between a CwModel instance and the CwModel hash code, so it can be de/serialized.

static Dictionary<CwHash, Texture>
HashToTexture

This stores an association between a Texture hash code and the Texture instance, so it can be de/serialized.

static Dictionary<Texture, CwHash>
TextureToHash

This stores an association between a Texture instance and the Texture hash code, so it can be de/serialized.

static Dictionary<CwHash, CwPaintableTexture>
HashToPaintableTexture

This stores an association between a CwModel hash code and the CwModel instance, so it can be de/serialized.

static Dictionary<CwPaintableTexture, CwHash>
PaintableTextureToHash

This stores an association between a CwModel instance and the CwModel hash code, so it can be de/serialized.

int
Index

The material index in the attached renderer.

string
Name

The name of the texture in the specified material.

List<GameObject>
Prefabs

A random prefab from this list will be spawned.

float
Radius

The spawned prefab will be randomly offset by a random point within this radius in world space.

Vector3
Velocity

If the prefab contains a Rigidbody, it will be given this velocity in local space.

float
OffsetNormal

The spawned prefab will be offset from the hit point based on the hit normal by this value in world space.

Vector3
OffsetWorld

The spawned prefab will be offset from the hit point based on this value in world space.

void
Spawn

Call this if you want to manually spawn the specified prefab.

static void
StoreAllStates

This method will call StoreState on all active and enabled CwPaintableTextures.

static void
PotentiallyStoreAllStates

This method should be called if you're about to send paint hits that might apply paint to objects. If so, StoreState will be called on all active and enabled CwPaintableTextures

static void
ClearAllStates

This method will call ClearStates on all active and enabled CwPaintableTextures.

static void
UndoAll

This method will call Undo on all active and enabled CwPaintableTextures.

static void
RedoAll

This method will call Redo on all active and enabled CwPaintableTextures.

KeyCode
Key

The key that must be held for this component to activate on desktop platforms.

None = Any mouse button.

LayerMask
GuiLayers

Fingers that began touching the screen on top of these UI layers will be ignored.

GameObject
Prefab

The prefab that will be thrown.

float
Speed

The speed that the object will be thrown at.

bool
StoreStates

Should painting triggered from this component be eligible for being undone?

Texture
Texture

The texture that will be hashed.

CwHash
Hash

The hash code for the texture.

LayerMask
GuiLayers

Fingers that began touching the screen on top of these UI layers will be ignored.

KeyCode
Key

The key that must be held for this component to activate.

None = Any mouse button or finger.

ParticleSystem
Target

The particle system that will be enabled/disabled based on mouse/touch.

bool
StoreStates

Should painting triggered from this component be eligible for being undone?