Feed aggregator

Polygons 16,513

Vertices 17,256

Number of textures 4

Texture dimensions 4096x4096

Number of prefabs 1

Rigging No

UV mapping Yes

Types of materials and texture maps PBR

A high-quality, low-poly stylized rocket perfect for games, animations, and mobile apps. This model features a clean, "toony" aesthetic with a vibrant blue and white color scheme. Despite its optimized geometry, it includes high-resolution 4K textures to ensure crisp details even in close-up shots.

- Prefabs: 53

You can choose from five different body colors and nine different facial expressions. You can see images of all the prefabs. All of them are already set up.

- Animations: 7

Idle, Walk, Run, Jump, Sit, Sleep01, Sleep02

- Demo scene: 3

- Polygon count: 7456

- Textures: 59

- Texture size: 1024x1024

- System requirements: Ver.2019.4.41 or higher

Please feel free to contact us if you have any questions or problems.

You can choose from five different body colors and nine different facial expressions. You can mix and match the striped body and face parts to create your own cat. (There are 53 pre-set prefabs in total.)

Its simple design and low-poly style make it perfect for mobile games.

---------------------------------------- short technical description -----------------------

• Vertex counts of characters: 26884
• Texture Resolutions: (body x4096 weapons x2048)
• Number of Animations: 46

------------------------------------------------ SUPPORT ----------------------------------

Email: dyl.props.environment.artist@gmail.com

---------------------------------------------Demon Swordsman----------------------------

Demon Swordsman - https://youtu.be/pOT-gMJ5jGo

------------------------------------------------ FEATURES --------------------------------

• fabric simulation
• 3 sets of unique texturesanimation;
• Sword

7x attack

1x death

2x hit

2x idle

1x rage

2x run

6x Walk

1x Jump

1x Turn Left 90

1x Turn Right 90

1. monster

8x attack

1x death

2x hit

2x rage

2x idle

2x run

2x walk

1x fear

1x fear run

1x hysterics

Asset Content:

• 30+ Unique Meshes: Environment pieces, tools, furniture, industrial machines, and props (.FBX). （Below are the polygons of the unique meshes）
• BenchDrill:4954
• BluedNut:168
• BluedScrew:250
• CoffeeSign:2
• Gear:786
• Hammer:688
• Nut:168
• PlasticNut:168
• PlasticScrew:250
• Screw:250
• SM_BandSaw:4091
• SM_Barrel:872
• SM_Cabinet:596
• SM_Cardbox:156
• SM_CeilingLight:1560
• SM_CeilingLight_NoCable:1528
• SM_CoffeeBag:282
• SM_CoffeeBrewer:2538
• SM_CoffeeGrinde:1898
• SM_CoffeeMug:448
• SM_CoffeePortafilter:1008
• SM_CoffeePot:1640
• SM_Dustbin:962
• SM_DustbinBucket:576
• SM_DustbinLid:386
• SM_PropBox:456
• SM_Rack:528
• SM_WoodenCrate:728
• SM_Workbench:788
• WarningSign:2
• Wrench1:544
• Wrench2:478
• Textures: High-quality 2K PBR Maps (Albedo, Normal, Metallic/Smoothness, Ambient Occlusion).
• Texture Dimensions: 2048 x 2048 pixels
• Texture Types:
• BaseMap
• Normal Map
• Mask Map
• Ambient Occlusion (AO) Map
• Emission Map
• Materials: 6 Tiling materials for floors/walls and various decal textures to break up repetition.

Character & Animation:

• 1 Stylized Engineer: Fully rigged humanoid character.
• LODs: 3 Levels of Detail for performance optimization.
• Animations: Basic locomotion set (Idle, Walk, Run) and simple interaction animations.
• Scripts: Includes a lightweight, easy-to-use Character Controller script (and even a AI script).

Render Compatibility:

• Universal Render Pipeline (URP) - Recommended
• Built-In Render Pipeline

Additional Info:

• Designed specifically for Top-Down/Isometric views but suitable for Third-Person cameras.
• Demo scene included.

Kickstart your next project with the Stylized Engineering Workshop!

This all-in-one asset pack provides everything you need to construct a cozy, bustling workshop, factory, or garage. Designed with a clean, semi-realistic art style, this package is optimized for Top-Down perspectives (management sims, ARPGs) but detailed enough for Third-Person exploration.

✨ Complete Environment Kit

From brick walls and wooden storage to heavy industrial machinery like drill presses and bandsaws, you can build a scene that feels lived-in and functional. The assets utilize 2K PBR textures to ensure they look great under any lighting condition.

👷 Meet Your Engineer

Bring the scene to life immediately with the included Engineer character. He comes fully rigged with 3 LOD levels and a suite of essential animations (locomotion + interaction). We’ve even included a simple, plug-and-play character controller so you can start walking around your level right away.

☕ Priorities First

While the heavy machinery is impressive, we’ve included the most critical piece of equipment for any engineering project: The Coffee Machine. Complete with mugs and coffee bags, your digital workforce will never suffer from a lack of caffeine. 

Key Features:

• Render Pipeline: Built for URP, but fully compatible with the Standard (Built-in) Render Pipeline.
• Custom Shaders: Includes a custom 2-Layer Height Blend shader to create seamless, realistic transitions on floors and walls.
• Versatile: Perfect for strategy games, tycoons, or stylized adventures.

Unity Version: 2021.3 LTS or newer

Render Pipeline: Built-in / URP / HDRP compatible

Platforms: All Unity-supported platforms (PC, Mobile, VR, Console*)

Dependencies: None (no third-party packages required)

Audio Middleware: Uses Unity’s native AudioSource system

Architecture

• Centralized AudioSystem
• Data-driven SoundDefinition
• Struct-based PlayContext (no runtime allocations)
• Deterministic QueueController
• Pooled AudioVoice instances
• Runtime Debug Window (Editor only)

Layered Flow:

AudioTrigger → AudioSystem → QueueController → AudioVoice → AudioSource

Performance & Optimization

• Zero runtime allocations during playback
• No LINQ usage
• No reflection
• No dynamic GameObject creation during play
• AudioSource pooling (no instantiation spikes)
• Global voice limit protection
• Deterministic voice stealing
• Safe shutdown handling

Suitable for:

• Mobile projects
• VR applications
• UI-heavy systems
• Dialogue-heavy games
• Long-running sessions

Features

• QueueAllClip selection modes:
  Single
  Sequence
  RandomWeighted
  
• Per-sound or per-category queueing
• Cooldown & anti-spam protection
• SingleGlobal instance mode
• Protected voices
• Delay modes (Fixed / RandomRange)
• Runtime queue control (Next / Prev / Skip / Clear)
• PlayContext temporary overrides
• Zero-code AudioTrigger component
• Editor Debug Window (Active + Queued sounds)

Code Quality

• No static global state corruption
• No hidden runtime editor coupling
• Clear public API surface
• Deterministic execution order
• Safe under heavy load

Documentation

• Structured workflow documentation
• API reference examples
• Usage best practices
• Performance notes
• Common mistake guidance

🎧 Woi Audio System

Clean. Simple. Deterministic. Production-Ready.

🧩 Simple to Use

Add AudioSystem → Create SoundDefinition → Call Play()

That’s it.

No setup chaos. No hidden magic. Just structured audio.

🎮 Live Demo

Try the system directly in your browser or pc:

🔗 WEB DEMO | PC DEMO

Important Note:

This package does not include any music, sound effects, or demo audio clips.

Any audio used in preview videos, promotional content, or demonstration materials is for presentation purposes only and is not included in the package.

👨‍🎨 Designer-Friendly

All behavior lives inside SoundDefinition.

No hardcoded rules.

No scattered logic.

Use AudioTrigger for zero-code playback.

Designers control behavior. Programmers just send intent.

🚀 Why Developers Choose It

🧠 Deterministic Playback

No unpredictable overlap. Clear execution rules.

⚡ Optimized & Safe

Zero runtime allocations during playback

AudioSource pooling

Global voice limit protection

Safe shutdown handling

🔁 Advanced When Needed

Queue system

Sequence / Random / QueueAll

SingleGlobal rules

Cooldown & anti-spam

Runtime queue control

🔍 Built-In Debug Window

See active sounds

See queued sounds

Skip / Clear instantly

No more “Why is this not playing?” questions.

🎮 Built for Indie PC Developers

Perfect for:

• Story-driven games

• UI-heavy projects

• Dialogue systems

• Audio-sensitive mechanics

• Small teams that need structure

Lightweight enough for indie scale.

Structured enough for production.

📚 Well documented

🤝 Ongoing support

🧱 Clean architecture

⚙ Production-safe

Woi Audio System keeps audio predictable, optimized, and scalable — without overengineering.

• Architecture: Pure C# implementation using Unity.Collections, Unity.Jobs, and Unity.Burst.
• Solver Type: XPBD (Extended Position Based Dynamics) with constraint regularization.
• Performance: Fully multi-threaded simulation step. Zero-garbage collection during runtime (uses NativeArray and persistent allocators).
• Supports: Standard, URP, and HDRP (via standard Material support).
• Rendering:Procedural Mesh generation on the GPU/CPU boundary using Burst.
• Dependencies: Requires Burst and Mathematics packages (installed via Package Manager).
• Compatibility: Compatible with Unity 2021.3 LTS and newer.
• Platforms: Supports PC, Mac, Linux, Consoles, and High-End Mobile (iOS/Android) due to Burst optimization.
• Included: Full source code, 5 demo scenes (Grappling Hook, Bridge, Stress Test, Cutting, Winch), and PDF documentation.

Tensio is a cutting-edge rope simulation framework designed for developers who need more than just a visual line renderer. Whether you are building a physics puzzle, a swinging mechanic, or a realistic environment, Tensio provides the stability and performance required for gameplay-critical physics.

Built on the Extended Position Based Dynamics (XPBD) method, Tensio simulates elasticity, stiffness, and mass with high precision. It fully leverages Unity's Data-Oriented Technology Stack (DOTS) to handle hundreds of particles across multiple ropes with minimal CPU overhead.

Key Features

• XPBD Physics Solver: Stable, jitter-free simulation that supports both stretchy elastic ropes and rigid, non-stretching chains using sub-stepping.
• Two-Way Coupling: Real physics interaction; ropes can pull Rigidbodies, and Rigidbodies can pull ropes.
• Environment Collision: High-performance SphereCast collision for continuous detection against static and dynamic world geometry.Advanced Collision:
  Self-Collision: Ropes won't pass through themselves.
  Inter-Rope Collision: Multiple ropes can tangle and interact complexly.
  
• Aerodynamics: Built-in wind and turbulence simulation with air drag.Dynamic Interaction:
  Runtime Cutting: Slice ropes at any point in real-time.
  Grabbing & Pinning: Attach particles to objects or move them via script.
  
• Procedural Rendering: Smooth, tube-based mesh generation with support for textures, normal maps, and UV tiling. Includes Visual Stress (ropes thin out/change color under tension) and specialized Chain Rendering.
• Editor Tools: Intuitive Bezier curve editing for defining initial rope shapes directly in the scene view.

Immersive Procedural Audio:

• Tension-Based SFX: Dynamic creaking and snapping sounds that automatically modulate pitch and volume based on real-time physical stress. Hear the rope strain before it breaks!
• Velocity Whoosh: Aerodynamic wind sounds driven by the speed of individual rope particles during swings.
• Spatial Accuracy: Sound sources follow the exact point of highest tension or impact along the curve for fully 3D spatialized audio.

Third-Party Notice: This asset uses various audio and texture files under the CC0 1.0 Universal License; see the Third-Party Notices.txt file in the package for details.

1.Professional UI element design

Centered around scifi and cyberpunk, the unique and professional design is suitable for various scifi-themed games.

2.Richly styled elements

Buttons(4 states),popups,panels,sliders,labels,tabs,frames,input fields,check box,swiths,radios,tips,drop-down menu,liner progress,circular progress,etc.

3.UI elements as prefabs

Prefabs for individual elements were ready ,so you can easy to use them! All you need to do is drag the prefabs into your scene to easily create your own UI, or you can directly use the pre-built Canvas UI.

4.Sliced sprites

9-Sliced sprites were ready,so you can change size and color easily in unity 3d.

5.Customizable

Each element is separate, so you can use your own icon, text, etc.The white UI elements in the components are layered and their colors can be customized.

6.Resolution

Demo scene:1920*1080px

Components:3840*2160px

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

✪ Asset Content ✪

■ Textures

1800+ png textures(from 128px*128px to 3840px*2160px)

■ Prefabs

400+ prefabs

■ Scenes

2:Demo scene and component scene

■ Canvas

Scene Canvas:25

Components Canvas:20

■ Scripts

14 scripts

■ Animations

6 animations

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

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

Support:dfystudio.art@gmail.com

Key Features

• gameplay loop:
  Planting
  Growth stages
  Watering
  Fertilizing
  Harvesting
  
• Built entirely using Game Creator 2 systems (no custom runtime code required)
• Fully integrated with Game Creator 2 Inventory
• Seeds, crops, and tools are standard Inventory items
• Per-crop configuration via Scriptable Objects / data assets
• Visual, inspector-driven setup
• Demo scene included

• THIS ASSET DOES NOT CONTAIN CROPS, ONLY SYSTEM WITH GC2 INTEGRATION. (there is a AI Generated Carrot with 5 stages of growth and a soil planter meant for learning and demonstration purposes only)

Requirements

• Unity 2021 LTS or newer
• Game Creator 2 (Core)
• Game Creator 2 Inventory Module
• Game Creator 2 Inventory Examples (required)
• TextMeshPro

Game Creator 2 Farming System is a modular and fully data-driven farming framework suitable for a wide range of game genres, including survival, RPG, life-sim, cozy games, and farming simulators.

The system uses Game Creator 2 Actions,Variables and custom scripts allowing designers to configure farming plots, crops, and interactions visually without scripting.

All farming behavior including growth stages, watering requirements, fertilization, spoilage, and harvesting can be customized per crop.

A demo scene and Quick Start window are included to help users get up and running quickly.

This asset is ideal for developers who want a robust farming system that feels native to Game Creator 2 and follows its no-code philosophy.

🛠 Technical DetailsFast Reload bypasses Unity’s heavy Domain Reload process by using a Roslyn-based incremental compiler to inject modified logic directly into memory.

• Performance: Average injection time of ~0.5s (may scale with dependency chain complexity).
• State Preservation: Automatically transfers field data from old instances to new logic using our custom StateManager.
• Dynamic Injection (New): Supports real-time addition and initialization of new fields and C# Event Actions during Play Mode.
• Smart Callbacks: Use the [InvokeOnFastReload] attribute to trigger initialization logic immediately after a patch.

⚠️ Technical Notes & LimitationsTo maintain engine stability and transparency, certain structural changes require a standard Unity Re-compilation:

• Inspector Visibility: Newly added fields exist in memory but will not appear in the Unity Inspector until a formal re-compile.
• Unity System Callbacks: Engine-level callbacks (Awake, Start, OnCollisionEnter, etc.) must exist in the script before entering Play Mode to be patched.
• Generic Refresh: When editing a Generic method, you must also save the script that calls it to refresh the dependency chain.
• Auto-Properties: Currently, manual properties with backing fields are recommended over auto-implemented properties.

📋 System Requirements

• Unity Version: 2022.3 LTS or higher (Including 2023, and Unity 6).
• Operating System: Windows 10/11 Only (Uses kernel32.dll for memory protection and redirection).
• Scripting Backend: Mono (This is an Editor-only tool; it does not affect IL2CPP build stability).

💡 Pro Tip

If injection speed slows down after dozens of consecutive edits, simply hit the Manual Compile button in the Fast Reload window to refresh the engine state and restore peak performance.

Document

Fast Reload: Professional Hot Reloading for Unity "Keep your code as it is. Only the speed changes."

As projects grow, compilation times do more than just make you wait—they shatter your creative flow. Fast Reload is a high-performance Hot Reload solution that dramatically increases your development speed by injecting code changes into your live game in ~0.5 to 1 second, without a single domain reload.

🚀 Why Fast Reload?

• Zero Configuration: No extra using directives, script inheritance, or complex settings. Just import and code.
• Dynamic Field & Event Support (NEW): Add new variables and initialize them instantly. Support for adding and triggering C# Events during Play Mode is now fully available.
• Stay in the Zone: Don't stop Play Mode. The moment you save, your logic is injected via high-speed 64-bit Method Detouring.
• Identity Preservation: Our StateManager preserves the values of static fields and Singleton instances, keeping your game state intact.
• Unbeatable ROI: The time saved in just one day of development pays for this asset many times over.

🔥 Unmatched Power & Industry-Leading Feature CoverageFast Reload is engineered to handle real-world C# complexity that standard tools struggle with:

• Lambdas & LINQ: Real-time editing for complex queries and closure captures.
• Generics: Full support for modifying Generic classes, methods, and 'where' constraints.
• Dynamic Signatures: Change method parameters, return types, or add/remove methods on the fly.
• Modern C# Syntax: Full support for Switch expressions, Pattern matching, Null-coalescing, and Local functions.
• Specialized Attributes: Use [InvokeOnFastReload] to trigger custom initialization logic immediately after an update.

Invest your time in building great games, not watching loading bars. Once you experience this speed, there’s no going back.

- **Unity version**: 6000.0 or later

- **Dependencies**: com.unity.ugui 2.0.0

- **Optional dependency**: UniTask 2.0 or later (auto-enabled when installed)

- **Core features**:

- Command parsing/execution with pipelines and redirects

- Asynchronous execution via `async/await` (UniTask supported)

- Tab completion for commands and paths

- Shell variable define/lookup/removal

- Custom command registration (manual or assembly scan)

- FlyweightScrollView for large log output

- **Sample**: Basic Usage (Samples~/BasicUsage)

- **Documentation**: https://araiyuhki.github.io/UniTerminal_Reference/index.html

- **License**: MIT OR Apache-2.0

XTerminal is a string-based CLI execution framework that brings a Linux-like terminal experience into Unity. It supports shell constructs such as pipelines and redirects, and ships with built-in commands for file operations, text processing, and Unity object manipulation. With `async/await` execution and optional UniTask integration, it fits naturally into editor tooling, debugging consoles, and level-editing workflows.

**Key features**

- Shell syntax with pipelines (`|`) and redirects (`>`, `>>`, `<`)

- Built-in commands for file operations, text processing, and Unity-specific actions

- Easy extensibility for custom commands

- Variable expansion (`$NAME`, `${NAME}`) and tab completion

- Virtualized scroll view optimized for large logs

- Ctrl+C cancellation for long-running commands

Ideal for in-editor debug consoles, tool-integrated terminals, and in-game administration CLIs that boost productivity in Unity projects.

Texture Maps for Unity Universal Render Pipeline(URP) - Both Metallic and Specular Workflows

• AlbedoTransparent (4K) (2K) (1K)
• MetallicSmoothness (4K) (2K) (1K)
• SpecularSmoothness (4K) (2K) (1K)
• Normal (4K) (2K) (1K)

Unity High Definition Render Pipeline(HDRP) - Both Metallic and Specular Workflows

• Basemap (4K) (2K) (1K)
• MaskMap (4K) (2K) (1K)
• Specular (4K) (2K) (1K)
• Normal (4K) (2K) (1K)

Forklift Truck 03 Orange PolyCount Without Subdivision

1. Vertices - 79238
2. Faces - 72457
3. Tris -140171

Forklift Truck 02 Yellow PolyCount Without Subdivision

1. Vertices - 71444
2. Faces - 66043
3. Tris -127684

Features:

- UnityPackage is created using Built-in Render, URP and HDRP Textures are included in the package.

- Models with Glass and Transparent Meshes are assigned Unique Materials. So there will not any backface artifacts.

- Rig is created in Blender, this UnityPackage doesnot contain any Rig and Animations.

-Objects are grouped and named according to their real purpose, allowing the model to be rigged and animated easily.

-Clean and optimized topology is used for maximum polygon efficiency.

-All textures and materials are tailored and applied for high quality render results.

-Mid Poly and optimized for use for games, films, commercials, etc.

-All objects have fully unwrapped UVs and UVs are Overlapped to utilize more UV space and high texture quailty.

-No extra plugins are needed for this model.

Texture Maps for Unity
Universal Render Pipeline(URP) - Both Metallic and Specular Workflows
- AlbedoTransparent (4K) (2K) (1K)
- MetallicSmoothness (4K) (2K) (1K)
- SpecularSmoothness (4K) (2K) (1K)
- Normal (4K) (2K) (1K)

Unity High Definition Render Pipeline(HDRP) - Both Metallic and Specular Workflows
- Basemap (4K) (2K) (1K)
- MaskMap (4K) (2K) (1K)
- Specular (4K) (2K) (1K)
- Normal (4K) (2K) (1K)

Fantasy Trident 01

Vertices - 8796
Faces - 8567
Tris - 16836

Fantasy Trident 03

Vertices - 13547
Faces - 13280
Tris - 25872

Fantasy Trident 06

Vertices - 13299
Faces - 13132
Tris - 26068

Fantasy Trident 07

Vertices - 14147
Faces - 13851
Tris - 27992

Features:

- UnityPackage is created using Built-in Render, URP and HDRP Textures are included in the package.

- Models with Glass and Transparent Meshes are assigned Unique Materials. So there will not any backface artifacts.

- Rig is created in Blender, this UnityPackage doesnot contain any Rig and Animations.

-Objects are grouped and named according to their real purpose, allowing the model to be rigged and animated easily.

-Clean and optimized topology is used for maximum polygon efficiency.

-All textures and materials are tailored and applied for high quality render results.

-Mid Poly and optimized for use for games, films, commercials, etc.

-All objects have fully unwrapped UVs and UVs are Overlapped to utilize more UV space and high texture quailty.

-No extra plugins are needed for this model.

Unity Versions: 2021.3 LTS, 2022+, Unity 6
Render Pipelines: Built-in, URP, HDRP
Scripting Backend: Mono / IL2CPP
Input: Unity Input System (optional)
Localization: Unity Localization package (optional)
Documentation: Included
Source Code: Included

Why AXIS?

Every game needs settings.

Most teams rebuild them from scratch; menus, saving, rebinding, accessibility, events, profiles, graphics differences per pipeline…

AXIS solves this once, properly.

AXIS is a runtime-first settings and accessibility framework for Unity, designed to ship with real games.

It handles data, persistence, application, and events, so you can focus on UI and gameplay, not infrastructure.

Built for Unity 2021.3 LTS+ and Unity 6, AXIS works out of the box with UI Toolkit, Built-in, URP, and HDRP, and scales from indie projects to production pipelines.

What Makes AXIS Different?

• Not just a menu — a complete runtime settings architecture
• Accessibility-first design, not an afterthought
• Pipeline-agnostic graphics system via adapters
• Clean API & event system for reactive UI
• Designed to be extended, not locked down

Complete Settings Framework

• Graphics, audio, controls, accessibility, localization
• Centralized settings model with automatic persistence
• Apply settings instantly or via explicit Apply / Cancel flows

Accessibility Built In

• Text scaling
• High contrast mode
• Reduce motion support
• Fully configurable subtitles system
• Accessibility events for UI announcements

Cross-Render-Pipeline Graphics

• Built-in graphics adapters for: Built-in Render Pipeline, URP & HDRP
• Resolution, window modes, VSync, FPS limit, FOV
• Quality presets with smart fallbacks

Audio System Integration

• Master / Music / SFX / VO volume control
• Audio mixer–ready architecture
• Optional Night Mode support

Input Rebinding (Optional)

• Unity Input System support
• Runtime key rebinding
• Device-aware bindings
• Conflict detection events
• UI Toolkit–friendly rebind workflow

Profiles & Presets

• Create reusable settings profiles
• Apply presets at runtime (e.g. PC / Console / Accessibility presets)
• Capture current user settings into profiles

Modular & Extensible API

• Event-driven architecture
• Custom storage backends (JSON, PlayerPrefs, cloud, etc.)
• Replace or extend individual systems without modifying core code

Performance & Architecture

• Lightweight runtime footprint
• No per-frame polling
• Event-driven updates
• SRP-agnostic via adapter interfaces
• No dependency on legacy IMGUI

Compatibility

• Unity 2021.3 LTS or newer
• Unity 6 compatible
• Platforms: WebGL (with PlayerPrefs-based storage), PC, Consoles, Mobile
• Render Pipelines: Built-in, URP & HDRP
• Optional Packages: Unity Localization & Unity Input System
  

Included

• Full runtime framework
• Editor setup tools
• Sample scenes and scripts
• Example menus and integrations
• Complete documentation

Who Is This For?

• Indie developers who want professional-grade options & accessibility
• Teams shipping on multiple platforms
• Projects using UI Toolkit
• Developers who want clean APIs, not black boxes

Support

• Full documentation included
• Sample projects to learn from
• Clean, readable source code
• Designed for long-term project use

Bring modern, accessible, and scalable settings to your game with AXIS.

Technical Details

• Unity Version: Compatible with Unity 6 (6000.0.x) and newer.
• Dependencies: Requires com.unity.ui (UI Toolkit) - Standard in Unity 2022+.
• Build Support: Editor-only tool. Compatible with projects targeting All Platforms (Windows, Mac, iOS, Android, WebGL, Consoles).
• Assembly Type: Pre-compiled optimized DLL (Editor).
• Source Code: Core logic is DLL-encapsulated for compilation speed; Custom Rule templates are provided in C#.
• Documentation: Comprehensive PDF included.

Ship cleaner, faster, and safer with Asset Sentinel.

Is technical debt slowing down your development?

As projects grow, they accumulate "rot": missing scripts on prefabs, uncompressed audio files, duplicate assets, and debug materials left in release builds. Finding these manually is tedious and prone to human error.

Asset Sentinel automates this process. It acts as your project's gatekeeper, scanning thousands of assets in the background without freezing your Editor. It flags critical errors that break builds and optimization warnings that bloat your game size.

Key Features

• Build Guard: Never ship a broken build again. The pre-build processor automatically cancels the build process if Critical Errors (like Missing Scripts or Shader Errors) are detected.
• Asynchronous Scanning: Built on a time-sliced architecture, Sentinel scans massive projects without locking up your UI. Keep working while it scans.
• One-Click Fixes: Many rules implement IFixable. Fix texture compression, audio settings, or clean up empty folders instantly from the dashboard.
• Zero Runtime Overhead: The core system is compiled into a lightweight Editor DLL. No code or overhead is added to your player builds.
• Extensible API: Need project-specific checks? Create Custom Rules easily. The system automatically finds your scripts via reflection—no manual registration required.
• Modern Dashboard: Built with Unity's latest UI Toolkit, offering sortable columns, search filtering, and a clean, native look.

Included Rule Set (26 Built-in Rules)

Critical (Build Safety)

• Missing Script: Detects "Missing Behaviour" on Prefabs and ScriptableObjects.
• Scene in Build: Warns if a .unity file in your Scenes folder is not added to Build Settings.
• Shader Error: Detects materials using the broken (Pink) shader.
• Duplicate Assets: Detects binary identical files to save build size.

Graphics & Art

• Texture Power of Two: Ensures textures are POT for compression.
• Texture Compression: Flags textures set to "Uncompressed".
• Large Textures: Flags textures exceeding safe limits (default 2048px).
• Platform Override: Ensures specific overrides exist for Android/iOS.
• Read/Write Enabled: Flags Meshes with Read/Write enabled (memory waste).
• Mesh Tangents: Disables tangents on meshes without Normal Maps.
• Mesh Collider: Warns against expensive "Generate Mesh Collider" on import.
• Import Scale: Ensures models are imported at 1.0 scale.
• GPU Instancing: Checks if compatible materials have Instancing enabled.
• Double Sided GI: Flags materials with Double Sided Global Illumination enabled (expensive lightmapping).
• Sprite Atlas Size: Warns if Sprite Atlases exceed max texture dimensions.

Audio

• Audio Mono: Forces 3D SFX to Mono to save 50% memory.
• Load Type Optimization: Enforces "Decompress on Load" for short clips and "Streaming" for long music.

Performance & Code

• UI Raycast Target: Flags non-interactive UI elements (Images/Text) that block input.
• Particle System: Checks for excessive Max Particles or expensive Culling modes.
• Static Rigidbody: Flags Static objects that have Rigidbodies (high CPU cost).
• Empty Methods: Detects empty Update() calls in C# scripts.
• Huge Files: Warns about files > 100MB (VCS issues).
• Empty Folders: Detects empty directories cluttering the project.
• Static Mesh Animation: Flags Static objects that have Animator components attached.

Architecture

• Assembly Definition: Warns if a folder contains too many scripts (>20) without an .asmdef.
• Naming Convention: Checks standard prefixes (T_ for Texture, M_ for Material).

Features:

• 79 Unique Meshes
• Attention to Detail / AAA Quality
• Controllable parameters in Materials
• High-Quality Assets
• Game ready/Optimized
• Unique Concepts of Assets
• High Attention to Details
• Material Variations for some assets

Texture Sizes:

• 4096
• 2048
• 1024

Texture Size: 4096 for detailed Assets, 2048 for Mid-sized Assets, & 1024 for small assets

Collision: Yes, Custom collisions for complex assets

LODs: Yes, 4 LODs for complex assets , Nanite enabled for some meshes

Average Poly Count: around 1K up to 92K

Texture Map Types: Base Color / Diffuse, Normal, Smoothness / Roughness, Metalic, Opacity

Materials: This asset contains PBR-based materials which means each material contains a Base Texture and a Normal Texture by default and additionally has Smoothness, Ambient Occlusion, Metalic and Opacity Texture Maps according to the material.

Props: Barrel, Cinder Block, Concrete Barrier, Floor Tarp, Wood Plank, Shipping Containers, Pistol, Target, Sand Box, etc.. [Resolution 2048x] [Diffuse, Normal, Roughness, Opacity, AO, Metalic]

Architecture: Floor, Walls, Door, Roof, Ceiling, Beam, Column, Stair, Fence etc. [Resolution 2048x] [Diffuse, Normal, Roughness, Opacity, AO, Metalic]

Number of Meshes: 79 Unique Meshes

Number of Materials: 69

Number of Textures: 166

Supported Development Platforms: All Platforms

A pack of 79 props combined together to create a shoothouse/killhouse training range.

Includes:

• 79 props
• A hand crafted demonstration scene filled with all the assets.
• A Modular warehouse as the backdrop.
• Hand designed assets curated to create a shooting range in a temporary OSB board construction
• Fully controllable master material setup

✨ Follow Us & Stay Connected ✨

INSTAGRAM | X | YOUTUBE | ARTSTATION

-The package contains over 480 assets

-15 tileable textures and platforms

- 20 animated prefabs ( foliage+ windmill)

- 10 unique particle effects (air, fire, fog, leaves, rain, sand, snow, waterfall, wind, sun rays)

- 1 simple shader for foliage movement 

*2d URP is required for the project

*Unity version compatibility: Unity 2022.3.62f2 or above

It features:

-5 Unique environment scenes 

(Desert, Vegetation, Snow, WaterFall, Swamp)

- Animated vegetation using bones + shader

- Weather effects: rain, waterfall, wind, snow, fire, sand fall, fog, 

light rays, sand particle air particle, leaves particle

How to Use after installation: 

Step 1: create 5 sorting layers.

The order must be something like this: 

Background 4 

Background 3

Background 2

Background 1

Default

Foreground  

Step 2: From the hierarchy, select all assets from each folder and assign them 

to the corresponding sorting layer. 

Note: particles effect need to be assigned from the render tab--> sorting layer Id

Video Trailer + Tutorial

https://vimeo.com/1170884133?fl=pl&fe=sh

Enjoy

14 High-Performance Primitives:

• Basic (5): Line, Circle, Rectangle, Polygon, Point

• Advanced (9): Arc, Ellipse, Bezier Curves, Star, Arrow, Rounded Rectangle, Ring, Grid, Regular Polygon

30+ Production-Ready Prefabs:

• 6 Player characters (Triangle, Circle, Square, Hexagon, Pentagon, Diamond)

• 5 Enemy types with AI behavior

• 4 Projectile types

• 5 Collectibles (Coin, Gem, Star, Heart, PowerUp)

• 4 Obstacles (Spike, Wall, Moving Platform, Breakable Block)

• UI Elements (Health bars, Score displays, Menus)

3 Complete Sample Games (Full Source Code):

• Pong - 2-player paddle game (250 lines)

• Space Shooter - Top-down shooter with asteroids (450 lines)

• Platformer - Side-scrolling platformer with physics (650 lines)

Game Systems:

• Particle System - 5 effects (Smoke, Sparkle, Explosion, Confetti, Impact)

• Audio Manager - Built-in sounds (Jump, Shoot, Collect, Hit, Explosion)

• Health System - Damage, healing, death events

• Score System - Points, high scores, persistence

• Collision System - Layer-based detection

5 Game Templates:

• Score-Based arcade template

• Endless Runner template

• Wave Defense template

• Top-Down Shooter template

• Simple Puzzle template

Performance:

• 10,000 shapes in 3.29ms

• Zero GC allocation

• 60 FPS with 1,000+ shapes

• Batched rendering (1 draw call)

Documentation:

• 3,000+ pages of comprehensive guides

• 118 detailed tutorials

• Complete API reference

• Step-by-step game tutorials

Two Workflows:

• Code Workflow - Simple API with Draw.Command()

• No-Code Workflow - Drag-and-drop prefabs

Beautiful Neon Effects:

• HDR colors for bloom

• Additive blending for glow

• Perfect for arcade-style games

GlyphAureaLabs STANDARD - Professional 2D Vector Graphics for Unity

Build stunning arcade games, abstract visualizations, and neon effects with 14 high-performance primitives, 30+ drag-and-drop prefabs, and 3 complete playable games.

KEY FEATURES

14 Primitives (5 Basic + 9 Advanced):

• Basic: Line, Circle, Rectangle, Polygon, Point

• Advanced: Arc, Ellipse, Bezier Curves, Star, Arrow, Rounded Rectangle, Ring, Grid, Regular Polygon

30+ Production-Ready Prefabs:

• 6 Player characters (Triangle, Circle, Square, Hexagon, Pentagon, Diamond)

• 5 Enemy types with AI

• 4 Projectile types

• 5 Collectibles (Coin, Gem, Star, Heart, PowerUp)

• 4 Obstacles (Spike, Wall, Moving Platform, Breakable Block)

• UI Elements (Health bars, Score displays, Menus)

3 Complete Sample Games (Full Source Code):

• Pong - 2-player paddle game (250 lines)

• Space Shooter - Top-down shooter with asteroids (450 lines)

• Platformer - Side-scrolling platformer with physics (650 lines)

Game Systems Included:

• Particle System - 5 effects (Smoke, Sparkle, Explosion, Confetti, Impact)

• Audio Manager - Built-in sounds (Jump, Shoot, Collect, Hit, Explosion)

• Health System - Damage, healing, death events

• Score System - Points, high scores, persistence

• Collision System - Layer-based detection

5 Game Templates:

• Score-Based - High score arcade template

• Endless Runner - Infinite scrolling template

• Wave Defense - Wave-based spawning template

• Top-Down Shooter - Twin-stick shooter template

• Simple Puzzle - Puzzle game template

EXTREME PERFORMANCE

• 10,000 shapes in 3.29ms

• Zero GC allocation

• 60 FPS with 1,000+ shapes

• Batched rendering (1 draw call)

• Optimized for mobile and WebGL

BEAUTIFUL NEON EFFECTS

• HDR colors for bloom

• Additive blending for glow

• Perfect for arcade-style games

• Works with all post-processing

COMPREHENSIVE DOCUMENTATION

• 3,000+ pages of documentation

• 118 comprehensive guides

• Complete API reference

• 3 game tutorials (step-by-step)

• Code examples and snippets

TWO WORKFLOWS

Code Workflow:

using (Draw.Command(Camera.main))

{

Draw.Circle(Vector2.zero, 1f, Color.cyan);

Draw.Star(new Vector2(2, 0), 0.5f, 5, Color.yellow);

Draw.Arc(new Vector2(-2, 0), 1f, 0f, 180f, Color.magenta);

}

No-Code Workflow:

• Drag prefabs into scene

• Configure in Inspector

• Press Play!

PRODUCTION READY

• Unity 2019.4+ (LTS recommended)

• All render pipelines (Built-in, URP, HDRP)

• All platforms (Windows, Mac, iOS, Android, WebGL, Consoles)

• Commercial license included

• Priority email support

PERFECT FOR

• Arcade games (Pong, Breakout, Space Invaders, Asteroids)

• Puzzle games (Tetris, shape matching)

• Abstract art and visualizations

• Particle effects (10,000+ points)

• Data visualization (graphs, charts)

• Audio visualizers

• UI effects and transitions

• Neon-style games

• Platformers and side-scrollers

WHAT'S INCLUDED

Runtime:

• Draw.cs - Main API

• 14 primitive implementations

• Drag-and-drop components

• Particle system

• Audio manager

Prefabs:

• 30+ ready-to-use prefabs

• Players, enemies, bullets, collectibles, obstacles, UI

Templates:

• 5 complete game templates

• Full source code

• Customizable

Code Snippets:

• Movement (top-down, screen wrap)

• AI (chase, patrol)

• Weapons (basic shooter)

• Utilities (score manager)

Documentation:

• 118 guides (3,000+ pages)

• API reference

• Game tutorials

• Troubleshooting

QUICK START

1. Import GlyphAureaLabs STANDARD

2. Open Scenes/STANDARD/Games_Prefab/Platformer/PlatformerTest.unity

Open Scenes/STANDARD/Games_Prefab/Platformer/PongTest.unity

Open Scenes/STANDARD/Games_Prefab/Platformer/SpaceShooterTest.unity

3. Press Play - fully playable game!

4. Customize or build your own

PLATFORM SUPPORT

Fully tested:

• Windows, Mac, WebGL

Supported (should work):

• Linux, iOS, Android, Consoles, VR/AR

 SUPPORT

• Priority email support: ddaydota@gmail.com

• Response time: 24-48 hours

• Comprehensive documentation

• Code examples

FREE vs STANDARD

FREE Version:

• 5 basic primitives only

• Community support

STANDARD Version ($14.99):

• 14 primitives (5 basic + 9 advanced)

• 30+ prefabs

• 5 game templates

• Particle system

• Audio manager

• 3,000+ pages documentation

• Priority support

STANDARD = 10x More Features!

GET STARTED TODAY

Build your dream arcade game with GlyphAureaLabs STANDARD!

Website: https://sites.google.com/view/glyphaurealabs-standard/home

Email: ddaydota@gmail.com

UIGradientTarget

• Main component applied to UI objects
• Supports both Image and RawImage
• Handles gradient generation and application
• Automatically manages materials and textures

UIGradientPreset

• ScriptableObject for storing reusable gradient configurations
• Includes:
  Gradient data
  Shape (linear / radial)
  Angle, offset, scale
  Alpha preservation
• Supports preview thumbnail generation

GradientTextureGenerator

• Converts Unity Gradient into texture ramps
• Generates preview textures for Inspector and presets

Rendering

• Uses a custom shader:
  CinderellaGames/Shaders/UIGradient
• Features:
  Linear and radial gradient rendering
  UV-based transformation (angle, offset, scale)
  Alpha blending with original UI texture
  Works with Unity UI rendering pipeline
• Materials are generated automatically at runtime or in-editor
• Optional support for user-created material assets

Editor Tools

Custom Inspector

• Organized sections for gradient editing
• Large live preview
• Preset preview thumbnails
• Quick preset swatch palette
• Validation messages and target detection

Tools Window

• Batch apply presets to selected objects
• Add gradient component to multiple UI elements
• Selection-aware workflow

Compatibility

• Unity Version: 2021.3 LTS or newer recommended
• Render Pipeline: Built-in Render Pipeline (tested)
• UI System: Unity UI (UGUI)

Create, preview, save, and apply beautiful editable gradients to Unity UI directly from the Inspector.

UI Gradient Designer is a lightweight and artist-friendly editor extension that allows you to design and apply gradients to Unity UI elements without relying on external textures or image editing tools.

With a clean custom Inspector, live previews, and reusable preset support, this tool helps you build modern, visually appealing UI faster and more efficiently.

Key features

• Editable gradient field
• Linear and radial gradients
• Live preview
• Quick preset swatches
• Save reusable presets
• Image and RawImage support
• Batch tools window

Ideal for

• menus
• HUDs
• buttons
• cards
• mobile UI
• prototypes
• stylized interfaces

Why it helps

• no external texture editing needed
• faster iteration
• cleaner UI workflow
• reusable visual style system

Number of textures 6

Texture dimensions 4096*4096

Vertex count 19.941

Number of meshes/prefabs

Rigging: Yes

Animation count 0

UV mapping: Yes

Materials: 3 Materials

Presentation video.

The Knight in the Hood character for your game.

Used the Auto Rig Pro add-on for Blender.

Compatible with Humanoid Rig (Unity) and UE4 Skeleton (Unreal Engine 4).

## Features

* Real-time Tracking

* Visual Feedback

* Code Generation

* Selective Restore

* Undo Support

* Prefab Support

* Custom Attributes

* Inspector Highlights

* Demo Scene

* Optimized Performance

## Supported Unity Versions

* Unity 2021.3 LTS

* Unity 2022 LTS

* Unity 2023 / 6000+

## Supported OS

* Windows

* macOS

* Linux

*(Works on all platforms where the Unity Editor is supported)*

## Documentation

[Online Documentation]

Stop Losing Play Mode Changes in Unity -

Unity Play Mode is great for testing, but once you press Stop, all runtime tweaks are gone.
Values you carefully tuned, transforms you adjusted, debug changes you verified — everything resets.

Play Mode Saver fixes this workflow problem.

It tracks changes made during Play Mode, shows you exactly what changed, and lets you safely decide what should persist.

🔧 What It Does -->

Live Runtime Change Tracking

• Detects modifications made during Play Mode
• Highlights changed GameObjects in the Hierarchy
• Marks modified fields directly in the Inspector

Smart Restore Window

• Automatically appears when exiting Play Mode
• Clear before/after comparison of values
• Apply changes selectively or all at once
• Works cleanly with Prefabs and overrides

Runtime Change Review & Export

• Review all modified values in a structured diff view
• Export selected changes for long-term use
• Helps convert temporary runtime experiments into permanent decisions

Attribute-Based Control
Fine-grained control over what should or shouldn’t be saved:

[SaveOnPlayModeExit]
[IgnoreRuntimeChanges]

Undo-Safe

• All applied changes are registered with Unity’s Undo system
• Fully reversible Preset, editor-friendly workflow
• Fully JSON Export Supported!

Designed for Iteration

• Experiment freely during Play Mode
• Decide later what should become permanent
• Reduce trial-and-error and repeated manual tweaking

Stable & Editor-Safe Workflow

• Editor-based solution with predictable behavior
• Works alongside Unity’s serialization and Undo system
• Designed to fit cleanly into existing production pipelines

✅ Compatible With

• Scenes, Components & Prefabs
• Built-in and custom components
• Unity 2021.3 LTS and newer (including Unity 6)

🎯 Ideal For

• Developers iterating on gameplay tweaks 
• Designers tuning values live
• Teams tired of redoing Play Mode work

Play Mode Saver turns Play Mode into a safe experimentation space instead of a disposable test.

JOIN DISCORD | DOCUMENTATION | OTHER ASSETS