The Paint Shape Textures

These components have the ColorShape and AlphaShape textures. If you use the default Cut paint mode, then only the AlphaShape will be used, where the opacity/alpha of this texture will be used to cut holes in your destructible objects.

The Paint Setting

These components have the Paint setting, which allows you to control how the stamp shape texture(s) modify any paintable textures.

Cut This blending mode uses only the AlphaShape texture. This will damage sprites by subtracting alpha using alpha from the AlphaShape texture.

Heal This blending mode uses only the AlphaShape texture. This is the inverse of the Cut blending mode, and will add alpha using alpha from the AlphaShape texture.

Subtract This blending mode uses both the ColorShape and AlphaShape textures. This works like the Cut blending mode, but it will also subtract RGB using RGB from the ColorShape texture.

Subtract Inv Color This blending mode uses both the ColorShape and AlphaShape textures. This works like the Subtract blending mode, but it will invert the RGB values from the color tint you specify.

Cut Min RGB This blending mode uses both the ColorShape and AlphaShape textures. This works like the Cut blending mode, but it will also set the RGB to the minimum of the current RGB vs the RGB from the ColorShape texture. This allows you to darken your texture with the specified ColorShape, but not make things too dark.

Alpha Blend RGB This blending mode uses both the ColorShape and AlphaShape textures. This works like the Cut blending mode, but it will also alpha blend the RGB using RGB from the ColorShape texture. This allows you to paint the underlying destructible object with a new color.

Spawn On Impact

The most flexible approach is to add the D2dImpactSpawner component to your Rigidbody2D GameObject (e.g. on a flying rock).

Whenever the current object hits something, it will check the impact force. If this force exceeds the Threshold value, then the specified Prefab will be spawned at the hit point.

If you'd like to play a sound upon hit, then this prefab can have the AudioSource component.

If you'd like to emit particles upon hit, then this prefab can have the ParticleSystem component.

If you'd like to apply damage to the hit (and nearby) destructible objects, then this prefab can have the D2dExplosion component.

Damage On Impact

Destructible 2D comes with a damage system that can store how much impact force and explosion damage the current object has received.

This can be done by adding the D2dImpactDamage component to your object (e.g. a wall), which will automatically add the D2dDamage component as well.

Whenever the current object gets hit by something (e.g. a flying rock), it will check the impact force. If this force exceeds the Threshold value, then the specified D2dDamage component's Damage value will be increased.

Fracture On Impact

If you'd like your object to fracture into smaller pieces when it receives enough damage, then you can:

Your object will now automatically fracture when it gets hit enough.

Fissure On Impact

If you'd like your destructible object to develop a chip/cut/fissure when it gets hit by something, you can add the D2dImpactFissure component to it.

This component is ideal for certain kinds of objects/materials. For example, if you have a thin glass sheet and need it to fracture/crack at the exact point of impact, then you can use the fissure feature to cut the object at the hit point. This also allows you to filter by layer, so you can have different kinds of damage type for different kinds of objects.

Manual Event On Damage

If you want to trigger a custom event when your object receives a specific amount of damage, then you can add the D2dRequirements component to it.

If you enable its Damage setting, then you can specify the minimum and maximum damage required for the OnRequirementsMet event to get invoked. This event can then used to do anything you like. For example, in many example scenes this is used to enable the D2dDestroyer component, which can destroy the current GameObject after it's received too much damage.

Sprite Swap On Damage

The D2dDamage component has the States setting. If you add some states, then this allows you define which visual sprite will be used for your destructible object based on a specified damage range. This can be used to make the class sprite swap damage effect.

Editing The SpriteShape Spline

If you want to edit the spline of your SpriteShape, I recommend you click the D2dDestructibleRenderer component's "Revert Materials" button first. This will hide the current destruction state, which would otherwise make it difficult to see the new shape of your object.

Once you're happy with your new spline, you can click the "Rebuild" button. If you need to put the materials back, then click the "Revert Materials" button again.

Step 1 - Update your shader properties

In your shader's Property { ... } block, you need to add the following properties:

[PerRendererData] _D2dAlpha("D2D Alpha", 2D) = "white" {}
[PerRendererData] _D2dScale("D2D Scale", Vector) = (1,1,0,0)
[PerRendererData] _D2dOffset("D2D Offset", Vector) = (0,0,0,0)
[PerRendererData] _D2dSharpness("D2D Sharpness", Float) = 1.0
[Header(DESTRUCTIBLE 2D)]
[KeywordEnum(Original, Destructible, Combined)] _D2dOutputRgb("	Output RGB", Float) = 0
[KeywordEnum(Destructible, Combined)] _D2dOutputAlpha("	Output Alpha", Float) = 0
[Toggle(_D2D_OUTLINE)] _D2dOutline("	Outline", Float) = 0
_D2dOutlineColor("	Outline Color", Color) = (0,0,0,1)
_D2dOutlineMin("	Outline Min", Float) = 0.0
_D2dOutlineMax("	Outline Max", Float) = 1.0
_D2dOutlinePower("	Outline Power", Float) = 10.0

Step 2 - Update your variable declarations

In your shader's variable section (e.g. where you should have sampler2D _MainTex; or similar), add the following variables:

#pragma shader_feature_local _D2DOUTPUTRGB_ORIGINAL _D2DOUTPUTRGB_DESTRUCTIBLE _D2DOUTPUTRGB_COMBINED
#pragma shader_feature_local _D2DOUTPUTALPHA_DESTRUCTIBLE _D2DOUTPUTALPHA_COMBINED
#pragma shader_feature_local _ _D2D_OUTLINE
#include "Destructible2D.cginc"

Step 3 - Update your fragment or surface function

Inside your fragment function, e.g. fixed4 frag(v2f IN) : SV_Target { ... }

Or inside surface function, e.g. void surf (Input IN, inout SurfaceOutput o) { ... }

You need to modify your final color & alpha like this:

D2dModifyColorAndAlpha(finalColor.rgb, finalColor.a, IN.localPos);

or like this:

D2dModifyColorAndAlpha(o.Albedo, o.Alpha, IN.localPos);

Destructible Sprite

This shows you how the D2dDestructibleSprite component can be used to turn your normal SpriteRendThis shows you how to make a sprite destructible and damage it. First add the D2dDestructibleSprite component alongside your sprite's SpriteRenderer, then click the Rebuild and Change Material buttons. You can then add the D2dTapToStamp component to your scene, and specify a stamp Shape texture (this uses the alpha channel).rer into a destructible one. The D2dTapToStamp component is then used to stamp holes in the sprite using mouse clicks.

Optimize Sprite

This shows you how the width & height of your destruction data can be halved, giving you a 4x performance boost. This is done by clicking the Optimize button on your D2dDestructibleSprite component. While you can optimize multiple times, keep in mind it reduces the visual quality of the destruction each time. If you optimize too much, then click Rebuild to start again. To maximize performance I recommend you optimize as many times as possible until you reach the best balance between visual quality and performance.

Edge Collider

This shows you how the D2dEdgeCollider component can be added to your D2dDestructibleSprite, giving it an edge collider that automatically updates when you damage the sprite. Keep in mind Edge colliders should only be used for non-moving objects.

Polygon Collider

This shows you how the D2dPolygonCollider component can be added to your D2dDestructibleSprite, giving it a polygon collider that automatically updates when you damage the sprite. Keep in mind polygon colliders should be used for moving objects (e.g. ones with Rigidbody2D).

Splitter

This shows you how the D2dSplitter component can be added to your D2dDestructibleSprite, allowing it to split in half when you cut across the sprite with damage.

Slice

This shows you how the D2dDragToSlice component can be used to slice across destructible sprites.

Transparency

This shows you how the VisualSprite and AlphaSprite settings of the D2dDestructibleSprite component can be different, allowing you to have solid objects that are transparent. Keep in mind this effect requires you to use the Keep Alpha sprite material.

Explosion

This shows you how the D2dTapToSpawn component can be used to spawn a prefab with the D2dExplosion component. The D2dExplosion component allows you to stamp destructible sprites, add physics force to them, and increment their numerical damage value (SgtSprite.Damage).

Impact Fissure

This shows you how the D2dDragToThrow component can be used to spawn a Rigidbody2D prefab with velocity based on the drag vector. This also shows you how the D2dCollisionHandler and D2dImpactFissure components can be used to split the glass at the impact point.

Fixture

This shows you how the D2dFixture component can be added to a child GameObject of your D2dDestructibleSprite. Fixtures can only be attached to one D2dDestructibleSprite, and will automatically follow the one they are on top of when splitting. If the pixel underneath the fixture is destroyed, then the fixture will automatically destroy itself.

Break Off

This shows you how the D2dFixtureGroup component can be connected to a fixture. When all fixtures are detached from the curent D2dDestructibleSprite, the D2dFixtureGroup.OnAllDetached event will be called. This event is set to disable the Rigidbody2D.isKinematic setting, which causes the split sprite parts to break off.

Impact Spawner

This shows you how the D2dDragToThrow component can be used to throw a bomb prefab. The bomb prefab uses the D2dCollisionHandler and D2dImpactSpawner components, which are used to spawn an explosion prefab when the bomb hits another object. The D2dImpactSpawner.OnImpact event is also used to enable the D2dDestroyer component, causing the bomb to get destroyed on impact.

Damage

This shows you how the D2dDamage component can receive damage from rock impacts using the D2dImpactDamage component. The D2dDamage.States list can then be used to swap the SpriteRenderer.sprite setting based on the amount of damage taken.

Tap Fracture

This shows you how the D2dTapToFracture component can be used to fracture destructible objects under the mouse. If you disable the D2dClickToFracture.RequireFracturer setting, then any destructible object in the scene can be destroyed, even if it doesn't have a D2dFracturer.

Lightbulb

This shows you how the D2dFixtureGroup component can be used on the light source to check to see if a sibling power source D2dFixture is connected to the same destructible sprite. If not, D2dFixtureGroup.OnAllDetached is used to enable D2dDestroyer to turn the light off.

Swap

This shows you how the D2dRequirements component can be used to trigger the D2dSwap component when the D2dDestructibleSprite.AlphaRatio goes between 0.0 and 0.9, or when you do more than 10% damage.

Layers

This shows you how after doing 60% damage to a D2dDestructibleSprite the D2dRequirements component can be used to disable the D2dDestructible.Indestructible setting, allowing you to destroy the layer beneath.

Pierce

This shows you how to apply damage to one layer at a time, but you can damage the layer underneath if the pixel you hit above it has been destroyed. This is done by changing the D2dTapToStamp.Hit setting to First.

Cracking Eggs

This shows you how to combine D2dDamage sprite swapping with D2dFracturer splitting after you damage the eggs enough.

Heal

This shows you how to heal a damaged sprite. First you must add the D2dSnapshot component to your scene, and drag and drop your destructible object into its Save setting. Once saved, you can drag and drop this component into the D2dDestructible component's HealSnapshot setting. You can now heal this destructible object by stamping it with the Paint = Heal setting.

Heal Cuts

This shows you how the D2dHealCuts component can be used to automatically heal the current destructible sprite over time.

Camera Shake

This shows you how the D2dCameraShake component can be added to the child GameObject of your camera. The D2dTapToSpawn component is then used to spawn an explosion prefab. This explosion prefab uses the D2dShake component, which adds shake when it spawns.

Follow

This shows you how the D2dFollow component can be used, allowing it to move the camera to follow the egg. Keep n mind D2dFollow cannot be on the same GameObject as D2dCameraShake.

Melt

This shows you how the D2dClickToSpawn component can be used to spawn the Angry Sun prefab. This prefab uses the D2dRepeatStamp component, which constantly stamps the current GameObject position, allowing you to create a melting effect.

Animation

This shows you how you can animate a destructible sprite using the SpriteRenderer.sprite setting like normal. To make it compatible with D2dDestructibleSprite, you must use the Keep Alpha material, and your D2dDestructibleSprite.AlphaSprite must be a combination of the alpha of all of your animation frames. Keep in mind that while modifying your sprite animation you should keep your D2dDestructibleSprite component disabled.

Static Joint

This shows you how to bind a static Rigidbody2D to a destructible object with a HingleJoint2D. This is done using the standard HingeJoint2D setup, but the D2dFixtureJoint component is also added, and a D2dFixture is added on the destructible object to define the point that the joint attaches to. This component automatically updates the HingeJoint2D component's ConnectedRigidBody setting based on the body the specified fixture belongs to.

Fixed Joint

This shows you how to bind two destructible objects together using a single FixedJoint2D. This is done using the D2dFixtureJoint component with two fixtures to define the start and end points associated with the joint. This component will then manage the joint, even if you split either of the destructible objects.

Intermediary Joint

This shows you how to bind two destructible objects together using a non-destructible intermediary object. This is done using two FixedJoint2D and D2dFixtureJoint components associated with each destructible object.

Scorch Marks

This shows you how the Channels setting can be used to paint more than just the alpha/opacity of your destructible sprites. Keep in mind using more channels requires you to use the Default + Color material. Keep in mind Full RGBA should only be used if your D2dDestructibleSprite.Shape is set to a custom sprite. Using a normal color sprite will darken your image.

Filesize Optimization

This shows you how pressing the Clear button on the D2dDestructibleSprite component clears all destructible data, allowing you to save the scene with a very small filesize, which makes your final game builds very small. You can then use the D2dDestructibleSprite.RebuildInGame setting to cause it to be rebuilt in game, and the D2dDestructibleSprite.RebuildOptimizeCount setting to automatically optimize it.

Read Alpha

This shows you how the D2dTapToRead component allows you to read the current destructible sprite color under the current mouse position. This can also be done from C# using the D2dDestructible.TrySampleAlphaAll method.

Pixelated

This shows you how the D2dDestructibleSprite.Pixels setting can be used to give your destructible sprites a pixelated look. The Pixelated Binary setting forces any damaged pixels to either be fully solid, or fully destroyed. Keep in mind you must select the Threshold setting from your D2dDestructibleSprite component's context menu to convert the pixels to binary.

Trigger Overlap

This shows you how the D2dOverlapDamage component can be used with a Trigger collider to detect when a Rigidbody overlaps it. This can increment the D2dDamage.Damage value, and also trigger an action like D2dSpawner.Spawn from the D2dOverlapDamage.OnOverlap event.

Impact Explosion

This shows you how the D2dImpactSpawner component can be used to detect when the current Rigidbody2D hits something. The D2dImpactSpawner.Prefab setting can be used to spawn an explosion on impact, and the OnImpact event can be used to enable the D2dDestroyer component, which automatically destroys the current GameObject.

Cut Opacity

This shows you how the D2dDragToSlice.Color opacity can be lowered, requiring multiple slices to cut through objects. Keep in mind that if you're using optimized sprites, then you should set the D2dDestructibleSprite.OverrideSharpness setting to 1, so you can see the partial damage more clearly.

Paint Multiplier

This shows you how the D2dDestructibleSprite.PaintMultiplier setting can be used to make objects harder or easier to damage.

Slicing Beam

This shows you how the D2dSlicer component can be used to create a laser beam that constantly tries to cut through any object in the way. Select the Handle/Laser GameObject see where the beam starts and ends in the Scene view.

Dynamic Texture

This shows you how the D2dDestructibleSprite.OverrideTexture setting can be used to create a destructible sprite that has a dynamic texture. This is done using a Render Texture asset, and a scene camera to render to it. Keep in mind this requires your layers and camera mask to isolate each rendering scene.

Solid Range

This shows you how the D2dDestructibleSprite component's SolidRange setting can be used to create pixels that are harder or impossible to destroy. When this is set, pixels with an alpha of 255 will be impossible to destroy, and pixels within the range will be increasingly easier to destroy. The optional SolidMask setting can be used to easily define which pixels fall within this range. Keep in mind that you must click Rebuild for the mask changes to update.

Damage Threshold

This shows you how the D2dImpactDamage.Threshold setting can be used to make it harder or easier to damage an object. The D2dFracturer component is then used to fracture the object when it receives enough damage by enabling its Damage setting.

Monitor Pixels

This shows you how to spawn particles each time you destroy a pixel in the current sprite. This is done by enabling the D2dDestructibleSprite component's MonitorPixels setting, and adding the D2dModifiedPixelParticle component. This component detects when a pixel is destroyed, and spawns a new particle there.

Procedural Setup

This shows you how to create a destructible sprite entirely from code. Check out the D2dProceduralSetup.cs code to see how it works.

Painting RGB

This shows you how to cut holes and paint the RGB with alpha blending. First, make sure your D2dDestructibleSprite component's Channels setting is set to FullRGB so that the underlying sprite RGB values get stored in the destructible data. Next, make sure the destructible object is using a + Destructible RGB material, which ensures the Output RGB uses only the Destructible RGB data, and ignores the original sprite RGB. You can now stamp/damage your objects using the Paint = Alpha Blend RGB setting, with a ColorShape set to a normal sprite, and the AlphaShape set to the hole shape. Keep in mind that when using this technique, optimizing your sprites will result in reduced RGB quality.

Asteroid Blaster

This shows you how to combine various features to make a spaceship you can fly around in zero gravity. This spaceship has guns that fire in an alternating pattern whose bullets expode when impacting the asteroids. The asteroids are given red scorch marks and given enough damage they can split into smaller pieces.

Asteroid Laser

This shows you how to combine various features to make a spaceship you can fly around in zero gravity. This spaceship has guns that fire in an alternating pattern whose bullets expode when impacting the asteroids. The asteroids are given red scorch marks and given enough damage they can split into smaller pieces.

Crash Damage

This shows you how to make a top down car with simple controls. When the car hits an object an explosion is spawned, and this explosion can damage the shape of the car, which changes the way it handles.

Exploder

This shows you how the D2dTapToFracture component's Prefab setting can be combined with explosions and particle effects to look more interesting.

Glass Panels

This shows you how to make a scene with many glass panels that can be smashed using finger drags.

Jumping Spaceship

This shows you how to make a spaceship you can control, and instead of shooting, it causes the spaceship to jump forward a distance. When a jump is performed, all destructible objects between the previous and current position are sliced in half.

Scorch

This shows you how to make a forest scene with finger slicing that also add black scorch marks to the trees.

Shooting Gallery

This shows you how to make a shooting gallery where you can damage the targets when they're facing the camera.

Snake

This shows you how to make a snake that can dig in all directions and still have normal physics including gravity. This is done by adjusting the Rigidbody2D drag and acceleration based on the solid surfaces surrounding the snake head.

Swinging Weight

This shows you how to make a swinging weight that you can slice up. This uses a combination of HingeJoint2D and D2dFixtureJoint components.

Trees

This shows you how to make a forest scene and slice to cut the trees down or stop the bees from animating.

static void
Clear

Call this before using any of the returned arrays.

static T[]
ToArray
List<T> list

This will return a cached array copy of the specified list, and can be called multiple times with the same list length.

float
MassPerSolidPixel

The amount of mass added to the Rigidbody2D by each solid pixel in the attached D2dDestructible.

bool
FactorInSharpness

Automatically multiply the mass by the D2dDestructible.AlphaSharpness value to account for optimizations?

float
Density

This allows you to control the density setting on each generated collider.

PhysicsMaterial2D
Material

This allows you to set the material setting on each generated collider.

bool
IsTrigger

This allows you to set the isTrigger setting on each generated collider.

bool
UsedByEffector

This allows you to set the usedByEffector setting on each generated collider.

bool
UsedByComposite

This allows you to set the usedByComposite setting on each generated collider.

void
SetDensity
float value

This allows you to set the Density value without causing Refresh to be called.

void
SetMaterial
PhysicsMaterial2D value

This allows you to set the Material value without causing Refresh to be called.

void
SetIsTrigger
bool value

This allows you to set the IsTrigger value without causing Refresh to be called.

void
SetUsedByEffector
bool value

This allows you to set the UsedByEffector value without causing Refresh to be called.

void
SetUsedByComposite
bool value

This allows you to set the UsedByComposite value without causing Refresh to be called.

event System.Action<Collision2D>
OnCollision

This is invoked once for each collision.

event System.Action<Collider2D>
OnOverlap

This is invoked once for each collision.

event System.Action
OnDamageChanged

This is invoked when the damage field is modified.

float
Damage

This tells you how much numerical damage this sprite has taken. This is automatically increased by nearby explosions and such.

float
Threshold

The incoming damage must be at least this value to change this component's damage value.

float
Multiplier

This allows you to reduce or increase the rate at which damage changes.

List<State>
States

This allows you to modify the damage value directly without invoking NotifyDamageChanged/OnDamageChanged.

void
Add
float value

This method allows you to add to the damage value.

void
InvokeDamageChanged

Call this if you manually modified the damage value.

float
Life

This will decrease by 1 every second, and the current GameObject will be destroyed when it reaches 0.

GameObject
Target

If you want a different GameObject to be destroyed then specify it here.

bool
Fade

If you enable this then the attached SpriteRenderer.color will be faded out before destruction.

float
FadeDuration

The amount of seconds the fade out effect spans.

bool
Shrink

If you enable this then the Transform.localScale value will shrink to 0 before destruction.

float
ShrinkDuration

The amount of seconds the shrink effect spans.

Rigidbody2D
ShrinkPivot

If this object has a Rigidbody then you may want the shrink to work relative to the physics pivot point.

bool
RandomizeOnEnable

Should these settings get randomized when this component is enabled?

float
LifeMin

The minimum randomized Life value.

float
LifeMax

The minimum randomized Life value.

event System.Action
OnRebuilt

This is invoked when the whole destruction state changes.

event System.Action<D2dRect>
OnModified

This is invoked when a subset of the destruction state changes.

event System.Action
OnSplitStart

This is invoked before the destructible is about to be split into separate parts.

event System.Action<List<D2dDestructible>, SplitMode>
OnSplitEnd

This is invoked after the destructible is split into separate parts, with a list of all the parts.

Last Element = This Destructible.

event System.Action<List<int>>
OnModifiedPixels

This event is invoked after the destructible is modified, and contains indices of all pixels that crossed the 128 opacity boundary.

static event System.Action<D2dDestructible, List<int>>
OnGlobalModifiedPixels

This event works like OnModifiedPixels, but is statically invoked with a reference to the D2dDestructible whose pixels were modified.

D2dSnapshot
HealSnapshot

If you want to be able to heal this destructible sprite, then set a snapshot of the healed state here.

float
OverrideSharpness

This allows you to manually control the sharpness of the alpha gradient (0 = AlphaSharpness) (+ = OverrideSharpness) (- = AlphaSharpness * -OverrideSharpness).

float
PaintMultiplier

This allows you to control how easily this object can be painted.

1.0 = Default.

2.0 = Twice as much damage.

0.5 = Half as much damage.

int
SolidRange

This allows you to make it so some pixels are harder to destroy than others, based on their alpha value (0 .. 255).

0 = Every pixel is equally easy to destroy.

1 = Values between 0 and 254 receive normal damage, but 255 receives no damage.

10 = Values between 0 and 245 receive normal damage, but 246 receives 90% damage, 247 receives 80%, etc.

PixelsType
Pixels

This allows you to control how the alphaTex pixels are handled.

bool
Indestructible

This keeps your destructible sprite active, but prevents it from taking visual damage.

bool
MonitorPixels

If you enable this then all destroyed or healed pixel will be sent to the OnModifiedPixels event, which contains a list of the AlphaData array indices of the pixels.

bool
Ready

If this destructible has been generated correctly, this will be set.

Color32[]
AlphaData

This stores the current visual damage state of the destructible.

int
AlphaWidth

This stores the current width of the visual damage data.

int
AlphaHeight

This stores the current height of the visual damage data.

int
AlphaCount

This tells you how many pixels in the alphaData/alphaTex are solid (above 127).

int
AlphaCountRaw

This allows you to read the alphaCount value directly without causing it to be recalculated.

int
OriginalAlphaCount

This tells you the original AlphaCount value, if it was set.

int
OriginalAlphaCountRaw

This allows you to read the originalAlphaCount value directly without causing it to be recalculated.

float
AlphaRatio

This will return the ratio of remaining alpha (0 = no pixels remain, 1 = all pixels remain).

Vector2
AlphaOffset

This tells you offset of the alpha data in local space.

Vector2
AlphaScale

This tells you scale of the alpha data in local space.

float
AlphaSharpness

Each time you optimize/halve this sprite, this value will double.

Texture2D
AlphaTex

This stores the current texture of the visual destruction state.

D2dRect
AlphaModified

This stores the pixel region of the alphaData that hasn't been copied to the texture yet. These pixels will be copied in LateUpdate.

bool
CanHeal

This returns true if the healSnapshot is in a valid state for healing this destructible sprite.

TextureFormat
FinalFormat

This tells you the format the alphaTex should have based on your settings.

Matrix4x4
LocalToAlphaMatrix

This matrix allows you to transform a point from local space to alpha space.

Matrix4x4
WorldToAlphaMatrix

This matrix allows you to transform a point from world space to alpha space.

Matrix4x4
AlphaToLocalMatrix

This matrix allows you to transform a point from alpha space to local space.

Matrix4x4
PixelToLocalMatrix

This matrix allows you to transform a point from pixel space to local space.

Matrix4x4
PixelToWorldMatrix

This matrix allows you to transform a point from pixel space to world space.

void
Trim

This allows you to cut and smooth the edges of your destructible. This is automatically done in many cases, but when making a new destructible it isn't, so you can control how the edges look yourself.

void
Blur

This allows you to blur the pixels in your current destruction state. This can be used for certain effects, or to smooth the edges.

void
Threshold

This allows you to threshold all the pixels in your current destruction state. This will set them to full opacity if they are above half opacity, otherwise they will be set to zero opacity.

void
Halve

This allows you to halve the width & height of your destruction pixels.

void
Optimize

This allows you to reduce the amount of pixels used to store the destruction state of your sprite. Each time you do this you will increase performance 4x, but there will be some visual quality loss.

void
Clear

This allows you to clear all destruction data from the sprite, reverting it to a normal non-destructible sprite. NOTE: You will need to manually revert the material to completely revert the sprite state.

void
NotifyRebuilt

Call this if you manually modified the whole destruction state.

Color32
SampleAlphaLocal
Vector3 localPosition

This method allows you to sample the AlphaData at the specified local space position.

Color32
SampleAlphaWorld
Vector3 worldPosition

This method allows you to sample the AlphaData at the specified world space position.

Color32
SampleAlpha
Vector2 uv

This method allows you to sample the AlphaData at the specified UV.

static bool
TrySampleThrough
Vector3 worldPosition, ref D2dDestructible hitDestructible, byte threshold = 127

This method allows you to find the destructible object below the specified world space position as long as the sampled alpha value is above the threshold value.

This allows you to go through holes in objects that are on top.

bool
IsAbove
D2dDestructible other

This method allows you to see if the current destructible object is being drawn above the specified object.

static Color32
TrySampleAlphaAll
Vector3 worldPosition

This method allows you to sample the AlphaData of the top most object at the specified world space position.

static bool
TrySampleAlphaAll
Vector3 worldPosition, ref D2dDestructible hitDestructible, ref Color32 hitAlpha

This method allows you to sample the AlphaData of the top most object at the specified world space position and also find out which destructible object it came from.

List<Material>
OriginalMaterials

To rebuild this destructible object its original (non-destructible) material is used.

ChannelType
Channels

This allows you to set which color channels you want the destructible texture to use.

ChannelType
ChannelsRaw

This allows you to set channels without triggering a rebuild.

int
RebuildLayer

When this destructible object is rebuilt, it will be rendered using a temporary camera with everything set to this layer.

bool
RebuildInGame

To save scene file size you can Clear your destructible, and allow it to Rebuilt on Start.

int
RebuildOptimizeCount

This allows you to set how many times the rebuilt alpha data will be optimized when rebuilt on Start.

int
PixelsPerUnit

This allows you to set how many destructible pixels are generated per unit in local space. For example, if your object is 10 units in width + height, and this value is set to 3, then this destructible object will have a resolution of 30x30 pixels.

Renderer
CachedRenderer

This gives you the attached Renderer.

bool
InvalidMaterial

This tells you if the attached Renderer's sharedMaterial uses the default Unity sprite material, which isn't compatible with destructible objects.

void
ChangeMaterial

If you're using the normal Unity sprite material, then this swaps it to the Destructible 2D supported equivalent.

void
Rebuild

This allows you to rebuild the destruction state using the current sprite settings.

void
RevertMaterials

This method allows you to revert the associated renderer's materials to the original values before you made it destructible.

void
Rebuild
int optimizeCount

This allows you to rebuild the destruction state using the specified sprites.

Sprite
Shape

This allows you to set the shape of the destructible sprite.\nNOTE: This should match the settings of your visual sprite.

Texture
OverrideTexture

This allows you to override the sprite texture with any Texture.

Sprite
SolidRangeMask

This mask can be used to more easily control which pixel alpha values fall into the SolidRange.

0 Alpha = This pixel will receive normal damage.

255 Alpha = This pixel will receive no damage.

ChannelType
Channels

This allows you to set which color channels you want the destructible texture to use.

ChannelType
ChannelsRaw

This allows you to set channels without triggering a rebuild.

bool
CropSprite

Enable this if you want the attached SpriteRenderer.sprite to automatically crop to the AlphaTex boundary, reducing the fill rate requirements for large splitting sprites.

bool
RebuildInGame

To save scene file size you can Clear your destructible, and allow it to Rebuilt on Start.

int
RebuildOptimizeCount

This allows you to set how many times the rebuilt alpha data will be optimized when rebuilt on Start.

SpriteRenderer
CachedSpriteRenderer

This gives you the attached SpriteRenderer.

bool
InvalidMaterial

This tells you if the attached SpriteRenderer's sharedMaterial uses the default Unity sprite material, which isn't compatible with destructible objects.

void
ChangeMaterial

If you're using the normal Unity sprite material, then this swaps it to the Destructible 2D supported equivalent.

void
Rebuild

This allows you to rebuild the destruction state using the current sprite settings.

void
Rebuild
int optimizeCount

This allows you to rebuild the destruction state using the specified sprites.

float
EdgeRadius

This allows you to set the edgeRadius setting on each generated collider.

CellSizes
CellSize

This allows you to change the pixel width & height of each collider cell to improve performance. The pixel size you choose should be in relation to the typical size of destruction in your scene.

float
Optimize

This allows you to control how easily the edges can merge together. A higher value gives better performance, but less accurate colliders.

void
SetEdgeRadius
float value

This allows you to set the EdgeRadius value without causing Refresh to be called.

void
SetCellSize
CellSizes value

This allows you to set the CellSize value without causing Rebuild to be called.

void
SetOptimize
float value

This allows you to set the Optimize value without causing Rebuild to be called.

Vector3
Offset

This allows you to set the local offset of the fixture point.

bool
AutoDestroy

Automatically destroy this component if all fixtures are removed?

List<D2dFixture>
Fixtures

This allows you to set the fixtures that will be tracked by this group.

UnityEvent
OnAllDetached

This event will be invoked when all entries in the Fixtures list are destroyed.

Joint2D
Joint

This is the joint whose ConnectedBody will be updated based on the ConnectedFixture, and will be destroyed when either of the fixtures detaches.

D2dFixture
Fixture

This is the fixture associated with the joint.

D2dFixture
ConnectedFixture

This is the fixture associated with the object the current joint attaches to.

bool
AutoDestroyJoint

Automatically destroy this joint if detached?

bool
AutoDestroyThis

Automatically destroy this component if detached?

void
UpdateFixtures

This method can be used to immediately update this component.

bool
Damage

If you enable this then this destructible sprite will automatically be fractured when the attached D2dDamage.Damage value is high enough.

float
DamageRequired

The D2dDamage.Damage value must be at or above this value.

float
DamageMultiplier

After a successful fracture, the damageRequired value will be multiplied by this, allowing for multiple fractures.

float
PointsPerSolidPixel

This lets you set how many fracture points there can be based on the amount of solid pixels.

int
MaxPoints

This lets you limit how many points the fracture can use.

bool
FactorInSharpness

Automatically multiply the points by the D2dDestructible.AlphaSharpness value to account for optimizations?

bool
SplitAfterFracture

Fracturing can cause pixel islands to appear, should a split be triggered on each fractured part to check for these?

int
SplitFeather

This allows you to set the Feather value used when splitting.

int
SplitHealThreshold

This allows you to set the HealThreshold value used when splitting.

static bool
TryFracture
D2dDestructible destructible, int pointCount, bool splitAfterFracture, int splitFeather, int splitHealThreshold

This method allows you to manually try and fracture the specified D2dDestructible.

LayerMask
Mask

The collision layers you want to listen to.

float
Threshold

The impact force required.

float
Scale

This allows you to control the amount of damage inflicted relative to the force of the impact.

float
Delay

This allows you to control the minimum amount of time between fissure creation in seconds.

UnityEvent
OnImpact

This gets called when the prefab was spawned.

LayerMask
Mask

The collision layers you want to listen to.

float
Threshold

The impact force required.

float
Delay

This allows you to control the minimum amount of time between fissure creation in seconds.

GameObject
Prefab

If you want a prefab to spawn at the impact point, set it here.

D2dDestructible.PaintType
Paint

The paint type.

D2dShape
StampShape

The shape of the stamp.

Texture2D
ColorShape

The shape of the stamp when it modifies destructible RGB data.

Texture2D
AlphaShape

The shape of the stamp when it modifies destructible alpha data.

Color
Color

The stamp shape will be multiplied by this. Solid White = No Change

float
Thickness

This allows you to control the width of the fissure.

float
Depth

This allows you to control how deep into the impact point the fissure will go.

float
Offset

This allows you to move the start point of the fissure back a bit.

bool
UseSurfaceNormal

Use the surface normal instead of the impact velocity normal?

UnityEvent
OnImpact

This gets called when the prefab was spawned.

LayerMask
Mask

The collision layers you want to listen to.

float
Threshold

The impact force required.

float
Delay

This allows you to control the minimum amount of time between fissure creation in seconds.

GameObject
Prefab

If you want a prefab to spawn at the impact point, set it here.

float
Offset

This allows you to move the start point of the fissure back a bit.

RotationType
RotateTo

How should the spawned prefab be rotated?

UnityEvent
OnImpact

This gets called when the prefab was spawned.

LayerMask
Mask

The collision layers you want to listen to.

float
DamagePerSecond

This allows you to control the amount of damage inflicted per second of overlap.

float
Delay

This allows you to control the minimum amount of time between damage in seconds.

UnityEvent
OnOverlap

This gets called when the prefab was spawned.

CellSizes
CellSize

This allows you to change the pixel width & height of each collider cell to improve performance. The pixel size you choose should be in relation to the typical size of destruction in your scene.

float
Straighten

This allows you to control how easily the edges can merge together. A higher value gives better performance, but less accurate colliders.

void
SetCellSize
CellSizes value

This allows you to set the CellSize value without causing Rebuild to be called.

void
SetStraighten
float value

This allows you to set the Straighten value without causing Rebuild to be called.

bool
Met

Has the specified Criteria been met?

bool
Damage

If you enable this then the D2dDamage.Damage value will be checked.

float
DamageMin

The D2dDamage.Damage value must be at or above this value.

float
DamageMax

The D2dDamage.Damage value must be below this value.

bool
AlphaCount

If you enable this then the D2dDestructible.AlphaCount value will be checked.

float
AlphaCountMin

The D2dDestructible.AlphaCount value must be at or above this value.

float
AlphaCountMax

The D2dDestructible.AlphaCount value must be below this value.

bool
AlphaRatio

If you enable this then the D2dDestructible.AlphaRatio value will be checked.

float
AlphaRatioMin

The D2dDestructible.AlphaRatio value must be at or above this value.

float
AlphaRatioMax

The D2dDestructible.AlphaRatio value must be below this value.

UnityEvent
OnRequirementsMet

When all requirements have been met, this method will be invoked.

void
UpdateMet

This will immediately update the requirements.

static Matrix4x4
CalculateMatrix
Vector2 startPos, Vector2 endPos, float thickness

This will return the transformation matrix used to convert between world space and slice sprite space.

D2dSnapshotData
Data

This gives you the snapshot data in a normal class.

D2dSnapshotData
DataRaw

This allows you to get the data value without causing it to automatically initialize.

void
Clear

This will clear all snapshot data.

static D2dSnapshotData
Create
D2dDestructible destructible

This will return a snapshot of the specified D2dDestructible.

void
Clear

This will clear all snapshot data.

void
Save
D2dDestructible destructible

This will store the specified D2dDestructible's state to this snapshot.

void
Load
D2dDestructible destructible

This will copy this snapshot to the specified D2dDestructible.

float
Delay

This allows you to control the minimum amount of time between prefab creation in seconds.

float
Interval

This allows you to control the amount of seconds between spawns.

-1 = Spawn once only.

int
Remaining

The amount of extra times this component can spawn.

-1 = Unlimited.

float
Spread

This allows you to control how far the spawned object can randomly rotate from its initial rotation.

Vector2
Forward

This allows you to specify which direction is forward for your sprite when applying the speed.

float
SpeedMin

This allows you to set the minimum random speed applied to the spawned object if it has a Rigidbody2D.

float
SpeedMax

This allows you to set the maximum random speed applied to the spawned object if it has a Rigidbody2D.

GameObject
Prefab

If you want a prefab to spawn at the impact point, set it here.

int
Feather

If your destructible sprite has soft edges then you should increase the feather distance to the pixel thickness of your soft edges.

int
HealThreshold

Split pieces cannot be healed by default, this is because healing split pieces can often lead to unexpected behavior and worse performance. If you really want to allow healing of split pieces, then this setting allows you to control how many pixels must remain in the split piece for it to be eligible for healing.

-1 = Split pieces cannot be healed.

0 = All split pieces can be healed.

10 = Split pieces must have more than 10 AlphaCount to be healed.

static Matrix4x4
CalculateMatrix
Vector2 position, Vector2 size, float angle

This will return the transformation matrix used to convert between world space and stamp sprite space.