Comments on: Enhanced Crowd Rendering

By: Cody

Cody — Tue, 08 Jun 2010 07:08:43 +0000

the MS points to US currency is simple
80 Points = $1

By: PolyVector

PolyVector — Sat, 29 May 2010 05:43:23 +0000

Correction: The DualQuat gets converted to a Matrix once for each recursion through to the Parent… The DualQuats are used to tween/blend animations, then the final matrix is used to adjust for the parent… Since there’s so much math, I decided to have a hand at optimizing the conversion function and managed to eliminate 23 multiplications on top of my old optimizations that cut out 11!… So the function now uses 34 less multiplication instructions than the example I based it on. Here’s the crazy-optimized code, maybe someone has a clever way of optimizing it further?

float4x4 DualQuatToMatrix(float2x4 dQ)
{
float4 Qn = dQ[0];
float4 Qd = dQ[1];
Matrix M = 0;

//Qn Squared…
float4 Qn2 = Qn * Qn;
M[0][0] = Qn2.w + Qn2.x – Qn2.y – Qn2.z;
M[1][1] = Qn2.w + Qn2.y – Qn2.x – Qn2.z;
M[2][2] = Qn2.w + Qn2.z – Qn2.x – Qn2.y;

//x*y, y*z, z*w, w*x…
float4 Qn2_1 = Qn * Qn.yzwx;
M[0][1] = Qn2_1.x + Qn2_1.z;
M[1][0] = Qn2_1.x – Qn2_1.z;
M[1][2] = Qn2_1.y + Qn2_1.w;
M[2][1] = Qn2_1.y – Qn2_1.w;

//x*z, y*w, z*x, w*y…
float4 Qn2_2 = Qn * Qn.zwxy;
M[0][2] = Qn2_2.x – Qn2_2.y;
M[2][0] = Qn2_2.x + Qn2_2.y;

float4 Qdx_X_Qn = Qn * Qd.x;
float4 Qdy_X_Qn = Qn * Qd.y;
float4 Qdz_X_Qn = Qn * Qd.z;
float4 Qdw_X_Qn = Qn * Qd.w;
M[3][0] = Qdx_X_Qn.w – Qdy_X_Qn.z + Qdz_X_Qn.y – Qdw_X_Qn.x;
M[3][1] = Qdx_X_Qn.z – Qdz_X_Qn.x + Qdy_X_Qn.w – Qdw_X_Qn.y;
M[3][2] = Qdy_X_Qn.x + Qdz_X_Qn.w – Qdx_X_Qn.y – Qdw_X_Qn.z;

//Batch all the various 2x’s here to save instructions
M[0] *= float4(1, 2, 2, 1);
M[1] *= float4(2, 1, 2, 1);
M[2] *= float4(2, 2, 1, 1);
M[3] *= float4(2, 2, 2, 1);

float len2 = dot(Qn, Qn);
M[3][3] = len2;
M /= len2;

return M;
}

By: PolyVector

PolyVector — Sat, 29 May 2010 01:58:15 +0000

@T
Thank you.
You actually have me second guessing the Dual Quaternion thing… I believe I was using them because they’re easy to lerp, but I switched to them from matrices quite a while back when I was much newer to 3d programming (not that I’m an expert now)… So perhaps their use is unfounded… They are quite expensive to convert back into a matrix, but that only happens once per processed bone…, hrmmmmm….. Now I’m going to have to rethink them.

It sounds like you understand what I’m doing, except I’m traversing the tree in the reverse order CurrentBone->Parent->Parent->Parent until I hit root, this makes it much simpler.

I’m using a shader constant array and a modified “Fullscreen Quad” that’s now more of a “Partial-screen Quad” The instance is determined by Texel.Y, and the bone by the Texel.X.

By: T

Fri, 28 May 2010 23:02:41 +0000

Firstly, you’re awesome (and inspiring). Secondly, dual quaternions?! Really?! That’s hardcore. Why didn’t you go with quaternion(rotation)/vector(translation) out of curiosity? Is it slower or less accurate? It’s certainly less confounding. This is a really clever technique to leverage the strength of the Xbox’s GPU and I’d like to say thanks for sharing. I think I understand it except for the Animation Processor Shader (most important part). My understanding: In its most basic form you read the relative bone position for current bone for the current frame and read that bone’s parent index so you can read the parent bones relative position. You multiply this bone matrix and its parent bone’s matrix to get it’s absolute transform.
How do you ensure that the tree is traversed appropriately (ie root, child of root, child of child of root)?
Then you read the bone’s inverse bind pose matrix and multiply it by it’s absolute transform. Then spit out this matrix to three rendertargets.
How are you calculating over 200 animations in one draw call. Is the current frame index for each instance being written to a dynamic vertex buffer or shader contant array? I’m soo confused. Help me (so I can ask you more questions).

PS I love you.

By: David

David — Thu, 27 May 2010 14:03:10 +0000

I’ll have a look at that, looks promising Thank you

By: PolyVector

PolyVector — Tue, 25 May 2010 23:44:04 +0000

@David
My version is mixed up in a ShapeBuilder class, but I actually learned from this sample: (if I remember correctly)

http://creators.xna.com/en-US/sample/meshinstancing

By: David

David — Tue, 25 May 2010 20:24:32 +0000

Really cool, I’m trying to implement the same kind of thing based on the Gems 3, however implementing shader instancing is a pain. The InstanceSkinnedModelMesh.cs is killing me, would you mind posting the ReplicateVertexData method ?

By: PolyVector

PolyVector — Fri, 26 Mar 2010 19:37:57 +0000

@Ben
It’s worth considering, there’s also this site and the playtest area of CCO.

By: Ben

Ben — Fri, 26 Mar 2010 17:19:01 +0000

Sounds good, I’m all for taking the time to release quality. Please do consider uploading test builds to,
http://www.xblig.co.uk/forums/index.php

I think your game could be the one that draws more people to the press A forums. With a playable demo, I think you could even ask for donations. Bypassing the marketplace if you wish. I don’t know if you’re down for that sort of thing but it is a possibility.

By: PolyVector

PolyVector — Fri, 26 Mar 2010 04:55:34 +0000

@Ben
Oh, you meant actually create a mini game to fund the larger game’s dev. That could work, I do plan on releasing mini games eventually… We’ll have to see how long it takes me to even get a fully playable demo of anything. There’s too many collision/physics/art/performance issues at the moment to just rush something out. I want to release games I’m proud of.