 So I'm going to talk a bit about crystal space some technical stuff some less technical stuff Showing you giving you some explanation about why we do certain things and how we do certain things and also a bit about Associated projects that go along with crystal space so first introduction and I talk a bit about contributors Portability this is very important Of course, you have seen is already in the previous talk about this modularity and extensibility data structures debugging and of course The 3d engine itself, which is one of the most important parts of crystal space The 3d renderer which is the part that renders on screen actually Various other plugins and then crystal entity layer and the very new apricot project So what is a 3d engine? 3d engine is actually something that manages and organizes objects in a 3d world That's a very generic description, but it actually means Making sure that it they are represented in an optimal way and that you can easily Render them from any kind of viewpoint You know it also means an engine also has to manage the surface attributes of all objects What you how they look like the material is it wood is it stone? What kind of attributes does it have? 3d engine also does feasibility that determine my nation, which means Find out what? What you should see and what you should render and what is invisible at that point in time level of detail For an object that is very far away you don't want to render it with all thousands of polygons that's wasted And of course lighting It's very important too In addition there are a few responsibilities that are not eggs really part of 3d engine But crystal space is more than a 3d engine. It's actually a framework And so we also have support for collision detection physics scripting AI and sound among other things So when I started crystal space about 11 years ago There are a lot of problems that has have to be solved and I have to admit at that point in time I didn't solve most of them so that only came later while other people joined the team and generally added features for supporting all those problems for example One of the big problems for 3d engine is supporting the latest hardware features of the best nvidia or ati cards But still work sufficiently well enough on low-end hardware as well because you you don't want to Many people still have low-end hardware and you could choose to target only high-end Hardware, but we feel that it's better to to allow still the low-end as well Other problems are finding efficient data structures Which is very important in 3d engine because there's really a lot of data that is stored all the objects all the data Associated with objects how they are organized and it has to be stored very efficiently because otherwise you you lose speed very quickly Efficient algorithms are very obviously needed of course. I will go into more detail about all of these later One of the major issues is portability different hardware different operating system different window systems and The classical programming problem that's probably every One who has ever programmed as encountered as debugging of course Unfortunately, but very needed So I already told you a crystal space is a 3d application framework. It's actually not really specific to games It's just that games are the most Most used application, but you could also use crystal space for other kinds of 3d visualization Architecture for example or similar simulation It's open source. Otherwise, otherwise, I wouldn't be here It's portable it runs on Linux Windows Macintosh at this moment in the past There were even ports for us OS to be us Amiga, but these ports are no longer maintained So they have been abandoned It's modular and I will go into more detail about that because that's very important in crystal space Very extensible feature rich and we support both low and high-end hardware In addition to crystal space, there is also crystal entity layer, which is an separate project it's also start created by me and It's actually it actually adds the game the notion of game entity to crystal space so crystal spaces Doesn't really have to do with games, but crystal entity layer makes it easier to make games It's optional. You don't have to use it, but it's there and it's it can be a help So there's a short list of a few of the crystal space features that we currently have Portals crystal space is a portal based engine. Also something I will talk about more later there is a visibility color which is Actually the object the code that is responsible for finding out which objects are likely visible on which objects are certainly not visible Particle systems for smoke fire you name it volumetric fog landscape engine very important shaders shaders are actually the pieces of code that runs that run on the 3d hardware and they actually Make sure that's a polygon or a surface as a certain look Lightmaps for lighting. It's one way to do lighting Stencil shadows is another way to do lighting Then we also have physics We don't we didn't make it all ourselves We use ODE or bullet which are two other open source projects But we have an adapter on top of that so that an application using crystal space can Use bullet or all the E and it doesn't even have to change its code to just a matter of using another plugin We support sound we have a virtual file system. That's we'll talk about that later, too It's one way to solve the problem of the file systems of different operating systems being different Level of detail procedural textures window system based on cg Ui it's for in-game menus if you want you can use that and A lot more there are a few screenshots for from a few of the projects or test cases, so Just there are more on the crystal space site But here you see already for example out left side you can see the landscape engine. There's a particle system on in the top right for example and Here you see this screenshot shows bump mapping on the wall You see how the wall appears to be come out of a bit So that's done by shader and below you see a shader doing toon shading So you see the outlines of objects, so there are different possibilities So we started in August 1997 and about hundred eighty people have contributed since then Most of them very small contributions. There are a few bigger ones so we have registered registered our project on Olo and According to them we have about nine hundred thousand lines of code Most of that is C++ It's a bit of Python bit of Java and a bit of shell scripts also 256 person years, so I didn't do it all alone because I'm not not that old yet and 14 million dollars project cost. I don't know I could all this is of course It's just what that sites told about after analyzing the source code of crystal space So portability Portability is very important for crystal space We tar we try to target as many of the operating systems as possible at this moment Due to lack of maintenance. We only target the major tree so windows linux and macOS But the code is portable enough to so that it's relatively easy to add other sports So operating systems is one important target different CPUs Like Intel or others Windows systems are also very different 3d hardware Sound systems input devices So there are very a lot of different things that come to a 3d engine and you have to solve them in a way So that the application the game developer doesn't have to worry about it So that's one of the important goals if you make a game using crystal space You don't have to worry about portability if you do it right So you shouldn't have to worry about you just make your code in C++ or in a few other languages I will go more into that later and Without any modification except perhaps for the build system to adapt for your compiler you it should run on all three platforms So operating systems yes, okay, of course the obvious problems The current directory home directory finding user preferences all these things are different on different operating systems The file system works differently So you see a few examples there also There's the problem with line endings in text files, which is also different between windows and linux and Macintosh and crystal space solves that by adding an abstraction layer virtual file system and In a crystal space application you just use a predefined path for for example game data some file and The layer itself make sure it gets mapped to the right operating system specific path Act and first with my system also supports directly reading into zip archive So you can just read the file out of zip archive without doing anything special So CPUs of course you have the byte order little Indian versus big Indian how the integers are represented structure packing and alignment and different sizes of int for example 64 bits versus 32 bits Processors so all this has to be accounted for To solve the binary the packing in the little Indian versus big Indian we use as much Ascii format for saving and data as possible But of course you can do that all the time images for example you have to be our buying store binary and But then you have to be careful Window systems are another Big important thing so there's a lot of difference between X windows on linux for example and Direct draw on windows. It's it's complete completely different API But again the game developer shouldn't have to worry about that. He shouldn't have to know and It's also hard to support all in simple basis. We use actually solve this with different plugins I will talk more about that later 3d hardware many types of 3d cards of course we use open GL so by using open GL We already solve the portability problem partially, but still even then it's not enough because open jail drivers are Often have bugs in different combinations some cards count two certain features So you have to you have to really really be careful and see if you use open gel this way on this card It may look good, but another card It may not be very slow for example, and there may be another technique that is better suited so There's also the possibility of a software renderer, but these days software render is becoming more and more obsolete so it's a bit of an old plugin now sound again It's always the same story different APIs different sound file formats Input devices again mouse keyboard joystick there are more possibilities So we have a portable event system so that you can catch events and you don't have to worry how How they are handled in the operating system so That concludes the section about portability then another important feature of crystal space is modularity and extensibility Crystal space is a very big pro project. You saw 900,000 lines of code And but still to make that manageable you can't that it can't be one single library that wouldn't work So basically the project is split into a lot of modules more than a hundred modules different plugins And all these plugins are more or less independent or at least they only talk to other plugins through specific interfaces So we call those modules plugins. It's a very important part of crystal space There are only a few basic libraries and all the rest are plugins For example here are the basic libraries It's of course you need to have support for managing the plugins in the first place So that's that has to be in a library Something has to load the plugins The API is for the system specific tasks utility classes Then there's a library with mathematical classes image manipulation tools and High-level library for applications to make it easier to use crystal space. So there's a few libraries normal C++ libraries and then Nearly 95% of code is in some plugin and the plugin is a representation of some functionality And we call this a plugin type so Here are a few example types for for example sound drivers You have there's one Interface one API for a sound driver, but then you have multiple plugins all implementing that same interface so that you can have a sound driver for Linux and one for Windows for example same for image loader plugins. There's one Interface for image loader and then we have different plugins for all the different formats that we support It's very easy to write New plugins even the third party you you don't have to put them in crystal space You can also make a crystal space application and then add your own plugins if you have some very weird image format For example, and you want to support it, but it's not common enough to be put in crystal space Well, then just distribute it with your own application. That's no problem And every plugin is more or less than the loan The way to talk the plugins talk with each other is restricted. So Interfaces are one of the most important concepts for implementing a plugin So it's a bit like Java in Java. You have you actually have a keyword interface language supports interfaces It's not present in C++, but we simulate interfaces by just using abstract classes in C++ So and an interface is a contract So when you say some plugin implements one or more interfaces Then actually it means that plugin can do these things that are described in those interfaces if there are no books, of course So and the set of all interfaces together. That's the crystal space API Here's a small example of how an interface could look like in crystal space So you basically see it's a structure It could be class but we use struct because the only difference in C++ between struct and class is that the struct all members below with our public so you don't have to write public and We specify the versioning of the interface That's important for example when you upgrade the interface you add the function or you change a function You can change the version number so that an application can check if some object implements a certain version of an interface And then you have the virtual methods. There is they are purely pure virtual by the equals zero at the end So it means that there is no implementation here the implementation has to come elsewhere. It comes in the plugins here is a No overview of the architecture of crystal space. It's only a small part There are a lot more plugins, but it shows the most important plugins. So at the bottom you have the basic libraries and On top of that the blue section. That's actually everything that has to do with rendering and Operating system window support and events from input devices So you have the canvas below which is actually the plug-in responsible for opening a window Listening for keyboard joystick mouse events and sending it out to the rest of the application So you have different implement implementations one for X one for direct draw and so on and also for GLX for the open GL version and so on so there are a lot of implementations there on top of that you have a render and the render is the actually the Plug-in that interfaces with the 3d hardware or simulates is using a software render and We currently have three renders open GL, which is the default one the most used one Software render and a no renderers no renderers doesn't render anything It just implements the same API so that you can use crystal space on the server for example So that way you don't need to display There's also shader manager. There's a font system. You will be currently support fixed size fonts or true type Then on top of all its rendering system the green bit if is actually the engine it's actually So the 3d engine itself is one plug-in, but to do what it needs to do its support It has to use several other plugins for example the visibility colors are the plugins responsible for doing the visibility Determination and there are different versions of that There are lender render loops, but I will talk more about that later and the most important part is the set of mesh objects and the mesh object is Geometry is actually what you see on screen and there are also different plugins for measure objects because there are different ways you want to Represent geometry for example a landscape is usually represented with a height map So there is a specific mesh object that knows how to interpret a height map and render it on screen There's also There are also mesh objects for animated objects for example also particle systems Those so all are responsible for generating the geometry that is rendered by the renderer But they do they do it in a different way. So it's optimized for their specific task Then on top the yellow parts is actually everything that has to do with loading So we use XML a lot the entire map format is XML and so You have the map loader which is on top of everything and on the right you have image loaders also with different plugins and then you have For every mesh object type that you have below. There is also a corresponding loader plugin and For some measure object. There are also multiple plugins for example because we also support for some match objects binary formats so you can have multiple loader plugins supporting other formats and Yeah, there's also the XML parser and then finally you have the game or the application At the end of this presentation I will show you another slide which looks exactly like this one But which puts this entire block except for the gray one in one block called crystal space and then crystal entity layer sitting on top of that again so just to put things in perspective so To get things fast 3d cards are getting faster and faster, but to actually benefit from that speech You can't just do naively throw everything at it. You have to do it in a more clever way So you need good data structures. You need good algorithms Do not waste that fast hardware So here are few slides about memory management Allocating and the allocating memory is expensive. I have one very good example of this a Few years ago one of the big projects using Chris's place Chris's base was plane shift and they had a very big speed problem with loading maps, but only on Windows About on Windows loading a map was a factor seven to eight times slower than on Linux and After a lot of debugging we finally found out what the reason was the XML parser used to allocate lots of lots of objects it uses a dumb model which means that every note every attribute is its separate allocation and apparently in the Windows version which was compiled with dotnet if you use I'm not familiar with that net but apparently with the default settings for thread support Memory allocation is locked to support threads and that locking was very very slow So basically we rewrote this so we use pools. We don't allocate as much memory anymore Instead of allocating one note in F in single allocation We allocate a thousand notes and then use them one by one So we actually got the speed of the Windows version exactly the same as the Linux version so And the Linux version sped up a little bit as well because even on Linux also memory allocation has some overhead of course We generally avoid link lists There are good uses for the link lists But in general they add a lot of overhead one of the overheads is of course the memory allocation that you have to do for every note Of course, you can solve that with pools and other techniques on top of the link list But still in in many ways we use growing arrays because crystal space is rather old project now We don't use the STL race If we would start now we would use it But since it's that old we already created our own utility classes and they are used throughout the project So it's a bit of work to change that But basically we have the same kind of supporters STD factor for example, but in our own classes a Also an important principle that we use a lot in this space is Only do something when you actually need to do it don't do it earlier. So Because there are many cases and I will give some examples of that when it actually turns out that you don't even need to do what you plan to do so Here's an example, but I will explain that more later Debugging it's very important And 90% of the time I think it's it's just a rough estimate, but it will not be far away from that so and the problem with C++ is that it's a Very good language to make bugs in So you have to do memory allocation and memory management all by yourselves at this moment We have a pretty good system for that, but getting it there is also some some work Variables are not automatically initialized So it's very common to have someone not initialize a variable and have no problem with it because it happens on this operating system that it happens to be zero all the time so But there are several tools to help debug this like file grind is very useful on linux and Gdb of course just standard C++ Debuggers we also have some debug tools actually plug-ins in crystal space that help for analyzing But they are mostly useful for game developers Because they can analyze what is on screen and that object isn't rendered. Why isn't it rendered for example that kind of things? That's bug. Look so and it's a plugin that you can load transparently into any crystal space application without having to change the code This is just a way that we also use we use a lot of asserts in the code to The these are only compiled in the code in debug mode. So you get a lot of more checking then So one important part of crystal space of course the 3d engine So I will go a bit into detail. There are several plugins You have to call engine of a visibility colors if the mesh objects and the render loops I already talked about those earlier and engine Communicates with the renderers. That's the green part with the I believe I forgot color with the the blue part so so crystal space is a portal engine that means that every to make worlds you actually use portals to connect different spaces together and a Sector is one basic building block a sector is just infinite space and you can fill it with objects with match objects and using portals you can connect different spaces with each other and The most easy to understand example of a portal is just the doorway between two rooms then with the two rooms would each be a separate sector There are also special effects that are possible you can have a portal that points back to the same place and Transforms space so that it becomes a mirror for example Portals can move. There's just there are just objects like all the others So There are different type of mesh objects already talked about that earlier So you have the animated objects particle system landscape engine and for example and so you can also put objects in a hierarchical structure So that you can have for example an actor, which is an animated mesh Having a sword in his hand for example, which could be a separate object And also lights can can be put there One important concept of crystal space next to the mesh object is the mesh factory and the factory is actually the object that Contains the geometry, but it's static What that means is you can have a share in a room But if you want multiple chairs, you only need one chair factory and then different mesh objects all using this data from that Factory so way to save memory So here's an example you have the engine different mesh factories on the right and then there are two sectors here So every sector has a few lights So and then Every sector also has a visibility color. So visibility calling is done one sector at a time And then every sector has a number of objects And for example mesh 2 in sector 1 is actually a portal to sector 2 Mesh 3 in sector 2 is actually a portal to sector 1 so Here you see an example of Top view of a 3d world. There are three sectors here in this case and The camera is the little eye on the right and it can actually see into The second sector the middle sector through the doorway But it cannot see the third sector because the second portal is completely out of out of view and that's very useful for for level performance because the third room can be a really very complex room It can contains thousands of objects But if the camera doesn't see the portal that goes to that room it has no Overhead at all zero over it because the portal is not even considered So the objects in that other sector are not even considered for rendering So it's a great way to speed up your level Render loops are another concept in the engine as a way to give the game developer more precise control of over how to render objects and We have a very very general system So that you can actually say it has to do also with the fact that To render some geometry some shaders you need to do multiple passes for example, you do first to the Ambient and the diffuse of for example, and then you do bump mapping on top of that and Render loop controls that by rendering all the objects and having different steps that represent the different passes so Here's an example. It's XML It's just one of the standard render loops. So you see It has a name. There's two steps two major steps in it. The first step It's is this one Is actually the one that just does ambient lighting So it's just a fixed amount of lighting on the every surface and then there's a Step which was also plug-in that iterates over all lights in that sector and for every light It will use another step to add diffuse lighting So basically what this render loop will do it it will Render all objects and every object will be rendered with as many passes as there are lights hitting that object plus one so That's how this works Okay, one of the very important things even with fast hardware is still to find out What is visible and what is not because you don't want to waste time rendering something that is not visible It the of course if the hardware is fast you could argue why not send it all to the hardware It can handle millions of polygons while bother doing the visibility determination if the hardware can handle it, but of course Heart one with the hardware becoming faster people also expect more and one million object Polygon object will probably not be big enough and anymore So and also there are a lot of other things that are associated with objects like for example physics animation game logic and Also using the visibility color if you know some objects is not visible You don't need to animate it. You don't need to calculate the particle positions. You don't need to Calculate lighting on it. There are a lot of things that you don't have to do if you know it is not visible so But still because hardware is very fast these days The visibility calling should be as quick as possible So and there are currently two and one in development two colors in crystal space The first one is first this and it's very easy Just just does first in killing which means that everything which is outside the view is not visible Everything which is inside the view is visible. It's very easy. It's very fast So it is very good if you have for example a relatively simple world And it doesn't it's not no problem to render every object that is in front of you There's a more complex visibility color Dynamics and it tries to find out if some object is hidden by an object that is closer A KD KD three is a three-dimensional structure to organize data And it's heavily used by all colors to organize the objects in the world. It's one important of a very Important data structure that has to be very fast So here we also do updates lazy if an object moves indicate a tree We don't want to update it immediately We just put it on a cue and say if the camera happens to look in this direction then we will actually Move the object of the hierarchy Here's a quick example So the entire box represents the the world and first there's a horizon it's cut in two Horizontally so you have a top and a bottom part then the bottom part is cut into again that way and then again so you get every note is cut into two halves according to some access and Objects are distributed that way so Um But the KD tree can be traversed. I will go a bit quicker over these lights It's a bit technical and also it's not that important to know it in detail Just the way to illustrate what an engine all needs to do the responsibilities and that it's not That sometimes not that easy For example here you see our frustum culling works So you have the camera at the bottom and it looks that's the area that it can see So everything left and right of the red lines is not visible you can see the the The the rectangles are the notes of the KD tree This is of course the two-dimensional version But it works similarly in a 3d version and you see the dark green areas are areas that are completely out of the Frustrum so it doesn't have to render them and it also doesn't have to check if the objects in those notes are visible Because it also ready knows that the container is invisible objects that are cut into by the red lines Can contain objects that are visible so it then has to check the objects for example the object on the left Top left is not visible But the objects below that is is visible and of course you have notes that are completely inside the frustum and That's also easy because the objects inside that frustum don't have to be checked either because if the parent is inside it Then of course the children are too So dynamists tries to be a bit smarter than that It actually tries to calculate if Objects hide each other and to do that it uses a coverage buffer Which is a bit like a Z buffer for 3d hardware, but I Will not go into much detail here because it's really very It's really bit complicated so But actually it writes out the objects in a buffer and it compares the depth with that object With objects that are will be rendered later or earlier to see if they're visible so here you see two polygons and Death there's a death value for every eight by eight pixels in this case There are very a lot of optimizations because of course this coverage buffer is rather CPU intensive. It actually means you have to Transform the geometry from 3d to to to the screen and that's actually something that the 3d hardware already does for you So it's a bit a pity if you have to do it yourselves again in software That's where you have to do it twice once on the hardware and once on the CPU So there are several ways to minimize that problem so We for example, we calculate outlines of objects and then we only render the outline in one go instead of every single Triangle that's a lot faster already We also when we test if an object is visible we first test if the bounding rectangle is visible We don't we're not going to test every pixel or not going to test every polygon even because if you're going to test if a 100,000 polygon object is visible that's still going to take a lot of time So we just test the bounding rectangle and maybe we will make a mistake, but that's not the big deal If it can be that the object is Not visible, but we consider it visible because one part of the rectangle happens to be visible, but there is no geometry in it But it's better to make that mistake than the opposite mistake. So It's not no big problem We also Writing to the coverage buffer actually transforming the geometry to the screen is expensive So we avoid that by writing it putting it on a queue again again the same principle Don't to work unless you really need to So and in this case especially We found out that very often the work is no longer needed Also here history culling if an object was visible the previous frame there is a very big chance It will be visible again this frame because typically from frame to frame the geometry doesn't change that quickly So what we do is when we see an object is visible we say well, let's make it visible for the next I don't know five or six frames for example that way. We don't have to test that object again for some time Also, if we know one point of the object that is certainly visible then we can Next frame just test if that point is visible again And we only have to test a single point if it is visible then we know the object is visible if not Then maybe we have to do more complicated tests. So there are lots of little optimizations Well, this is not important Okay So dynamists also supports portals So when you go through portal the view frustum is actually restricted because When you look through that door what you can see of the room beyond is actually only a smart part So and the colors support that notion and know that everything beyond the portal bone boundary Can already be discarded easily Potentially visible sets. It's a very old system. That's actually dates from quake It actually is a pre-calculated visibility It's only feasible for if you have static worlds that don't change and you For you at every point in space or at least in notes You say this is the list of objects that are visible or not visible at this point in time And we have a visit a pvs plugin, but it's currently not operational. So it needs some work still Another way to gain speeds besides not rendering what you can't see is another way to scan speed is level of detail and An object that's very far away. You only have to render it with very low detail. So and there are several Several things that we support You based on the hardware that you have you can decide to render it in more detail anyway If you have speed enough why not that made it may look better, but you can tweak that a bit so for example progressive level of detail is Easily shown in this example. It's from it's not my image. It's from Microsoft so on the right you have the full detail detail rabbits and you have algorithms to Collapse that high detail into lower detail. So that in general the shape is preserved, but it just uses less triangles Imposter level of detail is also very important It means that you can say you have a very complex tree with lots of leaves and when it's close You want to render it in a lot of detail But when the tree is on a mountain you don't want to do that So you could replace it with a lower detail version or you could let the engine calculate that for you Render that tree once on a texture and then use that texture instead of the original tree for example We have support for that, but it's not completely functional yet for portals as well the contents of a portal contents of a doorway if you can Pre-render that on a texture then you can use that texture instead of going through the portal Statical level of detail is very simple just means Like the bunny different levels and you can switch between the levels as When you want more or less detail the disadvantage of that is of course that when you switch You can sometimes see an effect. You see that it suddenly gets more or less detail So that's the price you have to pay for speeds Landscape is because it's height map based has very specific algorithms for level of detail So here you see an example on the right on the left you have the more detailed version more polygons on the left There's a lower detail version and also our landscape engine supports lowering the detail for mountains that are in the distance and More detail for mountains that are close materials and shaders That's another part of the engine that is important. So we support also different plugins for example cg our Rb and fixed shaders we support and Shader is just the program that can run with 3d cards Because not all cards support shaders very well. We also support the notion of Software shaders that's actually just open GL calls that are done on the CPU instead of on the 3d cards and To we support different techniques, for example, you can say a shader for bump mapping on very good Hardware you might might be able to use a fragment shader that does very complex calculations But does it very quickly and needs only one step for example one pass But maybe that fragment shader doesn't work on lower-end hardware So you can add define multiple techniques and you can give them a priority and crystal space automatically Finds out what hardware supports and will select the highest priority technique that works on your hardware So that's one way that we can support both high-end with high quality and low-end with lower quality Lighting techniques, I will go a bit faster because I'm running out of time so different ways to do lighting and Light mapping is an important one. I will show that in this example So on the left you have the geometry. It's a room with some object in it and It's not lit which means that you just get the full bright textures. There's no lighting everything is as The same as the same level of brightness The light map calculators can calculate light maps. You see them in the second screenshot So the texture is gone But you see only the light map and because there is a purple and the blue lights You can see the different colors and then finally it is put together in the engine and so you see the shadow and the lighting together Lights maps are pre-calculated. So that means that they are not suitable for geometry that changes Vertex lighting is better than you have Lighting that can actually change at runtime and of course Shadows using to 3v hardware stencil hardware The advantage so this is an example. You see the shadows are Calculated at runtime here. So if the lights moves the shadows will actually move as well so the advantage of light maps are that it's Pre-calculated which means that at runtime there is no cost at all You can have a thousand lights affecting a single object and it will render just as fast as The same object with only one light of course It takes a lot longer to pre-calculate to calculate the lighting in the beginning but that is typically done by the game developer and The stencil lighting on the other hand has the advantage that It is no it doesn't have to be pre-calculated and objects can move around and lights can move But if you have a thousand lights affecting one object, it will not work That's simply too much for the hardware. So because it has to calculate it At runtime So as I said before we also support collision detection physics using opcode for collision detection and ODE and Felix and and bullet for physics So I was I will just mention this but we also have animation of course 3d engineer different types of animation Keyframe animation where you have Different frames different positions for a kind of object skeletal animation typically used for characters in games Hierarchical animation where you can put a sword in the hand of an actor. I already mentioned that for example Particle animations that's obvious. There are also several other animation options There's a sequence manager that you can have kind of scripts that you can save and for example for one second Move that object from there to there then after that it will jump three times and after that it will rotate a bit So you can make these kinds of scripts and of course texture animation animated gifts movies animated Textures in general So then on below the engine you have the renders So the render is actually responsible for sending the data to the open GL system or to the software renders I will not go into a lot of detail here. It's not that spectacular So the shaders are there and then crystal space There are a few hundred plugins. So there are a lot of plugins for console joystick support font plugins Scripting plugins. This is very important. I want to mention this a bit more. We actually support Java Pearl and Python in crystal space So you can write a full crystal space application in these three languages in four languages C++ as well, of course And it's the actually nearly the complete API is exposed. So you can Write it in any language that you want of those XML parsing sound plugins movie recorders sequence managers reporters Of course the window system Virtual file system Then crystal entity layer and I will just show you the overview here. So it sits on top of crystal space and It adds the notion of game entities of game concepts So it does that by defining entities and entity is a typical object in a game world It can be something that has a visual representation But it can also be something that just handles game logic. So it doesn't have to be visual and You can actually attach functionality with the property classes So if you want for example a camera an entity that represents the player it will typically have a camera So you attach the camera property class Then finally I will conclude by mentioning apricot. It's a new project started this month cooperation between blender and crystal space and the plan is to make an open game Where everything all artwork all sources everything will be open and published So you can download it later when it's ready You can also ready pre-order the DVD to support help support it because actually this project is made With six people were actually permanently in Amsterdam working on this right now So it's one important Here you see it's apricot projects goes together with the peach project Which is the open movie from blender and these are renders from the open movie and these characters are also going to be used in The game, so it's a bit of a cartoon game and This was just an example. It shows blender Integrated with crystal space of the opposite way at least crystal space integrated with blender So it's just one thing that they made in one week time in Amsterdam To make it easier to make games using crystal space and blender. So there's actually integration between the two So that's basically it