Yes, because you can get the source code to DBPro!
Without looking it up, I can tell you the math.
Basically, for DBPro's euler angles, you take a vector and FIRST rotate it around the X axis, then around the Y axis, then around the Z axis. Since each of those rotations can be expressed as rotation matrices, you can multiply a column vector by your X rotation matrix, then by y, then by Z. Eg, Z*Y*X*Vector=newVector
If you had a row vector it would be Vector*X*Y*Z, and the XYZ matrices would be a bit different. I prefer column vectors (for no particular reason other than they're what I usually use).
Really, what you need to know is that each individual rotation can be calculated as such:
When you multiply Z*Y*X, you get:
http://www.freeimagehosting.net/uploads/3b4c8dfbe1.png
so if we call that R, R*V is the new, rotated vector.
Now... for what rotation matrices represent.
Really, they are JUST a set of axes.If you notice, rotation matrices are
double orthogonal.
So, hold your left hand out, and raise your thumb, middle, and index finger so that they're all at 90 degrees to each other. This means that they are orthogonal. Your thumb is the x axis, your index finger is the y axis, and your middle finger is the Z axis. Move your hand so that your thumb is pointing right, your middle finger is pointing forward, and your index finger is pointing up. This is how DBPro does it.
Now imagine the origin is where your hand is. Try to come up with a position for the tips of each finger. The tip of your thumb, the X axis, would be at (1,0,0) (1 on the x axis), the tip of your index finger would be at (0,1,0), and the tip of your middle finger would be at (0,0,1).
now... if we make a matrix out of those, we get
X Y Z
[1 0 0]
[0 1 0]
[0 0 1]
An identity matrix!
Basically, a rotation matrix is EXACTLY like holding your hand out like I described above. When you rotate your hand, you wouldn't get nice values like 1,0,0, but you would get three vectors that are orthogonal, with length 1.
So, to move it forward, simply add the last column (Z vector) to the object's position! Since it's a unit vector, you can multiply it by the desired length before adding it to the position. The matrix has to be constructed anyways for rendering (though I don't think you can get direct access to it).
If your problem is turning yaw pitch roll angles into euler angles... that's kind of a tough one. First, you'll need to know if the yawpitchroll angles are right-handed or left-handed. Then, you'll need to construct the rotation matrix from the yaw pitch roll values, and turn the matrix back into euler angles. Luckily, there problem "How do I get euler angles from a matrix" has been solved a couple times before, here's a link to my use of someone elses solution
http://forum.thegamecreators.com/?m=forum_view&t=188692&b=1. I think he's right: my getM4Element function transposes the matrix, but then I transpose it right back. Pointless, but it works. Just keep that in mind if you use getM4Element for anything else xD
As far as finding the yaw pitch roll matrix... This page
http://planning.cs.uiuc.edu/node102.html gives a rotation matrix for a right-handed system, but DBPro and Direct3D both use left-handed coordinate systems. So...I think you can just rotate it 90 degrees about the X axis, and then flip the Z axis. That would look something like:
flip Z rotate 90 deg
[1 0 0] [1 0 0]
[0 1 0]*[0 0 -1]*Z*Y*X
[0 0 -1] [0 1 0]
[1 0 0]
[0 0 -1]*Z*Y*X
[0 -1 0]
Since we know Z*Y*X, you'd just have to flip some signs and what not to compute the matrix.
IN SUMMATION
To move an object forward given DBPro euler angles, just use the last row of that rotation matrix. (same for moving up or right)
To get DBPro euler angles from YPR angles, calculate the matrix as described above (I think), and then use my function to calculate the euler angles.
So... It's a lot if you're not already familiar with linear algebra, but some programming problems will be a lot easier after you know 3d linear algebra stuff.
[edit]
it's worth mentioning that matrix stuff makes transformations (rotation, scaling, mirroring, skewing, translation) painless, because once you describe everything in matrix form, you can use matrix rules involving determinants, factorization, inversion, eigenvalue stuff, and more to easily solve geometric problems.
Errm... "Painless" means conceptually, and only if you're already familiar with linear algebra. Programming it in DBPro is also annoying because there's no operator overloading (So sometimes even though your calculation is "C=A*B" for two matrices, you have to write out 30 lines of "C.M11=A.M11*B.M11+A.M12*B.M21+A.M13+B.M31")
