Changeset 2778 for GTP


Ignore:
Timestamp:
06/19/08 18:07:09 (17 years ago)
Author:
mattausch
Message:

updated the camera model

Location:
GTP/trunk/App/Demos/Vis/CHC_revisited
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/App/Demos/Vis/CHC_revisited/Camera.cpp

    r2776 r2778  
    77{ 
    88 
     9using namespace std; 
     10 
    911 
    1012Camera::Camera()  
    … …  
    1315        mHeight = 100; 
    1416        mFovy = 90.0f * M_PI / 180.0f; 
     17        mIsOrtho = false; 
     18         
     19        SetPosition(Vector3(0, 0, 0)); 
     20 
     21        mPitch = mYaw = 0; 
     22        Precompute(); 
    1523} 
    1624 
    … …  
    2230         
    2331        mFovy = fieldOfView * M_PI / 180.0f; 
     32 
     33        mIsOrtho = false; 
     34 
     35        SetPosition(Vector3(0, 0, 0)); 
     36 
     37        SetPosition(Vector3(0, 0, 0)); 
     38 
     39        mPitch = mYaw = 0; 
     40        Precompute(); 
    2441} 
    2542 
    … …  
    2744void Camera::Precompute()  
    2845{ 
    29         mDirection.Normalize(); 
    30  
    31         //Vector3 side = CrossProd(Vector3(0, 1, 0), mDirection); 
    32         Vector3 side = CrossProd(Vector3(0, 0, 1), mDirection); 
    33          
    34         mUp = -Normalize(CrossProd(side, mDirection)); 
    35         mRight = -Normalize(CrossProd(mDirection, mUp)); 
    36  
    37  
    38         float k = tan(mFovy/2); 
    39         mUp *= k; 
    40         mRight *= k*mWidth/mHeight; 
    41 } 
     46        Vector3 direction = Vector3(0, 1, 0); 
     47 
     48        Vector3 side = CrossProd(Vector3(1, 0, 0), direction); 
     49         
     50        Vector3 up = -Normalize(CrossProd(side, direction)); 
     51        Vector3 right = -Normalize(CrossProd(direction, up)); 
     52 
     53        mBaseOrientation = Matrix4x4(right, up, direction); 
     54        mViewOrientation = mBaseOrientation; 
     55} 
     56 
    4257 
    4358 
    … …  
    4560{ 
    4661        mPosition = pos; 
    47         Precompute(); 
    48 } 
    49  
    50  
    51 void Camera::SetDirection(const Vector3 &dir)  
    52 { 
    53         mDirection = dir; 
    54         Precompute(); 
    5562} 
    5663 
    … …  
    5966{ 
    6067        mNear = nearDist; 
    61 } 
    62  
    63  
    64 void Camera::LookInBox(const AxisAlignedBox3 &box) 
    65 { 
    66         //mDirection = Vector3(0, 0, 1); 
    67         mDirection = Vector3(0, 1, 0); 
    68         mPosition = box.Center(); 
    69         mPosition.z = box.Min(2) + 0.9f * box.Size(2); 
    70  
    71         Precompute(); 
    72 } 
    73  
    74  
    75 void Camera::LookAtBox(const AxisAlignedBox3 &box) 
    76 { 
    77         mDirection = Vector3(0, box.Min().y - box.Max().y, 0); 
    78         mPosition = Vector3(0);//box.Max() - mDirection; 
    79  
    80         Precompute(); 
    8168} 
    8269 
    … …  
    159146void Camera::SetupCameraView() 
    160147{ 
     148#if 1 
     149        //Matrix4x4 viewOrientation(mRight, mDirection, mUp); 
     150        //Matrix4x4 viewOrientation(mRight, mUp, mDirection); 
     151        Matrix4x4 tview = mViewOrientation; 
     152 
     153        //Vector3 pos = tview * mPosition; 
     154        Vector3 pos = -mPosition; 
     155        pos = tview * pos; 
     156 
     157        Debug << "vieworient:\n" << mViewOrientation << " pos " << pos << " position " << mPosition << endl; 
     158 
     159        Matrix4x4 viewOrientation = mViewOrientation; 
     160 
     161        viewOrientation.x[3][0] = pos.x; 
     162        viewOrientation.x[3][1] = pos.y; 
     163        viewOrientation.x[3][2] = pos.z; 
     164 
    161165        glLoadIdentity(); 
     166        glMultMatrixf((float *)viewOrientation.x); 
     167        //glMultMatrixf((float *)tm.x); 
     168        Debug << "matrix:\n" << viewOrientation << endl; 
     169#else 
     170        glLoadIdentity(); 
     171 
    162172        gluLookAt(mPosition.x, mPosition.y, mPosition.z, 
    163173                  mPosition.x + mDirection.x, mPosition.y + mDirection.y, mPosition.z + mDirection.z,  
    164174                          mUp.x, mUp.y, mUp.z); 
    165  
     175#endif 
    166176        //std::cout << "dir: " << mDirection << " pos: " << mPosition << " up: " << mUp << std::endl; 
    167177} 
    … …  
    180190        const float w_far = h_far * GetAspect(); 
    181191 
    182         const Vector3 view = mDirection; 
     192        const Vector3 view = GetDirection(); 
    183193        const Vector3 fc = mPosition + view * z_far;  
    184194         
    185         const Vector3 up = mUp; 
    186  
    187         const Vector3 right = mRight; 
     195        const Vector3 up = GetUpVector(); 
     196 
     197        const Vector3 right = GetRightVector(); 
    188198 
    189199        Vector3 t1, t2; 
    … …  
    197207        fbr = fc - t1 + t2; 
    198208 
    199         const Vector3 nc = mPosition + mDirection * z_near; 
     209        const Vector3 nc = mPosition + view * z_near; 
    200210         
    201211        t1 = h_near * 0.5f * up; 
    … …  
    209219 
    210220 
    211 } 
    212  
     221void Camera::SetOrtho(bool ortho) 
     222{ 
     223        mIsOrtho = true; 
     224} 
     225 
     226 
     227void Camera::Yaw(float angle) 
     228{ 
     229        mYaw += angle; 
     230        CalculateFromPitchAndYaw(); 
     231        /* 
     232        Matrix4x4 viewOrientation(mRight, mUp, mDirection); 
     233        Matrix4x4 rot = RotationYMatrix(angle); 
     234 
     235        viewOrientation = viewOrientation * rot; 
     236 
     237        mDirection = Vector3(viewOrientation.x[2][0], viewOrientation.x[2][1], viewOrientation.x[2][2]); 
     238        mRight =     Vector3(viewOrientation.x[0][0], viewOrientation.x[0][1], viewOrientation.x[0][2]); 
     239        mUp =        Vector3(viewOrientation.x[1][0], viewOrientation.x[1][1], viewOrientation.x[1][2]);*/ 
     240} 
     241 
     242 
     243void Camera::Pitch(float angle) 
     244{ 
     245        mPitch += angle; 
     246        CalculateFromPitchAndYaw(); 
     247} 
     248 
     249 
     250void Camera::CalculateFromPitchAndYaw() 
     251{ 
     252        mViewOrientation = mBaseOrientation; 
     253 
     254        Matrix4x4 roty = RotationYMatrix(mPitch); 
     255        Matrix4x4 rotx = RotationXMatrix(mYaw); 
     256 
     257        mViewOrientation *= roty; 
     258        mViewOrientation *= rotx; 
     259} 
     260 
     261 
     262Vector3 Camera::GetDirection() const 
     263{  
     264        return Vector3(mViewOrientation.x[0][2], mViewOrientation.x[1][2], mViewOrientation.x[2][2]); 
     265} 
     266 
     267 
     268Vector3 Camera::GetUpVector() const  
     269{  
     270        return Vector3(mViewOrientation.x[0][1], mViewOrientation.x[1][1], mViewOrientation.x[2][1]); 
     271} 
     272 
     273 
     274Vector3 Camera::GetRightVector() const  
     275{  
     276        return Vector3(mViewOrientation.x[0][0], mViewOrientation.x[1][0], mViewOrientation.x[2][0]); 
     277                 
     278} 
     279 
     280 
     281} 
     282 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/Camera.h

    r2776 r2778  
    2020        { 
    2121                /// the 6 clip planes 
    22                 //float mClipPlane[6][4]; 
    2322                Plane3 mClipPlanes[6]; 
    2423 
    … …  
    3029        Camera(int width, int height, float fieldOfView = 90.f); 
    3130 
    32         void Precompute(); 
    33  
    34         void LookInBox(const AxisAlignedBox3 &box); 
    35  
    36         void LookAtBox(const AxisAlignedBox3 &box); 
    3731 
    3832        void SetPosition(const Vector3 &pos); 
    3933 
    40         void SetDirection(const Vector3 &dir); 
    41  
    4234        inline Vector3 GetPosition() const { return mPosition; } 
    43         inline Vector3 GetDirection() const { return mDirection; } 
    44         inline Vector3 GetUpVector() const { return mUp; } 
    45         inline Vector3 GetRightVector() const { return mRight; } 
     35        Vector3 GetDirection() const; 
     36        Vector3 GetUpVector() const; 
     37        Vector3 GetRightVector() const; 
    4638 
    4739        inline float GetFov() const { return mFovy; } 
    … …  
    6052        inline float GetNear() const { return mNear; } 
    6153        void SetNear(float nearDist); 
     54         
     55        inline float GetFar() const { return mFar; } 
     56 
     57        void SetFar(float farDist) { mFar = farDist; } 
     58 
     59        void SetOrtho(bool ortho); 
     60 
     61        void Yaw(float angle); 
     62        void Pitch(float angle); 
     63        /** Sets up viewing in gl 
     64        */ 
     65        void Render(); 
    6266 
    6367 
    6468protected: 
    6569 
     70        void Precompute(); 
     71 
     72        void CalculateFromPitchAndYaw(); 
     73 
    6674        //////////////// 
    6775 
    68         Vector3 mPosition; 
    69         Vector3 mDirection; 
    70  
    71         /// up vector takes into account the FOV at a unit distance from the origin 
    72         Vector3 mUp; 
    73         /// right vector takes into account the FOV at a unit distance from the origin 
    74         Vector3 mRight; 
    7576 
    7677        float mFovy; 
    … …  
    7980 
    8081        float mNear; 
     82 
     83        float mFar; 
     84 
     85        bool mIsOrtho; 
     86 
     87        Matrix4x4 mBaseOrientation; 
     88        Matrix4x4 mViewOrientation; 
     89 
     90        float mPitch; 
     91        float mYaw; 
     92 
     93        Vector3 mPosition; 
    8194}; 
    8295 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/SceneQuery.cpp

    r2776 r2778  
    33#include "Vector3.h" 
    44#include "Camera.h" 
     5#include "SceneQuery.h" 
     6#include "RenderTraverser.h" 
    57 
    68 
    … …  
    2022 
    2123 
    22 SceneQuery::SceneQuery(const AxisAlignedBox3 &sceneBox):  
     24SceneQuery::SceneQuery(const AxisAlignedBox3 &sceneBox, RenderTraverser *renderer):  
    2325mSceneBox(sceneBox) 
    2426{ 
    25         Prepare(); 
     27        Prepare(renderer); 
    2628} 
    2729 
    … …  
    4547} 
    4648 
    47 void SceneQuery::Prepare() 
     49 
     50void SceneQuery::Prepare(RenderTraverser *renderer) 
    4851{ 
    4952        cout << "Preparing scene queries" << endl; 
    … …  
    5659        pos.z = mSceneBox.Center(2); 
    5760 
    58         Camera *orthoCam = new Camera(); 
    59         //orthoCam->SetOrtho(true); 
    60  
    61         // contain match scene bounding box; 
    62  
    6361        // for ortho cam this is the width 
    6462        const Vector3 len = mSceneBox.Size(); 
    65 /* 
    66         orthoCam->SetFov(len.x); 
    67         orthoCam->SetAspect(len.x / len.y); 
     63 
     64        Camera *orthoCam = new Camera(len.x, len.y); 
     65        orthoCam->SetOrtho(true); 
    6866 
    6967        orthoCam->SetNear(0.0f); 
    … …  
    7270        orthoCam->SetPosition(pos); 
    7371 
    74         OUT1("fov: " << orthoCam->GetFov()); 
    75         OUT1("near: " << orthoCam->GetNear()); 
    76         OUT1("far: " << orthoCam->GetFar()); 
    77         OUT1("aspect: " << orthoCam->GetAspect()); 
     72        cout << "fov: " << orthoCam->GetFov() << endl; 
     73        cout << "near: " << orthoCam->GetNear() << endl; 
     74        cout << "far: " << orthoCam->GetFar() << endl; 
     75        cout << "aspect: " << orthoCam->GetAspect() << endl; 
    7876 
    79         OUT1("pos: " << orthoCam->GetPosition()); 
    80         OUT1("view: " << orthoCam->GetViewDirection()); 
    81         OUT1("up: " << orthoCam->GetViewUpVector()); 
     77        cout << "pos: " << orthoCam->GetPosition() << endl; 
     78        cout << "view: " << orthoCam->GetDirection() << endl; 
     79        cout << "up: " << orthoCam->GetUpVector() << endl; 
    8280 
    83         const float pitch = 0; 
    84         const float yaw = YA_PI * 0.5f; 
     81        //orthoCam->SetDirection(Vector3(0, 1, 0)); 
     82        orthoCam->Yaw(M_PI * 0.5f); 
    8583         
    86         OffscreenRenderArea *of = new OffscreenRenderArea(); 
     84        renderer->SetCamera(orthoCam); 
    8785 
    88         of->Init(viewport[2], viewport[3]); 
    89         of->SetRenderAction(new GLRenderAction); 
    90          
    91         of->SetCamera(orthoCam); 
    92         of->SetSceneRoot(mSceneRoot); 
    93          
    94         of->Render(); 
     86        //OffscreenRenderArea *of = new OffscreenRenderArea(); 
     87        //of->Init(viewport[2], viewport[3]); 
    9588 
    96         sDepth = of->GetDepthFloat(); 
    97         */ 
     89        renderer->RenderScene(); 
     90        //sDepth = of->GetDepthFloat(); 
     91 
     92        delete orthoCam; 
    9893} 
    9994 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/SceneQuery.h

    r2776 r2778  
    88{ 
    99 
     10class RenderTraverser; 
     11 
     12 
    1013/** A simple class that computes the first intersection of a horizontal ray with 
    1114        the scene. Can be used to "drop" objects in the scene. 
    … …  
    1518public: 
    1619 
    17         SceneQuery(const AxisAlignedBox3 &sceneBox); 
     20        SceneQuery(const AxisAlignedBox3 &sceneBox, RenderTraverser *traverser); 
    1821 
    1922        bool CalcIntersection(Vector3 &pt); 
    2023 
     24 
    2125protected: 
    2226 
    23         void Prepare(); 
     27        void Prepare(RenderTraverser *traverser); 
    2428 
    2529 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/chc_revisited.vcproj

    r2776 r2778  
    190190        <Files> 
    191191                <Filter 
    192                         Name="utils" 
     192                        Name="util" 
    193193                        > 
    194194                        <File 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/chcdemo.cpp

    r2776 r2778  
    163163        //camera->LookInBox(bvh->GetBox()); 
    164164 
    165         camera->SetDirection(Vector3(0.961829f, 0.273652f, 0.0f)); 
     165        //camera->SetDirection(Vector3(0.961829f, 0.273652f, 0.0f)); 
     166        //camera->SetDirection(Vector3(0.0f, 1.0f, 0.0f)); 
    166167        camera->SetPosition(Vector3(483.398f, 242.364f, 186.078f)); 
    167168 
    … …  
    488489        case 'A': 
    489490                { 
    490                         Vector3 viewDir = camera->GetDirection(); 
    491                         // rotate view vector 
    492                         Matrix4x4 rot = RotationZMatrix(keyRotation); 
    493                         viewDir = rot * viewDir; 
    494                         camera->SetDirection(viewDir); 
     491                        camera->Pitch(keyRotation); 
    495492                } 
    496493                break; 
    … …  
    498495        case 'D': 
    499496        { 
    500                         Vector3 viewDir = camera->GetDirection(); 
    501                         // rotate view vector 
    502                         Matrix4x4 rot = RotationZMatrix(-keyRotation); 
    503                         viewDir = rot * viewDir; 
    504                         camera->SetDirection(viewDir); 
     497                        camera->Pitch(-keyRotation); 
    505498                } 
    506499                break; 
    507500        case 'w': 
    508501        case 'W': 
     502                { 
     503                        Vector3 pos = camera->GetPosition(); 
     504                        pos -= hvec * keyForwardMotion; 
     505                        camera->SetPosition(pos); 
     506                } 
     507                break; 
     508        case 'x': 
     509        case 'X': 
    509510                { 
    510511                        Vector3 pos = camera->GetPosition(); 
    … …  
    513514                } 
    514515                break; 
    515         case 'x': 
    516         case 'X': 
    517                 { 
    518                         Vector3 pos = camera->GetPosition(); 
    519                         pos -= hvec * keyForwardMotion; 
    520                         camera->SetPosition(pos); 
    521                 } 
    522                 break; 
    523516        case 'r': 
    524517        case 'R': 
    … …  
    547540        case GLUT_KEY_LEFT: 
    548541                { 
    549                         Vector3 viewDir = camera->GetDirection(); 
    550                         // rotate view vector 
    551                         Matrix4x4 rot = RotationZMatrix(keyRotation); 
    552                         viewDir = rot * viewDir; 
    553                         camera->SetDirection(viewDir); 
     542                        camera->Pitch(keyRotation); 
    554543                } 
    555544                break; 
    556545        case GLUT_KEY_RIGHT: 
    557546                { 
    558                         Vector3 viewDir = camera->GetDirection(); 
    559                         // rotate view vector 
    560                         Matrix4x4 rot = RotationZMatrix(-keyRotation); 
    561                         viewDir = rot * viewDir; 
    562                         camera->SetDirection(viewDir); 
     547                        camera->Pitch(-keyRotation); 
    563548                } 
    564549                break; 
    565550        case GLUT_KEY_UP: 
     551                { 
     552                        Vector3 pos = camera->GetPosition(); 
     553                        pos -= hvec * 0.6f; 
     554                        camera->SetPosition(pos); 
     555                } 
     556                break; 
     557        case GLUT_KEY_DOWN: 
    566558                { 
    567559                        Vector3 pos = camera->GetPosition(); 
    568560                        pos += hvec * 0.6f; 
    569                         camera->SetPosition(pos); 
    570                 } 
    571                 break; 
    572         case GLUT_KEY_DOWN: 
    573                 { 
    574                         Vector3 pos = camera->GetPosition(); 
    575                         pos -= hvec * 0.6f; 
    576561                        camera->SetPosition(pos); 
    577562                } 
    … …  
    641626void leftMotion(int x, int y)  
    642627{ 
    643         static float eyeXAngle = 0.0f; 
    644  
    645628        Vector3 viewDir = camera->GetDirection(); 
    646629        Vector3 pos = camera->GetPosition(); 
    … …  
    649632        Vector3 horView(viewDir[0], viewDir[1], 0); 
    650633         
    651         eyeXAngle = 0.2f *  M_PI * (xEyeBegin - x) / 180.0; 
    652  
    653         // rotate view vector 
    654         Matrix4x4 rot = RotationZMatrix(eyeXAngle); 
    655         viewDir = rot * viewDir; 
    656  
    657         pos += horView * (yMotionBegin - y) * 0.2f; 
    658  
    659         camera->SetDirection(viewDir); 
     634        float eyeXAngle = 0.2f *  M_PI * (xEyeBegin - x) / 180.0; 
     635 
     636        camera->Pitch(eyeXAngle); 
     637 
     638        pos -= horView * (yMotionBegin - y) * 0.2f; 
     639         
    660640        camera->SetPosition(pos); 
    661641         
    … …  
    672652void rightMotion(int x, int y)  
    673653{ 
    674         static float eyeYAngle = 0.0f; 
    675  
    676         Vector3 viewDir = camera->GetDirection(); 
    677         Vector3 right = camera->GetRightVector(); 
    678  
    679         eyeYAngle = -0.2f *  M_PI * (yEyeBegin - y) / 180.0; 
    680  
    681         // rotate view vector 
    682         Matrix4x4 rot = RotationAxisMatrix(right, eyeYAngle); 
    683         viewDir = rot * viewDir; 
    684  
    685         camera->SetDirection(viewDir); 
    686                  
     654        float eyeYAngle = -0.2f *  M_PI * (yEyeBegin - y) / 180.0; 
     655 
     656        camera->Yaw(eyeYAngle); 
     657         
    687658        yEyeBegin = y; 
    688659         
    … …  
    706677        rVec = rot * rVec; 
    707678         
    708         pos -= rVec * (x - horizontalMotionBegin) * 0.1f; 
     679        pos += rVec * (x - horizontalMotionBegin) * 0.1f; 
    709680        //pos[1] += (verticalMotionBegin - y) * 0.1f; 
    710681        pos[2] += (verticalMotionBegin - y) * 0.1f; 
    … …  
    799770        //////////// 
    800771        // --- visualization of the occlusion culling 
     772 
    801773        visualization->Render(); 
    802774         
Note: See TracChangeset for help on using the changeset viewer.