Search Unity

  1. Improved Prefab workflow (includes Nested Prefabs!), 2D isometric Tilemap and more! Get the 2018.3 Beta now.
    Dismiss Notice
  2. The Unity Pro & Visual Studio Professional Bundle gives you the tools you need to develop faster & collaborate more efficiently. Learn more.
    Dismiss Notice
  3. Improve your Unity skills with a certified instructor in a private, interactive classroom. Watch the overview now.
    Dismiss Notice
  4. Want to see the most recent patch releases? Take a peek at the patch release page.
    Dismiss Notice

[Released] DestroyIt - Cinematic Destruction System

Discussion in 'Assets and Asset Store' started by DeadlyAccurate, Jun 14, 2014.

  1. DeadlyAccurate

    DeadlyAccurate

    Joined:
    Apr 2, 2013
    Posts:
    148
    ModelShark Studio is happy to announce DestroyIt, a cinematic destruction system for Unity Free and Unity Pro!

    Asset Store Link



    The framework provides throttling tools for performance, material pre-loading and transfer for seamless visuals, a particle manager, and object pooling. A wealth of particle effects, sample destroyed prefabs, and documentation are also there to get you started. DestroyIt was designed to meet the following requirements:

    Highly Scalable
    DestroyIt comes complete with a Destruction Manager, a Particle Manager, Object Pooling, and a Material Preloader for high performance.

    Realistic Destruction
    DestroyIt was designed to use destroyed prefabs that break apart realistically and produce convincing, persistent debris. Flying debris can damage players and enemies, and can also be used for cover, which creates emergent gameplay.

    Emergent Gameplay
    When objects can be destroyed into realistic debris, it adds a facet of emergent gameplay and player choices that goes beyond visual effects. Create walls that can be breached; towers that can topple; and trees that can be chopped down.

    What You Get
    • Full C# source code, no DLLs
    • 29 Particle effects
    • 6 Shaderforge-compatible Progressive damage shaders, with textures
    • Demo that illustrates 22 core features
    • Demo that showcases many features using Unity's free Shanty Town SUV model.
    • All demo scene assets
    No programming knowledge is necessary but is helpful if you want to extend the system.

    Check out the demo!









    If you have urgent questions, please send us an email. The forum doesn't always let us know a post has been made.

    Always back up your project before updating your package.

    Changelog:

    v1.9 (Jun 2018):




      • Updated DestroyIt to Unity 2018.1
      • Replaced wooden chest (Main Scenarios Scene, #14) with a model that uses a single material
      • Fixed explosion effect on explosive barrel (Main Scenarios Scene, #4)
      • Cleaned up meshes in demo scenes (removed n-gons) to correct texture import warnings
      • Removed legacy shader for palm tree (Main Scenarios Scene, #21)
      • Fixed rotating particles on ConcreteDebris particle effect
      • Removed FadeTreeSwaying script since it only worked with legacy nature shader
    v1.8 (Apr 2018):
    • Updated the Nuke weapon particle effect
    • Replaced demo object #4 with a gas barrel model and replaced the explosion with one from the Unity Particle Pack
    • Replaced demo object #10 rock with a new rock
    • Retextured demo objects #12 and #13, cog box, and reduced number of textures used
    • Modified demo objects #17 and #18 targets to use only a single material
    • Adjusted the height and angle of the Nuke trigger GameObject on the First Person Controller
    • Reduced the size of several textures: track blinds, flag, pipe wrench, and rocket launcher sight
    • Modified the Flag prefab GameObject to remove the Hinge Joint due to Unity no longer allowing non-convex colliders to work with non-kinematic rigidbodies

    1.7.1 (Jan 2018)
    • Cleaned up Standard Assets references so there are no assetId conflicts with DestroyIt when importing any Standard Assets package.
    1.7 (Dec 2017)

    Fixes:

    • Updated to Unity 2017.2
    • Fixed muzzle flash particle effect for M4 rifle - now uses custom simulation space to stay attached to rifle muzzle.
    • Removed unused JavaScript Standard Asset scripts.
    • Fixed missing references for rocket launcher on Mass Destruction Demo scene.
    • Fixed object pool warnings on SUV Showcase Demo scene when restarting the scene with the 'R' key.
    1.6 (July 2017)

    Enhancements:

    • Updated DestroyIt to Unity 5.6.2.
    • Added a Mobile-Friendly Blinn-Phong lighting shader that supports progressive damage (see Main Demo Scene: #26).
    • Added an ALL DEBRIS option for the Reparent Debris field on the Destructible script.
    • Added ability to assign a parent for the destroyed prefab on the Destructible script.
    • Added option to turn kinematic off on unparented child rigidbodies (it's still on by default).
    • Added option to override the Fallback Particle position (especially useful for static meshes, see Main Demo Scene: #27)
    • Added option to set kinematic True/False for reparented debris (such as the longsword in Main Demo Scene: #19)
    Minor Enhancements/Optimizations:
    • Minor visual effects tweak (CogBox): Progressive damage is now more obvious, sparks particle effect render queue now based on shader so smoke doesn't hide it.
    • Optimized the demo scenes to work with Gamma lighting (Unity's default). Better visuals for mobile and WebGL builds of the demo scenes.
    • Optimized the demo terrain by reducing it to 512x512 and rebuilding the splatmaps. Greatly reduced build size for demo scenes.
    • Added a "Choose Demo" scene and wired it up to the Main Scenarios Scene and SUV Showcase Scene by use of the Main (M) button.
    • Added a Loading Screen and WebGLWarmUp object to demo scenes which pre-destroys objects in the scene to help WebGL build performance.
    • Removed "Tag Debris As" from all scripts and editors (no longer needed - use HitEffects script instead).
    • Added many tooltips to the Destructible editor script to explain the various options and when you would use them.
    New Scenarios in the Main Demo:
    • Scenario #25: Dynamically adding a destructible object to the scene at runtime.
    • Scenario #26: Mobile shader for DestroyIt that supports progressive damage.
    • Scenario #27: Static meshes and using the fallback particle position override.
    Bug Fixes:
    • Destructible objects set as static were invisible when the scene loaded, because GetMeshCenterPoint was accessing the mesh instead of sharedMesh.
    • Added more null checks to DestructionManager so errors will not be thrown if DestructionManager doesn't exist but there are Destructible objects in the scene.
    • Added [DisallowMultipleComponent] attribute to Destructible, TagIt, and HitEffects scripts to prevent putting more than one of these components on a game object.
    • Fixed all 'obsolete reference' warnings from previous version of Unity.
    • Removed Interpolate rigidbody setting on destroyed prefabs and Time Slow (T) feature because of a known issue with Unity 5.6.
    • Fixed bug related to destructible objects that have destroyed prefabs which are also destructible (now recursively adds destroyed prefabs to the object pool).
    • Demo Scenes: When your HUD ("H") or Reticle ("O") was toggled off and you started the scene, you had to press these keys twice to toggle them on.
    • Added a null reference check to the Material Preloader in case you don't supply a source material when adding a Material Replacement.

    1.5.3 (February 2017)

    New Features:
    • New HitEffects system. You can now specify different particle effects for each weapon/projectile type that hits an object. Also, you no longer need to place TagIt scripts on each collider that needs a different hit effect. You can now place a single HitEffects script on the parent and override individual colliders as needed. See the DestroyIt user guide for more info.
    Minor Changes:
    • Removed many old/unused assets from the package, saving approximately 20MB.
    • Moved SUV Showcase demo scene to its own folder.
    • Added HitEffects to DestroyIt-Ready system, so HitEffects scripts can now be converted to stubs that can be packaged with your own commercial assets.
    Bug Fixes:
    • Corrected several bullet hit particle effects and re-centered the wood splinter mesh's center point.
    1.5.1 (January 2017)
    • Corrected several bullet hit effect particle effects that were rotating on the ground
    • Recentered the wood splinter meshes center point
    1.5 (December 2016)

    We suggest that you delete your existing DestroyIt folder before importing the newer one, but please back up your project first!

    Major Changes:
    • Updated for Unity 5.5.
    • Progressive damage system overhauled to allow more control of damage levels and visible damage.
    • Damage can now be repaired, and any damage level effects will turn off as the object is repaired.
    • For each Destructible object, you can now have from 1 to 10 Damage Levels, and the hit point range can be customized for each.
    • All Destructible objects now start with 5 pre-defined Damage Levels.
    • Destructible objects now automatically detect if they are damaged or destroyed based on current hit points, rather than relying on external ApplyDamage() or ProcessDestruction() calls.
    • Performance increased by reducing Garbage Collection allocation on PlayDamageLevelEffects, HeadsUpDisplay, ReleaseClinging Debris, Bullet Update() method, Object Pool Spawn() method, and by removing the JointCleanup script.
    Minor Changes:
    • Damage masks extended from previously 5 levels of progressive damage to 10.
    • Many tooltips added to Destructible and DestructionManager script fields.
    • DestroyIt-Ready: You can now select a root folder in the Projects pane and click Convert Stubs to Destructible and it will find all prefabs under that folder.
    • DEMO SCENES
      • Removed unnecessary reflection probes and increased resolution of main reflection probe.
      • Bullet streak enhanced for a more visual, "tracer-like" effect.
      • Updated HUD UI to Unity Canvas.
      • ADDED: Performance, Keyboard/Mouse Controls, and Current Weapon sections to in-game HUD UI.
      • ADDED: Repair Wrench animated weapon with particle effect, to show off new Repair Damage feature.
      • DELETED: Some unused standard assets that were throwing warnings.
      • Changed to Linear lighting, tweaked tonemapping and blur camera settings, re-enabled light flares on SUV, changed reflection probes to baked lighting.
      • Removed "Draw Call Batching" scenario. Unity 5 now uses setpass calls and batches, making "draw calls" an inaccurate performance metric.
      • New cannon, repair wrench, and RPG models.
      • New brass pole, wall, longsword, and sconce models.
      • Mouse wheel can now be used to cycle through weapons.
      • Enhanced particle hit effects for metal, cloth, concrete, dirt, glass, and wood.
    • REMOVED: support for progressive damage on materials using legacy Unity 4 shaders.
    • REMOVED: Debug Monitor from Destructible script.
    • REMOVED: ForceCollisions script, it is no longer needed with Unity 5's physics.
    • REMOVED: unused progressive damage mask images.
    • Destructible custom editor script re-categorized, and fields moved to provide clarity.
    • Changed ApplyImpactDamage, ApplyExplosiveDamage, etc to ApplyDamage overload methods.
    • Refactored Damage types so they inherit from a generic Damage interface.
    • ADDED: Repaired event that fires when a Destructible object is repaired.
    • ADDED: Damaged event that fires when a Destructible object is Damaged.
    • ADDED: WhenDestroyedPlaySound.cs helper script for playing sounds when a destructible object is destroyed.
    • ADDED: WhenDamaged.cs helper script for taking action when a destructible object is damaged.
    • ADDED: WhenRepaired.cs helper script for taking action when a destructible object is repaired.

    Bug Fixes:

    • DestroyIt-Ready: Converting stubs/destructibles on Unsaved Scene caused undesired scene save popup.
    • DestroyIt-Ready: Converting a game object and its prefab at the same time caused duplicate scripts to be added.
    • Destructible objects can no longer be damaged into negative hit points.
    • When rotating a Destructible object with Damage Effects, the Damage Effects particles and gizmos did not rotate with the object.

    1.4.2 (April 2016)
    • FIXED: Editor scripts have been updated to use the EditorSceneManager introduced in Unity 5.3. This change was required for editors to save user modifications properly.
    1.4.1 (April 2016)
    • Added: TagItStub script so you can make DestroyIt-Ready assets that use TagIt scripts.
    • Added: New option on Destructible script "Ignore Collisions Under [X] Magnitude", which is useful for things like destructible tires, which should ignore most small-to-medium collisions yet still take full damage from bullets.
    • Fixed: Particle systems will no longer have DamageMaterial scripts added to them at runtime. This was a bug introduced by adding SkinnedMeshRenderer support.
    • Sink Into Ground option on Destructible script is now only available if the Destructible object has a rigidbody.
    • Bullets and the Axe melee weapon will now ignore trigger colliders.
    • The Axe melee weapon will now ignore the CharacterController tagged as "Player". This will prevent the player from hitting himself with the Axe.
    • Object Pool importing and saving improved. You can now import/save object pool files to different locations. When importing a file, it will now update existing objects in the pool instead of replacing all objects. Also added a Clear button to quickly remove all objects from the pool.
    1.4 (March 2016)
    • Added: DestroyIt - Ready. You can now make your own DestroyIt objects for commercial purposes.
    • Added: Skinned Mesh Renderer support for non-organic skinned mesh renderer objects.
    • Fixed: Warnings for deprecated properties and methods from Unity 5.2 and 5.3
    • Fixed: Mouse cursor not immediately visible when running in Unity editor and pressing Esc.
    1.3.5 (February 2016)
    • Fixed the Particle Alpha Blend (No Fog) shader for Unity 5.3, so textures using that shader no longer appear pink.
    1.3.4 (August 2015)
    • Optimization: Destructible objects that also have destructible debris now get initialized properly when auto-pooled so there are no surprise Garbage Collection allocations at runtime.
    • Optimization: Removed Linq queries and string concatenation on HeadsUpDisplay script to minimize Garbage Collection allocation.
    • Optimization: Moved the code that sets the fallback particle material from FixedUpdate() to Initialize(), so it doesn't have to happen at destruction time if autopooling is enabled.
    • Aesthetic Fix: Reflection probes on glass panes (Demo Scenarios #14 and #15) had intensity set too high.
    • Aesthetic Fix: Reflection probe anchor overrides on SUV doors were getting set to the window anchor overrides when destroyed.
    • Code was fixed so destroyed objects must have at least one matching TagIt tag in order to inherit their parent's probe anchor override.
    1.3.3 (June 2015)
    • Corrected the Roughness channel on the Metallic mask on the Destroyed Cog Box
    • Fixed an issue with Hinge Joints behaving erratically after the Unity 5.1 update. If you use DestroyIt's Support Points in your project, you'll notice it creates Fixed Joints now instead of Hinge Joints. NOTE: If your fixed joints ever seem "springy", increase the Solver Iteration Count in your Project Settings to around 20 or 30 (the default is 6).
    • Fixed a crash related to Hinge Joints on the #13 Hinge Motor scenario in the demo scene. We noticed this crash after the Unity 5.1 update. It occurs because the OpenCloseChest script is trying to set the hinge motor target velocity after the game object is destroyed. Unity 4 did not have a problem with this, but Unity 5 does. To fix this issue, all joints are now immediately removed from destructible objects when they are destroyed.
    1.3.2 (June 2015)
    Note: Please make sure you update to Unity 5.1 before you update DestroyIt to 1.3.2.

    • Updated GameObjectExtensions.cs to change the variable name MaxBounce to bounciness due to the variable name changing in Unity 5.1.
    1.3.1 (Apr 2015)
    • Fixed an NRE that could occur with the material preloader.

    1.3 (Mar 2015)

    THIS IS A MAJOR UPDATE - PLEASE CREATE A BACKUP COPY OF YOUR PROJECT IF YOU ARE UPGRADING FROM A PREVIOUS VERSION OF DESTROYIT.

    The best way to upgrade is to delete the entire "DestroyIt - Core" folder and re-import the new version of DestroyIt. Be sure to copy out any materials you may have saved to the Material_Preload folder. Also, click "Save To File" on the Object Pool, so you can quickly reload any object pool entries you've added.

    Unity 5 Fixes/Enhancements
    • Support added for progressive damage using the Unity 5 physically-based rendering Standard shaders. See documentation for instructions on how to use it.
    • Removed use of the ForceCollisions script, since fast-moving rigidbodies (like the cannonball) now correctly register collisions using Continuous collision detection on the rigidbody.
    • Destructible objects will automatically transfer any Reflection Probe Anchor to all mesh renderers on their destroyed prefabs.
    • The PoweredLight script now includes an optional "EmissiveOff" material, so you can have it turn off emission when the light goes out. This is illustrated in Scenario #10 "Power Sources" in the demo scene. When the light fixture becomes unpowered, the lampshade's emission is turned off for added realism.
    • The legacy DestroyIt Progressive Damage shaders were updated so they no longer double light input values.
    General Fixes/Enhancements
    • Support for melee weapons added. Fireman's Axe was added to the demo scenes to help get you started adding your own melee weapons.
    • "DestroyItDebris" layer is now automatically created on project startup if it doesn't already exist.
    • PoolAfter script - Added option to reset an object back to its original prefab state prior to re-pooling it. Useful for re-pooling destroyed objects.
    • A few particle effects were fixed: BulletStrikeWood and BulletStrikeConcrete were using the "stuffing" sprites by mistake. Color gradients were fixed on the BulletStrikeStuffing particle effect so now there's a mixture of white and black bits.
    • Added a collision.contacts safety check to both HitEffect and DestructibleParent scripts.
    • Removed many user-supplied fields from the InputManager script and made it smarter about locating weapon positions on the First Person Controller.
    • On the Destructible script, under "Children to Un-Parent when Destroyed", if you set a child to un-parent and then later move that child from under the destructible object, the reference to that object will be removed and it won't try to unparent it.
    • Now if you add a duplicate item to the object pool, it will remove the duplicate automatically and log a message, telling you that the item already exists and what item number it is.
    • Singleton scripts (DestructionManager, ObjectPool, MaterialPreloader, etc) were upgraded from lazy to standard, so now they will instantiate themselves from the scene whenever they are first accessed. This means you no longer need to mess with Script Execution Order for DestroyIt.
    • Clinging debris is now always parented under the object it clings to. This creates a more solid joint and is better for performance than adding and managing hinge joints for every piece of clinging debris.
    • New "Sink into Ground" option on Destructible script. If checked, the object will sink into the ground instead of being destroyed into particles/debris.
    Demo Scenes Fixes/Enhancements
    • Demo scenes are now setup to use Linear color space for more realistic lighting, since it's available to everyone (it was a pro feature in Unity 4). To enable, go to Edit => Project Settings => Player and change Color Space to Linear.
    • Deprecated "lockCursor" code was changed to use new lockState enum in the demo scenes.
    • Hinge Joint break/torque strengths are very different in Unity 5, so we had to increase the strength of support points (from 23 or so to 750) to keep the wooden tower from collapsing.
    • The wooden chest (Scenario #13) was changed to WakeUp() the rigidbody on open/close so it would trigger the hinge motor to activate.
    • Gun muzzle flash and BulletStrikeMetal particle effects were adjusted (tint white level increased) because they looked dull under Linear Lighting.
    • Skybox fixed in SUV scene (textures had alpha but not marked as HDR).
    • Glass pane debris shards no longer use thicker beveled colliders to prevent them falling through the ground. Instead, they use thin colliders based on the mesh and collision detection was changed to Continuous Dynamic.
    • On the cogbox's spinning cogs, removed the extra delay in the DelayedRigidbody script, since the new PhysX version handles collisions better and doesn't send the cogs through the thin box on high-speed impact.
    • Nuke got a visual update via the tonemapping image effect on the camera. This blows white levels out and makes the scene look weird and high-contrast while the nuke is in effect.
    • Particle and flare color/alpha values had to be brightened for demo scene assets.
    Known Issues (Unity 5 Related)
    • In the demo scenes, the mouse cursor flickers in the middle of the screen on Windows machines while in the editor ( http://forum.unity3d.com/threads/cursor-lockstate-troubles.278221 ). This only happens in the editor, not once you've built your game.
    • When shooting the springy ground targets (scenarios #16 and #17) with the cannonball, the impact seems to be so great sometimes that it "pulls" the target up from the ground a bit and there's a pause/freeze before it repositions the target and lets the physics continue. I think this is a hinge joint collision related issue.
    • The FadeOut script doesn't work for Unity 5 standard shaders, and we haven't been able to create a script that's as simple to use for the new shaders because the way they strip out any feature that isn't used at runtime. This means in order to get it to work with the standard shader, you would have to know to create a variant with Fade render mode and add that to your list of preloaded shader variants and also add the script to your destroyed objects, which is a bit much. We're waiting for a solution or for a ShaderForge version of the standard shaders, so we can make our own fading shader, like we did in Unity 4.

    1.2 (Jan 2015)

    Enhancements

    • Added FadeOut script. When attached to a destroyed prefab, strips colliders and rigidbodies from debris after a set amount of time and fades them out with a transparent shader.
    • TGA texture files converted to .PNG format. (Saved 105 MB on the package download size.)
    • Added three new damage masks, "Random Growth", to give you more variety for progressive damage.
    • Transparent Reflective progressive damage shaders were improved to enhance the look of the damage. This can be seen in the shattered glass effect in the demo scenes.
    • New shattered "safety" glass texture and normal map added.
    Fixes
    • Changed "Debris" layer to "DestroyItDebris" to resolve a conflict with UFPS, which uses a layer by the same name but for a different purpose.
    • You can now save/load your ObjectPool entries if you have renamed your DestroyIt - Core folder.
    • HUD in the demo scenes can now be turned on/off independently of the targeting reticle.
    • Impact rigidbodies (like the cannonball) will now have their momentum correctly maintained when destroying an object as a particle effect.
    • Removed back face on Glass Pane in demo scene and fixed UV stretching issue on a couple of the broken shards. This also fixed the glass shards flickering when they fall.
    • Fixed a lighting issue with Specular progressive damage shader - it was darker than the Bumped Specular version.
    • Fixed Scenario #10 in demo scene, where sconce bulb was "flashing out" even when not tagged as Powered.

    1.1 (Oct 2014)

    Note: Damage-Level Particle Effects on the Destructible script was renamed to Damage Effects. You will need to re-assign damage-level effects in your projects if you have previously used this feature.

    New Features

    • Chip-Away Debris Allows you to make debris cling to a solid core structure of your destroyed prefab. Useful for columns or walls that have solid rebar centers. Debris can be chipped away from the rebar once the object is destroyed.
    • Tag All Debris As... You can now tag all debris pieces automatically with the "Tag All Debris As" checkbox. Each piece of debris will be assigned the TagIt script with the appropriate tag when the Destructible object is destroyed.
    • Save/Load Object Pool Entries You can now save and load your Object Pool entries to a file with the new Save/Load buttons on the Object Pool editor.
    • Auto-Pool Destroyed Prefabs By default, destroyed prefabs will now be auto-added to the object pool when the scene starts. This has several performance benefits: materials are pre-transferred to the destroyed object, debris rigidbodies are pre-referenced, and debris is pre-tagged. You can turn this feature off if needed. For instance, if your destructible objects need their materials changed dynamically through gameplay.
    • Parent Under Object (ClingPoints) When selected, strips the rigidbodies off the debris piece and parents it under the object it clings to instead of using a hinge joint. Provides better performance and a rock-solid joint.
    • Re-parent to Destroyed Prefab Allows you to choose one or more children under the destructible object that will be re-parented under the destroyed prefab. This is useful for things like car doors that have a window child, which needs to be reparented under the destroyed prefab's door. (See SUV Showcase scene)
    Enhancements
    • Damage-Level Particle Effects were renamed Damage Effects, and can now be any game object, they don’t have to be a particle effect. This allows you to use any game object with (or without) a script as a Damage Effect, so you could for instance make an object shudder at a certain damage level, or do a post-processing effect of water droplets on the camera when a water barrel is destroyed at close range.
    • Added a Showcase SUV Scene that illustrates what’s possible with the many features of DestroyIt.
    • When trying to do material transfer, system now logs a warning if the material was not found in the Resources folder.
    • Support Points now display friendlier error messages when no collider is found on a gameobject with a support point.
    • Updated asset to support Unity 4.5.4.
    • Updated code to use the new Unity 4.5 GetComponentInParent() method, which significantly improved performance for recursive parent lookups.
    • Improved material transfer from undestroyed to destroyed prefab with the option to "auto-pool" the destroyed prefabs. This option pre-transfers the materials to the destroyed prefabs on game Start().
    • Improved performance by converting several "foreach" statements to standard "for" loops.
    • Improved performance by converting several critical path C# generic List<T> members to standard arrays.
    • Improved performance by moving the GetComponentsInChildren() check for debris ClingPoints and rigidbodies to game Start() when using auto-pooled destroyed prefabs.
    • Added new particle effect for bullets striking rubber tires.
    • Added new particle effect for bullets striking cushion stuffing.
    • Added Damage Bumped Reflective shader.
    • Improved Transparent Reflective shader to better handle curved glass.
    Bug Fix
    • Destructible script no longer throws exception when assigning multiple replacements for the same material. It logs a warning instead and skips that material replacement at runtime.
    ----
    1.01 Hotfix (Jul 2014)

    • FIXED: When dragging Destructible script onto a gameobject, receive multiple null reference exceptions from Destructible and DestructibleEditor scripts.
    DestroyIt 1.0 (Jul 2014)
    • Initial release

    Need destructible models?
    Check out the Wasteland Explorer series of packs and the FREE Destructible Decoratives pack. All models are pre-configured to work with DestroyIt.

    Wasteland Explorer Destructible Bedroom
    Wasteland Explorer Destructible Kitchen



    User Guide | Website | Demo |Youtube | Additional Screenshots
     
    Last edited: Jun 20, 2018
    D4N005H, Lohrion, s7 and 1 other person like this.
  2. ZJP

    ZJP

    Joined:
    Jan 22, 2010
    Posts:
    2,644
    Woooo! :eek:
    Bookmarked...
     
  3. casselliot123

    casselliot123

    Joined:
    Feb 22, 2014
    Posts:
    9
    This looks cool! :p How do u compare it to the other two though? the other destruction systems>
     
  4. pneill

    pneill

    Joined:
    Jan 21, 2007
    Posts:
    207
    What's the performance like?
     
  5. zangad

    zangad

    Joined:
    Nov 17, 2012
    Posts:
    174
    Thanks! (I'm the other half of the DestroyIt team, btw.)

    I'm not sure which two assets you're comparing ours to, but from my experience, there are only 4 ways to handle destruction of an object in Unity (ordered from highest performance cost to lowest):
    1. Swap the object out with a pre-fragmented, destroyed prefab
    2. Fragment the object at runtime (ie, a mesh cutter script)
    3. Swap the object out with a particle effect
    4. Remove the object from the game (no visual effect)
    #1 creates the best effect if you can handle the performance cost. You get realistic, persistent debris that looks great, casts shadows, can be interacted with, can be further destroyed, can cause damage, and tricky objects like trees and barrels break apart perfectly. The downside to this method is (A) you have to create those cool destroyed prefabs with a modeling tool, and (B) it quickly becomes a performance hog with all the persistent colliders and rigidbodies.

    #2 is a compromise for the sake of convenience. You get most of the benefits of #1, but the meshes are sliced up on the fly, so you don't have to create broken prefabs with a modeling tool. The downside with this method is (A) it can become a performance hog like #1, but even worse because it's doing a lot of work at destruction time (B) the mesh cutting is done via algorithm, so objects break into a voronoi or similar pattern, so it doesn't look realistic for tricky objects (ie, trees explode into chunks, barrels break into "closed" chunks instead of thin fragments, etc).

    #3 is a compromise for the sake of performance. You don't get persistent debris, but you can get some nice looking effects, since you can design mesh particles that look like fragments of the destroyed object. The benefit to this method is great performance. The downside to this method is (A) no persistent debris, (B) you still have to create those cool looking particle effects, and (C) it's not realistic for tricky objects (like a destroyed tree popping into a particle effect).

    #4 is the ultimate compromise for the sake performance. You get nothing when the object is destroyed, it just disappears right in front of your face. Sounds terrible, but it's still an option for certain situations. For example, you're not going to notice destruction happening in the distance when you're surrounded by smoke and flying debris in your face. The benefit to this method is ultimate performance. The downside is complete lack of realism, so you want to hide this type of destruction from the camera as much as possible.

    Now, to answer your question, the DestroyIt system doesn't rely on a single strategy for destruction. It uses #1, #3, and #4. It has a destruction manager to process destroyed prefabs and throttle them down to particle effects when destruction is heavy, while thinning out excess debris (you set the limit). It has a particle manager to throttle particle effects when destruction is heavy. And it uses object pooling to handle spawning and recycling objects instead of instantiating/destroying them directly.

    Our focus with DestroyIt is:
    • Large amount of destruction (high performance)
    • Realistic destruction (wood breaks like wood, glass like glass)
    • Destruction that matters (collapse towers by knocking out their supports, kill an enemy with a fallen tree, etc)
    So with that information, you can compare our system to any other and make an informed choice. I would suggest playing our web demo to see all the scenarios DestroyIt handles. Plus, it's just fun to run around and blow stuff up. :)
     
    Last edited: Jun 6, 2017
  6. RTSlang

    RTSlang

    Joined:
    May 3, 2013
    Posts:
    56
    So basically this can be applied to any mesh and it handles the rest of the work for you in a configurable manner? Does it auto generate the broken pieces?
     
  7. zangad

    zangad

    Joined:
    Nov 17, 2012
    Posts:
    174
    Hey pneill,

    Performance and realistic/cinematic effects were our top two design goals. The trade-off between those two is the heart of the DestroyIt system.

    We think performance is great, but more importantly, it's customizable to your game. So if your game is targeting low-end machines, you can adjust the performance down so fewer destroyed prefabs are spawned during heavy destruction and more will fall back to particle effects. And if it's still too heavy, you can adjust the particle manager to throttle the number of particle effects more aggressively. You could also limit destroyed prefabs to only spawn when within [X] distance from the camera. So there's a lot of performance tweaking available. That being said, we haven't tested DestroyIt for mobile devices.

    Performance Notes:

    In our trailer video, we setup a scene with 176 decorative columns and destroyed them all with the nuke's shockwave. The framerate on our moderate gaming rig dropped to 40 fps for a couple of frames, but it was not a noticeable lag in person. The decorative columns even have mesh colliders on them, and are not really optimized for mass destruction. We probably could have destroyed more with a more optimized model. Still, it's a pretty good idea of the limits.

    Also, in our web demo, you can use the 'Q' key to switch to the nuke and blow everything up in the scene all at once. That should give you a good idea of how performance is for your system, and whether it would be sufficient for your project.
     
    Last edited: Jun 6, 2017
  8. DeadlyAccurate

    DeadlyAccurate

    Joined:
    Apr 2, 2013
    Posts:
    148
    The only way it does that is if all you want are particle effects. The asset comes with a set of default particles you can use. (Check out demo scenario #1). If you want more complex particle effects, or destroyed prefabs, your artist will need to create them.


    No, it doesn't do that. You'll need to make a destroyed version of your object in a 3D modeling tool. Most 3D modeling tools have auto-fracturing add-ons, including Blender. All the scenarios in the demo after #3 use prefabs.

    We're also working on our first add-on model pack, a fully destructible, completely modular, modern residential house. It should be available in a few weeks.
     
    Last edited: Jun 17, 2014
  9. Reiner

    Reiner

    Joined:
    Dec 2, 2012
    Posts:
    180
    how can i make my fps player prefab to destroy your prefabs? not realy clear in the doc´s no capitel to setup the waepon or what else to shoot and destroy it with different weapons? mean new weapons!

    greetz Reiner
     
  10. Steve-Tack

    Steve-Tack

    Joined:
    Mar 12, 2013
    Posts:
    1,223


    Can you recommend any specific ones for Blender? One potential issue with having to do that in a modeling tool is that I use mostly purchased models and have had very mixed results trying to import some of them into Blender.

    I'm currently using the Exploder asset, which fractures meshes automatically and even UV's the new edges, but I would like to see if DestroyIt would work better for my game in terms of performance and working more reliably. Would you say that DestroyIt is a good fit for blowing up space ships in zero G? (sounds like it would be fine)
     
  11. DeadlyAccurate

    DeadlyAccurate

    Joined:
    Apr 2, 2013
    Posts:
    148
    We use modo, so I'm only vaguely familiar with Blender. I have version 2.69 installed, and it includes a Cell Fracture button, but I don't know how to use it. I found a couple of tutorials online that might point the way.
    DestroyIt would be an excellent fit for blowing up space ships! The way I'd probably do it is similar to what we did with the cog boxes in the demo (scenarios #11 & #12). The undestroyed version is just a rectangular cube, but the destroyed version has extra cogs and drive shafts packed inside.

    For a destroyed spaceship prefab, I'd slice the model along weak joints, give the metal a bit of a twist, put a texture on the interior polygons (something like black with glowing heated metal areas), and then pack a bunch of sci-fi greebles inside that'll fly out when it explodes.

    If you want to blow up parts of the ship separately (like destroy the wings separate from the body), you just need to put the script on each mesh instead of the parent object (in the demo, scenario #8, multiple meshes).
     
    Last edited: Jul 3, 2017
  12. zangad

    zangad

    Joined:
    Nov 17, 2012
    Posts:
    174
    Hey Reiner,

    Sorry, but I'm not sure what you're asking, specifically. We didn't document the weapons setup because they're not really the focus of the asset - just bonus goodies. :)

    Are you asking what you would need to do in order for your game's weapons to damage DestroyIt objects? If so, then what you need to do is make your ammo deal damage to DestroyIt objects on collision by calling ApplyExplosiveDamage() or ApplyImpactDamage() on the Destructible object, and telling it how much damage, force, etc to apply. Destructible objects have a set number of hit points, so once you apply enough damage to them, they will destroy themselves.

    In your OnCollisionEnter (or Update, if you ammo doesn't have a rigidbody, like the Bullet prefab in DestroyIt):
    Code (CSharp):
    1. private void OnCollisionEnter(Collision collision)
    2. {
    3.     // Apply damage if the object hit was a Destructible object
    4.     Destructible destructible = collision.contacts[0].otherCollider.gameObject.GetComponent<Destructible>();
    5.     if (destructible != null)
    6.     {
    7.         ImpactInfo bulletImpact = new ImpactInfo() {Damage=20, AdditionalForce=15, AdditionalForcePosition=hitInfo.point, AdditionalForceRadius = .5F};
    8.         destructible.ApplyImpactDamage(bulletImpact);
    9.     }
    10. }
    General Info about the DestroyIt Weapons:
    The weapons are model prefabs that are parented under the player's gameobject. There's an InputManager script that handles all input for the demo, and acts as the brains for firing the weapons. Once fired, each ammo prefab also has a small script that handles collisions, bullet streaks, rocket physics, dust effects (for the nuke), etc.

    Is there anything in particular you would like to see documented about the weapons?
     
  13. Reiner

    Reiner

    Joined:
    Dec 2, 2012
    Posts:
    180
    exactly what I was looking for. will test it now


    thank you for the quick response


    greetz Reiner
     
  14. zangad

    zangad

    Joined:
    Nov 17, 2012
    Posts:
    174
    Hey guys,

    We found a bug in the Destructible script and custom editor, and have submitted a hotfix update. Here's the change:

    v1.01 Hotfix
    FIXED: When dragging Destructible script onto a gameobject, you receive multiple null reference exceptions from Destructible and DestructibleEditor scripts when interacting with it in the Inspector.

    The reason this was happening is because the DamageLevelParticles and UnparentOnDestroy collections were not properly initialized before being iterated over in the custom editor.
     
    Last edited: Jul 8, 2014
  15. zugsoft

    zugsoft

    Joined:
    Apr 23, 2014
    Posts:
    427
    Hello, I just bought your asset, and for moment I am not happy with it.

    I only put 3 cubes in my game with differents sizes, and when I click on a button I destroy all cubes, result :
    The size is always the same, no realist.
     
    Last edited: Jul 14, 2014
  16. DeadlyAccurate

    DeadlyAccurate

    Joined:
    Apr 2, 2013
    Posts:
    148
    It sounds like you're describing scenario #1 in the demo scene, where you add the destructible script to an object without any additional changes. Am I understanding the problem? The destructible script uses the DefaultLargeParticle or DefaultSmallParticle particle effects (based on whether the object is greater or less than one meter). It offers a quick solution, but it's the least realistic. It's mostly intended as a placeholder effect until you have your real particle effects or destroyed meshes ready, to give you something visual.
     
  17. Ghosthowl

    Ghosthowl

    Joined:
    Feb 2, 2014
    Posts:
    171
    Dang, just found out about this today, judging from the demo this is awesome and very quick to get prototyping, wish I would have known about it before I bought another destruction system.
     
  18. zugsoft

    zugsoft

    Joined:
    Apr 23, 2014
    Posts:
    427
    Yes, I understood your script, I modify the maximumsize, 0.5 it's better.
    Now my problem is when my character walk, and touch your column, the column explode.
    I added 4 cubes around the column, and now only bullet can touch the column and destroy it.

    On mobile when your column pass to the destroyeed prefab *Column Marble DEST*, it's very laggy, I am working on.

    I also add a sound to your "one mat - middle chunk" with a simple script :

    public class destructionSound : MonoBehaviour {

    public AudioClip sound;
    // Use this for initialization

    void OnCollisionEnter(Collision collision) {
    if (collision.relativeVelocity.magnitude > 2)
    audio.Play();
    }
    }
     
  19. zangad

    zangad

    Joined:
    Nov 17, 2012
    Posts:
    174
    Hey Ghosthowl,

    Thanks for the kind words. Depending on which destruction system you bought, you might find it works well with ours, both complementing each other. For example, some of the destruction systems use mesh cutting algorithms, which would give you another destruction option for certain circumstances. Likewise, if your system breaks 3D models into debris pieces, those prefabs can be used as the destroyed prefabs in DestroyIt.
     
  20. zangad

    zangad

    Joined:
    Nov 17, 2012
    Posts:
    174
    Hey menfou,

    I'm out of town until tomorrow evening. When I get home I'll do my best to address the issues you mentioned. In the meantime, can you tell me what character controller system you are using?
     
  21. zugsoft

    zugsoft

    Joined:
    Apr 23, 2014
    Posts:
    427
    The workaround is simple:
    Total Hit Points = 1'000'000
    Mass = 1000
    Drag = 100

    On my iPad I have some lag during Column prefab load.
    I tried to put the prefab in the pool manager, but same result.
     
    Last edited: Jul 16, 2014
  22. zangad

    zangad

    Joined:
    Nov 17, 2012
    Posts:
    174
    Glad you found a workaround. Adding a million hit points and a thousand mass to something seems a bit odd, though. I wouldn't think you should have to do that. If your character controller has a rigidbody and running into things is causing it to do massive damage to them, I would suggest putting the character controller in a "Player" layer and in the ProcessDestructibleCollision() method, just exit if the collision was from an object in the "Player" layer (ie, don't apply the collision damage at all).

    But anyway, I'm glad you found a workaround. Just posting this alternate option in case someone else is having a similar problem with a rigidbody-based character controller.

    We haven't tested DestroyIt on mobile. Not saying it won't work, but my understanding is you have to use specific shaders and other considerations to make an asset mobile-ready across the board, and we weren't ready to tackle that yet. Still, I can try to assist...

    Some questions:
    1) So, you are having lag at the moment when the columns are destroyed, when the undestroyed object gets replaced with the destroyed prefab?
    2) Are you making sure the instance count in the object pool covers the number of columns you are destroying? If you're destroying 20 columns, you need 20 instances of the column in the object pool.
    3) You're not trying to play the nuke scene on iPad, are you? I can't imagine that scene would run well at all on a mobile device! :)
    4) When you say your destroyed column is lagging, which one are you using? Some of the columns in the demo scene weren't designed as much for performance as they were to show off other features of DestroyIt, so they probably have too many debris pieces and materials for good mobile performance.
    5) Speaking of...our columns use mesh colliders for the debris pieces, which work fine on desktop, but I'm wondering if those mesh colliders are tanking your performance on mobile. You might try converting the mesh colliders to box colliders to see if that gives you better performance. (For a real game, I would use box colliders, not mesh.)
     
    Last edited: Jul 17, 2014
  23. zangad

    zangad

    Joined:
    Nov 17, 2012
    Posts:
    174
    I was curious what it would take to get our DestroyIt system working with UFPS (a popular character controller and camera system) so tonight I tested it out. I'm happy to report the process was very straight-forward! Check it out:

    DestroyIt system with UFPS:
    (and don't laugh at my aim...)


    If you want to use DestroyIt with UFPS yourself, here are the steps:

    1) Open the DestroyIt demo scene.
    2) Disable the First Person Controller in the scene hierarchy.
    3) Click on the _GameManager object in scene hierarchy and disable the InputManager script.
    4) Import the uFPS asset.
    5) In the Project tab, dig down to UFPS\Base\Content\Prefabs\Players and drag the SimplePlayer prefab into the scene.
    6) In the Project tab, dig down to UFPS\Base\Content\Prefabs\Projectiles\PistolBullet prefab, click on it, and change the vp_HitscanBullet variables as follows:
    Force: 400
    Damage: 20
    7) Open the vp_HitscanBullet.cs file in your favorite script editor and on line 157 where the bullet does damage to the target, replace the line of code with this:
    Code (CSharp):
    1. // do damage on the target
    2. DestroyIt.Destructible destObj = hit.collider.gameObject.GetComponentInParent<DestroyIt.Destructible>();
    3. if (destObj != null)
    4. {
    5.     DestroyIt.ImpactInfo bulletImpact = new DestroyIt.ImpactInfo() {
    6.     Damage = (int)this.Damage,
    7.     AdditionalForce = this.Force / 5, // reduce the amount of force used on debris.
    8.     AdditionalForcePosition = hit.point,
    9.     AdditionalForceRadius = .5f };
    10.     destObj.ApplyImpactDamage(bulletImpact);
    11. }
    That's it! You should now be able to run around and destroy stuff in the DestroyIt demo scene using the UFPS character controller and camera. Hope that helps, and let us know if you have any issues.
     
    Last edited: Jul 17, 2014
  24. zugsoft

    zugsoft

    Joined:
    Apr 23, 2014
    Posts:
    427
    Did you see my video I sent you by email ?

    1/ Yes, only when the undestroyed objet is replaced by the prefab.
    I found a workaround:
    I disabled collider and gravity for each destroyed column parts.
    In my destructionFX.cs (attached on each "one mat - bottom chunk... "), I enabled collider after some millisec, and after gravity.
    On my iPad my framerate was 58, and drop to 42 when the destroyed objets was loaded.
    Now my framerate stay at 58.

    Code (CSharp):
    1. using UnityEngine;
    2. using System.Collections;
    3.  
    4. public class destructionFX : MonoBehaviour {
    5.  
    6.     public AudioClip sound;
    7.     int deltaTime=0;
    8.     int activation=Random.Range (10,40);
    9.     void OnCollisionEnter(Collision collision) {
    10.         if (collision.relativeVelocity.magnitude > 2) {
    11.             audio.Play ();
    12.         }
    13.     }
    14.     void Update()
    15.     {
    16.         if(deltaTime<100){
    17.             deltaTime++;
    18.             if(deltaTime > activation){
    19.             collider.enabled=true;
    20.         }
    21.         if(deltaTime > activation*2){
    22.             rigidbody.useGravity=true;
    23.         }
    24.         }
    25.     }
    26. }
    2/I put "Column Marble DEST" in the pool manager, and 4 for count.

    3/No, I not try it.

    4/I use your column

    5/ Mesh or box collider it's the same.
     
    Last edited: Jul 17, 2014
  25. zangad

    zangad

    Joined:
    Nov 17, 2012
    Posts:
    174
    Ok, I see what you're doing. Basically, you're spacing out the activation of the collider and rigidbody over a small amount of random milliseconds. I saw your suggestion of adding an option to the Destructible script to instantiate destroyed objects with their colliders disabled. I'm guessing this is so you can activate them with your destructionFX script?

    If there are no drawbacks to doing so, I might be able to add this functionality to the Destructible script so it works this way by default. If it improves performance on iPad, I can't imagine it would hurt performance for desktop. I'll do some testing to make sure it works with all the scenarios in our demo scene and roll it into our next patch if it improves performance without causing any issues. Worst case, I should be able to make it a checkbox option on the Destructible script to "Delay Collider/Rigidbody Activation".

    I just watched the videos you sent. Very impressed! I hope you don't mind me sharing them here. The destruction looks great, and it looks like you've got a solid game going on there!

    FPS + DestroyIt on iPad (Ced Lapierre)


     
  26. zugsoft

    zugsoft

    Joined:
    Apr 23, 2014
    Posts:
    427
    On the first video it's without my script, the fps drop to 42, in fact the game doesn't respond during 0.3s(1/60*(60-42)), it was not acceptable.
    On the second video the fps stay at 58fps with my script.
    On Android and WindowsPhone I measure the same thing.

    It's possible to play a sound and a particle when a destroyed objet hit other objet with velocity magnitude > 2 ?
    Else I can keep my destructionFX script , but 1 script it's better than 2 ;)

    Your asset will be the best if it will be possible to use a texture to make the destroyed prefab objet.
    But I think it's very hard to develop :D
     
    zangad likes this.
  27. popawheelie

    popawheelie

    Joined:
    May 27, 2013
    Posts:
    23
    Quick question. I am using a custom vertex blended shader for a lot of my structures. Does this system interfere or strip vertex colour from the models?
     
    zangad likes this.
  28. DeadlyAccurate

    DeadlyAccurate

    Joined:
    Apr 2, 2013
    Posts:
    148
    It transfers the materials from the undestroyed object to the destroyed object, but it's just a straight material copy. If you'd like, and your shaders aren't proprietary, send us one and we can test it.

    If you're using your own shaders, you wouldn't get the progressive damage our shaders provide, but ours are Shaderforge compatible, so you can easily see how we're doing the progressive damage and apply that to your own if you want.
     
  29. popawheelie

    popawheelie

    Joined:
    May 27, 2013
    Posts:
    23
    Awesome. My vertex blend shader is just a shader forge custom shader. Its really more about during the damage process. I was using another destruction plugin that stripped out vertex colour once damaged. (weird) So, if both models (damaged and undamaged) have the same vertex colours it should be fine?
     
    zangad likes this.
  30. DeadlyAccurate

    DeadlyAccurate

    Joined:
    Apr 2, 2013
    Posts:
    148
    I created a sphere and vertex painted it, then made a broken version with the same vertex map.



    Is that what you're looking for?
     
    Last edited: Jul 17, 2014
    popawheelie likes this.
  31. popawheelie

    popawheelie

    Joined:
    May 27, 2013
    Posts:
    23
    Thanks for that! Just bought it.
     
  32. DeadlyAccurate

    DeadlyAccurate

    Joined:
    Apr 2, 2013
    Posts:
    148
    Thanks! I replaced that video with another one that hopefully shows it off a little better.
     
  33. popawheelie

    popawheelie

    Joined:
    May 27, 2013
    Posts:
    23
    Hey guys,


    Is there an easier set up to so only hit objects fall or react? For example I have a pillar with a concrete core. (see attached) At the moment, once hit they all fall. I tried tagging it, and adding cling scripts to this many objects is too much of a time sink.
     

    Attached Files:

    Last edited: Jul 18, 2014
  34. DeadlyAccurate

    DeadlyAccurate

    Joined:
    Apr 2, 2013
    Posts:
    148
    We have an idea how to solve this, but we're still working on it. We'll get back to you as soon as we can.
     
  35. zangad

    zangad

    Joined:
    Nov 17, 2012
    Posts:
    174
    Hey popawheelie,

    Thanks for the question. We've been working on this over the last day or so. We thought it could be something a lot of people may like (including us!). So we've implemented it as a new feature called "Chip-Away Debris". It'll be a checkbox option on the Destructible script.

    Basically, you just leave the rigidbodies off of your destroyed prefab, set Chip-Away Debris to true, tell it what mass and drag you want your debris pieces to have when they fall off, and you're good to go. The debris will spawn in with only colliders and a lightweight script attached. If you want a little debris to fall off on initial destruction, put a rigidbody on those pieces. To keep your rebar "core" solid, put a kinematic rigidbody on that object. Everything else will fall off when struck with enough force. Since it didn't look as cool to have all the debris falling off at once with the area-of-effect weapons, I put in a random chance for those to knock debris off (50% seemed about right).

    Here's a video of it in action:
    (Watch on YouTube for bigger...videos seem to embed rather small here.)


    We're working towards our 1.1 release of DestroyIt, and this feature will be in it, along with the added scenario in the demo scene and the destructible column with rebar (I think yours looks way better!) and concrete texture. In the meantime, if you need this feature now, just email us (support@modelshark.com) and we'll get you a work-in-progress build.
     
    Last edited: Sep 18, 2017
    chelnok and popawheelie like this.
  36. popawheelie

    popawheelie

    Joined:
    May 27, 2013
    Posts:
    23
    Sorry for the late reply, I actually thought I did reply before I went on holiday. Anyways, I cannot thank you enough, great stuff.. I look forward to having a play with it when I get chance.
     
    zangad likes this.
  37. DeadlyAccurate

    DeadlyAccurate

    Joined:
    Apr 2, 2013
    Posts:
    148
    The 1.1 version of DestroyIt took longer than expected, but we added some fantastic new features. This update will be submitted to the asset store next week. Below is the changelog, and a short teaser trailer showing off many of the features of DestroyIt using one of Unity's free models, the Shanty Town: SUV.

    The showcase scene will be included with the updated package.





    Please be sure to back up your project before updating DestroyIt.

    Changelog:

    Notes
    • Damage-Level Particle Effects on the Destructible script was renamed to Damage Effects. You will need to re-assign damage-level effects in your projects if you have previously used this feature.

    New Features
    • Chip-Away Debris Allows you to make debris cling to a solid core structure of your destroyed prefab. Useful for columns or walls that have solid rebar centers. Debris can be chipped away from the rebar once the object is destroyed.
    • Tag All Debris As... You can now tag all debris pieces automatically with the "Tag All Debris As" checkbox. Each piece of debris will be assigned the TagIt script with the appropriate tag when the Destructible object is destroyed.
    • Save/Load Object Pool Entries You can now save and load your Object Pool entries to a file with the new Save/Load buttons on the Object Pool editor.
    • Auto-Pool Destroyed Prefabs By default, destroyed prefabs will now be auto-added to the object pool when the scene starts. This has several performance benefits: materials are pre-transferred to the destroyed object, debris rigidbodies are pre-referenced, and debris is pre-tagged. You can turn this feature off if needed. For instance, if your destructible objects need their materials changed dynamically through gameplay.
    • Parent Under Object (ClingPoints) When selected, strips the rigidbodies off the debris piece and parents it under the object it clings to instead of using a hinge joint. Provides better performance and a rock-solid joint.
    • Re-parent to Destroyed Prefab Allows you to choose one or more children under the destructible object that will be re-parented under the destroyed prefab. This is useful for things like car doors that have a window child, which needs to be reparented under the destroyed prefab's door. (See SUV Showcase scene)
    • New Shaderforge Progressive Damage Reflective Shader A reflective shader has been added to the list of progressive damage shaders.
    Enhancements
    • Damage-Level Particle Effects were renamed Damage Effects, and can now be any game object, they don’t have to be a particle effect. This allows you to use any game object with (or without) a script as a Damage Effect, so you could for instance make an object shudder at a certain damage level, or do a post-processing effect of water droplets on the camera when a water barrel is destroyed at close range.
    • Added a Showcase SUV Scene that illustrates what’s possible with the many features of DestroyIt.
    • When trying to do material transfer, system now logs a warning if the material was not found in the Resources folder.
    • Support Points now display friendlier error messages when no collider is found on a gameobject with a support point.
    • Updated asset to support Unity 4.5.4.
    • Updated code to use the new Unity 4.5 GetComponentInParent() method, which significantly improved performance for recursive parent lookups.
    • Improved material transfer from undestroyed to destroyed prefab with the option to "auto-pool" the destroyed prefabs. This option pre-transfers the materials to the destroyed prefabs on game Start().
    • Improved performance by converting several "foreach" statements to standard "for" loops.
    • Improved performance by converting several critical path C# generic List<T> members to standard arrays.
    • Improved performance by moving the GetComponentsInChildren() check for debris ClingPoints and rigidbodies to game Start() when using auto-pooled destroyed prefabs.
    • Added new particle effect for bullets striking rubber tires.
    • Added new particle effect for bullets striking cushion stuffing.
    • Updated the progressive damage transparent reflective shader to handle curved glass better.

    Bug Fix
    • Destructible script no longer throws exception when assigning multiple replacements for the same material. It logs a warning instead and skips that material replacement at runtime.
     
    Last edited: Jul 3, 2017
    zangad and chelnok like this.
  38. ZJP

    ZJP

    Joined:
    Jan 22, 2010
    Posts:
    2,644
    Nice update. :cool:
     
    zangad likes this.
  39. DeadlyAccurate

    DeadlyAccurate

    Joined:
    Apr 2, 2013
    Posts:
    148
    Thanks. We'll have a web demo showing off the destruction of the SUV soon.
     
    zangad likes this.
  40. JesterMaster

    JesterMaster

    Joined:
    Oct 29, 2014
    Posts:
    34
    Hi

    Great update I love the SUV.

    Could you help me with UFPS. I got the weapons working perfect except the maze. How can I make melee weapons work also with DestroyIt.

    Also when I walk through window with my UFPS player, I can not get the glass break. Is there any way make this happen?

    Thank you once more for this great asset.
     
    Last edited: Oct 30, 2014
    zangad likes this.
  41. zangad

    zangad

    Joined:
    Nov 17, 2012
    Posts:
    174
    Hey JesterMaster,

    Thanks for your comments, We're glad you're enjoying DestroyIt so far!

    I've been meaning to add a melee weapon to the sample scenes and web demos, so I'm glad you brought this up. I also own UFPS, so I'll take a look at it tomorrow and see what I can come up with.

    And yes, you can do walking/running into glass and breaking it. The CharacterController acts differently than other colliders, so we have to write a script to intercept the collisions and apply damage to destructible objects the player collides with.

    Create a new script, paste this code into it, and attach it to your character controller:

    Code (CSharp):
    1. using UnityEngine;
    2. using System.Collections;
    3.  
    4. namespace DestroyIt
    5. {
    6.     public class CharacterControllerCollision : MonoBehaviour
    7.     {
    8.         void OnControllerColliderHit(ControllerColliderHit hit)
    9.         {
    10.             if (hit.moveLength >= 0.15) // If this was a hard enough hit... (adjust to what fits your game)
    11.             {
    12.                 // See if the object hit is a destructible object
    13.                 Destructible destructibleObj = hit.collider.gameObject.GetComponentInParent<Destructible>();
    14.                 if (destructibleObj != null)
    15.                 {
    16.                     // Does the destructible object have a rigidbody? If so, we could get the impact velocity and whatnot...
    17.                     Rigidbody otherRbody = hit.collider.attachedRigidbody;
    18.                     if (otherRbody != null)
    19.                         Debug.Log("Hit rigidbody!");
    20.                     else
    21.                         Debug.Log("Hit non-rigidbody!");
    22.  
    23.                     // ...but for our simple scenario, just apply 50 points of damage with a hard hit.
    24.                     destructibleObj.ApplyDamage(50);
    25.                 }
    26.             }
    27.         }
    28.     }
    29. }
    This script will apply 50 points of damage to any destructible object the player runs into hard enough. You'll want to adjust the moveLength to fit what feels right for your game. I also left my Debug.Logs in there, so if your destructible objects have rigidbodies (even kinematic ones), you can get the impact velocity from them and use that to create a more accurate physics-based damage collision if desired.

    One thing this doesn't do is push through the glass and shove the shards out of the way. That's because the CharacterController (at least the default Unity one in the Standard package) doesn't have a rigidbody or mass, so it simply stops with a collision of any kind. To make it cooler, you could put a trigger collider around the character controller that applies force to anything it touches and therefore pushes the glass shards away when you bust through. Neat idea! :)

    Hope that helps. I'll take a look at melee weapons tomorrow.
     
  42. DeadlyAccurate

    DeadlyAccurate

    Joined:
    Apr 2, 2013
    Posts:
    148
    The 1.1 update is now live!

    We created a new trailer that shows off some of the new features and the SUV showcase scene that is included with the update.



    Enjoy!
     
  43. zangad

    zangad

    Joined:
    Nov 17, 2012
    Posts:
    174
    Just following up on JesterMaster's question about getting UFPS melee weapons to work with DestroyIt. I put together some drop-in code and a video tutorial that walks you through the changes and shows the results.

    While I was going through this exercise, I found an issue where UFPS was using the same Debris layer DestroyIt uses for some physics stuff, and it was making the DestroyIt debris act weird. So as a quick fix, I walk you through changing the code so DestroyIt references a new layer called DestroyItDebris. If you don't make this change, it's not a big deal, but some debris pieces might fall through one another when they're auto-added to the Debris layer on destruction.

    (NOTE: Watch on YouTube and change video settings to HD for best readability)


    Quick fix for duplicate "Debris" layers in UFPS and DestroyIt:
    1) Create new "DestroyItDebris" layer.
    2) Change DestroyIt code so it references "DestroyItDebris" instead of "Debris" layer. (Do a global Find for "Debris" in quotes, and change each instance to "DestroyItDebris".)

    Make UFPS melee weapons work with DestroyIt:
    1) Open the DestroyIt Demo scene.
    2) Disable the First Person Controller object in the demo scene.
    3) Disable the InputManager script on the _GameManager object.
    4) Drag the Hero prefab from UFPS to the scene.
    5) On the Hero object -> FPSCamera -> 4Mace vp_FPSWeaponMeleeAttack script, change the force to 150.
    6) Drag the PickupMace prefab from UFPS to the scene.
    7) Open up the UFPS code and replace the vp_FPWeaponMeleeAttack ApplyDamage() method with the code below:
    Code (CSharp):
    1. void ApplyDamage(RaycastHit hit)
    2.     {
    3.         // do damage on the target
    4.         var destructibleObj = hit.collider.GetComponentInParent<DestroyIt.Destructible>();
    5.         if (destructibleObj != null) // DestroyIt Destructible Objects
    6.         {
    7.             // Damage Effect (sparks, wood chips, etc)
    8.             var tagIt = hit.collider.GetComponent<DestroyIt.TagIt>();
    9.             GameObject effect = null;
    10.             if (tagIt != null && tagIt.tags.Count > 0)
    11.             {
    12.                 if (tagIt.tags.Contains(DestroyIt.Tag.Wood))
    13.                     effect = DestroyIt.InputManager.Instance.strikeWoodPrefab;
    14.                 else if (tagIt.tags.Contains(DestroyIt.Tag.Glass))
    15.                     effect = DestroyIt.InputManager.Instance.strikeGlassPrefab;
    16.                 else if (tagIt.tags.Contains(DestroyIt.Tag.Metal))
    17.                     effect = DestroyIt.InputManager.Instance.strikeMetalPrefab;
    18.                 else // Default is concrete effect
    19.                     effect = DestroyIt.InputManager.Instance.strikeConcretePrefab;
    20.             }
    21.             else // Default is concrete effect
    22.                 effect = DestroyIt.InputManager.Instance.strikeConcretePrefab;
    23.  
    24.             if (effect != null)
    25.                 DestroyIt.ObjectPool.Instance.Spawn(effect, hit.point, Quaternion.LookRotation(hit.normal));
    26.  
    27.             var explosiveDamage = new DestroyIt.ExplosionInfo()
    28.             {
    29.                 BlastForce = DamageForce,
    30.                 Position = hit.point,
    31.                 Radius = DamageRadius
    32.             };
    33.  
    34.             destructibleObj.ApplyExplosiveDamage(explosiveDamage);
    35.         }
    36.         else // Everything Else
    37.         {
    38.             hit.collider.SendMessage(DamageMethodName, Damage, SendMessageOptions.DontRequireReceiver);
    39.  
    40.             // if hit object has physics, add the damage force to it
    41.             Rigidbody body = hit.collider.attachedRigidbody;
    42.             if (body != null && !body.isKinematic)
    43.                 body.AddForceAtPosition(((m_Camera.Transform.forward * DamageForce) / Time.timeScale) / vp_TimeUtility.AdjustedTimeScale, hit.point);
    44.         }
    45.     }
     
    Last edited: Nov 1, 2014
  44. eridani

    eridani

    Joined:
    Aug 30, 2012
    Posts:
    655
    Does your asset approach destruction differently than the popular "Fracturing & Destruction" asset? Your asset seems newer and more polished, but the other one seems to be very well-established.

    I'm loving your uFPS examples though. And I want to target mobile devices. Thanks!
     
  45. DeadlyAccurate

    DeadlyAccurate

    Joined:
    Apr 2, 2013
    Posts:
    148
    Our focus is on performance and realistic destruction. We give you options to scale your destruction based on the needs of your game. You can set limits on how many destroyed prefabs or particle effects will be instantiated within a set time limit in order to space out heavy physics load. We provide integrated object pooling, custom shaders that give your models the appearance of progressive damage, the ability to set triggered effects at specific damage stages (so you could make an engine shudder and smoke at 60% damage), and a host of smaller scripts and utilities that help you do things like get appropriate collision particle effects (metal sparks when hit, concrete spews dust/chunks, dirt throws up grass clumps), setup joints easily with support points (which are converted to hinge joints at runtime), and clinging debris, which gives modular destructible objects like walls a jagged, randomly-destroyed look.

    We also focus on versatility. Our demo scene has 22 or so test scenarios in it, and we give you 4 weapons with different damage types (bullet, impact, explosive, and shockwave mass destruction) to test each scenario with. So a lot of our effort has been on making sure our asset works as expected with many different types of damage and situations.

    Our asset does not include a voronoi mesh fracturing tool. You need to supply your own particle effects, or break apart your own models in order to create destroyed prefabs. There is a free voronoi fracturing plugin that comes with Blender if you need to do this. We'll cover how to create a destroyed prefab in an upcoming video. I mostly use voronoi fracturing to create destroyed glass, walls, stone columns, urns, etc. For metal objects like a car or space ship, I'd pull apart the model at logical seams and warp the pieces with a 3D modeler's push/pull sculpting tool. A car wouldn't look very convincing if it exploded into voronoi chunks.

    It really depends on what you need for your game. If a car exploding into voronoi chunks would look fine in every situation for your game, then our asset is probably overkill. DestroyIt is a good fit when you need realistic destruction and progressive damage most of the time, but would like it to scale down to simple particle effects when a lot of destruction is going on at once.
     
  46. axelz58

    axelz58

    Joined:
    Apr 27, 2013
    Posts:
    17
    what about a huge mesh being hit? would it all crumble OR only a small fraction would break off?
     
  47. DeadlyAccurate

    DeadlyAccurate

    Joined:
    Apr 2, 2013
    Posts:
    148
    If you chose to use the Chip-Away Debris option, you could could crumble a large mesh a little at a time. It's mainly for debris that is attached to something else (like rebar or wall studs).



    What sort of object are you considering fracturing?
     
  48. ZJP

    ZJP

    Joined:
    Jan 22, 2010
    Posts:
    2,644
  49. DeadlyAccurate

    DeadlyAccurate

    Joined:
    Apr 2, 2013
    Posts:
    148
    DestroyIt can definitely handle destruction like that. In fact, reading those blog posts, it sounds like the same way we do it already. It also gave me an idea to add transparency cutouts to the DestroyIt shaders. I'll have to look into that.

    If you wanted to do more micro destruction, such as knock off the starboard engine nacelle and let the rest of the ship remain intact, you can split the mesh and make individual parts destructible. The SUV in the showcase scene is about 20 separate mesh renderers under one parent, so almost every part of the vehicle can be destroyed separately.

    I hope that helps. If you have any more questions, please don't hesitate to ask.

    (We'll try to get a web demo of the SUV up as soon as we can so people can play around with it).
     
    Recluse likes this.
  50. ZJP

    ZJP

    Joined:
    Jan 22, 2010
    Posts:
    2,644
    Thanks for the reply. I'm waiting for your future tests about the transparency cutouts things.;)