Asset Store newest packages

SYSTEM REQUIREMENTS

Unity Version: 2020.3 LTS or newer (2022.3 LTS recommended)

.NET: Standard 2.0 or newer

Render Pipeline: Any (Built-in, URP, HDRP)

Input System: Legacy Input Manager or New Input System 1.4+

Platforms: All platforms supported by Unity

PACKAGE CONTENTS

Runtime Scripts: 27 C# files

- 11 QTE config classes (ScriptableObject)

- 11 evaluator classes

- 1 lifecycle controller (QTEInstance)

- Input abstraction layer (4 files)

Editor Scripts: 25+ C# files

- 11 custom Inspector editors

- Import/Export Wizard

- Schema exporter modules (per-type + combiner)

- Timing phase editor

- Property drawers

Documentation: 10 HTML pages

Demo: 12 demo managers + 12 UI scripts

Test Data: 5 sample JSON files

NAMESPACES

SimpleQTE - Runtime classes

SimpleQTE.Editor - Editor tools

SimpleQTE.Demo - Demo scene scripts

ARCHITECTURE

Config Layer

    ScriptableObject-based configuration for each QTE type.

    Create via Assets menu or ScriptableObject.CreateInstance at runtime.

    All configs inherit from QTEConfig base class.

Evaluator Layer

    Pure C# classes implementing IQTEEvaluator interface.

    No MonoBehaviour dependency.

    Receives deltaTime and input, returns QTEResult.

    Stateless design allows reuse or disposal.

Instance Layer

    QTEInstance manages lifecycle: Created, Running, Completed, Cancelled, Disposed.

    Bridges game code to evaluators.

    Exposes events for state changes, progress updates, and completion.

INPUT SYSTEM

Dual-system support via compile-time detection:

- ENABLE_INPUT_SYSTEM defined: Uses New Input System API

- Not defined: Falls back to Legacy Input Manager

IQTEInputSource interface:

- IsPressed(): Button currently held

- WasPressedThisFrame(): Just pressed this frame

- WasReleasedThisFrame(): Just released this frame

- GetStickValue(): Analog stick position (Vector2)

QTEInputAdapter default implementation handles:

- Gamepad buttons (face, triggers, bumpers, d-pad, stick clicks)

- Keyboard fallbacks for all inputs

- Analog stick with keyboard simulation (WASD, IJKL)

QTEInput enum (14 platform-neutral button names):

    FaceSouth, FaceEast, FaceWest, FaceNorth

    DPadUp, DPadDown, DPadLeft, DPadRight

    LeftTrigger, RightTrigger, LeftBumper, RightBumper

    LeftStickButton, RightStickButton

QTEStick enum:

LeftStick (WASD/Arrows fallback), RightStick (IJKL fallback)

PERFORMANCE

- Zero GC allocation per Tick() call

- Evaluators use struct-based state

- No LINQ or delegates in hot paths

- Injected deltaTime supports slow-motion and frame stepping

QTE RESULT

QTEResult struct (immutable):

- ResultType: Perfect, Success, PartialSuccess, Failure, Timeout, Cancelled

- Accuracy: 0-1 normalized accuracy value

- CompletionTime: Time when QTE completed

- IsSuccess: True if Perfect, Success, or PartialSuccess

- IsPerfect: True if Perfect

QTE INSTANCE LIFECYCLE

States: Created -> Running -> Completed (or Cancelled/Disposed)

Methods:

- Start(): Begin QTE evaluation

- Tick(float deltaTime): Update each frame

- Cancel(): Stop QTE with Cancelled result

- Dispose(): Clean up resources

Events:

- OnStateChanged(QTEInstanceState)

- OnProgressChanged(float)

- OnCompleted(QTEResult)

TIMING SYSTEM

QTETimingProfile (shared timing config):

- mode: Open or Windowed

- enableTimeout: Optional time pressure

- promptLeadTime: Delay before active phase

- timeLimit: Total duration

- useRandomTimeLimit: Randomize between min/max

- useSpeedCurve: Countdown speed varies over time

- speedMode: Curve (AnimationCurve) or Phases (discrete ranges)

TimingPhase (for Phases mode):

- durationPercent: 1-100, phases must total 100%

- multiplier: Speed/decay multiplier for this phase

PingPong uses inline timing (like Mash/StickWaggle) with the same features.

RELEASE MODES

Available for: LinearPrecision, RotationalPrecision, Arc, RotationalSpin

- Continue: Input position maintained on release

- Decay: Drifts back to rest position over time

- Reset: Snaps back to start position

- Fail: Releasing input fails the QTE

COMPOSITE SYSTEM

CompositeStep:

- Atomic: Single QTE config reference

- Parallel: Multiple QTEs running simultaneously

- delayBefore: Optional delay before step

- onSuccessGoTo / onFailGoTo: Branching to other steps

ParallelLogic:

- All (AND): Every item must succeed

- Any (OR): At least one succeeding = success

Events:

- OnStepStarted(int stepIndex)

- OnStepCompleted(int stepIndex, QTEResult)

- OnBranchTaken(int fromStep, int toStep)

- OnCompositeCompleted(QTEResult)

PINGPONG SYSTEM

PingPongZone:

- position: Center on bar (0-1)

- range: Half-width of zone

- zoneType: Success, Perfect, Penalty

- penaltyEffect: Fail, AccuracyPenalty, LoseProgress

- randomizePosition: Randomize zone position each run

- randomizeRange: Randomize zone size between rangeMin/rangeMax

PingPongMode:

- AnyOne: Hit any target zone to win

- Sequence: Hit all zones in position order

- FreeOrder: Hit all zones in any order

PingPongMissEffect:

- Nothing: Cursor keeps bouncing

- Fail: Instant fail

- AccuracyPenalty: Lose accuracy on miss

JSON SYSTEM

Import:

- Full-fidelity deserialization (all config fields supported)

- Validation with error and warning reporting

- Two-pass import (atomics first, composites resolve references)

Export:

- Schema generation for AI tools (Claude, ChatGPT, Cursor)

- JSON or Markdown format

- Master schema (all 11 types) or single-type export

Supported formats:

- Full wrapper: { "metadata": {...}, "qtes": [...] }

- Single entry: { "type": "Press", "name": "...", "press": {...} }

- Array: [ { "type": "Press", ... }, { "type": "Hold", ... } ]

EDITOR TOOLS

Custom Inspectors:

- Visual timeline showing prompt/success/perfect zones

- D-pad picker for directional QTEs

- Arc and angle visualizations

- Bar preview with zone colors for PingPong

- Curve editors with phase alternative

- Real-time validation display

Import/Export Wizard (Window > SimpleQTE):

- Import-Export Wizard: Load JSON, validate, select entries, import

- Export Schema: Generate AI-ready documentation (per-type or master)

- Copy Schema to Clipboard: Quick paste into AI chat

- Documentation: Open any doc page directly from Unity

API QUICK START

// Create and run a QTE

var config = Resources.Load<PressQTEConfig>("MyPressQTE");

var input = new QTEInputAdapter(QTEInput.FaceSouth);

var instance = new QTEInstance(config, input);

instance.OnCompleted += result => {

    if (result.IsPerfect) Debug.Log("Perfect!");

    else if (result.IsSuccess) Debug.Log("Success");

    else Debug.Log("Failed");

};

instance.Start();

// In Update loop

instance.Tick(Time.deltaTime);

DEPENDENCIES

None. No external packages required.

New Input System package optional (auto-detected).

Simple QTE is a complete Quick Time Event framework for Unity. Create cinematic action sequences, boss finishers, and interactive moments with 11 fully-featured QTE types. Works with both Legacy Input Manager and New Input System out of the box.

Three ways to create QTEs:

- Design in the Inspector with visual timeline editors (ScriptableObject configs)

- Generate from JSON using the built-in import/export system (perfect for AI-assisted workflows)

- Create at runtime via code (ScriptableObject.CreateInstance or direct evaluator access)

11 QTE TYPES

Button-Based:

- Press: Single button press with Open or Windowed timing modes

- Hold: Hold button until meter fills, optional release decay

- Mash: Rapid presses to reach target (Count or Value modes), rapid bonus system

- PingPong: Bouncing cursor on a bar, press when over target zone (golf swing, penalty kick, fishing style)

Stick-Based:

- StickWaggle: Waggle stick back and forth on configurable axis

- Directional: Push stick in correct direction, 8-direction support

- LinearPrecision: Find sweet spot on horizontal bar and hold

- RotationalPrecision: Rotate to target angle and hold

- Arc: Traverse arc from start to end angle (God of War style)

- RotationalSpin: Rotate stick N full times (door crank style)

Advanced:

- Composite: Combine multiple QTEs in sequence or parallel blocks with branching

KEY FEATURES

Dual Input System Support

Works with Legacy Input Manager and New Input System 1.4+. No configuration needed - auto-detects at compile time.

JSON Import/Export

Full-fidelity JSON serialization. Export schema documentation for AI tools. Import AI-generated configs directly into your project. Includes 5 sample JSON files demonstrating all QTE types.

Advanced Timing System

- Random time limits for unpredictability

- Speed curves: countdown accelerates or decelerates over time

- Decay curves: decay rate changes over time

- Timing phases: designer-friendly alternative to curves

- Optional timeout: disable time pressure for accessibility

Composite QTEs

Build complex sequences with:

- Sequential steps (do A, then B, then C)

- Parallel blocks (do A AND B simultaneously)

- Logic gates (ALL must succeed vs ANY can succeed)

- Branching (custom success/fail paths, recovery routes, alternate endings)

Release Modes

For precision and rotation QTEs:

- Continue: cursor stays where it is

- Decay: cursor drifts back to rest position

- Reset: cursor snaps back to start

- Fail: releasing fails the QTE

Custom Editors

11 visual Inspector editors with:

- Timeline visualization showing prompt/success/perfect zones

- D-pad direction picker for Directional QTEs

- Arc and angle visualizations

- Bar preview with zone visualization for PingPong

- Real-time validation with error display

- Tooltips with examples

RUNTIME ARCHITECTURE

- Pure C# evaluators: no MonoBehaviour inheritance required

- Zero GC allocation per tick

- Injected deltaTime for slow-motion and frame stepping support

- Clean event system: OnStateChanged, OnProgressChanged, OnCompleted

- Immutable QTEResult struct with accuracy, timing, and score data

WHAT'S INCLUDED

Runtime Scripts:

- 11 QTE config classes (ScriptableObject)

- 11 evaluators with complete logic

- QTEInstance lifecycle controller

- Input abstraction layer (IQTEInputSource)

- QTEInputAdapter for both input systems

Editor Scripts:

- 11 custom Inspector editors

- Import/Export Wizard window

- Schema exporter for AI tools

- Timing phase editor with visual timeline

Demo and Documentation:

- Demo managers and UI for all 11 types

- 10 HTML documentation pages

- 5 sample JSON files (God of War, Resident Evil, Heavy Rain, Spider-Man, Edge Cases themes)

USE CASES

- Boss finishers and cinematic kills

- Parry based gameplay with QTE prompts

- Door cranks and valve wheels

- Lockpicking and safe cracking

- Button mashing escape sequences

- Precision aiming minigames

- Golf swing / penalty kick meters

- Fishing minigame reeling

- Dialogue wheel selections

- Struggle and grapple moments

- Charge attacks

- Multi-input combo sequences

- Timeline cutscene interaction with QTE

SUPPORT

- Full HTML documentation included

- Sample JSON files for reference

- Demo scenes for all QTE types

Number of Unique Meshes: 6

Vertex Count: 8961(All)

Rigged: (Yes)

Number of Characters: 1

Animated: (No)

Number of Materials: 4

Number of Textures: 16

Texture Resolutions: (4096x4096)

Rigged with Humanoid

High-quality sci-fi alien soldier character designed for games, cinematics, and concept projects.

The model combines organic forms with a technological armored suit, creating the look of an extraterrestrial fighter from a futuristic universe.

Model Features:

• Asymmetrical armor with technological modules
• Developed anatomy and expressive alien morphology
• High-detail materials: metal, fabric, organic surfaces
• Ideal for NPCs, enemies, soldiers, and sci-fi concept designs
• Modular
• Hight Quality Model & PBR Materials
• LowPoly - Game Ready
• Reasonable poly count
• Optimized the density of the textures

Asset has no animations, but rigged with Humanoid skeleton, so you can easy retarget animations.

Check out our BESTSELLER upgrade: [Quirky Series Ultimate Pack]

Website : https://omabuarts.com

Quirky Series - Animals Mega Pack Vol.1

Quirky Series - Animals Mega Pack Vol.2

Quirky Series - Animals Mega Pack Vol.3

Quirky Series - Animals Mega Pack Vol.4

Features

✅ Nine (9) animals pack

✅ Tiny 8x8 px texture [diffuse map only]

✅ Rigged/Skeleton

✅ 19 animations

✅ 4 Levels of Detail [min 300 up to 9k tris]

✅ Mobile, AR/VR ready

✅ Sample URP Shader included

❌ Vertex color

❌ Clean (non-overlapping) UV mapping

Animations

Attack | Bounce | Clicked | Death

Eat | Fear | Fly | Hit

Idle_A | Idle_B | Idle_C

Jump | Lay | Roll | Run | Sit

Spin/Splash | Swim | Walk

Blendshapes/Shapekeys:

eyes.blink | eyes.happy | eyes.sad | eyes.sad

eyes.annoyed | eyes.squint | eyes.shrink | eyes.dead

eyes.lookOut | eyes.lookIn | eyes.lookUp | eyes.lookDown

eyes.excited-1 | eyes.excited-2 | eyes.rabid

eyes.spin-1 | eyes.spin-2 | eyes.spin-3

eyes.cry-1 | eyes.cry-2 | eyes.trauma

teardrop-1.L | teardrop-2.L | teardrop-1.R | teardrop-2.R

sweat-1.L | sweat-2.L | sweat-1.R | sweat-2.R

Email : omabuarts@gmail.com

Website : https://omabuarts.com

Twitter : @omabuarts

Check out our BESTSELLER upgrade: [Quirky Series Ultimate Pack]

Website : https://omabuarts.com

Quirky Series - Animals Mega Pack Vol.1

Quirky Series - Animals Mega Pack Vol.2

Quirky Series - Animals Mega Pack Vol.3

Quirky Series - Animals Mega Pack Vol.4

Features

✅ Nine (9) animals pack

✅ Tiny 8x8 px texture [diffuse map only]

✅ Rigged/Skeleton

✅ 19 animations

✅ 4 Levels of Detail [min 300 up to 9k tris]

✅ Mobile, AR/VR ready

✅ Sample URP Shader included

❌ Vertex color

❌ Clean (non-overlapping) UV mapping

Animations

Attack | Bounce | Clicked | Death

Eat | Fear | Fly | Hit

Idle_A | Idle_B | Idle_C

Jump | Lay | Roll | Run | Sit

Spin/Splash | Swim | Walk

Blendshapes/Shapekeys:

eyes.blink | eyes.happy | eyes.sad | eyes.sad

eyes.annoyed | eyes.squint | eyes.shrink | eyes.dead

eyes.lookOut | eyes.lookIn | eyes.lookUp | eyes.lookDown

eyes.excited-1 | eyes.excited-2 | eyes.rabid

eyes.spin-1 | eyes.spin-2 | eyes.spin-3

eyes.cry-1 | eyes.cry-2 | eyes.trauma

teardrop-1.L | teardrop-2.L | teardrop-1.R | teardrop-2.R

sweat-1.L | sweat-2.L | sweat-1.R | sweat-2.R

Email : omabuarts@gmail.com

Website : https://omabuarts.com

Twitter : @omabuarts

Check out our BESTSELLER upgrade: [Quirky Series Ultimate Pack]

Website : https://omabuarts.com

Quirky Series - Animals Mega Pack Vol.1

Quirky Series - Animals Mega Pack Vol.2

Quirky Series - Animals Mega Pack Vol.3

Quirky Series - Animals Mega Pack Vol.4

Features

✅ Nine (9) animals pack

✅ Tiny 8x8 px texture [diffuse map only]

✅ Rigged/Skeleton

✅ 19 animations

✅ 4 Levels of Detail [min 300 up to 9k tris]

✅ Mobile, AR/VR ready

✅ Sample URP Shader included

❌ Vertex color

❌ Clean (non-overlapping) UV mapping

Animations

Attack | Bounce | Clicked | Death

Eat | Fear | Fly | Hit

Idle_A | Idle_B | Idle_C

Jump | Lay | Roll | Run | Sit

Spin/Splash | Swim | Walk

Blendshapes/Shapekeys:

eyes.blink | eyes.happy | eyes.sad | eyes.sad

eyes.annoyed | eyes.squint | eyes.shrink | eyes.dead

eyes.lookOut | eyes.lookIn | eyes.lookUp | eyes.lookDown

eyes.excited-1 | eyes.excited-2 | eyes.rabid

eyes.spin-1 | eyes.spin-2 | eyes.spin-3

eyes.cry-1 | eyes.cry-2 | eyes.trauma

teardrop-1.L | teardrop-2.L | teardrop-1.R | teardrop-2.R

sweat-1.L | sweat-2.L | sweat-1.R | sweat-2.R

Email : omabuarts@gmail.com

Website : https://omabuarts.com

Twitter : @omabuarts

Check out our BESTSELLER upgrade: [Quirky Series Ultimate Pack]

Website : https://omabuarts.com

Quirky Series - Animals Mega Pack Vol.1

Quirky Series - Animals Mega Pack Vol.2

Quirky Series - Animals Mega Pack Vol.3

Quirky Series - Animals Mega Pack Vol.4

Features

✅ Nine (9) animals pack

✅ Tiny 8x8 px texture [diffuse map only]

✅ Rigged/Skeleton

✅ 19 animations

✅ 4 Levels of Detail [min 300 up to 9k tris]

✅ Mobile, AR/VR ready

✅ Sample URP Shader included

❌ Vertex color

❌ Clean (non-overlapping) UV mapping

Animations

Attack | Bounce | Clicked | Death

Eat | Fear | Fly | Hit

Idle_A | Idle_B | Idle_C

Jump | Lay | Roll | Run | Sit

Spin/Splash | Swim | Walk

Blendshapes/Shapekeys:

eyes.blink | eyes.happy | eyes.sad | eyes.sad

eyes.annoyed | eyes.squint | eyes.shrink | eyes.dead

eyes.lookOut | eyes.lookIn | eyes.lookUp | eyes.lookDown

eyes.excited-1 | eyes.excited-2 | eyes.rabid

eyes.spin-1 | eyes.spin-2 | eyes.spin-3

eyes.cry-1 | eyes.cry-2 | eyes.trauma

teardrop-1.L | teardrop-2.L | teardrop-1.R | teardrop-2.R

sweat-1.L | sweat-2.L | sweat-1.R | sweat-2.R

Email : omabuarts@gmail.com

Website : https://omabuarts.com

Twitter : @omabuarts

• Texture Resolution: 2048 x 2048
• Texture Type: Seamless / Tileable
• File Format: .png
• Texture Maps Included: Albedo (Base Color), Normal, Height, Ambient Occlusion, Metallic, Smoothness, Edge Mask.

Moss Textures Pack contains seamless 2048x2048 textures with Ambient Occlusion, Edge, Height, Normal, Smoothness, and Metallic maps.

All maps are in .png format and fully optimized for mobile and low-spec systems, giving you great-looking results with minimal performance cost.

• 3 base color textures (512×512)
• UV-mapped models, ready for texturing
• 1 standard materials + 3 customizable color materials (Shader Graph-based)
• No LODs included
• Tested and optimized for Unity 6 (URP).

This asset is suited for crowd scenes, casual games, or as background characters for mid- to long-range views.

• 8 unique stylized low-poly characters.
• Each character comes with 4 prefab versions (one for each of the 4 included materials).
• All characters are Humanoid rigged(Non-rigged versions are also included for use with auto-rigging tools).
• Includes Shader Graph materials that allow customization of skin, hair, and clothing colors.
• Character models range from 528 to 582 triangles.
• Compatible with motion libraries such as Mixamo.
• No animations included.

All models are provided in T-pose.

Note:

• Due to the simplified geometry, it may not fully accommodate fine or highly detailed animations.
• Custom (Shader Graph) Materials: Designed for URP only.
• Standard Materials: These are simple texture-based materials and should work in the Built-in Render Pipeline, although they have been primarily tested in URP.

Series Compatibility:

This pack is designed to match the scale and overall style of the PolyPeople: CityPeople series. While some mesh details have been slightly adjusted for the Zombie theme, the overall aesthetic remains consistent—so you can mix and match them to build a seamless, unified world.

Unity Version

• Built with Unity 2021 LTS+
• Compatible with newer Unity versions (including Unity 6)
• Uses standard Unity components and APIs only

Render Pipeline

• Built-in Render Pipeline
• Universal Render Pipeline (URP) compatible
• HDRP compatible (no pipeline-specific shaders)

Platforms

• Windows
• macOS
• Linux
• WebGL
• Android
• iOS
• Console-ready (controller-friendly input setup)

Dependencies

• No third-party packages required
• Uses Unity Physics (Rigidbody-based movement)
• Uses UnityEvents for extensibility
• TextMeshPro used for HUD text (optional)

Input

• Keyboard & Mouse
• Gamepad / Controller support
• Uses Unity Input System–agnostic input handling
  (works with legacy Input Manager or Input System via mapping)

Architecture

• Modular, component-based design
• Event-driven systems using UnityEvents
• State-based movement logic for hero controller
• All gameplay systems decoupled and reusable
• Designed for easy extension and customization

Performance

• Optimized for real-time gameplay
• Physics interactions tuned for stable Rigidbody behavior
• Minimal per-frame allocations
• Uses non-alloc physics queries where applicable
• Gizmos and debug visuals only active in editor

Code Quality

• Clean, readable C#
• Namespaced under GolemkinGames
• One class per file
• Inspector-friendly with tooltips and headers
• No hard-coded scene references
• No static singletons required for core gameplay

Included Systems

• Rigidbody-based Superhero Controller
• State-driven third-person camera
• Event-driven audio controller
• Health & respawn system
• Combat and hit detection
• Destructible object framework
• NPC pedestrian controller
• NPC vehicle controller
• Bomb enemy AI
• Coin collectible system
• HUD (health and coins)

Animator Requirements

• Mecanim Animator supported
• Uses standard parameters:
  Float: Speed
  Bool: Grounded, Flying, Climbing
  Triggers: Jump, SuperJump, Fly, Fall, Land, Punch
• Animator Controller not included (character-agnostic)

Physics Requirements

• Rigidbody required on hero
• CapsuleCollider required for hero
• Colliders required for destructible objects and enemies
• Uses layer masks for:
  Ground detection
  Climbable surfaces
  Punchable targets
  Camera collision

Multiplayer

• Single-player focused
• Not networked out of the box
• Can be adapted for multiplayer with authoritative physics handling

Documentation

• Comprehensive inline code comments
• Scene gizmos for visual debugging
• Example setup instructions included in package

Package Contents

• C# source code
• Example prefabs
• Example demo scene
• No art, characters, or animations included

File Size

• Lightweight code-only asset
• Minimal footprint (no textures, meshes, or audio required)

SUPERHERO CONTROLLER is a complete, arcade-style superhero gameplay framework built for fast iteration and satisfying moment-to-moment movement. Designed around Rigidbody physics, it delivers responsive ground movement, massive charged jumps, smooth free-flight, wall climbing, punch-based combat, and cinematic landings—perfect for open-city superhero games, prototypes, or full productions.

This asset goes far beyond a basic character controller. In addition to the hero, it includes a full supporting ecosystem: pedestrian NPCs, traffic vehicles, destructible objects, bomb enemies, collectible coins, a HUD system, a third-person camera, and an event-driven audio controller. Drop it into a scene and start playing immediately.

Core Hero Features

• Walk, run, sprint, and responsive ground movement
• Charged Super Jump for leaping buildings
• Toggleable Flight Mode with acceleration, tilt, roll correction, and fast flight
• Wall climbing, wall jumping, and ledge mantling
• Punch-based combat with knockback and hit effects
• Health system with respawning and checkpoints
• Rigidbody-based physics for natural interactions

Movement States

The controller internally manages movement using a clean state system:

• Grounded
• Jumping
• Falling
• Flying
• Climbing

This makes it easy to extend or customize behavior for your own mechanics.

Combat & Destruction

• Box-based punch hit detection
• Damage, knockback, cooldowns, and hit VFX
• Fully featured Destructible System:
  Destroy
  Spawn debris
  Ragdoll
  Replace with destroyed prefab
• Health, invulnerability, effects, sounds, and events

City Sandbox Systems

Populate your world instantly with included NPC controllers:

Pedestrians

• Waypoint paths or free wandering
• Idle pauses and obstacle avoidance
• Optional fleeing behavior from threats

Vehicles

• Road waypoint driving
• Speed variation and corner slowing
• Obstacle and pedestrian detection
• Optional brake lights and wheel animation

Bomb Enemies

• Chase-and-explode enemy behavior
• Warning flashes and beeping
• Explosion damage, knockback, and VFX

Camera, HUD & Audio

• State-based third-person camera (ground, flight, climbing)
• Dynamic FOV based on speed
• Collision-aware camera system
• HUD with animated health bar and coin counter
• Fully event-driven audio controller for footsteps, flight, combat, and impacts

Events & Extensibility

Nearly every major action exposes UnityEvents:

• Jump, Super Jump, Land, Fly Start/End
• Climb Start/End, Wall Jump
• Punch, Speed Change
• Health Change and Death

Perfect for hooking in your own VFX, audio, UI, or gameplay logic without modifying core code.

Quick Setup

1. Add a Rigidbody and CapsuleCollider to your hero
2. Add SuperheroController
3. (Optional) Add Camera, HUD, and Audio controllers
4. Press Play

Defaults are tuned to feel good out of the box, with extensive inspector controls for fine-tuning.

Ideal For

• Superhero games
• Open city sandboxes
• Prototypes and vertical slices
• Arcade-style action games
• Physics-driven character gameplay

Included Scripts

• SuperheroController
• SuperheroCamera
• SuperheroAudioController
• SuperheroHUD
• Destructible
• PedestrianController
• VehicleController
• Coin
• BombEnemy

Number of textures: 33

Texture dimensions: 512 x 512, 1024 x 1024

Polygon count:

Bike1: 37.4k

Bike2: 50.1k

Bike3: 52.7k

Bike4: 42.7k

Bike5: 57.5k

Bike6: 37.7k

Bike7: 49.7k

Bike8: 46.1k

Bike9: 56.7k

Bike10: 58.9k

Bike11: 56k

Bike12: 51.4k

Bike13: 32.9k

Bike14: 37.3k

Bike15: 51.7k

Bike16: 36.3k

Bike17: 51.5k

Bike18: 47.6k

Bike19: 63.2k

Bike20: 39.3k

Bike21: 74k

Bike22: 59k

Bike23: 68.8k

Bike24: 61.5k

Bike25: 39.3k

Bike26: 50k

Bike27: 57.2k

Bike28: 67.8k

Bike29: 36.9k

Bike30: 48.9k

Bike31: 34.2k

Bike32: 62.1k

Minimum polygon count : 32.9k

Maximum polygon count: 74k

Number of prefabs: 32

Rigging: Yes

UV mapping: Yes

HQ Bikes Pack is a versatile collection of 32 detailed 3D motorcycle models, crafted for developers building bike racing games, open world games, bike simulation games, or other simulators.

This pack includes a wide variety of bike styles (vespa bikes, dirt bikes, racing bikes, sport bikes, naked bikes, chooper bikes and scifi futurisitic bike) allowing you to populate your game world with diverse vehicles without needing multiple assets. Each model features clean geometry, consistent scaling, and visually appealing materials suitable for modern game environments.

Whether you’re creating a fast-paced street racer, a sandbox driving game, or a casual mobile experience, this pack provides a ready to use solution that saves development time and enhances visual quality.

The bikes are designed with both visual fidelity and performance in mind, making them suitable for PC and mobile platforms.

The color of each bike is changeable and each 3D model had logical pivot points to animate. Each bike had separated Front Body, Back Body, Bike Stand, Front Wheel, Back Wheel, Bike Handle, some bikes have Needle for speed or rpm and some have Digital meter and each object had their logical pivot points for animation.

Models

• arch (40 tris)
• barrel (664 tris)
• bars (284 tris)
• bed (3184 tris)
• bowl (212 tris)
• brazier (940 tris)
• bucket (972 tris)
• cage 1 (2276 tris)
• cage 2 (2080 tris)
• ceiling 1 (2 tris)
• ceiling 2 (16 tris)
• chain (1152 tris)
• chest (1842 tris)
• crate (588 tris)
• door 1 (788 tris)
• door 2 (512 tris)
• door 3 (716 tris)
• doorway (220 tris)
• floor (2 tris)
• moulding (12 tris)
• pillar (86 tris)
• shackle (220 tris)
• staircase (32 tris)
• stool (268 tris)
• table (284 tris)
• tankard (956 tris)
• torch (844 tris)
• wall 1 (2 tris)
• wall 2 (4 tris)
• window (66 tris)

Textures (4096x4096, 2048x2048 or 1024x1024 depending on model size)

• 19 albedo maps
• 3 normal maps
• 1 emission map

Dungeon - Fantasy Environment by Holotna.

Create your own medieval dungeon where flickering torchlight reveals cold stone corridors, locked cells, and forgotten places beneath the castle.

Features

• 30 game-ready assets
• 1 demo scene

Shaders (Shader Graph)

• customizable colors

Visual Effects (VFX Graph - URP and HDRP only)

• fire

Performance Optimization

• all objects use the same shader
• all objects use only 1 material slot

Compatibility

• works in Unity 2022.3.16f1 and above
• supports URP, HDRP and Built-in
• suitable for games with a first-person, third-person or top-down perspective
• the demo scene is big and may not be suitable for mobile

This asset pack fits in perfectly with all of our other packs.

Join our Discord if you have any questions or suggestions.

Performance Notes

• Optional wave simulation for low-end devices
• Lightweight physics with no mesh-based water collision
• No third-party dependencies

Requirements

• Unity 2021.3 LTS or newer
• Rigidbody-based physics
• No additional packages required

Known Limitations

• Water detection is height-based, not mesh collision
• Procedural waves are not synced to visual water shaders
• Multiplayer is not included
• Character mounting is not included

Boat Controller is a complete, modular water vehicle system for Unity designed for arcade-style gameplay. It provides responsive boat movement, buoyancy physics, procedural waves, dynamic camera effects, aerial tricks, speed ramps, audio, and HUD components — all built with clean architecture and easy customization in mind.

This asset is ideal for speedboats, jetskis, futuristic watercraft, and arcade racing or exploration games where fun, control, and feel matter more than heavy simulation.

Core Features

Water Physics

• Spring-based buoyancy system with configurable float depth
• Water drag for natural deceleration and handling
• Procedural wave simulation affecting height and tilt
• Smooth transitions between water and air states
• Separate airborne physics with gravity scaling

Movement & Handling

• Throttle-based acceleration and braking
• Speed-responsive steering and turning
• Water grip system for controlling slide and drift
• Natural banking and leaning during turns
• Reverse movement with separate tuning values
• Jumping from water surface with forward boost
• Mid-air control and stabilization after jumps

Camera System

• Smooth follow camera with rotation tracking
• Wave motion compensation to reduce visual jitter
• Dynamic FOV scaling based on speed
• Speed-based camera distance and height adjustment
• Optional speed and impact camera shake

Speed Ramps & Boost Pads

• Multiple boost modes:
  Additive
  Multiplicative
  Set Speed
  Directional
• Optional vertical launch force
• Per-vehicle cooldown handling
• Visual pulse effects and audio feedback
• Editor gizmos for easy level setup

Trick System

• Front flips, back flips, and barrel rolls
• Height-based trick activation logic
• Trick chaining with score multipliers
• Auto-recovery when too close to water
• Fully event-driven scoring system
• Keyboard and gamepad input support

Audio System

• Engine sound with pitch and volume scaling
• Water spray audio based on speed
• Splash and splashdown effects
• Launch and landing sounds
• Brake and deceleration feedback
• Water enter and exit transitions

HUD System

• Speed display with configurable units
• Speed bar visualization
• Water vs airborne status indicator
• Throttle and brake feedback
• Optional wave height display

Core Features:

• ✅ Complete two-story cottage 3D model
• ✅ 1024×1024 resolution textures (PBR workflow)
• ✅ Demo scene with exploration capabilities
• ✅ First-person player controller included

Model Specifications:

• Total Polygons: ~ 8000
• Texture Resolution: 1024×1024 pixels
• Number of Materials: 23 main materials
• Model Formats: FBX, Unity Prefab

Texture Sets Included:

• Wall Textures: Wood/stone facade (Albedo, Normal, Roughness)
• Roof Textures: Tiled roof materials
• Detail Textures: Window frames, doors, trim

This package features a detailed two-story cottage 3D model complete with optimized 1024×1024 textures and a functional demo scene. Ideal for creating cozy villages, fantasy settlements, or rural game environments.

Package Includes:

• Two-Story Cottage Model - Complete building with interior space
• 1024×1024 PBR Textures - Optimized for performance without sacrificing quality
• Ready Demo Scene - Pre-configured environment with lighting
• Player Controller - First-person exploration system included

Perfect For:

• Village and hamlet environments
• Fantasy RPG towns
• Cozy simulation games
• Architectural prototyping
• Low-poly style projects

Model Specifications:

• Authentic cottage design with traditional elements
• Clear separation between floors
• Roof with visible timber details
• Windows and doors properly modeled

Ease of Use:
Simply import the package, open the demo scene, and see the cottage in action. The model is fully textured and ready to drop into any Unity project. Modify colors, adjust materials, or resize to fit your specific needs.

Educational Value:
Great for learning 3D environment setup in Unity, understanding PBR materials, or as a base for environment design tutorials.

This package is built with performance and extensibility in mind.

• Core Physics Engine:
  Uses Explicit Verlet Integration for stable, energy-conserving simulation without the instability of standard spring joints.
  Iterative Constraint Solver: Stiffness is controlled via iteration counts (constraintIterations), allowing you to balance between absolute rigidity and CPU budget.
  Time Step Independence: Physics calculations are locked to FixedUpdate to ensure deterministic behavior across different frame rates.
• Collision System:
  Zero-Allocation Checks: Utilizes Physics.OverlapSphereNonAlloc to prevent garbage collection spikes during collision detection.
  Continuous Collision Detection (CCD): Implements Physics.SphereCast between previous and current node positions to prevent "tunneling" through thin objects at high velocities.
  Terrain Optimization: Features a dedicated, lightweight height-check (Terrain.SampleHeight) for performant ground interaction without mesh collider overhead.
• Procedural Rendering:
  Dynamic Mesh Update: Rope meshes are generated procedurally using a dedicated RopeMesh class. Vertex arrays are pre-allocated and updated in LateUpdate to ensure smooth visual interpolation after the physics step.
  Render Pipeline Agnostic: Since the system generates a standard Unity Mesh, it is fully compatible with Built-in, URP, and HDRP (dependent only on the Material you assign).
• Advanced Raycasting:
  Does not rely on MeshColliders for raycasting (which would be slow to update every frame).
  Includes a custom Analytic Raycast system (VerletPhysics.Raycast) that performs mathematical Ray-Segment intersection tests against the simulation nodes. This is significantly faster than updating a physics mesh every frame.
• Architecture:
  Coupling: Rigidbody interaction uses AddForceAtPosition for accurate torque generation on connected bodies.
  Centralized Manager: A static registry (VerletPhysics) keeps track of active ropes for global queries.

Bring realistic physics to your game with the Advanced Verlet Rope System. Whether you are building a grappling hook mechanic, a physics-based puzzle, or simply need decorative hanging cables, this package provides a stable and performant solution based on Verlet Integration.

Unlike simple joint chains, this system simulates soft-body dynamics, allowing ropes to stretch, slack, and interact naturally with the environment. It comes with a powerful Two-Way Coupling feature: ropes don't just follow objects; they physically pull and interact with Rigidbodies based on mass and force settings.

🔥 Key Features

• Robust Verlet Physics: fast and stable simulation that handles gravity, air friction, and stiffness constraints without jitter.
• Bi-Directional Coupling: Connect ropes to Rigidbodies. Heavy objects pull the rope, and the rope can pull objects back. Perfect for cranes, winches, or character swinging.
• Dynamic Procedural Mesh: Generates smooth 3D meshes at runtime. Fully customizable radial segments (resolution), radius, and texture tiling.
• Advanced Collision Detection:
  Standard Colliders: Works with MeshColliders (convex/non-convex), Box, Sphere, and Capsule colliders.
  Terrain Support: Efficiently handles collisions with Unity Terrain.
  Self-Collision: Optional support for ropes colliding with themselves.
• Runtime Manipulation (API):
  Spawning: Create ropes dynamically using the RopeController.
  Connections: Branch ropes by connecting them to other ropes, transforms, or rigidbodies at runtime.
  Cutting/Resizing: Extend or shorten ropes, or cut them at specific nodes dynamically.
• Custom Raycasting: Includes a dedicated high-performance Raycast system (VerletPhysics.Raycast) to detect hits on thin procedural rope meshes accurately.

🛠️ How It Works

Simply add the VerletRopeGenerator component to an object, set your start and end points, and hit play. The system automatically handles the mesh generation and physics constraints. You can pin nodes to static or moving objects to create complex physical contraptions.

📦 Use Cases

• Grappling Hooks & Swinging Mechanics
• Physics Puzzles (Pulling bridges, levers)
• Industrial Simulations (Cables, wires, hoses)
• Decorations (Hanging vines, chains, power lines)

Technical Details

• Solver: Iterative Constraint Solver (Adjustable iterations for performance vs. quality balance).
• Rendering: Uses standard MeshRenderer (Compatible with Built-in, URP, and HDRP pipelines assuming standard materials are used).
• Source Code: Full C# source code included.

Take full control of your physics simulations today with Advanced Verlet Rope!

Requirements / Notes

• Uses built-in Unity systems only (no third-party dependencies).
• NavMesh option uses UnityEngine.AI (only needed if you enable NavMesh sampling).
• Editor tooling is included in an Editor/ folder (excluded from builds automatically).
• Compatible with any Render Pipeline (Built-in, URP, HDRP)

Wave Spawner System is a lightweight, data-driven framework for spawning enemy waves in Unity. It’s designed to be easy for designers to tune and easy for programmers to integrate — without hardcoding wave formulas.

Waves are configured using ScriptableObjects (EnemyDefinition + WaveDefinition), allowing you to control difficulty scaling through AnimationCurves for budget, duration, spawn rate, and optional caps. The spawner supports multiple spawn patterns and spawn shapes, making it suitable for arena games, survival modes, tower defense variants, and roguelike-style encounters.

To integrate cleanly into any project, the system exposes both C# events and UnityEvents (for non-coders), including wave start/end and enemy spawn notifications. It also includes optional boss waves, elite spawns, and special wave modifiers such as Rush, Tank, and Swarm, which apply configurable multipliers to your curves.

For performance, the system includes an optional lightweight pooling component (warmup + auto-expand). And for editor usability, it ships with a custom inspector featuring validation warnings and a one-click “Generate Next Wave Preview” that displays computed values and a seeded simulation of enemy counts.

Core Features

• ScriptableObject-based configuration
• EnemyDefinition: prefab, cost, weight, minWave/maxWave
• WaveDefinition: curve-driven scaling, allowed enemy lists, modifiers
  
• Curve-based difficulty scaling
• Budget curve (points per wave)
• Duration curve (seconds per wave)
• Spawn rate curve (spawns/second)
• Optional caps via curves (max enemies per wave, max alive at once)
• Optional spawn pacing curve (multiplier over wave progress)

Spawning System

• Spawn modes
• Round-robin
• Random
• Weighted random (optional SpawnPoint weight component)
• Closest to target / Farthest from target
• Outside camera / offscreen spawn (camera-aware)
• NavMesh-valid spawn (optional sampling)
  
• Spawn shapes
• Predefined spawn transforms
• Random point in box (Bounds)
• Ring around target (inner/outer radius)
  

Wave Variety

• Boss waves
• Boss every N waves
• Boss can spawn at start or end
• Optional “boss consumes budget”
• Boss spawns in addition to normal wave enemies
  
• Elite spawns
• Separate elite enemy pool
• Elite chance scales via curve and can occur on any wave type
  
• Special wave modifiers
• Rush (faster, shorter, lower budget)
• Tank (slower, fewer spawns, cost-biased toward expensive enemies)
• Swarm (faster, more spawns, cost-biased toward cheap enemies)
  

Integration Hooks

• C# events + UnityEvents
• OnWaveStarted(int wave)
• OnWaveEnded(int wave)
• OnEnemySpawned(GameObject enemy)
• OnAllEnemiesDefeated()
  

Performance (Optional)

• Lightweight pooling
• Pool warmup entries
• Auto-expand toggle
• Works with inactive-as-dead tracking for pooled enemies
  

Editor Tools

• Custom inspector
• One-click Generate Next Wave Preview
• Displays computed values (duration, budget, spawn rate, caps, elite chance, special type)
• Seeded simulation for repeatable preview counts
• Validation warnings (missing wave definition, enemies, spawn points, target/camera, pooling setup)
  

Technical Details / Key Features

• Automatic drop shadow generation for any GameObject with a SpriteRenderer
• Runtime-synced shadow sprite
  Shadow position and sprite update automatically every frame
• Configurable shadow offset (Vector2) for precise visual control
• Custom shadow color & opacity via SpriteRenderer.color
• Sorting layer & order control
  Adjustable sorting order difference relative to the main sprite
• Zero shader usage
  Pure C# solution, compatible with all render pipelines (Built-in, URP, HDRP)
• Lightweight & performant
  Creates a single additional SpriteRenderer per object
• Plug-and-play workflow
  Add the component and tweak values in the Inspector
• Safe initialization
  Uses [RequireComponent(typeof(SpriteRenderer))] to prevent misconfiguration
• Fully runtime compatible
  Supports sprite changes via code (SetSprite() included)
• Clean hierarchy management
  Shadow GameObject is automatically parented and named

Sprite Drop Shadow is a lightweight, plug-and-play Unity component that instantly adds clean, dynamic drop shadows to any SpriteRenderer. No shaders, no custom materials, no setup headaches, just add the component and get instant visual depth.

Designed for 2D games where readability and polish matter, this asset automatically creates and maintains a shadow sprite that follows your main sprite in real time, keeping everything perfectly in sync.

Whether you’re working on pixel art, stylized 2D or UI-like visuals, Sprite Drop Shadow helps your sprites stand out with minimal effort and zero performance stress.

✨ Key Features

• One-click setup – Add the component to any SpriteRenderer
• Automatic shadow management – Shadow sprite is created and updated for you
• Fully configurable
• Offset (X / Y)
• Shadow color & opacity
• Sorting layer & order control
• Always in sync – Shadow updates automatically when the sprite changes
• Lightweight & performant – No shaders, no extra draw logic
• Safe & clean – Shadow is parented and managed automatically

🎯 Perfect For

• 2D platformers
• Top-down games
• Pixel art projects
• Prototypes that need instant polish
• UI-style 2D elements that need depth

• Hybrid Audio Engine: Combines baked volumetric data (for expensive effects like Reverb/Echo) with real-time raycasting (for dynamic Occlusion/Diffraction) to maximize performance.
• Volumetric Baking: Automatically scans scene geometry to generate a 3D grid of acoustic data, assigning precise Reverb Time (RT60), Room Size, and Echo Delay to every point in space.
• Physics-Based Occlusion: Sounds don't just stop at walls; they are muffled realistically using dynamic LowPass filtering and volume attenuation based on wall thickness and material.
• Real-Time Diffraction: Simulates sound "wrapping" around corners and pillars using a volumetric source radius, preventing the unrealistic "instant cut-off" of standard raycasts.
• Indirect Path Finding: Detects open doorways or "holes" in the environment, allowing sound to travel down corridors and reach the player even without a direct line of sight.
• Acoustic Material System: Customizable AcousticMaterial assets allow you to define physical properties (Absorption, HF Brightness) for different surfaces like Concrete, Wood, or Carpet.
• Smart Source Radius: Differentiates between small sounds (footsteps) that are easily blocked and large sounds (explosions) that wash over obstacles.
• Editor Workflow Tools: Includes auto-fitting grids, visual debug gizmos (visualizing reverb heatmaps and raycasts), and exclusion zones for easy setup.

Acoustics Baker Pro is a hybrid audio engine for Unity that bridges the gap between static reverb zones and expensive real-time wave simulation. It combines volumetric baking (pre-calculating reverb and echo data into a 3D grid) with real-time raycasting (calculating occlusion and diffraction on the fly). This allows sound to behave physically—getting muffled behind walls, flowing through open doorways, and reverberating naturally based on room size and materials—without draining CPU performance.

Is it Customizable?

Yes, highly. The system is designed to be tuned for both performance and artistic intent:

• Custom Acoustic Materials: You define how surfaces sound. Create AcousticMaterial assets for "Concrete," "Wood," "Carpet," or "Alien Slime," adjusting:
  Absorption (0.0-1.0): How much sound energy is lost (controls Reverb Time).
  HF Absorption: How much "brightness" is lost (controls muffling).
• Baking Controls: You have full control over the generation process:
  Grid Resolution: Adjust probe spacing (e.g., 2.0m for performance, 1.0m for high fidelity).
  Layer Masking: Choose exactly which objects block sound or generate reverb.
  Exclusion Zones: Use AcousticModifier volumes to prevent probes from spawning inside solid geometry or specific areas.
• Source Tuning: Each AcousticSource can be tweaked individually:
  Source Radius: Make a "large" sound (explosion) wrap around corners easier than a "small" sound (footstep).
  Indirect Ray Count: Scale the quality of diffraction per sound source.

Suitable Genres

This package is particularly well-suited for genres where audio spatialization is critical to gameplay or immersion:

• Stealth & Tactical Shooters: Essential for gameplay where players need to know if an enemy is in the same room or the next one over. The diffraction system prevents the "wall-hack" hearing effect common in standard Unity audio.
• Horror Games: Creates claustrophobic atmospheres where dead-ends sound "dead" and large halls sound echoing. The real-time occlusion ensures monsters aren't heard through thick walls until they open a door.
• Immersive Sims & VR: Adds a layer of physical realism that grounds the player in the world. The volumetric reverb prevents the jarring "snap" transitions of standard Reverb Zones.
• Indoor/Outdoor Hybrids: Because it bakes data into a grid, it handles transitions from tight corridors to open outdoor spaces seamlessly without manual scripting.

• Real-Time Occlusion: Dynamically muffles sound (LowPass Filter + Volume) when objects block the line of sight, simulating realistic wall thickness.
• Zero-Setup Workflow: No baking, no scene scanning, no pre-calculation. Just add the AcousticSource component and assign your wall layer.
• Volumetric Diffraction: Simulates sound "wrapping" around corners using a source radius, preventing unnatural instant silence when a sound center is barely hidden.
• Indirect Path Simulation: "Smart" rays detect open doorways and gaps, allowing sound to travel down corridors to reach the player even without a direct visual line of sight.
• Dynamic Geometry Support: Because it relies on real-time physics, it works on moving platforms, opening doors, and destructible walls out of the box.
• Unity Audio Compatible: Works directly on top of the standard Unity AudioSource, making it easy to integrate into existing projects.

Acoustics Lite is a "plug-and-play" audio solution designed for projects that need realistic sound obstruction without the workflow complexity or memory overhead of baked systems. It focuses entirely on the AcousticSource component, which calculates occlusion and diffraction dynamically in real-time.

Is it Customizable? Yes. While it automates the heavy lifting, you can tune the physics for every sound source:

• Source Radius: Define the physical size of a sound. Make a "massive" boss scream wrap around corners easily, while a small "coin drop" is blocked by a thin pillar.
• Occlusion Sensitivity: Adjust how quickly sound muffles (Lerp Speed) and the minimum volume/frequency that bleeds through walls (simulating bass transmission).
• Performance Scaling: You can adjust the Direct Ray Count and Indirect Ray Count per source, allowing you to prioritize CPU for hero sounds while keeping background noises cheap.

Suitable Genres

• Procedural / Roguelikes: Since there is no baking, it works perfectly on levels generated at runtime.
• Stealth Games: Provides reliable audio cues for player hiding and enemy detection.
• Mobile & VR: The lightweight raycasting system is optimized to run efficiently on restricted hardware compared to full-wave simulation.
• Multiplayer FPS: Helps players locate opponents via sound without giving away unfair positions through walls.

Number of Models/Prefabs: 11/20

Number of Materials: 138

Texture Dimensions: 2048x2048

Number of Textures: 510 (Albedo, Metallic, Normal, Occlusion) for Built-In and URP

Number of Textures: 404 (Base, Mask, Normal, Subsurface Scattering) for HDRP

UV Mapping: Yes

Rigging: No

DevDen ArchViz Premium Edition (Realistic) is an enhanced and upgraded version of DevDen ArchViz Vol. 1 – Scotland. This environment features updated props, refined materials, and improved overall visual quality to deliver a more immersive architectural visualization experience.

The asset is fully compatible with Built-in, URP, and HDRP rendering pipelines, ensuring smooth and seamless integration into any Unity project. Experience the VR scene with greater clarity and realism using PC VR devices such as HTC VIVE and Oculus Rift.

All 3D models included in the scene are carefully customized and optimized, making them suitable for games, VR experiences, and architectural walkthroughs.

What’s Included

• Ready-to-use Demo Scene with baked lighting
• Fully explorable interior environment
• Optimized assets for VR and real-time performance

Features

• 100+ low-poly assets
• High-quality PBR textures compatible with Built-in, URP, and HDRP
• Realistic lighting setup
• Optimized for PC VR devices
• Optimized for game environments
• Clean, modular assets ready for customization

Props List

BALCONY

1. Balcony Carpet
2. Balcony Floor Cushion
3. Balcony Sofa Set
4. Balcony Tea Table
5. Balcony Plant Table
6. Flower Pots
7. Flower Pot Wall Holder
8. Flower Vase

BATHROOM

1. Bathroom Cupboard
2. Props Stand 1
3. Handwash
4. Powder Box
5. Soap with Holder
6. Toothbrush with Holder
7. Bathtub
8. Bathtub Glass Sliding Doors
9. Drying Hanger
10. White Cloth
11. Bathroom Carpet
12. Mirror
13. Shower Set
14. Toilet Set
15. Towel with Box
16. Washbasin
17. Washing Machine

BEDROOM

1. Bed
2. Pillow Sets
3. Dressing Table
4. Dressing Chair
5. Bed Side Table
6. Carpet
7. Cup and Saucer
8. Flower Vase
9. Mirror
10. Makeup Props
11. Table Lamps
12. Timer
13. Curtains
14. Ceiling Light
15. Air Conditioner
16. Wardrobe
17. Photoframes with Stand

DINING AREA

1. Ceiling Light
2. Wall Arts
3. Dining Table
4. Dining Chair
5. Side Table
6. Decor Set 1
7. Decor Set 2
8. Table Mat
9. Fruit Bowl
10. Plate
11. Tissue with Holder
12. Cutlery Stand

KITCHEN AREA

1. Induction Stove
2. Chimney
3. Oven
4. Sink
5. kitchen Cabinet
6. Fruit Basket
7. Oil Bottle
8. Bowls
9. Coffee Mugs
10. Chopping Board
11. Decor Set
12. Jar
13. Juice Jug
14. Spoon, Fork, Knife with mug
15. Plates
16. Sauce Pan
17. Serving Bowls
18. Sugar Box
19. Tea Kettle
20. Wine Bottles
21. Wine Glasses
22. Refridgerator
23. Cutlery Stand

LIVING ROOM

1. Decor Clock
2. Tea Table
3. Laptop
4. Wall Arts
5. Carpet
6. Curtain
7. Magazines
8. Mobile
9. Sofa Set with Pillows
10. TV
11. TV Remote
12. TV Panel
13. TV Cupboard
14. Air Conditioner

STUDY ROOM

1. Cupboards
2. Chair
3. Books with Stand
4. Pens with Holder
5. Globe
6. Computer Set
7. Photo Frames
8. Decor Plane
9. Flower Pots
10. Gold Button Award
11. Open Book
12. Open Pen
13. Rubik's Cube
14. Study Lamp
15. Victory Cup

ENTRANCE

1. Keys with Holder
2. Shoe Rack
3. Flower Vase
4. Male Shoes
5. Female Shoes
6. Boots
7. Travel Bag

COMMON

1. Electric Switches with Board
2. Electric Lamps
3. Windows 
4. Doors
5. Walls and Floors

Enjoy creating immersive architectural experiences—and if you find this asset useful, please consider leaving a rating on the Unity Asset Store. Your feedback is greatly appreciated!

Gmail - admin@devdensolutions.com

Website

Facebook

Youtube

LinkedIn

Instagram

Technical Details

• Engine version: Unity 2022.3 LTS
• Render Pipeline: URP
• Number of prefabs: 102
• Asset categories:
  Trees (Birch, Oak, Pine)
  Grass (thin, dense, tall)
  Bushes and flowers
  Rocks
  Mushrooms and forest props
  Water plants (lilies, cattails)
• Polygon count example:
  Birch tree LOD0: ~1990 triangles
  Birch tree LOD1: ~992 triangles
  Birch tree LOD2: ~396 triangles
• LOD support:
  Yes (LOD0, LOD1, LOD2)
  All assets include LODs except environment elements (skybox, water plane, mountains)
• Colliders:
  Optimized colliders included (e.g. capsule colliders for trees)
• UV mapping: Yes
• Textures:
  Total textures: 95
  Texture resolution: 2048x2048
  Texture types: Base Color, Normal Map
• Materials:
  Shared materials (typically used by groups of 2–6 assets)
• Rigging: No
• Animations: No
• Prefab ready: Yes
• Intended use: Real-time games and environments

Stylized Nature - Forest Biome is a handcrafted collection of stylized forest assets designed to quickly and efficiently create natural outdoor environments in Unity.

The pack includes a wide variety of trees (birch, oak, pine), grass types, bushes, flowers, rocks, mushrooms, and small forest details, allowing you to build rich and visually consistent forest scenes.

Assets are optimized for real-time use and suitable for games, prototypes, stylized worlds, and environment showcases. The art style works well for fantasy, adventure, survival, and casual game genres.

Most assets include multiple LOD levels for performance-friendly rendering. Materials and textures are shared across asset groups to reduce draw calls and memory usage.

This pack is ideal for developers and artists who want a ready-to-use stylized forest biome that looks good out of the box while remaining flexible for customization.