Feed aggregator

- Optimized Meshes

- UV mapped

- 2K textures (Base Tex + Normal Maps )

- LOD's included

- Prefabs included

- URP pipeline

These assets were remeshed and optimzed for non-deformable game-ready application. 

( 5 ) Game-Ready assets Including LOD's:

    - Huge_Rock_1_LOD0 = 4542 tris

    - Huge_Rock_1_LOD1 = 2439 tris

    - Huge_Rock_1_LOD1 = 699 tris

    - Large_Rock_1_LOD0 = 5053 tris

    - Large_Rock_1_LOD1 = 1915 tris

    - Large_Rock_1_LOD2 = 709 tris

    - Medium_Rock_1_LOD0 = 4410 tris

    - Medium_Rock_1_LOD0 = 2112 tris

    - Medium_Rock_1_LOD0 = 715 tris

    - Small_Rock_Group_1_LOD0 = 3852 tris

    - Small_Rock_Group_1_LOD1 = 1813 tris

    - Small_Rock_Group_1_LOD2 = 576 tris

    - Small_Rock_1_LOD0 = 4974 tris

    - Small_Rock_1_LOD1 = 2362 tris

    - Small_Rock_1_LOD2 = 974 tris

( 5 ) URP/Lit materials consisting of a Base Map and a Normal Map

        - Huge_Rock_1_Mat = Huge_Rock_1_baseTex, Huge_Rock_1_NM = 2048 x 2048

        - Large_Rock_1_Mat = Large_Rock_1_baseTex, Large_Rock_1_NM = 2048 x 2048

        - Medium_Rock_1_Mat = Medium_Rock_1_baseTex, Medium_Rock_1_NM = 2048 x 2048

        - Small_Rock_1_Mat = Small_Rock_1_baseTex, Small_Rock_1_NM = 2048 x 2048

        - Small_Rock_Group_1 = Small_Rock_Group_1_baseTex, Small_Rock_Group_1_NM = 2k

Textures consisting of a semi-photorealistic visual style with some hand-painted touch ups that can add some uniqueness to your environments.

Prefabs ready to be placed and arraged in various configurations and structures. 

• Capture PNGs from any scene camera
• Configurable output resolution (width + height) with a size multiplier up to 8x for super-resolution output
• Quick-set buttons: Game View, 1080p, 4K
• Scene View overlay with Quick Capture and Scene View Capture buttons
• Configurable keyboard shortcuts for Quick Capture and Scene View Capture
• Fully configurable output path and filename format (prefix, camera name, resolution, timestamp)
• Recent screenshots grid showing the last 10 captures with clickable thumbnails
• Open Folder After Capture toggle
• Automatic render pipeline detection (Built-in, URP, HDRP)
• Settings stored in a ScriptableObject with full undo support
• No runtime dependencies. Editor-only tool with zero build footprint

ScreenshotKit Lite is a free Unity Editor tool for capturing clean, high-resolution screenshots directly from your project. One click from the Scene View overlay or the main window, and you get a pixel-perfect image from any camera, no Play Mode, no scripts, no hassle.

It works across Built-in, URP, and HDRP with automatic pipeline detection, and everything saves exactly where you want it with a fully configurable filename format.

ScreenshotKit Lite is the free companion to ScreenshotKit, the full-featured capture suite with GIF recording, image sequences, EXR export, transparent composite capture, Cryptomatte passes, and batch multi-camera capture. If your needs grow, upgrading takes seconds.

Cozy Farm Music Pack – 10 Seamless Loops for Indie Games

Bring your farming or life simulation game to life with warm, relaxing, and fully seamless music loops.

This pack includes 10 high-quality looping tracks designed specifically for cozy, atmospheric gameplay. Each track is crafted to loop perfectly in Unity with no clicks or gaps, making it ideal for continuous background music.

Perfect For:

• Farming simulation games

• Life simulation / cozy indie games

• Casual and mobile games

• RPGs and exploration environments

• Menu screens and idle gameplay

Features:

• 10 seamless looping tracks

• WAV format (high quality)

• Optimized for Unity AudioSource looping

• No pops, clicks, or silence gaps

• Ready for immediate use in-game

All tracks are designed to enhance immersion while staying subtle and non-intrusive for long play sessions.

Track List:

• Sunrise Over Clover Fields

• Morning Chores & Dewdrops

• Breezes Through The Orchard

• Fireflies & Fences

• Golden Harvest Days

• Market Day

• Lanterns at Dusk

• Rain On The Tin Roof

• Tilling The Earth

• A Simple Good Life

Whether you're building a relaxing farming sim or a cozy indie experience, this pack provides a complete audio foundation for your game.

Render Pipeline Compatibility:

• Universal Render Pipeline (URP) - Custom ScriptableRendererFeature included.
• Built-in Render Pipeline - Standard OnRenderImage post-processing script included.

Platform Compatibility:

• Mobile (Highly Optimized)
• PC / Mac / WebGL

Included Files:

• 1x Custom Post-Processing Shader: A cleanly structured, fully procedural screen-space shader.
• 3x C# Scripts: Cleanly coded URP and Built-in integration scripts wrapped safely inside the StylizedSpeedLines namespace.
• 1x Material: A ready-to-use material with pre-configured parameters.

Customizable Material Properties:

• Colour
• Speed Lines Tiling
• Speed Lines Radial Scale
• Speed Lines Power & Remap
• Speed Lines Animation
• Mask Scale, Hardness & Power

• Number of VFXs: 1 Full-screen Post-Processing Effect
• Texture sizes: 0 (Fully Procedural, no external textures required)
• Custom shaders: 1 Screen-Space Shader

Enhance the sense of high-speed action in your projects! Stylized Speed Lines is a high-performance, full-screen post-processing effect designed specifically for racing games, intense action scenes, and anime-style aesthetics.

Whether you are using the classic Built-in Render Pipeline or the Universal Render Pipeline (URP), this package is coded to work seamlessly out of the box.

Key Features:

• Fully Customizable: Easily tweak the color, animation speed, tiling, radial scale, and the size/hardness of the central mask to perfectly match your game's visual style.
• Zero Texture Dependencies (Procedural): The speed lines are generated entirely via math inside the shader. It requires absolutely no external texture files, keeping your package size and memory usage to an absolute minimum.
• Mobile-Friendly: Thanks to its highly optimized procedural structure, it runs smoothly with great performance on mobile platforms.
• Quick & Easy Setup: Integrate it into your camera in seconds using the provided Scriptable Renderer Feature for URP, or a simple MonoBehaviour script for the Built-in pipeline.

• Complete UI system: buttons, panels, sliders, toggles
• Themed icons and game elements
• Pre-designed popups (confirmation, rewards, error, level up)
• Demo screens (lobby, gameplay, UI examples)
• Consistent rock/adventure visual style
• Fully customizable and layered assets
• Optimized for Unity Canvas UI
• Easy drag-and-drop integration
• Clean and organized file structure
• Compatible with URP and Built-in Render Pipeline

Adventure Rock Theme UI Kit is a complete 2D interface pack designed to help you quickly build clean and polished game UIs with an adventure/jungle style.

2D Asset Details:

- 87 UI elements (buttons, panels, icons)

- Resolution: Varies per asset

- File Format: PNG

- Color Depth: RGBA

- Transparent Backgrounds: Yes

- UI Type: 2D Sprite-based

What’s included:

Buttons (play, settings, shop, etc.)

Panels and windows for menus

Popups (confirm, rewards, error, level up)

Icons (items, currency, UI symbols)

Sliders and basic UI controls

Lobby and gameplay UI demo screens

What it’s for:

Adventure and jungle-themed games

Casual and mobile games

Puzzle or exploration games

Developers who want ready-made UI

Why use it:

Saves UI design time

Easy to customize (colors, text, layout)

Works with Unity Canvas (drag & drop ready)

Clean and consistent visual style

Perfect for quickly creating a professional-looking game interface without starting from scratch.

Unity Version: 2021.3 or newer (recommended)
Render Pipeline:
– Core functionality is render pipeline independent
– Tested primarily with Universal Render Pipeline (URP)
– Weight visualization shader is currently URP-based and may require adjustments for Built-in or HDRP

Supported Platforms:
– Editor tool (Windows, macOS)

Dependencies:
– No external dependencies required

Content:
– Editor scripts
– Debug visualization tools
– Demo scene included

Limitations:
– Weight visualization currently optimized for URP

Documentation:
– Included in package

Rig Debug Toolkit is a powerful Unity Editor extension designed to simplify rig debugging, bone inspection, and skinned mesh analysis.

Working with rigs in Unity can be slow and frustrating — navigating deep hierarchies, guessing bone positions, and debugging weights without proper visualization.
This tool solves that problem by bringing all essential rig debugging features directly into the Scene view.

With Rig Debug Toolkit you can instantly visualize bones, select them directly in the scene, inspect components, and generate detailed reports — all in a fast and intuitive workflow.

Key Features:
• Real-time bone visualization in Scene view
• Direct bone selection and highlighting
• Bone filtering and quick navigation
• Component inspection and debugging tools
• Bone report generation for analysis
• Clean Editor overlay UI
• Optimized workflow for technical artists and developers

Designed for technical artists, gameplay programmers, and anyone working with character rigs, Rig Debug Toolkit helps you debug faster and work more efficiently inside Unity.

Technical Features

• 100% scalable (vector-based design)
• High-quality clean edges (no pixel loss)
• Well-organized layers & groups
• Easy to edit colors, glow, and effects
• Compatible with Photoshop, Illustrator 
• Optimized for UI/UX, game design, and motion graphics

Designed for games, apps, dashboards, streams, and sci-fi interfaces. This collection features sleek metallic elements, HUD components, and modular UI parts that are fully customizable and scalable.

Crafted with precision and modern design trends, these assets bring a clean cyberpunk / sci-fi aesthetic to any digital product.

File Details

• PSD FileSize: 1920 × 1080 px (Full HD)
  Fully layered & organized
  Smart objects included
  Easy color customization
• Transparent background
• High-resolution export
• Ready to use in any project
  

• 30+ Specialized Raymarching Shaders (Lit, Unlit, Matcap, and Special Effects).
• 8 Core C# Scripts for physics handling and shader uniform management.
• Supports dynamic tracking for up to 20 objects simultaneously.
• Customizable SDF operators: Twist, Bend, Displacement, and Onion (Shelling).
• Dedicated HLSL Include library for Noise and Raymarching functions.

Package Content:

• Prefabs: 10 Ready-to-use VFX setups for quick integration.
• Shaders: Fully categorized library (Basic, Interactive, Deformations, Stylized).
• Textures: High-quality Matcap and Noise textures.
• Scripts: Modular and clean C# code for easy extension.

Technical Specs:

• Texture Sizes: 256x256 and 512x512 (Memory efficient).
• Number of Prefabs: 10.
• Render Pipeline: URP Only (Universal Render Pipeline).
• Unity Version Support: Unity 2021.3 LTS or higher (Requires Visual Effect Graph support).

Interactive Raymarcher is a high-performance toolkit designed specifically for the Universal Render Pipeline (URP). It allows developers to create and manipulate complex Signed Distance Fields (SDF) in real-time, focusing on organic shapes like metaballs, liquid blobs, and animated gyroids.

This package is built with performance in mind, making it an ideal choice for standalone VR (Meta Quest) and Mobile projects where GPU resources are precious but visual quality cannot be compromised.

Key Highlights:

• URP Optimized: Built from the ground up for the Universal Render Pipeline.
• Organic Blending: Achieve seamless, liquid-like transitions between procedural shapes using advanced "Smooth Minimum" logic.
• Real-time Physics Integration: Connect Unity’s physics engine directly to raymarched fields for truly interactive environments.
• Visual Excellence: Features built-in Subsurface Scattering (SSS), Fresnel effects, and procedural noise for high-end aesthetic results.
• Ready for VR: Battle-tested performance for mobile-based VR headsets.

Whether you're building sci-fi world-building tools, medical visualizations, or abstract VFX, this toolkit provides the core math and shaders to get you there.

• List of VFXs included: 11 Ready-to-use Smoke Prefabs/VFX
• Texture sizes: 1024x1024 and 2048x2048
• Number of Textures: 43
• Supported Unity Version: 2021.3 LTS or higher (URP Required)
• Target Platforms: All Platforms (PC, Console, Mobile, VR)

Technical Features:

• Custom URP Shaders (Built with Shader Graph)
• 6-Way Lighting & Normal Map Support
• Flipbook Blending & Texture Array Optimization
• Soft Particles (Depth Fade)
• Emissive, Scattering, and Ambient control parameters
• Custom HLSL lighting nodes included

Enhance your environments with Realistic Smoke URP, a comprehensive smoke VFX package built natively for the Universal Render Pipeline. Designed for high-quality visual fidelity and optimized performance, these smoke assets react dynamically to your scene's lighting across all platforms.

The core of this package relies on advanced Shader Graph implementations. By utilizing 6-Way Lighting and Normal Maps, the 2D smoke flipbooks achieve a convincing 3D volumetric look, allowing environmental lights (point lights, spot lights, main directional light) to illuminate the smoke from different angles naturally.

Key Features Include:

• Dynamic Light Reaction: Fully supports URP lighting with custom HLSL light nodes.
• 6-Way Lightmap Support: Pre-configured shaders to calculate directional light absorption and scattering.
• Smooth Animation: Flipbook blending ensures seamless transitions between animation frames.
• Depth Integration: Soft Particle calculations prevent harsh clipping intersections with your 3D geometry.
• Highly Optimized: Utilizes Texture Arrays to minimize texture binding overhead, making it suitable for VR and Mobile.
• Modular Architecture: Built with Shader Graph subgraphs, allowing you to easily customize or extend the logic.

• Render Pipeline: Universal Render Pipeline (URP)
• Required Packages: Visual Effect Graph
• Number of Prefabs: 1 highly customizable VFX Prefab
• Number of Textures: 48 unique Cookie Textures
• Texture Resolution: 512x512px
• Platform Compatibility: All platforms supported
• Supported Unity Versions: Compatible with any Unity version that supports the Visual Effect Graph package.

Volumetric Light Shafts URP is a highly customizable visual effect package designed to bring realistic and atmospheric god rays to your environments.

Whether you are creating sunbeams filtering through a dense forest, dusty light rays in a dark cave, or artificial spotlights in a sci-fi scene, this package provides the exact aesthetic you need. Powered by Unity's Visual Effect Graph, it includes a versatile library of 48 unique cookie textures, allowing you to instantly change the shape and style of the light shafts.

The effect is incredibly user-friendly. Simply drag and drop the provided prefab into your scene and easily adjust parameters—like the beam color you exposed—directly from the Inspector to match your project's mood perfectly.

Key Features:

• Plug-and-play visual effect prefab for instant integration.
• 48 high-quality cookie textures for varied light ray patterns.
• Easily adjustable colors and parameters via the Inspector.
• Built entirely with Visual Effect Graph for optimized performance.
• Fully cross-platform: Supports all platforms where Visual Effect Graph is available.

Number of textures: 2

Texture dimensions: (2048x2048)

Polygon count :

Minimum polygon count: 2268

Maximum polygon count: 2268

Number of meshes/prefabs: 3x1

Rigging: Yes

Animation count: 11

Animation type list:

1. Attack
2. Attack2
3. Death
4. Hit_Left
5. Hit_Right
6. Idle
7. Walk
8. Block
9. Jump
10. Jump_Attack
11. Run

UV mapping: Yes

LOD information: No LODs

Types of materials and texture maps:

Albedo, Normal in TGA Format

Polycount:

• Polygons: 2268
• Vertices: 2247
• Triangles: 3802

Animation list:

1. Attack
2. Attack2
3. Death
4. Hit_Left
5. Hit_Right
6. Idle
7. Walk
8. Block
9. Jump
10. Jump_Attack
11. Run

Requirements

• Unity 2021.3+ (recommended)
• Works in URP, HDRP, and Built‑in
• Editor‑only generation (runtime generation optional with minor adjustments)

Included

• Full building generator system
• Flat roof generator
• Sloped roof generator
• Facade and floor generation system
• Roof prop system (Flat + Sloped)
• Sample modular assets (for demonstration)
• Complete C# source code
• Editor tools and custom inspectors

Features

• Procedural building assembly
• Modular prefab‑driven design
• Realtime editor updates
• Captured facade plans
• Roof prop placement with spacing, probability, and socket rules
• Symmetry options for facades
• Clean, documented codebase
• Extensible architecture for custom modules

Performance

• Lightweight and optimized
• No heavy runtime overhead
• Designed for large‑scale city generation workflows

Pipeline Compatibility

• Works with any modeling style (realistic, stylized, low‑poly, voxel, etc.)
• Compatible with custom materials, shaders, and lighting setups
• Supports nested prefabs and variant workflows

Optimized for real production environments:   

Building Architect is structured to work flawlessly with camera occlusion, frustum culling, and LOD systems. Each generated building is organized into predictable, modular groups, making it easy to attach LOD Groups, apply custom culling rules, or integrate third‑party optimization tools.

Building Architect is a fully modular exterior building generator designed for artists, level designers, and technical creators who want fast, flexible, and reliable procedural architecture inside Unity.

With a clean and intuitive workflow, you can generate complete buildings — including walls, floors, facades, sloped roofs, flat roofs, and roof props in a simple click. 

Every change updates instantly in the editor, making iteration fast and enjoyable.

The system is built around a robust modular architecture: each building is assembled from interchangeable prefabs, allowing you to plug in your own assets, materials, and styles. Whether you're creating realistic cities, stylized environments, or prototype layouts, Building Architect adapts to your pipeline.

Key Features

• procedural generation Buildings Generate instantly floors, roof types, or design settings in 1 clic.
• Modular prefab‑based architecture Plug in your own wall modules, windows, doors, roof tiles, and props.
• Complete roof system
  Sloped roofs with multi‑row logic
  Flat roofs with edge and center modules
  Fully functional roof prop placement for both modes
• Facade generation Automatic placement of windows, doors, shops, and decorative elements with symmetry options.
• Captured facade plans Lock and reuse facade layouts across floors or entire buildings.
• Artist‑friendly controls Width, length, floors, symmetry, roof mode, and design presets — all editable in realtime.
• Clean hierarchy & optimized structure Generated buildings are organized, readable, and ready for further editing or export.

Use Cases

• Open‑world cities
• Stylized towns and villages
• Prototyping and level blockouts
• Architectural visualization
• Procedural content tools
• Game‑ready modular environments

Building Architect gives you the speed of procedural generation with the control of handcrafted assets — a perfect balance for modern Unity workflows

Performance‑ready architecture:   

Generated buildings follow a clean, modular hierarchy that works seamlessly with Unity’s occlusion culling, frustum culling, and LOD systems. Whether you use Unity’s built‑in tools or a custom optimization pipeline, Building Architect integrates smoothly into performance‑critical environments such as open‑world cities or large‑scale levels.

• Smooth first-person mouse look system
• Walking, sprinting, crouching, and jumping mechanics
• Leaning system (left/right) with adjustable offsets
• Zoom/aim system with configurable FOV and sensitivity
• Stamina system with sprint drain and regeneration
• Dynamic surface-based footstep system (walk, sprint, crouch sounds)
• Head bob camera motion while moving
• Procedural camera shake for idle and movement
• Safe crouch system preventing standing under obstacles
• Jump sound and optional breathing ambience audio
• Fully customizable movement and camera settings in the Inspector
• Layer-based surface detection for footsteps
• Demo scene included for quick setup and testing
• Lightweight and easy to integrate into existing projects
• Compatible with Built-in, URP, and HDRP render pipelines
• Works with Legacy Input Manager and projects using both input systems

Advanced FPS Controller is a complete and customizable first-person character controller designed to help developers quickly implement polished FPS movement mechanics in their Unity projects. The system focuses on smooth movement, realistic camera effects, and modular gameplay features that can be easily adjusted from the Unity Inspector.

The controller includes core FPS movement systems such as walking, sprinting, crouching, jumping, and zooming, along with additional mechanics like leaning, stamina management, and dynamic surface-based footstep sounds. Camera effects such as head bobbing and subtle camera shake are included to create a more immersive first-person experience.

The crouch system includes safety checks that prevent the player from standing up when there is an obstacle above the character, ensuring proper collision behavior in tight spaces such as tunnels, arches, or low ceilings.

The package also includes a dynamic footstep system that allows developers to assign different sounds for walking, sprinting, and crouching on various surfaces using Unity layers. This makes it easy to create immersive environments where footsteps change depending on materials like concrete, wood, grass, or metal.

Most gameplay parameters are fully customizable through the Inspector, including movement speeds, jump height, gravity strength, stamina drain and regeneration, lean angles, camera motion, and footstep timing. This allows the controller to be adapted for different gameplay styles and genres.

Advanced FPS Controller is suitable for a wide range of first-person games including:

• FPS shooters
• survival games
• horror games
• exploration games
• simulation projects
• prototypes and game jams

The system is designed to be lightweight, easy to integrate, and extendable, allowing developers to build additional mechanics such as weapon systems, interaction systems, or inventory systems on top of it.

A demo scene is included to demonstrate the controller's features and provide a quick starting point for integration into new or existing Unity projects.

Resolution: 2048x2048

Maps included:

- Color

- Normal

- AO

- Height

- Mask

This pack contains:

10 seamless textures

🏗️ Core Architecture & Features:

• UI Framework: Built entirely with Unity UI Toolkit (USS + C# programmatic, no UXML). Feels native to the Editor at every level.
• Architecture: MVC + Command Pattern for clean separation of concerns and predictable state management.
• Undo / Redo: LinkedList-based CommandHistory with descriptive action labels. Persists across all board operations.
• Persistence: JSON serialization via JsonUtility with a versioned migration chain (v1.0 → v1.6). Auto-save is batched via EditorApplication.delayCall to prevent save-on-every-keystroke overhead.
• Performance: Debounced search (250ms), lazy RebuildBoard() calls, ScrollerVisibility.Auto to prevent layout shifts, CSS transitions for smooth animations at zero CPU cost. No reflection, no serialization overhead.
• GC Optimized: No unnecessary allocations during board interaction or card rendering.
• Settings, Archive & Shortcuts: Implemented as standard IMGUI Editor Windows for maximum Editor compatibility.
• Assembly Definitions: Fully isolated compile times via .asmdef files.

🔗 Dependencies & Requirements:

• Unity 6000.3 or newer (UI Toolkit required)
• Compatible with Built-In, URP, and HDRP render pipelines
• Editor-only zero runtime overhead, no impact on build size
• Works with any project type and any game genre

📂 What's Included:

• Full C# source code
• USS stylesheets (dark theme, CSS variable-based)
• JSON data file (auto-created on first use)
• Unit tests (NUnit, EditMode)
• Assembly definition files

Welcome to FrostBoard a fully-featured project management tool built

directly into your Unity Editor.

Stop switching between Trello, Notion, and sticky notes. Stop losing

context every time you alt-tab out of Unity. Everything your team needs

to stay organized lives exactly where you work.

Built from the ground up with Unity 6's UI Toolkit, FrostBoard feels

completely native to the Editor. It's snappy, keyboard-driven, and

designed for solo developers and small teams who want professional-grade

task tracking without the overhead of external tools.

DOCUMENTATION | YOUTUBE

🔥 Key Features

• Zero Context-Switching: Your entire project board lives inside Unity. Open FrostBoard, manage it, close it never leave the Editor.
• Drag-and-Drop Kanban: Unlimited columns, full card and column reordering, inline Add Task / Add Column buttons, and visual WIP limit indicators per column.
• Rich Task Cards: 3 display modes (Compact, Normal, Detailed). Toggle 9 fields per card Priority, Labels, Story Points, Due Dates, Subtasks, Comments, Assignee, Dependencies, and Task Type. Overdue highlighting, subtask progress bars, and card aging for stale tasks.
• Task Detail Panel: A full-screen slide-in panel with every field your team needs. Fibonacci story point quick-pick (1–21), integrated calendar date picker, subtasks with checkboxes, timestamped comments, and Blocked by / Blocking dependency tracking.
• Swim Lanes: Group your board by Assignee, Priority, or Task Type in one click. Column headers stay visible at all times.
• Team Members: Define your team once — name and color. Assignees become a clean dropdown, and color-coded avatars appear on every card automatically.
• Full Undo / Redo: Every board action is undoable with descriptive tooltips ("Undo: Move task to Done"). Nothing is ever accidentally lost.
• Archive & Templates: Archive tasks off the board without deleting them. Restore anytime. Save any task as a reusable template and spawn it via right-click.
• Multi-Select & Batch Actions: Ctrl+Click to select multiple cards. Batch delete, move, or archive in one action.
• Keyboard-First: Ctrl+Z Undo, Ctrl+N New Task, Ctrl+F Search, Arrow Keys to navigate, Delete to remove. Full shortcut reference built-in (Ctrl+Shift+/).
• Smart Search & Filters: 250ms debounced text search across title, description, and assignee. Priority and label filter dropdowns. "Showing X of Y" status bar.
• Zoom Support: Scale the board from 60% to 150% with Ctrl+Scroll. Zoom level persists between sessions.

💾 Persistence & Performance

FrostBoard auto-saves on every change via batched EditorApplication.delayCall. JSON-based save file lives inside your project. Data versioning with automatic migration chain ensures your board survives every update. Debounced search, lazy board rebuilds, and zero reflection overhead keep everything fast.

Questions?

contact@frostemberstudios.com

Number of textures: 40

Texture dimensions: 4096x4096

Polygon count of : about 5 000 faces each character

Number of meshes/prefabs: 20/20

Rigging: Yes

UV mapping: Yes

Types of materials and texture maps: Color, Normal map

Mixall studio presents a good solution for your games, VR projects and simulators: Beach Bundle - Boys and Girls. A set of 20 character in swimsuits. Perfect for VR projects

*The models are single-mesh and may not always be suitable for close-ups; please view screenshots before purchasing.

You can also purchase Beach characters - Boys and Beach characters - Girls characters separately, but by purchasing this package you save 20%

★ Key Features ★

• 20 character in swimsuits
• Characters are setup to work with Mecanim (no animations included in this pack)
• low poly mesh grid
• HDRI beach map

★ Assets ★

• 20 characters with rig

★ Other Assets ★

Combine this asset pack with our other assets:

-Beach - resort

-Miami beach - modular street

-Boxing equipment - helmet and gloves

-Hockey arena - sport pavilion

-Fitness hall - sports equipment

-Boxing hall - interior and equipments

-Universal sport hall - basketball, football, volleyball, tennis

-Boxing arena - fighting show

-Swimming Pool

-Octagon - fighting ring and show arena

-Cloakroom - interior and props

-Fitness hall - interior and props

-Small pool - interior and props

-Sports equipment - balls and outfit

Need support? Write to us: Mixall.team@gmail.com

★ Follow us on social media ★

INSTAGRAM | YOUTUBE | FACEBOOK

ARTSTATION | PINTEREST | DISCORD

- Quest Management: Singleton SimpleQuestManager with full lifecycle control (start, complete, fail, abandon, reset). Supports 4 objective types (Simple, Counter, Location, Conversation) and 5 reward types (Currency, Item, Experience, Reputation, Custom). Event-driven architecture with callbacks for all state changes.

- Visual Dialog Editor: Node-graph editor for building branching dialog trees stored as DialogTreeAsset ScriptableObjects. 15+ node types across 4 categories: Speech (Say, PlayerChoice, Narration), Flow (Start, End, Branch, BranchOnQuestStatus, Sequence, Random), Conditions (CheckQuest, CheckObjective, CheckVariable, CheckInventory), and Actions (StartQuest, CompleteQuest, GiveReward, SetVariable, TriggerEvent).

- AI Quest Generator: Natural language parser (AIQuestGenerator) using regex-based extraction to parse objectives, rewards, and story context from plain English descriptions. Generates Quest assets and complete dialog trees with proper node wiring for all 5 quest states. Story-aware dialog generation produces contextual NPC dialogue referencing threats, locations, and task details from the original description.

- 4 Dialog UI Styles: Classic RPG, Cinematic, Speech Bubble, and Minimal -- each supporting typewriter text effects, continue indicators, choice buttons, speaker portraits, and fade animations. Switchable per-NPC or globally via DialogManager.

- Trigger System: QuestLocationTrigger for area-based objective completion with optional discovery dialogs, QuestCollectible for counter-incrementing pickups with effects and sounds, QuestConversationTrigger for dialog-driven completion.

- Save/Load: Automatic PlayerPrefs-based persistence with manual serialization API. Full state restoration including objective progress and counter values.

- Dialog Blackboard: Per-conversation and global variable system supporting Bool, Int, Float, and String types. Used for conditional branching and reward distribution.

Simple Quest System is a fully-featured quest management and dialogue framework for Unity 6+.

It enables developers to create, track, and complete quests with multiple objective types (counter, location, conversation, simple) and a flexible reward system supporting currency, items, XP, reputation, and custom data.

The centerpiece is a visual node-based dialog editor that supports branching conversations with speech, player choices, narration, conditional branching, and quest-aware actions like starting, completing, and rewarding quests directly from dialog trees.

Four professionally designed UI styles are included out of the box: Classic RPG, Cinematic, Speech Bubble, and Minimal.

The standout feature is the AI Quest Creator, which lets developers describe a quest in plain English and automatically generates a complete Quest ScriptableObject with objectives and rewards alongside a fully-wired dialog tree handling all quest states -- from initial offer through acceptance, progress checking, turn-in, completion, failure, and abandonment.

The system also includes a quest journal, on-screen tracker, alert notifications, save/load support, trigger components for locations and collectibles.

Simple demo scene included

Furture Enhancements include:

  Dialog & UI

  - Localization support for dialog text and quest descriptions

  - Animated portrait expressions that change with emotion states

  - Skip/fast-forward for previously seen dialog

  Quest System

  - Quest chains/prerequisites — require completing one quest before another unlocks

  - Timed objectives with visible countdown UI

  - Branching quest outcomes — different endings based on player choices

  - Quest difficulty levels or level requirements

  Triggers & Interaction

  - Kill/defeat objective trigger (enemy death increments counter)

  - Escort objective type

  - Multi-step objectives (e.g., go to location then collect items there)

  - Proximity-based auto-dialog for ambient NPC chatter

• *Works on all input systems.*
• *Works on all render pipelines.*
• *Supports Unity 2019.4 or newer.*

More From Creator

• Collapsible Headers - An editor tool that makes [Header] attributes collapsible to clean up the editor.
• Collapsible Events - An editor tool that makes UnityEvents collapsible to clean up the editor.
• Fish In VR - A complete physics driven VR fishing solution for Unity game engine.
• Drive In VR - A powerful VR driving system that lets you steer using a steering wheel or handle bars using your XR controllers (or hand tracking).
• Chess Engine & AI (Multiplayer) - A complete multiplayer chess game that supports all target platforms, Netcode and PUN2 multiplayer, and has cross-platform DLC for AI like Stockfish.

Missing Script Registry (MSR)

Have you ever opened an old Unity project or updated a third party asset pack, only to be met with dozens of "Missing (Mono Script)" warnings? We have all been there, staring at an empty box in the Inspector with absolutely no memory of what script used to be attached.

MissingScriptRegistry solves this completely. By hooking into native Unity events, it runs silently in the background and builds a persistent shadow map of your project architecture. As you work and click around your scenes, it automatically pairs every component instance to its validated file path and class name. It even cracks open compiled DLLs to track specific scripts inside them.

When a link inevitably breaks, the tool steps in. Instead of a useless blank box, you are presented with a human readable recovery plan showing the exact original filename and location. You get the clarity you need to restore your game rather than rebuilding it from memory.

Built for Performance

It is designed to be completely invisible while you work. Instead of causing Editor stutters by scanning your whole scene on a loop, it uses a lazy event driven approach. It maps objects instantly when you click on them or save your scene, keeping your frame rate smooth. It also uses a highly optimized string dictionary system that relies on Unity's native GUIDs. This avoids duplicating paths for tens of thousands of components, keeping the memory footprint incredibly small.

Team Friendly

Your registry is saved as a clean JSON file in your ProjectSettings, making it completely friendly for Git and version control. If a teammate accidentally breaks a prefab and pushes it, your local registry will read the broken reference, check the team shadow map, and immediately tell you what script they deleted so you can fix it without asking them.

Features

• ✍️ Editor-only: Zero runtime cost.
• 🕵️ Silent Tracking: Automatically maps components to their source scripts in the background as you click around and save.
• 🚑 Instant Recovery Info: Replaces useless missing script warnings with the exact original file path and class name.
• ⚡ Ultra-Optimized: Uses an event-driven scanning system and lightweight string dictionaries to guarantee zero stuttering in massive scenes.
• 📦 Full Managed DLL Support: Accurately identifies and tracks individual scripts compiled inside external assemblies.
• 🤝 Team & Git Friendly: Saves registry data cleanly to ProjectSettings using Universal Identifiers to prevent version control merge conflicts.
• 🔎 Missing Script Finder: An editor window that quickly shows you which GameObjects are missing scripts and allows you to easily select them with 1-click.
• 🧹 Self-Cleaning: Automatically purges dead records of intentionally deleted scripts over time to prevent file bloat.
• 🎨 Native UI Integration: Flawlessly mimics Unity's default missing script Inspector while retaining full drag-and-drop repair functionality.
• 📋 Built-In Debugger: Includes a custom window with a real-time activity feed to see exactly what the registry is tracking.
• 😑 Minimal Footprint: Designed to stay completely out of your way and feel like a native Unity feature.
• 🧩 Widely Compatible: Works from Unity 2019.4 to the latest Unity 6.x.

Documentation:

Documentation

Modern Shooting UI Pack is a clean, friendly modern shooting game UI skin pack.Can be used for PC or mobile games.

1.The canvas prefabs and 9-sliced pngs were ready ,so you can easy to use them in unity!

2.Each element is separate, so you can replace it with your own icon, text, etc..You can use them completely in unity, almost without any ps processing.So this is a lazy UI skin package.

3.Include editable psd source files,meet your advanced customization needs.

Demo Scenes:

• Loading Page

• Login Page

• Stage Select

• Level Select

• Home Page

• Main Scene1

• Main Scene2

• Daily Reward

• Receive Rwards

• Crafting Panel

• Store

• Popup

• Recharge

• Missions

• Settings

• Level up

• Inventory

• Armoury

• Ranking

• Pause

• Victory

• Died

• Quit

• Sniper Rifle Sight

• Character Creation

• Matching Hall

• Components

• Icons

• Backgrounds

Asset contains:

--Demo Scene

--1000+ 9 sliced png files

--30 editable psd files

--Free icons(128px)

--Fonts

--Scripts

More Packs:

https://assetstore.unity.com/publishers/39517

If you have any questions or have better suggestions about this asset, please contact us immediately.Thanks.

Number of textures : 4

Texture dimensions : 512*512

Polygon count :

• Bulldozer - 6,134
• WheelLoader - 2,918
• Excavator - 5,517
• Dump_Truck - 3,444
• Tower_Crane - 3,032

Minimum polygon count : 2,918

Maximum polygon count : 6,134

Number of meshes/prefabs : 22 prefabs

UV mapping: Yes

Texture maps : Base Color, Emission

This stylized low poly construction heavy equipment pack includes 5 different vehicles designed for construction site and industrial environment scenes. It is suitable for games, simulations, and other real-time projects.

Included vehicles:
• Excavator
• Bulldozer
• Dump Truck
• Tower Crane
• Wheel Loader

All models feature clean topology and are optimized for efficient performance in real-time environments.

Some parts are separated to allow simple movement setups within your scene (such as rotating wheels or movable components). No animations are included, giving you the flexibility to implement your own animations if needed.

Note: Each vehicle in this pack is also available as an individual asset on the Asset Store. Purchasing both the individual assets and this pack may result in duplicated content.