Question

I have a very rudimentary camera which generates 3 vectors for use with gluLookAt(...) the problem is I’m not sure if this is correct, I adapted code from something my lecturer showed us (I think he got it from somewhere).

This actually works until you spin the mouse round in circles than camera starts to rotate around the z-axis. Which shouldn’t happen as the mouse coords are only attached to the pitch and yaw not the roll.

Camera

// Camera.hpp

#ifndef MOOT_CAMERA_INCLUDE_HPP
#define MOOT_CAMERA_INCLUDE_HPP

#include <GL/gl.h>
#include <GL/glu.h>

#include <boost/utility.hpp>
#include <Moot/Platform.hpp>
#include <Moot/Vector3D.hpp>

namespace Moot
{
    class Camera : public boost::noncopyable
    {
    protected:

        Vec3f m_position, m_up, m_right, m_forward, m_viewPoint;
        uint16_t m_height, m_width;

    public:


        Camera()
        {
            m_forward = Vec3f(0.0f, 0.0f, -1.0f);
            m_right = Vec3f(1.0f, 0.0f, 0.0f);
            m_up = Vec3f(0.0f, 1.0f, 0.0f);
        }

        void setup(uint16_t setHeight, uint16_t setWidth)
        {
            m_height = setHeight;
            m_width = setWidth;
        }

        void move(float distance)
        {
            m_position += (m_forward * distance);
        }


        void addPitch(float setPitch)
        {
            m_forward = (m_forward * cos(setPitch) + (m_up * sin(setPitch)));
            m_forward.setNormal();

                    // Cross Product
            m_up = (m_forward / m_right) * -1;
        }


        void addYaw(float setYaw)
        {
            m_forward = ((m_forward * cos(setYaw)) - (m_right * sin(setYaw)));
            m_forward.setNormal();

                    // Cross Product
            m_right = m_forward / m_up;
        }


        void addRoll(float setRoll)
        {
            m_right = (m_right * cos(setRoll) + (m_up * sin(setRoll)));
            m_right.setNormal();

                    // Cross Product
            m_up = (m_forward / m_right) * -1;
        }

        virtual void apply() = 0;       

    }; // Camera
} // Moot

#endif

Snippet from update cycle

    // Mouse movement
    m_camera.addPitch((float)input().mouseDeltaY() * 0.001);
    m_camera.addYaw((float)input().mouseDeltaX() * 0.001);

apply() in the camera class is defined in an inherited class, which is called from the draw function of the game loop.

void apply()
        {
            glMatrixMode(GL_PROJECTION);  
            glLoadIdentity();
            gluPerspective(40.0,(GLdouble)m_width/(GLdouble)m_height,0.5,20.0);

            m_viewPoint = m_position + m_forward;

            gluLookAt(  m_position.getX(),  m_position.getY(),  m_position.getZ(),
                        m_viewPoint.getX(), m_viewPoint.getY(), m_viewPoint.getZ(),
                        m_up.getX(),        m_up.getY(),        m_up.getZ());
        }

Answer 1

Don’t accumulate the transforms in your vectors, store the angles and generate the vectors on-the-fly.

EDIT: Floating-point stability. Compare the output of a and b:

#include <iostream>

using namespace std;

int main()
{
    const float small = 0.00001;
    const unsigned int times = 100000;

    float a = 0.0f;
    for( unsigned int i = 0; i < times; ++i )
    {
        a += small;
    }
    cout << a << endl;

    float b = 0.0f;
    b = small * times;
    cout << b << endl;

    return 0;
}

Output:

1.00099
1