3d Open GL Game - How to fix a object to the camera =)

Hi guys! I have successfully created a Player class which shows a player ( lovely cow! ). However, I wanted to make the player be static in the screen, since I wanted to create a racing-supermario like game. Basically what I have now is a camera that goes around but I want to stick it to the player mesh.

Here is some code:

Camera look() function code

Code:

void CCamera::Look(){
    // Give openGL our camera position, then camera view, then camera up vector
    gluLookAt(m_vPosition.x, m_vPosition.y, m_vPosition.z,    
              m_vView.x,     m_vView.y,     m_vView.z,    
              m_vUpVector.x, m_vUpVector.y, m_vUpVector.z);

}

Player.h

Code:

#ifndef _PLAYER_H#define _PLAYER_H


#include "Model_3DS.h"


// This class was made to handle models created for player use.


class Player
{


    Model_3DS playerModel;




public:




    
    void LoadPlayer();  //Method to load player mesh
    void DrawPlayer();  //Method to draw player mesh
   


        Player();                                    // Constructor
    virtual ~Player();
    
};



 #endif

Player.cpp

Code:

#include "Player.h"

Player::Player()
{
     playerModel.scale = 3.0f;//Scale the model up
     playerModel.pos.x = 250.0f;//Set the x position
     playerModel.pos.y = 15;//Set the y position
     playerModel.pos.z = 400.0f;//Set the z position
}


Player::~Player()
{


}






void Player::LoadPlayer(){
    playerModel.Load("Data/3DS/SecondaryObjects/cow2.3ds"); // Load a 3ds model
}


void Player::DrawPlayer(){


    playerModel.Draw();//Draw tree model
    



};

I was thinking that I should call the position of the camera in the player position, but I am not so sure how

If somebody could give me a hand would be great!
Also, if you want to add me on skype so its quicker would be good too ^^: natalieberrystraw is my skype.

Thanks in advance! <3

Natalie xxx
Main.cpp
Camera.cppCamera.hAttachment 11143Player.cppPlayer.h

Natalie:

I'm a little unclear with what you ultimately want to accomplish. What I think you're asking is you want the camera to constantly be behind the player on screen? IE: if you turn right the camera will shift to be behind the player and face right?

Hey thanks for the reply! http://public.gamedev.net/public/sty...ault/smile.gif

Well, I just wanted to accomplishe a 3rd person view.

I found some other code that helped:

Added this on the camera.cpp:

Code:

void CCamera::RotateAroundPoint(CVector3 vCenter, float angle, float x, float y, float z)
{
    CVector3 vNewPosition;            

    // To rotate our position around a point, what we need to do is find
    // a vector from our position to the center point we will be rotating around.
    // Once we get this vector, then we rotate it along the specified axis with
    // the specified degree.  Finally the new vector is added center point that we
    // rotated around (vCenter) to become our new position.  That's all it takes.

    // Get the vVector from our position to the center we are rotating around
    CVector3 vPos = m_vPosition - vCenter;

    // Calculate the sine and cosine of the angle once
    float cosTheta = (float)cos(angle);
    float sinTheta = (float)sin(angle);

    // Find the new x position for the new rotated point
    vNewPosition.x  = (cosTheta + (1 - cosTheta) * x * x)        * vPos.x;
    vNewPosition.x += ((1 - cosTheta) * x * y - z * sinTheta)    * vPos.y;
    vNewPosition.x += ((1 - cosTheta) * x * z + y * sinTheta)    * vPos.z;

    // Find the new y position for the new rotated point
    vNewPosition.y  = ((1 - cosTheta) * x * y + z * sinTheta)    * vPos.x;
    vNewPosition.y += (cosTheta + (1 - cosTheta) * y * y)        * vPos.y;
    vNewPosition.y += ((1 - cosTheta) * y * z - x * sinTheta)    * vPos.z;

    // Find the new z position for the new rotated point
    vNewPosition.z  = ((1 - cosTheta) * x * z - y * sinTheta)    * vPos.x;
    vNewPosition.z += ((1 - cosTheta) * y * z + x * sinTheta)    * vPos.y;
    vNewPosition.z += (cosTheta + (1 - cosTheta) * z * z)        * vPos.z;

    // Now we just add the newly rotated vector to our position to set
    // our new rotated position of our camera.
    m_vPosition = vCenter + vNewPosition;
}

Then in the main.cpp I added the key states:

Code:

      // We made 2 changes from the Camera2 tutorial.  Instead of gCamera.RotateView()
    // we use our new RotateAroundPoint() function.  We pass in the camera's view
    // point.  This will be the point that we rotate our camera position around.
    
    if(GetKeyState(VK_LEFT) & 0x80) {            // If we hit the LEFT arrow key

        // We want to rotate around the Y axis so we pass in a positive Y speed
        g_Camera.RotateAroundPoint(g_Camera.m_vView, kSpeed, 0, 1, 0);    
    }

    if(GetKeyState(VK_RIGHT) & 0x80) {            // If we hit the RIGHT arrow key

        // Use a negative Y speed to rotate around the Y axis
        g_Camera.RotateAroundPoint(g_Camera.m_vView, -kSpeed, 0, 1, 0);    
    }

The only problem is that I added in the RenderScene() function

Code:

 gPlayer.DrawPlayer();      
   glTranslatef(g_Camera.m_vView.x, 0, g_Camera.m_vView.z);

However as you see above I have a player class, so I'm not so sure how to point glTranslatef to only the player..at the moment it compiles but the whole world turns around weirdly

Netalie xxx

No need for trigonometry, just push an identity matrix and apply a similar "glulookat()" or plain rotations( for player direction ), retrieve the front vector from the matrix( -mat[2], -mat[8], -mat[12] ) and subtract it from the player's position. There you have it, the camera is right behind the player! ( You may want to add something to Y coordinate in order to look at him with an angle. Much faster than trigonometry! )

Translate to the player position, translate on the look vector a negative camera distance or translate on the negative look vector a positive camera distance.

One thing to also consider -- building off of what GReaper just told you-- is if you want the camera fixed on the back of an object is to use gluLookAt combine with some (depending on how you feel about them) global variables relating to the object position and the camera position.

So say you want the camera to be sort of over the shoulder, behind the object... a la Mario Kart or any number of 3rd person view games.

Initialize a camera array variable with your starting positions, then initialize 2 more arrays that correspond to the object position and camera position. Then, when you move the object you update object position and camera position. Then, you can call gluLookAt() like this:

Code:

gluLookAt(camera[0], camera[1], camera[2],  obj[0], obj[1], obj[2],  0, 1, 0);

The camera is now fixed behind him. You can get fancy and have it track the object which you can probably figure out fairly easily based on the above.

Hi! this can be a solution, if you think its appropriate to implement with respect to the architecture you are making :S
You can implement a function in camera class, that takes an argument as Player. using this player, you can get the information about the position of you player in the scene... update you cameras position (in your case its : m_vPosition.x, m_vPosition.y, m_vPosition.z ) with respect to the player position... This should work... also, you will have to alter the camera position by taking care of dimension of the player.. hope I am making some sense..

Thanks,
NJ

If no over shoulder views are necessary and this is a simple 3rd person straight behind the player camera gluLookAt is overkill and wastes cycles.