Followers 0

DX11 convert code from dx11 to dx9

1 post in this topic

can anyone do me a favour and convert this code to directx 9 , i dont understand dx 11 at all and need to get this code working in a dx9 application , thanks alot.

[code]
void MoveChar(double time, XMVECTOR&amp; destinationDirection, XMMATRIX&amp; worldMatrix)
{
// Normalize our destinated direction vector
destinationDirection = XMVector3Normalize(destinationDirection);
// If character is currently facing the complete opposite direction as the desired direction
// they will turn around VERY slowly, so we want to make sure they turn around at a normal speed
// by making the old character direction not the exact opposite direction as the current character
// position. Try commenting out the next two lines to see what i'm talking about
if(XMVectorGetX(XMVector3Dot(destinationDirection, oldCharDirection)) == -1)
oldCharDirection += XMVectorSet(0.02f, 0.0f, -0.02f, 0.0f);
// Get our current characters position in the world, from it's world matrix
charPosition = XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f);
charPosition = XMVector3TransformCoord(charPosition, worldMatrix);
// Rotate our character smoothly when changing direction (from the GPG series)
float destDirLength = 10.0f * frameTime; // Change to the speed you want your character to rotate. This uses the game timer from an earlier lesson
// The larget this value, the faster the character rotates
currCharDirection = (oldCharDirection) + (destinationDirection * destDirLength); // Get the characters direction (based off time, old position, and desired
// direction), by adding together the current direction and the old direction
// to get vector that smoothly turns from oldCharDir to denstinationDirection
currCharDirection = XMVector3Normalize(currCharDirection); // Normalize the characters current direction vector
// Here we find the angle of our character (angle between current direction and world's normal vector), used so that we can actually rotate
// our characters world matrix. The three lines below, together, find the angle between 0 PI and 2 PI (360 degrees, and technically, it returns
// the degrees in radians from -1 PI to 1 PI, but that has the same effect as 0 PI to 2 PI) between two vectors.
// XMVector3AngleBetweenNormals returns an angle between two vectors, but always a positive result between
// 0 and 1 PI. Which means, it doesn't tell us which half of the 2 PI degrees that are possible. So, we have the next if statement below,
// which crosses the current characters direction and the worlds forward (0,0,1), which should give us the y axis vector (assuming that our character
// rotates on the xz plane). We check to see if the y vector is positive ( > 0.0f), and if it is, we set the characters direction angle to be
// the opposite of what it currently is, giving us the result in -1 PI to 1 PI.
float charDirAngle = XMVectorGetX(XMVector3AngleBetweenNormals( XMVector3Normalize(currCharDirection), XMVector3Normalize(DefaultForward)));
if(XMVectorGetY(XMVector3Cross(currCharDirection, DefaultForward)) > 0.0f)
charDirAngle = -charDirAngle;
// Now we update our characters position based off the frame time, his old position, and the direction he is facing
float speed = 15.0f * frameTime;
charPosition = charPosition + (destinationDirection * speed);
// Update characters world matrix
XMMATRIX rotationMatrix;
Scale = XMMatrixScaling( 0.25f, 0.25f, 0.25f );
Translation = XMMatrixTranslation(XMVectorGetX(charPosition), 0.0f, XMVectorGetZ(charPosition) );
rotationMatrix = XMMatrixRotationY(charDirAngle - 3.14159265f); // Subtract PI from angle so the character doesn't run backwards
worldMatrix = Scale * rotationMatrix * Translation;
// Set the characters old direction
oldCharDirection = currCharDirection;
// Update our animation
float timeFactor = 1.0f; // You can speed up or slow down time by changing this
UpdateMD5Model(NewMD5Model, time*timeFactor, 0);
}

void UpdateCamera()
{
// Rotate target around camera
/*camRotationMatrix = XMMatrixRotationRollPitchYaw(camPitch, camYaw, 0);
camTarget = XMVector3TransformCoord(DefaultForward, camRotationMatrix );
camTarget = XMVector3Normalize(camTarget);*/
/*XMMATRIX RotateYTempMatrix;
RotateYTempMatrix = XMMatrixRotationY(camYaw);
// Walk
camRight = XMVector3TransformCoord(DefaultRight, RotateYTempMatrix);
camForward = XMVector3TransformCoord(DefaultForward, RotateYTempMatrix);
camUp = XMVector3Cross(camForward, camRight);*/
/*// Free Cam
camRight = XMVector3TransformCoord(DefaultRight, camRotationMatrix);
camForward = XMVector3TransformCoord(DefaultForward, camRotationMatrix);
camUp = XMVector3Cross(camForward, camRight);*/
/*camPosition += moveLeftRight*camRight;
camPosition += moveBackForward*camForward;
moveLeftRight = 0.0f;
moveBackForward = 0.0f;
camTarget = camPosition + camTarget;*/
// Third Person Camera
// Set the cameras target to be looking at the character.
camTarget = charPosition;
// This line is because this lessons model was set to stand on the point (0,0,0) (my bad), and we
// don't want to just be looking at the models feet, so we move the camera's target vector up 5 units
camTarget = XMVectorSetY(camTarget, XMVectorGetY(camTarget)+5.0f);
// Unlike before, when we rotated the cameras target vector around the cameras position,
// we are now rotating the cameras position around it's target (which is the character)
// Rotate camera around target
camRotationMatrix = XMMatrixRotationRollPitchYaw(-camPitch, camYaw, 0);
camPosition = XMVector3TransformNormal(DefaultForward, camRotationMatrix );
camPosition = XMVector3Normalize(camPosition);
// Set our cameras position to rotate around the character. We need to add 5 to the characters
// position's y axis because i'm stupid and modeled the character in the 3d modeling program
// to be "standing" on (0,0,0), instead of centered around it ;) Well target her head here though
camPosition = (camPosition * charCamDist) + camTarget;
// We need to set our cameras forward and right vectors to lay
// in the worlds xz plane, since they are the vectors we will
// be using to determine the direction our character is running
camForward = XMVector3Normalize(camTarget - camPosition); // Get forward vector based on target
camForward = XMVectorSetY(camForward, 0.0f); // set forwards y component to 0 so it lays only on
// the xz plane
camForward = XMVector3Normalize(camForward);
// To get our camera's Right vector, we set it's x component to the negative z component from the
// camera's forward vector, and the z component to the camera forwards x component
camRight = XMVectorSet(-XMVectorGetZ(camForward), 0.0f, XMVectorGetX(camForward), 0.0f);
// Our camera does not "roll", so we can safely assume that the cameras right vector is always
// in the xz plane, so to get the up vector, we just get the normalized vector from the camera
// position to the cameras target, and cross it with the camera's Right vector
camUp =XMVector3Normalize(XMVector3Cross(XMVector3Normalize(camPosition - camTarget), camRight));
camView = XMMatrixLookAtLH( camPosition, camTarget, camUp );
}
[/code] Edited by Anddos
0

Share on other sites
Where is the D3D 11 part?

The code is just about vector manipulation. MSDN has quite good documentation of each function. I think that those functions should work with D3D9 also.

Cheers!
1

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Followers 0

• Similar Content

• Hi Guys,
I am revisiting an old DX11 framework I was creating a while back and am scratching my head with a small issue.
I am trying to set the pixel shader resources and am getting the following error on every loop.
As you can see in the below code, I am clearing out the shader resources as per the documentation. (Even going overboard and doing it both sides of the main PSSet call). But I just can't get rid of the error. Which results in the render target not being drawn.
ID3D11ShaderResourceView* srv = { 0 }; d3dContext->PSSetShaderResources(0, 1, &srv); for (std::vector<RenderTarget>::iterator it = rtVector.begin(); it != rtVector.end(); ++it) { if (it->szName == name) { //std::cout << it->srv <<"\r\n"; d3dContext->PSSetShaderResources(0, 1, &it->srv); break; } } d3dContext->PSSetShaderResources(0, 1, &srv);
I am storing the RT's in a vector and setting them by name. I have tested the it->srv and am retrieving a valid pointer.
At this stage I am out of ideas.
Any help would be greatly appreciated

• hi, guys, how to understand the math used in CDXUTDirectionWidget ::UpdateLightDir
the  following code snippet is taken from MS DXTU source code

D3DXMATRIX mInvView;
D3DXMatrixInverse( &mInvView, NULL, &m_mView );
mInvView._41 = mInvView._42 = mInvView._43 = 0;
D3DXMATRIX mLastRotInv;
D3DXMatrixInverse( &mLastRotInv, NULL, &m_mRotSnapshot );
D3DXMATRIX mRot = *m_ArcBall.GetRotationMatrix();
m_mRotSnapshot = mRot;
// Accumulate the delta of the arcball's rotation in view space.
// Note that per-frame delta rotations could be problematic over long periods of time.
m_mRot *= m_mView * mLastRotInv * mRot * mInvView;
// Since we're accumulating delta rotations, we need to orthonormalize
// the matrix to prevent eventual matrix skew
D3DXVECTOR3* pXBasis = ( D3DXVECTOR3* )&m_mRot._11;
D3DXVECTOR3* pYBasis = ( D3DXVECTOR3* )&m_mRot._21;
D3DXVECTOR3* pZBasis = ( D3DXVECTOR3* )&m_mRot._31;
D3DXVec3Normalize( pXBasis, pXBasis );
D3DXVec3Cross( pYBasis, pZBasis, pXBasis );
D3DXVec3Normalize( pYBasis, pYBasis );
D3DXVec3Cross( pZBasis, pXBasis, pYBasis );

https://github.com/Microsoft/DXUT/blob/master/Optional/DXUTcamera.cpp
• By YixunLiu
Hi,
I have a surface mesh and I want to use a cone to cut a hole on the surface mesh.
Anybody know a fast method to calculate the intersected boundary of these two geometries?

Thanks.

YL

• By hiya83
Hi, I tried searching for this but either I failed or couldn't find anything. I know there's D11/D12 interop and there are extensions for GL/D11 (though not very efficient). I was wondering if there's any Vulkan/D11 or Vulkan/D12 interop?
Thanks!

• Hi Guys,
I am just wondering if it is possible to acquire the address of the backbuffer if an API (based on DX11) only exposes the 'device' and 'context' pointers?
Any advice would be greatly appreciated

• 19
• 14
• 23
• 11
• 28