Probleme de rotation

Question

bon voila je veux faire une camera comme dans un fps le probleme c'est
que je ne sait pas comment on fait des rotation autour des axes x et y
de la camera car mes rotation s'effectuent autour des axes de la carte

wxccxw · Answer

ah les math :) 
j'espere que tu est tres bon  en math :p et tres bon en OpenGL/D3d 
mais je vais te filer un truc tout fait :)

wxccxw · Answer

#include"CCamera.h"


CCamera::CCamera()
{
   // Initialize variables...
   mPos = CVector4(0.0f, 0.0f, 0.0f);
   mView = CVector4(0.0f, 0.0f, 0.0f);
   mUp = CVector4(0.0f, 0.0f, 0.0f);
   mStrafe = CVector4(0.0f, 0.0f, 0.0f);

   currentRotationAngle = 0.0f;
}


void CCamera::SetCamera(float x, float y, float z,
                        float xv, float yv, float zv,
                        float xu, float yu, float zu)
{
   // Here we set the camera to the values sent in to us.  This is mostly used to set up a
   // default position.
   mPos = CVector4(x, y, z);
   mView = CVector4(xv, yv, zv);
   mUp = CVector4(xu, yu, zu);
}

void CCamera::GetDirection(CVector4 &Direction)
{
   // The look direction is the view (where we are looking) minus the position (where we are).
   Direction = mView - mPos;
}


void CCamera::MoveCamera(float speed)
{
   // Moving the camera requires a little more then adding 1 to the z or subracting 1.
   // First we need to get the direction at which we are looking.
   CVector4 Direction;

   // Get the direction and store it in the object Direction.
   GetDirection(Direction);

   Direction.Normal();

   // Call UpdateCamera to move our camera in the direction we want.
   UpdateCamera(Direction, speed);

   // NOTE if the camera moves too slow try increasing the UP and DOWN values in the header.
   // The camera is frame based so it will move differently for you.
}


void CCamera::UpdateCamera(CVector4 Direction, float speed)
{
   // Move the camera on the X and Z axis.
mPos.x += Direction.x * speed;
   mPos.y += Direction.y * speed;
mPos.z += Direction.z * speed;

   // Move the view along with the position
mView.x += Direction.x * speed;
   mView.y += Direction.y * speed;
mView.z += Direction.z * speed;
}


void CCamera::StrafeCam(float speed)
{
   CalculateStrafe();                           // Calculate the straft direction.
   UpdateCamera(mStrafe, speed);                // Then add it to the camera's position.
}


void CCamera::CalculateStrafe()
{
   CVector4 Direction;
   CVector4 Cross;
   float magnitude = 0.0;

   // Strafing is just like moving the camera forward and backward.  First we will get the
   // direction we are looking.
   GetDirection(Direction);

   // Now if we were to call UpdateCamera() we will be moving the camera foward or backwards.
   // We don't want that here.  We want to strafe.  To do so we have to get the cross product
   // of our direction and Up direction view.  The up was set in SetCamera to be 1 positive
   // y.  That is because anything positive on the y is considered up.  After we get the
   // cross product we can save it to the strafe variables so that can be added to the
   // camera using UpdateCamera().

   // Get the cross product of the direction we are looking and the up direction.
   Cross.CrossProduct(Direction, mUp);

   // Normalize it.
   Cross.Normal();

   // Save our strafe (cross product) values in the mStrafe object.
   mStrafe = Cross;
}


void CCamera::RotateCamera(float AngleDir, CVector4 Speed)
{
   CVector4 newDir;
   CVector4 LookDirection;
   float CosineAngle, SineAngle = 0.0;

   // First we will need to calculate the cos and sine of our angle.  I created two macros to
   // do this in the CCamera.h header file called GET_COS and GET_SINE.  To use the macros
   // we just send in the variable we ant to store the results and the angle we need to
   // calculate.
GET_COS(CosineAngle, AngleDir);
   GET_SINE(SineAngle, AngleDir);

// Next get the look direction (where we are looking) just like in the move camera function.
   GetDirection(LookDirection);

// Calculate the new X position.
newDir.x = (CosineAngle + (1 - CosineAngle) * Speed.x) * LookDirection.x;
newDir.x += ((1 - CosineAngle) * Speed.x * Speed.y - Speed.z * SineAngle)* LookDirection.y;
newDir.x += ((1 - CosineAngle) * Speed.x * Speed.z + Speed.y * SineAngle) * LookDirection.z;

// Calculate the new Y position.
newDir.y = ((1 - CosineAngle) * Speed.x * Speed.y + Speed.z * SineAngle) * LookDirection.x;
newDir.y += (CosineAngle + (1 - CosineAngle) * Speed.y) * LookDirection.y;
newDir.y += ((1 - CosineAngle) * Speed.y * Speed.z - Speed.x * SineAngle) * LookDirection.z;

// Calculate the new Z position.
newDir.z = ((1 - CosineAngle) * Speed.x * Speed.z - Speed.y * SineAngle) * LookDirection.x;
newDir.z += ((1 - CosineAngle) * Speed.y * Speed.z + Speed.x * SineAngle) * LookDirection.y;
newDir.z += (CosineAngle + (1 - CosineAngle) * Speed.z) * LookDirection.z;


// Last we add the new rotations to the old view to correctly rotate the camera.
   mView = mPos + newDir;
}


void CCamera::RotateByMouse(int mousePosX, int mousePosY, int midX, int midY)
{
float yDirection = 0.0f;         // Direction angle.
float yRotation = 0.0f;          // Rotation angle.

// If the mouseX and mouseY are at the middle of the screen then we can't rotate the view.
if((mousePosX midX) && (mousePosY midY))
      return;

// Next we get the direction of each axis.  We divide by 1000 to get a smaller value back.
yDirection = (float)((midX - mousePosX)) / 1000.0f;		
yRotation = (float)((midY - mousePosY)) / 1000.0f;		

// We use curentRotX to help use keep the camera from rotating too far in either direction.
currentRotationAngle -= yRotation;  

// Stop the camera from going to high...
if(currentRotationAngle > 1.5f)
      {
   currentRotationAngle = 1.5f;
         return;
      }

// Stop the camera from going to low...
if(currentRotationAngle < -1.5f)
{
         currentRotationAngle = -1.5f;
         return;
      }

   // Next we get the axis which is a perpendicular vector of the view direction and up values.
   // We use the cross product of that to get the axis then we normalize it.
   CVector4 Axis;
   Axis.CrossProduct(mView - mPos, mUp);
   Axis.Normal();

   // Rotate the camera.
   RotateCamera(yRotation, CVector4(Axis.x, Axis.y, Axis.z));
   RotateCamera(yDirection, CVector4(0, 1, 0));
}

wxccxw · Answer

la haut ct CCamera.cpp et la 
CCamera.H



#ifndef CCAMERA_H
#define CCAMERA_H

#include<math.h>                          // Math header that allows us to use cos() and sin().
#include"CVector.h"                       // CVector3 class.

#define FORWARD         1.0               // Forward speed.
#define BACKWARD        -1.0              // Backward speed.
#define UP              0.03              // Up speed.
#define DOWN            -0.03             // Down speed.
#define LEFT            0.03              // Left speed.
#define RIGHT           -0.03             // Right speed.
#define STRAFE_LEFT     -1.0              // Left straft speed.
#define STRAFE_RIGHT    1.0               // Right straft speed.

#define GET_COS(a, b)   a = (float)cos(b) // Get the cos angle of b and store it in a.
#define GET_SINE(a, b)  a = (float)sin(b) // Get the sine angle of b and store it in a.


class CCamera
{
   public:
      CCamera();                                      // Constructor.

      void SetCamera(float x, float y, float z,       // Set the camera's position.
                     float xv, float yv, float zv,
                     float xu, float yu, float zu);

      void GetDirection(CVector4 &Direction);         // Get the view direction.
      void MoveCamera(float speed);                   // Move the camera forwards and backwards.
      void UpdateCamera(CVector4 Direction, float speed);// Update the camera's position.
      void StrafeCam(float speed);
      void CalculateStrafe();                            // Calculate the direction of the straft.
      void RotateCamera(float AngleDir, CVector4 Speed); // Rotate the camera around a point.
      void RotateByMouse(int mousePosX, int mousePosY, int midX, int midY);

      CVector4 mPos;                                  // Camera position.
      CVector4 mView;                                 // Look at position.
      CVector4 mUp;                                   // Up direction.
      CVector4 mStrafe;                               // Strafe direction.
      float currentRotationAngle;                     // Keeps us from going too far up or down.
};

#endif

wxccxw · Answer

http://www.ultimategameprogramming.com/zips/Gl_BspLoader.ZIP


et le lien complet :
Camera Style FPS, BSP loader (les maps BSP), texture et lumiere

cs_Mick7 · Answer

je vais essayer de comprendre mais en faite j'aimerai bien tester le loader mais je sais pas comment on link GLext.h

wxccxw · Answer

Tu telecharge OpenGL sur le site tu dezip les .h dans ton dossier Include, et les .lib dans le dossier lib ;) 

apres #include <GLext.h>
  et pour openGl lib si tu est sous VC++ tu fais #pragma comment(lib,"ta lib.lib")

sinon Projet->Option->Liens-> et tu ajout le opengl.lib

cs_Mick7 · Answer

Le probleme c'est que j'ai pas VC++ mais Dev-c++ si quelqu'un sait comment on link cette librairie...

Et sinon je voudrai juste qu'on m'explique mathematiquement comment on
change de repere, c'est plus interessant que d'avoir un truc deja tout
pret.

Utilisateur anonyme · Answer

Bonjour


Juste un petit rappel. Le code que l'on t'a proposé fonctionnera
pleinement si tu te contentes vraiment de tourner autour de 2 axes mais
si un jour, tu veux faire tourner un objet en fonction de 3 axes, cette
méthode ne marche pas. C'est due à une limitation de l'utilisation des
transformations Eulériennes. Cette limitation est appelée "verrou de
Cardan" et aussi "gimbal lock". J'ai eu beaucoup de problème à cause de
ça et il y a un tas d'inepsies qui circulent sur le net à propos des
façons de résoudre ce problème. Alors, si ça t'intéresse, fais moi
signe (je précise que j'ai fait vérifier mes travaux par plusieurs
professeurs d'informatique graphique).

yeah! vive java

Probleme de rotation

8 réponses

Votre réponse

Discussions similaires