Asset Store newest packages

Tileable Assets: Seamless looping images for creating long, continuous levels

Parallax-Ready: Layered backgrounds designed to support parallax scrolling

Unique Art Style: Distinct visual design to give your game a standout aesthetic

Modular Layout: Easily combine and rearrange assets to build custom environments

Optimized for 2D: Ideal for side-scrollers, platformers, and other 2D genres

High-Resolution Graphics: Crisp visuals that scale well across devices and resolutions

Lightweight Files: Game-ready asset sizes to ensure smooth performance

Customizable Elements: Easily edit colors and components to suit your project

This package includes:

• Total Assets: 5 high-quality 2D images
• Dimensions: 2000 × 2500 px each
• File Format: PNG
• Color Depth: 32-bit
• Transparency: Yes (Alpha channel included)
• Style: Vector/hand-drawn, night and dusk tones
• • Sky gradient background Layers Included: • Foreground (3 variations) • Sun sprite

• Windows 64-bit support.
• Requires Chromium Embedded Framework (CEF) runtime. 

Cefious Web Browser brings Chromium-powered web technology directly into Unity, letting you run modern web experiences inside your app without opening an external browser. It also allows you to create fully local websites for your game, perfect for in-game interfaces, tools, and content.

Build in-game web views, dashboards, launchers, account portals, patch notes, storefronts, and internal tools with a developer-first workflow focused on reliability, flexibility, and production-ready performance.

Supports Unity Version 2022.3.62f3 + (fully tested on Unity 6+)

User-Facing Features

• Chromium-based rendering for modern website compatibility
• Tabbed browsing with dynamic tab creation and active tab switching
• Session history and favorites/bookmarks
• Stored website icons/favicons and retained browsing data
• Multi-download support with progress display and cancellation
• Zoom controls for browser content readability
• Web media playback support, including WebM/YouTube scenarios
• View Source in new tab support

Developer & Integration Features

• Ready to go Prefab with zero setup for use with Unity Canvas
• Native-feeling Unity integration for runtime and tooling workflows
• JavaScript ↔ C# bridge for two-way communication and argument passing
• Included JS Executor for direct script execution and event invocation
• Event-driven architecture with built-in hooks and custom extension points
• Programmable navigation, custom controls, and interaction handling
• AudioSource bridge to route browser audio through Unity audio pipelines
• Console/debug utilities for faster testing and troubleshooting
• Popup interception with configurable new-tab or same-tab fallbac

Cefious includes a clean, feature-rich browser UI, but the UI is fully optional.

• Use the included UI as-is, customize it, or replace it completely
• Easy to adapt to your own prefabs, Canvas setup, and design language
• Supports both Overlay Canvas and World Space (3D) Canvas
• Scalable layout suitable for many screen resolutions
• Includes PSB and Affinity Designer templates to speed up visual customization

Context Menu & Interaction Control

• Custom context menu system with page-aware actions
• Built-in actions include copy, paste, open link, open in new tab, download, and save/copy image
• Add your own context actions or modify built-in behavior

URL Rewrite, Local Sites & Security

• URL Rewriter can map incoming URLs to custom targets, including local hosted content
• Build fictitious in-game websites from project content (example workflow included)
• Build-time security restrictions can limit which host/domain rules are allowed, helping reduce misuse
• Rewrite rules support custom security indicators: Configurable labels
  Configurable active/inactive security icons per rule
  Optional global icon/label overrides for consistent UX
  
• Address bar can display rewrite/fictitious state clearly so users understand when content is locally mapped

Remote Debugging

• CEF remote debugging can be enabled with a configurable local port (default commonly 9222)
• http://localhost:9222When enabled, Cefious exposes a local inspector endpoint such as:
  
• Open that URL in Chrome, Edge, or another Chromium-based browser to inspect active Cefious pages
• This lets you use familiar browser devtools workflows (DOM/CSS/script/network diagnostics) against pages running inside Unity

UI Flexibility

Whether you are building immersive in-game web experiences or robust developer tooling, Cefious Web Browser gives you a production-ready browser backend with an optional UI layer you can keep, adapt quickly, or fully replace.

Platform Support & Current Limitations

• Windows: Fully supported now.
• macOS: Planned for a future update.
• Video codecs/licensing: Some video playback scenarios may be limited without appropriate FFmpeg licensing/configuration.
• VR: Not yet fully validated/tested in production VR workflows; planned improvements and validation are targeted for a future update.

Future updates:

Cefious currently targets Windows (64-bit). macOS and expanded VR validation are planned in upcoming updates.

Support:

Documentation

Forum

Third-Party Notices
Cefious includes third-party components.
This asset includes Chromium Embedded Framework (CEF), licensed under the BSD 3-Clause License.
This asset also includes Noto Sans font files from Google Fonts, licensed under the SIL Open Font License 1.1.
Third-party notice and license files are included inside the asset at:
Assets/Cefious Web Browser/notices.txt
Assets/Cefious Web Browser/ThirdPartyLicenses/

🧩 Engine Compatibility

• Unity 2021.3 LTS or newer
• Tested with Unity 2022 LTS and Unity 6
• Compatible with:
  Built-in Render Pipeline
  Universal Render Pipeline (URP)
• Editor extension built using Unity GraphView / UI Toolkit
• No third-party dependencies required

🏗 Architecture Overview

BTGraph Pro is a modular extension layered on top of BTGraph Basic.

• Shared canonical runtime core between Basic and Pro
• No runtime duplication between editions
• Existing behavior tree assets remain fully compatible
• No migration required when upgrading from Basic
• Strict separation between runtime execution and editor tooling
• Safe integration into existing Unity projects

Runtime assemblies contain no UnityEditor dependencies and are safe for standalone builds.

🧠 Advanced Debugging System

BTGraph Pro provides a professional Behavior Tree debugging environment for Unity.

• Real-time execution tracking per agent instance
• Live node state visualization (Success / Failure / Running)
• Integrated breakpoint system (node enter, exit, failure, blackboard key change)
• Step-by-step execution control
• Configurable execution history buffer
• Multi-agent runtime inspection
• Synchronized blackboard inspection during runtime
• Optional debugger activation per tree instance

Debugging tools can be enabled or disabled per behavior tree to avoid unnecessary runtime overhead.

🌳 Subtree & Graph System Enhancements

Subtrees are implemented as reusable ScriptableObject assets with production-ready safety mechanisms.

• Parameter override support with type validation
• Circular reference detection
• Deterministic serialization for stable GUID handling
• Editor-side validation with zero runtime performance cost
• Collapsible subtree visualization for scalable graph organization

Designed for large AI architectures and reusable behavior modules.

⚙ Runtime Enhancements

BTGraph Pro extends runtime control for complex projects.

• Tick budgeting configurable per behavior tree instance
• Optional Event-Driven execution model
• Hybrid execution support
• Abort policies integrated into composite evaluation
• Interrupt handling support
• Allocation-aware execution design to minimize GC pressure
• No reflection in hot runtime evaluation paths

Engineered for performance-sensitive and multi-agent scenarios.

🗂 Blackboard System

Robust and scalable blackboard architecture:

• Strongly-typed key system (no string-based lookups)
• Inspector-driven key selection
• Key metadata support (defaults, categories, tooltips)
• Runtime validation of key usage
• Event-driven wake integration

Designed for predictable, maintainable AI state management.

🎥 Recording & Replay

Integrated execution recording system for advanced diagnostics.

• Lightweight runtime recording
• Editor-based replay without requiring live gameplay
• Execution timeline inspection
• Exportable execution data for debugging and analysis

Enables detailed behavior inspection for complex AI systems.

🚀 Performance Characteristics

• Designed for large multi-agent environments
• Debugger overhead is negligible when disabled
• No editor validation logic included in builds
• Runtime execution remains lightweight and deterministic
• Allocation-safe idle behavior in Event-Driven mode

Suitable for production-scale AI systems across PC, console, and mobile projects.

BTGraph Pro transforms BTGraph into a complete, production-grade AI development environment for Unity.

Designed for complex projects and professional workflows, Pro adds advanced debugging tools, runtime control systems, and scalable architecture features that allow you to build, inspect, and maintain large AI systems with confidence.

If BTGraph provides the foundation, BTGraph Pro provides visibility, control, and production-level tooling.

🧠 Debugger Pro — See Exactly How Your AI Thinks

Understand and diagnose behavior trees in real time.

• Live execution path visualization
• Clear node state highlighting (Success / Failure / Running)
• Step-by-step execution control
• Node-level breakpoints (enter, exit, failure, blackboard key change)
• Multi-agent runtime inspection
• Execution history timeline
• Recording and replay support

Stop guessing why your AI behaves a certain way.
Inspect decision flow, evaluate abort logic, and analyze state transitions instantly.

Perfect for debugging:

• Stealth AI
• Combat decision systems
• Utility-based logic
• Multi-agent behavior scenarios

🏗 Architect Pro — Scalable AI Architecture

Build large, maintainable AI systems without losing clarity.

• Reusable subtree assets (tree-as-function workflow)
• Advanced node grouping and collapsible composites
• Enhanced graph search and reference tools
• Built-in graph validation and lint analysis
• Deterministic serialization for clean version control
• Structure-friendly workflows for team environments

Architect Pro enables long-term scalability for:

• Complex NPC systems
• Modular AI libraries
• Multi-character behavior frameworks
• Team-based development pipelines

⚙ Runtime & Authoring Pro — Advanced Control & Safety

Take control of runtime behavior and execution management.

• Strongly-typed blackboard keys
• Tick budgeting and execution control
• Abort policies and interrupt handling
• Node creation wizard for rapid development
• Execution recording and replay
• Multi-agent monitoring

Designed for advanced workflows where stability, safety, and predictability matter.

📊 Production-Level AI Workflow

BTGraph Pro is ideal for:

• Studios building scalable AI architectures
• Developers debugging complex behavior trees
• Teams requiring deterministic version control
• Projects with dozens or hundreds of active agents
• Performance-sensitive AI systems

It turns BTGraph into a full AI toolkit — not just a graph editor.

🔗 Seamless Compatibility

BTGraph Pro integrates directly with BTGraph Basic.

• Existing behavior trees continue to function without modification.
• No migration required.
• Same runtime foundation.
• Expanded tooling layer on top.

Upgrade when your project grows — not because you must, but because you’re ready for deeper control.

🚀 Why Choose BTGraph Pro?

• Advanced Behavior Tree debugging for Unity
• Execution timeline & replay system
• Multi-agent inspection
• AI graph validation & linting
• Runtime control & safety mechanisms
• Clean, modular AI architecture support
• Designed for production environments

BTGraph Pro transforms BTGraph from a powerful behavior tree system into a professional AI development suite for serious Unity projects.

Architecture & Performance:

• 100% Burst Compatible: Trigger sounds from any Job or System.
• Zero GC Allocations: Fully pre-allocated object pools for both One-Shot and Looping sounds.
• No Main Thread Stalls: Double Buffering ensures the Main Thread never waits for ECS workers.
• Cache Optimized: AudioEvent structs are explicitly packed to 32 bytes, allowing exactly two events per CPU cache line.

Features:

• Priority-Based Voice Stealing: Automatically recycles the lowest-volume AudioSources when pools reach capacity.
• Shadow Entity Loop Tracking: Attach looping sounds to moving entities. The system automatically stops the sound when the target entity is destroyed.
• TimeScale Independent: Uses AudioSettings.dspTime to ensure sound lifetimes are calculated correctly even during slow-motion effects.
• Fluent Builder API: Clean, chainable syntax for triggering sounds.
• AudioMixer Support: Route sounds to different Mixer Groups (SFX, Music, UI).
• 3D Spatial Audio: Full support for Spatial Blend, Min/Max Distance, and Rolloff curves.
• Auto-Generated C# Constants: Eliminates string-based lookups and typos using stable Hash IDs.

Triggering standard Unity audio from pure ECS is notoriously difficult. Audio Dispatcher solves this elegantly.

Audio Dispatcher for DOTS is a production-ready, Data-Oriented audio bridging system. It allows your Burst-compiled Jobs to trigger, move, and stop managed AudioSource components without ever touching the Managed Heap or stalling the Main Thread.

How it works:

Instead of forcing the Main Thread to wait for your Jobs to finish, the system uses a Double Buffering Command Architecture. Your high-frequency systems (like bullets or explosions) write 32-byte cache-aligned events into a lock-free queue. A dedicated Burst-compiled "Brain" processes these events, handles pooling logic, and passes a clean command buffer to the Main Thread for execution.

Perfect for any genre:

Whether you are building a massive RTS, a chaotic Bullet Hell, or a fast-paced Shooter, this tool ensures your audio scales with your entity count.

Developer Friendly:

You don't need to write boilerplate code. Use the included Fluent API to trigger sounds directly inside your IJobEntity:

AudioID.EXPLOSION.Shot(position).Volume(0.8f).Apply(writer);

Key Highlights:

• Clean Archetypes: Looping sounds (like tank engines) follow your entities using "Shadow Tracking", meaning your core gameplay entities remain untouched and tightly packed in memory.
• Smart Voice Stealing: If your audio pool is full, the system doesn't just cut off random sounds. It calculates priorities and replaces the quietest/furthest sound automatically.
• Stable IDs: Audio IDs are generated as stable Hashes. Reordering your audio database will never break your code.

WAV Quality: 44.100 Hz sample rate.

32 bits depth

MP3 Quality: 44.100 Hz sample rate

Loopable

Stereo

1 Song. Loop (wav and mp3)

·Battle Begins : 3:19

- Note Board editor window that displays all notes

- Attach Notes to any asset or scene object

Note Board editor window

- Browse and organize all notes

- Plan upcoming work

- Track feature development

- Project Progress Bar (%)

Attach Notes to any asset or scene object

- No additional components needed, just click a button to add notes

- Track progress

TODO: any tasks that need work

WIP: items in active development

DONE: your systems that are ready-to-go!

- Flag Markers

Stable: As good as it'll get. These items are ready to ship

Refactor: Functional but needs improvements for performance, scalability, etc.

Experiment: Opposite of stable. These systems need lots of testing.

Bug: Strange behaviors. Helpful to write a descriptive note alongside this one.

Placeholder: Temporary items. Anything that won't be included in the final product.

- Note

Write anything: Description, Documentation, Reminders, Author, Ideas, etc.

This tool is in active development.

Make sure to leave a review with any feedback or feature requests!

Two Flexible Scene Change Systems

1️. Bootloader Scene Group System

A centralized bootloader controller that:

• Loads scene groups
• Unloads scene groups
• Manages multi-scene setups
• Keeps your project organized and scalable
• Ideal for large or modular projects

Perfect for:

• Multi-scene architecture
• Streaming setups
• Level + UI + Lighting separation workflows

2️. Persistent Toggle-Based Scene System

Includes:

✔ A Persistent Scene Manager component

✔ A Toggle Caller component for any scene

How it works:

• The Persistent Manager stays alive across scene changes
• Any scene can call a toggle to trigger a scene switch
• Clean separation between caller and manager
• No tight coupling between scenes

Perfect for:

• Menu systems
• Level selectors
• Modular gameplay flow

ScriptableObject-Driven Scene Transitions

Create and assign custom transition effects using ScriptableObjects.

Supports:

• Simple fade in/out
• Dissolve effects
• Custom shader-based transitions
• Fully extendable transition system

Swap transition styles per scene group with zero code changes.

Additional Features:

• Average triangle count: 800
• 1 Texture: Compact 512x512 pixels for optimal performance.
• Rigging: No
• Game-Engine Ready: All models are optimized for smooth integration and high performance.

Low Poly Stylized Modular Interior Pack provides a set of fully modular interior rooms including kitchen, bedroom, living room, and bathroom. All assets are designed to be easily combined and rearranged to create different interior layouts.

The pack is optimized for stylized low poly projects and works well in casual games, mobile games, prototypes, and indie development. Content is suitable for fast level design and iteration, allowing developers to quickly build interior environments without additional modeling.

All modules are customizable through modular placement, making it easy to expand or modify scenes depending on project needs.

Product Details

This TTF font has been professionally designed to meet industry standards for use by individuals, indie studios, and triple-A game companies. It can certainly prove useful for designing logos, icons, graphics, posters, text, dialogues, and much more— giving credit is optional!

• Professionally crafted

• Scaling is smooth and dynamic

• Works on all resolutions

• Colors can be modified

You can also learn how to integrate fonts with TextMesh Pro through our easy-to-follow documentation which can be accessed here at any time.

Terms and Conditions

This font can be used commercially and non-commercially for any purpose so long as each party owns their appropriate entity license (Single-Entity or Multi-Entity), and this product listing and its contents are not being redistributed or resold anywhere.

The characters available for each font vary. For this particular font, all of its available characters are displayed on the offficial product image and any characters missing from its preview are not currently supported.

Product Details

This TTF font has been professionally designed to meet industry standards for use by individuals, indie studios, and triple-A game companies. It can certainly prove useful for designing logos, icons, graphics, posters, text, dialogues, and much more— giving credit is optional!

• Professionally crafted

• Scaling is smooth and dynamic

• Works on all resolutions

• Colors can be modified

You can also learn how to integrate fonts with TextMesh Pro through our easy-to-follow documentation which can be accessed here at any time.

Terms and Conditions

This font can be used commercially and non-commercially for any purpose so long as each party owns their appropriate entity license (Single-Entity or Multi-Entity), and this product listing and its contents are not being redistributed or resold anywhere.

The characters available for each font vary. For this particular font, all of its available characters are displayed on the offficial product image and any characters missing from its preview are not currently supported.

Product Details

This TTF font has been professionally designed to meet industry standards for use by individuals, indie studios, and triple-A game companies. It can certainly prove useful for designing logos, icons, graphics, posters, text, dialogues, and much more— giving credit is optional!

• Professionally crafted

• Scaling is smooth and dynamic

• Works on all resolutions

• Colors can be modified

You can also learn how to integrate fonts with TextMesh Pro through our easy-to-follow documentation which can be accessed here at any time.

Terms and Conditions

This font can be used commercially and non-commercially for any purpose so long as each party owns their appropriate entity license (Single-Entity or Multi-Entity), and this product listing and its contents are not being redistributed or resold anywhere.

The characters available for each font vary. For this particular font, all of its available characters are displayed on the offficial product image and any characters missing from its preview are not currently supported.

Number of textures: 31

Texture dimensions: 2048x2048 and 512x512

Polygon count: 14100 tris

Number of meshes/prefabs: 14 / 57

Rigging: Yes

Animation count: 110

Animation type list: In Place and Root Motion

UV mapping: Yes

LOD information: 4 level

Types of materials: PBR

This asset has realistic MALINOIS model.

The model has 57 bones, 14100 tris and 4 levels of LODs. LODs are enabled and configured.

Texture maps - albedo (alpha mask), AO / metallic / roughness, normal map (all 2048x2048).

Separate model for mobile phones with 3600 triangles.

The asset also has a dog model without alpha channels (see screenshot).

100+ animations (IP/RM):

Attack (bite, bite move, front, left, right, jump), hit (front, back, middle), death (left, right), digging (start, loop, end), bark, idle 1-7, eat, eat tear, drink, lie 1-2, lie belly 1-2, sleep, sleep belly, 15 stages jump (start, start forward, start place, fly up, fly up forward, fly horizontal, fly down high, fly down high forward, fly down low, fly down low forward, land, land forward, land place, fall edge, hooked and climbed), jump (forward, run, place), crouch move (front, left, right, back, back left, back right), crouch (idle 1-2, turn left, turn right), walk (front, left, right, back, back left, back right ), trot (front, left, right), run (front, left, right ), run fast (front, left, right ) swim (enter, front, left, right, back, back left, back right ), turn (left, right), turn 180 (left, right ), sitting (start, end, idle 1-2), scratch ear, pick up, etc.

This pack includes objects for creating a location. The package contains: barriers for dogs, toys, bowls, mats, beds, dog houses and more.

Textures support HDRP, but there are no ready-made locations and materials in the asset.

The animator controller is missing.

If you have questions, then write to the mail:

RedDeer3D@gmail.com

WAV file Specifications

Sample Rate: 48kHz

Bit Depth: 24-bit

Loopable: No

Additional: Full mix only, no separate stems.

This folder includes 6 music tracks designed for trailers, cutscenes and linear sequences.

Each track features a unique motif theme, resulting in a tracklist of various moods and styles. MP3 references are available in the soundcloud playlist

Tracklist & Guidance [w/ sampler timestamps]

1. [0:00] Together - moral hope from a single purpose that orients others and creates cohesion. Steady strings as guiding warmth.

2. [0:15] Goddess' Warrior - hope that feels like a miracle; it's sudden and luminous, almost forbidden in the bleakest moments. "A pulse where there should be none."

3. [0:29] RED - the reckless spark; imagine intoxicating, risky hope that ignores cost. A flirtation with doom.

4. [0:45] Dragon's Promise - a dark hope maintained as ritual; it's hollow, maybe painful, but necessary. Never spoken out loud.

5. [1:04] Rising Queens - explosive, decision-driving hope born of urgency; fuels immediate action rather than reflection.

6. [1:20] Twice Blessed - the essence of a restorative hope that rebuilds and repairs. This is the mesmerizing wonder of total renewal after trauma or loss.

Please note; these may be less ideal for interactive systems as they do not loop seamlessly.

Rigged: (Yes)

Added bones: u_jaw, u_tongue, u_tongue_2, u_eyes_l, u_eye_r, u_tail_01 , u_tail_02 , u_tail_03 , u_tail_04 , u_tail_05 , u_tail_06 , u_tail_07 , u_tail_08.

Number of characters: 1

Vertex counts of characters: 50.541 tris: 80.495

Number of Materials: 10 

Number of Textures: 50

Body, Clothes , Masks 4096x4096. Sword 2048x2048

Low-poly model of the character for games. Character has multiple color schemes.

The model contains Humanoid rig.

Number of textures 18

Texture dimensions 4096x4096

Polygon count of [Barbarian centaur] 30 045

Minimum polygon count 30 045

Maximum polygon count 58 425

Number of meshes/prefabs 4

Rigging: Yes

Animation count 27

Animation type list

UV mapping: Yes

LOD information (count, number of levels)

Types of materials and texture maps (e.g., PBR) Yes

Low-poly model of the character "Barbarian centaur".

27 animations:

walking (x1)

running (x2)

attack(x8)

strafe left(x2)

strafe right(x2)

strafe back(x1)

idle(x2)

jump(x2)

get hit(x2)

death(x2)

180 turn(x1)

scream(x1)

sudden stop(x1)

Suitable for games of different games: RPG, strategy, first-person shooter, etc.

Three uv set 4096x4096 (down to 1024x1024).

Four skins.

Poly count:

faces: 30 045

verts: 29 722

tris: 58 425

Package Content (74 Unique Objects):

• Trees (19 Models): A wide variety of lush tropical trees and palms for dense jungle canopies.
• Rocks & Stones (15 Models): Various shapes and sizes to build cliffs, paths, and ground details.
• Bushes (5 Models): Versatile stylized bushes for mid-layer vegetation.
• Cacti (5 Models): Detailed cacti for arid transitions or oasis-style biomes.
• Logs & Stumps (5 Models): Fallen wood and hollow stumps for organic ground detailing.
• Mushrooms (5 Models): Colorful stylized mushrooms for fantasy and forest interest points.
• Flowers (5 Models): Vibrant floral accents to add life and color to your scenes.
• Dry Trees (4 Models): Dead trees and twisted branches for ancient forest vibes.
• Grass (3 Models): Stylized grass tufts for terrain movement and filling.
• Roots (2 Models): Large surface roots for organic level design.
• Structures (1 Model): Stylized wooden cabin (perfect for shelters or base camps)
• Props (1 Model): Detailed campfire for rest points or village scenes.
• Total Meshes: 74 Optimized Unique Meshes.
• Total Triangles: 38,190 (Complete Scene).
• Average Polycount: ~530 Tris per object (Perfect for Mobile, VR, and Desktop).
• Textures: 1 Optimized Texture Atlas (2048x2048).
• Materials: 1 Master Material (Minimizes Draw Calls and optimizes performance).
• Pipeline: Fully compatible with URP (Universal Render Pipeline) and Built-in.
• Engine: Developed and tested in Unity 6 (6000.0.59f2).

Package Content:

• Diverse Vegetation: A complete selection of tropical trees, majestic palms, dense bushes, and exotic plants to create rich and deep forest environments.
• Detailed Nature Elements: Bring your world to life with colorful mushrooms, vibrant flowers, fallen logs, and a variety of rocks (ranging from small pebbles to large boulders) for a stylized touch.
• Modular Terrain Elements: Easy-to-use modular pieces designed to create elevation changes, paths, and ground details, allowing for fully customized map layouts.
• Ready-to-Use Prefabs: All assets are pre-configured as Prefabs, allowing you to simply "drag and drop" them into your hierarchy and build your scene in minutes.

Number of Prefabs: 130

Number of Meshes: 120

Number of Materials: 84

Number of Textures: 340

Texture Types:

(BaseColor, Normal, MetallicSmooth, Ambient Occlusion, MaskMap)

Texture Resolution : High Quality 2K+ Texture Set (512 - 4K)

Vertex Count: 2 - 51K

LOD : X

Discord | YouTube | Instagram

| Info

Step into a richly detailed Victorian-era train carriage, where elegance, craftsmanship, and atmosphere come together to create a truly immersive environment.

This environment features intricately designed wooden interiors, vintage furniture, decorative fabrics, and authentic period details—crafted to deliver strong visual storytelling and depth across games, cinematics, VR, and real-time experiences.

📷 All images were captured in the HDRP version of the project.

| Link

- Showcase VOD

- Document

Features :

| 130 Unique High Quality Prefabs

| High Quality 2K+ Texture Set

| Modular train interior environment

| This environment is fully compatible with Unreal Engine and Unity (Built-in, URP, and HDRP). Please refer to the documentation for details.

| Contact & Support:

If you encounter any issues or have any questions, please feel free to contact us via Discord or email below. We will get back to you as soon as possible.

Discord: https://discord.gg/kT9d96vnDP

Email: spia0901@gmail.com

Unity Version Compatibility

• Unity 2023.3 LTS and above
• Fully compatible with Unity versions.
• Unity Editor Extension (EditorWindow-based tool)
• Does NOT run at runtime (Editor-only utility)

Supported Content

• 3D Models (GameObjects with MeshFilter / SkinnedMeshRenderer)
• Materials and Textures linked to models

Core Analysis Features

• Vertex & Triangle counting
• Mesh memory profiling using UnityEngine.Profiling
• Texture memory estimation per model
• Disk size estimation via System.IO
• Build size estimation (mesh + texture approximation)

Optimization Features

• ModelImporter mesh compression:Low
  Medium
  High
  
• Automatic optimization:Polygon optimization
  Vertex optimization
  
• Texture optimization:Max texture size control
  Texture compression (Compressed format)
  Mipmaps enabled
  

Preview System

• Interactive 3D model preview using Editor.CreateEditor()
• Real-time selection update via OnSelectionChange()

Performance & Workflow

• Cached stats system for fast UI updates
• Lightweight editor processing
• Refresh-safe optimization pipeline
• Batch-friendly texture processing per model path

Dependencies

• UnityEditor API
• UnityEngine API
• System.IO
• UnityEngine.Profiling

Limitations

• Editor-only tool (not included in builds)
• Build size estimation is approximate
• Texture dependency detection relies on material collections

Code Structure

• ModelAnalyzerWindow → Main UI & interaction layer
• ModelAnalyzerData → Core analysis & calculation engine

Optimizer Hub Pro is a powerful Unity Editor tool designed to help developers analyze, optimize, and improve 3D models with real-time performance insights.

Easily select any 3D character or model and instantly view its mesh complexity, memory usage, texture impact, and estimated build size—all in one clean and intuitive interface.

 Key Features

 Before & After Optimization Workflow

Visually compare model performance before and after optimization.

 Mesh Analysis

• Vertex count
• Triangle count
• Runtime memory usage

 Texture Memory Tracking

Automatically calculates total texture memory usage from materials and dependencies.

 Build Size Estimation

Estimates how much impact the selected model has on final build size.

 One-Click Optimization Presets

• LOW (Mobile optimized)
• MEDIUM
• HIGH (PC quality)

Smart Optimization System

With a single click, optimize:

• Mesh compression
• Polygon reduction settings
• Vertex optimization
• Texture size reduction
• Mipmapping & compression settings

All changes are applied instantly through Unity’s importer pipeline.

 Real-Time Model Insights

• Interactive 3D preview inside the editor
• Instant stats update on selection change
• Clear warning for high build impact assets
• Lightweight and fast performance

Perfect For

• Game developers
• Technical artists
• Mobile game optimization
• VR/AR developers
• Performance-critical projects
• Large 3D environments

This tool helps developers:

- Reduce project size

- Improve performance on mobile devices

- Detect hidden issues in large projects

- Save hours of manual optimization work

Model Optimizer Pro gives you real data + instant optimization tools so you can reduce draw calls, lower memory usage, and improve FPS effortlessly.

Result

•  Faster games
•  Smaller builds
•  Optimized 3D assets
•  Better performance decisions

Technical Details

- Runtime Scripts:

  - Free_Simple_Shooting.cs (3D)

  - Free_Simple_Shooting_2D.cs (2D)

  - TMC_Quick_WASD_Input_Events.cs (demo helper)

- Editor Scripts:

  - TMC_Shoot_Basic_Single_Transform.Editor.cs

  - TMC_Shoot_Basic_Single_Transform_2D.Editor.cs

- Assembly Definitions:

  - Taylor Made Code.Free Basic Shoot.asmdef

  - Taylor Made Code.Free Basic Shoot.Editor.asmdef

- Test Coverage:

  - EditMode and PlayMode tests included

  - Separate asmdefs for EditMode/PlayMode test assemblies

- Supported Unity Version:

  - 2021.3+

- Dependencies:

  - Taylor Made Code Core (required, free)

- Included Content:

  - Demo scenes

  - Prefabs (Gun, Bullet)

  - Art assets (mesh + sprite icon)

  - Documentation

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

- Build 3D and 2D Shooting Fast with Free Simple Shooting -

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

- Introduction -

Free Simple Shooting is a lightweight, production-ready shooting toolkit for Unity. Add projectile firing in minutes with clear inspector controls, demo scenes, and documentation links directly in the custom editor.

| Discord |

- What You Get -

This package includes both:

- Free_Simple_Shooting (3D)

- TMC_Free_Simple_Shooting_2D (2D)

You can configure shooting using:

- Transform-based projectile movement

- Physics-based projectile movement (Rigidbody / Rigidbody2D)

- Bullet Clear Modes -

Choose how bullets are cleared:

- Collision via Layer

- Collision via Tag

- Timer-based clear

- Built for Real Projects -

Free Simple Shooting also includes:

- Optional object pooling (including strict pool behavior)

- Damage + hit events (UnityEvent<float, GameObject>)

- Audio hooks for fire/hit feedback

- Render-layer support for FPS weapon visibility

- Lifecycle events for custom integrations

- Demo scenes for quick onboarding

- Requirements -

- Unity 2021.3 or newer

- Taylor Made Code Core (free dependency)

- Quick Start -

1. Add a shooting component (3D or 2D) to a GameObject.

2. Assign Bullet Prefab + Spawn Point.

3. Select Transform or Physics mode.

4. Configure clear behavior and optional pooling/events.

5. Press Play and iterate.

Free Simple Shooting is designed to be simple for beginners and flexible enough for advanced workflows.

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

• Single-file 3D enemy AI controller for Unity
• Custom tabbed inspector for cleaner setup and tuning
• Cone-based sight detection with line-of-sight checks
• Tagged AudioSource hearing system with uncertainty
• Suspicion system with escalation thresholds and decay
• Memory system for last known position, direction, and confidence
• Investigation and search states with logical transitions
• Patrol system with waypoint support and randomized waypoint completion
• Blind chase and close-range reacquire behavior
• Optional experimental prediction and intercept system
• NavMeshAgent-based navigation
• Runtime NavMesh build hook support
• Debug gizmos for vision, hearing, memory, search, and prediction
• UnityEvents for detection, search, chase, sound, target loss, and state changes
• Suitable for stealth, horror, and pursuit-focused Unity 3D projects

AI Horror Enemy Toolkit is a reusable single-file enemy AI controller for Unity built for horror, stealth, and tension-heavy gameplay. The system focuses on believable behavior rather than cheating or using perfect information.

The AI uses cone-based sight, sound detection, memory of last known target information, suspicion escalation, investigation, patrol, search routines, blind chase, close-range reacquire, and optional experimental prediction and intercept behavior. It is designed to feel more human, readable, and responsive during pursuit.

The asset includes a custom inspector with grouped controls, runtime debug tools, configurable state tuning, and UnityEvents for common gameplay hooks. It works well for developers who want either a simple drop-in enemy or a more advanced hunter-style pursuer with expandable behavior.