Changeset 2476


Ignore:
Timestamp:
Feb 24, 2013, 2:58:50 PM (6 years ago)
Author:
sam
Message:

scene: start refactoring the camera code; we now have a stack of cameras
in the scene where we can push and pop cameras.

Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/camera.cpp

    r2294 r2476  
    2727{
    2828
    29 Camera::Camera(vec3 const &position, vec3 const &target, vec3 const &up)
    30   : m_target(target),
    31     m_up(up)
     29Camera::Camera()
    3230{
    3331    m_gamegroup = GAMEGROUP_BEFORE;
     
    3533
    3634    /* Create a default perspective */
    37     SetPerspective(45.f, 800.f, 600.f, -1000.f, 1000.f);
    38     SetPosition(position);
     35    SetProjection(mat4::perspective(45.f, 800.f, 600.f, -1000.f, 1000.f));
     36    SetView(mat4::lookat(vec3(0.f, 50.f, 50.f),
     37                         vec3(0.f),
     38                         vec3(0.f, 1.f, 0.f)));
    3939}
    4040
     
    4343}
    4444
    45 void Camera::SetPosition(vec3 const &pos)
     45void Camera::SetView(mat4 const &view)
    4646{
     47    m_view_matrix = view;
     48    m_position = inverse(view)[3].xyz;
     49}
     50
     51void Camera::SetView(vec3 eye, vec3 target, vec3 up)
     52{
     53    m_view_matrix = mat4::lookat(eye, target, up);
     54    m_position = eye;
     55}
     56
     57void Camera::SetView(vec3 pos, quat rot)
     58{
     59    m_view_matrix = mat4::lookat(pos,
     60                                 pos + rot.transform(vec3(0.f, 0.f, -1.f)),
     61                                 rot.transform(vec3(0.f, 1.f, 0.f)));
    4762    m_position = pos;
    4863}
    4964
    50 void Camera::SetRotation(quat const &rot)
     65void Camera::SetProjection(mat4 const &proj)
    5166{
    52     m_rotation = rot;
     67    m_proj_matrix = proj;
    5368}
    5469
    55 void Camera::SetOrtho(float width, float height, float near, float far)
     70mat4 Camera::GetView()
    5671{
    57     m_proj_matrix = mat4::ortho(width, height, near, far);
     72    return m_view_matrix;
    5873}
    5974
    60 void Camera::SetPerspective(float fov, float width, float height,
    61                             float near, float far)
     75mat4 Camera::GetProjection()
    6276{
    63     m_proj_matrix = mat4::perspective(fov, width, height, near, far);
     77    return m_proj_matrix;
    6478}
    6579
    66 void Camera::SetTarget(vec3 const &pos)
    67 {
    68     m_target = pos;
    69 }
    70 
    71 vec3 Camera::GetTarget()
    72 {
    73     return m_target;
    74 }
    7580vec3 Camera::GetPosition()
    7681{
     
    7883}
    7984
    80 mat4 const &Camera::GetViewMatrix()
    81 {
    82     return m_view_matrix;
    83 }
    84 
    85 mat4 const &Camera::GetProjMatrix()
    86 {
    87     return m_proj_matrix;
    88 }
    89 
    90 void Camera::ForceSceneUpdate()
    91 {
    92     Scene::GetDefault()->SetViewMatrix(m_view_matrix);
    93     Scene::GetDefault()->SetProjMatrix(m_proj_matrix);
    94 }
    95 
    9685void Camera::TickGame(float seconds)
    9786{
    9887    WorldEntity::TickGame(seconds);
    99 
    100 #if 0
    101     /* Hackish keyboard support */
    102     float updown = 2.f * (Input::GetButtonState('w')
    103                            + Input::GetButtonState('z')
    104                            - Input::GetButtonState('s'));
    105     float rightleft = 2.f * (Input::GetButtonState('d')
    106                               - Input::GetButtonState('q')
    107                               - Input::GetButtonState('a'));
    108     float pgupdown = 2.f * (Input::GetButtonState('r')
    109                              - Input::GetButtonState('f'));
    110 
    111     /* Hackish stick support */
    112     static Stick *stick = NULL;
    113     if (!stick)
    114         stick = Input::TrackStick();
    115     if (stick && stick->GetAxisCount() >= 2)
    116     {
    117         rightleft += 2.f * stick->GetAxis(0) * std::abs(stick->GetAxis(0));
    118         updown += -2.f * stick->GetAxis(1) * std::abs(stick->GetAxis(1));
    119     }
    120 
    121     m_position += vec3(rightleft, pgupdown, -updown) * 200.f * seconds;
    122     m_target += vec3(rightleft, 0, -updown) * 200.f * seconds;
    123 
    124 #endif
    125     m_view_matrix = mat4::lookat(m_position, m_target, m_up)
    126                   * mat4(m_rotation);
    12788}
    12889
     
    13091{
    13192    WorldEntity::TickDraw(seconds);
    132 
    133     ForceSceneUpdate();
    13493}
    13594
  • trunk/src/camera.h

    r2294 r2476  
    2525{
    2626public:
    27     Camera(vec3 const &position, vec3 const &target, vec3 const &up);
     27    Camera();
    2828    ~Camera();
    2929
    3030    char const *GetName() { return "<camera>"; }
    3131
    32     void SetPosition(vec3 const &pos);
    33     void SetRotation(quat const &rot);
    34     void SetOrtho(float width, float height, float near, float far);
    35     void SetPerspective(float fov, float width, float height,
    36                         float near, float far);
    37     void SetTarget(vec3 const &pos);
    38     vec3 GetTarget();
     32    void SetView(mat4 const &view);
     33    void SetView(vec3 eye, vec3 target, vec3 up);
     34    void SetView(vec3 pos, quat rot);
     35
     36    void SetProjection(mat4 const &proj);
     37
     38    mat4 GetView();
     39    mat4 GetProjection();
     40
    3941    vec3 GetPosition();
    40 
    41     mat4 const &GetViewMatrix();
    42     mat4 const &GetProjMatrix();
    43     void ForceSceneUpdate();
    4442
    4543protected:
     
    4947private:
    5048    mat4 m_view_matrix, m_proj_matrix;
    51     vec3 m_target, m_up;
    5249};
    5350
  • trunk/src/easymesh/easymesh.cpp

    r2457 r2476  
    152152void DefaultShaderData::SetupShaderDatas(mat4 const &model)
    153153{
    154     mat4 modelview = Scene::GetDefault()->GetViewMatrix() * model;
     154    mat4 proj = Scene::GetDefault()->GetCamera()->GetProjection();
     155    mat4 view = Scene::GetDefault()->GetCamera()->GetView();
     156    mat4 modelview = view * model;
    155157    mat3 normalmat = transpose(inverse(mat3(modelview)));
    156158
     
    168170    m_shader->SetUniform(*GetUniform("in_ModelView"), modelview);
    169171    m_shader->SetUniform(*GetUniform("in_Inv_ModelView"), inverse(modelview));
    170     m_shader->SetUniform(*GetUniform("in_View"), Scene::GetDefault()->GetViewMatrix());
    171     m_shader->SetUniform(*GetUniform("in_Inv_View"), inverse(Scene::GetDefault()->GetViewMatrix()));
    172     m_shader->SetUniform(*GetUniform("in_Proj"), Scene::GetDefault()->GetProjMatrix());
     172    m_shader->SetUniform(*GetUniform("in_View"), view);
     173    m_shader->SetUniform(*GetUniform("in_Inv_View"), inverse(view));
     174    m_shader->SetUniform(*GetUniform("in_Proj"), proj);
    173175    m_shader->SetUniform(*GetUniform("in_NormalMat"), normalmat);
    174176    m_shader->SetUniform(*GetUniform("in_Damage"), 0);
  • trunk/src/gradient.cpp

    r2277 r2476  
    9696
    9797    uni_mat = data->shader->GetUniformLocation("proj_matrix");
    98     data->shader->SetUniform(uni_mat, Scene::GetDefault()->GetProjMatrix());
     98    data->shader->SetUniform(uni_mat, Scene::GetDefault()->GetCamera()->GetProjection());
    9999    uni_mat = data->shader->GetUniformLocation("view_matrix");
    100     data->shader->SetUniform(uni_mat, Scene::GetDefault()->GetViewMatrix());
     100    data->shader->SetUniform(uni_mat, Scene::GetDefault()->GetCamera()->GetView());
    101101    uni_mat = data->shader->GetUniformLocation("model_matrix");
    102102    data->shader->SetUniform(uni_mat, model_matrix);
  • trunk/src/scene.cpp

    r2444 r2476  
    5858    }
    5959
    60     mat4 m_model_matrix;
    61     mat4 m_view_matrix;
    62     mat4 m_proj_matrix;
    63 
    6460    Array<Tile> m_tiles;
    6561    Array<Light *> m_lights;
     
    6965    Array<VertexBuffer *> bufs;
    7066
     67    Camera *m_default_cam;
     68    Array<Camera *> m_camera_stack;
     69
    7170    static Scene *scene;
    7271};
     
    8180  : data(new SceneData())
    8281{
    83     data->m_model_matrix = mat4(1.f);
    84     data->m_view_matrix = mat4(1.f);
    85     data->m_proj_matrix = mat4::ortho(0, Video::GetSize().x,
    86                                       0, Video::GetSize().y, -1000.f, 1000.f);
     82    /* Create a default orthographic camera, in case the user doesn’t. */
     83    data->m_default_cam = new Camera();
     84    mat4 proj = mat4::ortho(0, Video::GetSize().x, 0, Video::GetSize().y,
     85                            -1000.f, 1000.f);
     86    data->m_default_cam->SetProjection(proj);
     87    PushCamera(data->m_default_cam);
    8788
    8889    data->m_shader = 0;
     
    9394Scene::~Scene()
    9495{
     96    PopCamera(data->m_default_cam);
     97
    9598    /* FIXME: this must be done while the GL context is still active.
    9699     * Change the code architecture to make sure of that. */
     
    110113}
    111114
     115void Scene::PushCamera(Camera *cam)
     116{
     117    Ticker::Ref(cam);
     118    data->m_camera_stack.Push(cam);
     119}
     120
     121void Scene::PopCamera(Camera *cam)
     122{
     123    /* Parse from the end because that’s probably where we’ll find
     124     * our camera first. */
     125    for (int i = data->m_camera_stack.Count(); i--; )
     126    {
     127        if (data->m_camera_stack[i] == cam)
     128        {
     129            Ticker::Unref(cam);
     130            data->m_camera_stack.Remove(i);
     131            return;
     132        }
     133    }
     134
     135    ASSERT(false, "trying to pop a nonexistent camera from the scene");
     136}
     137
     138Camera *Scene::GetCamera()
     139{
     140    return data->m_camera_stack.Last();
     141}
     142
    112143void Scene::Reset()
    113144{
     
    116147    data->bufs.Empty();
    117148    data->m_lights.Empty();
    118 }
    119 
    120 void Scene::SetViewMatrix(mat4 const &m)
    121 {
    122     data->m_view_matrix = m;
    123 }
    124 
    125 void Scene::SetProjMatrix(mat4 const &m)
    126 {
    127     data->m_proj_matrix = m;
    128 }
    129 
    130 mat4 const &Scene::GetViewMatrix(void)
    131 {
    132     return data->m_view_matrix;
    133 }
    134 
    135 mat4 const &Scene::GetProjMatrix(void)
    136 {
    137     return data->m_proj_matrix;
    138149}
    139150
     
    184195          sizeof(Tile), SceneData::Compare);
    185196
    186     // XXX: debug stuff
    187     data->m_model_matrix = mat4::translate(320.0f, 240.0f, 0.0f);
    188 #if 0
    189     static float f = 0.0f;
    190     f += 0.01f;
    191     data->m_model_matrix *= mat4::rotate(6.0f * sinf(f), 1.0f, 0.0f, 0.0f);
    192     data->m_model_matrix *= mat4::rotate(17.0f * cosf(f), 0.0f, 0.0f, 1.0f);
    193 #endif
    194     data->m_model_matrix *= mat4::translate(-320.0f, -240.0f, 0.0f);
    195 #if __ANDROID__
    196     data->m_model_matrix = mat4::scale(1280.0f / 640,
    197                                        736.0f / 480,
    198                                        1.0f) * data->m_model_matrix;
    199 #endif
    200     // XXX: end of debug stuff
    201 
    202197    ShaderUniform uni_mat, uni_tex;
    203198    ShaderAttrib attr_pos, attr_tex;
     
    208203
    209204    uni_mat = data->m_shader->GetUniformLocation("proj_matrix");
    210     data->m_shader->SetUniform(uni_mat, data->m_proj_matrix);
     205    data->m_shader->SetUniform(uni_mat, GetCamera()->GetProjection());
    211206    uni_mat = data->m_shader->GetUniformLocation("view_matrix");
    212     data->m_shader->SetUniform(uni_mat, data->m_view_matrix);
     207    data->m_shader->SetUniform(uni_mat, GetCamera()->GetView());
    213208    uni_mat = data->m_shader->GetUniformLocation("model_matrix");
    214     data->m_shader->SetUniform(uni_mat, data->m_model_matrix);
     209    data->m_shader->SetUniform(uni_mat, mat4(1.f));
    215210
    216211#if defined USE_D3D9 || defined _XBOX
  • trunk/src/scene.h

    r2289 r2476  
    2121#include "tileset.h"
    2222#include "light.h"
     23#include "camera.h"
    2324
    2425namespace lol
     
    3536    static Scene *GetDefault();
    3637
    37     void SetViewMatrix(mat4 const &m);
    38     void SetProjMatrix(mat4 const &m);
    39     mat4 const &GetViewMatrix(void);
    40     mat4 const &GetProjMatrix(void);
     38    Camera *GetCamera();
     39    void PushCamera(Camera *cam);
     40    void PopCamera(Camera *cam);
    4141
    4242    void Reset();
  • trunk/test/btphystest.cpp

    r2451 r2476  
    6767
    6868    /* Create a camera that matches the settings of XNA BtPhysTest */
    69     m_camera = new Camera(vec3(0.f, 600.f, 0.f),
    70                           vec3(0.f, 0.f, 0.f),
    71                           vec3(0, 1, 0));
    72     m_camera->SetRotation(quat::fromeuler_xyz(0.f, 0.f, 0.f));
    73     m_camera->SetPerspective(45.f, 1280.f, 960.f, .1f, 1000.f);
    74     //m_camera->SetOrtho(1280.f / 6, 960.f / 6, -1000.f, 1000.f);
    75     Ticker::Ref(m_camera);
     69    m_camera = new Camera();
     70    m_camera->SetView(vec3(0.f, 600.f, 0.f),
     71                      vec3(0.f, 0.f, 0.f),
     72                      vec3(0, 1, 0));
     73    m_camera->SetProjection(mat4::perspective(45.f, 1280.f, 960.f, .1f, 1000.f));
     74    Scene::GetDefault()->PushCamera(m_camera);
    7675
    7776    m_ready = false;
     
    305304            mat4 GroundMat = PhysObj->GetTransform();
    306305            vec3 CenterToGround = GroundMat.v3.xyz - GroundBarycenter;
    307             vec3 CenterToCam = m_camera->m_position - GroundBarycenter;
     306            vec3 CenterToCam = m_camera->GetPosition() - GroundBarycenter;
    308307
    309308            if (dot(normalize(CenterToCam - CenterToGround),
     
    394393        PhysObjBarycenter /= factor;
    395394
     395#if 0
    396396        m_camera->SetTarget(m_camera->GetTarget() + (seconds / (seconds + 0.18f)) * (PhysObjBarycenter - m_camera->GetTarget()));
    397397        vec3 CamPosCenter = m_camera->GetTarget() + vec3(.0f, 5.0f, .0f);
    398398        m_camera->SetPosition(CamPosCenter + normalize(m_camera->GetPosition() - CamPosCenter) * 20.0f);
     399#endif
    399400    }
    400401    else
     
    412413        PhysObjBarycenter /= factor;
    413414
     415#if 0
    414416        m_camera->SetTarget(PhysObjBarycenter);
    415417        m_camera->SetPosition(GroundBarycenter + normalize(GroundBarycenter - PhysObjBarycenter) * 60.0f);
     418#endif
    416419    }
    417420
     
    434437BtPhysTest::~BtPhysTest()
    435438{
    436     Ticker::Unref(m_camera);
     439    Scene::GetDefault()->PopCamera(m_camera);
    437440    Ticker::Unref(m_light1);
    438441    Ticker::Unref(m_light2);
  • trunk/test/meshviewer.cpp

    r2450 r2476  
    6565        m_fov_compensation = mat4::translate(vec3(.0f));
    6666        if (new_fov > 0.1f)
    67             m_camera->SetPerspective(new_fov, (float)video_size.x, (float)video_size.y, .1f, 1000.f);
     67            Scene::GetDefault()->GetCamera()->SetProjection(mat4::perspective(new_fov, (float)video_size.x, (float)video_size.y, .1f, 1000.f));
    6868        else
    69             m_camera->SetOrtho((float)video_size.x, (float)video_size.y, .1f, 1000.f);
     69            Scene::GetDefault()->GetCamera()->SetProjection(mat4::ortho((float)video_size.x, (float)video_size.y, .1f, 1000.f));
    7070    }
    7171
     
    9999
    100100        m_angle = 0;
    101         DefaultTexture = NULL;
     101        m_default_texture = NULL;
    102102
    103103        //Camera Setup
     
    105105        m_fov_damp = 60.0f;
    106106        m_fov = 60.0f;
    107         m_camera = new Camera(vec3(0.f, 600.f, 0.f),
    108                               vec3(0.f, 0.f, 0.f),
    109                               vec3(0, 1, 0));
     107        m_camera = new Camera();
    110108        SetFov(m_fov_damp);
    111         m_camera->SetTarget(vec3(0.f, 0.f, 0.f));
    112         m_camera->SetPosition(vec3(0.f, 0.f, 10.f));
    113         m_camera->ForceSceneUpdate();
    114         Ticker::Ref(m_camera);
     109        m_camera->SetView(vec3(0.f, 0.f, 10.f),
     110                          vec3(0.f, 0.f, 0.f),
     111                          vec3(0.f, 1.f, 0.f));
     112        Scene::GetDefault()->PushCamera(m_camera);
    115113
    116114        //Lights setup
     
    149147    ~MeshViewer()
    150148    {
    151         Ticker::Unref(m_camera);
     149        Scene::GetDefault()->PopCamera(m_camera);
    152150        for (int i = 0; i < m_lights.Count(); ++i)
    153151            Ticker::Unref(m_lights[i]);
     
    214212        SetFov(m_fov_damp);
    215213
    216         m_camera->SetPosition(m_camera->GetPosition() + cam_move);
    217         m_camera->SetTarget(m_camera->GetPosition() + vec3(0, 0, -5.0f));
     214        vec3 campos = Scene::GetDefault()->GetCamera()->GetPosition();
     215        Scene::GetDefault()->GetCamera()->SetView(campos + cam_move, quat(1.f));
    218216
    219217        //--
     
    330328        }
    331329
    332         if (!DefaultTexture)
     330        if (!m_default_texture)
    333331        {
    334332            m_texture_shader = Shader::Create(LOLFX_RESOURCE_NAME(shinymvtexture));
    335333            m_texture_uni = m_texture_shader->GetUniformLocation("u_Texture");
    336334            //m_image = new Image("data/test-texture.png");
    337             DefaultTexture = Tiler::Register("data/test-texture.png", ivec2(0), ivec2(0,1));
     335            m_default_texture = Tiler::Register("data/test-texture.png", ivec2(0), ivec2(0,1));
    338336
    339337            //ivec2 size = m_image->GetSize();
     
    343341            // PixelFormat::ABGR_8
    344342        }
    345         else if (m_texture && DefaultTexture)
    346             m_texture_shader->SetUniform(m_texture_uni, DefaultTexture->GetTexture(), 0);
     343        else if (m_texture && m_default_texture)
     344            m_texture_shader->SetUniform(m_texture_uni, m_default_texture->GetTexture(), 0);
    347345
    348346        for (int i = 0; i < m_meshes.Count(); i++)
     
    366364        Video::SetClearColor(vec4(0.0f, 0.0f, 0.0f, 1.0f));
    367365
    368         mat4 default_proj = Scene::GetDefault()->GetProjMatrix();
     366        mat4 default_proj = Scene::GetDefault()->GetCamera()->GetProjection();
    369367        for (int i = 0; i < m_meshes.Count(); i++)
    370368        {
     
    380378                }
    381379                m_meshes[i].m4 = damp(m_meshes[i].m4, new_mesh_offset, .35f, seconds);
    382                 Scene::GetDefault()->SetProjMatrix(mat4::translate(m_meshes[i].m4) *
    383                                                    mat4::translate(vec3(m_mesh_screen_offset_damp, .0f)) *
    384                                                    mat4::scale(vec3(vec2(m_meshes[i].m3), 1.0f)) *
    385                                                    default_proj *
    386                                                    m_fov_compensation);
     380                Scene::GetDefault()->GetCamera()->SetProjection(mat4::translate(m_meshes[i].m4) *
     381                                                                mat4::translate(vec3(m_mesh_screen_offset_damp, .0f)) *
     382                                                                mat4::scale(vec3(vec2(m_meshes[i].m3), 1.0f)) *
     383                                                                default_proj *
     384                                                                m_fov_compensation);
    387385#if WITH_FUR
    388386                for (int j=0; j < 40; j++)
     
    394392            }
    395393        }
    396         Scene::GetDefault()->SetProjMatrix(default_proj);
     394        Scene::GetDefault()->GetCamera()->SetProjection(default_proj);
    397395    }
    398396
    399397private:
    400     float           m_angle;
    401     mat4            m_mat;
     398    Camera * m_camera;
     399    float    m_angle;
     400    mat4     m_mat;
    402401
    403402    //Mesh infos
    404403    //Move damping
    405     vec2            m_mesh_rotate_damp;
    406     vec2            m_mesh_screen_move_damp;
    407     vec2            m_mesh_move_damp;
     404    vec2 m_mesh_rotate_damp;
     405    vec2 m_mesh_screen_move_damp;
     406    vec2 m_mesh_move_damp;
    408407
    409408    //Move transform damping
    410     vec2            m_mesh_rotation_damp;
    411     vec2            m_mesh_screen_offset_damp;
    412     vec2            m_mesh_offset_damp;
    413 
    414     vec2            m_mesh_rotation;     //Meshes rotation
    415     vec2            m_mesh_screen_offset;//Meshes screen offset
    416     vec2            m_mesh_offset;       //Mesh Offset after first mesh (x: offset, y: scale)
     409    vec2 m_mesh_rotation_damp;
     410    vec2 m_mesh_screen_offset_damp;
     411    vec2 m_mesh_offset_damp;
     412
     413    vec2 m_mesh_rotation;     //Meshes rotation
     414    vec2 m_mesh_screen_offset;//Meshes screen offset
     415    vec2 m_mesh_offset;       //Mesh Offset after first mesh (x: offset, y: scale)
    417416
    418417    //File data
    419     String          m_file_name;
    420     Array<String>   m_cmdlist;
    421     float           m_stream_update_time;
    422     float           m_stream_update_timer;
     418    String        m_file_name;
     419    Array<String> m_cmdlist;
     420    float         m_stream_update_time;
     421    float         m_stream_update_timer;
    423422
    424423    //misc datas
    425424    Array<EasyMesh, bool, float, vec3> m_meshes;
    426425    Array<Light *>  m_lights;
    427     Camera *        m_camera;
    428426    Shader *        m_texture_shader;
    429     TileSet *       DefaultTexture;
     427    TileSet *       m_default_texture;
    430428    Texture *       m_texture;
    431429    ShaderUniform   m_texture_uni;
  • trunk/tutorial/05_easymesh.cpp

    r2289 r2476  
    4747        m_angle = 0;
    4848
    49         m_camera = new Camera(vec3(0.f, 600.f, 0.f),
    50                               vec3(0.f, 0.f, 0.f),
    51                               vec3(0, 1, 0));
    52         m_camera->SetPerspective(30.f, 960.f, 600.f, .1f, 1000.f);
    53         m_camera->SetTarget(vec3(0.f, -1.f, 0.f));
    54         m_camera->SetPosition(vec3(-15.f, 5.f, 0.f));
    55         Ticker::Ref(m_camera);
     49        m_camera = new Camera();
     50        m_camera->SetProjection(mat4::perspective(30.f, 960.f, 600.f, .1f, 1000.f));
     51        m_camera->SetView(mat4::lookat(vec3(-15.f, 5.f, 0.f),
     52                                       vec3(0.f, -1.f, 0.f),
     53                                       vec3(0.f, 1.f, 0.f)));
     54        Scene::GetDefault()->PushCamera(m_camera);
    5655
    5756        /* Add a white directional light */
     
    7271    ~EasyMeshTutorial()
    7372    {
    74         Ticker::Unref(m_camera);
     73        Scene::GetDefault()->PopCamera(m_camera);
    7574        Ticker::Unref(m_light1);
    7675        Ticker::Unref(m_light2);
Note: See TracChangeset for help on using the changeset viewer.