'Velocity' would imply that they were actually moving forwards...
The Star Citizen Thread v8
- Thread starter Yaffle
- Start date
- Status
'Velocity' would imply that they were actually moving forwards...
Pretty much… time to effort post.
Level of Detail (LoD):
The method of using different art assets depending on the distance between the viewer and the object they're looking at. Be it sprites or 3D models or textures, lower-detailed ones are used at larger distances because any more detail will just be squished together to a size smaller than a pixel, and be lost. This method has been around for the last 30 years.
Serialised variables:
Serialisation is the method of turning a complex data structure into a much more simplified series of data points. Instead of dumping an entire block of memory onto the client, you compact it into something much mor terse and relevant.
You may have a ship (partially) stored in memory as:
0000AB12▢Ugly Ducking▢▢▢▢▢▢▢▢▢▢▢▢▢▢▢▢▢▢▢▢006E▢
0000000000003039▢000000000000D431▢0000000000002F59▢
3CE4186D399E326B▢308D6E044A0A2E92▢009BE179CA492B01▢ etc etc etc.
…where the different parts are things like ship ID, name, type, x/y/z coordinates, memory coordinates for fitted equipment and so on.
That's a whole bunch of ugly junk to send, and those last bits won't even be accurate because they depend on how the equipment is stored in the server's RAM — the client will be completely differently set up. You have to turn it into something that's not just light-weight enough for transmission, but also actually useful for the client. So you “serialise” it — turn it into a data series that the client can use — along the lines of:
43794,Ugly Duckling,110,12345,54321,1212, … [and then some serialisation of the different equipment]
The client knows which parts are which, and stores them into memory in a way that's suitable to it, and life goes on.
This is simply a different way of saying that the way data is stored internally is not how it is (or should be) transmitted — it's an idea that is as old as computers, and I'd be surprised if this was news even to Ada Lovelace.
Incidentally, formats like XML or JSON, that you may have heard of in relation to this, are serialisations of variables — they let you express complex objects in a very structured way. The problem is that their focus is on being easy to read for humans and on being interoperable between different software, not on being efficient. So for a controlled and fast-paced environment, you really want something else. Hence why Cryengine's internal XML-based structures make for a very poor basis for syncing objects over a network, and why you had this guffaw a few years back where each ship in SC required megabytes worth of data to be sent to the client — they were dumping the entire inefficient XML structure on the poor users.
Serialised variable culling:
That's all nice and well, but do you really need all that data to be sent, even in a serialised format? After all, the equipment won't really change that often, and even positions may be static. So to reduce traffic even further, you devise a way to inform the client what you're actually sending and what it should just retain based on old data. This may entail either skipping entire variable series, or skipping parts of a series. Either way, you can now use different update intervals for different variables, and the trick is more in figuring out what needs to be processed when — the rest is “culled”, that is, deemed not relevant for now and thus not processed.
Where, before, you might send a compact data structure of the format Ship ID, name, X, Y, Z, equipment data, you can now just send something along the lines of
ID=43794,X=12355
…because all that happened between the old update and the new is that our Ugly Ducking ship changed its x-position, and we detected that and skipped all other variable processing and transmission.
Again, a thoroughly ancient technique, but since the whole detection of what needs to be updated creates a bit of processing overhead, it may in some cases be easier and faster to not do it at all. It's a balancing question of, does the lowered transmission and (potentially) reduced processing rate warrant that extra book-keeping overhead?
Bind culling:
Even with that reduced and simplified traffic, the question remains: do we actually need to send anything at all to the client? For the vast majority of stuff going on in a space game, the answer is a resounding “no”. They're too far away to have any impact, or they're just in the wrong location, or of the wrong type. A ship that's half a parsec away is not relevant to you; a character that sits inside a different station than yours isn't relevant to you; the colour of Miles Eckhart's third jacket isn't relevant to you (because while he's close-by, he's a walking-around-mode character and you're current piloting a ship).
So you decide that there needs to be no connection between some object the server knows about, and the client. You don't “bind” that object — i.e. you don't make it a part of the list of things you need to update the client on — and as objects move in and out of relevance, you constantly check and cull that list of objects and in many cases don't even get to the step where you have to bother with serialisation and culling of object variables.
This is a concept that is, in gaming at least, 20+ years old. Any game that offers multiplayer and that supports some kind of division of the world into zones does this to some extent. Well… most of them. Cryengine is (in)famous for having particularly non-granular culling methods — all clients get the same updates on all the same objects, and screw their individual preferences…
I think you are describing these, at least the ones I've bothered to try and figure out what CIG means, incorrectly in terms of the context of Star Citizen.
The ones I've tried to figure out what CIG means is for Serialized Variables, Serialized Variable Culling, and Network Bind Culling.
Serialized Variables
In normal software development, serializing a variable is such a trivial thing, it was odd to see such a big deal being made of it in Star Citizen. In Star Citizen, it is referring to an internal framework they have developed to intelligently handle the serialization and communication of the object between the server and client. The process is abstracted out, so a normal game programmer doesn't have to worry about how an object gets serialized and sent over the network. Their Serialized Variable frameworks handles things like only sending values that have change etc.
Before they came up with this framework, they were still doing variable serialization, they are just doing it through a framework now.
https://www.youtube.com/watch?v=L4m2nwn5wT8&feature=youtu.be&t=1410
Serialized Variable Culling and Network Bind Culling
With Serialized Variable Culling all entities are still getting created on the client, but if they are out of range the client will no longer receive updates about the entity. This still has the overhead and memory impact of the entity being present on the client, but stops the client from have to worry about what it is doing.
As an example, if I am at Port Olisar and you spawn a Caterpillar at Levksi, my client will create the Caterpillar on my side. But it won't receive updates when you start flying around.
With Network Bind Culling entities that are out of range of me will not be spawned on the client at all. This cuts the overhead of having to crate the entity at all and in theory would reduce memory consumption.
As an example, if am at Port Olisar and you spawn a Caterpillar at Levksi, my client will have no idea that this took place at all.
https://www.youtube.com/watch?v=7YPFaVK61xM&feature=youtu.be&t=606
Nah. The terms means what I've said, even in (especially in) the context of SC. CIG just likes to use big terms for trivial matters because it lets them uphold the air of doing something special, when it's very ordinary stuff they're dealing with. They also like to use these terms to make it seem like they came up with something, when it's really just CompSci… well… perhaps not 101, so let's generously say 201.
Doing serialisation and culling through a framework is how it's always done unless you're doing some ugly quick hack — their doing it that way isn't very special. If they did something else before, then they were just doing it badly and they're making a big deal of not being bad at their jobs any more.
Your explanation of bind culling does not differ from what I said.
e: Actually, come to think of it, there is one thing about my descriptions that needs to be specified in the context of SC. What I described is how these things would work if SC had and used any of these methodologies. What you have to realise in this context is that it doesn't — they're fancy words for standard things they haven't properly implemented yet.
Last edited:
These guys articulate as well as they code. Someone should try giving them a deadline or stretch goals when they make mouth noises to see if anything funny drops like verbal sandworms.
If you had a room full of chimpanzees pounding on keyboards, they would eventually create Star Citizen. They would also do it faster than Chris and Erin and their team...
Heh, me too.
Its not so much the stuttering, filler noises, etc. Tape yourself talking on the fly and you might get the same. Especially if discussing a topic where you are having to be careful with the words you say as you have many people listening, ready to dissect and pounce on the slightest badly phrased item.
What gets me about these is they spent paragraphs basically saying nothing.
In other news, funding tracker dropping below $1000/hr regularly now. Hitting $500 at times.
Expect some sort of sale within the next week or two. Presume it will coincide with the next patch.
It's OK you just need to focus on patch 3.1...3.2...3.3...3.4...3.5...3.6...3.7................99.99.......Alpha 1.0[haha]
There was a GIF floating about years ago comparing the SC and ED galaxies.
It was a wondrous thing to behold
The saddest part is that SC doesn't have a galaxy, it doesn't even have one complete star system.
It doesn't even have one complete ship!
Except for the big sandworm that appeared once in a trailer several years ago, are there any other Dune influences? I must have missed them.
![[VR] Merkir](https://forums-cdn.zaonce.net/data/avatars/m/141/141091.jpg?1553527154){kind=avatar}
By inventing their new jargon, CIG avoids any possible negative associations connected to the old jargon that they might be unaware of. Clever these CIGers are. [haha]
Like going in circles for seven years?!?!?
…and also a quick comment on “walkways”Hav said:
Heresy! Those are fidelity facilitators!
That's how everyone is doing it.
Everyone.
Also it's not a framework but just a library. But CE already contains serialization and it's pretty efficient at that too. You could optimize it, yes, but not by much, and again there's already libraries that do that for you.
What CIG is doing, is they're slowly figuring out how to write software, and then claim to have invented it first. And that is the main reason why I am convinced that they are not wearing any clothes after all. Or was it the emperor, or something.
Movement and direction.
Movement without direction is implied by speed.
The question is, is an aggregate direction sufficient to call it “velocity”? Tumbling end over end, rolling backwards down a hill — would we still classify that as velocity or just as hilariously cringe-worthy?
Yes.would we still classify that as velocity or just as hilariously cringe-worthy?
- Status