Feed aggregator

Smart NPCs is a flexible and modular AI system for Unity, designed to create dynamic, decision-making NPCs that adapt to their environment.

This pack contains complex algorithms to achieve a modular solution, due to the complex setup it allows you to easily expand upon it if you desire so.

In order to have the pack fully functional you are required to instal the unity AI Navigation package into your project. This can be found in the Package Manager under the Unity Registry.

Out of the box Smart NPC offers the following:

• Tool for quickly creating NPCs with various behaviours
• A simple way to create NPC routines
• Patrol (waypoint to waypoint behaviour with settings)
• Idle (find a place to rest at or go to the house of the npc)
• Multiple AI Brains
• Performance (automatically enabled depending on the settings)
• Simple - FSM (rotates behaviour sequence)
• Complex - GOAP (essentially hero NPCs with complex adaptive sequences)
• Tool for creating patrol areas
• Completely customize the waypoints and the animations it should perform
• Prioritize certain waypoints over others for NPCs randomly selecting them
• Tool for creating rest areas
• Tired NPCs (if you want) can rest at restaurant-like places or stalls or something else
• Configure which animation should be played
• Tool for debugging
• See the important hidden NPC details
• Quick start guides based on complexity
• How to create a NPC
• How to use the other tools
• Tips for "dynamic" areas
• How to modify/expand a module
• How to create your own module

Smart NPCs has a few updates scheduled to be released. This is included in this package and will become available as an update:

• Debugging upgrade
• More detailed insights
• Module expansion 1
• Dialogue (simple NPC - player interaction and even NPC - NPC interaction)
• Combat (simplistic melee combat)
• Module expansion 2
• Sensory (NPC can observe and react to occurances)
• Tool for creating occurances
• Configure which NPCs are involved in what occurance
• Eg. NPC A kills NPC B.

Smart NPCs: Dynamic AI for Your Game

Bring your game to life with Smart NPCs, an easy-to-use, modular AI system for Unity that lets you create intelligent, reactive characters with minimal effort. Whether your NPCs are patrolling, resting, fighting, or engaging in conversations, this asset pack provides the flexibility and power to make your world feel alive.

With a variety of behavior modules, including advanced patrolling, advanced resting, and more, each NPC adapts to their surroundings and makes decisions based on emotions, needs, and situational awareness. Perfect for both beginners and experienced developers, Smart NPCs allows you to scale complexity while keeping performance optimized.

Key Features:

• Modular Design: Add or remove behavior modules like patrolling, resting, etc. to fit your NPCs’ needs.
• Easy Setup: Quickly get started with intuitive inspectors and built-in tools to simplify NPC creation.
• Advanced Decision-Making: Hero NPCs intelligently adapt using GOAP (Goal-Oriented Action Planning), emotional states, and utility-based decision-making.
• Lightweight Accessible: Standard NPCs use an advanced FSM (Finite-Statemachine) to perform routines while being capable of dynamic reactions.
• Performance Optimized: Designed to run efficiently, even in large, complex environments.

Create smarter, more immersive worlds effortlessly with Smart NPCs—your go-to solution for NPC behavior in Unity!

This pack comes with a future roadmap, please see the technical details for what is yet to come!

Price $108.00

Super complete low-poly asset pack to use as a base for your next game! Includes all the essential elements from modular buildings, vehicles and props. +700 prefabs!

Average:

All assets included in the packages add up to a total of 149,845 Polygons.

The average number of polygons in each asset is ~161 polygons

Number of textures: 2

Texture dimensions: 64x64

Minimum polygon count: 1

Maximum polygon count: 3561

Number of meshes/prefabs: 764

UV mapping: Yes, each asset includes 2 UV channels.

 - UV1 Unwrap No Overlap

 - UV2 for color through the gradient texture (Overlap).

LOD information: Some assets include LOD solely for the purpose of improving their visualization in distant cameras, taking into account the low-poly nature of the package.

Types of materials and texture maps: All assets include Metallic, Roughness and Emissive maps stored in their vertex colors.

No animations included

Other:

The pack is developed to use only 3 materials and a single gradient base texture. It has PBR maps that are baked into the vertex colors of the assets.

R = Metallic

G = Roughness

B = Emission

A = N/A (The environment plants have a mask to be used as a base for a leaf movement shader. NOT included)

It includes a variation of the base shader in case you don't need the PBR channels and for something more toon-like using only the BaseColor.

In this pack you will find:

• Modular building sets for farms and suburbs buildings. (x95)
• Crop plants set with 3 growth stages ready to implement as needed. (x146)
• Road set. (x18)
• Vegetation set for the environment. (x90)
• Porps (x358)
• Vehicles (x10)
• Terrain set for the environment. (x27)

The style of the pack seeks to evoke the old low-poly era of the N64, but for modern times. It has a strong emphasis on having a smooth and simplified style.

Price $40.00

A highly customizable shader powered button - no image files required! The only button package you will ever need.

Dependencies:

• TextMeshPro (Unity 2018.1 or later): TextMeshPro is included by default in Unity 2018.1 or later. If using an earlier version of Unity, please install TextMeshPro via the Package Manager. Also, make sure essential TextMeshPro Essential Resources are imported (Window -> TextMeshPro -> Import TMP Essential Resources).

The Custom Button package offers a flexible and highly customizable UI component for Unity developers, enabling the creation of buttons with unique shapes, colors, animations, and interactive features, all without coding. This prefab easily integrates into any project, powered by a shader for compatibility across devices—no image files required!

Why Choose the Custom Button Package?

• Any genre
• No coding required
• Compatibility across devices of any resolution
• Extensive customization
• Time-saving
• Beautiful animations
• No image files
• Built in sounds and fonts with OFL and CC0 licensing (no attribution required)

Key Features:

• Shape Customization: Modify each button corner with either a Cut, Cloud, Round, Spike, and Splash shape. Modify button depth, aspect ratios, shape density, amplitude and intensity, to create a variety of unique shapes.
• Color and Outline Settings: Set front face, background, and outline colors. Set outline thickness and gradient angles.
• Text and Font Integration: Easily add and manage fonts with the ability to adjust text size and color with over 65 built in OFL fonts.
• Animation Controls: Multiple built in animation states, including Idle, Focus, Unfocus, and Click animations - all fully customizable without needing to edit the animations themselves.
• Sound and Vibration: Sound on button interaction with over 85 built in CC0 sounds with the ability to add your own. Enable vibration on mobile devices.
• Easy Setup: Add the Button prefab to your scene, customize settings, and save as new prefab variants for consistent use.
• Compatibility: Fully compatible with Unity's Animator system for dynamic UI elements.

Licensing (see Third-Party Notices.txt for details):

• Fonts: ALL fonts included in this package are licensed under the Open Font License (OFL), sourced from Google Fonts.
• Sounds: ALL audio files included in this package are provided under the CC0 license, free for use and modification.

This package is governed by the Unity Asset Store EULA, ensuring flexibility in use for both personal and commercial projects.

Explore more:

• Tutorial: https://youtu.be/XXojaBb_158
• Trailer: https://youtube.com/shorts/CuE-y-IoCBs
• Documentation: found in the package's README.md or at https://playya.au

Price $150.00

A tool for comparing Unity3D Prefabs, quickly comparing differences, copying components, copying properties, etc.

Feature List

• Compare Prefab Differences
• Visualize Results
• Filterable Results
• Customizable Ignored Properties
• Quick Copy of GameObject
• Quick Copy of Component
• Quick Comparison Menu
• Synchronized Tree List
• Component Display Consistent with Unity

The principle is based on the comparison of the subtrees of two Prefabs in sequence (by name), and then the differences are displayed in a tree structure. Then, by clicking in, you can see the differences in the Components of the two sub-GameObjects. After selecting a specific GameObject or Component, you can see the comparison based on SerializedObject and SerializedProperty, and then you can perform editing operations.

Compatible Version: 2020.3+

Price $9.99

3D grid-based pathfinding featuring A*, Weighted A*, Greedy Search, Dijkstra, BFS, and DFS algorithms; includes path smoothing, curving, and movement scripts with avoidance and roaming behaviors.

1. Grid and Node Management:

• Node Class:Represents individual cells in a grid.
  Contains properties such as walkability, world position, grid coordinates, and pathfinding costs (gCost, hCost, fCost).
  Tracks parent nodes for path retracing.
  
• GridManagerPathPro Class:Creates and manages a 2D grid of nodes based on specified world size and node radius.
  Implements dynamic walkability checks using Unity's physics system to detect obstacles.
  Supports adjustable grid settings, including cell height and walkability check intervals.
  Includes methods to retrieve nodes from world positions and find neighboring nodes.
  

2. Pathfinding Algorithms:

• Implemented Algorithms:A* (A-Star): Finds the shortest path using heuristics to estimate cost to the goal.
  Weighted A*: Variation of A* that uses a weight factor to influence path selection.
  Greedy Best-First Search: Prioritizes nodes closest to the goal, faster but may not find the shortest path.
  Dijkstra's Algorithm: Explores all possible paths to find the absolute shortest path without heuristics.
  Breadth-First Search (BFS): Explores equally in all directions; guarantees the shortest path in unweighted graphs.
  Depth-First Search (DFS): Explores as far as possible along each branch; may not find the shortest path.
  
• PathfindingManagerPathPro Class:Contains methods for each pathfinding algorithm.
  Allows for dynamic selection of algorithms at runtime.
  Supports path smoothing and curving options for each algorithm.
  Implements helper methods for retracing paths and calculating distances.
  

3. Path Smoothing and Curving:

• Path Smoothing:Removes unnecessary nodes from the path to create more direct routes.
  Checks for walkable straight lines between nodes to prune the path.
  
• Path Curving:Replaces sharp turns with smooth Bezier curves for natural movement.
  
  Adjustable parameters:Curve Resolution: Determines the number of interpolated points on the curve.
  Bevel Size: Controls the size of the curve's smoothing effect.
  
• Customization:Enable or disable smoothing and curving for each algorithm individually.
  Adjust bevel size and curve resolution to fine-tune path appearance.
  

4. Movement Scripts:

• MovementPathPro Class:Handles agent movement along calculated paths.
  Supports settings for speed, path visualization, and target positions.
  
  Features avoidance behavior:Agents can flee from targets when within a specified danger zone.
  Safe zone distances can be set to define when agents stop fleeing.
  
  Includes random roaming mode:Agents can move to random walkable points within the grid.
  Roaming range is adjustable.
  
• Movement Behaviors:Agents can dynamically switch between following paths, avoiding targets, and roaming.
  Movement is updated in real-time, with options to recalculate paths based on movement thresholds.
  

5. Visualization and Debugging:

• Grid Visualization:Uses Unity's Gizmos to draw the grid in the editor.
  Walkable and unwalkable nodes are color-coded (e.g., white for walkable, red for unwalkable).
  
• Path Visualization:Paths are drawn using LineRenderer components.
  Different colors represent different algorithms (e.g., blue for A*, red for Weighted A*).
  Visualization can be toggled on or off.
  

6. Dynamic Environment Handling:

• Walkability Checks:Nodes update their walkability status based on the presence of obstacles.
  Walkability checks can be performed at set intervals.
  Agents respond to changes in the environment, recalculating paths as needed.
  
• Event System:GridManagerPathPro includes an event to notify when the grid is updated.
  Agents subscribe to these events to react promptly to environmental changes.
  

7. Performance and Optimization:

• Efficient Algorithms:Algorithms are implemented with performance in mind, using data structures like heaps and hash sets where appropriate.
  Open and closed sets are managed efficiently to optimize pathfinding calculations.
  
• Adjustable Settings:Developers can fine-tune settings like walkability check intervals and path recalculation thresholds to balance performance and responsiveness.
  

8. Extensibility:

• Modular Design:Classes are designed to be easily extendable.
  New algorithms or movement behaviors can be added without significant changes to the existing codebase.
  
• Customization:Developers can adjust grid sizes, node radii, and algorithm-specific parameters to suit their project's needs.
  Supports modifications for unique game mechanics or AI behaviors.
  

This Unity asset offers comprehensive 3D grid-based pathfinding solutions, implementing a variety of algorithms including A*, Weighted A*, Greedy Best-First Search, Dijkstra, Breadth-First Search (BFS), and Depth-First Search (DFS). It features path smoothing and curving for realistic and natural movement paths. The package includes movement scripts that support avoidance behavior, allowing agents to flee from targets or navigate around obstacles, as well as random roaming for more dynamic and unpredictable agent movement.

The asset supports dynamic obstacle detection and walkability checks, ensuring that pathfinding adapts in real-time to changes in the environment. With customizable settings for path smoothing, curving resolution, and movement speed, developers have fine-grained control over agent navigation behaviors. Ideal for game developers seeking to implement sophisticated AI navigation and movement in their 3D Unity projects, this asset simplifies the integration of advanced pathfinding techniques.

*3 Main Scripts

-GridManagerPathPro

-PathfindingManagerPathPro

-MovementPathPro

*3 Bonus Scripts

-CameraFly

-DelayedEnabler

-MazeGenerator

*5 Example Scenes 

-ObjectScene

-MazeScene

-RampScene

-ChaseScene

-CrowdScene

Price $100.00

Number of textures 12

Texture dimensions 4096x4096

Polygon count of [Boy] 6280

Minimum polygon count 6280

Maximum polygon count 11444

Number of meshes/prefabs 5

Rigging: Yes

Animation count 19

Animation type list

UV mapping: Yes

LOD information (count, number of levels) No

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

Low-poly model of the character Boy

19 animations:

walking (x2)

running (x1)

attack(x3)

strafe left(x1)

strafe right(x1)

strafe back(x1)

idle(x2)

turn(x1)

sneaking(x1)

roll(x1)

jump(x1)

get hit(x1)

death(x2)

180 turn(x1)

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

two UV sets 4096x4096 (down to 1024x1024).

4 skins

7 materials

12 texture maps

Character :

faces: 6280

verts: 6061

tris: 11444

Price $15.00

Mono Beige Room is a 3D asset for Unity, crafted with UModeler X. It features high-quality, customizable models optimized for Built-in, URP.

Number of Texture: 30

Texture Dimensions : 2048 * 2048

Polygon count of 'Mono Beige Room' : 44,232

Maximum polygon count : 11,686

Minimum polygon count : 2

Number of meshes/prefabs : 29/56

Rigging: No

UV mapping: Yes

LOD information (count, number of levels) : 1

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

Overview

Welcome to our high-quality 3D asset package, meticulously crafted by UModeler, Inc. All assets in this pack have been created using UModeler X within Unity, allowing for seamless editing and modification without ever needing to leave Unity. Whether you are a UModeler X user or not, these assets are readily available for your projects just like any other general 3D meshes.

Key Features

• UModeler X Exclusive Assets: All assets are created using UModeler X within Unity, ensuring top quality and seamless integration.
• Advanced 3D Modeling Techniques: Various 3D modeling features in UModeler X were utilized to create intricate and detailed low-poly models.
• UV Unwrapping and 3D Painting: The scene benefits from UModeler X's robust UV unwrapping and 3D painting capabilities, resulting in precise and realistic textures.
• Full Demo Scene: A complete scene to demonstrate the assets in action.
• .FBX and .Prefab Files Included: All models are provided in .FBX and prefab formats for easy use.
• Compatibility: With UModeler X assets, you can quickly modify and customize the meshes directly in Unity without the need for any external tools.

Render Pipeline Compatibility

Supports BuiltInRP, URP

Use Cases

Ideal for game development, VR experiences, architectural visualization, educational and training simulations, and AR applications.

Additional Resources

We also provide a comprehensive tutorial video showcasing how to create this scene from A to Z using UModeler X within Unity. This step-by-step guide helps you master the process and make full use of this asset.

UModeler X Plus Availability

UModeler X Plus is released, allowing you to easily edit and modify any 3D meshes in this package. With UModeler X Plus, customization is straightforward, enabling you to tailor the assets to your specific needs with ease. Download the Mono Beige Room today and start creating stunning virtual environments that captivate and delight!

Installation Note

This asset package should be installed in a project where the UModeler X Plus or Basic package is already installed. You can install UModeler X Basic with the UModeler Hub included in the package.

UModeler X Plus | UModeler X Basic | Discord | YouTube | Twitter

Price $19.90

A set of axes, where there are two different models and six textures.

6 Textures

4096x4096px

13254 polygons in RunicAxe and 4616 polygons in BasicAxe

2 3d Models

UV mapings : Yes

Texture maps :

BaseMap

MaskMap

Normal

Specular

There are two 3D models, where the one with two blades has 2 textures (with blood and without) and the one with one blade has 4 textures (basic with blood and without and with runes with blood and without).

Price $15.00

Cartoon Stylized Skybox MEGA Pack HDRI Anime Fantastic Clouds

Skybox MEGA Pack Contains 100 different skies. 6144x3072px High Res Panaromic Sky Textures Landscape100 Sky Material

• Sky Types :
• 7x Realistic
• 7x Anime
• 7x Desert
• 5x Mountains
• 8x Cartoon
• 5x Rainbow
• 8x Fantastic
• 11x Clouds
• 5x Polygon
• 8x Hell
• 8x Snow
• 5x Sunset
• 5x Space
• 7x Sea

Number of Materials: 1

Number of Material Instances: 1

Number of Textures: 100

Texture Resolutions: 6144x3072px

Supported Development Platforms:

• Windows: (Yes)
• Mac: (Yes)

Skybox MEGA Pack Contains 100 different skies. 6144x3072px High Res Panaromic Sky Textures Landscape100 Sky Material

• Sky Types :
• 7x Realistic
• 7x Anime
• 7x Desert
• 5x Mountains
• 8x Cartoon
• 5x Rainbow
• 8x Fantastic
• 11x Clouds
• 5x Polygon
• 8x Hell
• 8x Snow
• 5x Sunset
• 5x Space
• 7x Sea

Number of Materials: 1

Number of Material Instances: 1

Number of Textures: 100

Texture Resolutions: 6144x3072px

Supported Development Platforms:

• Windows: (Yes)
• Mac: (Yes)

Price $50.00

This pack includes six characters with their respective textures, animations and fully rigged.

Models

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

* Beetle 01 : 466 polygons. Includes 3 levels of detail (LOD). Full animated

* Beetle 02 : 512 polygons. Includes 3 levels of detail (LOD). Full animated

* Beetle 03 : 645 polygons. Includes 3 levels of detail (LOD). Full animated

* Beetle 04 : 588 polygons. Includes 3 levels of detail (LOD). Full animated

* Beetle 05 : 642 polygons. Includes 3 levels of detail (LOD). Full animated

* Beetle 06 : 645 polygons. Includes 3 levels of detail (LOD). Full animated

Textures

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

8 PNG textures, 512 x 512

3 PNG textures, 256 x 512

1 PNG textures, 64 x 64

This pack includes six characters with their respective textures, animations and fully rigged. Each one has over 20 animation clips, multiple textures, and their respective animation controllers, as well as artificial intelligence.

Beetles

He is a simple character, the six versions of this character share the same animations, and the same textures.

Price $35.00

This is a coal block that can be used in coal mine scenarios.

Number of textures:4

Texture dimensions:4096*4096 pixel

Polygon count of [Model Name]:

mineA:2726

mineB:3894

mineC:2021

Minimum polygon count:8641

Maximum polygon count:0

Number of meshes/prefabs:1

Rigging: NO

Animation count:NO

Animation type list:no

UV mapping: Yes

LOD information (count, number of levels):0

Types of materials and texture maps:PBR

There are three coal blocks that can be used for coal mine scene models.

Other assets related to the mine (to be purchased separately):

Mine CoalCutter:https://assetstore.unity.com/packages/3d/props/industrial/mine-coalcutter-207306

Fan in coal mine:https://assetstore.unity.com/packages/3d/props/industrial/fan-in-coal-mine-217149

Coal Mine Environment:https://assetstore.unity.com/packages/3d/environments/coal-mine-environment-196381

Price $11.00

Optimize performance with the Script Culling System. Disable unnecessary scripts off-screen using Unity's CullingGroup API, ensuring your game runs smoothly by reducing overhead from inactive objects.

Key Features:

• Script-Based Culling: Automatically enable or disable scripts on game objects when they are visible or off-screen, ensuring that only active scripts are consuming resources.
• CullingGroup API Integration: Utilizes Unity's built-in CullingGroup API for efficient management of visibility and bounding spheres, reducing overhead and improving performance.
• Priority Script Management: Keep essential scripts running at all times, regardless of camera visibility, while disabling non-essential scripts to optimize performance.
• Customizable Culling Behaviors: Choose between different culling strategies, such as enabling/disabling scripts, fading out objects visually, or performing custom logic when objects are culled.
• Real-Time Telemetry: Monitor the number of active, visible scripts and those that have been culled with real-time telemetry, helping you track performance improvements as scripts are managed dynamically.
• Efficient Bounding Sphere Updates: Automatically update bounding spheres to match object movement, with the option to manually force updates for real-time control over culling.
• Simple API for Integration: Easily integrate the culling system with your project by registering or deregistering objects and scripts using the provided API methods.

The GolemKin Script Culling System is a high-performance optimization tool that leverages Unity’s CullingGroup API to disable unnecessary scripts on off-screen objects, significantly reducing overhead and improving frame rates in your Unity projects. This system dynamically manages scripts on objects based on their visibility to the camera, offering an efficient way to reduce CPU consumption in large or complex scenes.

Key Features:

• Script-Based Culling: Automatically enable or disable scripts on game objects when they are visible or off-screen, ensuring that only active scripts are consuming resources.
• CullingGroup API Integration: Utilizes Unity's built-in CullingGroup API for efficient management of visibility and bounding spheres, reducing overhead and improving performance.
• Priority Script Management: Keep essential scripts running at all times, regardless of camera visibility, while disabling non-essential scripts to optimize performance.
• Customizable Culling Behaviors: Choose between different culling strategies, such as enabling/disabling scripts, fading out objects visually, or performing custom logic when objects are culled.
• Real-Time Telemetry: Monitor the number of active, visible scripts and those that have been culled with real-time telemetry, helping you track performance improvements as scripts are managed dynamically.
• Efficient Bounding Sphere Updates: Automatically update bounding spheres to match object movement, with the option to manually force updates for real-time control over culling.
• Simple API for Integration: Easily integrate the culling system with your project by registering or deregistering objects and scripts using the provided API methods.

How It Works:

The GolemKin Script Culling System uses Unity’s CullingGroup API to dynamically manage the lifecycle of scripts attached to game objects. Scripts on objects that are outside of the camera’s view are automatically disabled, and scripts on visible objects are enabled. This allows you to optimize your game’s performance by ensuring that only the scripts on relevant, visible objects are consuming resources at any given time.

By defining priority scripts, you can ensure that critical game systems remain active, even when the objects they’re attached to are not visible. This system is ideal for large-scale games or applications where managing script overhead is crucial for maintaining smooth gameplay.

Features in Detail:

• Custom Culling Behaviors: The system supports various culling behaviors, including disabling scripts, fading out objects, or running custom culling logic. You can choose the most effective method based on your specific project needs.
• Real-Time Telemetry and Debugging: Get insights into how many scripts are actively running versus how many have been culled with real-time telemetry, allowing you to monitor the system's effectiveness during gameplay.
• Manual Bounding Sphere Updates: While the system automatically handles most updates, you can manually trigger bounding sphere updates for more precise control, ensuring that object visibility is always accurately tracked.

Use Cases:

• Open-World Games: Efficiently manage script performance by disabling scripts on objects in distant areas of the map, improving frame rates while keeping critical systems running.
• VR/AR Applications: Reduce the overhead of running scripts on objects outside the player's field of view, optimizing performance in resource-heavy VR/AR environments.
• Large-Scale Simulations: In simulation projects where numerous objects have scripts attached, this system allows for more efficient use of resources by disabling non-essential scripts as needed.

Who Should Use This?

If you’re working on a Unity project with large-scale scenes, many objects, or complex logic systems, the GolemKin Script Culling System is designed for you. It helps you balance gameplay complexity with high performance, especially for open-world games, VR/AR projects, or simulations where efficiency is critical.

Support & Documentation:

This asset comes with thorough documentation and example scenes to help you quickly integrate it into your project. Our support team is always available for assistance at support@golemkin.com. Feel free to reach out with any questions or concerns.

Price $15.00

Experimental Unity3D tool for simulating all possible 2D, two-state cellular automata on a square grid.

Features:

• Simulate all 512-bit rules of 2D, two-state cellular automata on a square grid.
• GPU-accelerated simulation for fast performance and smooth visuals.
• User-friendly interface for creating, saving, and chaining cellular automata rules.
• Customizable initial configurations with built-in presets: Center, Grid, Noise, and Paint. Plus, a simple API that lets you easily create your own custom initial configurations.
• Rule Editor for detailed rule management, with a binary view, search, and script-driven rule generation.
• Customizable field initializers and support for importing external .png files for initial setups.
• Rule chaining options with queue types: Order, Repeat, or Random.
• For advanced users, the tool includes an intuitive API for creating automated rule-building scripts, allowing you to generate and modify rules programmatically via the RuleBuilder class.

Supported Operating Systems:

• Windows (tested)
• macOS and Linux (expected compatibility but not yet tested)

Documentation:

• Full documentation and instructions are available on GitHub: OmniCA Documentation

This tool implements a 2D version of Wolfram's Elementary Cellular Automaton (CA), where the neighborhood frame consists of 9 cells, resulting in a 512-bit rule size. This creates an immense rule space of 2^512, which equals approximately 1.34 × 10^154 possible rules. The tool features a user-friendly interface for creating and saving rules and controlling initial conditions and simulation parameters. The simulation is highly efficient, running on the GPU and utilizing a compact representation of the rules. Users can create custom initial configurations, or utilize built-in options such as "Center", "Grid", "Noise", or "Paint". OmniCA also allows for chaining rules to create more complex patterns and behavior.

Visit our website for more details:

https://omnica.crd.co

Price $0.00

A detailed car from the collection "Realistic Mobile Cars", which can be used for a mobile device. This car has a unique design and does not copy the design of existing car brands. This car has four exterior looks which is done by replacing some parts such as rear bumper, front bumper and spoiler.

Join my Facebook page to keep up with the latest news

Technical Details:

4 LOD's:
Car A:
-LOD0: 73506tris
-LOD1: 41270tris
-LOD2: 20729tris
-LOD3: 3759tris
-LOD4: 258tris

Wheel A:
-LOD0: 1925ris
-LOD1: 1026tris
-LOD2: 439ris
-LOD3: 113tris
-LOD4: 32tris

Texture sizes:
RMCar40Body 4096x2048px
RMCar40PaintAo 1024x1024px
RMCarCarbon 256x256px
RMCar40Numbers.tga 512x64px

Type textures:
-Albedo map
-Metallic\Smoothness map
-Normal map
-Emissive map

- Compatible with Unity Vehicle, Edy's and other systems
- Four design options
- The doors are separated
- Steering wheel
- PBR textures
- Collision
- 4 levels of LOD's
- Very detailed interior
- Dashboard ready for animation
- All nodes, materials and textures are appropriately named
- Emissive texture for lights included
- Optimized geometry

Please, rate and comment.
For all questions: pro3dmodels@ukr.net
Price $16.00

This village environment package are idealy for most type of games. It can be RPG , Farm, roquelike, Survival, RTS..etc game types.

The idea is with this pack you can extend or combine many type of game genres to create something fun and creative. My target is create a world of assets that contains many worlds and units so you can have a lot of idea come from here.

• Auto tiling Support
• Grid-based tileset and props
• The Wheat plants
• 3 type of soil for farm/plant game mechanics
• Auto tiling for fence
• Layered grass to make it looks natural
• Grid Size : 16x16
• File type : PNG

Price $17.99

Asian Fishing Environment with 158 Unique Meshes

Features:

• 158 Unique Meshes
• Attention to Detail / AAA Quality
• Controllable parameters in Materials
• Game ready/Optimized
• Unique Concepts of Assets
• High Attention to Details

Material Variations For Some Assets

Texture Sizes:

• 4096
• 2048
• 1024

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

Collision: Yes, Custom collisions for complex assets

LODs: Yes, 3 LODs for complex assets

Average Poly Count: around 1K up to 40K

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

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

Props: Fish Net, Barrel, Box, Chain, Cualdron, Rope, Lantern, Rocks etc.. [Resolution 2048x] [Base Color, Normal, Roughness, Opacity, AO, Metalic]

Architecture: Beams, Walls, Columns, Floors, Roofs, Windows etc. [Resolution 2048x] [Base Color, Normal, Roughness, Opacity, AO, Metalic]

Number of Meshes: 158 Unique Meshes

Number of Materials: 59

Number of Textures: 150

Supported Development Platforms: All Platforms

Asian Fishing Village Environment with 158 Unique Meshes. It includes all showcased assets, high-quality assets with good detail, and assets optimized for Game-Ready Projects.

Creative Direction by Leartes Team, Environment made by talented Artist “Vladislav Markov”

If you want to populate your game environments or any Virtual Production levels, this pack provides high-quality visuals and well-optimized assets.

For all your promotional requests, technical support needs, suggestions please create a ticket.

Here you can join Leartes Discord channel for live support, discounts and Custom Outsource Environment Projects.

INSTAGRAM FACEBOOK LINKEDIN TWITTER YOUTUBE REDDIT

Price $79.99

The Easy Optimized Object Blur Shader lets you easily add adjustable Gaussian blur effects to objects in Unity, enhancing visuals and depth in your projects.

Key Features:

• Adjustable Blur Radius: Control the intensity of the blur effect with a customizable radius (1.0 to 100.0).
• Auto Sigma Adjustment: Automatically adjusts sigma based on the blur radius for optimized results.
• Manual Sigma Control: Fine-tune the blur strength with a user-defined sigma value.
• Command Buffer Rendering: Efficient rendering using command buffers for better performance.
• Transparency Support: Works with transparent and fade materials to blur backgrounds effectively.
• User-Friendly Setup: Simple integration with a dedicated component for easy configuration.

Easy Optimized Object Blur Shader is an effect designed specifically for objects in Unity. It applies an optimized Gaussian blur that is adjustable in real-time and easy to configure. This shader is ideal for games and applications that require artistic blur on specific objects rather than a full-screen blur.

Price $21.99

Customizable objects of the energy system of future. Suitable and optimised for VR, Movie and Games.

- Full 4K-2K PBR textures: Albedo, Normals, AO, Specular, Detail.

- LODs 4 lvl average:

~ from 30000 to 1500 tris.

Recommended Unity 2020.1 and newer.

17 prefab-model elements.

Example levels.

Included Skybox, LoDs.

Price $15.00

Low Poly Farm Locations Pack of different sizes and shapes, optimized for any of your projects! The best solution for creating your own projects such as games. Great for learning the engine!

Huge low poly style resource pack of 284 models for creating incredible Farm Locations Environments, each containing only material and satin texture to be flexible and easy to use.

◼ 10 unique Farm Locations, you can use them to create your own.

◼ Supports builtin renderer and URP.

◼ Universal texture, for every model.

◼ Pieces are designed to be combined with others to create variety and enable your creativity.

◼ Drag and position pieces together to achieve unique and beautiful results for your levels in very little time.

A total of 284 prefabs in the package:

🌄Locations (x10)

10 Farm Locations With Transport and a Beautiful and Rich Atmosphere

⛺Environment (x138)

Bags Wheat, Barns, Bee Hives, Benches, Boxes, Chicken Coops, Fences, Food Stalls, Foods,

Wells, Wooden Arches, Baloons, Hays, Trailers, Barrels, Basket, Bottles, Bridges, Containers, Gazebo, Tables, Pier, Post, Wind Farm, Farm Tools

🏠Houses (x15)

Houses, Animal Hangars, Different Farm Houses, Hangar, Mill, Watermill, Wine House

🌏Lands (x10)

Different Lands For Farm Locations

🌴Trees (x19)

Trees, Fir Trees, Tree Trunks

🗿Stones (x6)

Stones, Flat Stones

🌿Plants (x48)

Flowers, Plants, Shrubs, Grass, Flowers Boxes, Wheat

🚗Vehicles (x27)

Pickups, Tractors, Trucks, Cars, Sailboat

All transport is made for animation

🐈Animals (x11)

Cows, Horses, Lambs, Chiken, Pig, Rosster

If you liked the locations, you can buy my big pack at a great price

⊹₊🔥⋆｡°✩Low Poly Locations Ultimate Pack⊹₊🔥⋆｡°✩

Additional Information

Package contain 1 universal texture 256px in .png format, so you can change the colors.

The models are between 12 and 7396 verts, total number of all 89743 verts.

The package also contains a guide on how to use it.

No rigging, no animation.

MOBILE FRIENDLY!

DEMO SCENE included!

On the demoscene, you can see all the assets of this collection.

I also made for you some examples of creating locations (scenes) and settings for them.

If you have any ideas, specific requirements or need help, feel free to contact me on email palmovisland@gmail.com

Price $20.00

This is a project showing the constructions of the ancient peoples of the world, in a modern form. Suitable and optimised for VR, Movie and Games.

- Full 4K PBR textures: Albedo, Normals, AO, Specular.

- LODs average:

~ from 20000 to 100 tris.

- Include HDRP/URP materials.

Recommended Unity 2020.1 and newer.

41 prefab-model elements.

4 level LOD-s

2 terrain texture.

HDRP/URP example level.

HDRI Sky.

Price $40.99