PhM

I could probably find out about the drivers by asking a contact at AMD. Nevertheless it does not mean that the engine using the driver has to be single threaded, these are two different things. Nope, nothing. Given the posts I made on the org that he answered he knows about my findings, there are also people in touch with Laminar on several forums that most probably read this kind of posts. PhM

I stumbled upon this post and, has I am working in the game industry on graphics engines, I feel that I have to put things straight. It's quite the opposite, and has been for a while, all top professional game engines are multi-threaded. Given the fact that game companies want to get the best results and cram as much as they can in their games, why would they leave 75% of the processing power (in the case of a quad core CPU) unused in the first place ? Valve presented their work on their source engine in 2007, here are some interesting slides.Volition also presented their work in 2007, the presentation can be found here. This one is especially interesting as it presents the whole design process leading toward a multi-core engine.The same goes with DICE, a presentation can be found here.I had quite a long email discussion with Ben, back in 2008 probably, explaining him why the job architecture was the way to go with a multi-core hardware. So who knows, may be one day this will happen. PhM

You can find a discussion about that accident on Pprune. PhM

I fly helicopters, so FS is clearly not an option. PhM

Would it be legit to distribute it this way ? PhM

Read this, these are my findings after taking a look at what X-Plane does with openGL. PhM

Understanding this will help. PhM

Sources ? PhM

How do you guys manage to have crashy PCs ? Mine hasn't crashed for years, no BSOD, no re-boot, nothing. PhM

Yes. And as this is about plugin development, in other words programming, I thought that someone might end up here while looking for what recursion is all about. Given the fact that your comment : "It really is an area of programming where the programmer must tread carefully." was totally appropriate I decided to add some facts to help understand why it is not a good thing to do. In short : Nice and fun in academic discussions, too risky in real life. PhM

Indeed, the biggest danger being a stack overflow. This is not something PC developers are aware of as the default stack is rather big. But stack overflow may very well bite you if you have to port your perfectly working and elegant program on some other platforms. If you need to port on such platforms and chose to stick with recursion you will then have to make sure any input data that your program will have to deal with will never ever overflow the stack no matter where the stack pointer is a the time your recursive program is called. This means things like checking all code paths, size of arguments passed on stack and all local variables in each of these code paths. Having to develop on several platforms, recursion is something I stay away from, too much potential trouble. PhM

In fact the rendering frame time depends on many parts of a system, to make it simple if you get slo-mo then : - If your GPU usage is at, or close to, 100% you are GPU bound, it can't keep up with what has to be done. - If your CPUs usage is at, or close to, 100% you are CPU bound they can't keep up with what has to be done. - If none of the above applies then your are API (openGL) or I/O (PCIe) bound. PhM

AAARRRGGGHHHH ! This awful mac keyboard . I can't use these, I had to when porting a game engine to the mac, never again please . PhM

Indeed, you only have that many PUs in your computer whether C or G, and each can do no more than a given amount of work in a given amount of time. It's more about balancing work across your PUs and making sure no one is idle waiting for data. Considering the GPU it is the only PU in your computer than can do graphic stuff efficiently, it is therefore better to use it for graphics first even if it can do other things, using CUDA or anything else for this purpose. PhM

Fun with the H500D in the Alps here, the video may take a while to load. PhM

Would you like to have as much fun as ? Then try this .PhM

I never leave all the sceneries in my X-Plane folder, only those I am going to use. It makes the job easier for X-Plane as there are less things to fiddle with, and makes me confident that it won't load stuff that is not needed, like keeping a huge list of what was found in this folder, or anything else not related to what I want it to use. PhM

Well I hope that all those seats will be properly culled so they won't waste machine resources while we fly this plane. PhM

A sound source that has a position as well as a direction. Depending on the relative positions and directions of the sound and the listener the sound engine will render it as coming from the front, from behind, from the left, etc... is a video with some explanation about 3D sounds in wwise, an audio engine I worked on.PhM

Same here on W7 32 bits. PhM

Hi, I went to Asus's web site and found this page. PhM

Hi, Depends, Do you support multiple platforms ? If yes then what compiler are you using on each platform ? MS's compiler provides intrinsics for these instructions, I read things that lead me to believe that they are also available in XCode. There is some documentation on MSDN, look for streaming SIMD extensions. Once wrapped properly you can have the same syntax used for every platform. These instructions will do miracle provided that you have enough stuff to be processed, otherwise the improvement versus floating point is less. PhM

It's out, go get it. PhM

Hi x-alberto, By using structures to clearly define what is handled by your routines you will benefit from efficient type checking at compile time that will filter out several possible mistakes. It also happens to be helping the compiler out quite a bit as the code generated is over 2.5 times smaller, thus faster as less instructions get executed. I guess that you already know that if you are considering transforming more than a few vectors you should consider using SSE instructions, along with the compound transformation matrix that you mentioned that also saves a lot of instructions. Here is what I came up with, feel free to do whatever you may want with this code. PhM struct Vector3 { double x; double y; double z; }; struct Inputs { Vector3 Coordinates; Vector3 Rotations; }; struct Matrix3x3 { Vector3 Row1; Vector3 Row2; Vector3 Row3; }; void Transform3D(const Vector3 *in_pLocalCoords, const Inputs *in_pMap, Vector3 *out_pCoords) { //http://en.wikipedia.org/wiki/Rotation_matrix //http://inside.mines.edu/~gmurray/ArbitraryAxisRotation/ArbitraryAxisRotation.html //Make constants easier to handle. //Put angles into radians. const double H_rad = -in_pMap->Rotations.x * DEG2RAD; //heading const double P_rad = in_pMap->Rotations.y * DEG2RAD; //pitch const double R_rad = -in_pMap->Rotations.z * DEG2RAD; //roll const double cos_H = cos(H_rad); const double sin_H = sin(H_rad); const double cos_P = cos(P_rad); const double sin_P = sin(P_rad); const double cos_R = cos(R_rad); const double sin_R = sin(R_rad); //Pitch rotation matrix const Matrix3x3 Mx = { 1.0, 0.0, 0.0, 0.0, cos_P, -sin_P, 0.0, sin_P, cos_P }; //Heading rotation matrix const Matrix3x3 My = { cos_H, 0.0, sin_H, 0.0, 1.0, 0.0, -sin_H, 0.0, cos_H }; //Roll rotation matrix const Matrix3x3 Mz = { cos_R, -sin_R, 0.0, sin_R, cos_R, 0.0, 0.0, 0.0, 1.0 }; //What we want is out = [Mx*My*Mz] * in //We will use three consequent multiplications //The _only_ correcy sequence is //Mz //Mx //My //otherwise you get garbage (see multiplication rules for matrices...) Vector3 step1 = {0.0,0.0,0.0}; Vector3 step2 = {0.0,0.0,0.0}; // step1 = Mz * in mmult(in_pLocalCoords, &Mz, &step1); // step2 = Mx * step1 mmult(&step1, &Mx, &step2); // out = My * step2 mmult(&step2, &My, out_pCoords); /*Finally, apply translation*/ out_pCoords->x += in_pMap->Coordinates.x; out_pCoords->y += in_pMap->Coordinates.y; out_pCoords->z += in_pMap->Coordinates.z; } void mmult(const Vector3 *in_pX, const Matrix3x3 *in_pR, Vector3 *out_pX) { out_pX->x = in_pR->Row1.x * in_pX->x; out_pX->x += in_pR->Row1.y * in_pX->y; out_pX->x += in_pR->Row1.z * in_pX->z; out_pX->y = in_pR->Row2.x * in_pX->x; out_pX->y += in_pR->Row2.y * in_pX->y; out_pX->y += in_pR->Row2.z * in_pX->z; out_pX->z = in_pR->Row3.x * in_pX->x; out_pX->z += in_pR->Row3.y * in_pX->y; out_pX->z += in_pR->Row3.z * in_pX->z; }

Flying the H500D around NTAA. PhM