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 P3dLight 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 P3dSceneManager 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.

Step 1 - Make Your Object Paintable

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

Step 2 - Make a Texture Paintable

Next, you need to mark which textures you want to paint. Your MeshRenderer or SkinnedMeshRenderer component has the Materials array, and each texture used by these materials can be painted.

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

Inside this component, you can click the dropdown to the right of the Slot setting, allowing you to pick from a list of materials and texture slots.

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 - Make Your Material Clone Itself

The P3dPaintableTexture component takes over the texture slot of the material you specify, which means all other objects using this material will see the same paint. To fix this you must make sure the material is turned into a unique clone before your paintable textures are applied.

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

Finally, make sure the P3dMaterialCloner.Index setting matches your P3dPaintableTexture.Slot index. For example, if your slot is 0, _MainTex, then your Index should also be set to 0.

Step 4 - Paint It!

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

One simple method is to make a new GameObject, and add the P3dHitScreen and P3dPaintDecal 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 P3dPaintDecal 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!

Step 0 [Optional] - Make a New Scene

Before you paint objects in-editor, I recommend you make a new scene (e.g. copy+paste your objects into a new scene). This is because configuring your objects for painting requires the scene to be modified (these modifications can easily be removed though).

Step 1 - Open Paint in 3D

To open the main Paint in 3D window, click on Window > Paint in 3D > Paint in 3D from the top menu bar, or select the Paint in 3D tool from the top left tool bar.

Step 2 - Make Objects Paintable

Make sure you're on the Scene tab.

Select at least one GameObject in your scene that you want to paint, and it should appear in the list.

On the right of each object you should see the Make Paintable button, which you can click to configure the GameObject for painting.

Step 4 - Make Materials Paintable

After you make an object paintable, you must choose which of its materials you want to paint. Below the object you can see a list of its materials, and on the right side you can click the +Preset button to open a list of preset configurations available for this material.

Step 5 - Export Material & Textures

After you add a material preset, you can see a new Export button next to it. If you click this, then you can save a copy of this material and all its textures to the location you specify.

Once you finish painting you can use this new material with painted textures in your scenes.

Step 6 - Open Paint in Editor

To open the main Paint in Editor window, click on Window > Paint in 3D > Paint in Editor from the top menu bar, or select the Paint in Editor tool from the top left tool bar.

At the top you can see 3 boxes: Tool, Material, and Shape.

If you click the Tool box, then you can choose a paint tool. These control how the paint is applied in the scene (e.g. dots, line, triangles).

If you click the Material box, then you can choose a paint material. These define a set of textures that allow you to paint a type of surface (e.g. brick, dirt, chrome).

If you click the Shape box, then you can choose the paint shape. These change the shape of the material as you paint, giving more interesting edges.

Step 7 - Save

Make sure you're on the Paint in 3D window's Scene tab.

After you've painted your textures, you can click the Re-Export All button at the bottom right. This will automatically save all previously exported textures with the current paint state.

What if I don't know how to UV map?

Unity can automatically do it for you. Just keep in mind that doing it manually will allow you to achieve better results.

To automatically generate UV data, you can enable the Generate Lightmap UVs setting in your mesh import settings. This will generate UV data suitable for painting, and they will be stored in the second UV channel.

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 P3dMaterialCloner and P3dPaintableTexture 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.

How do I copy UV data from the second UV channel to the first?

Paint in 3D comes with the Coord Copier tool, which allows you to do this.

To use this tool, select your mesh in the Project window, and click the context menu (⋮icon) button at the top right of the inspector, and select the Coord Copier (Paint in 3D) option.

Your Project window should now contain a Coord Copier (YOUR_MESH_NAME) prefab, and you can click Generate to copy the coords over.

The generated mesh with the copied coords is now placed as a child of the Coord Copier prefab, and you can drag and drop it into your Mesh Filter or Skinned Mesh Renderers.

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. P3d Opaque).

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 Seams (Paint in 3D).

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

If you want to see the result of the seam fixing, set the Debug Scale setting to 10 or so.

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.

Example 1

This is an example of what a good UV map looks like.

As you can see, the whole mesh is unwrapped making good use of the texture space. All triangles are within the standard (0..1) boundary, none of the triangles overlap, and there is sufficient spacing/padding between each UV 'island'.

Example 2

This is an example of what a bad UV map looks like.

As you can see, most of the triangles have no UV data, so they cannot be painted. The remaining triangles have UV data, but it's all overlapping, which means painting one area will cause paint to appear in multiple areas, because they share the same pixels.

Example 3

This is another example of what a bad UV map looks like.

As you can see, most of the triangles are out of bounds. This means most of the mesh can't be directly painted. If you paint the remaining areas, the paint will appear on the out of bounds areas due to texture tiling.

UndoRedo Setting

The first step is to select your P3dPaintableTexture 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 P3dPaintableTexture 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 P3dPaintableTexture in your scene, letting Paint in 3D know that you're about to paint on them.

For example, the P3dHitScreen component has the StoreStates setting, as well as P3dToggleParticles, and P3dTapThrow.

Buttons

Finally, you can add the P3dUndoAll and P3dRedoAll 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 P3dPaintableTexture 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 P3dPaintableTexture 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 P3dPaintableTexture 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

To paint objects in your scene you need to use a hit component like P3dHitScreen, P3dHitParticles, etc. Some of these components like P3dHitNearby will apply in 3D without the need for colliders, but components like P3dHitScreen use Physics.Raycast, which means your paintable objects need 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. P3dPaintDecal'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 P3dHitScreen component's RotateTo setting is set to Normal, and RotateTo/Direction is set to RayDirection. The P3dPaintDecal 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 P3dPaintable 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 P3dPaintableTexture. 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 P3dHitScreen 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 P3dHitParticles 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.

Paintable Textures

Each preset has one or many P3dPaintableTexture components.

Each paintable texture's Slot setting is automatically set when using the Paint in 3D window, so you can leave it empty.

Each paintable texture must have its own Group setting, which defines the kind of texture it will paint. For example, if you have one paintable texture that targets the "Occlusion (G)" group, then this preset will allow you to paint occlusion textures.

Paint Groups

For a preset to show in the Paint in 3D window, the shader you want to paint must have textures that match all paintable textures in the preset.

Since shaders can arbitrarily define texture names, you must manually associate a paint group with a shader and its texture slot.

You can find the existing paint groups in the PaintCore/Extras/Groups folder.

The way this works is each paint group defines a list of shaders and texture names associated with the group. In the example image you can see the "Albedo (RGB) Alpha (A)" group, which among others has the "_MainTex@Standard" line. This means the "Standard" shader has the "_MainTex" texture, which is an albedo and alpha texture.

Paint in 3D comes pre-configured with paint groups and associations for most built-in Unity shaders.

Paint Hits

Paint hits are the high-level data used to paint your scene (e.g. the P3dHitScreen component sends hit data to components like P3dPaintDecal). 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 P3dHit___ component. You can then implement any of the IHit___ interfaces, to get specific hit data. For example, the P3dHitScreen 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 P3dPaintMultiplayer.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 P3dModel, P3dPaintable, and P3dPaintableTexture 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 P3dTextureHash 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 P3dPaintableTexture.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 P3dCommandSerialization.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 P3dPaintable, P3dMaterialCloner, and P3dPaintableTexture components. You can then paint the spaceship using the mouse/finger with the Paint GameObject, which has the P3dHitScreen and P3dPaintSphere components. Keep in mind that P3dHitScreen 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 Seam 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 seam fixer, simply click the context menu button (⋮ icon) at the top right of your mesh inspector window. You can then select Fix Seams (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 P3dPaintable 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 P3dPaintableTexture.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 P3dPaintableTexture.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 P3dPaintableTexture.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 P3dPaintSphere.Radius setting and/or increasing the P3dHitScreen.Interval setting allows you to draw dotted lines.

Connect Hits

This shows you how the P3dHitScreen 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 P3dButtonClearAll 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 P3dPaintableTexture.Clear method.

Isolate Tools

This shows you how the P3dButtonIsolate 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 P3dPaintSphere 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 P3dPaintableTexture 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 P3dPaintableTexture 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 P3dGenerateMask component alongside your P3dPaintableTexture 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 P3dHitScreen and P3dPaintDecal components can be combined to paint decals. Decals allow you to paint a custom texture on an object at a specific location. The P3dPaintDecal settings give you control over the angle, size, opacity, etc.

Wrapping

This shows you how the P3dPaintDecal 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 P3dHitScreen 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 P3dHitScreen 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 P3dPaintDecal 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 P3dPaintDecal component''s Advanced / NormalFade setting can be used to control the sharpness of the normal cut-off transition.

Settings

This shows you how the P3dPaintDecal 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 P3dCloneMirror 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 P3dCloneMirror.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 P3dTapThrow 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 P3dHitCollisions and P3dPaintDecal components.

Destroyer

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

Spawner

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

Between Painting

This shows you how the P3dHitBetween component can be used to paint between two Transform points. The P3dHitBetween.Line can be used to visualize the current beam, and the P3dHitBetween.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 P3dHitBetween 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 P3dPaintSphere on the first hit point it finds between these two points, and paint them red. The camera can then be rotated using the P3dPitchYaw component.

Through Points

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

Particle Painting

This shows you how the P3dHitParticles component can be added to your ParticleSystem GameObjects. This allows you to paint with components like P3dPaintSphere 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 P3dHitParticles 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 P3dHitParticles 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 P3dPaintSphere, 9 calls are skipped.

Nearby Painting

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

Throw

This shows you how the P3dTapThrow component can spawn and throw the Ball prefab. This prefab has the P3dHitNearby 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 P3dPaintableTexture.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 P3dPaintableTexture.UndoRedo setting can be used to store undo and redo states. You can then add the P3dButtonUndoAll and P3dButtonRedoAll 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 P3dHitScreen.

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. P3dPaintDecal), 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 P3dGraduallyFade 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 P3dPaintableTexture 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 P3dPaintReplace component can be used to replace every pixel in the currently painting texture. Keep in mind the GameObject with the P3dPaintableTexture must have a collider for this to work, and P3dHitScreen.Emit must be set to PointsOnUV.

Fill Painting

This shows you how the P3dPaintFill component can be used to blend every pixel in the painted texture. This allows you to gradually change it, rather than instantly like P3dPaintReplace does. Keep in mind the GameObject with the P3dPaintableTexture must have a collider for this to work, and P3dHitScreen.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 P3dPaintableTexture.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 P3dPaintableTexture.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 P3dChannelCounter component can be used to count the total pixels in the specified P3dPaintableTexture that exceed the threshold value in each R/G/B/A channel. The P3dChannelCounterText 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 P3dChannelCounter.Mesh setting to the original non-seam-fixed mesh. The paint percentage can then be displayed using the P3dChannelCounterText and P3dChannelCounterFill 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 P3dColorCounter component can be used to count the total pixels in the specified P3dPaintableTexture that are within the threshold color of a P3dColor. The P3dColorCounterText component can then be used to display these in the UI.

Change Counter

This shows you how the P3dChangeCounter 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 P3dChangeCounter 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 P3dPaintableTexture 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 P3dPaintabeTexture.State = LocalCommandCopy setting.

Live Painting

This shows you how to create live paint that can be repositioned in game. This is done using the P3dHitNearby 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 P3dHitNearby component's ManuallyHitNow function.

Translate

This shows you how the P3dTranslate component can be used to move a live decal around the scene using UI button events that call the P3dTranslate.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 P3dPaintable.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 P3dPaintable component's Advanced / OtherRenderers list. You must then add the P3dModel component to the other objects, and drag and drop the first object into the P3dModel.Paintable setting.

Fill Painting

This shows you how to paint filled in polygon shapes. This is done by replacing the P3dHitScreen component with the P3dHitScreenFill 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 P3dMask 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 P3dMask 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 P3dPaintableTexture 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 P3dReadColor component, which can be added alongside any P3dHit___ component that works using raycasts like P3dHitScreen and P3dHitBetween. 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 P3dReadColorEvent component, which can be added alongside the P3dReadColor 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 P3dReadColor and P3dPaintBetween 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 P3dPaintMultiplayer 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 P3dProceduralSetup 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 P3dHitScreen 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 P3dPaintableTexture to its current Texture and Color settings. The texture that will be revealed is first hidden using the P3dPaintableTexture.Color setting with 0 alpha. The P3dPaintable.OnActivated event is then used to reset this back to full alpha using the P3dPaintable.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 P3dChangeCounter 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 P3dHitScreen 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 P3dMask. This is done using the P3dPaintableTexture 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/P3dPaintFromCode.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 P3dGraduallyFade 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 P3dGraduallyFade to twist the texture around, but it also has a second P3dGraduallyFade to fade it to black to slow down the speed. The albedo texture''s P3dGraduallyFade.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 P3dGraduallyFadeGroup 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 P3dHitScreen 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 P3dHitNearby and P3dHitThrough components with the P3dPaintSphere and P3dPaintDecal components to continuously paint any pixels that enter the current volume. Keep in mind the P3dPaintDecal.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 P3dHitScreenLine component, which can be combined with the P3dPaintSphere/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 P3dHitScreen and P3dHitScreenLine 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 P3dPaintDebug 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 P3dPaintableTexture 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 P3dGraduallyFade 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 P3dPaintableTexture 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/P3dCommandSerialization.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 P3dMask 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 P3dHitNearby component with the PaintIn setting set to Start. The P3dPaintSphere 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 P3dPaintSphere.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 P3dPaintSphere component's Advanced/TargetModel setting.

Depth Mask

This shows you how to mask paint behind foreground objects. This is done with the P3dRenderDepth component, which can render the scene depth from the perspective of a camera. You can then drag and drop this component into the P3dPaint___ component''s Advanced / DepthMask setting.

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.

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 P3dPaintableTexture.Group setting, and to paint these textures a matching P3dPaintSphere.Group/P3dPaintDecal.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 P3dPaintCollisions components can be used with different layer filtering and different Root settings, allowing you to apply different kinds of paint to different objects. The P3dPaintDecal component and P3dPaintableTexture''s GameObject must have matching layers for this to work.

Shield Impacts

This shows you how P3dHitCollisions and P3dPaintSphereTriplanar can be added to a Rigidbody GameObject. This allows them to paint the Spaceship_Shield GameObject with a special impact pattern. The P3dGraduallyFade 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 P3dToggleParticles 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 P3dPaintDecal.Scale.z setting, and with the P3dHitScreen.Normal = RayDirection setting, to rotate the depth so it faces the paint direction.

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.

static LinkedList<P3dChangeCounter>
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.

static long
GetTotal
ICollection<P3dChangeCounter> counters = null

The Total of the specified counters.

static long
GetCount
ICollection<P3dChangeCounter> counters = null

The Count of the specified counters.

static float
GetRatio
ICollection<P3dChangeCounter> counters = null

The Ratio of the specified counters.

static LinkedList<P3dChannelCounter>
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.

static long
GetTotal
ICollection<P3dChannelCounter> counters = null

The Total of the specified counters.

static long
GetCountR
ICollection<P3dChannelCounter> counters = null

The CountR of the specified counters.

static long
GetCountG
ICollection<P3dChannelCounter> counters = null

The CountG of the specified counters.

static long
GetCountB
ICollection<P3dChannelCounter> counters = null

The CountB of the specified counters.

static long
GetCountA
ICollection<P3dChannelCounter> counters = null

The CountA of the specified counters.

static float
GetRatioR
ICollection<P3dChannelCounter> counters = null

The CountR / Total of the specified counters.

static float
GetRatioG
ICollection<P3dChannelCounter> counters = null

The CountG / Total of the specified counters.

static float
GetRatioB
ICollection<P3dChannelCounter> counters = null

The CountB / Total of the specified counters.

static float
GetRatioA
ICollection<P3dChannelCounter> counters = null

The CountA / Total of the specified counters.

static Vector4
GetRatioRGBA
ICollection<P3dChannelCounter> counters = null

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

static LinkedList<P3dClone>
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<P3dColor>
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<P3dColorCounter>
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.

static long
GetTotal
ICollection<P3dColorCounter> counters = null

The Total of the specified counters.

static long
GetCount
P3dColor color, ICollection<P3dColorCounter> counters = null

The Count of the specified counters.

static float
GetRatio
P3dColor color, ICollection<P3dColorCounter> counters = null

The Ratio of the specified counters.

int
Count
P3dColor color

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

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.

P3dHashedMaterial
Material

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

int
Pass

The material pass that will be used.

P3dHashedModel
Model

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

int
Submesh

The mesh submesh that will be painted.

P3dHashedTexture
LocalMaskTexture

The LocalMask that will be used when painting.

Vector4
LocalMaskChannel

The channel of the LocalMaskTexture that will be used.

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.

P3dPaintableTexture
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.

P3dBlendMode
BlendMode

This component will paint using this blending mode.

Texture
BlendTexture

The texture that will be faded toward.

P3dPaintableTexture
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.

P3dPaintableTexture
MaskPaintableTexture

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

P3dChannel
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).

List<TextureData>
TextureDatas

This allows you to specify the way each channel of this group's pixels are mapped to textures. This is mainly used by the in-editor painting material builder tool.

string
ShaderData

This allows you to specify which shaders and their properties are associated with this group.

static List<P3dGroupData>
CachedInstances

This static property returns a list of all cached P3dGroupData 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 P3dGroupData with the specified Index setting, or null.

static P3dGroupData
GetGroupData
int index

This static method returns the P3dGroupData 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.

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.

P3dChannel
Channel

The mask will use pixels from this texture channel.

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<P3dMask>
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.

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.

P3dPaintable
Paintable

The paintable this separate paintable is associated with.

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.

P3dHash
Hash

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

static LinkedList<P3dModel>
Instances

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

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.

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

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

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<P3dModifier>
Instances

This stores all modifiers in this list.

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.

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.

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
Activated

This lets you know if this paintable has been activated.

Being activated means each associated P3dMaterialCloner and P3dPaintableTexture has been Activated.

HashSet<P3dPaintableTexture>
PaintableTextures

This gives you all P3dPaintableTexture components that have been activated.

void
RemoveComponents

This method will remove all P3dPaintable, P3dMaterialCloner, and P3dPaintableTexture components from this GameObject.

void
ScaleSize
ref int width, ref int height

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

void
Activate

This allows you to manually activate all attached P3dMaterialCloner and P3dPaintableTexture components.

void
Deactivate

This reverses the material cloning.

void
ClearAll
Color color

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

void
ClearAll
Texture texture, Color color

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

void
Register
P3dPaintableTexture paintableTexture

This allows you to manually register a P3dPaintableTexture.

void
Unregister
P3dPaintableTexture paintableTexture

This allows you to manually unregister a P3dPaintableTexture.

static LinkedList<P3dPaintableManager>
Instances

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

P3dSlot
Slot

The material index and shader texture slot name that this component will paint.

P3dCoord
Coord

The UV channel this texture is mapped to.

P3dGroup
Group

The group you want to associate this texture with. Only painting components with a matching group can paint this texture. This allows you to paint multiple textures at the same time with different settings (e.g. Albedo + Normal).

UndoRedoType
UndoRedo

This allows you to set how this texture's state is stored, allowing you to perform undo and redo operations.

FullTextureCopy = A full copy of your texture will be copied for each state. This allows you to quickly undo and redo, and works with animated skinned meshes, but it uses up a lot of texture memory.

LocalCommandCopy = Each paint command will be stored in local space for each state. This allows you to perform unlimited undo and redo states with minimal memory usage, because the object will be repainted from scratch. However, performance will depend on how many states must be redrawn, and it may not work well with skinned meshes.

int
StateLimit

The amount of times this texture can have its paint operations undone.

SaveLoadType
SaveLoad

This allows you to control how this texture is loaded and saved.

Manual = You must manually call Save(SaveName) and Load(SaveName) from code.

Automatic = Save(SaveName) is called in Deactivate/OnDestroy, and Load(SaveName) is called in Activate.

SemiManual = You can manually call the Save() and Load() methods from code or editor event, and the current SaveName will be used.

string
SaveName

If you want this texture to automatically save & load, then you can set the unique save name for it here.

int
Width

The base width of the created texture.

int
Height

The base height of the created texture.

Texture
Texture

When activated or cleared, this paintable texture will be given this texture, and then multiplied/tinted by the Color.

None = White.

Color
Color

When activated or cleared, this paintable texture will be given this color.

RenderTextureFormat
Format

The format of the created texture.

MipType
MipMaps

The useMipMap mode of the created texture.

Auto = Copied from the Texture.

FilterType
Filter

The filterMode of the created texture.

Auto = Copied from the Texture.

AnisoType
Aniso

The anisoLevel of the created texture.

Auto = Copied from the Texture.

WrapType
WrapU

The wrapModeU mode of the created texture.

Auto = Copied from the Texture.

WrapType
WrapV

The wrapModeV of the created texture.

Auto = Copied from the Texture.

ExistingType
Existing

If this component's Texture setting is none/null but the Slot texture is not none/null when this component activates, what should happen?

Ignore = Nothing will happen.

Use = This paintable texture will activate with the Slot texture.

UseAndKeep = The same as Use, but the Slot texture will also be stored in the Texture setting.

ConversionType
Conversion

If you're painting special textures then they may need to be converted before use.

Normal = Convert texture to be a normal map.

Premultiply = Premultiply the RGB values.

Texture
LocalMaskTexture

This allows you to restrict painting to specific areas.

P3dChannel
LocalMaskChannel

This allows you to specify which channel from the LocalMaskTexture texture will be used.

string
ShaderKeyword

Some shaders require specific shader keywords to be enabled when adding new textures. If there is no texture in your selected slot then you may need to set this keyword.

P3dHash
Hash

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

bool
IsDummy

If you want to paint a texture but don't want it to be applied to the specified material texture slot, then enable this.

string
Output

When you export this texture as a PNG asset from the in-editor painting window, the exported texture's GUID will be stored here so you can easily re-export it to the same file.

event System.Action<P3dCommand>
OnAddCommand

This event is called after a paint command has been added to this texture. These commands will be executed at the end of the frame.

static event System.Action<P3dPaintableTexture, P3dCommand>
OnAddCommandGlobal

This event is called after a paint command has been added to this texture. These commands will be executed at the end of the frame.

static System.Action<P3dPaintableTexture>
OnInstanceAdded

This is invoked every time a paintable texture component is enabled.

static System.Action<P3dPaintableTexture>
OnInstanceRemoved

This is invoked every time a paintable texture component is disabled.

event System.Action<bool>
OnModified

This event is called after this texture has been painted, allowing you to perform actions like counting the pixels after modification.

Bool = Preview painting.

static LinkedList<P3dPaintableTexture>
Instances

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

bool
Activated

This lets you know if this texture is activated and ready for painting. Activation is controlled by the associated P3dPaintable component.

bool
CanUndo

This lets you know if there is at least one undo state this texture can be undone into.

bool
CanRedo

This lets you know if there is at least one redo state this texture can be redone into.

List<P3dPaintableState>
States

This property returns a list of all stored undo/redo states.

int
StateIndex

This tells you which undo/redo state is currently active inside the States list.

Material
Material

This tells you which material this paintable texture is currently stored in.

P3dPaintable
Paintable

This quickly gives you the P3dPaintable component associated with this paintable texture.

RenderTexture
Current

This gives you the current state of this paintable texture.

RenderTexture
Preview

This gives you the current state of this paintable texture including any preview painting information.

bool
CommandsPending

This lets you know if there are paint commands in this paintable texture's paint stack.

static List<P3dPaintableTexture>
FilterAll
P3dModel model, P3dGroup group

This allows you to get a list of all paintable textures on a P3dModel/P3dPaintable with the specified group.

void
ClearStates

This will clear all undo/redo texture states.

void
StoreState

This will store a texture state so that it can later be undone. This should be called before you perform texture modifications.

void
Undo

This will revert the texture to a previous state, if you have an undo state stored.

void
Redo

This will restore a previously undone texture state, if you've performed an undo.

void
SetColor
string html

This allows you to set the Color based on an HTML style string (#FFF, #FF0055, yellow, red)

void
NotifyOnModified
bool preview

You should call this after painting this paintable texture.

Texture2D
GetReadableCopy
bool convertBack = false

This method returns a Texture2D copy of the current texture state, allowing you to read pixel values, etc.

byte[]
GetPngData
bool convertBack = false

This method returns the current texture state as a PNG byte array.

byte[]
GetTgaData
bool convertBack = false

This method returns the current texture state as a TGA byte array.

void
Clear

This method will clear the current texture state with the current Texture and Color values.

void
Clear
Texture texture, Color tint, bool updateMips = true

This method will clear the current texture state with the specified texture and color.

void
Replace

This method will replace the current texture state with the current Texture and Color values, including size.

void
Replace
Texture texture, Color tint

This method will resize the current texture state based on the specified texture, and then replace its contents with the specified texture and color.

bool
Resize
int width, int height, bool copyContents = true

This method will resize the current texture state with the specified width and height.

void
Save

This method will save the current texture state to PlayerPrefs using the current SaveName.

void
Save
string saveName

This will save the current texture state with the specified save name.

void
Load

This method will replace the current texture state with the data saved at SaveName.

void
Load
string saveName, bool replace = true

This method will replace the current texture state with the data saved at the specified save name.

void
LoadFromData
byte[] data, bool allowResize = true

This method will replace the current texture state with the specified image data (e.g. png).

void
HidePreview

If you last painted using preview painting and you want to hide the preview painting, you can call this method to force the texture to go back to its current state.

static void
HideAllPreviews

This automatically calls HidePreview on all active and enabled paintable textures.

void
ClearSave

This will clear save data with the current SaveName.

static void
ClearSave
string saveName

This will clear save data with the specified save name.

void
UpdateMaterial

If you modified the slot material index, then call this to update the cached material.

void
CopySize

If the current slot has a texture, this allows you to copy the width and height from it.

void
CopyTexture

This copies the texture from the current slot.

void
Activate

This allows you to manually activate this paintable texture.

void
AddCommand
P3dCommand command

This will add a paint command to this texture's paint stack. The paint stack will be executed at the end of the current frame.

void
ExecuteCommands
bool sendNotifications, bool doSort

This allows you to manually execute all commands in the paint stack.

This is useful if you need to modify the state of your object before the end of the frame.

P3dPaintableTexture
PaintableTexture

This is the paintable texture whose pixels we will count.

float
Interval

This allows you to specify the minimum delay between each texture read in seconds.

0 = Instant.

1 = Once a second.

bool
Async

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

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 P3dPaintableTexture to be registered.

void
Unregister

This forces the specified P3dPaintableTexture 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.

P3dChannel
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.

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.

P3dGroup
Group

Only the P3dPaintableTexture 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.

Camera
SourceCamera

The camera whose depth information will be read.

Matrix4x4
SourceMatrix

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

RenderTexture
TargetTexture

The RenderTexture where the depth information will be stored.

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
ReadInStart

Should the scene depth be rendered in Start?

bool
ReadInUpdate

Should the scene depth be rendered every frame in Update?

void
ReadNow

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

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<P3dHash, P3dModel>
HashToModel

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

static Dictionary<P3dModel, P3dHash>
ModelToHash

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

static Dictionary<P3dHash, Texture>
HashToTexture

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

static Dictionary<Texture, P3dHash>
TextureToHash

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

static Dictionary<P3dHash, P3dPaintableTexture>
HashToPaintableTexture

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

static Dictionary<P3dPaintableTexture, P3dHash>
PaintableTextureToHash

This stores an association between a P3dModel instance and the P3dModel 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.

static void
StoreAllStates

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

static void
ClearAllStates

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

static void
UndoAll

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

static void
RedoAll

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

Texture
Texture

The texture that will be hashed.

P3dHash
Hash

The hash code for the texture.

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.

P3dPointConnector
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 P3dHitCollisions 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.

P3dPointConnector
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 P3dHitParticles 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.

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.

P3dPointConnector
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.

LayerMask
GuiLayers

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

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
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.

P3dPointConnector
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.

P3dLineConnector
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
Title

This allows you to name this preset.

None/null = The GameObject name will be used.

bool
AddMaterialCloner

Automatically add the P3dMaterialCloner.

static List<P3dPreset>
CachedPresets

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

bool
Targets
Shader target

This method returns true if this preset is designed for the specified shader.

void
AddTo
P3dPaintable paintable, Shader shader, int index, int stateLimit

This method applies the preset components to the specified paintable.

Mesh
Source

The original mesh.

Mesh
Output

The mesh with fixed seams.

List<Pair>
Meshes

The meshes we will fix the seams of.

P3dCoord
Coord

The UV channel whose seams will be fixed.

float
Threshold

The threshold below which vertex UV coordinates will be snapped.

float
Border

The thickness of the UV borders in the fixed mesh.

static float
DebugScale

If this is above 0 then Debug.Lines will be output during generation.

void
AddMesh
Mesh mesh

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

static void
Generate
Mesh source, Mesh output, P3dCoord coord, float threshold, float border

This static method allows you to fix the seams of the source mesh at runtime.

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.

P3dGroup
Group

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

P3dBlendMode
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.

P3dModifierList
Modifiers

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

void
IncrementOpacity
float delta

This method increments Opacity by the specified value.

P3dGroup
Group

Only the P3dPaintableTexture 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.

P3dModifierList
Modifiers

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

P3dGroup
Group

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

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.

bool
ClearStates

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

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.

List<P3dChangeCounter>
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<P3dChangeCounter>
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<P3dChangeCounter>
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.

List<P3dChannelCounter>
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<P3dChannelCounter>
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<P3dChannelCounter>
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.

List<P3dColorCounter>
Counters

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

None = All active and enabled counters in the scene.

P3dColor
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<P3dColorCounter>
Counters

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

Zero = All active and enabled counters in the scene.

P3dColor
Color

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

bool
Inverse

Inverse the fill?