bool Framework::Init( HINSTANCE hInstance, HWND hWindow, const LaunchInfo& launchInfo )
{
RECT rect;
if (GetClientRect(hWindow, &rect) == FALSE)
{
OutputDebugString(L"Failed to extract the initial window size");
return false;
}
unsigned int width = rect.right - rect.left;
unsigned int height = rect.bottom - rect.top;
PIXELFORMATDESCRIPTOR pfd =
{
sizeof(PIXELFORMATDESCRIPTOR),
1,
PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER, //Flags
PFD_TYPE_RGBA, //The kind of framebuffer. RGBA or palette.
32, //Colordepth of the framebuffer.
0, 0, 0, 0, 0, 0,
0,
0,
0,
0, 0, 0, 0,
24, //Number of bits for the depthbuffer
8, //Number of bits for the stencilbuffer
0, //Number of Aux buffers in the framebuffer.
PFD_MAIN_PLANE,
0,
0, 0, 0
};
m_WindowHandleToDeviceContext = GetDC(hWindow);
if (m_WindowHandleToDeviceContext == NULL)
{
return false;
}
int letWindowsChooseThisPixelFormat = ChoosePixelFormat(m_WindowHandleToDeviceContext, &pfd);
if (letWindowsChooseThisPixelFormat == 0)
{
return false;
}
if (SetPixelFormat(m_WindowHandleToDeviceContext, letWindowsChooseThisPixelFormat, &pfd) == FALSE)
{
return false;
}
HGLRC ourOpenGLRenderingContext = wglCreateContext(m_WindowHandleToDeviceContext);
if (ourOpenGLRenderingContext == NULL)
{
return false;
}
if (wglMakeCurrent(m_WindowHandleToDeviceContext, ourOpenGLRenderingContext) == FALSE)
{
return false;
}
// Initialize the OpenGL functions we will be using
// This must be called after we make our OpenGL rendering context above
OpenGLInterface::Initialize();
m_CameraManager = new CameraManager();
m_CameraPosition = m_PlayerPosition = glm::vec3();
m_PlayerRotationDegrees = 0.0f;
m_CameraOrientation = glm::vec3(0,0,1);
m_PlayerOrientation = glm::vec4( 0, 0, 1, 1 );
//m_CameraPosition = Vector3(0, 0, 100);
m_CameraPosition = glm::vec3( 0.0f, 30.f, 0.0f );
m_CameraTargetPitch = m_CameraCurrentPitch = 0.0f;
m_CameraTargetYaw = 0.0f;
m_CameraCurrentYaw = 0.0f;
m_FOVX = 45.0f;
assert(m_pInput == NULL);
m_pInput = new Input();
assert(m_pInput != NULL);
if (m_pInput->Init() == false)
{
return false;
}
// Initialize the stats related variables
m_OldFrameTime = timeGetTime();
m_OneSecondIntervalAccumulator = 0;
m_UpdateAccumulator = 0;
m_CurrentFPS = 0;
ResizeWindow(width, height);
m_Landscape.Initialize();
m_Loki.Load( "Media/Objects/capsule.sbm" );
//m_Loki.Load( "Media/Objects/dragon.sbm" );
// Initialize the 2D text system
m_Text2D.init( 128, 50 );
glm::vec3 cameraOffset( 35, 15, 0 );
CameraManager::CameraId followCamera = m_CameraManager->AddCamera( CameraManager::FOLLOW, "Follow" );
m_CameraManager->SetCameraTarget( followCamera, &m_Loki );
m_CameraManager->SetCameraPosition( followCamera, m_PlayerPosition + glm::vec3( cameraOffset.x, cameraOffset.y, 0 ) );
m_CameraManager->SetCameraOffset( followCamera, cameraOffset );
return true;
}
bool DrivingSimulatorV1::frameRenderingQueued(const Ogre::FrameEvent& evt)
{
// capture input devices
if(inputManager)
{
keyboard->capture();
mouse->capture();
}
// abort scene if window has been closed or escape button has been hit
if(renderWindow->isClosed() || keyboard->isKeyDown(OIS::KC_ESCAPE))
return false;
// decrease speed (air resistance, etc...)
if(speed > 0)
speed *= Ogre::Math::Pow(0.92, evt.timeSinceLastFrame);
else
speed *= Ogre::Math::Pow(0.7, evt.timeSinceLastFrame);
// accelerate / brake car
if(gear == DRIVE)
{
// udp input
if(UdpListener::throttle >= 0)
{
speed += UdpListener::throttle * 9 * evt.timeSinceLastFrame;
}
else
{
speed += UdpListener::throttle * 30 * evt.timeSinceLastFrame;
}
// keyboard input
if(keyboard->isKeyDown(OIS::KC_UP))
{
speed += 9 * evt.timeSinceLastFrame;
}
if(keyboard->isKeyDown(OIS::KC_DOWN))
{
speed -= 30 * evt.timeSinceLastFrame;
}
if(speed < 0)
{
speed = 0;
}
}
else if(gear == REVERSE)
{
// udp input
if(UdpListener::throttle <= 0)
{
speed += UdpListener::throttle * 9 * evt.timeSinceLastFrame;
}
else
{
speed += UdpListener::throttle * 30 * evt.timeSinceLastFrame;
}
// keyboard input
if(keyboard->isKeyDown(OIS::KC_UP))
{
speed += 30 * evt.timeSinceLastFrame;
}
if(keyboard->isKeyDown(OIS::KC_DOWN))
{
speed -= 9 * evt.timeSinceLastFrame;
}
if(speed > 0)
speed = 0;
}
else
{
if(UdpListener::throttle > THROTTLE_THRESHOLD || keyboard->isKeyDown(OIS::KC_UP))
gear = DRIVE;
else if(allowReverse && UdpListener::throttle < -THROTTLE_THRESHOLD || keyboard->isKeyDown(OIS::KC_DOWN))
gear = REVERSE;
}
if(speed == 0 && Ogre::Math::Abs(UdpListener::throttle) < THROTTLE_THRESHOLD && !keyboard->isKeyDown(OIS::KC_UP) && !keyboard->isKeyDown(OIS::KC_DOWN))
gear = NEUTRAL;
// update speed information for udp socket
UdpListener::speed = Ogre::Math::Abs(speed) * 1.1;
// calculate steer intensity
Ogre::Real normalizedSpeed = Ogre::Math::Abs(speed / 180);
Ogre::Real steerIntensity = 100 / (100 * (Ogre::Math::Pow(normalizedSpeed, 2)) + 1) * Ogre::Math::Pow(normalizedSpeed, 1.5);
// rotate car by udp input
carNode->yaw(Ogre::Degree(UdpListener::steer * -5 * evt.timeSinceLastFrame * speed));
cameraRotationOffset += UdpListener::steer * 90 * evt.timeSinceLastFrame;
// rotate car by keyboard input
if(keyboard->isKeyDown(OIS::KC_LEFT))
{
keyboardSteer += 270 * evt.timeSinceLastFrame;
}
if(keyboard->isKeyDown(OIS::KC_RIGHT))
{
keyboardSteer -= 270 * evt.timeSinceLastFrame;
}
if(!keyboard->isKeyDown(OIS::KC_LEFT) && !keyboard->isKeyDown(OIS::KC_RIGHT))
{
if(keyboardSteer > 0)
keyboardSteer -= std::min(270 * evt.timeSinceLastFrame, keyboardSteer);
else if(keyboardSteer < 0)
keyboardSteer += std::min(270 * evt.timeSinceLastFrame, keyboardSteer * -1);
}
if(keyboardSteer < -90)
keyboardSteer = -90;
else if(keyboardSteer > 90)
keyboardSteer = 90;
if(gear == DRIVE)
{
carNode->yaw(Ogre::Degree(steerIntensity * keyboardSteer * evt.timeSinceLastFrame));
cameraRotationOffset -= keyboardSteer * 0.3 * evt.timeSinceLastFrame * steerIntensity;
}
else if(gear == REVERSE)
{
carNode->yaw(Ogre::Degree(steerIntensity * keyboardSteer * evt.timeSinceLastFrame * -1));
cameraRotationOffset -= keyboardSteer * 0.3 * evt.timeSinceLastFrame * steerIntensity * -1;
}
// change camera mode
if(keyboard->isKeyDown(OIS::KC_V))
{
if(!keyState[OIS::KC_V])
{
cameraMode = 1 - cameraMode;
if(cameraMode == THIRD_PERSON)
{
cameraRotationOffset = 0;
}
}
keyState[OIS::KC_V] = true;
}
else
{
keyState[OIS::KC_V] = false;
}
// update car position
Ogre::Real xMove = Ogre::Math::Sin(carNode->getOrientation().getYaw()) * speed * evt.timeSinceLastFrame;
Ogre::Real zMove = Ogre::Math::Cos(carNode->getOrientation().getYaw()) * speed * evt.timeSinceLastFrame;
carNode->translate(xMove, 0, zMove);
// update camera
if(cameraMode == COCKPIT)
{
// position camera
Ogre::Vector3 cameraOffset(1.3, 4.0, 0.7);
camera->setOrientation(carNode->getOrientation() * Ogre::Quaternion(Ogre::Degree(180), Ogre::Vector3::UNIT_Y));
camera->setPosition(carNode->getPosition() + carNode->getOrientation() * cameraOffset);
// position car cockpit
Ogre::Vector3 cockpitOffset(0, 2, 0.7);
cockpitNode->setPosition(carNode->getPosition() + carNode->getOrientation() * cockpitOffset);
cockpitNode->setOrientation(carNode->getOrientation());
cockpitNode->yaw(Ogre::Degree(180));
// fix inaccuracy of carNode's orientation and position by assigning it it's own transformations
carNode->setOrientation(carNode->getOrientation());
carNode->setPosition(carNode->getPosition());
// position speed pointer
Ogre::Vector3 pointerOffset(0.0, 2.7, 2.9);
Ogre::Quaternion pointerPitch(Ogre::Degree(15), Ogre::Vector3::UNIT_X);
Ogre::Quaternion pointerRoll(Ogre::Degree(45 + Ogre::Math::Abs(UdpListener::speed * 2.25)), Ogre::Vector3::UNIT_Z);
pointerNode->setPosition(carNode->getPosition() + carNode->getOrientation() * pointerOffset);
pointerNode->setOrientation(carNode->getOrientation() * pointerPitch * pointerRoll);
// position steering wheel
Ogre::Vector3 steeringWheelOffset(1.3, 2.5, 2.5);
Ogre::Quaternion steeringWheelPitch(Ogre::Degree(15), Ogre::Vector3::UNIT_X);
Ogre::Quaternion steeringWheelRoll(Ogre::Degree(keyboardSteer * -1.5 + UdpListener::steer * 450), Ogre::Vector3::UNIT_Z);
steeringWheelNode->setOrientation(carNode->getOrientation() * steeringWheelPitch * steeringWheelRoll);
steeringWheelNode->setPosition(carNode->getPosition() + carNode->getOrientation() * steeringWheelOffset);
carNode->setVisible(false);
cockpitNode->setVisible(true);
pointerNode->setVisible(true);
if(showSteeringWheel)
steeringWheelNode->setVisible(true);
else
steeringWheelNode->setVisible(false);
}
else if(cameraMode == THIRD_PERSON)
{
if(gear != REVERSE)
cameraRotationOffset *= Ogre::Math::Pow(0.1, evt.timeSinceLastFrame);
else
cameraRotationOffset = cameraRotationOffset * Ogre::Math::Pow(0.1, evt.timeSinceLastFrame) + 180 * (1 - Ogre::Math::Pow(0.1, evt.timeSinceLastFrame));
Ogre::Radian camAngle = carNode->getOrientation().getYaw() + Ogre::Degree(cameraRotationOffset);
Ogre::Real camXOffset = -Ogre::Math::Sin(camAngle) * 25;
Ogre::Real camYOffset = 8;
Ogre::Real camZOffset = -Ogre::Math::Cos(camAngle) * 25;
camera->setPosition(carNode->getPosition() + Ogre::Vector3(camXOffset, camYOffset, camZOffset));
camera->lookAt(carNode->getPosition());
carNode->setVisible(true);
cockpitNode->setVisible(false);
pointerNode->setVisible(false);
steeringWheelNode->setVisible(false);
}
// debug output
//std::cout << "Position: " << carNode->getPosition() << " Rotation: " << carNode->getOrientation().getYaw().valueDegrees() << std::endl;
// if we reach this position of the code, no error has occurred
return true;
}
