If you don’t look uncomfortable watching a talk are you even a developer?

kzfaq.info/get/bejne/qL5gfNeHqrzOeJc.html

Nihal Kenkre Thank you!!!

Yeah. One moment that especially stood out was when he talked about L1, L2 cache misses and demonstrated how much time it takes for the CPU to fetch data from main memory. The audience saw the animation, we didn't. And someone who never saw one of Mike's talks before will be confused about why he's so quiet suddenly.

And always zooming in on the same chick. Methinks Cameraman has a crush.

@@BrandonCaptain :D exactly

@@BrandonCaptain Good taste tho.

The clowns that mike kicked out of the car.

uh hi

I wish we could apply that to the camera manager...

He gave a talk in 2017 at GDC where he did just this. He showed a Unity tech demo and how it ran before and after the DOD overhaul. It's on YT. Def check it out!

I feel like it's a bit misleading to refer to these two paradigms as if they're an algorithm that can be swapped out. At their core, they are a set of principles and are a mindset. What Mike Acton is doing here is trying to convey the mindset of DOD. It is a little contrived, but the message that you should look at a program as something that transforms data is a good one, and one that is difficult to see for many people.

So don't listen to John carmack

I began my career in a very weird manner, easiest way to convince someone of the gains to be had is to have the programmer try to solve any form of exponential coupled data problem and then show them the data oriented method of solving it, because lets be real programmers are smart usually but still very human, demonstration is almost always infinitely better.

mike drop, got it

Can you explain what is contradictory about those statements?

To me the only "sales pitchy" thing was when he listed the numbers of Unity users etc. in the beginning. What else do you mean?

This applies outside of Unity. He made virtually the same presentation in way more detail at CppCon 2014 before he ever started working for Unity. kzfaq.info/get/bejne/qL5gfNeHqrzOeJc.html

Not the same talk at all

Not a sales pitch for Unity so much as a sales pitch for the "new way of using Unity". The audience is people already using Unity and he was advertising that a new feature is coming that will improve performance but requires some getting used to on the part of developers.

This point is literally addressed in the talk around 12:00.

@ Boggled Eggnoggler You can still use such convenient functions like `LookAt()` in a data-oriented architecture with an open data mentality to its design. The difference is that if you need to do a fairly complex transformation that involves inputting a transformation matrix and outputting a new one, you don't have to try to figure out how to do it with complex interfaces and layers upon layers of abstractions that hide that vital data as in object-oriented designs. I've had colleagues before who worked with abstract `ITransformer` interfaces that would write the most convoluted code trying to just do simple things like align and snap one object to the surface of another, and mainly because the layers of abstractions made it so difficult for them to input the actual data.

Except those lookAt() and setActive() functions never "just work". They're built on top of something else, and when there are a problems (there are always problems), you will have to dig into what those functions actually do anyway. You don't solve problems by pretending they aren't there.

​@@tedbendixson That's one thing I found as well -- we had such a complex interface for the analogical transformer, including functions involving pivots, and rotating pivots, and whatnot. In fairness, my team consisted mostly of academic R&D types heavy on computer graphics research -- maybe far more academically smart than smart about designing easy-to-use interfaces for things, and they were from various parts of the world -- English wasn't always their native language. So I found myself and some colleagues often frustrated -- like just gimme the damned 4x4 matrix there. I know how to align two surfaces together with basic linear algebra -- the math is simpler than the complex interfaces they gave me and the manual-style verbose documentation they'd write (they'd literally write about 20+-page documents into source files and call them "usage manuals"). I find that a recurring problem in computer graphics -- like the domain knowledge required is already sorta steep, but once we break through it, the plainest representations of data are what we master.... not someone else's idea of how to abstract it. It's like I've been working long enough to understand all images are just 2-dimensional matrices of some vector or scalar type. pixel=y*img.w+x or, for power-of-two widths, pixel=y>>img.bitshift+x is burned into my brain from the DOS days. It's second nature to me now... but not like get_pixel(x, y), or set_pixel(x, y), or convert_pixel(x, y), or ImageFactory, or PIxelConverterFactory, or any of that OOP BS people wanna pile on top which, from my standpoint, provides not only some obstacles for the optimizer but for veterans as well in this industry. What I like with suggesting lookat() functions and stuff if people wanna build that on top of a data-oriented engine is that they can do that... for their personal use -- in a sort of modular way. Just don't expect me to use it or debug it. I recommend that for sorta high-level developers who struggle with these things to build whatever convenience stuff they wanna put on top -- including object-oriented designs... But I think at the core engine type of level which tends to demand a high degree of domain expertise anyway and has a far larger portion of critical execution paths and performance-critical code than maybe even Knuth would ever have anticipated, it helps to just expose the data if in doubt.

​@@tedbendixson Well, my sort of rude thought on this is that OOP is best for beginners.. along with languages like Python and whatnot. So for people who don't know how the basic math to access a pixel at a certain row/column, or normalize vectors, or do transform with pivots, or anything of this sort, they can build layers of abstractions on top of our engine. And that's fine -- just like how some people who aren't very savvy at this stuff write their game mods for Unreal using Python or whatnot. My thing is like just don't write the core engine in object-oriented Python let alone object-oriented C++. It will be horribly inefficient typically for both CPU and veterans used to transforming and accessing memory/data very efficiently.