Asset Store newest packages

This bundle includes the following tools by Virtual Maker:

Flexalon 3D & UI Layouts

Flexalon gives level designers, animators, and interface designers the power to make adaptive 3D layouts that are precise and easy to update.

Proxima Runtime Inspector + Console

Your game doesn't have to be a black box. Proxima lets you inspect, debug, and control your game from any web browser.

Bindables Reactive Programming

Bindables is a reactive framework for managing your game state and syncing it to UI and gameplay. Easily bind to lists, dictionaries, derived state, animations, intervals, events, and even URIs.

Join the conversation on Discord.

After purchasing this bundle, visit each linked package to claim them for free.

• Flexalon: Store Link
• Proxima: Store Link
• Bindables: Store Link

Textures in this package:

- Number of textures: 1

- Resolution: 256x256

- Size: ~40 KB

Model stats (total, ~):

- Vertices: 23 000

- Triangels: 44 000

Number of meshes/prefabs:

50+ Meshes

UV Light-Map:

Yes

POLY | Pack - Trucks & Trailers

This asset pack includes 50+ models for your project. Pack also includes truck accessories to customize the trucks and a variant of different trailer loads.

Need any help?

Join our Discord and we will help you right away :)

Or Contact Us Here

Website

Compatibility

• Unity 2021.3+, 6.000+
• Built-in RP, URP
• Works on all platforms supported by Unity
• Requires TextMeshPro

Performance

• Performance: Uses MaterialPropertyBlock for efficient rendering; 0 garbage allocation during runtime updates.
• Architecture: Single-directional-light design to keep draw calls low; RenderTextures are editor-only (Visualizer).
• Setup: Drag-and-drop prefab setup. No complex initialization required.

Code Quality

• Modular and extensible C# architecture
• All editor tools use proper cleanup & lifecycle handling
• Inspector tooltips provided for all fields
• Fully documented and organized scripts

Setup Time

• One-click prefab
• Immediate visual results
• Fully customizable with minimal coding required

Beautiful Skies. Zero Bloat.

Stop fighting with massive, over-engineered weather systems that hijack your project. Advanced, Lightweight Day–Night & Seasonal Sky System is a focused, high-performance lighting engine designed for developers who need professional day/night cycles without the overhead of a full weather simulation.

Whether you are building a low-poly RPG or a stylized adventure, this tool gives you deep control over your world’s atmosphere while remaining lightweight enough for mobile and VR.

✨ Why Choose This Over the Giants?

• No "Black Box" Code: Clean, modular C# that doesn't break your render pipeline.
• Workflow First: Includes a 360° Sky Visualizer so you can tweak sunsets without ever hitting "Play."
• Content Ready: Comes with 21 Professional Seasonal Profiles (Alien, Arctic, Fantasy, Realistic, etc.) so your game looks good instantly.

🎨 Key Features

🌎 Complete Seasonal EngineDon't just loop day and night—make your world evolve.

• 4-Season Support: Seamlessly blend lighting, fog, and exposure from Spring to Winter.
• Smart Blending: The system interpolates everything—from ambient equator colors to moon tint—ensuring no hard transitions.
• Lighting Windows: Define exact "Dawn," "Midday," and "Dusk" hours to perfectly time your golden hour.

☀️ Professional Skybox Management

• Hybrid Modes: Use Unity's procedural sky, static cubemaps, or our Dual-Cubemap Blending for high-fidelity transitions.
• Visualizer Tool: Preview your sky timeline, sun path, and moon phases directly in the Scene View with our custom Editor Window.

🌙 Advanced Celestial System

• Realistic Moon Phases: Fully configurable lunar cycles with a custom moon shader (glow, shadows, fog influence).
• Orbital Objects: Easily animate planets, satellites, or space stations with elliptical orbits and parallax correction.
• Starfield System: Performant particle or mesh-based stars that fade in based on seasonal visibility.

🛠️ Developer-Centric Workflow

• Clipboard Power: Copy/Paste seasonal settings instantly in the Inspector (huge time saver!).
• Scene Lighting Controller: Includes example scripts for time-based streetlights, window emissives, and flicker effects.
• Clean API: DayNightCycle.TimeOfDay and simple events like OnDusk or OnHourChanged make coding gameplay logic a breeze.

📦 Compatibility

• Pipelines: Built-in & URP.
• Unity Versions: 2021.3+, 6.000+.
• Platforms: PC, Console, Mobile, VR/AR.
• Reequires: TextMeshPro

Note: The city shown in the demo video uses "SimplePoly City - Low Poly Assets" and is for demonstration purposes only.

This tool comes with an editor that allows you to create skeletons by dragging nodes in the editor scene.

This tool provides runtime support and can dynamically create skeleton meshes through code.

Using this tool, creators only need to adjust a few simple parameters, such as the position and cross-sectional radius of each node in the skeleton, and the tool can automatically create a low-polygon mesh based on the relationships between the nodes.

 Then, by stitching together multiple skeleton meshes, more complex mesh models can be created. 

The generated mesh model can be exported as a prefab and automatically bound to bones.

This tool includes the following examples:

1. A simple tree generator that automatically generates low-polygon tree models by adjusting the corresponding parameters.
2. A simple wireframe mesh generator that can generate a skeleton mesh model of the connection of mesh vertices and edges based on the existing mesh.
3. A simple monster simulator(runtime) that creates different monster models by piecing together different body parts. At the same time, it automatically generates bone binding and adds simple procedural animations.

• Unity Version: 2020.3 LTS to 2022.3+ (6000.2.9f1 LTS recommended)

• Render Pipelines: Built-in, URP, HDRP (shader adjustments)

• Platforms: Windows, macOS, Linux, iOS, Android, Consoles

• Animation System: 8 states (Idle, Walk, Run, Sprint, Jump, Die, SwimIdle, Swim)

• Dual Animation Styles: Minecraft (rigid) ↔ Roblox (flexible)

• Unified Jump System: Takeoff, airborne, landing with physics sync

• Death & Swimming System: Multi-phase animations, stroke cycles

• Performance: Optimized for 50+ characters, low memory usage

• Audio: Integrated 3D audio with PlayerAudioController (Land, Water, Melee, Damage, Health)

• Character Controller Integration: FixedThirdPersonController included, input support (Legacy/New/Both), water detection, slope handling, physics-animation sync

• Event System: OnAnimationStateChanged, OnJumpStarted/Landed, OnDeathProgressChanged, OnSwimStrokeComplete, OnAttackStarted/Landed

• Dependencies: Only Unity Audio & Physics (no external DLLs)

• Tools: VoxelCharacterConfigurator, AnimationDebugVisualizer, VoxelCharacterTester, AnimationValidator

Tired of wrestling with complex Animator Controllers and animation graphs? VoxelCharacterAnimator is a complete procedural animation solution that gives you professional-quality character movement in minutes, not days.

This system eliminates the need for traditional animation workflows. Add the component, assign your character's bones, and watch your character come to life with smooth, natural movement. No animation expertise required.

Switch between rigid Minecraft-style movements and flexible Roblox-style animations at runtime. Fine-tune every parameter in Play Mode until it feels perfect for your game. Engineered for scalability, you can run 50+ animated characters simultaneously without performance loss.

VoxelCharacterAnimator also includes a fully integrated 3D audio system, syncing footsteps, attacks, and swimming sounds with animations. It comes with a production-ready third-person controller, input system support (Legacy, New, or Both), physics-animation synchronization, and a modular swimming and slope handling system.

This asset is perfect for solo developers, rapid prototyping, multi-platform projects, and games with voxel, blocky, or stylized aesthetics.

• Hide, Show & Close Floating Windows
• Auto Detect Any Floating Window
• Multi Tab, Tab Drag-Outs Detection
• More Usable Space On Laptops
• Free-Up Second Monitor For Other Tasks

⚠️Supports Only Windows 11, Not MacOS.⚠️

To open Floaty, just access it from menu bar Window/Floaty

then dock it as you like.

✨Enhance Productivity by not having to manage Editor WIndows!

✨Greatly improves the experience of working on Laptop, as you get a lot more screen space to work with & ability to use 125% Scaling for better visibility.

✨Keep many Windows at hand to open when needed instantly rather than going through menus.

✨Doesn't impact performance as Hidden Windows are not rendered.

✨Built with UI Builder has nice UI/UX.

🟢Supports Unity 6+, 2022.3 LTS & 2021.3 LTS (tested latest LTS).

Why I built this tool?

I always used to find it super annoying that certain windows like Project has to be mostly docked, since how frequent it is used & few floating windows, but it just takes up so much space that the docked windows squeeze up other window space while floating windows ends up blocking few windows they're over & it's just such a productivity killer! constant moving around, scaling, repeat...😭, also 100% dpi is tiny, 125% easy on eyes, but eats up space 😞

😄I hope you'll enjoy your time using Floaty.

📝Please Note that Floaty has nothing to do with any of your Project Files, so don't worry about breaking or losing stuff!

Render Pipeline

• Universal Render Pipeline (URP)

Platforms

• Windows, macOS, Linux
• Consoles
• VR / XR (Quest, Index, Pico, WMR — depending on URP)
• Mobile (with reduced settings)

Mobile Performance Recommendations

• Use Half or Quarter downsampling
• Reduce bloom mip count
• Prefer Gaussian/Tent blur with smaller radii
• Enable Bloom Mip Chain reuse
• Use simpler streak setups

Requirements

• No external dependencies
• Works as a URP Renderer Feature + Volume Component
• All shaders included (no SRP Core hacks required)

Performance Notes

• Efficient downsampling cascade
• High-performance blur kernels
• Optional HDR
• Temporal stabilization and prefiltering reduces flicker
• Bloom Mip reuse eliminates redundant bright filters

Documentation

• Complete PDF documentation included
• Clear explanations of every parameter
• Technical overview of resolution cascade and performance behavior
• Artist-friendly best practices

Lens FX is a complete, high-quality post-processing suite for Unity URP, designed to bring authentic camera optics and expressive visual effects to any project. From subtle, physically inspired lighting to bold, stylized flares and streaks — Lens FX gives you full control over Bloom, Lens Flares, Glare, Streaks, Lens Dirt, Refraction, and many other optical behaviors.

With a modular architecture, extensive artistic controls, and several advanced performance options, this package is ideal for real-time games, VR experiences, cinematics, simulations, and stylized worlds.

Note: normal maps and dirt textures for the dirt and refraction effects seen in the promo material are not included, you can find those on the internet.

- Works across build targets. Designed for both Mono and IL2CPP builds and tested in real commercial titles since 2015.

- Schedule jobs with precise timing. Use QueueJob to run a job after a delay (ms) or as a repeating job (fixed count or endless) - perfect for polling, periodic autosave, telemetry pings, timed gameplay events, etc.

- Cancel anything, anytime. Store the returned jobId and stop jobs on demand (CancelJob, CancelAllJobs) - ideal for scene unloads, menu transitions, or aborting outdated async requests.

- Batch per-frame work. Register FrameListeners to coalesce many small tasks into a single per-frame execution, reducing overhead and avoiding GC churn from scattered callbacks.

- Control performance spikes. Set a per-frame execution quota (µs) so main-thread jobs never blow your frame budget. Tune it per platform or scene to keep frame times stable.

- Centralized error handling. Plug in a global exception handler to capture, log, and recover from job exceptions without crashing gameplay.

- Run work off the main thread. Offload heavy tasks (pathfinding, procedural generation, compression/decompression, JSON/XML parsing, save/load, network message processing) to background threads via AsyncProcessor to keep your frame rate smooth.

- Marshal results back to Unity`s main thread. Post callbacks to the main thread via JobProcessor for safe interaction with Unity APIs (instantiate objects, update UI, modify Scene/Components) without UnityException: get_isPlaying can only be called from the main thread.

JobProcessor & AsyncProcessor are battle-tested Unity scripts for simple, reliable multithreading. Offload expensive tasks to background threads, then deliver results to Unity’s main thread safely and predictably - without scene clutter or custom components.

• Fully code-based system
• All animations are generated through scripts. No shaders or materials are required.
• Easy integration
• Simply add `using TextMasterTool;` and start animating immediately.
• 20+ built-in text effects
• Includes Typewriter, Fade, Wave, Shake, Bounce, Pulse, Scramble, Rotate, ColorShift, and more.
• Parameter-driven animations
• Fine-tune speed, intensity, frequency, duration, and other animation settings.
• TextMeshPro and Unity UI compatibility
• Works seamlessly with both text systems.
• Performance optimized
• Designed to run smoothly on both mobile and PC platforms.
• Loop and timing support
• Any effect can be looped or controlled dynamically.
• User-friendly API
• Create visually rich text animations with a single line of code.
• Example usage:
• TextMaster.Typewriter(myText, "Welcome!", 0.05f);
• Documentation and demo scenes included
• Comes with setup guides, usage examples, and ready-to-use demo scenes.
• URP and HDRP compatible
• Works reliably across all Unity render pipelines.

Documentation

TextMaster is a powerful, code-driven text animation tool built entirely without shaders or materials.

It allows developers to create dynamic, professional, and visually polished text animations for both

TextMeshPro and Unity UI Text elements using pure C#.

Key Features

- Pure code-based system  

  No shaders, materials, or additional components required.

- Real-time text animations  

  Includes ready-to-use effects such as Fade, Typewriter, Bounce, Shake, Wave, Pulse, and more.

- Highly customizable parameters  

  Control amplitude, speed, frequency, intensity, and timing to match your project’s style.

- Full compatibility  

  Works seamlessly with both TextMeshPro and Unity UI Text.

- Optimized for performance  

  Designed to be lightweight and suitable for mobile, PC, and high-end projects.

- Easy to use API  

  Create complex, professional-looking text animations with a single line of code.

- Documentation included  

  Comes with setup instructions, usage examples, and demo scenes.

TextMaster is ideal for animating game titles, dialogues, UI elements, notifications, and score popups.

It is designed for developers, designers, and UI artists who want full creative control over text

animations without unnecessary complexity.

In short, TextMaster transforms static text into expressive, animated visual elements.

Technical Details

Category: Editor Extension / Tools
Type: Utility – Character Optimization

Features:
• Merge multiple SkinnedMeshRenderers into one unified mesh
• Automatically combine materials and textures into a single atlas
• Preserve animations, blend shapes, bones, and rig hierarchy
• Maintain shader compatibility and original material assignments
• Reduce draw calls, GPU load, and material count
• Detect and fix UV out-of-bounds automatically
• Generate a clean, mobile-ready prefab in one click

Supported Render Pipelines:
✅ Built-in Render Pipeline
✅ Universal Render Pipeline (URP)
❌ High Definition Render Pipeline (HDRP) – not tested

Platform Compatibility:
• Windows, macOS, Android, iOS, WebGL, VR

Dependencies:
• None – fully self-contained, no third-party libraries required

Unity Versions Tested:
• 2021.3 LTS
• 2022.3 LTS
• 2023.2+

Included Scripts:
• CharacterMergerWindow.cs
• SkinnedMeshMerger.cs
• MaterialMerger.cs
• UVIntegrityChecker.cs

Mobile Avatar Merger is a powerful Unity editor utility that automatically combines all Skinned Mesh Renderers, materials, and textures from a 3D character into a single, optimized prefab.

It drastically reduces draw calls, material count, and GPU load, improving performance on mobile and VR platforms — while preserving animations, rigs, blend shapes, and shader compatibility.

Perfect for developers who want to quickly prepare high-quality, animation-ready characters for mobile, AR/VR, and Metaverse projects.

coloring pages generation

friendly svg importer

customizable svg coloring pages

coloring pages preview generation

🎨 SVG Coloring Book – Complete Unity Solution

Build a high-quality coloring app powered by SVG. Drop in your own pages, organize them into categories, and pick the delivery option that fits your project—from tiny raw SVGs to instant-loading baked pages. Supports solid colors, gradients, and embedded raster graphics—mix vector crispness with photo detail.

Includes 35+ coloring pages (more coming soon!)

Import & Delivery Options

• Raw SVG (minimal setup): Fast authoring; limited control over region colors, color-index positions, and outline color. Generates at runtime in a few seconds. Optional runtime preview helper.
• Configured SVG (editor-driven): Friendly Unity editor tooling to set region colors, color-index positions, and outline color. Still generates at runtime. One-click editor previews or assign from Assets.
• Baked Page (instant load): Editor-configured SVG with mesh data baked for zero runtime generation. Uses more memory (up to ~20 MB/page) but loads immediately ⚡

Coloring Modes

• FillOnClick: Tap a region to fill it—classic coloring flow.
• RevealOnClick: Tap to hide a mask region and reveal underlying raster art—great for more complex scenes.

Previews

When generating a preview, choose between:

• Colored — matches the final SVG coloring page.
• Outlined — removes all fills and shows only strokes using your configured Outline color.

Gameplay & UX

• Optimized SVG import with per-page controls
• Multi-language support
• Customizable Settings (vibration, sounds)
• Player progress tracking—continue from the Gallery tab
• Monetization-ready: IAP for Remove Ads and ads support
• Hints system to assist stuck players
• Selected-color highlighting—guides players to valid regions

Performance Notes

Tested on Qualcomm Snapdragon 8 Gen 2:

• ~50 KB colored SVG with a few gradients: ≈1 s to generate
• Baked pages skip generation and load instantly (with higher memory use).~200 KB more complex SVG: ≈3 s to generate
  

Play Demo: Coloring Book SVG by gilett4

Note: Actual performance and memory use vary by device, SVG complexity, and project settings.

Pixit Cube World is a lightweight Minecraft-style block world starter kit for Unity.

It focuses on clean, readable systems you can actually extend instead of fighting:

• Chunk-based procedural world generation
• ScriptableObject-driven block & tool data
• Mining, block breaking & drops
• Inventory + hotbar with drag & drop
• Held tools / blocks in first person view
• 9 animated animals + 9 animated creature/monster models (idle, walk, attack)

You get a ready-to-play demo scene where you can move, mine, pick up items, manage your hotbar and place blocks in a simple cubic world.

Key Features

Chunk-based world generation

• Configurable chunk size (X, Y, Z)
• World size defined in chunks (X, Z)
• Min / max ground height and simple mountain noise
• Seed-based generation for reproducible worlds
• Grass, dirt and stone layers with optional ore placement by depth and rarity

Blocks & ores via ScriptableObjects

• BlockData assets for each block type
• Byte-based block IDs (0 = Air, 1+ = solid blocks)
• Per-block:
  Display name & icon
  World prefab (1×1×1 cube recommended)
  Drop prefab for pickups
  Base break time
  Optional ore settings (minY, maxY, rarity)

Mining, breaking & drops

• Raycast from the camera to target blocks
• Per-block break time and progress
• Blocks turn into Air and the chunk mesh is rebuilt when broken
• Drops are spawned from dropPrefab and picked up into the inventory
• Optional tool support to speed up or require tools for certain blocks

Inventory & hotbar

• Inventory component on the player
• Configurable hotbar size (e.g. 8 slots) and main inventory size (e.g. 32 slots)
• Each slot can contain a block (BlockData) or a tool (ToolData) plus a stack count
• Number keys (1–8) select hotbar slots
• Drag & drop to rearrange items between slots
• Stack count text and selected slot highlight
• Full inventory panel toggle (e.g. “I” key) with mouse lock / unlock

Tools & held item visuals

• ToolData assets with:
  Display name and icon
  In-hand prefab for first person
  Optional flags such as “acts as pickaxe”
• HeldItemRenderer:
  Reads the current hotbar slot
  Spawns either the tool prefab or block prefab in the player’s hand
  Controls local position, rotation and scale
  Disables physics on the held instance

Pickups

• BlockPickup and ToolPickup components
• Trigger-based pick up:
  Detect player
  Add items to Inventory
  Destroy the pickup object

Animated animals & creatures

• 9 low-poly animal models (stylized, block-world friendly)
• 9 low-poly creature / monster models in the same style
• Each model includes:
  Idle animation
  Walk / run-style animation
  Basic attack animation
• Perfect as ambient wildlife or simple enemies in your cube world
• Easy to connect to your own AI / state machines / behavior trees

Included Content

• World generator and chunk scripts
• WorldSettings, BlockData, ToolData ScriptableObjects
• Chunk mesh building and block storage (byte IDs)
• Mining & breaking logic with drops
• Inventory + hotbar system and UI
• First person controller + held item renderer
• 9 animated animals (idle / walk / attack)
• 9 animated creatures / monsters (idle / walk / attack)
• Demo scene with everything wired together

Requirements

• Unity 2022.3 LTS or newer
• Built-in Render Pipeline by default (URP/HDRP compatible with your own materials)

You are free to expand this into your own full game: crafting, enemies, saving, biomes, multiplayer, etc. The kit stays intentionally simple so you can plug your own systems on top.

Online Documentation

Setup steps, component explanations and scripting notes:

https://pixitgames.com/docs/cubeworld/

Project Window Features

• Custom per-folder colors
• Smooth feathered gradients (left → right)
• Adjustable text-safe "clear" zone
• Subfolder auto-lightening
• Global opacity & right-edge strength
• Zero text distortion, labels stay crisp
• Fully non-destructive (no icons replaced, no hacks)

Hierarchy Window Features

• Smooth horizontal gradient bars
• Optional glow strips beneath text
• Adjustable glow width, brightness & alpha
• Object “color dots” (size + offset adjustable)
• Sub-objects inherit & lighten automatically
• Neutral highlight mode (soft gray strip under text)

Transform Your Workflow with Color

Project & Hierarchy Color Suite enhances your Unity editor with clean, modern visual organization. Designed for medium to large teams and solo developers alike, this tool adds intuitive color coding to both the Project Window and Hierarchy Window, making navigation faster and dramatically more enjoyable. Use colors to mark gameplay systems, art folders, prefabs, scripts, scenes, UI groups, and more. Smooth gradients, adjustable feathering, right-edge glow, and optional highlight strips help every color stand out without overwhelming the interface. The Hierarchy includes dot markers, category colors, and optional text glow to enhance clarity even further.

Every element is customizable gradients, opacity, dot sizes, glow intensity, neutral highlight blending, and per-item colors, allowing you to tailor your editor environment exactly as you like. The result is a visually clean, organized, and highly efficient workspace.

If you’re looking to improve navigation speed, reduce visual clutter, and bring a modern aesthetic to Unity, this package delivers an elegant, professional solution with A sharper, clearer, more inspiring Unity editor, for creators who build worlds and want their workflow to feel as intentional as their game design.

Key features include:

• Automatic and safe service registration during initialization
• Fast, type-based generic retrieval methods
• Separate support for ScriptableObject-based and MonoBehaviour-based services
• Built-in protection against accidental type duplication
• Optional lazy service access for improved performance
• A minimal and intuitive API designed for clarity and maintainability

The Simple Dependency Injector was created with one goal in mind: to help you keep your project clean, decoupled, testable, and easy to maintain — without adding unnecessary complexity.

If you want a dependency-injection solution that is simple, efficient, and truly built for Unity, you’ve just found it.

Simple Dependency Injector is a lightweight, efficient, and Unity-focused plugin designed to streamline how you manage shared services throughout your game. Unlike large and complex dependency-injection frameworks, this tool is crafted specifically for Unity’s architecture — respecting object lifecycles, performance constraints, and the unique workflows of game development.

With this plugin, you can register services implemented as ScriptableObjects or MonoBehaviours and retrieve them through a clean and centralized API. The system avoids heavy reflection, unnecessary abstractions, and runtime overhead, delivering a minimal and predictable approach that works seamlessly inside Unity projects of any size.

Read me

https://github.com/icaro56/simple-dependency-injector/blob/main/README.md

You can install this package via UPM. Follow the readme link.

Supported Unity Versions:

• Unity 2021.3 LTS and above
• Fully tested on Unity 2022 & 2023 editors
• Unity 6

Editor Compatibility:

• Works in Edit Mode and Play Mode
• Editor-only (no runtime code included)
• Safe for all project types (2D, 3D, URP, HDRP)

Platform Support:

• Windows
• macOS (Editor only)

Input & Shortcuts:

• Fullscreen on Play (on/off)
• Default shortcuts:
• F1: Toggle Game Fullscreen
• F2: Toggle Scene Fullscreen 
• F3: Mobile Portrait View 1080x1920
• F4: Mobile Landscape View 1080x1920
• Shortcuts can be changed or reassigned
• Close Fullscreen button included in UI

Enter a true fullscreen preview of your Game or Scene without launching a new build. A great way to test layouts, showcase progress, and get the real feel of your game.

Work Faster & get Full Attention To Details without the editor noise!

Key Features:

1. Fullscreen on Play -> ON / OFF
2. Toggle Game Fullscreen -> F1
3. Toggle Scene Fullscreen -> F2
4. Mobile Portrait View 1080x1920 -> F3
5. Mobile Landscape View 1080x1920 -> F4

✅ Instant Fullscreen

Jump into fullscreen Game View or fullscreen Scene View with a single key.

✅ Clean Scene View Mode

Fullscreen game scenes just like playing your game for real -> inside Unity!

✅ Minimal, Non-Intrusive UI

A small corner button lets you exit fullscreen at any time.

No windows moved. No layout destroyed.

✅ Works in Edit & Play Mode

Enable fullscreen even when the game isn’t running.

Perfect for presentations, scene reviews, and environment polish.

✅ Zero Setup

Editor-only, lightweight, and completely safe for all projects.

No dependencies. No performance impact.

✅ Just Plug N’ Play

Import the package and you’re ready - no configuration, no integration, no extra steps.

FAQ ❓

Q: Do I need to build my game to use fullscreen?

A: No. Fullscreen Editor Pro works entirely inside the Unity Editor. No builds, scenes, or project changes are required.

Q: Does fullscreen change my Unity layout?

A: No. Your layout stays exactly the same. Fullscreen uses a temporary popup window that closes cleanly without moving or modifying any panels.

Q: Can I use fullscreen in both Edit Mode and Play Mode?

A: Yes. You can enter fullscreen even when the game isn’t running — ideal for testing, scene reviews, and presentations.

Q: Will this affect my game build or runtime performance?

A: Not at all. The package is Editor-only and does not modify runtime code, project settings, or builds.

Note: On multi-display setups, keep the Unity Editor on the primary/main screen to enable fullscreen correctly.

Scene showcase using Unity Starter Assets – Third Person Controller

Let’s create something amazing ❤️

Intelligent Labs.

Core Components:Bake Tool: An Editor Window to configure and execute the baking process. Allows setting sampling FPS (30/60), batch size, and data trimming options.

Effect Renderer: A lightweight MonoBehaviour that plays back the baked data using GPU Instancing.

Animation Data: Efficient ScriptableObject format for storing frame-by-frame particle states.

Requirements:Unity 2022.3 or higher (Compatible with newer versions).

Particle Systems must use Local Simulation Space for baking.

Limitations:

• Simulation Space must be set to Local.
• Some complex rotation combinations with "World Alignment" + "Align To Direction" may have limited support (warnings provided in the tool).
• Physics/Collision modules are baked as recorded positions (collisions are not calculated at runtime).
  

ParticleBakePro is a powerful optimization tool designed to convert dynamic Unity Particle Systems into static, high-performance baked animation data.

By baking particle simulations into ScriptableObject assets, you can render thousands of particles with minimal CPU overhead using GPU Instancing. This is ideal for complex visual effects on mobile devices, VR/AR headsets, or any scenario where performance is critical.

Key Features:

🚀 Extreme Performance: Renders particles using Graphics.DrawMeshInstanced, significantly reducing draw calls and CPU usage compared to standard Particle Systems.

📱 Mobile & VR Ready: Perfect for optimizing heavy effects on resource-constrained platforms.

🔒 Deterministic Playback: Baked animations look exactly the same every time they play. No more random variations—perfect for cinematics or precise gameplay sequencing.

🎨 Comprehensive Baking Support:

Supports Mesh, Billboard, and Horizontal Billboard render modes.

Supports Local, World, View, Facing, and Velocity render alignments.

Bakes Color, Size, Rotation, and Custom Data (Streams 1 & 2).

🛠️ Easy Workflow:

Intuitive Editor Window (Tools > ParticleBakePro).

Real-time baking preview.

Auto-generates baked assets.

✨ Smooth Interpolation: Built-in runtime interpolation ensures smooth playback even at lower bake frame rates.

Why use ParticleBakePro?

Standard Unity Particle Systems run simulations on the CPU every frame. With ParticleBakePro, you calculate the simulation once (at edit time) and play it back purely on the GPU. This frees up valuable CPU time for your game logic.

Instead of arbitrarily setting a "damage" or "speed" float, LP++ simulates the combustion of propellant inside the chamber. It calculates the pressure curve, muzzle velocity, and thermal losses in real-time based on physical parameters.

Perfect for tactical shooters, milsims and games where barrel length, caliber, and ammunition type matter. It allows you to run physics in real-time directly on a GameObject, making it easy to use alongside any external ballistics script.

• Dynamic Behavior: Swap a short barrel for a long one, and watch the muzzle velocity and pressure drop naturally.
• Real Physics: Powder Combustion follows Vieille's Law. The impetus generated by the burn pushes the bullet down the barrel and the movement is simulated, by default, down to the microsecond.
• Detailed Parameters: Tweak everything from Propellant Density and Grain Geometry (Web Size) to Specific Heat Ratio (Gamma).
• Ready to Use: Comes with example weapons and calibers pre-configured so you can start testing immediately.
• Documentation: Includes a PDF Manual explaining what each physical parameter does.

Features:

• Scientific Approach: Mathematics based on books, academic and military papers. Results checked against publicly available telemetry on each stage of development.
• Data Visualization: Generates CSV data to plot Pressure/Velocity graphs.
• Thermodynamics: Includes variables for Specific Energy (Q) and Thermal Efficiency. Thermodynamics are calculated each timestep(dt), simulating conversion from chemical into mechanical energy.
• Customizable Ammo: Simulate everything from subsonic 9mm to high-pressure .338 or even custom wildcat rounds and even fantasy rounds.
• Performance Friendly: Optimized for single-player real-time use. Potentially millions of steps in milliseconds.
• Extensible: The C# Solver is extensible and generally adaptable to projects. One can simulate, for example, Barrel Erosion and Part Durability using the data from it.

Technical Note: Designed primarily for single-player. For multiplayer, the script should not be run in real-time. A LUT-generating algorithm is recommended.

Disclaimer: Intended for entertainment and simulation purposes only. Not certified for real-world ammunition manufacturing.

REQUIRMENTS

• Unity 2022.3+
• Unity Splines Package 2.0.0+
• Unity Terrain Tools 5.0+
• Universal Render Pipeline (for ShaderGraph Shaders in the Samples)

DOCUMENTATION

DISCORD

A simple yet powerful terrain editing tool that lets you modify Unity terrains without permanently altering your original data. Perfect for creating stylized, cartoony landscapes or rapid prototyping—change anything at any time without commitment or hassle. ALL SPLINE BASED!

Easy Setup – Create your terrain and splines, parent them to an empty GameObject, then press the "Find Refs" button - you're ready to go!

Key Features

• Non-Destructive Workflow - Experiment freely and iterate quickly without permanently modifying your terrain

• Multi-Terrain Support - Work seamlessly across multiple terrain objects simultaneously (real-time updates may slow down linearly with the number of active terrains in your scene)

• Supports Multiple Terrain Operations - Height, Paint, Hole, Fill, with configurable brushes both global and local.

• Mixed Workflow - Combine workflows of TerraSplines + Unity Terrain Editor (EXPERIMENTAL)

!!! WARNING !!!

If your scene has a lot of splines and/or terrains the tool will not work in real-time. We recommend switching to manual update mode when the scene gets laggy.

Included Assets

• 3 Pre-Built Environments
• 3 Parallax Backgrounds
• 96 Total Items in the Pack
• (PNG – Sizes range from 620×185 to 728×462 px)18 High-Quality Tilesets
  

• (PNG – Sizes range from 706×940 to 1024×1024 px)15 High-Quality Trees
  

• (PNG – Sizes range from 554×335 to 1024×1024 px)12 High-Quality Bushes
  

• (PNG – Sizes range from 544×449 to 1184×864 px)14 High-Quality Houses
  
• (PNG – Sizes range from 622×598 to 1184×864 px)19 High-Quality Obstacles
  
• (PNG – Sizes range from 189×190 to 1024×1024 px)6 Unique Collectibles
  
• 6, 2D Characters (PNG Sequence Animations)
• (Visit character pages for sizes & animation previews)
• Boarok
• Iron Mobster
• Rotfang
• Venomelt
• Thornox
• Mecha-Rex

Whether you're creating lush forests, stylized mountains, calm plains, or vibrant adventure worlds, this pack gives you everything you need to build polished, visually consistent 2D environments.

All assets are neatly organized, tile-ready, and fully optimized for Unity.

✅ Features

• 100% Unity-compatible (URP, HDRP & Standard)
• Perfect for beginners and experienced environment artists
• Modular, flexible, and easy to customize
• Ideal for mobile, PC, and web games
• Designed for fast world-building and clean workflow

This pack gives you all the tools to create immersive, professional-quality environments—without wasting time searching for extra assets.

• Unique And Appealing Character Design
• 9 Smooth Animations with Detail of each Character
• All animations are provided in PNG format (527x589px Resolution).
• Prefab with Demo scene inclueded
• Source Files As SCML (Spriter), Unity

Animation List:

• Idle
• Idle Blinking
• Throwing
• Jump Start
• Jump Loop
• Walking
• Falling Down
• Hurt
• Dying

Looking to enhance this pack? We’re open to feedback! Drop us your suggestions — and if possible, we’ll include them in future updates.

✅ Love this asset?

Explore our full collection for more powerful 2D characters!