wc3campaigns
WC3C Homepage - www.wc3c.netUser Control Panel (Requires Log-In)Engage in discussions with other users and join contests in the WC3C forums!Read one of our many tutorials, ranging in difficulty from beginner to advanced!Show off your artistic talents in the WC3C Gallery!Download quality models, textures, spells (vJASS/JASS), systems, and scripts!Download maps that have passed through our rigorous approval process!

Go Back   Wc3C.net > Tutorials > MDL Editing
User Name
Password
Register Rules Get Hosted! Chat Pastebin FAQ and Rules Members List Calendar



Reply
 
Thread Tools Search this Thread
Old 01-08-2006, 11:37 PM   #1
Extrarius
User
 
Extrarius's Avatar
 
Join Date: Jul 2002
Posts: 952

Submissions (1)

Extrarius will become famous soon enough (59)Extrarius will become famous soon enough (59)

Send a message via ICQ to Extrarius
Idea Interpolation in the MDL/X

This was written as two posts in reply to a question on another thread, so it's not written in the best style and it's in the two following posts:
__________________
ExtProtect - Extrarius's Map Protector
Extrarius is offline   Reply With Quote
Sponsored Links - Login to hide this ad!
Old 01-08-2006, 11:38 PM   #2
Extrarius
User
 
Extrarius's Avatar
 
Join Date: Jul 2002
Posts: 952

Submissions (1)

Extrarius will become famous soon enough (59)Extrarius will become famous soon enough (59)

Send a message via ICQ to Extrarius
Idea A (not quite) brief tutorial on Interpolation

A (not quite) brief tutorial on Interpolation:

Interpolation is a group of methods for using some information you have in order to guess about information you don't have.

For warcraft 3 models, that means taking two coordinates that each have an associated time and creating a coordinate at some time in between using some formula.

For math purposes, the time used for the first coordinate is 0, and the time used for the second coordinate is 1, but using some algebra you can use any other time values you want.

For translation, scaling, and anything else(like alpha values) that isn't isn't a rotation:

The basic method, Linear Interpolation, uses a formula based on making a line between two points:
MiddleValue = (Time * (EndValue - StartValue)) + StartValue
which, can be simplified to:
MiddleValue = ((1 - Time) * StartValue) + (Time * EndValue)
Basically, you take some part of StartValue and some part of EndValue, and add them together.
If Time is 0, you get StartValue
If Time is 1 you get EndValue
For Time values in between, you get more of StartValue the closer Time is to 0, and more of EndValue the closer Time is to 1.
Another way to understand it is that you're taking an average, except that instead of multiplying each part by 0.5 (same as dividing by 2), you're giving each half different importance depending on how much time has passed (because you want to start one place, and end at the other).

Ok, so how do InTan and OutTan factor into this? They're used in higher order interpolation, which means interpolation that uses more information than just two points to make shapes other than a straight line.
Warcraft 3 allows the use of two types of spline interpolation: 3rd-degree (cubic) hermite curves, and 3rd-degree(cubic) bezier curves. 3rd-degree means (in this context) that they work with 4 pieces of information.

Cubic Hermite curves take the two endpoints, just like linear interpolation, but also take a tangent for each point. The tangent is the direction the curve is going at that point. For example, a tangent of (0, 0, 1) would mean that at the point, the curve is going straight up (because Z=1 means up). The longer the tangent (meaning if you take the vector length, which means square all parts, add them up, then take the square root), the more the curve will travel in that direction. The curve blends between the two tangents in addition to the two coordinates to create a more rounded transistion.

For Hermite Curves, InTan is the tangent when a coordinate is used as the end point, and OutTan is the tangent when a coordinate is used as the start point. For example, blending between an animation at time 0 to animation at time 500, it uses the coordinate for 0 as the start point, the OutTan for 0 as the start tangent, the coordinate for 500 as the ending point, and the InTan for 500 as the ending tangent.

Cubic Bezier curves are essentially the same thing, but in a different format. Instead of giving tangents directly, you have to give control points instead. At the start point, the curve is going straight toward the first control point, and at the end point, the curve is coming straight from the second control point. You can think of it as
FirstControlPoint = StartPoint + StartTangent
and
SecondControlPoint = EndPoint + EndTangent
It's just like a Cubic Hermite Curve, except that instead of specifying a tangent directly, you have to add the related coordinate to the value.

For Bezier Curves, InTan is the second control point when a coordinate is used as the end point, and OutTan is the first control point when a coordinate is used as the start point. For example, blending between an animation at time 0 to animation at time 500, it uses the coordinate for 0 as the start point, the OutTan for 0 as the first control point, the coordinate for 500 as the ending point, and the InTan for 500 as the second control point. The curve blends between two lines (from a coordinate to the related control point) to create a more rounded transistion.

For rotation, things are more difficult because rotation is not stored in vectors (which are easy to manipulate), but in Quaternions, which can be a difficult mathematical beast. Put simply, they're like a special kind of vector that holds rotations (Quaternion Rotation) instead of positions.
Instead of linear interpolation,a method called Spherical Linear Interpolation must be used to get smooth rotations. This doesn't have any affect in what you put in an MDL file if you use Linear - you still just put the values you want and the game blends between them, but the information might help you understand Quaternions.
I'm not sure how Cubic Hermite or Cubic Bezier interpolation applies to rotation, but I'm fairly certain just sticking quaternions into the normal curve formulas would not work.
__________________
ExtProtect - Extrarius's Map Protector
Extrarius is offline   Reply With Quote
Old 01-08-2006, 11:38 PM   #3
Extrarius
User
 
Extrarius's Avatar
 
Join Date: Jul 2002
Posts: 952

Submissions (1)

Extrarius will become famous soon enough (59)Extrarius will become famous soon enough (59)

Send a message via ICQ to Extrarius
Idea A (still not) brief tutorial on creating rotations

A (still not) brief tutorial on creating rotations:

Ok, so you know Quaternion Rotation is how rotations are represented, but still have no idea how to use them.

There are two things you need to know to use basic quaternions - how to do a basic rotation, and how to combine rotations.

First, to make a basic rotation that spins in circles, you need to know that a rotation quaternion has basically 4 parts: XR, YR, ZR, and WR. Note that I put an R after them because they're not the same thing as the parts of a vector.

Lets say you have a vector, like (0, 0, 1) which is straight up, and you want to rotate around that in a circle constantly. Well, to rotate in a complete circle, you'll need to animate a rotation starting at 0 degrees, then to 120 degrees, then to 240 degrees, then to 360 degrees (which is the same as 0).

Why did I pick these numbers? Well, for a circle, you have to go from 0 to 360, but if you just put 0 then 360 there will be no rotation because they are the same rotation.
Why not do a simple halfway point and do 0, 180, 360? There are two ways to go from 0 to 180, either clockwise or counter-clockwise, and there is no telling which way the math will come out when you do that, so you can get the wrong rotation any time you try to rotate exactly 180 degrees.
Maybe do something like 0, 1, then 360? That doesn't work because the math always picks the shortest rotation, so it would rotate 1 degree, then 2 degrees the other way.
All this means that it takes at least 4 frames to do a full rotation, and while you can pick other numbers (as long as each rotation is less than 180 degrees), if you want a smooth rotation at constant speed it's easiest to just use equally-spaced numbers and equally-spaced frames.

Ok, so we want to rotate around (0, 0, 1) and go from angle 0 to 120 to 240 to 360.

Convert an axis and angle pair to a quaternion is simple:
XR = Sine(Angle/2) * X
YR = Sine(Angle/2) * Y
ZR = Sine(Angle/2) * Z
WR = Cosine(Angle/2)

So what are X, Y, and Z? They're not just the parts of the axis, they're parts of the normalized axis vector.
Sine and Cosine are the standard Trigonometric Functions.

Ok, so we have a formula, now what? Well, first the rotation should apply all the time, for any animation, so it needs an entry in the GlobalSequences section. Let's make it take 3 seconds to do a full rotation:
Code:
GlobalSequences 1 {
	Duration 3000,
}
So now, somewhere (in a bone, helper, particle system or whatever we want to rotate) we need to add a rotation:
Code:
Rotation 4 {
	Linear, //Linear Interpolation works fine for rotations
	GlobalSeqId 0,//Only global sequence there is
	//Axis = X 0.00000000 / Y 0.00000000 / Z 1.00000000
	   0: {  0.00000000,  0.00000000,  0.00000000,  1.00000000 },//@    0.00
	1000: {  0.00000000,  0.00000000,  0.86602540,  0.50000000 },//@  120.00
	2000: {  0.00000000,  0.00000000,  0.86602540, -0.50000000 },//@  240.00
	3000: {  0.00000000,  0.00000000,  0.00000000, 1.00000000 },//@  360.00
}
So where did the numbers come from? Well, the format for WC3's rotations in MDL is (XR, YR, ZR, WR), so at time 0 and 3000, there is no rotation but the length (square each part, add them up, take square root) should always be 1, so the representation of 'no rotation' is (0, 0, 0, 1)

Ok, now for the actual rotations: Applying the formula for axis of (0, 0, 1) and angle 120, we get:
XR = Sine(120/2) * 0 = 0
YR = Sine(120/2) * 0 = 0
ZR = Sine(120/2) * 1 = 0.866...
WR = Cosine(120/2) = 0.5
And there you have it, the quaternion for a 120 degree turn around the Z (vertical) axis

Apply the formula with the angle 240 degrees, and the only thing that changes is that WR is -0.5

Make a special note that specifying 3000 for the duration means the animation goes from frame 0 to 2999, and frame 3000 is never displayed. The reason we specify a rotation for frame 3000 is that frame 2000 needs to blend back to frame 0 to make a smooth cycle, but warcraft 3 won't do that automatically. Instead, we put frame 3000 the same as frame 0 so it blends from frame 2000 up to 2999 with a frame just like frame 0, so the effect is the same (but more work).

One final thing to note about this is that it's not just rotating the model, it's rotating it's axis also. What does that mean? It means that if you rotate around the horizontal axis X (1, 0, 0) by 90 degrees, you just swapped the Y and Z axis, and Y is up/down and Z is horizontal! Remeber this when you combine rotations, because you'll get the wrong result if you don't take it into consideration.

Ok, now to combine rotations(quite a bit longer)
Code:
A = (FirstWR + FirstXR)*(SecondWR + SecondXR);
B = (FirstZR - FirstYR)*(SecondYR - SecondZR);
C = (FirstWR - FirstXR)*(SecondYR + SecondZR);
D = (FirstYR + FirstZR)*(SecondWR - SecondXR);
E = (FirstXR + FirstZR)*(SecondXR + SecondYR);
F = (FirstXR - FirstZR)*(SecondXR - SecondYR);
G = (FirstWR + FirstYR)*(SecondWR - SecondZR);
H = (FirstWR - FirstYR)*(SecondWR + SecondZR);

WR = B + (-E - F + G + H) / 2
XR = A - ( E + F + G + H) / 2
YR = C + ( E - F + G - H) / 2
ZY = D + ( E - F - G + H) / 2
Yes, it looks complicated, and it is, but with a decent calculator (or basic programming knowledge) you can automate it and never have to look at the formula again.

Lets say we want to rotate an object 90 degrees on the X axis (to tip it over on it's side), and then have it rotate it in a horizontal circle. You might think we could use the information from above where we rotated the object around the Z axis (making a horixontal circle), but because of the X-axis rotation here, the Z axis isn't the vertical axis any more.
So first, we need to do the X-axis rotation, then make the circle around the Y-axis because it is the vertical axis now. This gives:
Code:
Rotation 4 {
	Linear, //Linear Interpolation works fine for rotations
	GlobalSeqId 0,//Only global sequence there is
	   0: {  0.70710678,  0.00000000,  0.00000000,  0.70710678 },
	1000: {  0.35355339,  0.61237244,  0.61237244,  0.35355339 },
	2000: { -0.35355339,  0.61237244,  0.61237244, -0.35355339 },
	3000: { -0.70710678,  0.00000000,  0.00000000, -0.70710678 },
}
Note how ugly the numbers are: Quaternions pretty much never come out with nice numbers due to the fact that they invovle trigonometry and square roots (during the normalization of the axis vector).
__________________
ExtProtect - Extrarius's Map Protector
Extrarius is offline   Reply With Quote
Old 01-13-2006, 04:38 AM   #4
StealthFox
User
 
StealthFox's Avatar
 
Join Date: May 2004
Posts: 132

Submissions (1)

StealthFox is on a distinguished road (21)

Default

I will add all of the knowledge that I have on bone rotations, SLerp, Hermite interpolation, and the InTan, OutTan in MDLs.

As you may have discovered, WarcraftIII models mainly have hermite in bone rotations and use SLerp (Spherical Linear Interpolation) for interpolating bone rotation...I think. Here is a formula off of http://number-none.com/product/Under...%20Using%20It/

Written in C++

Quaternion slerp(Quaternion const &v0, Quaternion const &v1, double t) { --v0 is the initial bone position and v1 is next bone position and t is a scalar value
// v0 and v1 should be unit length or else
// something broken will happen.

// Compute the cosine of the angle between the two vectors.
double dot = dot_product(v0, v1);
--This pertains to omega which represents cos theta = v0 (dot product) v1 and is found in wikipedia's formula for SLerp

const double DOT_THRESHOLD = 0.9995;
if (dot > DOT_THRESHOLD) {
// If the inputs are too close for comfort, linearly interpolate
// and normalize the result.

Quaternion result = v0 + t*(v1 – v0);
result.normalize();
return result;
}

Clamp(dot, -1, 1); // Robustness: Stay within domain of acos()
double theta_0 = acos(dot); // theta_0 = angle between input vectors
double theta = theta_0*t; // theta = angle between v0 and result

Quaternion v2 = v1 – v0*dot;
v2.normalize(); // { v0, v2 } is now an orthonormal basis

return v0*cos(theta) + v2*sin(theta);
}


How SLerp works and how it improves the smoothness of a rotation:

"Figure 1: We want to find the vector r that is at angle θ from v0."

"Figure 2: Using v1, we build the orthonormal basis { v0, v2 }, which allows us to easily compute r."

Linear Interpolation is good for easy rotations, but is choppy for most rotations.

Now for those hermite splines and what not:

From my extensive research on hermite stuff, hermite splines are used in keyframing to create a smooth transition from keyframe to keyframe. I believe 3dsMax uses TCB (tension, bias, continuity) splines in their interpolation.

TCB splines

As a side note, tension pertains to the speed at which a position is interpolated to another position (smooth bellcurve at tension = -1 and sharp pointy curve at tension = 1), bias pertains to the skewedness of the spline (curve slopes up fast on the left at bias = -1 and slopes down slowly and the curve initially slopes slowly but then drops quickly on the right when bias = 1), and continuity pertains to the continuity of the derivative of the curve or, in the common tongue, the smoothness of the curve as it approaches the next position and the smoothness as it leaves that position (continuity of -1 is a smooth curve throught the next position and a continuity of 1 curves sharply into the next position and sharply curves out of it).

Hermite splines

Finally, hermite splines use 4 formulas to interpolate keyframes. The formulas are the function for the initial position, the function for the derviative (tangent) of the initial position, the function for the next position, and the function for the derivative (tangent) of the next position. There are also formulas for calculating hermite spline interpolation, but they are complex and are everywhere on the internet. Google "hermite spline""interpolation."

Now if we could only figure out a way to export this "knowledge" from MilkShape3d.......that would help me LOTS.
Attached Images
File Type: jpg slerpvisual1.jpg (13.8 KB, 75 views)
File Type: jpg slerpvisual2.jpg (15.4 KB, 57 views)
__________________
StealthFox is offline   Reply With Quote
Reply


Thread Tools Search this Thread
Search this Thread:

Advanced Search

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

vB code is On
Smilies are On
[IMG] code is On
HTML code is Off


All times are GMT. The time now is 09:42 AM.


Donate

Affiliates
The Hubb http://bylur.com - Warcraft, StarCraft, Diablo and DotA Blog & Forums The JASS Vault Clan WEnW Campaign Creations Clan CBS GamesModding Flixreel Videos

Powered by vBulletin (Copyright ©2000 - 2014, Jelsoft Enterprises Ltd).
Hosted by www.OICcam.com
IT Support and Services provided by Executive IT Services