docs/html/cameracontrol_8cpp_source.html

/*

        Skyscraper 2.0 Alpha - Camera Control Form

        Copyright (C)2003-2024 Ryan Thoryk

        https://www.skyscrapersim.net

        https://sourceforge.net/projects/skyscraper/

        Contact - ryan@skyscrapersim.net


        This program is free software; you can redistribute it and/or

        modify it under the terms of the GNU General Public License

        as published by the Free Software Foundation; either version 2

        of the License, or (at your option) any later version.


        This program is distributed in the hope that it will be useful,

        but WITHOUT ANY WARRANTY; without even the implied warranty of

        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

        GNU General Public License for more details.


        You should have received a copy of the GNU General Public License

        along with this program; if not, write to the Free Software

        Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/


//(*InternalHeaders(CameraControl)

#include <wx/intl.h>

#include <wx/string.h>

//*)

#include "globals.h"

#include "sbs.h"

#include "camera.h"

#include "debugpanel.h"

#include "cameracontrol.h"


using namespace SBS;


namespace Skyscraper {


//(*IdInit(CameraControl)

const long CameraControl::ID_STATICTEXT3 = wxNewId();

const long CameraControl::ID_txtDirectionFront = wxNewId();

const long CameraControl::ID_STATICTEXT15 = wxNewId();

const long CameraControl::ID_txtDirectionTop = wxNewId();

const long CameraControl::ID_STATICTEXT4 = wxNewId();

const long CameraControl::ID_txtCurrentFloor = wxNewId();

const long CameraControl::ID_STATICTEXT5 = wxNewId();

const long CameraControl::ID_txtLastMesh = wxNewId();

const long CameraControl::ID_STATICTEXT6 = wxNewId();

const long CameraControl::ID_txtDesiredVel = wxNewId();

const long CameraControl::ID_STATICTEXT7 = wxNewId();

const long CameraControl::ID_txtVelocity = wxNewId();

const long CameraControl::ID_STATICTEXT8 = wxNewId();

const long CameraControl::ID_txtDesiredAngle = wxNewId();

const long CameraControl::ID_STATICTEXT9 = wxNewId();

const long CameraControl::ID_txtAngle = wxNewId();

const long CameraControl::ID_STATICTEXT10 = wxNewId();

const long CameraControl::ID_txtSpeed = wxNewId();

const long CameraControl::ID_STATICTEXT11 = wxNewId();

const long CameraControl::ID_txtMouseDown = wxNewId();

const long CameraControl::ID_STATICTEXT12 = wxNewId();

const long CameraControl::ID_txtStartFloor = wxNewId();

const long CameraControl::ID_STATICTEXT13 = wxNewId();

const long CameraControl::ID_txtStartPosition = wxNewId();

const long CameraControl::ID_STATICTEXT29 = wxNewId();

const long CameraControl::ID_txtFOV = wxNewId();

const long CameraControl::ID_STATICTEXT14 = wxNewId();

const long CameraControl::ID_txtGravity = wxNewId();

const long CameraControl::ID_bGravity = wxNewId();

const long CameraControl::ID_lblGravityEnabled = wxNewId();

const long CameraControl::ID_txtGravityEnabled = wxNewId();

const long CameraControl::ID_bGravityEnabled = wxNewId();

const long CameraControl::ID_STATICTEXT17 = wxNewId();

const long CameraControl::ID_txtCollisions = wxNewId();

const long CameraControl::ID_bCollisions = wxNewId();

const long CameraControl::ID_STATICTEXT32 = wxNewId();

const long CameraControl::ID_txtReportCollisions = wxNewId();

const long CameraControl::ID_bReportCollisions = wxNewId();

const long CameraControl::ID_STATICTEXT19 = wxNewId();

const long CameraControl::ID_txtFreelook = wxNewId();

const long CameraControl::ID_bFreelook = wxNewId();

const long CameraControl::ID_STATICTEXT20 = wxNewId();

const long CameraControl::ID_txtFreelookSpeed = wxNewId();

const long CameraControl::ID_bFreelookSpeed = wxNewId();

const long CameraControl::ID_STATICTEXT33 = wxNewId();

const long CameraControl::ID_txtBinocularsFOV = wxNewId();

const long CameraControl::ID_bBinocularsFOV = wxNewId();

const long CameraControl::ID_STATICTEXT18 = wxNewId();

const long CameraControl::ID_txtGotoFloor = wxNewId();

const long CameraControl::ID_bGotoFloor = wxNewId();

const long CameraControl::ID_STATICTEXT1 = wxNewId();

const long CameraControl::ID_STATICTEXT2 = wxNewId();

const long CameraControl::ID_lblPosition = wxNewId();

const long CameraControl::ID_lblRotation = wxNewId();

const long CameraControl::ID_STATICLINE2 = wxNewId();

const long CameraControl::ID_rPosition = wxNewId();

const long CameraControl::ID_rRotation = wxNewId();

const long CameraControl::ID_STATICTEXT28 = wxNewId();

const long CameraControl::ID_txtMoveSpeed = wxNewId();

const long CameraControl::ID_bZPlus = wxNewId();

const long CameraControl::ID_bYPlus = wxNewId();

const long CameraControl::ID_bXNeg = wxNewId();

const long CameraControl::ID_chkHold = wxNewId();

const long CameraControl::ID_bXPlus = wxNewId();

const long CameraControl::ID_bZNeg = wxNewId();

const long CameraControl::ID_bYNeg = wxNewId();

const long CameraControl::ID_bStartPosition = wxNewId();

const long CameraControl::ID_bStartRotation = wxNewId();

const long CameraControl::ID_bStartDirection = wxNewId();

const long CameraControl::ID_STATICTEXT16 = wxNewId();

const long CameraControl::ID_STATICTEXT21 = wxNewId();

const long CameraControl::ID_txtPositionX = wxNewId();

const long CameraControl::ID_bPositionX = wxNewId();

const long CameraControl::ID_STATICTEXT22 = wxNewId();

const long CameraControl::ID_txtPositionY = wxNewId();

const long CameraControl::ID_bPositionY = wxNewId();

const long CameraControl::ID_STATICTEXT23 = wxNewId();

const long CameraControl::ID_txtPositionZ = wxNewId();

const long CameraControl::ID_bPositionZ = wxNewId();

const long CameraControl::ID_STATICLINE1 = wxNewId();

const long CameraControl::ID_STATICTEXT27 = wxNewId();

const long CameraControl::ID_STATICTEXT24 = wxNewId();

const long CameraControl::ID_txtRotationX = wxNewId();

const long CameraControl::ID_bRotationX = wxNewId();

const long CameraControl::ID_STATICTEXT25 = wxNewId();

const long CameraControl::ID_txtRotationY = wxNewId();

const long CameraControl::ID_bRotationY = wxNewId();

const long CameraControl::ID_STATICTEXT26 = wxNewId();

const long CameraControl::ID_txtRotationZ = wxNewId();

const long CameraControl::ID_bRotationZ = wxNewId();

const long CameraControl::ID_STATICLINE3 = wxNewId();

const long CameraControl::ID_STATICTEXT30 = wxNewId();

const long CameraControl::ID_txtSetFOV = wxNewId();

const long CameraControl::ID_bSetFOV = wxNewId();

const long CameraControl::ID_bResetFOV = wxNewId();

//*)


BEGIN_EVENT_TABLE(CameraControl,wxDialog)

//(*EventTable(CameraControl)

//*)

END_EVENT_TABLE()


CameraControl::CameraControl(DebugPanel* parent,wxWindowID id)

{

        //(*Initialize(CameraControl)

        wxFlexGridSizer* FlexGridSizer10;

        wxFlexGridSizer* FlexGridSizer11;

        wxFlexGridSizer* FlexGridSizer12;

        wxFlexGridSizer* FlexGridSizer13;

        wxFlexGridSizer* FlexGridSizer14;

        wxFlexGridSizer* FlexGridSizer1;

        wxFlexGridSizer* FlexGridSizer2;

        wxFlexGridSizer* FlexGridSizer3;

        wxFlexGridSizer* FlexGridSizer4;

        wxFlexGridSizer* FlexGridSizer5;

        wxFlexGridSizer* FlexGridSizer6;

        wxFlexGridSizer* FlexGridSizer7;

        wxFlexGridSizer* FlexGridSizer8;

        wxFlexGridSizer* FlexGridSizer9;

        wxGridSizer* GridSizer1;

        wxStaticBoxSizer* StaticBoxSizer1;

        wxStaticBoxSizer* StaticBoxSizer2;

        wxStaticBoxSizer* StaticBoxSizer3;

        wxStaticBoxSizer* StaticBoxSizer4;


        Create(parent, wxID_ANY, _("Camera Control"), wxDefaultPosition, wxDefaultSize, wxCAPTION|wxSYSTEM_MENU|wxCLOSE_BOX|wxMINIMIZE_BOX, _T("wxID_ANY"));

        FlexGridSizer1 = new wxFlexGridSizer(2, 2, 0, 0);

        FlexGridSizer8 = new wxFlexGridSizer(0, 1, 0, 0);

        StaticBoxSizer1 = new wxStaticBoxSizer(wxHORIZONTAL, this, _("Information"));

        FlexGridSizer2 = new wxFlexGridSizer(0, 2, 0, 0);

        StaticText3 = new wxStaticText(this, ID_STATICTEXT3, _("Direction Front:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT3"));

        FlexGridSizer2->Add(StaticText3, 1, wxALL|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);

        txtDirectionFront = new wxTextCtrl(this, ID_txtDirectionFront, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY, wxDefaultValidator, _T("ID_txtDirectionFront"));

        txtDirectionFront->SetMinSize(wxSize(125,-1));

        FlexGridSizer2->Add(txtDirectionFront, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        StaticText15 = new wxStaticText(this, ID_STATICTEXT15, _("Direction Top:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT15"));

        FlexGridSizer2->Add(StaticText15, 1, wxALL|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);

        txtDirectionTop = new wxTextCtrl(this, ID_txtDirectionTop, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY, wxDefaultValidator, _T("ID_txtDirectionTop"));

        FlexGridSizer2->Add(txtDirectionTop, 1, wxEXPAND, 5);

        StaticText4 = new wxStaticText(this, ID_STATICTEXT4, _("Current Floor:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT4"));

        FlexGridSizer2->Add(StaticText4, 1, wxALL|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);

        txtCurrentFloor = new wxTextCtrl(this, ID_txtCurrentFloor, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY, wxDefaultValidator, _T("ID_txtCurrentFloor"));

        FlexGridSizer2->Add(txtCurrentFloor, 1, wxEXPAND, 5);

        StaticText5 = new wxStaticText(this, ID_STATICTEXT5, _("Last Hit Mesh:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT5"));

        FlexGridSizer2->Add(StaticText5, 1, wxALL|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);

        txtLastMesh = new wxTextCtrl(this, ID_txtLastMesh, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY, wxDefaultValidator, _T("ID_txtLastMesh"));

        FlexGridSizer2->Add(txtLastMesh, 1, wxEXPAND, 5);

        StaticText6 = new wxStaticText(this, ID_STATICTEXT6, _("Desired Velocity:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT6"));

        FlexGridSizer2->Add(StaticText6, 1, wxALL|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);

        txtDesiredVel = new wxTextCtrl(this, ID_txtDesiredVel, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY, wxDefaultValidator, _T("ID_txtDesiredVel"));

        FlexGridSizer2->Add(txtDesiredVel, 1, wxEXPAND, 5);

        StaticText7 = new wxStaticText(this, ID_STATICTEXT7, _("Velocity:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT7"));

        FlexGridSizer2->Add(StaticText7, 1, wxALL|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);

        txtVelocity = new wxTextCtrl(this, ID_txtVelocity, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY, wxDefaultValidator, _T("ID_txtVelocity"));

        FlexGridSizer2->Add(txtVelocity, 1, wxEXPAND, 5);

        StaticText8 = new wxStaticText(this, ID_STATICTEXT8, _("Des Angle Vel:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT8"));

        FlexGridSizer2->Add(StaticText8, 1, wxALL|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);

        txtDesiredAngle = new wxTextCtrl(this, ID_txtDesiredAngle, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY, wxDefaultValidator, _T("ID_txtDesiredAngle"));

        FlexGridSizer2->Add(txtDesiredAngle, 1, wxEXPAND, 5);

        StaticText9 = new wxStaticText(this, ID_STATICTEXT9, _("Anglular Velocity:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT9"));

        FlexGridSizer2->Add(StaticText9, 1, wxALL|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);

        txtAngle = new wxTextCtrl(this, ID_txtAngle, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY, wxDefaultValidator, _T("ID_txtAngle"));

        FlexGridSizer2->Add(txtAngle, 1, wxEXPAND, 5);

        StaticText10 = new wxStaticText(this, ID_STATICTEXT10, _("Speed:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT10"));

        FlexGridSizer2->Add(StaticText10, 1, wxALL|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);

        txtSpeed = new wxTextCtrl(this, ID_txtSpeed, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY, wxDefaultValidator, _T("ID_txtSpeed"));

        FlexGridSizer2->Add(txtSpeed, 1, wxEXPAND, 5);

        StaticText11 = new wxStaticText(this, ID_STATICTEXT11, _("MouseDown:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT11"));

        FlexGridSizer2->Add(StaticText11, 1, wxALL|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);

        txtMouseDown = new wxTextCtrl(this, ID_txtMouseDown, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY, wxDefaultValidator, _T("ID_txtMouseDown"));

        FlexGridSizer2->Add(txtMouseDown, 1, wxEXPAND, 5);

        StaticText12 = new wxStaticText(this, ID_STATICTEXT12, _("Start Floor:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT12"));

        FlexGridSizer2->Add(StaticText12, 1, wxALL|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);

        txtStartFloor = new wxTextCtrl(this, ID_txtStartFloor, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY, wxDefaultValidator, _T("ID_txtStartFloor"));

        FlexGridSizer2->Add(txtStartFloor, 1, wxEXPAND, 5);

        StaticText13 = new wxStaticText(this, ID_STATICTEXT13, _("Start Position:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT13"));

        FlexGridSizer2->Add(StaticText13, 1, wxALL|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);

        txtStartPosition = new wxTextCtrl(this, ID_txtStartPosition, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY, wxDefaultValidator, _T("ID_txtStartPosition"));

        FlexGridSizer2->Add(txtStartPosition, 1, wxEXPAND, 5);

        StaticText29 = new wxStaticText(this, ID_STATICTEXT29, _("FOV Angle:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT29"));

        FlexGridSizer2->Add(StaticText29, 1, wxALL|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);

        txtFOV = new wxTextCtrl(this, ID_txtFOV, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY, wxDefaultValidator, _T("ID_txtFOV"));

        FlexGridSizer2->Add(txtFOV, 1, wxEXPAND, 5);

        StaticBoxSizer1->Add(FlexGridSizer2, 1, wxRIGHT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        FlexGridSizer8->Add(StaticBoxSizer1, 1, wxBOTTOM|wxLEFT|wxRIGHT|wxALIGN_LEFT|wxALIGN_TOP, 5);

        StaticBoxSizer3 = new wxStaticBoxSizer(wxHORIZONTAL, this, _("Parameters"));

        FlexGridSizer3 = new wxFlexGridSizer(0, 3, 0, 0);

        StaticText14 = new wxStaticText(this, ID_STATICTEXT14, _("Gravity:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT14"));

        FlexGridSizer3->Add(StaticText14, 1, wxRIGHT|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);

        txtGravity = new wxTextCtrl(this, ID_txtGravity, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_txtGravity"));

        txtGravity->SetMinSize(wxSize(100,-1));

        FlexGridSizer3->Add(txtGravity, 1, wxEXPAND, 5);

        bGravity = new wxButton(this, ID_bGravity, _("Set"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT, wxDefaultValidator, _T("ID_bGravity"));

        FlexGridSizer3->Add(bGravity, 1, wxLEFT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        lblGravityEnabled = new wxStaticText(this, ID_lblGravityEnabled, _("Gravity On:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_lblGravityEnabled"));

        FlexGridSizer3->Add(lblGravityEnabled, 1, wxRIGHT|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);

        txtGravityEnabled = new wxTextCtrl(this, ID_txtGravityEnabled, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY, wxDefaultValidator, _T("ID_txtGravityEnabled"));

        FlexGridSizer3->Add(txtGravityEnabled, 1, wxEXPAND, 5);

        bGravityEnabled = new wxButton(this, ID_bGravityEnabled, _("Set"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT, wxDefaultValidator, _T("ID_bGravityEnabled"));

        FlexGridSizer3->Add(bGravityEnabled, 1, wxLEFT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        StaticText17 = new wxStaticText(this, ID_STATICTEXT17, _("Collisions:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT17"));

        FlexGridSizer3->Add(StaticText17, 1, wxRIGHT|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);

        txtCollisions = new wxTextCtrl(this, ID_txtCollisions, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY, wxDefaultValidator, _T("ID_txtCollisions"));

        FlexGridSizer3->Add(txtCollisions, 1, wxEXPAND, 5);

        bCollisions = new wxButton(this, ID_bCollisions, _("Set"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT, wxDefaultValidator, _T("ID_bCollisions"));

        FlexGridSizer3->Add(bCollisions, 1, wxLEFT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        StaticText32 = new wxStaticText(this, ID_STATICTEXT32, _("Report Collisions:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT32"));

        FlexGridSizer3->Add(StaticText32, 1, wxRIGHT|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);

        txtReportCollisions = new wxTextCtrl(this, ID_txtReportCollisions, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY, wxDefaultValidator, _T("ID_txtReportCollisions"));

        FlexGridSizer3->Add(txtReportCollisions, 1, wxEXPAND, 5);

        bReportCollisions = new wxButton(this, ID_bReportCollisions, _("Set"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT, wxDefaultValidator, _T("ID_bReportCollisions"));

        FlexGridSizer3->Add(bReportCollisions, 1, wxLEFT|wxALIGN_TOP|wxALIGN_CENTER_HORIZONTAL, 5);

        StaticText19 = new wxStaticText(this, ID_STATICTEXT19, _("Freelook:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT19"));

        FlexGridSizer3->Add(StaticText19, 1, wxRIGHT|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);

        txtFreelook = new wxTextCtrl(this, ID_txtFreelook, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY, wxDefaultValidator, _T("ID_txtFreelook"));

        FlexGridSizer3->Add(txtFreelook, 1, wxEXPAND, 5);

        bFreelook = new wxButton(this, ID_bFreelook, _("Set"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT, wxDefaultValidator, _T("ID_bFreelook"));

        FlexGridSizer3->Add(bFreelook, 1, wxLEFT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        StaticText21 = new wxStaticText(this, ID_STATICTEXT20, _("Freelook Spd:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT20"));

        FlexGridSizer3->Add(StaticText21, 1, wxRIGHT|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);

        txtFreelookSpeed = new wxTextCtrl(this, ID_txtFreelookSpeed, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_txtFreelookSpeed"));

        FlexGridSizer3->Add(txtFreelookSpeed, 1, wxEXPAND, 5);

        bFreelookSpeed = new wxButton(this, ID_bFreelookSpeed, _("Set"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT, wxDefaultValidator, _T("ID_bFreelookSpeed"));

        FlexGridSizer3->Add(bFreelookSpeed, 1, wxLEFT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        StaticText33 = new wxStaticText(this, ID_STATICTEXT33, _("Binoculars FOV:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT33"));

        FlexGridSizer3->Add(StaticText33, 1, wxRIGHT|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);

        txtBinocularsFOV = new wxTextCtrl(this, ID_txtBinocularsFOV, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_txtBinocularsFOV"));

        FlexGridSizer3->Add(txtBinocularsFOV, 1, wxEXPAND, 5);

        bBinocularsFOV = new wxButton(this, ID_bBinocularsFOV, _("Set"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT, wxDefaultValidator, _T("ID_bBinocularsFOV"));

        FlexGridSizer3->Add(bBinocularsFOV, 1, wxLEFT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        StaticText18 = new wxStaticText(this, ID_STATICTEXT18, _("Goto Floor:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT18"));

        FlexGridSizer3->Add(StaticText18, 1, wxRIGHT|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);

        txtGotoFloor = new wxTextCtrl(this, ID_txtGotoFloor, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_txtGotoFloor"));

        FlexGridSizer3->Add(txtGotoFloor, 1, wxEXPAND, 5);

        bGotoFloor = new wxButton(this, ID_bGotoFloor, _("Set"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT, wxDefaultValidator, _T("ID_bGotoFloor"));

        FlexGridSizer3->Add(bGotoFloor, 1, wxLEFT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        StaticBoxSizer3->Add(FlexGridSizer3, 1, wxTOP|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        FlexGridSizer8->Add(StaticBoxSizer3, 1, wxBOTTOM|wxLEFT|wxALIGN_TOP|wxALIGN_CENTER_HORIZONTAL, 5);

        FlexGridSizer1->Add(FlexGridSizer8, 1, wxTOP|wxALIGN_LEFT|wxALIGN_TOP, 5);

        FlexGridSizer9 = new wxFlexGridSizer(0, 1, 0, 0);

        StaticBoxSizer2 = new wxStaticBoxSizer(wxHORIZONTAL, this, _("Control"));

        FlexGridSizer5 = new wxFlexGridSizer(0, 1, 0, 0);

        GridSizer1 = new wxGridSizer(0, 2, 0, 0);

        StaticText1 = new wxStaticText(this, ID_STATICTEXT1, _("Position:"), wxDefaultPosition, wxDefaultSize, wxALIGN_CENTRE, _T("ID_STATICTEXT1"));

        GridSizer1->Add(StaticText1, 1, wxALL|wxEXPAND, 5);

        StaticText2 = new wxStaticText(this, ID_STATICTEXT2, _("Rotation:"), wxDefaultPosition, wxDefaultSize, wxALIGN_CENTRE, _T("ID_STATICTEXT2"));

        GridSizer1->Add(StaticText2, 1, wxALL|wxEXPAND, 5);

        lblPosition = new wxStaticText(this, ID_lblPosition, _("0, 0, 0"), wxDefaultPosition, wxDefaultSize, wxST_NO_AUTORESIZE|wxALIGN_CENTRE, _T("ID_lblPosition"));

        GridSizer1->Add(lblPosition, 1, wxALL|wxEXPAND, 5);

        lblRotation = new wxStaticText(this, ID_lblRotation, _("0, 0, 0"), wxDefaultPosition, wxDefaultSize, wxST_NO_AUTORESIZE|wxALIGN_CENTRE, _T("ID_lblRotation"));

        GridSizer1->Add(lblRotation, 1, wxALL|wxEXPAND, 5);

        FlexGridSizer5->Add(GridSizer1, 1, wxEXPAND, 5);

        StaticLine2 = new wxStaticLine(this, ID_STATICLINE2, wxDefaultPosition, wxSize(10,-1), wxLI_HORIZONTAL, _T("ID_STATICLINE2"));

        FlexGridSizer5->Add(StaticLine2, 1, wxBOTTOM|wxEXPAND, 5);

        FlexGridSizer11 = new wxFlexGridSizer(0, 2, 0, 0);

        rPosition = new wxRadioButton(this, ID_rPosition, _("Position"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_rPosition"));

        rPosition->SetValue(true);

        FlexGridSizer11->Add(rPosition, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        rRotation = new wxRadioButton(this, ID_rRotation, _("Rotation"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_rRotation"));

        FlexGridSizer11->Add(rRotation, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        FlexGridSizer5->Add(FlexGridSizer11, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        FlexGridSizer14 = new wxFlexGridSizer(0, 2, 0, 0);

        StaticText20 = new wxStaticText(this, ID_STATICTEXT28, _("Speed"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT28"));

        FlexGridSizer14->Add(StaticText20, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        txtMoveSpeed = new wxTextCtrl(this, ID_txtMoveSpeed, _("1.0"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_txtMoveSpeed"));

        txtMoveSpeed->SetMinSize(wxSize(90,-1));

        FlexGridSizer14->Add(txtMoveSpeed, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        FlexGridSizer5->Add(FlexGridSizer14, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        FlexGridSizer12 = new wxFlexGridSizer(0, 3, 0, 0);

        FlexGridSizer12->Add(-1,-1,1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        bZPlus = new wxButton(this, ID_bZPlus, _("Z+"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_bZPlus"));

        FlexGridSizer12->Add(bZPlus, 1, wxALIGN_BOTTOM|wxALIGN_CENTER_HORIZONTAL, 5);

        bYPlus = new wxButton(this, ID_bYPlus, _("Y+"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_bYPlus"));

        FlexGridSizer12->Add(bYPlus, 1, wxBOTTOM|wxLEFT|wxALIGN_LEFT|wxALIGN_BOTTOM, 5);

        bXNeg = new wxButton(this, ID_bXNeg, _("X-"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_bXNeg"));

        FlexGridSizer12->Add(bXNeg, 1, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);

        chkHold = new wxCheckBox(this, ID_chkHold, _("Hold"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_chkHold"));

        chkHold->SetValue(false);

        FlexGridSizer12->Add(chkHold, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        bXPlus = new wxButton(this, ID_bXPlus, _("X+"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_bXPlus"));

        FlexGridSizer12->Add(bXPlus, 1, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);

        FlexGridSizer12->Add(-1,-1,1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        bZNeg = new wxButton(this, ID_bZNeg, _("Z-"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_bZNeg"));

        FlexGridSizer12->Add(bZNeg, 1, wxALIGN_TOP|wxALIGN_CENTER_HORIZONTAL, 5);

        bYNeg = new wxButton(this, ID_bYNeg, _("Y-"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_bYNeg"));

        FlexGridSizer12->Add(bYNeg, 1, wxTOP|wxLEFT|wxALIGN_LEFT|wxALIGN_TOP, 5);

        FlexGridSizer5->Add(FlexGridSizer12, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        FlexGridSizer13 = new wxFlexGridSizer(0, 3, 0, 0);

        bStartPosition = new wxButton(this, ID_bStartPosition, _("StartPosition"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_bStartPosition"));

        FlexGridSizer13->Add(bStartPosition, 1, wxTOP|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        bStartRotation = new wxButton(this, ID_bStartRotation, _("StartRotation"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_bStartRotation"));

        FlexGridSizer13->Add(bStartRotation, 1, wxTOP|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        bStartDirection = new wxButton(this, ID_bStartDirection, _("StartDirection"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_bStartDirection"));

        FlexGridSizer13->Add(bStartDirection, 1, wxTOP|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        FlexGridSizer5->Add(FlexGridSizer13, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        StaticBoxSizer2->Add(FlexGridSizer5, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        FlexGridSizer9->Add(StaticBoxSizer2, 1, wxTOP|wxRIGHT|wxALIGN_TOP|wxALIGN_CENTER_HORIZONTAL, 5);

        StaticBoxSizer4 = new wxStaticBoxSizer(wxHORIZONTAL, this, _("Set Camera"));

        FlexGridSizer6 = new wxFlexGridSizer(0, 1, 0, 0);

        StaticText16 = new wxStaticText(this, ID_STATICTEXT16, _("Position"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT16"));

        FlexGridSizer6->Add(StaticText16, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        FlexGridSizer4 = new wxFlexGridSizer(0, 3, 0, 0);

        StaticText22 = new wxStaticText(this, ID_STATICTEXT21, _("X:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT21"));

        FlexGridSizer4->Add(StaticText22, 1, wxLEFT|wxRIGHT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        txtPositionX = new wxTextCtrl(this, ID_txtPositionX, _("0"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_txtPositionX"));

        txtPositionX->SetMinSize(wxSize(90,-1));

        FlexGridSizer4->Add(txtPositionX, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        bPositionX = new wxButton(this, ID_bPositionX, _("Set"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT, wxDefaultValidator, _T("ID_bPositionX"));

        FlexGridSizer4->Add(bPositionX, 1, wxLEFT|wxRIGHT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        StaticText23 = new wxStaticText(this, ID_STATICTEXT22, _("Y:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT22"));

        FlexGridSizer4->Add(StaticText23, 1, wxLEFT|wxRIGHT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        txtPositionY = new wxTextCtrl(this, ID_txtPositionY, _("0"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_txtPositionY"));

        txtPositionY->SetMinSize(wxSize(90,-1));

        FlexGridSizer4->Add(txtPositionY, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        bPositionY = new wxButton(this, ID_bPositionY, _("Set"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT, wxDefaultValidator, _T("ID_bPositionY"));

        FlexGridSizer4->Add(bPositionY, 1, wxLEFT|wxRIGHT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        StaticText24 = new wxStaticText(this, ID_STATICTEXT23, _("Z:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT23"));

        FlexGridSizer4->Add(StaticText24, 1, wxLEFT|wxRIGHT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        txtPositionZ = new wxTextCtrl(this, ID_txtPositionZ, _("0"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_txtPositionZ"));

        txtPositionZ->SetMinSize(wxSize(90,-1));

        FlexGridSizer4->Add(txtPositionZ, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        bPositionZ = new wxButton(this, ID_bPositionZ, _("Set"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT, wxDefaultValidator, _T("ID_bPositionZ"));

        FlexGridSizer4->Add(bPositionZ, 1, wxLEFT|wxRIGHT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        FlexGridSizer6->Add(FlexGridSizer4, 1, wxTOP|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        StaticLine1 = new wxStaticLine(this, ID_STATICLINE1, wxDefaultPosition, wxSize(10,-1), wxLI_HORIZONTAL, _T("ID_STATICLINE1"));

        FlexGridSizer6->Add(StaticLine1, 1, wxTOP|wxEXPAND, 5);

        StaticText28 = new wxStaticText(this, ID_STATICTEXT27, _("Rotation"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT27"));

        FlexGridSizer6->Add(StaticText28, 1, wxTOP|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        FlexGridSizer7 = new wxFlexGridSizer(0, 3, 0, 0);

        StaticText25 = new wxStaticText(this, ID_STATICTEXT24, _("X:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT24"));

        FlexGridSizer7->Add(StaticText25, 1, wxLEFT|wxRIGHT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        txtRotationX = new wxTextCtrl(this, ID_txtRotationX, _("0"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_txtRotationX"));

        txtRotationX->SetMinSize(wxSize(90,-1));

        FlexGridSizer7->Add(txtRotationX, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        bRotationX = new wxButton(this, ID_bRotationX, _("Set"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT, wxDefaultValidator, _T("ID_bRotationX"));

        FlexGridSizer7->Add(bRotationX, 1, wxLEFT|wxRIGHT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        StaticText26 = new wxStaticText(this, ID_STATICTEXT25, _("Y:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT25"));

        FlexGridSizer7->Add(StaticText26, 1, wxLEFT|wxRIGHT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        txtRotationY = new wxTextCtrl(this, ID_txtRotationY, _("0"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_txtRotationY"));

        txtRotationY->SetMinSize(wxSize(90,-1));

        FlexGridSizer7->Add(txtRotationY, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        bRotationY = new wxButton(this, ID_bRotationY, _("Set"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT, wxDefaultValidator, _T("ID_bRotationY"));

        FlexGridSizer7->Add(bRotationY, 1, wxLEFT|wxRIGHT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        StaticText27 = new wxStaticText(this, ID_STATICTEXT26, _("Z:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT26"));

        FlexGridSizer7->Add(StaticText27, 1, wxLEFT|wxRIGHT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        txtRotationZ = new wxTextCtrl(this, ID_txtRotationZ, _("0"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_txtRotationZ"));

        txtRotationZ->SetMinSize(wxSize(90,-1));

        FlexGridSizer7->Add(txtRotationZ, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        bRotationZ = new wxButton(this, ID_bRotationZ, _("Set"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT, wxDefaultValidator, _T("ID_bRotationZ"));

        FlexGridSizer7->Add(bRotationZ, 1, wxLEFT|wxRIGHT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        FlexGridSizer6->Add(FlexGridSizer7, 1, wxTOP|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        StaticLine3 = new wxStaticLine(this, ID_STATICLINE3, wxDefaultPosition, wxSize(10,-1), wxLI_HORIZONTAL, _T("ID_STATICLINE3"));

        FlexGridSizer6->Add(StaticLine3, 1, wxTOP|wxEXPAND, 5);

        FlexGridSizer10 = new wxFlexGridSizer(0, 4, 0, 0);

        StaticText30 = new wxStaticText(this, ID_STATICTEXT30, _("FOV:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT30"));

        FlexGridSizer10->Add(StaticText30, 1, wxLEFT|wxRIGHT|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5);

        txtSetFOV = new wxTextCtrl(this, ID_txtSetFOV, _("0"), wxDefaultPosition, wxSize(50,-1), 0, wxDefaultValidator, _T("ID_txtSetFOV"));

        FlexGridSizer10->Add(txtSetFOV, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        bSetFOV = new wxButton(this, ID_bSetFOV, _("Set"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT, wxDefaultValidator, _T("ID_bSetFOV"));

        FlexGridSizer10->Add(bSetFOV, 1, wxLEFT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        bResetFOV = new wxButton(this, ID_bResetFOV, _("Reset"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT, wxDefaultValidator, _T("ID_bResetFOV"));

        FlexGridSizer10->Add(bResetFOV, 1, wxRIGHT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        FlexGridSizer6->Add(FlexGridSizer10, 1, wxTOP|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        StaticBoxSizer4->Add(FlexGridSizer6, 1, wxBOTTOM|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

        FlexGridSizer9->Add(StaticBoxSizer4, 1, wxTOP|wxBOTTOM|wxALIGN_TOP|wxALIGN_CENTER_HORIZONTAL, 5);

        FlexGridSizer1->Add(FlexGridSizer9, 1, wxALIGN_RIGHT|wxALIGN_TOP, 5);

        SetSizer(FlexGridSizer1);

        FlexGridSizer1->Fit(this);

        FlexGridSizer1->SetSizeHints(this);

        Center();


        Connect(ID_bGravity,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&CameraControl::On_bGravity_Click);

        Connect(ID_bGravityEnabled,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&CameraControl::On_bGravityEnabled_Click);

        Connect(ID_bCollisions,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&CameraControl::On_bCollisions_Click);

        Connect(ID_bReportCollisions,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&CameraControl::On_bReportCollisions_Click);

        Connect(ID_bFreelook,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&CameraControl::On_bFreelook_Click);

        Connect(ID_bFreelookSpeed,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&CameraControl::On_bFreelookSpeed_Click);

        Connect(ID_bBinocularsFOV,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&CameraControl::On_bBinocularsFOV_Click);

        Connect(ID_bGotoFloor,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&CameraControl::On_bGotoFloor_Click);

        Connect(ID_rPosition,wxEVT_COMMAND_RADIOBUTTON_SELECTED,(wxObjectEventFunction)&CameraControl::On_rPosition_Select);

        Connect(ID_rRotation,wxEVT_COMMAND_RADIOBUTTON_SELECTED,(wxObjectEventFunction)&CameraControl::On_rRotation_Select);

        Connect(ID_bZPlus,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&CameraControl::On_bZPlus_Click);

        Connect(ID_bYPlus,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&CameraControl::On_bYPlus_Click);

        Connect(ID_bXNeg,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&CameraControl::On_bXNeg_Click);

        Connect(ID_chkHold,wxEVT_COMMAND_CHECKBOX_CLICKED,(wxObjectEventFunction)&CameraControl::On_chkHold_Click);

        Connect(ID_bXPlus,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&CameraControl::On_bXPlus_Click);

        Connect(ID_bZNeg,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&CameraControl::On_bZNeg_Click);

        Connect(ID_bYNeg,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&CameraControl::On_bYNeg_Click);

        Connect(ID_bStartPosition,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&CameraControl::On_bStartPosition_Click);

        Connect(ID_bStartRotation,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&CameraControl::On_bStartRotation_Click);

        Connect(ID_bStartDirection,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&CameraControl::On_bStartDirection_Click);

        Connect(ID_bPositionX,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&CameraControl::On_bPositionX_Click);

        Connect(ID_bPositionY,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&CameraControl::On_bPositionY_Click);

        Connect(ID_bPositionZ,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&CameraControl::On_bPositionZ_Click);

        Connect(ID_bRotationX,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&CameraControl::On_bRotationX_Click);

        Connect(ID_bRotationY,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&CameraControl::On_bRotationY_Click);

        Connect(ID_bRotationZ,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&CameraControl::On_bRotationZ_Click);

        Connect(ID_bSetFOV,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&CameraControl::On_bSetFOV_Click);

        Connect(ID_bResetFOV,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&CameraControl::On_bResetFOV_Click);

        //*)

        Simcore = 0;

        panel = parent;

        OnInit();

}


CameraControl::~CameraControl()

{


}


void CameraControl::OnInit()

{

        Simcore = panel->GetSystem();


        txtGravity->SetValue(TruncateNumber(Simcore->camera->GetGravity(), 4));

        txtFreelookSpeed->SetValue(TruncateNumber(Simcore->camera->Freelook_speed, 2));

        hold_vector = Vector3(0, 0, 0);

        txtBinocularsFOV->SetValue(TruncateNumber(Simcore->camera->BinocularsFOV, 4));

}


void CameraControl::Loop()

{

        //if active engine has changed, refresh values

        if (Simcore != panel->GetSystem())

                OnInit();


        if (!Simcore)

                return;


        Vector3 direction_front, direction_top;

        Simcore->camera->GetDirection(direction_front, direction_top);

        txtDirectionFront->SetValue(TruncateNumber(direction_front.x, 2) + wxT(", ") + TruncateNumber(direction_front.y, 2) + wxT(", ") + TruncateNumber(direction_front.z, 2));

        txtDirectionTop->SetValue(TruncateNumber(direction_top.x, 2) + wxT(", ") + TruncateNumber(direction_top.y, 2) + wxT(", ") + TruncateNumber(direction_top.z, 2));

        txtCurrentFloor->SetValue(ToString(Simcore->camera->CurrentFloor) + wxT(" (") + Simcore->camera->CurrentFloorID + wxT(")"));

        txtLastMesh->SetValue(Simcore->camera->LastHitMesh);

        txtDesiredVel->SetValue(TruncateNumber(Simcore->camera->desired_velocity.x, 2) + wxT(", ") + TruncateNumber(Simcore->camera->desired_velocity.y, 2) + wxT(", ") + TruncateNumber(Simcore->camera->desired_velocity.z, 2));

        txtVelocity->SetValue(TruncateNumber(Simcore->camera->velocity.x, 2) + wxT(", ") + TruncateNumber(Simcore->camera->velocity.y, 2) + wxT(", ") + TruncateNumber(Simcore->camera->velocity.z, 2));

        txtDesiredAngle->SetValue(TruncateNumber(Simcore->camera->desired_angle_velocity.x, 2) + wxT(", ") + TruncateNumber(Simcore->camera->desired_angle_velocity.y, 2) + wxT(", ") + TruncateNumber(Simcore->camera->desired_angle_velocity.z, 2));

        txtAngle->SetValue(TruncateNumber(Simcore->camera->angle_velocity.x, 2) + wxT(", ") + TruncateNumber(Simcore->camera->angle_velocity.y, 2) + wxT(", ") + TruncateNumber(Simcore->camera->angle_velocity.z, 2));

        txtSpeed->SetValue(TruncateNumber(Simcore->camera->speed, 2));

        txtMouseDown->SetValue(BoolToString(Simcore->camera->MouseDown()));

        txtStartFloor->SetValue(ToString(Simcore->camera->StartFloor));

        txtStartPosition->SetValue(TruncateNumber(Simcore->camera->StartPositionX, 2) + wxT(", ") + TruncateNumber(Simcore->camera->StartPositionZ, 2));

        txtGravityEnabled->SetValue(BoolToString(Simcore->camera->GetGravityStatus()));

        txtCollisions->SetValue(BoolToString(Simcore->camera->CollisionsEnabled()));

        txtReportCollisions->SetValue(BoolToString(Simcore->camera->ReportCollisions));

        txtFreelook->SetValue(BoolToString(Simcore->camera->Freelook));

        lblPosition->SetLabel(TruncateNumber(Simcore->camera->GetPosition().x, 2) + wxT(", ") + TruncateNumber(Simcore->camera->GetPosition().y, 2) + wxT(", ") + TruncateNumber(Simcore->camera->GetPosition().z, 2));

        lblRotation->SetLabel(TruncateNumber(Simcore->camera->GetRotation().x, 2) + wxT(", ") + TruncateNumber(Simcore->camera->GetRotation().y, 2) + wxT(", ") + TruncateNumber(Simcore->camera->GetRotation().z, 2));

        txtFOV->SetValue(TruncateNumber(Simcore->camera->GetFOVAngle(), 4));


        //move if hold vector is not zero

        if (hold_vector != Vector3(0, 0, 0))

        {

                if (rPosition->GetValue() == true)

                        Simcore->camera->Move(hold_vector, 1);

                else

                        Simcore->camera->Rotate(hold_vector, 1);

        }

}


void CameraControl::On_rPosition_Select(wxCommandEvent& event)

{


}


void CameraControl::On_rRotation_Select(wxCommandEvent& event)

{


}


void CameraControl::On_bZPlus_Click(wxCommandEvent& event)

{

        if (chkHold->GetValue() == true)

        {

                hold_vector += Vector3(0, 0, atof(txtMoveSpeed->GetValue()));

                return;

        }


        if (rPosition->GetValue() == true)

                Simcore->camera->Move(Vector3(0, 0, 1), atof(txtMoveSpeed->GetValue()));

        else

                Simcore->camera->Rotate(Vector3(0, 0, 1), atof(txtMoveSpeed->GetValue()));

}


void CameraControl::On_bYPlus_Click(wxCommandEvent& event)

{

        if (chkHold->GetValue() == true)

        {

                hold_vector += Vector3(0, atof(txtMoveSpeed->GetValue()), 0);

                return;

        }


        if (rPosition->GetValue() == true)

                Simcore->camera->Move(Vector3(0, 1, 0), atof(txtMoveSpeed->GetValue()));

        else

                Simcore->camera->Rotate(Vector3(0, 1, 0), atof(txtMoveSpeed->GetValue()));

}


void CameraControl::On_bXNeg_Click(wxCommandEvent& event)

{

        if (chkHold->GetValue() == true)

        {

                hold_vector -= Vector3(atof(txtMoveSpeed->GetValue()), 0, 0);

                return;

        }


        if (rPosition->GetValue() == true)

                Simcore->camera->Move(Vector3(-1, 0, 0), atof(txtMoveSpeed->GetValue()));

        else

                Simcore->camera->Rotate(Vector3(-1, 0, 0), atof(txtMoveSpeed->GetValue()));

}


void CameraControl::On_bXPlus_Click(wxCommandEvent& event)

{

        if (chkHold->GetValue() == true)

        {

                hold_vector += Vector3(atof(txtMoveSpeed->GetValue()), 0, 0);

                return;

        }


        if (rPosition->GetValue() == true)

                Simcore->camera->Move(Vector3(1, 0, 0), atof(txtMoveSpeed->GetValue()));

        else

                Simcore->camera->Rotate(Vector3(1, 0, 0), atof(txtMoveSpeed->GetValue()));

}


void CameraControl::On_bZNeg_Click(wxCommandEvent& event)

{

        if (chkHold->GetValue() == true)

        {

                hold_vector -= Vector3(0, 0, atof(txtMoveSpeed->GetValue()));

                return;

        }


        if (rPosition->GetValue() == true)

                Simcore->camera->Move(Vector3(0, 0, -1), atof(txtMoveSpeed->GetValue()));

        else

                Simcore->camera->Rotate(Vector3(0, 0, -1), atof(txtMoveSpeed->GetValue()));

}


void CameraControl::On_bYNeg_Click(wxCommandEvent& event)

{

        if (chkHold->GetValue() == true)

        {

                hold_vector -= Vector3(0, atof(txtMoveSpeed->GetValue()), 0);

                return;

        }


        if (rPosition->GetValue() == true)

                Simcore->camera->Move(Vector3(0, -1, 0), atof(txtMoveSpeed->GetValue()));

        else

                Simcore->camera->Rotate(Vector3(0, -1, 0), atof(txtMoveSpeed->GetValue()));

}


void CameraControl::On_bStartPosition_Click(wxCommandEvent& event)

{

        Simcore->camera->SetToStartPosition(true);

}


void CameraControl::On_bStartRotation_Click(wxCommandEvent& event)

{

        Simcore->camera->SetToStartRotation();

}


void CameraControl::On_bStartDirection_Click(wxCommandEvent& event)

{

        Simcore->camera->SetToStartDirection();

}


void CameraControl::On_bGravity_Click(wxCommandEvent& event)

{

        Simcore->camera->SetGravity(atof(txtGravity->GetValue()));

}


void CameraControl::On_bGravityEnabled_Click(wxCommandEvent& event)

{

        Simcore->camera->EnableGravity(!Simcore->camera->GetGravityStatus());

}


void CameraControl::On_bCollisions_Click(wxCommandEvent& event)

{

        Simcore->camera->EnableCollisions(!Simcore->camera->CollisionsEnabled());

}


void CameraControl::On_bFreelook_Click(wxCommandEvent& event)

{

        Simcore->camera->Freelook = !Simcore->camera->Freelook;

}


void CameraControl::On_bFreelookSpeed_Click(wxCommandEvent& event)

{

        Simcore->camera->Freelook_speed = atof(txtFreelookSpeed->GetValue());

}


void CameraControl::On_bPositionX_Click(wxCommandEvent& event)

{

        Simcore->camera->SetPosition(Vector3(atof(txtPositionX->GetValue()), Simcore->camera->GetPosition().y, Simcore->camera->GetPosition().z));

}


void CameraControl::On_bPositionY_Click(wxCommandEvent& event)

{

        Simcore->camera->SetPosition(Vector3(Simcore->camera->GetPosition().x, atof(txtPositionY->GetValue()), Simcore->camera->GetPosition().z));

}


void CameraControl::On_bPositionZ_Click(wxCommandEvent& event)

{

        Simcore->camera->SetPosition(Vector3(Simcore->camera->GetPosition().x, Simcore->camera->GetPosition().y, atof(txtPositionZ->GetValue())));

}


void CameraControl::On_bRotationX_Click(wxCommandEvent& event)

{

        Simcore->camera->SetRotation(Vector3(atof(txtRotationX->GetValue()), Simcore->camera->GetRotation().y, Simcore->camera->GetRotation().z));

}


void CameraControl::On_bRotationY_Click(wxCommandEvent& event)

{

        Simcore->camera->SetRotation(Vector3(Simcore->camera->GetRotation().x, atof(txtRotationY->GetValue()), Simcore->camera->GetRotation().z));

}


void CameraControl::On_bRotationZ_Click(wxCommandEvent& event)

{

        Simcore->camera->SetRotation(Vector3(Simcore->camera->GetRotation().x, Simcore->camera->GetRotation().y, atof(txtRotationZ->GetValue())));

}


void CameraControl::On_chkHold_Click(wxCommandEvent& event)

{

        if (chkHold->GetValue() == false)

                hold_vector = Vector3(0, 0, 0);

}


void CameraControl::On_bSetFOV_Click(wxCommandEvent& event)

{

        Simcore->camera->SetFOVAngle(atof(txtSetFOV->GetValue()));

}


void CameraControl::On_bResetFOV_Click(wxCommandEvent& event)

{

        Simcore->camera->SetToDefaultFOV();

}


void CameraControl::On_bGotoFloor_Click(wxCommandEvent& event)

{

        Simcore->camera->GotoFloor(atoi(txtGotoFloor->GetValue()), true);

}


void CameraControl::On_bReportCollisions_Click(wxCommandEvent& event)

{

        Simcore->camera->ReportCollisions = !Simcore->camera->ReportCollisions;

}


void CameraControl::On_bBinocularsFOV_Click(wxCommandEvent& event)

{

        Simcore->camera->BinocularsFOV = atof(txtBinocularsFOV->GetValue());

}


}

camera.h

cameracontrol.h

SBS::Camera::CurrentFloorID
std::string CurrentFloorID
Definition camera.h:50

SBS::Camera::GetFOVAngle
Real GetFOVAngle()
Definition camera.cpp:1010

SBS::Camera::Freelook_speed
Real Freelook_speed
Definition camera.h:88

SBS::Camera::Move
bool Move(Vector3 vector, Real speed=1.0, bool flip=true)
Definition camera.cpp:317

SBS::Camera::GetGravityStatus
bool GetGravityStatus()
Definition camera.cpp:985

SBS::Camera::BinocularsFOV
Real BinocularsFOV
Definition camera.h:91

SBS::Camera::SetGravity
void SetGravity(Real gravity, bool save_value=true, bool camera_only=true)
Definition camera.cpp:949

SBS::Camera::GetDirection
void GetDirection(Vector3 &front, Vector3 &top, bool global=false)
Definition camera.cpp:263

SBS::Camera::LastHitMesh
std::string LastHitMesh
Definition camera.h:85

SBS::Camera::CollisionsEnabled
bool CollisionsEnabled()
Definition camera.cpp:1065

SBS::Camera::SetPosition
void SetPosition(const Vector3 &position)
Definition camera.cpp:179

SBS::Camera::CurrentFloor
int CurrentFloor
Definition camera.h:49

SBS::Camera::GotoFloor
void GotoFloor(int floor, bool disable_current=true)
Definition camera.cpp:1166

SBS::Camera::Freelook
bool Freelook
Definition camera.h:87

SBS::Camera::SetToStartDirection
void SetToStartDirection()
Definition camera.cpp:467

SBS::Camera::StartPositionX
Real StartPositionX
Definition camera.h:52

SBS::Camera::MouseDown
bool MouseDown()
Definition camera.cpp:1497

SBS::Camera::SetRotation
void SetRotation(const Vector3 &rotation)
Definition camera.cpp:209

SBS::Camera::SetToStartPosition
void SetToStartPosition(bool disable_current_floor)
Definition camera.cpp:456

SBS::Camera::SetFOVAngle
void SetFOVAngle(Real angle)
Definition camera.cpp:990

SBS::Camera::GetRotation
Vector3 GetRotation()
Definition camera.cpp:285

SBS::Camera::angle_velocity
Vector3 angle_velocity
Definition camera.h:80

SBS::Camera::GetPosition
Vector3 GetPosition(bool relative=false)
Definition camera.cpp:250

SBS::Camera::desired_velocity
Vector3 desired_velocity
Definition camera.h:77

SBS::Camera::SetToStartRotation
void SetToStartRotation()
Definition camera.cpp:473

SBS::Camera::GetGravity
Real GetGravity()
Definition camera.cpp:962

SBS::Camera::StartPositionZ
Real StartPositionZ
Definition camera.h:53

SBS::Camera::speed
Real speed
Definition camera.h:81

SBS::Camera::ReportCollisions
bool ReportCollisions
Definition camera.h:84

SBS::Camera::desired_angle_velocity
Vector3 desired_angle_velocity
Definition camera.h:79

SBS::Camera::EnableGravity
void EnableGravity(bool value)
Definition camera.cpp:967

SBS::Camera::velocity
Vector3 velocity
Definition camera.h:78

SBS::Camera::StartFloor
int StartFloor
Definition camera.h:51

SBS::Camera::Rotate
void Rotate(const Vector3 &position, Real speed=1.0)
Definition camera.cpp:367

SBS::Camera::EnableCollisions
void EnableCollisions(bool value)
Definition camera.cpp:1052

SBS::Camera::SetToDefaultFOV
void SetToDefaultFOV()
Definition camera.cpp:1018

SBS::SBS::camera
Camera * camera
Definition sbs.h:160

Skyscraper::CameraControl
Definition cameracontrol.h:40

Skyscraper::CameraControl::ID_bPositionX
static const long ID_bPositionX
Definition cameracontrol.h:119

Skyscraper::CameraControl::ID_txtFOV
static const long ID_txtFOV
Definition cameracontrol.h:72

Skyscraper::CameraControl::ID_STATICLINE2
static const long ID_STATICLINE2
Definition cameracontrol.h:101

Skyscraper::CameraControl::ID_STATICTEXT18
static const long ID_STATICTEXT18
Definition cameracontrol.h:94

Skyscraper::CameraControl::ID_STATICTEXT7
static const long ID_STATICTEXT7
Definition cameracontrol.h:57

Skyscraper::CameraControl::Simcore
SBS::SBS * Simcore
Definition cameracontrol.h:281

Skyscraper::CameraControl::On_bResetFOV_Click
void On_bResetFOV_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:675

Skyscraper::CameraControl::On_bYPlus_Click
void On_bYPlus_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:524

Skyscraper::CameraControl::txtDirectionFront
wxTextCtrl * txtDirectionFront
Definition cameracontrol.h:253

Skyscraper::CameraControl::ID_STATICTEXT9
static const long ID_STATICTEXT9
Definition cameracontrol.h:61

Skyscraper::CameraControl::ID_txtLastMesh
static const long ID_txtLastMesh
Definition cameracontrol.h:54

Skyscraper::CameraControl::ID_STATICTEXT10
static const long ID_STATICTEXT10
Definition cameracontrol.h:63

Skyscraper::CameraControl::ID_txtCurrentFloor
static const long ID_txtCurrentFloor
Definition cameracontrol.h:52

Skyscraper::CameraControl::ID_STATICTEXT30
static const long ID_STATICTEXT30
Definition cameracontrol.h:138

Skyscraper::CameraControl::On_bFreelook_Click
void On_bFreelook_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:624

Skyscraper::CameraControl::ID_lblPosition
static const long ID_lblPosition
Definition cameracontrol.h:99

Skyscraper::CameraControl::ID_txtStartPosition
static const long ID_txtStartPosition
Definition cameracontrol.h:70

Skyscraper::CameraControl::ID_STATICTEXT16
static const long ID_STATICTEXT16
Definition cameracontrol.h:116

Skyscraper::CameraControl::txtLastMesh
wxTextCtrl * txtLastMesh
Definition cameracontrol.h:261

Skyscraper::CameraControl::txtFOV
wxTextCtrl * txtFOV
Definition cameracontrol.h:255

Skyscraper::CameraControl::ID_STATICTEXT21
static const long ID_STATICTEXT21
Definition cameracontrol.h:117

Skyscraper::CameraControl::ID_bReportCollisions
static const long ID_bReportCollisions
Definition cameracontrol.h:84

Skyscraper::CameraControl::ID_STATICLINE3
static const long ID_STATICLINE3
Definition cameracontrol.h:137

Skyscraper::CameraControl::ID_txtMoveSpeed
static const long ID_txtMoveSpeed
Definition cameracontrol.h:105

Skyscraper::CameraControl::ID_bStartPosition
static const long ID_bStartPosition
Definition cameracontrol.h:113

Skyscraper::CameraControl::ID_txtGravityEnabled
static const long ID_txtGravityEnabled
Definition cameracontrol.h:77

Skyscraper::CameraControl::lblPosition
wxStaticText * lblPosition
Definition cameracontrol.h:245

Skyscraper::CameraControl::ID_STATICTEXT8
static const long ID_STATICTEXT8
Definition cameracontrol.h:59

Skyscraper::CameraControl::ID_STATICTEXT13
static const long ID_STATICTEXT13
Definition cameracontrol.h:69

Skyscraper::CameraControl::On_chkHold_Click
void On_chkHold_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:664

Skyscraper::CameraControl::On_bReportCollisions_Click
void On_bReportCollisions_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:685

Skyscraper::CameraControl::ID_STATICTEXT14
static const long ID_STATICTEXT14
Definition cameracontrol.h:73

Skyscraper::CameraControl::OnInit
void OnInit()
Definition cameracontrol.cpp:449

Skyscraper::CameraControl::txtReportCollisions
wxTextCtrl * txtReportCollisions
Definition cameracontrol.h:267

Skyscraper::CameraControl::ID_txtGotoFloor
static const long ID_txtGotoFloor
Definition cameracontrol.h:95

Skyscraper::CameraControl::txtDesiredVel
wxTextCtrl * txtDesiredVel
Definition cameracontrol.h:252

Skyscraper::CameraControl::On_bStartDirection_Click
void On_bStartDirection_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:604

Skyscraper::CameraControl::ID_STATICTEXT33
static const long ID_STATICTEXT33
Definition cameracontrol.h:91

Skyscraper::CameraControl::ID_bBinocularsFOV
static const long ID_bBinocularsFOV
Definition cameracontrol.h:93

Skyscraper::CameraControl::ID_txtPositionY
static const long ID_txtPositionY
Definition cameracontrol.h:121

Skyscraper::CameraControl::ID_STATICTEXT19
static const long ID_STATICTEXT19
Definition cameracontrol.h:85

Skyscraper::CameraControl::ID_txtDesiredAngle
static const long ID_txtDesiredAngle
Definition cameracontrol.h:60

Skyscraper::CameraControl::ID_txtStartFloor
static const long ID_txtStartFloor
Definition cameracontrol.h:68

Skyscraper::CameraControl::ID_bZPlus
static const long ID_bZPlus
Definition cameracontrol.h:106

Skyscraper::CameraControl::ID_txtSpeed
static const long ID_txtSpeed
Definition cameracontrol.h:64

Skyscraper::CameraControl::ID_bRotationZ
static const long ID_bRotationZ
Definition cameracontrol.h:136

Skyscraper::CameraControl::ID_STATICLINE1
static const long ID_STATICLINE1
Definition cameracontrol.h:126

Skyscraper::CameraControl::Loop
void Loop()
Definition cameracontrol.cpp:459

Skyscraper::CameraControl::ID_bPositionZ
static const long ID_bPositionZ
Definition cameracontrol.h:125

Skyscraper::CameraControl::ID_STATICTEXT20
static const long ID_STATICTEXT20
Definition cameracontrol.h:88

Skyscraper::CameraControl::ID_txtDesiredVel
static const long ID_txtDesiredVel
Definition cameracontrol.h:56

Skyscraper::CameraControl::ID_bGravity
static const long ID_bGravity
Definition cameracontrol.h:75

Skyscraper::CameraControl::txtRotationY
wxTextCtrl * txtRotationY
Definition cameracontrol.h:269

Skyscraper::CameraControl::txtFreelookSpeed
wxTextCtrl * txtFreelookSpeed
Definition cameracontrol.h:257

Skyscraper::CameraControl::txtSpeed
wxTextCtrl * txtSpeed
Definition cameracontrol.h:272

Skyscraper::CameraControl::ID_STATICTEXT32
static const long ID_STATICTEXT32
Definition cameracontrol.h:82

Skyscraper::CameraControl::ID_bYNeg
static const long ID_bYNeg
Definition cameracontrol.h:112

Skyscraper::CameraControl::ID_STATICTEXT24
static const long ID_STATICTEXT24
Definition cameracontrol.h:128

Skyscraper::CameraControl::ID_STATICTEXT15
static const long ID_STATICTEXT15
Definition cameracontrol.h:49

Skyscraper::CameraControl::ID_bFreelook
static const long ID_bFreelook
Definition cameracontrol.h:87

Skyscraper::CameraControl::On_bPositionZ_Click
void On_bPositionZ_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:644

Skyscraper::CameraControl::ID_bStartDirection
static const long ID_bStartDirection
Definition cameracontrol.h:115

Skyscraper::CameraControl::On_rRotation_Select
void On_rRotation_Select(wxCommandEvent &event)
Definition cameracontrol.cpp:505

Skyscraper::CameraControl::On_bRotationY_Click
void On_bRotationY_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:654

Skyscraper::CameraControl::ID_STATICTEXT2
static const long ID_STATICTEXT2
Definition cameracontrol.h:98

Skyscraper::CameraControl::On_rPosition_Select
void On_rPosition_Select(wxCommandEvent &event)
Definition cameracontrol.cpp:500

Skyscraper::CameraControl::ID_lblGravityEnabled
static const long ID_lblGravityEnabled
Definition cameracontrol.h:76

Skyscraper::CameraControl::On_bPositionX_Click
void On_bPositionX_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:634

Skyscraper::CameraControl::ID_txtPositionX
static const long ID_txtPositionX
Definition cameracontrol.h:118

Skyscraper::CameraControl::ID_txtAngle
static const long ID_txtAngle
Definition cameracontrol.h:62

Skyscraper::CameraControl::ID_STATICTEXT4
static const long ID_STATICTEXT4
Definition cameracontrol.h:51

Skyscraper::CameraControl::ID_txtReportCollisions
static const long ID_txtReportCollisions
Definition cameracontrol.h:83

Skyscraper::CameraControl::ID_bGotoFloor
static const long ID_bGotoFloor
Definition cameracontrol.h:96

Skyscraper::CameraControl::~CameraControl
virtual ~CameraControl()
Definition cameracontrol.cpp:443

Skyscraper::CameraControl::ID_txtGravity
static const long ID_txtGravity
Definition cameracontrol.h:74

Skyscraper::CameraControl::txtStartFloor
wxTextCtrl * txtStartFloor
Definition cameracontrol.h:273

Skyscraper::CameraControl::ID_bGravityEnabled
static const long ID_bGravityEnabled
Definition cameracontrol.h:78

Skyscraper::CameraControl::ID_bRotationY
static const long ID_bRotationY
Definition cameracontrol.h:133

Skyscraper::CameraControl::On_bSetFOV_Click
void On_bSetFOV_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:670

Skyscraper::CameraControl::ID_bStartRotation
static const long ID_bStartRotation
Definition cameracontrol.h:114

Skyscraper::CameraControl::On_bPositionY_Click
void On_bPositionY_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:639

Skyscraper::CameraControl::ID_STATICTEXT6
static const long ID_STATICTEXT6
Definition cameracontrol.h:55

Skyscraper::CameraControl::txtMouseDown
wxTextCtrl * txtMouseDown
Definition cameracontrol.h:262

Skyscraper::CameraControl::On_bYNeg_Click
void On_bYNeg_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:580

Skyscraper::CameraControl::ID_bCollisions
static const long ID_bCollisions
Definition cameracontrol.h:81

Skyscraper::CameraControl::ID_STATICTEXT27
static const long ID_STATICTEXT27
Definition cameracontrol.h:127

Skyscraper::CameraControl::ID_bResetFOV
static const long ID_bResetFOV
Definition cameracontrol.h:141

Skyscraper::CameraControl::On_bFreelookSpeed_Click
void On_bFreelookSpeed_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:629

Skyscraper::CameraControl::ID_bXPlus
static const long ID_bXPlus
Definition cameracontrol.h:110

Skyscraper::CameraControl::On_bZNeg_Click
void On_bZNeg_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:566

Skyscraper::CameraControl::txtFreelook
wxTextCtrl * txtFreelook
Definition cameracontrol.h:256

Skyscraper::CameraControl::ID_rRotation
static const long ID_rRotation
Definition cameracontrol.h:103

Skyscraper::CameraControl::ID_txtRotationZ
static const long ID_txtRotationZ
Definition cameracontrol.h:135

Skyscraper::CameraControl::ID_bSetFOV
static const long ID_bSetFOV
Definition cameracontrol.h:140

Skyscraper::CameraControl::On_bStartPosition_Click
void On_bStartPosition_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:594

Skyscraper::CameraControl::ID_txtDirectionFront
static const long ID_txtDirectionFront
Definition cameracontrol.h:48

Skyscraper::CameraControl::ID_STATICTEXT11
static const long ID_STATICTEXT11
Definition cameracontrol.h:65

Skyscraper::CameraControl::hold_vector
Vector3 hold_vector
Definition cameracontrol.h:277

Skyscraper::CameraControl::txtAngle
wxTextCtrl * txtAngle
Definition cameracontrol.h:247

Skyscraper::CameraControl::ID_STATICTEXT23
static const long ID_STATICTEXT23
Definition cameracontrol.h:123

Skyscraper::CameraControl::ID_STATICTEXT22
static const long ID_STATICTEXT22
Definition cameracontrol.h:120

Skyscraper::CameraControl::txtCollisions
wxTextCtrl * txtCollisions
Definition cameracontrol.h:249

Skyscraper::CameraControl::txtDirectionTop
wxTextCtrl * txtDirectionTop
Definition cameracontrol.h:254

Skyscraper::CameraControl::ID_txtSetFOV
static const long ID_txtSetFOV
Definition cameracontrol.h:139

Skyscraper::CameraControl::ID_STATICTEXT3
static const long ID_STATICTEXT3
Definition cameracontrol.h:47

Skyscraper::CameraControl::ID_bPositionY
static const long ID_bPositionY
Definition cameracontrol.h:122

Skyscraper::CameraControl::ID_STATICTEXT28
static const long ID_STATICTEXT28
Definition cameracontrol.h:104

Skyscraper::CameraControl::txtCurrentFloor
wxTextCtrl * txtCurrentFloor
Definition cameracontrol.h:250

Skyscraper::CameraControl::txtSetFOV
wxTextCtrl * txtSetFOV
Definition cameracontrol.h:271

Skyscraper::CameraControl::lblRotation
wxStaticText * lblRotation
Definition cameracontrol.h:246

Skyscraper::CameraControl::ID_bXNeg
static const long ID_bXNeg
Definition cameracontrol.h:108

Skyscraper::CameraControl::On_bRotationZ_Click
void On_bRotationZ_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:659

Skyscraper::CameraControl::On_bZPlus_Click
void On_bZPlus_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:510

Skyscraper::CameraControl::ID_txtMouseDown
static const long ID_txtMouseDown
Definition cameracontrol.h:66

Skyscraper::CameraControl::ID_lblRotation
static const long ID_lblRotation
Definition cameracontrol.h:100

Skyscraper::CameraControl::On_bStartRotation_Click
void On_bStartRotation_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:599

Skyscraper::CameraControl::txtStartPosition
wxTextCtrl * txtStartPosition
Definition cameracontrol.h:274

Skyscraper::CameraControl::txtBinocularsFOV
wxTextCtrl * txtBinocularsFOV
Definition cameracontrol.h:248

Skyscraper::CameraControl::txtMoveSpeed
wxTextCtrl * txtMoveSpeed
Definition cameracontrol.h:263

Skyscraper::CameraControl::ID_txtPositionZ
static const long ID_txtPositionZ
Definition cameracontrol.h:124

Skyscraper::CameraControl::ID_bYPlus
static const long ID_bYPlus
Definition cameracontrol.h:107

Skyscraper::CameraControl::ID_STATICTEXT5
static const long ID_STATICTEXT5
Definition cameracontrol.h:53

Skyscraper::CameraControl::ID_STATICTEXT29
static const long ID_STATICTEXT29
Definition cameracontrol.h:71

Skyscraper::CameraControl::ID_chkHold
static const long ID_chkHold
Definition cameracontrol.h:109

Skyscraper::CameraControl::panel
DebugPanel * panel
Definition cameracontrol.h:282

Skyscraper::CameraControl::txtRotationZ
wxTextCtrl * txtRotationZ
Definition cameracontrol.h:270

Skyscraper::CameraControl::ID_txtRotationY
static const long ID_txtRotationY
Definition cameracontrol.h:132

Skyscraper::CameraControl::txtRotationX
wxTextCtrl * txtRotationX
Definition cameracontrol.h:268

Skyscraper::CameraControl::ID_txtFreelookSpeed
static const long ID_txtFreelookSpeed
Definition cameracontrol.h:89

Skyscraper::CameraControl::On_bBinocularsFOV_Click
void On_bBinocularsFOV_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:690

Skyscraper::CameraControl::On_bXNeg_Click
void On_bXNeg_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:538

Skyscraper::CameraControl::ID_bZNeg
static const long ID_bZNeg
Definition cameracontrol.h:111

Skyscraper::CameraControl::On_bRotationX_Click
void On_bRotationX_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:649

Skyscraper::CameraControl::ID_bRotationX
static const long ID_bRotationX
Definition cameracontrol.h:130

Skyscraper::CameraControl::ID_STATICTEXT17
static const long ID_STATICTEXT17
Definition cameracontrol.h:79

Skyscraper::CameraControl::ID_txtBinocularsFOV
static const long ID_txtBinocularsFOV
Definition cameracontrol.h:92

Skyscraper::CameraControl::On_bGotoFloor_Click
void On_bGotoFloor_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:680

Skyscraper::CameraControl::ID_rPosition
static const long ID_rPosition
Definition cameracontrol.h:102

Skyscraper::CameraControl::txtVelocity
wxTextCtrl * txtVelocity
Definition cameracontrol.h:275

Skyscraper::CameraControl::ID_STATICTEXT12
static const long ID_STATICTEXT12
Definition cameracontrol.h:67

Skyscraper::CameraControl::ID_txtCollisions
static const long ID_txtCollisions
Definition cameracontrol.h:80

Skyscraper::CameraControl::txtGravity
wxTextCtrl * txtGravity
Definition cameracontrol.h:259

Skyscraper::CameraControl::ID_STATICTEXT26
static const long ID_STATICTEXT26
Definition cameracontrol.h:134

Skyscraper::CameraControl::txtPositionX
wxTextCtrl * txtPositionX
Definition cameracontrol.h:264

Skyscraper::CameraControl::rPosition
wxRadioButton * rPosition
Definition cameracontrol.h:207

Skyscraper::CameraControl::ID_txtDirectionTop
static const long ID_txtDirectionTop
Definition cameracontrol.h:50

Skyscraper::CameraControl::ID_txtVelocity
static const long ID_txtVelocity
Definition cameracontrol.h:58

Skyscraper::CameraControl::On_bXPlus_Click
void On_bXPlus_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:552

Skyscraper::CameraControl::txtGotoFloor
wxTextCtrl * txtGotoFloor
Definition cameracontrol.h:258

Skyscraper::CameraControl::ID_STATICTEXT1
static const long ID_STATICTEXT1
Definition cameracontrol.h:97

Skyscraper::CameraControl::chkHold
wxCheckBox * chkHold
Definition cameracontrol.h:206

Skyscraper::CameraControl::ID_STATICTEXT25
static const long ID_STATICTEXT25
Definition cameracontrol.h:131

Skyscraper::CameraControl::ID_txtFreelook
static const long ID_txtFreelook
Definition cameracontrol.h:86

Skyscraper::CameraControl::txtPositionY
wxTextCtrl * txtPositionY
Definition cameracontrol.h:265

Skyscraper::CameraControl::ID_bFreelookSpeed
static const long ID_bFreelookSpeed
Definition cameracontrol.h:90

Skyscraper::CameraControl::On_bGravity_Click
void On_bGravity_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:609

Skyscraper::CameraControl::On_bCollisions_Click
void On_bCollisions_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:619

Skyscraper::CameraControl::On_bGravityEnabled_Click
void On_bGravityEnabled_Click(wxCommandEvent &event)
Definition cameracontrol.cpp:614

Skyscraper::CameraControl::txtGravityEnabled
wxTextCtrl * txtGravityEnabled
Definition cameracontrol.h:260

Skyscraper::CameraControl::ID_txtRotationX
static const long ID_txtRotationX
Definition cameracontrol.h:129

Skyscraper::CameraControl::txtDesiredAngle
wxTextCtrl * txtDesiredAngle
Definition cameracontrol.h:251

Skyscraper::CameraControl::txtPositionZ
wxTextCtrl * txtPositionZ
Definition cameracontrol.h:266

Skyscraper::DebugPanel
Definition debugpanel.h:66

Skyscraper::DebugPanel::GetSystem
SBS::SBS * GetSystem()
Definition debugpanel.h:131

debugpanel.h

globals.h

Vector3
Ogre::Vector3 Vector3
Definition globals.h:58

SBS
Definition skyscraper.h:45

SBS::ToString
std::string ToString(int number)
Definition globals.cpp:279

SBS::BoolToString
std::string BoolToString(bool item)
Definition globals.cpp:101

Skyscraper
Definition native.cpp:50

Skyscraper::TruncateNumber
wxString TruncateNumber(float value, int decimals)
Definition debugpanel.cpp:768

sbs.h