void Engine::synchronizeForRendering() {
// Stop Qt from clearing the back buffer now that we have properly attached to the rendering
// thread. We need to render beneath it, so the window clearing would obscure our draws. We
// instead clear the back buffer ourselves in sceneRender().
mViewer->setClearBeforeRendering(false);
// Clean up the render list, just in case Qt decided not to render a frame.
mRenderList->reset();
mSyncsSinceNextLevelRequest++;
// Do not render if our level has not been loaded, or we are currently preparing to delete it.
// We cannot render a level that is about to be deleted because the children of Level (actors,
// graphics etc.) hold on to resources used by GL, which might get used by our threaded
// renderer.
if (!mLevelReady) {
return;
}
// Generate the new render list.
RenderList* renderList = mRenderList.get();
forEach<Graphic>([renderList] (Graphic* graphic) {
graphic->synchronizeForRendering(renderList);
});
// Set up our transforms.
Matrix4 projMat;
memcpy(projMat, mCamera->getOpenGLViewMatrix().data(), sizeof(Matrix4));
mRenderer->setProjectionMatrix(projMat);
mRenderer->getDebugRenderer()->setProjectionMatrix(projMat);
// Queue up our debug shapes.
mRenderer->attachAsCurrent();
debugRender();
mRenderer->detachAsCurrent();
mRenderer->getDebugRenderer()->synchronizeForRendering();
}
void Tile::render(const G3MRenderContext* rc,
const TileRenderContext* trc,
const GLState& parentState,
std::list<Tile*>* toVisitInNextIteration,
const Planet* planet,
const Vector3D& cameraNormalizedPosition,
double cameraAngle2HorizonInRadians,
const Frustum* cameraFrustumInModelCoordinates) {
const float verticalExaggeration = trc->getVerticalExaggeration();
if (verticalExaggeration != _verticalExaggeration) {
// TODO: verticalExaggeration changed, invalidate tileExtent, Mesh, etc.
_verticalExaggeration = trc->getVerticalExaggeration();
}
TilesStatistics* statistics = trc->getStatistics();
statistics->computeTileProcessed(this);
if (isVisible(rc, trc, planet,
cameraNormalizedPosition,
cameraAngle2HorizonInRadians,
cameraFrustumInModelCoordinates)) {
setIsVisible(true, trc->getTexturizer());
statistics->computeVisibleTile(this);
const bool isRawRender = (
(toVisitInNextIteration == NULL) ||
meetsRenderCriteria(rc, trc) ||
(trc->getParameters()->_incrementalTileQuality && !_textureSolved)
);
if (isRawRender) {
rawRender(rc, trc, parentState);
if (trc->getParameters()->_renderDebug) {
debugRender(rc, trc, parentState);
}
statistics->computeTileRendered(this);
prune(trc->getTexturizer(),
trc->getElevationDataProvider());
//TODO: AVISAR CAMBIO DE TERRENO
}
else {
const Geodetic2D lower = _sector._lower;
const Geodetic2D upper = _sector._upper;
const Angle splitLongitude = Angle::midAngle(lower._longitude,
upper._longitude);
const Angle splitLatitude = trc->getLayerTilesRenderParameters()->_mercator
/* */ ? MercatorUtils::calculateSplitLatitude(lower._latitude,
upper._latitude)
/* */ : Angle::midAngle(lower._latitude,
upper._latitude);
std::vector<Tile*>* subTiles = getSubTiles(splitLatitude, splitLongitude);
if (_justCreatedSubtiles) {
trc->getLastSplitTimer()->start();
statistics->computeSplitInFrame();
_justCreatedSubtiles = false;
}
const int subTilesSize = subTiles->size();
for (int i = 0; i < subTilesSize; i++) {
Tile* subTile = subTiles->at(i);
toVisitInNextIteration->push_back(subTile);
}
}
}
else {
setIsVisible(false, trc->getTexturizer());
prune(trc->getTexturizer(),
trc->getElevationDataProvider());
//TODO: AVISAR CAMBIO DE TERRENO
}
}
void LightSystem::render(const sf::View& screenView, sf::RenderTarget& target)
{
debugRender(screenView,target,LightSystem::DebugFlags::DEFAULT);
}
//-----------------------------------------------------------------------
// WinMain
//-----------------------------------------------------------------------
int APIENTRY WinMain(HINSTANCE _hInstance, HINSTANCE _hPrevInstance, LPSTR _lpCmdLine, int _nCmdShow)
{
// Register the window class
WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L, GetModuleHandle(NULL), NULL, NULL, NULL, NULL, APPLICATION_NAME, NULL };
RegisterClassEx(&wc);
// Calcular el tamano de nuestra ventana
RECT rc = {
0, 0, 800, 600
};
AdjustWindowRect(&rc, WS_OVERLAPPEDWINDOW, FALSE);
// Create the application's window
HWND hWnd = CreateWindow(APPLICATION_NAME, APPLICATION_NAME, WS_OVERLAPPEDWINDOW, 100, 100, rc.right - rc.left, rc.bottom - rc.top, NULL, NULL, wc.hInstance, NULL);
// Añadir aquí el Init de la applicacioón
s_Context.CreateContext(hWnd, 800, 600);
ShowWindow(hWnd, SW_SHOWDEFAULT);
s_Context.CreateBackBuffer(hWnd, 800, 600);
s_Context.InitStates();
{
CDebugRender debugRender(s_Context.GetDevice());
CInputManagerImplementation inputManager(hWnd);
CInputManager::SetCurrentInputManager(&inputManager);
inputManager.LoadCommandsFromFile("Data\\input.xml");
CDebugHelperImplementation debugHelper(s_Context.GetDevice());
CDebugHelper::SetCurrentDebugHelper(&debugHelper);
CApplication application(&debugRender, &s_Context);
UpdateWindow(hWnd);
MSG msg;
ZeroMemory(&msg, sizeof(msg));
// Añadir en el while la condición de salida del programa de la aplicación
DWORD m_PreviousTime = timeGetTime();
bool hasFocus = true;
while (msg.message != WM_QUIT)
{
if (PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
{
if (!debugHelper.Update(msg.hwnd, msg.message, msg.wParam, msg.lParam))
{
bool WasDown = false, IsDown = false, Alt = false;
switch (msg.message)
{
case WM_SETFOCUS:
hasFocus = true;
inputManager.SetFocus(true);
break;
case WM_KILLFOCUS:
hasFocus = false;
inputManager.SetFocus(false);
break;
case WM_SYSKEYDOWN:
case WM_SYSKEYUP:
case WM_KEYDOWN:
case WM_KEYUP:
WasDown = ((msg.lParam & (1 << 30)) != 0);
IsDown = ((msg.lParam & (1 << 31)) == 0);
Alt = ((msg.lParam & (1 << 29)) != 0);
if (WasDown != IsDown)
{
if (IsDown)
{
bool consumed = false;
switch (msg.wParam)
{
case VK_RETURN:
if (Alt)
{
WINDOWPLACEMENT windowPosition = { sizeof(WINDOWPLACEMENT) };
GetWindowPlacement(msg.hwnd, &windowPosition);
ToggleFullscreen(msg.hwnd, windowPosition);
consumed = true;
}
break;
case VK_ESCAPE:
PostQuitMessage(0);
consumed = true;
break;
case VK_F4:
if (Alt)
{
PostQuitMessage(0);
consumed = true;
}
break;
}
if (consumed)
{
break;
}
}
}
if (!hasFocus || !inputManager.KeyEventReceived(msg.wParam, msg.lParam))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
break;
case WM_MOUSEMOVE:
if (hasFocus)
{
int xPosAbsolute = GET_X_LPARAM(msg.lParam);
int yPosAbsolute = GET_Y_LPARAM(msg.lParam);
inputManager.UpdateCursor(xPosAbsolute, yPosAbsolute);
}
else
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
break;
default:
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
}
else
{
inputManager.BeginFrame();
DWORD l_CurrentTime = timeGetTime();
float m_ElapsedTime = (float)(l_CurrentTime - m_PreviousTime)*0.001f;
m_PreviousTime = l_CurrentTime;
application.Update(m_ElapsedTime);
application.Render();
inputManager.EndFrame();
}
}
UnregisterClass(APPLICATION_NAME, wc.hInstance);
}
// Añadir una llamada a la alicación para finalizar/liberar memoria de todos sus datos
s_Context.Dispose();
return 0;
}
//-----------------------------------------------------------------------
// WinMain
//-----------------------------------------------------------------------
int APIENTRY WinMain(HINSTANCE _hInstance, HINSTANCE _hPrevInstance, LPSTR _lpCmdLine, int _nCmdShow)
{
// Register the window class
WNDCLASSEX wc = {sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L, GetModuleHandle(NULL), NULL, NULL, NULL, NULL, APPLICATION_NAME, NULL };
input = new CInputManagerImplementation;
CInputManager::SetCurrentInputManager(input);
input->LoadCommandsFromFile("Data\\input.xml");
RegisterClassEx( &wc );
l_D3DDevice = 0;
l_DeviceContext = 0;
l_SwapChain = 0;
// Calcular el tamano de nuestra ventana
RECT rc = {0, 0, WIDTH_APPLICATION, HEIGHT_APPLICATION};
AdjustWindowRect( &rc, WS_OVERLAPPEDWINDOW, FALSE);
//width = rc.right - rc.left;
//height = rc.bottom - rc.top;
// Create the application's window
HWND hWnd = CreateWindow( APPLICATION_NAME, APPLICATION_NAME, WS_OVERLAPPEDWINDOW, 100, 100, 800, 600, NULL, NULL, wc.hInstance, NULL );
// Añadir aquí el Init de la applicacioón
context.CreateContext(hWnd, WIDTH_APPLICATION, HEIGHT_APPLICATION);
ShowWindow( hWnd, SW_SHOWDEFAULT );
context.CreateBackBuffer(hWnd,800,600);
context.InitStates();
CDebugRender debugRender(context.GetDevice());
CApplication application(&debugRender, &context);
UpdateWindow(hWnd);
MSG msg;
ZeroMemory(&msg, sizeof(msg));
// Añadir en el while la condición de salida del programa de la aplicación
DWORD m_PreviousTime = timeGetTime();
while( msg.message != WM_QUIT )
{
if (PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
{
switch (msg.message)
{
case WM_SYSKEYDOWN:
case WM_SYSKEYUP:
case WM_KEYDOWN:
case WM_KEYUP:
if (!input->KeyEventReceived(msg.wParam, msg.lParam))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
break;
default:
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
else
{
input->BeginFrame();
// Main loop: Añadir aquí el Update y Render de la aplicación principal
l_CurrentTime = timeGetTime();
l_ElapsedTime = (float)(l_CurrentTime - l_PreviousTime)*0.001f;
l_PreviousTime = l_CurrentTime;
application.Update(l_ElapsedTime);
application.Render();
input->EndFrame();
}
}
UnregisterClass( APPLICATION_NAME, wc.hInstance );
// Añadir una llamada a la alicación para finalizar/liberar memoria de todos sus datos
return 0;
}