  # Garold

Member

7

## Posts posted by Garold

1. ### Rotate A Quad Along Axis To Face Camera

Your method seems way simpler :)

2. ### Rotate A Quad Along Axis To Face Camera

Thanks Rob.

I found a solution within the library, after learning some basic math.

 Orientation3D.SetUpDirection(ref cparticle.Orientation, Vector3.Cross(cparticle.Velocity, CameraPosition - cparticle.Position));


I'll try to see if I can use your method to edit the vertices directly, but it looks a little like the function it calls is doing as you suggest anyway.

        public static Quaternion GetRotationTo(Vector3 CurrentDirection, Vector3 DesiredDirection, Vector3 sFallbackAxis)
{
Quaternion quaternion = new Quaternion();
Vector3 vector = CurrentDirection;
Vector3 vector2 = DesiredDirection;
vector.Normalize();
vector2.Normalize();
float num = Vector3.Dot(vector, vector2);
if (num >= 1f)
{
return Quaternion.Identity;
}
if (num <= -0.999999f)
{
if (sFallbackAxis != Vector3.Zero)
{
sFallbackAxis.Normalize();
return Quaternion.CreateFromAxisAngle(sFallbackAxis, 3.141593f);
}
Vector3 axis = Vector3.Cross(Vector3.UnitX, vector);
if (axis.LengthSquared() < 0.999998f)
{
axis = Vector3.Cross(Vector3.UnitY, vector);
}
axis.Normalize();
return Quaternion.CreateFromAxisAngle(axis, 3.141593f);
}
Vector3 vector4 = Vector3.Cross(vector, vector2);
double num2 = Math.Sqrt((double) ((1f + num) * 2f));
double num3 = 1.0 / num2;
quaternion.X = (float) (vector4.X * num3);
quaternion.Y = (float) (vector4.Y * num3);
quaternion.Z = (float) (vector4.Z * num3);
quaternion.W = (float) (num2 * 0.5);
quaternion.Normalize();
return quaternion;
}

3. ### Rotate A Quad Along Axis To Face Camera

I am having some success aligning a particle to a direction and then rotating it along its axis. At the moment I am just constantly rotating it. How do I calculate the correct rotation so it always faces the camera?

Please have a look at this video:

I am using DPSF. I have modified the "FlyingSparks" demo.

To calculate the orientation Quaternion I run this code:

private void UpdateOrientation(DefaultTextureQuadTextureCoordinatesParticle cparticle, float felapsedtimeinseconds)
{
var normalized = cparticle.Velocity;
normalized.Normalize();
cparticle.Orientation = Quaternion.Identity;
cparticle.Right = -normalized;
_rotation += 0.03f;
cparticle.Orientation = Quaternion.CreateFromAxisAngle(normalized, _rotation) * cparticle.Orientation;
}

After some trial and error the above code produces what you see in the video.

Line 5: resets the orientation.
Line 6: aligns the quad to the velocity direction.
Line 7: increments the rotation.
Line 8: further rotates the quad along its axis by the rotation.

What I am asking is how do I calculate the rotation?

I am not a maths expert. I can guess that I need the normal of the particle, calculated within line 6 and then use that to determine it's difference from the camera direction. I have looked at some billboarding techniques but they don't offer exactly what I want.

I am very close to finishing my game and this is the last hurdle, any help or pointers would be greatly appreciated, thank you for taking the time to look at this • ### XNA 4.0 - shimmering shadow maps

I would very much like to thank you for the explanation and code. I had shadows that would shimmer whenever I rotated or moved. Now they are rock solid. The difference is very satisfying If you are interested here's a playlist that details my shadows development:

Or have a look at this video:

• ### Programmer already, just new to gaming

I have been programming professionally for 25 years, usually large corporations, COBOL, C, VB, SQL and so on. I started dabbling with XNA and C#. The code is very easy to understand. It's techniques that are real key. I would wade through the example XNA programs on the APPHUB website. They are very informative and complete.
• ### I want to align my bullet hole decal with the surface hit

Here's a video of the problem fixed!

I ditched the idea of using a trianglelist based particle system. Instead I use a quad model circular array. I can manipulate the matrix up vector using the normal of the surface hit.

Thanks for looking.

BTW: I think I should have posted this in the XNA section, sorry about that, I didn't realise till after posting.
• ### I want to align my bullet hole decal with the surface hit

HI, this is my first post and would appreciate any help.

Here's a video of the problem

I am using the particle system from the "Particles3D" XNA example. Currently the texture is always aligned with the camera. I want it to be aligned with the surface hit.

In the video I have displayed the location and normal of each collision.

The sample particle system has a lot of redundant code that I don't need for the bullet holes. For example I don't need the particles to move, rotate, change size or color.

The vertex shader input contains a float3, Velocity, that I could presumably replace with the normal.

in the ParticleVertexShader the output.Position is calculated in ComputeParticlePosition.

 // Custom vertex shader animates particles entirely on the GPU. VertexShaderOutput ParticleVertexShader(VertexShaderInput input) { VertexShaderOutput output; // Compute the age of the particle. float age = CurrentTime - input.Time; // Apply a random factor to make different particles age at different rates. age *= 1 + input.Random.x * DurationRandomness; // Normalize the age into the range zero to one. float normalizedAge = saturate(age / Duration); // Compute the particle position, size, color, and rotation. output.Position = ComputeParticlePosition(input.Position, input.Velocity, age, normalizedAge); float size = ComputeParticleSize(input.Random.y, normalizedAge); float2x2 rotation = ComputeParticleRotation(input.Random.w, age); output.Position.xy += mul(input.Corner, rotation) * size * ViewportScale; output.Color = ComputeParticleColor(output.Position, input.Random.z, normalizedAge); output.TextureCoordinate = (input.Corner + 1) / 2; return output; } 

Inside ComputeParticlePosition the position is multiplied by the view and projection matrix.

 // Vertex shader helper for computing the position of a particle. float4 ComputeParticlePosition(float3 position, float3 velocity, float age, float normalizedAge) { float startVelocity = length(velocity); // Work out how fast the particle should be moving at the end of its life, // by applying a constant scaling factor to its starting velocity. float endVelocity = startVelocity * EndVelocity; // Our particles have constant acceleration, so given a starting velocity // S and ending velocity E, at time T their velocity should be S + (E-S)*T. // The particle position is the sum of this velocity over the range 0 to T. // To compute the position directly, we must integrate the velocity // equation. Integrating S + (E-S)*T for T produces S*T + (E-S)*T*T/2. float velocityIntegral = startVelocity * normalizedAge + (endVelocity - startVelocity) * normalizedAge * normalizedAge / 2; position += normalize(velocity) * velocityIntegral * Duration; // Apply the gravitational force. position += Gravity * age * normalizedAge; // Apply the camera view and projection transforms. return mul(mul(float4(position, 1), View), Projection); } 

So in summary, I don't need most of this code, I have only included it so you see what is currently happening. The input velocity is zero.

How do I transform the position so that it aligns with the normal?

Any help or pointers would be great.