... on topic but slightly off topic
I just hit the link you provided to the unity Entity Component System. I've not got far. say the first real slide about 14 minutes in.
Bloody hell!
- OOP is not optimisable
- data (things) should be not be built from defaults, but from clear things that are built to do one job really well
- data should be explicitly declared at the start
- 'stuff' should be able to be validated
- No Garbage Collectors
- streams of small data xyxyxyxyxyxy. NOT blobs of big data1, data2, data3
These are all really interesting observations how messy things have got and how to rewrite the concepts of doing stuff.
a good example would be something like a particle system.
1. lets assume the data is already small, just xyz locations
how Could we represent this?
3 arrays of x y z
an array of type xzy
a linked list of some sort
arrays are fast to access but limited in size as they should really be pre defined
arrays are slow to sort - as you are moving data around
lists can hold any number of items, but are slower to process. there is also no direct access of list objects
lists are better as sorting doesn't require data to be moved - just the pointer/ref
I think the reality here is we are talking about stream processors. Where we have a stream of little data and minimal interaction on this data.
E.G. think of a a defined array of xyzxyzxyz, stored in memory in that order
the stream processor starts at the beginning of the stream and eats data in 3 data chunks (xyz), then output (whatever the process is) the result
the other thing it seems is that (to keep things simple) you don't have access to other data chunks. so that the chunks in a stream could be processed out of order, or even process in parallel.
So...
the simplest extension of the particle system would be the data. there would now be a second stream of modifier data
from xyz to xyz + XYZ (where XYZ are modifiers - think small numbers of movement)
the process becomes new data = old data plus modifier data
The result could be fed into another processor that eats the entire voxel data for a level and the particle stream positions
if the voxel position[ particle xyz ] is occupied, kill particle
etc...
