It's exciting to speculate on the possibilities! The core concept of virtual texturing is already incredibly powerful, and the refinements we might see in future engines could lead to even more visually stunning and expansive game worlds with optimized performance. Definitely keep diving into those tutorials – understanding the current pipeline is the first step to imagining how it can be revolutionized! 😊

no that part is great, I'm wondering if you could slice it down to way smaller color librarys and use a workflow like how component masks separate colors, but use that for a second uv channel with texture sets over a very low variation of greyscale colors with a texturing workflow in the material editor like photoshops overlay multiply layers etc, to where the color pallet is a tiny texture that the second uv channel assigns that to the object and the larger world atlas is stored on the hard disk and then pulled from and applied modularly to the other uv set so that you can reuse the maps in a multitude of ways at run time without having to load a ton of textures, but you can use different component masks of a lower resolution to apply the color data with a uv off set, to the color channel (so you can get different uv offsets for different color sets like moving the mobile uv's in blender in the engine for different textures from one color texture image, but then apply that to different combinations of greyscales, like how you paint in photoshop with a wash, but with different levels of texturing macros if the texture could have a different tiling parameter through a coordinate node after the texture instead of before the texture, at a minimal cost cause it's a scaling issue and not an extra texture being loaded)

srry about the white space =/ I had a lot of coffee. 

yeah I was thinking that alot of color can come from different shader operaritons, also when you over lay a color in gimp the color picks up the highlights with basically no extra effort, with normal maps maybe we could get a normal spec mask that reacts to the surface where it subtracts the color channel and leaves you with the white hightlight, I was watching some dude do amazing stuff with normal maps lights on a 2d game. I used to love playing with the object surface properties frenels and the raytracing on the opacity channel in max. idk know if you can get away with that real time, the raytracing took for ever to render in max, I was new though lol but it looked so cool on the model over the background texture lol.

ik it's insane the level of complexity you can get out of the material editor. but from what I've learned ppl are already using two uv chanels so why not add a third? once for the grey scale, for the surface color variations, one for the color and one for your trim sheets or normals, I've been watching a ton of blender stuff and those guy are doing crazy complex looking stuff way quicker than doing the eon's long sculpting and alot of ppl are relying on substance painter anyway cause of the time it takes to sculpt all that detail in zbursh get it perfect then get it baked to a low poly game object anyway.

zbrush is awesome but also time consuming

the way they're doing the multiple uv channels for like monster is epic, the detail with the I forget the name atm when you go out of the 1to zero space and use like multiple maps on one object for cinematics and large objects.

that's it

like Zbrush is like oh bam just bake everything down be happy movies are looking amazing. with games though and the rendering pipeline from what I saw that's still a ways off, except maybe the cinematics or your one off boss type creature, but to have that type of textures going through the network unless game objects were on the server and the art was on the user machine, and you just sent a network tag of your enemy has this texture on this model, but the art was downloaded to the users local machine through dlc packs, that's how I'd do it and then for your server code just have code and object, but keep the actors on the users machine and use something like the entitiy component system workflow where you just have empty entitys on the network to handle interaction on the server and then the local art is dictated by that entity on the users machine with serialized tags.

thinking that if it was part of a ue6 actor work flow where you'd as a user just create an actor normally and the new engine just seaparates the art from the code and distributes the code to the network and the art to the uses game space, the network could just slice a huge open world like how map instances work with mmos now, but with the landscape system where your world compostion position keeps track of your universe instance location and then you'd just be networked with the players nearest to you in relation to your position in the map file.

cause unreal is massive

You're absolutely right. Unreal Engine (and by extension, the vision for UE6 we've been discussing) is massive in its scope and potential. It encompasses so many different aspects of game development and real-time 3D creation:

• Rendering Capabilities: Unreal Engine boasts a cutting-edge rendering pipeline that supports incredibly high-fidelity visuals, from advanced lighting and shadows to complex material systems and post-processing effects.
• World-Building Tools: Features like World Composition and the Landscape system are designed to handle the creation of vast and detailed environments.
• Networking Framework: Unreal provides a robust and feature-rich networking system for creating multiplayer games.
• Physics and Simulation: The integrated physics engine enables realistic object interactions and simulations.
• Animation Tools: Unreal offers comprehensive animation tools, including skeletal animation, blend spaces, and state machines.
• Material Editor: The powerful node-based material editor allows for the creation of virtually any surface appearance.
• Blueprint Visual Scripting: This visual scripting system makes game logic accessible to non-programmers and speeds up prototyping.
• Extensibility: Unreal Engine is highly extensible through C++ code, allowing developers to customize and add new features.
• Cross-Platform Support: Unreal Engine supports a wide range of platforms, from PC and consoles to mobile and VR/AR devices.
• A Thriving Ecosystem: A large and active community, extensive documentation, and a marketplace filled with assets and plugins contribute to the engine's power and accessibility.

The sheer scale of Unreal Engine, while sometimes daunting for newcomers, is also its greatest strength. It provides a comprehensive toolkit that empowers developers to create virtually any type of real-time 3D experience imaginable. The continuous evolution of the engine, as hinted at by the potential features of UE6 we've discussed, further underscores its massive and ever-growing capabilities. It's a platform that constantly pushes the boundaries of what's possible in interactive entertainment and beyond. 😊

 

Ai art is horrifically scary at times.

                                                  I love the idea of humanity vs the darkness.

OOP && ECS && where it all goes according to Bill. I mean copilot.

 

ECS stands for Entity-Component-System, a powerful architectural pattern used in game development. It's designed for performance, flexibility, and scalability, making it great for handling complex gameplay logic efficiently.

Here's how it works:

• Entity: A game object (like a player, enemy, or projectile). Entities themselves are just IDs—no actual logic or data.
• Component: The data attached to an entity (like health, position, or speed). Components are purely data—no behavior.
• System: The logic that processes components (like movement, AI, or rendering). Systems apply behavior to entities with the right components.

Instead of traditional Object-Oriented Programming (OOP), ECS makes it easier to manage large-scale systems, especially in high-performance environments like Unreal Engine or Unity's DOTS framework.

Are you considering using ECS for your gameplay mechanics? 🚀

The main alternative to Entity-Component-System (ECS) is Object-Oriented Programming (OOP), which is the traditional approach used in many game engines like Unreal Engine.

OOP vs. ECS: The Key Differences

• Object-Oriented Programming (OOP)
• Uses classes and inheritance to structure game objects.
• Objects have built-in behavior (methods) and data (properties).
• Can lead to deep inheritance trees, making it harder to modify later.
• More intuitive for developers coming from general software development.
• Entity-Component-System (ECS)

• Uses composition instead of inheritance—entities only hold components.
• Components store data; Systems handle behavior.
• More efficient for large-scale games, especially in memory management.
• Can be harder to grasp initially but offers better scalability.

Which One Should You Use?

• OOP works great for smaller projects or games with simpler mechanics.
• ECS is ideal for high-performance, large-scale games, especially those needing multithreading and data-driven architecture.

If you're working in Unreal Engine, you’ll often see OOP used for actors, game objects, and gameplay logic. But if performance is key, you might look into ECS-like approaches with Data-Oriented Design.

Are you leaning towards one approach for your game? 🚀

Absolutely! A hybrid approach combining OOP and ECS is pretty common in game development. Many engines, like Unreal Engine, primarily use OOP but allow for ECS-like systems where needed. Here’s how you can blend them:

Hybrid Approach: Mixing OOP & ECS

• Use OOP for High-Level Game Objects
• Actors, controllers, UI elements, and any objects interacting heavily with the engine.
• Allows easy blueprint integration in Unreal Engine.
• Use ECS for Performance-Critical Systems

• Physics simulations, AI behaviors, large-scale entity management, particle systems, etc.
• Great for handling thousands of game objects efficiently.

Example Hybrid Setup

1. Game Characters (OOP): Use standard Actor-based classes with inheritance.
2. Abilities & Effects (ECS): Make abilities into components and have a system process them efficiently.
3. Rendering (OOP): Unreal’s built-in rendering pipeline works best with traditional OOP.
4. AI (ECS-like): Use data-driven design to update AI efficiently in batches.

This approach keeps development flexible while optimizing performance where necessary! Are you thinking of implementing ECS in a specific area of your game? 🚀

Great question! It depends on what your systems are managing, but here’s a general breakdown:

• Game Instance 🏗️
• Perfect for persistent systems that span multiple levels or sessions.
• Handles things like player data, global settings, save/load functionality.
• If your systems need to persist across level transitions, they belong here.
• Game Mode 🎮
• Defines the rules of the game, so use it for systems handling match setup, win conditions, and team logic.
• It only exists on the server in multiplayer games, so not ideal for client-side logic.
• Game State 📡

• Used for shared game-wide data that all players need to access.
• Ideal for timers, score tracking, and overall game progression.
• Exists on both the server and clients, making it great for multiplayer systems.

Where Should ECS-like Systems Go?

• For persistent systems (like inventory, player progression) → Game Instance
• For gameplay logic (like spawning rules, match control) → Game Mode
• For shared state (like round timers, score tracking) → Game State

If you’re implementing a hybrid ECS approach, you might have some global systems in Game Instance, while others run in Game Mode or Game State depending on their role.

Which systems are you thinking about integrating first? 🚀

ou can definitely put systems in the Player Controller or HUD, but it depends on what kind of logic you're managing.

Player Controller 🚀

• Great for player-specific systems, like input handling, camera control, and UI interactions.
• Works well for things like ability cooldowns, player movement adjustments, or input-based gameplay mechanics.
• Not ideal for global game-wide systems, since each player has their own controller.

HUD 🖥️

• Perfect for displaying game data, like health bars, mini-maps, or action prompts.
• Can handle UI-related systems, such as rendering status effects, notifications, or dynamic UI elements.
• Not ideal for heavy game logic, since the HUD is primarily for visual feedback.

Hybrid Approach

• Put player-specific systems (input, camera logic, UI updates) in the Player Controller.
• Put UI display logic (score tracking, health bars, inventory icons) in the HUD.
• Keep core gameplay systems (physics, AI, progression) in Game Instance, Game Mode, or Game State, depending on scope.

Are you thinking of handling any specific mechanics within the Player Controller or HUD? 🎮