Asset Store newest packages

Number of meshes: 263

Polygon count: ~1000 on trees

LOD information: Custom LODs, up to 3 on some trees

Number of prefabs: 148

Number of textures: 78

Texture dimensions: Up to 4k, except sky up to 8k

UV mapping: Yes on trees, no on rocks (world aligned)

Number of shaders: 14

Number of materials/variants: 75

OVER 150 ASSETS

A library of many different desert and oasis assets as well as stylized rocks, foliage, flowers, and more. See the full list below!

HIGH PERFORMANCE

Every asset is designed to balance quality with performance! Low poly counts, custom LOD meshes on every tree, and frequent use of LOD materials reduce overhead. Features and settings can be tweaked to further improve performance, as mentioned in the Documentation.

PART OF MY MEGA PACK

You can get all of these assets and much more at a discount by grabbing my MEGA PACK

SUPPORT

You can get the best support from the Documentation or by joining the Discord

WHAT'S INCLUDED

• One large demo desert map and an overview map
• Stylized sky sphere
• Stylized water
• Waterfalls
• Sandfalls
• Sea shells, starfish
• Desert Palm trees, saplings
• Desert Coconut Palm trees
• Windswept trees, saplings
• Cacti
• Grasses, flowers, shrubs, bushes
• Rainbows
• Desert rocks, hoodoos, shelves, cliffs
• Background mountains

Unity Version Support

• Unity 2020.3 LTS or newer (tested with 2021, 2022, and Unity 6 / 6000.x)
• Compatible with URP, HDRP, and Built-in pipelines

Dependencies

• None – works out of the box
• Optional: TextMeshPro Essentials (for FrameRateUI HUD & controls)

Scripts Included

• FrameRateController.cs – Core script (required)
• FrameRateUI.cs – Optional runtime HUD & UI controller

Features

• Extremely lightweight (~2 scripts, zero overhead)
• No third-party dependencies
• Saves/loads settings via PlayerPrefs (optional)
• Reacts automatically to resolution, refresh, and screen mode changes
• Optional runtime UI shows FPS, Mode, Refresh Rate, Render Resolution, Screen Mode

Platforms

• PC, Mac, Linux
• Mobile (iOS, Android)
• Consoles

Other Notes

• Drop-in design: add once to bootstrap scene
• Global singleton access via FrameRateController.Instance
• Editor-friendly with one-time VSync hints and startup logs

Tired of juggling VSync and FPS limits manually? Or maybe you’re setting up frame rate control in every new project?

With this Frame Rate Controller, all your frame pacing lives in one place—extremely lightweight, dependency-free (only TMP Essentials), and just two scripts (with the UI script fully optional).

✦ What It Does

Centralizes frame pacing (FPS + VSync) with four clear modes:

• Unlimited – uncapped FPS (with optional safety ceiling)

• Limited – custom FPS cap

• Native – auto-match display refresh rate

• Synced – VSync with refresh ÷ division (1–4)

Also:

• Reacts automatically to resolution, refresh, and screen mode changes
• Saves & loads settings via PlayerPrefs (optional)
• Provides a global singleton instance (drop in once, works everywhere)
• Includes an optional runtime UI (HUD + live adjustments)

✦ Why You’ll Love It

• Extremely lightweight – zero overhead, clean and efficient
• No dependencies – works out of the box (UI only needs TMP Essentials)
• Only two scripts – FrameRateController (core) + FrameRateUI (optional)
• No more rewriting frame controllers from scratch
• Instant FPS settings menu
• Debug-friendly HUD: FPS, refresh, resolution, screen mode
• Works on PC, Console, Mobile – with URP, HDRP, or Built-in
• Production-ready, drop-in, and future-proof

✦ How To Use

• Drag & Drop the prefab into your bootstrap scene
• Or control it manually with a simple API:

FrameRateController.Instance.Set(FrameRateController.Mode.Limited, customLimit: 60);

FrameRateController.Instance.Set(FrameRateController.Mode.Synced, customSyncDivision: 2);

List of all features:

• Overlay System:
• Natural Curve Blending.
• Support for Overlay Poses and Animator Controllers.
• Play Animations from Code.
• Smooth Pose Transitions.
• Dynamic Bones Feature.
• Procedural Animation Modifiers:
• Modify Bone.
• Two Bone IK.
• Foot IK.
• Procedural Steps.
• Look and Turn In Place.
• Movement Leaning.
• Editor Gizmos for easy adjustments.
• Easy Setup:
• Native support for 4 skeleton types.
• Synty.
• Mixamo.
• Character Creator (CC4, CC5).
• Unreal Mannequin.
• Motion Warping:
• Climbing, vaulting, and interactions.
• Example Content (free demo content downloaded separately):
• KINEMATION Mannequin (Generic and Humanoid Avatars).
• Character Controller.
• Character Props (Axe, Torch, Barrel, and a Gun).
• Animations and Demo Scene.
• Simple Camera System:
• First- and third-person views.
• Camera shakes.

Works with Animator: Yes, CAS natively works with Animator Controllers.

Optimized: Yes, with Animation Jobs.

Supported rig types: Humanoid and Generic.

Example content: Yes, available for download separately via a built-in tool.

Try Demo (Windows) • Docs • Roadmap

🎮 Animation Made Simple!

Animation in Unity is NOT easy. Layers multiply, state machines pile up, and every new feature makes the graph harder to manage. Character Animation System (CAS) streamlines that reality.

It works with your existing Animator Controller – keeping it clean and simple – while handling the heavy lifting behind the scenes. Instead of stacking complex layers or Override Controllers, you add Modular Overlays – poses or controllers (like holding a torch or swinging an axe) that blend dynamically with a few sliders.

Paired with procedural modifiers (IK, procedural steps, and more), CAS lets you dream, prototype, and ship features without worrying about animation.

Ready to see what you get with CAS? Let’s dive in.

🔹 Your Animator, Modular Overlays

Build your Animator once, add your Overlays, and adjust the blending sliders.

CAS also supports Overlay Animators – modular controllers with custom logic (say, sword draw, holster, and attack). Create states, transitions, or blend trees, and CAS will dynamically blend them with the main Animator.

🔹 Simple Workflow

With CAS, adding new features takes a few clicks, not hours:

1. Add your Overlay and adjust the sliders on the fly.
2. Add Procedural Animation Modifiers.
3. Link your gameplay logic with CAS without writing any code.

🔹 Nice and Smooth

CAS creates automatic transitions between poses, making sure the gameplay is smooth.

🔹 Procedural Animation

Add dynamic features to your game with powerful modifiers:

• Two Bone IK: Attach hands to props (e.g., barrels or levers).
• Procedural Steps: Perfect to avoid foot sliding.
• Look around and Turn In Place: No need for blend trees!
• Foot IK: Perfectly places feet in the game world.
• Move Leaning: Lean towards velocity when running or sprinting.
• Or just modify bones in the editor without any code!

The workflow is very simple:

1. Create Procedural Animation Settings.
2. Add your animation modifiers (say, Look and Foot IK).
3. Start the game and adjust on the fly!

CAS supports swapping Procedural Settings at runtime, so you can have procedural presets for different gameplay situations (e.g., holding a barrel or climbing).

🔹 Climb and Interact

Add traversal and interaction actions easily with Motion Warping. Easy setup, natural motion, and highly customizable.

🔹 Example Content

Additional game-ready content for CAS - prefabs, animations, scripts, and more.

CAS makes animation simple so you can focus on what matters – your game.

YouTube • Discord

• AI-Powered Translation: Uses Google Gemini 1.5 API for high-quality, context-aware translations in 30+ languages (European, Asian, and Middle Eastern languages)
• Dual Integration: Works with Unity Localization Tables or CSV files directly—no dependencies required for CSV-only workflows
• Smart Caching System: Saves all translations locally to avoid redundant API calls, reducing costs and enabling offline work with cached translations
• Intuitive Wizard Interface: 6-step guided workflow from API setup through translation completion with real-time progress tracking
• Translation Review Tools: Built-in review window for manual editing and quality assurance of AI-generated translations
• Flexible Configuration: Custom prompt templates, context-aware translation options, and selective table/language processing
• Automatic Locale Management: Creates missing Unity Locales automatically during translation
• Batch Processing: Translate multiple language tables and CSV files simultaneously with progress indicators
• Comprehensive Logging: Detailed console and file logging for debugging and audit trails
• Non-Destructive Workflow: Optional preservation of existing translations with overwrite controls
• Export/Import Cache: Share translation caches across team members to maximize efficiency
• Production Ready: Fully documented code, zero compilation errors, tested with Unity 2022.3 LTS+

This package is ideal for indie developers, small studios, and anyone looking to make their Unity projects accessible to a global audience without extensive localization budgets. The plugin seamlessly integrates with Unity's Localization system or works directly with CSV files, making it suitable for all project types—from mobile games and story-driven adventures to utility tools and educational applications.

The AI-powered translations understand context and maintain consistent tone across your content. With an intelligent caching system, repeated translations are free and instant, making it perfect for iterative development. Whether you're prototyping for multiple markets, preparing an Asset Store submission, or launching a commercial game, this tool adapts to your workflow. The content is fully customizable through custom prompt templates, allowing you to fine-tune translation style for specific genres or brand voices.

• Starter RPG UI Screen 
• Settings
• Inventory
• CharacterPreview
• UI Toolkit
• USS Best Practices
• Theme Management

LiberateUI is a production-ready Unity UI Toolkit framework that accelerates game UI development with beautiful, responsive designs.

What's Included:

• 3 complete art styles: CelShadedBoldOutline, DarkHandDrawnFantasy,

PixelArtRetro (more styles coming)

• 6 runtime themes (3 art styles × 2 responsive layouts)

• Complete UI screens: Main Menu, Inventory, Settings, Character Preview

• Automatic Portrait/Landscape responsive layouts

• Design token system with CSS variables for consistent styling

• Theme switching system via ThemeManager component

• Event-driven architecture with UIView base class

• 13 C# scripts with full API documentation

• 60+ UXML/USS files organized by component

• Demo scene showcasing all features

Key Features:

• Fully responsive - automatically adapts to any screen size and orientation

• Modular architecture - easy to customize and extend

• Design tokens - consistent spacing, sizing, and typography throughout

• Theme Manager - runtime switching between art styles and layouts

• Clean, well-documented code in LiberateUI namespace

• Compatible with all render pipelines (Built-in, URP, HDRP, Custom RP)

• Works with Unity 6.0 or newer

Perfect For:

• RPGs, fantasy games, adventure games

• Mobile and desktop projects requiring responsive UI

• Developers wanting professional UI without starting from scratch

• Projects needing multiple theme variations

Support & Community:

• Join our Discord server to request new art styles, report bugs, ask questions, and get support:
• Discord: https://discord.gg/RVJxtkA7BS
• We're actively developing new UI styles based on community feedback. Join us to influence the roadmap and get early access to upcoming features!

Number of textures : 28

Texture dimensions : 4096

Polygon count of [Model Name] : 99428 [PineTree_002] ...

Minimum polygon count : 100

Maximum polygon count : 1920912

Number of meshes/prefabs : 24 (PineTree_001, PineTree_002 ...)

Rigging: No

Animation count : No

Animation type list : No

UV mapping: Yes

LOD information (count, number of levels) : No

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

It is suitable for AR, VR, Game, Animation and so on.

📊 Technical Details:

- Average Verts And Normals Count per Model:

    - "Helmet Body" : 67586 Verts & 67570 Normals

    - "Helmet Glass" : 1316 Verts & 1007 Normals

- Texture Sizes:

    - 4096 x 4096 px

- Texture Maps:

    - Base Color

    - Emissive

    - Height Map

    - Normal Map

    - Roughness

    - Metallic

    - Ambient Occlusion

- Texture Types:

    - Dragon Textures

    - Happy Family Textures

    - Normal ( Other Different Textures Are Coming Soon …)

- Supported Pipelines:

    - Built-in Render Pipeline (default)

    - URP compatible (via material conversion)

Description:

This package includes 3D Professional Helmet With Different Skins

Content:

Model Includes

- Helmet Body

- Helmet Glass

Each model is:

✔️ Game Ready

✔️ UV-unwrapped (non-overlapping)

✔️ Prefab setup for plug-and-play use

✔️ Pivot points placed logically for animation and placement

📂 Folder Structure:

- Models/

    - Individual FBX and OBJ files per asset

- Textures/

    - Organized by asset name

- Prefabs/

    - Drag-and-drop ready prefabs

- Scenes/

    - Showcase scene with lighting and setup

- Documentation/

    - This README file

📏 Scale & Pivot Info:

- All models are scaled to real-world proportions (1 unit = 1 meter)

- Default Unity cube (1x1x1m) used for scale reference

📌 Usage Notes:

- Suitable for both personal and commercial projects.

- Redistribution or resale of these assets as-is is strictly prohibited.

- Models are intentionally optimized for performance while retaining visual quality.

📧 Support:

For feedback, bug reports or business inquiries, contact:  

📩 onurdgn2023@gmail.com  

🔥 Thank you for downloading this pack!

If you enjoy using it, consider leaving a ⭐ review — it helps a lot!

• Features:
• Unity Multiplayer Services
• Unity Matchmaker assets and deployment to the cloud project
• Customizable UI using UIToolkit
• Test scenes already setup to connect players to a session
• Drag and Drop into your project
• Supported platforms: All
• Supported OS: All
• Documentation Links:
• https://docs.unity3d.com/Manual/building-blocks-multiplayer-prerequisites.html
• https://docs.unity3d.com/Manual/building-blocks-multiplayer-matchmaking.html

The Matchmaker Session Building Block helps you integrate Unity’s Matchmaker into your project to connect players together. It can serve as a starting point for your multiplayer projects, or as a quick integration of Matchmaker throughout development.

This Building Block demonstrates how to do the following:

• Manage a Matchmaker Queue configuration from your Unity project.
• Deploy such Queue asset to the cloud services to use it during Play Mode.
• Connect players together through the Matchmaker service using a list of rules.

The Matchmaker Session Building Block includes an example Scene, a UIToolkit UI, and a preset of Matchmaker queue configuration with basic rules to connect players together. If you need gameplay synchronization, you can optionally add netcode using Unity Netcode for GameObjects or Netcode for Entities.

• Features:
• Unity Multiplayer Services
• Customizable UI using UIToolkit
• Test scenes already setup to connect players to a session
• Drag and Drop into your project
• Supported platforms: All
• Supported OS: All
• Documentation Links: 
• https://docs.unity3d.com/Manual/building-blocks-multiplayer-prerequisites.html
• https://docs.unity3d.com/Manual/building-blocks-multiplayer-sessions.html

The Multiplayer Session Building Block helps you integrate Unity’s multiplayer sessions into your project to connect players. This Building Block can serve as a starting point for your multiplayer projects, or as a quick integration of sessions throughout development.

This Building Block demonstrates how to do the following:

• Create and join a session through the Multiplayer Services SDK.
• Use the Quick Join API to quickly get players into any existing session.
• Use the Session Browsing API to list existing sessions and join a specific one.
• Use a JoinCode to share and join a specific session.

The Multiplayer sessions Building Block includes example scenes, UIToolkit UI assets, and runtime components to create, browse, and join sessions, and debug them with a SessionInfo panel. If you need gameplay synchronization, you can optionally add netcode using Unity Netcode for GameObjects or Netcode for Entities.

• Features:
• Customizable UI backed by UI Toolkit
• Cross-platform support for player data writing and reading
• Test scene to demonstrate writing and reading to player data with different controls
• Also demonstrates using game-date, data managed by cloud-code that is not player specific
• Drag & Drop into your project
• Leverages Live Ops Services as a single platform for backend integration
• Authentication
• Cloud Save
• Cloud Code (optional)
• Supported platforms: All
• Supported OS: All
• Documentation Link: https://docs.unity3d.com/Manual/building-blocks-liveops-player-accounts.html

The Player Account Unity Building Block combines the Authentication, Cloud Code, and Cloud Save services to offer an extendable UI to represent user sign up, sign in and player account management for their users in their project.

This Unity Building Block should be used as an accelerator for developers looking to implement cross-platform player data storage in their games. It comes with documentation that includes extensibility guidelines to support customization, so these elements can be used in production.

• Features:
• Customizable UI backed by UI Toolkit
• Cross-platform support for leaderboards
• Supports trusted clients with Cloud Code integration
• Test scene to help developers submit scores and visualize their leaderboard
• Drag & Drop into your project
• Leverages Live Ops Services as a single platform for backend integration
• Authentication
• Cloud Code
• Leaderboards
• Supported platforms: All
• Supported OS: All
• Documentation Link: https://docs.unity3d.com/Manual/building-blocks-liveops-leaderboard.html

The Leaderboards Unity Building Block combines the Authentication, Cloud Code, and Leaderboards services to offer an extendable UI to represent leaderboard progression from their users in their project.

This Unity Building Block can be used as an accelerator for developers looking to implement cross-platform leaderboards in their games. It comes with documentation that includes extensibility guidelines to support customization, so these elements can be used in production.

• Features:
• Customizable UI controls backed by UI Toolkit
• Cross-platform support for achievement progress tracking
• Supports trusted clients with Cloud Code integration
• Test scene with developer controls to help iterate
• Drag & drop into your project
• Leverages LiveOps Services as the single platform for backend services
• Remote Config
• Cloud Code
• Cloud Save
• Authentication
• Supported platforms: All
• Supported OS: All
• Documentation Link : https://docs.unity3d.com/Manual/building-blocks-liveops-achievements.html

The Achievements Building Block combines the Remote Config, Cloud Code, and Cloud Save services to offer a system for defining player achievements, storing their progress, and displaying the collection of achievements in-game.

This Unity Building Block can be used as an accelerator for developers looking to implement cross-platform agnostic Unity-based Achievement mechanism in their games. It comes with documentation that includes extensibility guidelines to support customization, so these elements can be used in production.

In the context of regular achievements, it is not intended to address a first-party (platform) achievements system, but help bootstrap a cross-platform UGS powered achievement system, while demonstrating a real-world use-case of combining services to achieve a non-trivial online system.

Technical Details — Lite Version

• Parameter Support: Call methods with primitive types only (int, float, bool, string, Enum, etc.).
• Coroutine Support: Methods returning IEnumerator can run as coroutines, letting you sequence actions with delays, user prompts, or event waits.
• Use Cases: Rapid prototyping, lightweight editor automation, testing, and simple scene manipulations. Perfect for developers and artists looking for a fast, minimal setup.
• Execution Method: Uses C# reflection to dynamically locate and invoke methods on any component in your scene or prefab.

Documentation: Function Player Documentation

This Lite edition bridges the gap between code and editor by letting you instantly call component methods from the Unity Editor—without writing extra scripts.

Call methods that take primitive types as arguments, run coroutines, and quickly test or trigger functionality directly from the Inspector.

Instead of hardcoding sequences of events, you can interactively design and trigger them in real time—waiting for user input, a timed delay, or in-game events. Whether you’re a developer prototyping gameplay or an artist automating simple tasks, this streamlined version makes experimentation fast and easy.

✅ Call component methods directly from the Inspector

✅ Pass primitive type arguments (int, float, string, bool, etc.)

✅ Run and test coroutines on the fly

✅ Lightweight and easy to set up—no extra dependencies

Looking for more power?

Check out the Pro version for advanced features, including:

• Support for Unity object arguments such as Vector2, Vector3, Rect, AnimationCurve...
• Setter support for built-in Unity properties like Transform.position
• Advanced workflows for designers, developers, and technical artists

If you find this Lite tool helpful, please consider leaving a review—it supports development and helps guide future improvements. I’d also love to hear about how you’re using it in your projects!

1. - Smooth character movement using CharacterController
2. - Precise jumping with coyote time for edge cases
3. - Dynamic sprinting with adjustable speeds
4. - Fluid sliding with camera tilt and FOV boost
5. - Responsive crouching with automatic ceiling detection
6. - Realistic head bobbing tied to movement 
7. - Flexible camera system with smooth mouse look
8. - Customizable FOV transitions for sprint and slide
9. - Efficient ground checking with layered physics
10. - Modular settings for easy tweaking in Inspector

Easy Peasy First Person Controller is a lightweight, open-source first-person controller for Unity. Designed for simplicity and flexibility, it offers a robust set of features with easy customization to fit your game’s needs.

This package includes:

Smooth jumping with coyote time

Dynamic sprinting and sliding

Responsive crouching with ceiling detection

Realistic head bobbing

Customizable camera FOV transitions

New input system

Gamepad support

And much more!

RTuner is:

• Gathering information about the rendering of each object in the scene, its queue, shader, and material.
• Convenient presentation of collected data for analysis in one place.
• Fast final tuning of materials and textures.
• Convenient work with materials and textures.

With RTuner, you can:

• Find and fix rendering errors made during production.
• Quickly switch the scene to any other shader in just a few clicks.
• Optimize the scene by reducing the number of pass switches.
• Repack textures channel by channel for custom shaders.

RTuner consists of Analyzer and three components for additional processing:

• Scene Analyzer - convenient presentation of rendering data in the active scene, with batch material settings
• Shader Replacer - batch shader replacement
• Texture Repacker - multi-channel texture repacker for custom shaders
• Material Filler - filling in free texture cells in the material to reduce the number of keywords for shaders with #pragma multi_compile

If you have any questions or would like to provide feedback, you are welcome to do so on our Discord server

• Developed using Unity 6000.0.42f1.
• Tested on mid-range Android devices (API 24+) and Windows 10/11 PCs with consistent performance.
• The asset relies only on standard Unity components and classes, with no third-party dependencies required.

Touch Effect System Mini ✨is a Unity touch-effect asset supporting cross-platform input. Suitable for point-and-click games, as well as any other projects that require touch visualization. To get started, add the One-Touch effect prefab to your Canvas. 📄 Full documentation (eng)

💡 For advanced features, consider TOUCH EFFECT SYSTEM (full)

So you get:

• Platform-specific configurations for optimal performance, multi-touch support and automatic canvas detection (Overlay/Camera/World Space).
• Extensive shader library (25+ variants, including blade effects, expanding rings, neon shapes, rotating patterns, dynamic effects, matrix grids, lightning, broken glass, force fields, and more).
• Trail system with advanced controls.
• Sprite-based particle system.
• Preview system to get looped effect previews, useful as tutorial pointers.
• Technical support and custom development services.

Use this Unity touch-effect asset to improve your project UX.

Requires Unity 6.0 (or later) and HDRP.

- Transparent objects are not blended.

- Tested on Windows and Mac.

- VR not supported.

Edge Fusion HDRP is a post-processing effect for the High-Definition Rendering Pipeline that blends edges between objects to eliminate hard seams and produce cohesive, natural-looking scenes. Add it as a Render Feature and control it through a Volume, with both global and per-object settings to target exactly where blending should occur.

🌟 Key features:

- Edge blending: smooths transitions between meshes, terrain, and props without changing materials or geometry.

- Global control via Volume: intensity, world‑space radius, max blend distance, and max screen radius.

- Intra-object fusion (optional): blends within the same mesh based on normal/depth discontinuities.

- Per-object overrides with Edge Fusion Object: custom radius (0 disables), include children with layer mask.

- Performance tuning: sample count, binary search steps, jitter (TAA-friendly), 3D noise (intensity/scale), shadow protection.

- Blend layers: choose precisely which objects participate in blending.

- Debug views: object IDs, Edges, Blending, Normals, and Depth.

- Compare mode: realtime side-by-side view to compare the original with the applied effect.

- Editor friendly: optional Scene View rendering; can run even if the camera’s post processing is off.

🎯 Ideal usecases:

• Modular environments: hide seams between tiles, walls, floors, cliffs.
• Terrain + props/materials: blend contacts for rocks, sand, snow, mud, gravel, dust, ice, ash, soil, moss, roots, asphalt/roads, ...
• Kitbashing/mixed packs: unify assets from different styles and PBR setups.
• Photogrammetry: soften scan boundaries when merging with terrain/meshes.
• Foliage/debris contacts: reduce harsh intersections for more believable placement.
• Intra‑object smoothing: reduce visible splits/normal seams on segmented meshes.
• Cinematics/marketing: fast polish without editing materials or geometry.
• Prototyping/blockouts: Instant cohesion while iterating layouts.

➡️ Getting started:

1) Add a Custom Pass Volume to your scene (GameObject -> Volume -> Custom Pass).

2) Set the Custom Pass Volume to Global and Injection Point to "After Opaque and Sky" or "Before Transparent”.

3) Add "EdgeFusionPass" to the Custom Pass Volume.

4) Set Intensity > 0 to enable the effect and customize!

📖 Support & docs:

Online guide · Forum · Discord

Related assets:

- Edge Fusion for URP.

Core Components:

• Interactor: Raycast-based component for detecting interactable objects with a specific tag.
• InteractibleObj: Component to make any GameObject interactable by linking it to an Interaction Type.
• Interaction Registry: A ScriptableObject that serves as the central database for all interactions.

Editor Tool Features:

• Create new interactions (auto-generates a simple C# script to customize, prompt asset, and type asset).
• Edit existing interactions (modify prompt text and key).
• Safely and easily delete interactions.

Technical Specs:

• Zero-Setup Initialization: The system initializes itself automatically at runtime with no manual setup required.
• ScriptableObject Architecture: Highly modular and data-driven.
• Dependencies: Requires the TextMeshPro package for UI prompts (automatically installed by Unity).
• Full C# source code included.
• Includes comprehensive documentation and a ready-to-use demo scene.

Compatibility:

• Made with Unity 6000.0.23f1.
• Supports all render pipelines (Built-in, URP, HDRP).

Support:

• Detailed documentation included.
• For questions or support, please contact snogdev@gmail.com.

The Snog's Interaction System is a complete, data-driven framework designed to save you hours of development time. This asset allows you to create and edit any type of in-game interaction through an intuitive editor window.

Whether you need to open doors, pick up items, talk to NPCs, or trigger complex events, the system will doo all the hard and boring work of making your wolrd interatible.

Features

• Little Setup Required: The asset works right out of the box. Just import, create the interactions in the editor window and you're ready to customize it all.
• No-Code: Create, edit, and delete interactions using the Interaction Creator window. Define names, UI prompts, and interaction keys with a few clicks. The system automatically generates all the necessary scripts and assets for you to customize the interaction. Simply open the auto-generated C# script and fill in the Execute method.
• Easily Extensible/Customizable for Programmers: While no coding is required to get started, the system is built on a clean, interface-based design. Based on a ScriptableObject architecture, each interaction is a self-contained unit. This makes your project clean, easy to manage, and scalable.

How It Works

1. Open the Creator: Launch the Interaction Creator from the Tools menu.
2. Create: Define a new interaction (e.g., "OpenDoor"). The tool generates a new customizable C# script and all required assets.
3. Implement : Open the new script and add your unique gameplay logic to the Execute method.
4. Assign: Add the InteractibleObj component to any object in your scene and type in the interaction name ("OpenDoor") and add the Interactor to the player.

It's that simple. The system handles detection, UI prompts, and input automatically.

Roadmap & Future Updates

The Snog's Interaction System is actively developed and supported. Your purchase helps support the development of these future updates!

• (Done) v1.0: Initial Release
• Interaction Conditions: Add an easy-to-use condition system directly in the editor, allowing you to create interactions that only work if certain conditions are met (e.g., "Player has the 'Gold Key' item").
• Dynamic Prompts: The ability to easily switch an object's prompt text after an interaction (e.g., from "Press E to Open" to "Press E to Close").
• Hold: Support for interactions that require the user to hold down a key for a certain duration (e.g., "Hold E to unlock").
• (Considering) Outlines: Built-in support for easily adding common visual feedback, like utlining the object when the player looks at it.

Have a feature you'd like to see? Let me know! Contact snogdev@gmail.com

Fast Play Mode is a lightweight Unity Editor tool that saves you time by giving quick access to Enter Play Mode Options.

Switch between fast iteration mode and safe default mode directly from the Scene View — no need to open Project Settings.

✔ Toggle Domain Reload
✔ Toggle Scene Reload
✔ One-click Play/Stop button
✔ Full tooltip with status
✔ Context menu with Reset to Default and Help

⚠ Remember: disabling reloads can cause static variables or scene states to persist. Always reset before shipping builds.

Perfect for rapid prototyping, iteration, and gameplay testing.

Demonstration Full YouTube - SHOWCASE

Number of textures - 8

Texture dimensions - 4096x4096

Polygon count - 19 386 Tris | 9 717 Points

Number of meshes/prefabs - 4/5

Rigging - Yes (rig is issued personally at your request)

Animation count - x11

Animation type list - In-Place/Root

UV mapping: Yes

Types of materials and texture maps - PBR

Feel free to contact:

Email existencestudio.help@gmail.com

Be part of our community on Discord!

| Be part of our community on Discord

| And Social Links Artstation | LinkedIn

Demonstration Full YouTube - SHOWCASE

Features:

✅ Custom Animations: Includes combat and basic actions.

✅ Custom Player Controller: Ready to use with our animations.

✅ Control Rig & IK: Fully rigged for Cinema 4D and Maya.

✅ Unity: Fully configured project with a custom controller with our animations.

✅ SRP, URP, HDRP Support: Ready for all Unity pipelines.

✅ Detailed Characters: All models include a mouth (with teeth and tongue) and eyes. All elements are rigged for animation via bones.

✅ DCC Packages: Preconfigured rigs for Blender, Maya, 3ds Max, and Cinema 4D.

✅ PBR Materials, 4K Textures.

📦 File Formats: Unreal Engine, Unity, FBX, OBJ, Cinema4D, 3DsMax, Blender, Maya, PBR-ready Textures.

Technical Info:

• Version Unity - 2019, 2021, 6000 and higher
• DEMO scene is not included
• DISCLAIMER: Video & Photo preview render make in another software - background and other content except for the model is not included in the asset

Polycount:

• Total Count - 19 386 Tris | 9 717 Points

Control Settings (Unity):

• W, A, S, D – Move
• F - Burrow_In/Out
• Shift - Speed
• LBC - Attack
• MBC - Attack (under ground)
• RBC - Dead

AnimationsPack consists of custom x11 animations:

• acid_spit, attack, burrow_attack, burrow_in/out, dead, get_hit, idle, walk, walk_angle_l,r

Overview

🪱 Acid Worm - a realistic, rigged & animated creature for the Underwater Creatures line.

This predatory worm weaponizes corrosive acid and viscous slime, bridging insect and snake traits into a believable apex enemy. Built for real-time use, it fits fantasy dungeons, scifi facilities, and horror encounters alike-an alien mutant animal that tunnels, ambushes, and dissolves prey with poison and toxic sprays.

⚙️ Gameplay & setup

Production-ready, fully rigged and animated for burrow loops, strike snaps, idle coil, and surface breaches. Hooks make it easy to scale into a set-piece boss or stealth parasite encounter, with damage over time from acid pools and mucus trails of slime.

🌍 World contexts

From endless dune seas where a towering sandworm stalks caravans, to crash sites where a ufo leaves biotech horrors in its wake, drop the creature into scifi labs, irradiated wastes, or abyssal trenches. Its segmented bulk sells a giant presence, while close-up detail supports cinematic shots and sickly toxic glints under hard light.

🔬 Look & feel

Realistic membranes, pitted enamel, and layered plates read at gameplay distance and hold up in close-ups. The rig supports full-body undulation and jaw deformation for convincing consumption and spray attacks-grounded, lethal, and unmistakably monster creature.

Successful development to you!