Asset Store newest packages

Unity Version:
Built and tested in Unity 2021.3 LTS
(Compatible with 2022+ and Unity 6 under Built-in RP)

Render Pipeline:
Built-in Render Pipeline (no URP/HDRP dependencies)

Input System:
Supports both Legacy Input and New Input System
(Default setup: one-click/tap control)

Platforms:
Windows, macOS, Android, iOS, WebGL

Dependencies:
None – no SDKs, ads, or third-party plugins required

Scripts Included:

• PlayerController – Orbiting movement & jumping with coyote-time
• LoopSpawner – Smart obstacle spawning and spacing
• Obstacle – Rotating obstacle logic with self-destruction
• GameManager – Score, UI, and game-over handling
• MenuManager – Start screen and best-score tracking
• CameraShake – Screen feedback on jump or death
• BackgroundParallax – Layered background rotation
• BackgroundColorPulse – Hue-shifting comic-style color cycle

Demo Scenes:

• MenuScene
• GameScene

Script Namespace:
SoloStudio54.SoloLoopRunner

Render Pipeline Compatibility:
✔ Built-in RP
✖ URP
✖ HDRP

Dive into the comic-book chaos of Solo Loop Runner, a fast-paced arcade template built around a vibrant, looping world!
Orbit, jump, and dodge your way through an endless pop-art arena packed with style, motion, and juicy feedback.

Designed for creators who want an instantly playable mobile game or a base to build upon, Solo Loop Runner combines clean, modular code with expressive visuals and classic one-tap gameplay.

Gameplay

• Tap to jump as your character orbits the circular world.
• Avoid rotating obstacles that slowly drift around the ring.
• Survive as long as possible to chase your best score.
• Increasing speed and rhythm turn every loop into a test of precision and timing.

Key Features

• One-tap controls, perfect for mobile or desktop.
• Circular movement system with radial gravity.
• Smart obstacle spawner with safe zones and spacing logic.
• Moving obstacles that orbit dynamically for constant tension.
• Smooth camera shake, trail, and color-pulse effects for juicy feedback.
• Parallax comic background with counter-rotation and hue shift.
• Menu, gameplay, and game-over flow with best-score saving.
• Fully commented C# scripts under the SoloStudio54.SoloLoopRunner namespace.
• 100% Built-in Render Pipeline, Unity 2021.3 LTS compatible.
• No ads, SDKs, or dependencies – pure gameplay.

Perfect For

• Developers who want to build or reskin mobile arcade games.
• Artists exploring pop-art, comic, or retro visual themes.
• Educators and students learning circular motion and radial physics in Unity.

Included

• 2 ready-to-play demo scenes (Menu + Game).
• Modular scripts: PlayerController, LoopSpawner, Obstacle, GameManager, CameraShake, and more.
• Pixel-clean UI with best-score tracking.
• Comic-style background artwork and color pulse FX.

Technical Details

• Unity Version: 2021.3 LTS or newer
• Render Pipeline: Built-in
• Input: New Unity Input System or legacy mouse/touch
• Platforms: Mobile & Desktop

Solo Loop Runner – fast, bright, and endlessly replayable.
Built by Solo Studio 54 for developers who want games that feel alive.

Unity Version 6000.0.58f2 or later

Programming Language C#

Dependencies TextMeshPro, Newtonsoft JSON

Architecture Event-driven, Manager-based

Localization English

Performance Object pooling, Batch processing,

Frame-budgeted event queue

Ultimate Stock Market Simulation Framework for Unity

Build your own real-time stock market world — complete with AI traders, social sentiment, and dynamic events.

Whether you're creating a serious financial simulator or a chaotic meme-stock adventure, this framework gives you the tools to make it real.

Start trading your virtual market today.

Overview

Ultimate Stock Market Simulation Framework is a complete and extensible financial simulation engine built with Unity.

It replicates a real-time trading environment — with order book mechanics, AI traders, dynamic news feeds, and narrative market events — making it ideal for:

• Financial & business simulation games
• Trading education or training apps
• AI trading experiments and backtesting prototypes
• Fintech visualization and marketing demos

Everything is modular, event-driven, and fully customizable.

Core Features

Real-Time Trading Engine

• Full order book mechanics (limit / market orders, partial fills, cancellations)
• Thread-safe order matching with coroutine-based parallel processing
• Configurable batch processor for high-frequency trading performance

AI Trader & Market Maker

• Multiple AI trader types: AITrader, SimpleCommandTrader, MarketMaker
• Realistic market participation, liquidity simulation, and command-based manipulation
• Fully extensible — add your own trading agents easily

Dynamic News & Social Media System

• Event-driven news articles and simulated social posts
• Influencers and sentiment-driven reactions
• Integrated with Scenario System for organic storytelling

Scenario & Event Framework

• JSON-defined narrative events (time, stock, or random triggers)
• Event actions: publish news, modify prices, post SNS, issue trader commands
• Full control of in-game macro events and crisis simulations

Character & Relic System

• Select trader archetypes (AntTrader, MemeTrader, etc.)
• Each character has unique trading traits
• Collect relics with gameplay bonuses (profit boost, fee reduction, early news)

Modular & Scalable Architecture

• Manager-based system with dependency-safe initialization
• EventManager for decoupled communication between systems
• Easy integration with your own UI, data, or gameplay extensions

System Architecture Highlights

• Event-Driven Architecture — clean Observer pattern communication
• Object Pooling — efficient reuse of SNS posts, order rows, and events
• Parallel Processing — each stock trades in its own coroutine
• Data-Driven Design — scenarios and company info via JSON and ScriptableObjects
• Expandable Modules — add new stocks, AI traders, or relics without modifying core logic

Includes full documentation with diagrams and an AI assistant guide for developers.

What’s Included

• Full C# Source Code
• Complete Trading Engine
• AI Trader System (3 base implementations)
• News + SNS Information System
• Scenario/Event System with JSON support
• Character & Relic Framework
• 25+ Modular UI Components
• Detailed Documentation & AI Assistant Guide (Markdown)
• Ready-to-run Demo Scenes

Extensibility Examples

Add a New Stock
Register via CompanyManager or VirtualAssetsGenerator — auto-populated in StockMarketSystem and UI

Add a New Scenario
Create a JSON file in /Resources/Scenarios/, define triggers (time / price / random) and actions

Add a New Character
Inherit from BasePlayerCharacter and implement InitializeTraits()

Add a New Relic
Inherit from Relic and implement ApplyEffect() / RemoveEffect()

Performance Optimizations

• BatchOrderProcessor: Groups and processes orders per frame
• EventBatchProcessor: Efficient event queuing and delivery
• Frame-Time Budgeting: EventManager caps to 8 ms per frame
• Coroutine-based Distribution: Smooth performance for 20+ stocks
• Object Pools: Minimized GC pressure during gameplay

Perfect For

• Game Developers – create realistic investment or trading games
• Educators – teach stock trading dynamics interactively
• AI Researchers – simulate trading agents or reinforcement learning environments
• Fintech Teams – prototype market behaviors or test UX flows

Documentation Included

Three developer-ready documents:

• PROJECT_OVERVIEW.md — Full system summary
• AI_ASSISTANT_GUIDE.md — AI-powered development guidance
• ARCHITECTURE.md — Architecture diagrams and dependency maps

Each includes initialization order, event flows, and modular extension points.

Requires Unity: 2022.3 LTS or newer (Unity 6 compatible)

Render Pipelines: Built-in, URP, HDRP

Platforms: Windows, macOS

Dependencies: None (NavMesh/Cinemachine optional)

Content: Runtime scripts, Editor tools, HUD, sample scenes & prefabs, documentation

Living Ecosystem lets you add a modular, terrain-aware, game-friendly ecosystem to Unity in minutes. Plants grow and propagate, animals act by role (Herbivore, Predator, Pollinator, Neutral), and emergent loops appear: pollinators visit plants (non-destructive) and linger, giving predators a natural window. Everything is driven by a simple Editor seeding workflow and a live HUD for monitoring.

Use cases

– Open-world/survival wildlife

– Builder/sandbox simulation

– Education/visualization (pollination, predator–prey cycles)

– Ambient life for exploration games

Key Features

– Flora: GrowthAgent with ageing, visual growth, seeding (radius + local density), optional pollination boost

– Fauna: AnimalAgent roles (Herbivore / Predator / Pollinator / Neutral), sense radius, interact distance, energy/hunger, reproduction, post-interact linger

– Pollinators: non-destructive plant visits that refill energy and ground flyers for a while (predator window)

– Editor Seeding: ratios and filters (height, skip underwater) for one-click population

– HUD: multi-camera grid with overlays (role, energy, age, reproduction timers); toggle via hotkey

– Terrain Awareness: min/max height and water level respected by seeding

– Clean Prefabs: plug-and-play plant/animal prefabs with tiny trigger colliders

What’s Included

– Runtime: GrowthAgent, AnimalAgent, PollinatorEmitter, HerbivoreEmitter

– Editor: Terrain (height/water), Flora & Fauna lists, Seeding tools

– HUD: multi-camera grid and overlays

– Sample scenes: Archipelago, Plains, Valley

– Docs: full website (MkDocs Material) + quick start

Quick Start

1. Open Terrain, set Min/Max Height and Water Level, then Generate.
2. Prepare prefabs: add GrowthAgent to plants and AnimalAgent to animals (keep a small trigger collider on the root).
3. In Flora/Fauna, add prefabs and set ratios/counts; enable Skip Underwater.
4. Click Spawn, press Play, toggle the HUD to monitor.

Technical Details

– Unity: 2022.3 LTS or newer (tested on Unity 6)

– Render Pipelines: Built-in, URP, HDRP (gameplay scripts only)

– Dependencies: none (NavMesh optional; Cinemachine optional)

– Platforms: Windows, macOS (editor + standalone)

– Performance: proximity queries; keep sense radius reasonable; HUD cameras are the biggest GPU cost

Notes

-Some screenshots and demo setups may use third-party or free sample assets

(such as vegetation, characters, or skyboxes) for illustration only.

These third-party assets are NOT included in the package.

Please import your own assets or the original free packages separately

according to their licenses. Example video shows how to use prefabs.

-This is a game-friendly ecosystem (not a scientific model). Parameters are exposed for stability and readability.

Support & Docs

Documentation

Email: info@pixitgames.com

Changelog

v1.0.0 — Initial release: flora growth/seeding, fauna roles (Herbivore/Predator/Pollinator/Neutral), editor seeding, HUD.

• Editor-only; zero runtime impact
• Unity 2021.3+ (tested 2022.3 & 6000.x)
• SRP support: Built-in, URP, HDRP
• No package dependencies (no TMP/Addressables/etc.)
• Auto-create RuleSets from folder contents
• Checks: required scripts/assets/prefabs, namespace prefix/regex, folder→namespace mapping
• Ignore globs for paths & filenames (**/ThirdParty/**, *.gen.cs, etc.)
• Exports findings: JSON / Markdown / TXT + summary
• System Structure Manager: preview + dry-run, collision-safe moves, multi-level undo
• Writes only to ProjectReports/ and Assets/Validation (idempotent)
• Safe defaults; ping/copy helpers; menu under Tools → TDG

TDG Validation V1 is an editor-only toolkit to keep your project tidy and consistent.

Scan your Systems, auto-create or edit RuleSets, validate required scripts/assets/prefabs, enforce folder→namespace conventions, and export findings as JSON/Markdown/TXT.

Includes a System Structure Manager to create standard subfolders and safely move selected assets with preview, dry-run, and multi-level undo.

Why use it

• Catch missing files and namespace mismatches early
• Keep large teams/projects organized
• Produce shareable validation reports

How it works

1. Create RuleSets (auto-create or manual).
2. Run Validate All or Validate Selected.
3. Review findings; export reports or fix with your IDE.
4. (Optional) Use the Structure Manager to normalize folders.

Compatibility

• Unity 2021.3+ (tested 2022.3 & 6000.x)
• Built-in/URP/HDRP
• Editor-only; no runtime code; no package dependencies

Output & Paths

• Reports in ProjectReports/
• RuleSets under Assets/Validation/RuleSets
• Optional TDG docs under Assets/TDG/...

Technical details (key features)

• Editor-only validation; zero runtime impact
• Auto-create RuleSets from folder contents
• Checks: required scripts/assets/prefabs, namespace prefix/regex, folder→namespace mapping
• Ignore globs for paths & filenames
• Exports: JSON / Markdown / TXT + summary
• System Structure Manager with preview, dry-run, collision-safe moves, multi-level undo
• Works with Built-in/URP/HDRP; Unity 2021.3+
• No dependencies (no TMP/Addressables/etc.)
• Writes to ProjectReports/ and Assets/Validation only

Support: info@tdggamingstudio.com

Batch replace Mesh Filters and Mesh Colliders in scenes.

One-click replacement of mesh references.

Compress to another format.

Custom editor panel.

Fast decompression at runtime.

Scene preview after replacement.

Original meshes excluded from the build.

Supports Unity 2019.4+ and WebGL.

Unity Mesh Compression Plugin

A high-performance mesh compression plugin built specifically for Unity WebGL projects, with a focus on China's mini-game market. Proven through extensive testing: compress 8K meshes down to 2K, and 200K assets down to 50K. Large meshes achieve a stable 30% compression rate, while smaller meshes see even greater efficiency. Effectively reduces game asset size by 30-75%, drastically improving download speed and reducing bandwidth costs.

• Dedicated Support: Exclusively for Unity 2019.4 and above, with deep optimization for the WebGL platform.
• Simple Integration: Features one-click installation and a user-friendly configuration window. Get started without writing any code.
• Out-of-the-Box: Once imported, enable compression with a single click for your MeshFilter and SkinnedMeshRenderer components.
• Native Support: Fully compatible with the Built-in Render Pipeline, ensuring maximum stability in WebGL environments.

How It Helps Your Project?
This plugin is the ultimate solution for bloated Unity WebGL build sizes. It directly helps your game meet the strict size limits of platforms like WeChat Mini-Games, enabling instant loading times and significantly improving user retention.

Tested On:

• Unity Version: Unity 6000.0.50f1

Configuration:

• Configurations are stored in `PrefabSpawnerConfig` ScriptableObjects.
• Create new config via:
• Tools > CreepyTools > Prefab Spawner Manager > "Create New Config"
• Or - Assets > Create > CreepyTools > Prefab Spawner Config
• Or - Alt + Right-Click in editor > Open Manager > "Create New Config"

Workflow Example:

• Open Prefab Spawner Manager.
• Tools > CreepyTools > Prefab Spawner Manager
• or - Alt + Right-Click in editor > "⚙️Manage"
• Create categories such as "Environment", "Enemies", "Props".
• Drag & drop prefabs from the Project Window
• Spawn prefabs directly in Scene View, using the spawner menu Alt + Right-Click.
• + Additional Features:
• Assign hotkeys for your most-used prefabs
• Assign Custom Thumbnails/Icons
• Adjust Spawn Scale per prefab
• Adjust Color per Category
• Batch Selection Tools (by prefab root or layer)
• Add Prefabs (Advanced) (by layer, name contains/excludes, tags, folder scan, automatic search in Assets or open scenes).

Prefab Spawner Pro helps you ORGANIZE, MANAGE, and SPAWN PREFABS anywhere, directly inside the Unity Editor.

It provides category-based prefab management, quick-search functionality, and fast in-editor prefab spawning via a dedicated scene menu.

Currently, this is an early release (beta), primarily focusing on 2D projects. We are actively working on improvements and greatly value your feedback.

If you encounter any issues, please contact us directly on our Discord or check out our Website. We're quick to address bugs and release updates.

❤️ We appreciate your feedback and look forward to hearing your suggestions for new features in the next release!

This tool lets you create games in the style of The Stanley Parable or moral dilemma experiences – all without writing a single line of code. Simply add triggers and features to your scene and start building the story-driven game of your dreams.

Demo Game
Try it here: https://mrsticks.itch.io/naratorstoryengine

Includes:

• The Narrator Story Engine
• A complete demo game scene
• First-person controller
• Fully furnished 3D office environment
• In-game tutorial with examples

Video Demo (Spoiler)

https://youtu.be/rJCsCQ5koIo

Video Tutorial/Examples

https://youtu.be/FuGW7BXgZOs

Play the Demo in the Browser

https://mrsticks.itch.io/naratorstoryengine

Unity Compatibility

• Editor: 2021.3.45f2
• Build: Mono & IL2CPP
• Platforms: Windows/Mac/Linux Standalone, iOS, Android
• Render Pipelines: RP-agnostic (UI only, Screen Space – Overlay)
• Input: Mouse & touch (Unity UI/EventSystem)

Dependencies

• TextMeshPro (built-in).
• No third-party packages. No services required.

Code & Architecture

• Namespace: SoloStudio54.SoloIdleClicker
• Modular components (no monolithic managers)
• Event-driven refresh (GameEvents.OnRebirth)
• ScriptableObjects for items (ShopItemDef)
• Clean C# with summary comments; plug-and-play components

Core Systems

• GameApp + GameState (currency, CPS, tap power, lifetime, prestige)
• IdleTickSystem (CPS ticks, pop aggregation)
• TapSystem / TapButtonView (serve button)
• ShopSlotView (cost scaling, unlocks, ETA, milestones, instant save)
• ShopRowAdCapSkin (AdCap-style icon/label/progress bar)
• RebirthSystem (Franchise; tuned curve + min gate; +8%/star)
• ProductionRecomputeOnBoot (authoritative CPS rebuild on boot/rebirth)
• UX: PopTextManager/PopText, ButtonPunch, pause overlay helpers

Prestige (Franchise)

• Defaults: Base 100,000, Power 0.55, Min Lifetime 50,000Points: floor((Lifetime / Base)^Power)
  
• Bonus: GlobalMultiplier = 1 + stars * 0.08
• Rebirth wipes owned levels; lifetime persists

Shop & Milestones

• Cost: geometric (baseCost * multiplier^level, default 1.15)
• Milestones: default levels 10/25/50/100/200, multiplier ×2 each
• Exact delta CPS applied on purchase (pre/post milestone aware)
• Unlocks: by lifetime and optional dependency

Save & Persistence

• PlayerPrefs JSON via JsonUtility
• Schema: currency, ips, tapPower, lifetimeEarned, prestigeBank, itemLevels[]
• itemLevels: list of { id, level } (dictionary-free)
• Autosave every few seconds + on buy/pause/quit
• Hard reset utility included

Offline Earnings

• Configurable cap (hours), multiplier, optional prestige scaling
• Grants on resume; ignores micro-absences
• Separate timestamp key; cleared by hard reset

Performance

• Idle tick accumulator (default 10 Hz)
• UI refresh cadence ~0.12s (low GC)
• No per-row coroutines; no reflection in tight loops
• Pop texts are lightweight instantiates (pooling not required; trivial to add)

UI/Art

• TMP UI; icon-ready item rows
• Works with 250×250 sprites; palette/theme easily swapped
• Safe for varied aspect ratios; screen-space overlay

Extensibility

• Bulk buy (×1/×10/×100/MAX) helpers included (optional)
• Easy to add items (duplicate ShopItemDef and a row)
• Hooks for SFX, achievements, ads/IAP, localization
• Serializer can be swapped (e.g., JSON .NET) if desired

Limitations

• No cloud save out of the box
• No localization framework bundled (strings are UI/TMP-driven)
• Single-player; no networking

Support

• Clear entry points: GameConfig, ShopItemDef, scene rows
• Commented scripts; minimal magic; ready to reskin and extend

Solo Idle Clicker Template (AdCap-style)

A production-ready idle/clicker foundation with a fast-food theme and Adventure-Capitalist-style shop rows. Clean C#, ScriptableObjects, tuned prestige, milestones, autosave, and offline earnings. Drop in your art, tweak a few ScriptableObjects, and ship.

Features

• Tap + CPS loop with clear UI and number formatting
• Shop rows with cost scaling, lifetime/dependency unlocks, and time-to-afford ETA
• Milestones at 10/25/50/100/200 (configurable), exact delta CPS math
• Prestige/Franchise with tuned curve and minimum lifetime gate
• Offline earnings with cap and multiplier (optional prestige scaling)
• Autosave on purchase, pause overlay, hard reset utility
• Modular C# components, data-driven items, TextMeshPro UI

Technical

• Unity 2021.3 LTS+; Built-in/URP/HDRP (Screen Space – Overlay UI)
• Desktop and mobile; no third-party packages beyond TextMeshPro

Notes

• Placeholder sprites included for demonstration. Replace with your art for release.

How It Works
-----------
* References To: Uses AssetDatabase.GetDependencies to find outgoing links.
* Referenced By: Scans textual assets (.prefab, .unity, .mat, .anim, .controller, .asset, etc.) and finds where the GUID is used.
This dual approach is fast and avoids the overhead of building a permanent dependency cache.

Limitations
-----------
* Only direct references are shown. (Transitive chains require recursive scan for References To.)
* Works on YAML/text-based assets. Binary-only references may not be detected.
* String-based loads (Resources.Load("name"), Addressables keys/labels) are not detected.
* Deleted or broken GUIDs in YAML will still appear as broken links.

Unlike full-project indexers, this tool works on-demand and scans only your project assets — giving you instant and accurate results without heavy caching.

Features
------------------

Find References To: See which assets your selected file depends on.
Find Referenced By: Discover which assets in your project reference the selected file.
Fast, Cache-Free: No heavy indexing; works directly on asset files.
Scope Control: Limit search to selected folders or scan entire Assets/.
Clear UI: Dependencies are shown with asset icons and colored labels.

In Unity URP 2D, implementing background distortion is usually challenging. The traditional method using _CameraSortingLayerTexture is not robust and may be incompatible with newer Unity versions.

MaskDistortionEffect solves this by employing a double-camera technique:

1. A second camera is set up to render the background separately.
2. This camera outputs to a Render Texture, capturing the background content.
3. The Render Texture is then passed to the distortion shader graph as a texture input.
4. The shader graph samples the Render Texture and applies distortion effects based on mask textures and shader parameters such as strength, speed, and tiling.

This approach ensures robust, high-quality background distortion effects that are fully customizable and compatible with URP 2D. It avoids limitations of older methods, maintains compatibility with future Unity updates, and offers flexibility for a wide range of 2D game genres.

MaskDistortionEffect is a customizable URP 2D shader package that includes six mask-based distortion effects: Waterfall, Ripple, Magnifier, Swirl, Glass, and Pixelate. 

All effects are fully adjustable via exposed shader parameters such as strength, speed, tiling, and mask texture. 

This package is ideal for a variety of genres, including 2D platformers, puzzle games, visual novels, and UI design, allowing developers to easily enhance visuals, create magical effects, and add dynamic background distortions without writing shader code.

Number of textures: 20

Texture dimensions: 4K

Polygon count of Character: 49 895

Number of meshes: 5

Number of prefabs: 5

Rigging: Yes

Animation count: 24

UV mapping: Yes

LOD information: No.

Types of materials and texture maps: PBR

Features:

• Non-customizable materials.
• Weapon included.
• FPS Arms included.
• SRP, URP, HDRP Support.
• PBR Materials, 4K Textures.

Includes Animations (24):

• Idle (x1)
• Walk (x8)
• Run (x3)
• Hit Reactions (x4)
• Crouch (x8)

Polycount of Character:

• Tris: 49 895
• Verts: 29 879

Polycount of FPS Arms:

• Tris: 29 724
• Verts: 17 220

Polycount of Weapon:

• Tris: 9 774
• Verts: 9 153

• One-click MCP server setup - No Node.js installation required

• 187+ Unity manipulation tools via natural language

• Built-in Node.js runtime for all platforms (Windows/Mac/Linux)

• WebSocket communication between Unity and AI platforms

• Real-time Unity scene manipulation

• GOAP AI system with natural language behavior definition

• Support for Claude Desktop, ChatGPT, and other MCP clients

• Comprehensive project analysis and automation tools

• No external dependencies - everything included

The Future of Unity Development is Here

Transform Unity with AI-powered natural language control. Simply describe what you want in plain English - Synaptic Pro handles the rest. With 187+ professional tools and true one-click setup, create games 10x faster.

Why Developers Choose Synaptic Pro

"Finally, an AI tool that actually works out of the box!"

"The GOAP system alone is worth the price"

Unlike competitors requiring Node.js installation, terminal commands, and JSON editing:

• Node.js Pre-Installed: Everything included in the package

• Automatic Configuration: AI platforms detected and configured instantly• Zero Manual

Setup: Click "Complete MCP Setup" → Click "Start AI Connection" → Done!

• 60 Seconds to Productivity: From import to creating - verified by users

187+ Professional Tools - More Than All Competitors Combined

GameObject & Scene Management (15 tools)

Create, transform, duplicate, organize - all through natural language

Advanced UI Systems (16 tools)Complete UI from descriptions: "Create an RPG inventory with 5x5 grid and tooltips"

Visual Effects Suite (24 tools)

Post-processing, particles, screen effects with auto-generated shaders

Cinematic Weather System (11 tools)

Movie-quality weather: "Create a thunderstorm with lightning and wind"

3D Audio Revolution (15 tools)

Spatial audio, adaptive music, reverb zones, real-time visualization

AI Behavior Systems (13 tools)

Natural language GOAP, behavior trees, pathfinding, ML agents

Animation & Timeline (11 tools)

Procedural animations, timeline control, blend trees

Development Tools (24+ tools)

Batch operations, profiling, debugging, project analysis

[Full tool list in documentation]

Game-Changing Exclusive Features

Natural Language GOAP

World's first plain English AI behavior system:

"Create a guard that patrols between waypoints, investigates

disturbances, calls for backup when health drops below 30%"

No state machines. No behavior trees. Just describe and deploy.

Smart Shader Protection

Never see pink materials again:

• Automatic pipeline detection (URP/HDRP/Built-in)

• Instant fallback shader generation

• Zero shader knowledge required

Unified Weather System

Professional weather in one command:

• 5 cinematic presets with smooth transitions

• Performance-optimized particles

• Atmospheric scattering and fog

• Wind zone integration

Real Examples from Real Developers

Basic Commands:

"Create a red cube at position 0,5,0"

"Add post-processing with bloom and depth of field"

"Generate 50 pine trees randomly on terrain"

"Create a health bar UI in the top left corner"

Advanced Magic:

"Create a complete third-person controller with sprint, jump, and climb mechanics"

"Build an enemy spawner that increases difficulty every 30 seconds"

"Setup a day-night cycle lasting 10 minutes with appropriate lighting"

"Generate a complete main menu with settings, save/load, and transitions"

Honest Comparison

| Feature | Synaptic Pro | Competitor A | Competitor B |

|-----------------------|------------------|--------------|--------------|

| Total Tools | 187+ | 45 | 28 |

| Setup Time | 60 seconds | 2+ hours | 30+ minutes |

| Node.js Required | No (Included) | Yes (Manual) | Yes (Manual) |

| Natural Language GOAP | Exclusive | No | No |

| Weather System | Complete | Basic | None |

| Auto Shaders | Yes | No | No |

| Price | $55 Early Access | $89 | $129 |

Perfect For

• Solo Developers: Ship games 10x faster

• Studios: Standardize AI-assisted workflows• Beginners: Learn Unity through doing

• Professionals: Eliminate repetitive tasks

• Artists/Designers: Create without coding

Early Access Benefits

$55 $79 - Save 30% (Limited Time)

- All 187+ tools included

- Lifetime updates

- Priority Discord support

- Commercial license

- Source code access

- Beta access to new features

Price increases to $79 after first 500 sales

Roadmap

v1.1 (April 2025)

• Visual scripting integration

• Multiplayer networking tools

• Mobile optimization suite

v1.2 (July 2025)• VR/AR specialized tools

• Cloud collaboration

• Custom tool SDK

Technical Requirements

• Unity 2022.3 LTS or higher

• Windows 10/11, macOS 10.15+, Linux Ubuntu 20.04+

• 4GB RAM (8GB recommended)

• 500MB disk space

What's Included

• Complete MCP integration system

• All 187+ tool implementations• Automatic setup wizard

• 50-page PDF documentation

• 10 example projects

• Discord community access

Risk-Free Purchase

• Verified by Unity Asset Store

• Regular updates

• Responsive support

Join the AI Revolution

Don't waste months on repetitive tasks. Let AI handle the implementation while you focus on creativity. With Synaptic Pro, you're not just buying tools - you're buying time, efficiency, and creative freedom.

Get Started in 60 Seconds

1. Import package

2. Click setup button

3. Start creating with AI

Transform your Unity workflow forever.

[Get Early Access - Save 30%]

---

Synaptic Pro - Where Natural Language Meets Game Development

Technical Details

• Native Android driver connecting Vuforia with external USB cameras
• Easy Unity integration (single setup script included)
• Works on Android devices with USB OTG support
• compatible with Vuforia’s Image tracking system

If you have any issues, please contact us:

skangogames@skangogames.com

This plugin is a native Android driver that lets you connect external USB cameras directly to Vuforia in Unity. It is designed for developers who need to extend beyond the built-in mobile camera and integrate higher-quality or specialized cameras into their AR projects.

The package is lightweight, easy to install, and requires only one Unity script for setup. It supports any Android device with USB OTG and is fully compatible with Vuforia’s image tracking system. Developers can use it for AR apps in various fields—education, retail, industrial training, prototyping, and more.

The solution is not genre-specific and can be customized to fit your own Unity projects. It’s ideal for anyone who wants better control over AR experiences by improving camera quality, enabling wider fields of view, or connecting custom camera hardware.

Android is a trademark of Google LLC.

• Requirements: Unity 2022.3 LTS+; DOTween 1.2.x. Optional: 2D Sprite Editor package (for spritesheet slicing in editor).
• Supported targets: Transform/RectTransform, UnityEngine.UI.Image & SpriteRenderer, CanvasGroup, ParticleSystem.
• Pipelines: Built-in/URP/HDRP agnostic (animation-only, no shaders).
• Performance: DOTween pooled tweens; duration-driven updates; controllers avoid per-frame allocs; editor slicing uses AssetDatabase only.
• Inspector UX: targets on top; collapsible channels; events foldout (closed by default); bottom test buttons; drag-and-drop for Children/Sprites.
• Ownership model: first controller wins per property (Position / AnchoredPosition / Rotation / Scale / Sprite / Alpha / Particles) with skip warnings.
• Timing: Delay (component-wide), Stagger (per target), loops (−1 = infinite). Speed control is orchestrator-only (hidden on controllers).
• Included: runtime & editor asmdefs.
• Known limits: Anchored moves require RectTransform; Sprite restore on Stop(Reset) not automatic by design; infinite loops never fire onComplete.

• Orchestrator: Sequence/Parallel, nesting, computed duration, speed cascade.
• Controllers: Transform, Move From→To, CanvasGroup (alpha + interactable/raycast), Sprite Sequence (array/spritesheet), Toggle/Destroy, Particle Action (Play/Stop/Clear).
• Workflow: per-channel ease (or custom curve), multi-target + stagger, first-writer property ownership, events (start/complete/skip), inspector buttons (Play/Pause/Stop/Restart), drag-to-add (Children/frames), tidy foldouts.
• Design: no ScriptableObject lock-in; add components as needed; clear errors/warnings.

SYSTEM ARCHITECTURE

-------------------

• Editor Window Extension (EditorWindow)

• Reflection-based Unity API access for maximum compatibility

• SerializedObject manipulation for property preservation

• Asset Database integration for file management

• Scene management with hierarchy traversal

• Material shader mapping system

• Component conversion with property transfer

CONVERSION METHODOLOGY

----------------------

MATERIAL CONVERSION:

  • Stores all material properties before shader change

  • Maps properties between URP and HDRP shaders

  • Preserves textures using SerializedObject

  • Handles material variants with parent relationship

  • Supports custom shader assignment

  • Property name mapping: _BaseMap, _MainTex, _Color, etc.

DECAL CONVERSION:

  • Detects DecalProjector components (URP/HDRP specific)

  • Converts material first, then recreates component

  • Transfers all properties: size, rotation, fade, scale mode

  • Handles ShaderGraph decals and legacy decals

  • Preserves hierarchy and transform data

  • Scale mode enum name matching for reliability

LIGHTING CONVERSION:

  • Light intensity adjustment ratio: 10x multiplier

  • HDRP → URP: Divide intensity by ratio

  • URP → HDRP: Multiply intensity by ratio

  • Ambient intensity: 0 for URP, 1 for HDRP

  • Skybox assignment with default fallback

  • Environment lighting mode set to Skybox

EMISSIVE MATERIALS:

  • HDRP → URP: Divide emission by 10 (if > 5)

  • URP → HDRP: Multiply emission by 10 (if 0.01-5 range)

  • Physical units (HDRP) vs arbitrary values (URP)

  • Preserves emission color and intensity relationship

VOLUME PROFILE CONVERSION:

  • Converts Exposure, Bloom, Tonemapping, Color Adjustments

  • Maps volume override components between pipelines

  • Preserves parameter values and override states

  • Handles missing components gracefully

  • Creates new profiles if needed

SHADER MAPPING

--------------

URP SHADERS:

  • Universal Render Pipeline/Lit

  • Universal Render Pipeline/Simple Lit

  • Universal Render Pipeline/Unlit

  • Shader Graphs/Decal

  • Legacy Shaders/Decal

HDRP SHADERS:

  • HDRP/Lit

  • HDRP/Unlit

  • HDRP/Decal

PROPERTY MAPPING:

  • _BaseMap (URP) ↔ _BaseColorMap (HDRP)

  • _BaseColor (URP) ↔ _BaseColor (HDRP)

  • _Metallic (URP) ↔ _Metallic (HDRP)

  • _Smoothness (URP) ↔ _Smoothness (HDRP)

  • _EmissionColor (both)

  • _BumpMap (both)

ASSET MANAGEMENT

----------------

• Duplicate scene with GUID remapping

• Organized folder structure creation

• Material renaming with pipeline suffix

• Texture and asset dependency tracking

• Automatic asset database refresh

• Settings folder for pipeline assets

ERROR HANDLING

--------------

• Try-catch blocks for all critical operations

• Detailed console logging with emoji indicators

• EditorUtility.DisplayDialog for user feedback

• Graceful degradation for missing components

• Validation before conversion operations

• Undo support for reversible operations

PERFORMANCE OPTIMIZATION

------------------------

• Batch material conversion for efficiency

• Progress bar updates for user feedback

• Asset database refresh optimization

• Delayed execution for timing-sensitive operations

• HashSet for processed asset tracking

• Efficient scene traversal algorithms

API USAGE

---------

• UnityEditor namespace for editor functionality

• UnityEngine.Rendering for pipeline detection

• System.Reflection for dynamic type access

• AssetDatabase for file operations

• EditorUtility for dialogs and progress bars

• SceneManagement for scene operations

• SerializedObject for property manipulation

COMPATIBILITY

-------------

• Unity 6+ (optimized for latest version)

• Universal RP package required for URP

• High Definition RP package required for HDRP

• Windows, Mac, Linux editor support

• No runtime dependencies (editor-only tool)

CODE STRUCTURE

--------------

• Single C# file: NullMigrationHelper.cs (~5700 lines)

• Assembly definition for proper compilation

• Organized into logical sections:

  - UI Drawing methods

  - Conversion methods

  - Pipeline activation methods

  - Troubleshooting methods

  - Utility methods

  - Asset management methods

SAFETY FEATURES

---------------

• Optional scene duplication before conversion

• Backup folder support

• Undo system integration

• Validation checks before operations

• Confirmation dialogs for destructive actions

• Detailed logging for troubleshooting

EXTENSIBILITY

-------------

• Modular method structure for easy updates

• Reflection-based approach for future Unity versions

• Custom shader support for user extensions

• Procedural design with no hardcoded project paths

• Clear code documentation for modifications

OVERVIEW

--------

Null Migration Helper is the ultimate solution for Unity developers who need 

to convert their projects between Universal Render Pipeline (URP) and High 

Definition Render Pipeline (HDRP). Whether you're upgrading to HDRP for 

better graphics or downgrading to URP for broader platform support, this tool 

handles the complex conversion process automatically.

KEY FEATURES

------------

✓ BIDIRECTIONAL CONVERSION

  • Full support for both URP → HDRP and HDRP → URP conversion

  • All features work in both directions

  • Reversible conversions with consistent results

✓ COMPREHENSIVE SCENE CONVERSION

  • Converts entire scenes with one click

  • Automatically converts all materials, decals, and lighting

  • Preserves scene hierarchy and object properties

  • Optional scene duplication for safe conversion

  • Organized asset management with automatic folder structure

✓ INTELLIGENT MATERIAL CONVERSION

  • Converts materials between URP and HDRP shaders

  • Preserves textures, colors, and material properties

  • Supports material variants and hierarchy inheritance

  • Batch conversion of multiple materials

  • Custom shader assignment option

  • Filter materials by current scene or entire project

✓ ADVANCED DECAL CONVERSION

  • Converts decal projectors and materials

  • Supports ShaderGraph decals and legacy decals

  • Preserves decal settings (scale mode, fade, rotation)

  • Two conversion methods: objects in scene or materials in project

  • Automatic Decal Renderer Feature enabling for URP

✓ LIGHTING & POST-PROCESSING

  • Automatic light intensity adjustment for both pipelines

  • Environment lighting configuration

  • Skybox assignment and ambient lighting setup

  • Emissive materials adjustment (bidirectional)

  • Volume profile conversion with post-processing effects

  • Exposure, bloom, tonemapping, and color adjustment conversion

✓ PIPELINE ACTIVATION TOOLS

  • One-click URP/HDRP asset creation

  • Automatic pipeline activation

  • Settings management and configuration

  • Assets created in organized Settings folder

✓ TROUBLESHOOTING & AUTO-FIX

  • Automatic issue detection and scanning

  • One-click auto-fix for common problems

  • Manual troubleshooting tools

  • Detailed console logging for debugging

  • Post-conversion auto-fix option

✓ USER-FRIENDLY INTERFACE

  • Clean, organized three-tab layout

  • Clear step-by-step workflow

  • Visual feedback with progress bars

  • Helpful tooltips and descriptions

  • Color-coded buttons matching pipeline

WHAT GETS CONVERTED

--------------------

• Materials (Standard, Lit, Unlit, Custom)

• Decals (Projectors, Materials, ShaderGraph)

• Lighting (Directional, Point, Spot lights)

• Environment Lighting (Skybox, Ambient, Intensity)

• Emissive Materials (Glowing objects, Neon, Screens)

• Post-Processing (Exposure, Bloom, Tonemapping, Color)

• Volume Profiles (All post-processing settings)

• Material Variants (Child materials with inheritance)

• Textures (Albedo, Normal, Metallic, Emission, etc.)

PERFECT FOR

-----------

• Developers switching between URP and HDRP

• Teams maintaining multiple pipeline versions

• Projects targeting different platforms (mobile + PC)

• Asset creators supporting both pipelines

• Prototyping with different render pipelines

• Learning and comparing URP vs HDRP

WORKFLOW EXAMPLE

----------------

1. Open the tool: Window > Null Station > Migration Helper

2. Activate target pipeline (URP or HDRP)

3. Choose conversion direction

4. Select options (materials, decals, lighting, etc.)

5. Click Convert button

6. Done! Scene is converted automatically

The tool handles all technical details including shader mapping, property 

preservation, light intensity adjustment, and post-processing conversion.

WHY CHOOSE NULL MIGRATION HELPER

---------------------------------

• SAVES TIME: Automates hours of manual conversion work

• RELIABLE: Extensively tested with real-world projects

• SAFE: Optional scene duplication prevents data loss

• COMPLETE: Converts everything, not just materials

• BIDIRECTIONAL: Full support for both conversion directions

• MAINTAINED: Regular updates for latest Unity versions

• DOCUMENTED: Comprehensive documentation included

• PROCEDURAL: No hardcoded values, works on any project

TECHNICAL HIGHLIGHTS

--------------------

• Reflection-based component handling for maximum compatibility

• Robust material property preservation using SerializedObject

• Intelligent shader detection and mapping

• Asset GUID remapping for duplicated scenes

• Automatic dependency tracking and conversion

• Error handling with detailed logging

• Unity 6+ optimized with latest API usage

REQUIREMENTS

------------

• Unity 6 or newer

• Universal RP package (for URP conversion)

• High Definition RP package (for HDRP conversion)

INCLUDES

--------

• Main Editor Tool (NullMigrationHelper.cs)

• Assembly Definition for proper compilation

• Comprehensive Documentation (Documentation.txt)

• README with quick start guide

• Backup system for safety

GET STARTED IN MINUTES

-----------------------

Import the package, open the tool window, and start converting! The intuitive 

interface guides you through each step. Detailed documentation explains every 

feature with simple language and clear examples.

Transform your Unity projects between render pipelines with confidence!

Included Effects:

• Meteor Effect - Falling meteor with explosion
• Blizzard Effect - Snowstorm with ice formation and destruction
• Typhoon Effect - Swirling wind vortex
• Thunder Effect - Rain with randomized lightning strikes

Features:

• Real-time GUI control system
• Easy resizing with scale parameters
• Loop and auto-play options
• Adjustable particle playback speed
• Optimized object pooling and caching
• Interactive demo scene
• Documentation (Korean & English)

Effect Types:

• Weather Effects - 4
• Particle Systems - Multiple per effect
• Total Prefabs - 4 main effects + sub-particles

Technical Requirements:

• Unity Version - 2020.3 or higher
• Render Pipeline - Built-in Render Pipeline
• Platform - All platforms supported
• Scripting - C# (.NET 4.x)

Script Components:

• TwinSmithEffects - Base class
• MeteorEffect
• BlizzardEffect
• TyphoonEffect
• ThunderEffect
• TwinSmithEffectsManager - GUI controller

Customizable Parameters:

• Timing controls - delays, duration, intervals
• Scale adjustments
• Meteor fall angle
• Typhoon movement settings
• Lightning Y-axis offset
• Particle speed multiplier

Performance:

• Object pooling
• Cached particle system references
• Optimized coroutine usage
• Efficient memory usage

Package Contents:

• Scripts - 6 C# files
• Prefabs - 4 main effects + sub-particles
• Demo Scene
• Documentation - README files
• Example materials and textures

Controls:

• Runtime GUI sliders and toggles
• Previous/Next effect switching
• GUI hide/show option
• Code-based control support

Compatible With:

• PC - Windows, Mac, Linux
• Mobile - iOS, Android
• WebGL
• Consoles - requires appropriate Unity license

This package is designed to help small and mid-sized indie game studios easily implement high-quality particle effects without requiring deep technical knowledge. All effects are optimized, scalable, and fully controllable at runtime through an intuitive GUI system. Each effect is built with performance, flexibility, and ease of integration in mind.

Armor Police Vehicle Physics Controller

Poly Count(3d Vehicle)

•Interior : 3614 tris

•Exterior : 19,587 tris

•Wheel : 2837 tris

Police Pursuit Vehicle Physics

Poly Count (3d Vehicle)

•Interior : 3192 tris

•Exterior : 18,618 tris

•Wheel : 3120 tris

APC Military Police Vehicle Physics

Poly Count (3d Vehicle)

•Interior : 3160 tris

•Exterior : 16,261 tris

•Wheel : 3081 tris

Texture Dimension:

4096x4096 (vehicle body)

2048x2048 (wheel / interior )

1024x1024 (glass/Interior display)

256x256 (Color Pallet)

64x64 (dust)

Rigging: Yes

UV mapping: Yes

PBR texture: Yes

Vehicle Controller Script: Yes

Camera Script: Yes

Police Siren Script: Yes

Light Controler Script: Yes

*IMPORTANT

What will you get in this Bundle?

You will receive the following three asset packs from the Armor Police Collection:

1. Armor Police Vehicle Physics Controller
2. Police Pursuit Vehicle Physics
3. APC Military Police Vehicle Physics

How to redeem?

After purchasing this bundle, click on the three assets listed above and add them to your cart. You'll notice that your total cart amount will be $0, allowing you to complete your purchase. Remember to use the same Unity account with which you purchased this bundle.

Support New Unity Input System

With the New Unity Input System, you can bind keys to any compatible controller device, such as your gamepad, joystick, keyboard, or mobile touch input, and more.

*Note: If you face any error regarding 'InputAction' or 'InputSystem' please install Input System from your Package Manager under Unity Registry.

Ready To Drive!

These vehicle pack comes with the JRS Vehicle Physics Controller 1.5. You can drive the vehicle, adjust parameters like Motor Force, Max Steer Angle, Brake Force, Gear Ratios, and Shift Threshold. Set up a customizable light system, add door animations and dust particle effects.

The script offers customization options for creating dynamic vehicle physics and effects in games or simulations.

More Options to Customize Your Police Armor Vehicle

Our vehicle scripts comes with different options to customize the behavior of your vehicle. These include:

• Motor Force: This is the force that your vehicle's engine will produce. Larger numbers mean a more powerful engine.
• Max Steer Angle: This variable determines how sharply your vehicle can turn. High values will allow for sharp turns, low values for gradual ones.
• Brake Force: This determines how powerful your brakes are. You can play around with the value.
• Gear Ratios: These are the ratios that determine how much torque is transferred to your wheels at each gear. Gear ratios control the power and speed of the car. Gear ratios determine the relationship between the engine RPM and the wheel speed. You can add how many gears you want and adjust these values to control the vehicle's acceleration and top speed in each gear.
• Shift Threshold: The RPM value at which the car will shift to the next gear. When the current RPM exceeds this threshold, the script will automatically shift to the next gear.
• Enable 4x4: When enabled, this feature activates the vehicle's 4-wheel drive. When disabled, it reverts to 2-wheel drive.
• Dust Particle System: Reference to the dust particles system for each wheel. They are used to enable or disable the particle systems based on wheel slip, drift, and braking.

Keyboard, Game pad, Joystick and Mobile touch Input Controller

• Enables vehicle control using both keyboard, Game pad, Joystick and on-screen mobile inputs
• Provides customizable input buttons with New Unity Input System
• Create on-screen buttons for mobile input
• Easily assign input buttons via Vehicle Input Action
• Supports camera switching
• Sample scene included for keyboard/Gamepad and Mobile touch inputs as shown in this video

Camera Controller

• Three types of cameras included. The Follow camera, the Orbit camera, and the Dash-view camera.
• Provide different camera perspectives for the vehicle
• Offer customizable parameters for camera movement and zooming
• Camera Manager: Assign a target GameObject for the camera to follow or orbit around
• Adjust parameters like Offset, Rotation Speed, Zoom Speed, and Zoom Time

Vehicle Door Mechanic

• Allows opening and closing of vehicle doors
• Provides customizable parameters for door movement and sound effects
• Adjust Angle, Speed, and Assign Key via InputAction using Door id.
• Audio Sources for open and close sounds

PBR Texture

• Each model includes both exterior and interior designs.
• Physically Based Rendering (PBR) textures that enhance the vehicle's look under different lighting conditions.

Police Siren and Sound

The Police Pursuit Vehicle is an SUV-type police vehicle suitable for adding a special police force reinforcement to your game, whether an open-world or a police game projects. It comes equipped with a functional siren and sound that can be activated. The siren lights flash in synchronization with the sound, creating an immersive and realistic experience for players.

Functional Light System

Not only does this asset have a Police Siren but it also has a fully functional light system that can be activated for the headlight, brake light, signal light, reverse light, and extra light. These lights can be controlled and customized to suit different gameplay situations, enhancing the vehicle's functionality and versatility in the game environment.

The Light control script was design in such a way that each light elements an be easily dragged and dropped into its corresponding function, ensuring a seamless user experience.

You can also add your own lights elements by clicking on the ‘+’ icon below each light element properties.

URP Compatible

This asset is compatible with Universal Render Pipeline (URP).

One of the key advantages of URP is its performance optimization. It is designed to efficiently utilize modern hardware capabilities, making it suitable for a wide range of platforms, including desktop, mobile, and console. URP also includes a lightweight render pipeline option, which is optimized for low-end devices or projects that require high performance. You can also watch this tutorial here on how to set-up URP for your projects.

Prefab included

Adding these vehicles to your scene is as easy as drag-and-drop with the included prefab.

Light Glow Effect

If light glow effect is not enable in your scene then you need to install Post Processing if you are using the Built-in Render Pipeline. You can also watch the video tutorial here.

If you are using URP then no need to install Post Processing since this features is already included in URP.

Package Contains: 3D Vehicle Models + Platform environment props

Support Team:

Every asset in this pack has been skillfully designed and modeled from scratch by our dedicated team of professional artists. If you need any help regarding or assets please reach out to us from our contact details below.

Video Demo:

https://youtu.be/oLZn2e8neUI

https://youtu.be/NaGXHtdrivE

https://youtu.be/fgBfTn83xE4

Tutorial:

How to add glow effect to your vehicle lights using our Game Asset in Unity Built-in Render Pipeline

How to set up a URP Project in Unity with Our Asset Pack

Contact:

Send Email

WhatsApp

www.jermesa.com

Join US on Discord

All included materials are Standard Built-In. This means they can easily be upgraded to either URP or HDRP using the Upgrader Tool of the selected pipeline.

This third "Full Pack" volume includes Monster Pack Vol 13, 14 and 15. It will include upcoming Monster Pack Vol 16, 17 and 18. It gathers 15 Monsters (with 15 more in the making). Get it right now and enjoy 15 Add-Ons for free! (Once complete, the package will be listed at $399.99)

Are currently included:

• Crassoplast
• Erucatrox
• Formickarce
• Hexapodosaurus
• Loricaderm
• Aranocodus
• Mantikarce
• Friktichelon
• Kapeloproboskid
• Turpisomorph
• Trimaxillopod
• Bombiactus
• Akanthasaur
• Gigabdomocauda Bombis
• Gigabdomocauda Larva

All materials included are Standard Built-In. This means they can easily be upgraded to either URP or HDRP using the Upgrader Tool of the selected pipeline.

This 15th volume gathers a set of 5 monsters ready to populate your project.

Are included:

• Akanthasaur
• bombiactus
• Gigabdomocauda Bombis
• Gigabdomocauda Larva
• Trimaxillopod

All included materials are Standard Built-In. This means they can easily be upgraded to either URP or HDRP using the Upgrader Tool of the selected pipeline.

Here is Gigabdomocauda Larva. This juvenile version of Bombis is obviously much smaller but it didn't lose its fierceness and aggressivity at all. This creature will tear you apart before yo ueven know what happened.

Geometry is 9.48 Ktris total (Main body: 8.49 Ktris and Weakpoint: 986 Tris). Model uses 1 material with a 2048*2048 PBR texture set.

The package includes a set of 30 animations (10 being root motion variations).