Feed aggregator

• UI framework: Unity UI Toolkit (UIElements) — no UXML or USS files required, all layout is code-driven
• Theme-aware: all colours reference EkiooWindowStyle constants that are calibrated for both Editor light and dark themes; no manual theme detection needed
• EkiooWindowStyle: single source of truth for colours (Bg, Accent, ActiveColor, DoneColor, RemoveColor, TextTitle, TextMuted, BorderColor, …), font sizes (FontSizeXS → FontSizeHeading), spacing (SpaceXS → SpaceXXL), and border radii (RadiusSm, RadiusMd, RadiusBadge, RadiusPill)
• EkiooInspectorBuilder: SectionLabel, Separator, ReadOnlyRow, MetaRow, ActionButton, RuntimeContainer — all returning VisualElement and composable without subclassing
• EkiooWindowBuilder: BuildSection, Badge, BuildTogglePill, FlexRow, ItemRow, Divider, ToolbarContainer, StatusBar, AccentDot — all returning VisualElement
• EkiooSparklineElement: custom VisualElement drawn with Painter2D; call SetSamples(float[], Color) to update — supports grid lines, fill gradient, zero line, and terminal dot
• DependencyChecker: static Require(packageId, displayName, url, sentinelTypeName) called from an [InitializeOnLoad] class; shows a one-time informational dialog per Unity session if a dependency is missing
• AssetDatabaseHelper: GetAssets<T>() — finds all ScriptableObject assets of a given type across the entire project without writing GUID queries by hand
• Assembly: Ekioo.Editor.asmdef, autoReferenced: true, includePlatforms: ["Editor"] — zero runtime overhead, does not appear in builds
• Unity: 6000.0 (Unity 6) or later
• Render pipeline: compatible with Built-in, URP, and HDRP (Editor-only, no rendering dependency)
• Sample: "Style Showcase" — importable from Package Manager; includes an EditorWindow, a CustomEditor, a demo MonoBehaviour, and a demonstration scene

Ekioo Editor Core is the shared foundation used by all Ekioo packages to build consistent, polished editor interfaces in Unity. It provides a centralised style system, a library of ready-to-use UI Toolkit components for both EditorWindow and CustomEditor, and a sparkline renderer — all designed to be dropped into any in-house or third-party Unity toolset.

The package ships a Style Showcase sample that demonstrates every visual primitive interactively, inside a live EditorWindow and a CustomEditor, with real-time Play Mode polling.

Who is this for? Any Unity developer or team building their own editor tools, custom inspectors, or Asset Store packages who wants a solid, theme-aware visual foundation without reinventing the wheel. The package has no runtime footprint — it is 100% Editor-only and adds zero overhead to builds.

What is included?

• A complete colour/typography/spacing palette that automatically adapts to Unity's light and dark themes
• Pre-built CustomEditor components: section headers, read-only rows, metadata rows, action buttons, and a Runtime foldout that disables itself outside Play Mode
• Pre-built EditorWindow components: titled sections, badges, toggle pills, item rows, toolbar, status bar
• A custom VisualElement that renders a data sparkline with grid lines, fill area, and a terminal dot
• A dependency-check mechanism for packages that need to declare optional or required dependencies
• A fully documented, interactive sample importable directly from the Package Manager

Requirements

• Extenject Dependency Injection IOC
• DOTween (HOTween v2)

Supported platforms

Multiplayer Card Game Core was designed for creating PC games. All of the systems will work on mobile, though UI would need adjustements.

Third-Party Notices

Asset uses the Ebbe font under a SIL OFL 1.1 license and Sclate font under a free license; see Third-Party Notices.txt file in package for details.

Create, customize, and launch your own Trading Card Game (TCG) or Collectible Card Game (CCG) in Unity - now with 1v1 Multiplayer built-in.

Card Game Core + Multiplayer Module gives you the complete single-player foundation of the original template, expanded with synchronized head-to-head duels for competitive turn-based gameplay.

Easily add your own cards, spells, heroes, effects, and abilities through a structured workflow, then validate balance in both AI matches and player-vs-player duels without rebuilding your core systems.

Powered by Unity Netcode for GameObjects (NGO) - Unity’s official networking solution for a Unity-native multiplayer foundation and smooth integration into modern Unity projects.

HELPFUL LINKS:

📄 DOCUMENTATION | 🌐 WEBSITE | 💬 DISCORD | 🎥 YOUTUBE

🛠 FEATURES OF CARD GAME CORE MULTIPLAYER INCLUDE:

⚔️ 1v1 Multiplayer Duels

Play head-to-head matches using a synchronized turn-based duel flow.

🎴 Synchronized Mulligan

Both players confirm opening hand changes before turn one begins - stable pacing and fair starts.

🔁 Turn Sync & Authority Rules

Clear “Your Turn / Opponent Turn” control, with consistent turn progression on both clients.

✅ Validated Actions

Actions are checked before being applied, keeping matches stable, predictable, and competitive.

🏁 Results & Rematch Flow

Finish matches cleanly, review outcomes, and start the next duel fast.

🎯 Where This Asset Fits Best

Card Game Core + Multiplayer Module is designed for projects where deck building, card collection, turn-based combat flow, and ongoing balance tuning are central - now extended with competitive 1v1 PvP.

Competitive CCG / 1v1 PvP Foundations

Deck builder, collection progression, and polished duel flow suitable for head-to-head play - in the spirit of Hearthstone, Legends of Runeterra, or Shadowverse.

Hero-Based Card Combat Systems

Support for heroes, spells, units, and clear combat feedback in a clean turn-based structure - similar in feel to Gwent or KARDS.

Prototype-to-Production TCG Projects

Ship a playable vertical slice faster with complete core systems plus multiplayer duel support - ideal when you want to validate rulesets, pacing, and balance early.

🔗 Plays Well With These Asset Categories

This asset stack integrates smoothly with the systems commonly used alongside TCG/CCG projects:

Backend, Player Profiles & Cloud Save

Account-based collections, cross-device persistence, secure inventory storage.

Card Pack, Gacha & Loot Systems

Booster packs, rarity pools, pity rules, pack-opening UX.

LiveOps, Events & Remote Config

Balance updates, rotating formats, limited-time events, weekly rule changes.

Quests, Daily Tasks & Battle Pass Systems

Retention loops rewarding matches, wins, and collection milestones.

Ranked Play, Leaderboards & Tournaments

Ladders, seasonal progression, brackets, competitive ranking layers.

Economy, Shops & IAP Frameworks

Currency sinks, bundles, cosmetics, starter packs, store flows.

Analytics & A/B Testing Tools

Track deck meta, win rates, funnels, churn signals for faster iteration.

Content Pipelines (CSV / Sheets-Based Tools)

Scalable card authoring and balancing via spreadsheets and localization tables.

Card Game Core is designed to fit into modern TCG/CCG production pipelines and works smoothly alongside commonly used Unity tools for multiplayer, data management, and scalable workflows.

Possible Integrations:

• Odin Inspector & Serializer
• Easy Save – The Complete Save System
• PlayFab Unity SDK
• Behavior Designer Pro - DOTS Powered Behavior Trees
• Toolkit for Steamworks 2026
• Hot Reload
• vHierarchy 2
• Scriptable Sheets
• Sensor Toolkit 2
• DOTween (HOTween v2)
• I2 Localization
• Master Audio 2024
• Amplify Shader Editor
• Super Text Mesh
• Rewired
• Curvy Splines
• Behavior Designer

Core Component:

• NPC Controller Script – central “brain” managing NPC behavior, movement, interactions, and animations.

Movement & Navigation:

• Integrated with Unity NavMesh for pathfinding
• Smooth animation blending via Animator.CrossFade
• Target-based movement logic for dynamic navigation

Interactions:

• NPC-to-NPC conversations (visual / timed interactions)
• Object-based interactions (pick up, use, activate)
• Interruptible actions with state-safe fallback

Zone Awareness:

• Limit NPC Movable Space.

Animation & Visuals:

• Assign animations to world objects
• NPCs can visually interact or appear to talk to each other
• Supports environment storytelling via actors and animated objects

Customization & Extensibility:

• Adjustable parameters for movement speed, interaction timing, zone behavior
• Modular namespace and clean architecture for easy integration into projects
• Lightweight and optimized for performance

Setup:

1. Add NPC Controller to your NPC prefab
2. Assign Animator and optional NavMeshAgent
3. Configure zones, interactions, and targets

Ideal For:

• RPGs, adventure games, simulations, fantasy worlds, open-world games
• Developers who want quick setup with modular, extensible NPC behavior

Bring your world to life with a powerful and flexible NPC behavior system designed to create believable, dynamic characters with minimal setup.

This asset allows you to create NPCs that move naturally, interact with the environment, talk to each other, and respond to different zones in your world — making your game feel alive instead of static.

• Deterministic snapshot storage for repeatable comparisons
• Baseline vs current diff with increases, decreases, new, and removed entries
• Budget thresholds for total variants, delta variants, percent delta, and per-shader caps
• Ignore rules and allow rules for cleaner signal
• Latest-passing baseline workflow for CI promotion
• Incomplete snapshot detection with fail-fast CI gating
• Batchmode runner with stable exit codes for automation

📜 Docs

Shader Variant Budget & CI Guard helps Unity teams find, understand, and stop shader variant regressions before those regressions turn into bigger build problems. Instead of guessing why variant counts suddenly went up, you can capture snapshots, compare builds, and see exactly what changed. The tool is made for developers who want a clear workflow, not a vague warning after the damage is already done.

The core job of this tool is simple: it tracks shader variant counts over time and tells you when they move in the wrong direction. After a build, it reads the variant data from Editor.log, saves a deterministic snapshot, and lets you compare a baseline build against a current build. You can quickly see total variant changes, per-shader changes, new entries, removed entries, and where the biggest increases came from.

This matters because shader variant growth is easy to miss. A project can look fine for weeks, then slowly collect extra variants through shader changes, keyword changes, package updates, or content changes across teams. By the time someone notices, the project may already have slower build iteration, harder debugging, and a less predictable pipeline. This tool gives you a practical guardrail so shader variants stay visible and controlled.

Inside the Unity Editor, the workflow is built to be direct and easy to use. You open the Shader Variant Guard window, capture or load snapshots, choose a baseline and current result, and run a comparison. The results are shown with summary cards, filtered diff views, search tools, sorting, and diagnostics. That means you do not need to dig through raw logs by hand just to answer basic questions like “what changed?” or “which shader caused this jump?”

The budget system is where this becomes a real production tool, not just a viewer. You can define hard limits and warning limits for total variants, delta variants, percent delta, and per-shader counts. When the current snapshot breaks those rules, the tool reports the problem clearly. You can also add ignore rules and allow rules so the results stay focused on the shader changes that actually matter to your team.

For teams working in CI, this tool is built to gate builds automatically. It includes a batchmode runner with stable exit codes, external JSON budget support, report export options, and a latest-passing baseline workflow. In practice, that means you can run it in automated validation and fail a build when shader variant counts cross the limits you defined. Instead of noticing regressions later, your pipeline can stop them at the point where they are introduced.

Baseline management is handled with real production needs in mind. The tool can compare against the latest snapshot, the latest passing snapshot, or a specific snapshot path. It also supports profile-aware baseline matching, latest-passing index overrides, and optional baseline promotion in CI. This makes it useful for teams that need a repeatable baseline workflow across multiple branches, build targets, or build profiles.

The tool also protects you from low-quality data. If a snapshot is incomplete, the guard can detect that and fail the check instead of silently giving you bad results. This is important because a broken or partial snapshot can hide a real regression. The incomplete-snapshot gating makes the tool more reliable when used in automated environments where confidence in the data matters.

The editor experience is practical, not bloated. Settings are available in Project Settings, with normal and advanced sections, browse buttons for paths, clear controls for storage and retention, and guidance for unusual values. The main window supports snapshot-first comparisons, filtering, search, diff tabs, and diagnostics export. There is also a one-click Generate Example Test Workflow action so you can seed realistic sample data and understand the tool fast.

This asset is a strong fit if your project has grown past the point where manual checking is enough. If you are shipping on multiple targets, working with a team, reviewing build health in CI, or trying to stop shader complexity from creeping up over time, this tool gives you structure and visibility. It is especially useful when you want to turn shader variant control into a repeatable process instead of relying on memory, guesswork, or occasional cleanup passes.

What you are really buying is control. You get a way to measure shader variant changes, compare builds with confidence, define budgets that match your project, and enforce those budgets both in the Editor and in CI. If shader variants have ever felt like a hidden problem in your pipeline, Shader Variant Budget & CI Guard turns them into something visible, trackable, and manageable.

• One-click generation of clean 2D icons from 3D models

• Automatically exports PNG icons with transparent backgrounds

• Automatically imports icons as Sprite (2D and UI)

• Preview camera shows the final icon in Game View before export

• Export directly into the Unity project or to an external location

• Automatic folder creation for icon exports

• Ideal for RPG inventory icons, item icons, and UI thumbnails

IconStudio is a lightweight Unity editor tool that converts 3D models into clean, UI-ready 2D icons with a single click.

Simply place your model under the ItemSpawn object, position it at (0,0,0), adjust rotation as desired, and export. IconStudio automatically renders the object to a transparent PNG and configures the texture import settings for immediate use in Unity UI.

Designed for developers who want their UI icons to perfectly match their 3D models, IconStudio makes it easy to generate consistent, professional-looking icons without needing design experience or spending hours creating custom artwork. It works out of the box in clean Unity projects and supports Built-in, URP, and HDRP pipelines.

Perfect for inventory systems, RPGs, strategy games, mobile UI, or any project requiring fast icon generation.

Stop wiring everything together.

Evently introduces a clean and deterministic event-driven communication layer for Unity. Instead of tightly coupling systems with direct references, singletons, or manager chains, Evently allows components to communicate through a scalable publish/subscribe event architecture. This keeps your codebase modular, maintainable, and significantly easier to extend as your project grows.

No string-based events. 

No hidden dependencies. 

No fragile object graphs.

Evently provides a type-safe event system for Unity that enables systems to react to events without knowing about each other.

Core Capabilities

• Global Event Bus – project-wide messaging system for communication between gameplay systems
• Scoped Event Buses – isolated buses for modular features, UI panels, mini-games, tools, or temporary systems
• Disposable Subscriptions – explicit lifetime control for every event listener
• Auto-Bound MonoBehaviour Listeners – automatic cleanup when Unity objects are destroyed
• Lightweight Debug Window – inspect active events and listener counts directly in the Unity Editor

Event Dispatching, Done Right

• Type-Safe Events – strongly-typed contracts (structs or classes), zero magic strings
• Fluent Listener API – chainable configuratio for expressive and maintainable subscriptions
• Duplicate Subscription Protection – prevent accidental multiple registrations
• Exception-Safe Dispatching – one failing listener won’t break the entire event chain
• Minimal Allocations – optimized for performance-sensitive and mobile projects

Documentation

FEATURES

• Uses Burst compiler and Jobs for optimizing performance.
• Extremely low GC footprint.
• Simple API.

VERIFIED PLATFORMS

Windows, Linux, Android, WebGL.

SUPPORTED PLATFORMS

Windows, Linux, MacOS, Unity WebGL, Android, iOS, PlayStation, Xbox, Switch.

Requires Collections package v2.6.5+

OP Tween

The package contains the Engine dll. The Burst code open sourced. And a demo folder showcasing OP Tween's use.

The package was built with simplicity and performance in mind, allowing for easy and efficient Transform tweening. The engine keeps a low GC footprint with no allocations except on initialization and resizing.

Why OP Tween?

- Best performant tweening engine thus far.

- Has by far the least GC footprint compared to other well established tweening engines.

- Future proof. Using Unity's Burst compiler OP Tween benefits from any improvements done on this worked on module.

Warning!

It is highly recommended to use the open source Burst code as is! Any changes made could easily affect performance.

• 25 FBX models 8 → 10,026 triangles
• 200 PBR Textures (2048x2048)
• 66 Materials (Metallic Workflow) Albedo (BaseMap) Normal MaskMap (Metallic + Smoothness)
• 111 Prefabs Drag-and-drop ready
• Texture Variants Floors: 8 Walls: 4 Doors: 2 Surgical tables: 2

Hospital Horror Props Pack

Create immersive and terrifying hospital environments for horror games, escape rooms, or cinematic scenes.
This pack provides a complete set of modular medical props and building elements, allowing you to quickly build detailed, atmospheric hospital interiors with ease.

Key Features

• Complete modular hospital environment
• Designed for dark, horror-focused scenes
• Easy drag-and-drop workflow
• Optimized for real-time performance
• Compatible with URP and HDRP

Ideal For

• Survival horror games
• Psychological horror experiences
• Escape room projects
• Unity or Unreal cinematic scenes

What’s Included

This pack contains 25 unique 3D models, organized into the following categories:

Medical Props

• Hospital beds (standard and wheeled)
• Empty and fully dressed variants (mattress and sheets)

Surgical Equipment

• Surgical table
• Overhead surgical light

Furniture

• Medical cabinet
• Carts (standard, wheeled, and damaged variants)
• Wheelchair

Modular Building System

• Wall segments (1m, 4m, corner, door cut, window cut)
• Floor tiles
• Ceiling tiles
• Doors (single and double)
• Windows

Lighting

• Ceiling light fixture with emissive material

Technical Details

• Triangle count: 8 – 10,026 per asset
• 25 FBX models
• 111 prefabs (drag-and-drop ready)

Textures & Materials

• 200 PBR textures (2048x2048)
• 66 materials (metallic workflow)
• Includes:Albedo (Base Map)
  Normal maps
  Mask maps (Metallic + Smoothness)
  

Variations

• Surgical tables: 2 texture variants
• Floors: 8 variants
• Walls: 4 variants
• Doors: 2 variants

Render Pipeline Support

Fully compatible with:

• Universal Render Pipeline (URP)
• High Definition Render Pipeline (HDRP)

Includes separate materials and prefabs for each pipeline.
No additional setup required — just import and use.

Performance & Optimization

• Low-poly and performance-friendly
• Clean UV mapping
• Optimized for real-time applications
• Suitable for PC and mid-range hardware

Modular Workflow

• Snap-based modular system
• Easily build rooms, corridors, and full hospital layouts
• Reusable components for fast level design

Why Choose This Pack?

• Complete hospital environment solution
• High-quality PBR assets
• Modular and scalable design
• Production-ready for games

A small monster suitable for 2D top-down view retro pixel-art games.

The Sprouting Seeds are cute, but don't let their innocent looks fool you. They are perfect for sunny meadows, old greenhouses, or overgrown ruin game scenes.

4-Directional Movement: Animated in Top, Down, Left, and Right views.

Dynamic Attack & Death: High-frame-count animations for a smooth, high-quality feel.



Aseprite Source Files: Easily tweak colors or frame rates to fit your game.

Package including：

Idle: 4 frames x 4 directions

Move: 8 frames x 4 directions

Rush Attack: 10 frames x 4 directions

Spinning Attack: Spinning Loop 3 frames (can be uesed in all directions), Spinning Start 15 frames x 4 directions, Spinning End 5 frames x 4 directions, Spinning Dizzy 11 frames x 4 directions.

Hurt: 1 frames x 4 directions

Death: 10 frames (Left&Right)

Easy to use, start your first fight enemy right now!

10 high-quality poison effect for pixelart

Poison_Effect_01 -- 20 frames

Poison_Effect_02 -- 7 frames

Poison_Effect_03 -- 12 frames

Poison_Effect_04 -- 17 frames

Poison_Effect_05 -- 20 frames

Poison_Effect_06 -- 6 frames

Poison_Effect_07 -- 15 frames

Poison_Effect_08 -- 8 frames

Poison_Effect_09 -- 29 frames

Poison_Effect_10 -- 9 frames

Including aseprite files and sprite sheet.

You can edit the sprites freely, but cannot repackage, resell or redistribute them in any way.

Enhance your 2D RPG or Action game with this comprehensive collection of 24 hand-crafted pixel art particle effects. These effects are pre-configured as Unity Prefabs, allowing for immediate integration into your character or environment logic.



Effect List (24 Total)

Burn: Rising orange flames and embers.

Cold: A frozen blue crystalline overlay.

Electric: Sharp purple electrical arcs.

Paralysis: Yellow jolting currents.

Poisoning: Bubbling green toxic gas.

Blood: Splattering red droplets for bleed effects.

Stench: Murky purple haze and bubbles.

Petrifaction: A stony, desaturated statue effect.

Stun: Rotating golden halos.

Confusion: Circling stars above the head.

Blind: Obscuring cloud or "miss" indicators.

Sleep: Classic floating "Z" icons.

Fear: Dark purple skull icons and trembling energy.

Slow: Downward-moving particles indicating heavy weight.

Heal: Vibrant green crosses and sparkles.

Food: Health restoration through nourishment visuals.

Purify: Clean white light for debuff removal.

PowerUp: Golden upward arrows and glowing aura.

Fast: Speed trails and swift movement sparks.

Star: Shimmering celestial energy.

Energy: Concentrated aura for mana or power.

Vampire: Red life-steal absorption effects.

Rage: Intense focused combat energy.

Demon: Dark, ominous supernatural aura.



Easy to use and ready for your project!

You can edit the sprites freely, but cannot repackage, resell or redistribute them in any way.

A set of high-quality fire pixel-art effects.​​Whether you are building a platformer, a top-down ARPG, or a classic rogue-lite,

This pack contains 5 projectiles and 3 impacts:



Package including：

effect_state_blind

FireFX_Set01_02: 6 frames.

FireFX_Set01_03: 6 frames.

FireFX_Set01_04: 6 frames.

FireFX_Set01_05: 9 frame.

FireFX_Set01_06: 7 frames.

FireFX_Set01_07: 14 frames.

FireFX_Set01_08: 5 frame.



All animations have Aseprite file and sprite-sheet file.

Easy to use and ready for your project!



You can edit the sprites freely, but cannot repackage, resell or redistribute them in any way.

A group of cute animated emoticons, to makes your conversation more interesting！

Includes 18 emoticons, 32*32 sized:

*Sigh - 10 frames

*Question - 10 frames

*Sweat - 10 frames

*Idea - 10 frames

*Whisper - 10 frames

*Happy - 10 frames

*Anger - 10 frames

*Sad - 10 frames

*Laugh - 10 frames

*Shock - 10 frames

*Excite - 5 frames

*Fingers - 10 frames

*Tension - 5 frames

*Greedy - frame 10

*Pride - 10 frames

*Heart - 10 frames

*Depression - 10 frames

*Shyness - 10 frames

Including aseprite files, sprite sheet and preview gif.

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

License

- You can use the assets for commercial or personal game projects.( I’m so glad to see if you can make some games using these assets! )

- You can edit the assets freely, but cannot repackage, resell or redistribute them in any way.

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

A small monster suitable for 2D top-down view retro pixel-art games.

Watch out for the shadows! Emerging from the dampest corners of the underground, the Green Spider is a classic foe for any top-down adventure. With its vibrant green shell and glowing red eyes, it stands out perfectly in dark dungeon environments.

4-Directional Movement: Animated in Top, Down, Left, and Right views.

Dynamic Attack & Death: High-frame-count animations for a smooth, high-quality feel.

Aseprite Source Files: Easily tweak colors or frame rates to fit your game.

Package including：

Idle: 8 frames x 4 directions

Move: 6 frames x 4 directions

Attack: 9 frames x 4 directions

Hurt: 1 frames x 4 directions

Death: 18 frames (Only down)

Easy to use, start your first fight enemy right now!

You can edit the sprites freely, but cannot repackage, resell or redistribute them in any way.

=== Content ===

- Number of Unique Meshes: 32.

- Number of Unique Materials: 44.

- Number of polygons: 2 to 2.784.

- Texture sizes used:

  - 2048x2048 (62)

  - 1024x1024 (1)

- Types of texture maps: BaseMap, MaskMap, NormalMap.

=== Statistics ===

The package includes:

  - 13 FBX models.

  - 23 Prefabs.

  - 44 Materials.

  - 63 Textures.

  - 1 Demo Scene(s) with preconfigured Lightmap.

=== Notes ===

- Optimized 3D Models for performance.

- VR-ready assets.

- Baked GI included.

- Post Processing Setup provided.

Lumina Art Gallery – Modern VR Environment Pack is a high-quality 3D environment designed for Unity, crafted to deliver an immersive and realistic virtual exhibition experience.

This environment features a spacious, minimalist gallery with clean white architecture, polished reflective floors, and a soft illuminated grid ceiling that enhances the visual atmosphere. The scene includes multiple framed artworks (abstract, portraits, and modern compositions), structural columns, and a contemporary bench, creating a refined museum-like space.

Fully optimized for VR and real-time applications, this asset ensures smooth performance while maintaining high visual quality. The modular-friendly layout allows easy customization—replace artworks, adjust lighting, or expand the gallery to fit your project.

Whether you're building a virtual museum, an interactive experience, or a cinematic environment, Lumina Art Gallery provides a versatile and elegant foundation.

Key Features:

• High-quality modern art gallery environment
• Fully optimized for VR (smooth performance)
• Minimalist architecture with clean lighting
• Multiple artworks included (easy to replace)
• Reflective polished floor and soft global lighting
• Modular-friendly layout
• Ready for games, VR, and cinematics

Use Cases:

• Virtual reality (VR) exhibitions
• Art gallery / museum scenes
• Architectural visualization
• First-person exploration games
• Cinematic environments

🧩 Technical Details

• Total prefabs: 108
• Total tris for each prefabs: Between 32 verts to 196K verts
• 88 unique material sets for optimal quality and performance
• Colliders: Custom mesh colliders and primitive colliders included
• Textures: PBR, optimized for modular use (4096 to 1024). Downgrade as you need for better performance on mobile.

⭐ Community ⭐

Join the Friday Night Studio Discord for support, exclusive updates, freebies, vouchers, and early access to new packages 🎁:

🚀 FRIDAY NIGHT STUDIO - DISCORD 🚀

🤝 Overview

This modular Futuristic Environment Pack is the Fourth entry in our biggest and most ambitious series yet. We are really excited to finally share it with the world! 💫

If you want to expand the environment even further, feel free to check out the others packages in the series, designed to connect seamlessly with each other.🧩

• Vol.1 Futuristic Environment Kit – Sci-Fi Mega Mall
• Vol.2 Futuristic Environment Kit – Sci-Fi Living Facility
• Vol.3 Futuristic Environment Kit – Sci-Fi Armory Facility

Take a look at our unity asset store page for more futuristic environments! ✨🏞️

• Friday Night Studio - Unity Asset Store

Perfect for PC, consoles, VR, Mobile, games, cinematic projects, and interactive experiences. 🎮🎥

• Fully modular parts with PBR Metallic Roughness workflow.
• Game-ready prefabs and materials.
• Optimized colliders for smooth gameplay.
• Demo scenes included for easy showcase and testing.

🚀 Pipeline Compatibility

🛠️ All materials and prefabs already converted and ready to use.

• Built-in Render Pipeline ✅
• Universal Render Pipeline (URP) ✅
• High Definition Render Pipeline (HDRP) ✅

✔️ Notes:

• Lighting and post-processing settings may vary between render pipelines. Adjust them as needed for your scene. 💡
• There are no scripts or animations included in this pack. Everything is modular, allowing you to customize each piece and attach your own scripts and animations as needed.
• The main Hall features Two entry/exit points, allowing you to easily expand and build around it. Modular corridors and airlock sections (SAS) are included in the package.

The packs contains mainly :

• Landing Base
• Landing pads
• Landing stations
• Train stations
• Elevator
• Control Room
• Spaceships
• Fuel tanks
• Corridors
• Sas
• Storage

⭐Follow us for updates, promotions, previews & more⭐:

DISCORD | INSTAGRAM

• Core: Runs as a Unity EditorWindow with modular architecture (Core, GUI, Tools, Systems). Separate Runtime/Editor assemblies.
• Rendering: GPU-composed layers via custom LayerBlend shader and 7 Compute Shaders. Features async readbacks and memory-pooling to prevent GC spikes.
• Data Security: RAM-Protected Undo History and Backup Manager with auto-recovery snapshots.
• Tools: Brush/Eraser (with custom textures), Flood Fill, Eyedropper, Shape Tools (Line/Rect/Circle), Move, Transform (Scale/Rotate/Skew), and per-pixel selection masking (Select/Lasso/Magic Wand).
• Layers: Standard Layers, Smart Layers (Rasterize/Convert), Alpha Lock, Clipping Masks, Real-time Styles, Tags, and Multi-select Merging.
• Animation: Frame-based visual timeline, Onion skinning (configurable range/tint), Animation Tag sequences, and adjustable FPS preview.
• Export/Import: Import PNG/JPG, gpl/hex palettes, and Sprite Sheets. Export as PNG, JPG, TGA, auto-padded Sprite Sheets, GIFs, and Unity Animation Clips (.anim).

Sanctyr Pixel Art Editor is a fully-featured, GPU-accelerated pixel art and animation environment built directly into the Unity Editor. Say goodbye to switching between external apps and Unity — draw, animate, and export your assets all in one place.

• Lightning Fast & Large Canvas Support: Powered by 7 dedicated Compute Shaders, you can draw on 2048x2048 canvases with dozens of layers without input lag.
• Non-Destructive Workflows: Utilize Photoshop-like Smart Layers, Clipping Masks, and real-time Layer Styles (Outlines, Drop Shadows) that never damage your original art.
• Professional Toolset: Includes Alpha Lock, Skew/Transform, Magic Wand, Custom Brushes, Symmetry Drawing, and a 3x3 Tile Preview for seamless textures.
• Animation Made Easy: Full timeline controls with Onion Skinning and Animation Tags. Export your frames directly to auto-sliced Sprite Sheets or ready-to-use Unity .anim Clips in a single click

Number of textures: 3

Texture dimensions: 2048x2048

Polygon count of lily: 4770 faces

Number of meshes/prefabs: 1

Rigging: Yes

Animation count:1

UV mapping: Yes

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

Animated 3D blooming lily

Rigged, Animated, UV's Unwrapped and Textured with 2048px sized images

.Fbx and .Blend files included

Mesh and textures:

Quad topology (4770 faces), 3 textures (2048px) (base color, normal, roughness)

Animations:

This model is supplied with 1 blooming animation

Files:

• .blend editable Blender file
• .fbx all in one file, easy to use

Misc. information

I carefully make all my models from stracth using Blender, So I hope you like them :)

For any questions, please contact me, I'll be glad to help :)

You can also check my social networks, I often post renders of my works!

Instagram

Youtube

Mail: zacxophone3d@gmail.com

Number of textures: 3

Texture dimensions:4096x4096

Polygon count of Fish: 1960 faces

Number of meshes/prefabs: 1

Rigging: Yes

Animation count:1

UV mapping: Yes

LOD information (count, number of levels): NO LOD

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

Animated 3D Regal tang

Rigged, Animated, UV's Unwrapped and Textured with 4096px sized images

Import:

Check all the files you need and the correct pipeline folder. Uncheck the two other pipeline folder

Mesh and textures:

Quad topology (1960 faces), 3 textures (4096px) (albedo, normal, MetallicSmoothness)

Animations:

This model is supplied with 1 cycled wimming animations

Armature:

Hand made armature (80 bones), I placed all bone by hand

Misc. information

I carefully make all my models from stracth using Blender, So I hope you like them :)

For any questions, please contact me, I'll be glad to help :)

You can also check my social networks, I often post renders of my works!

Instagram

Youtube

Mail: zacxophone3d@gmail.com

Cloud Shadows Pro is a simple yet powerful drag & drop solution to add dynamic cloud shadows to your scenes.

Designed for maximum ease of use, this asset works directly on Mesh Renderers—no complex setup required.

How it works:

Just add an extra material slot to your mesh renderer and assign the CloudShadowsPro material. Instantly, animated cloud shadows will appear on your surface.

Important:

• Works only with Mesh Renderer
• Not compatible with Terrain