Lucas de Vries
863 lines
21 KiB
C++
863 lines
21 KiB
C++
#include "main/tick.h"
|
|
#include "main/input_handling.h"
|
|
#include "main/references.h"
|
|
#include "main/logging.h"
|
|
#include "processing.h"
|
|
#include "obj/object.h"
|
|
#include "scene/animation/anim_node_sync.h"
|
|
#include "main/console.h"
|
|
#include "main/initialization.h"
|
|
#include "network/network_manager.h"
|
|
#include "ISoundDevice.h"
|
|
#include "files.h"
|
|
#include "design/projectiles.h"
|
|
#include "render/vertexBuffer.h"
|
|
#include "render/gl_framebuffer.h"
|
|
#include "save_load.h"
|
|
#include <cmath>
|
|
#include <stdio.h>
|
|
#include <stdint.h>
|
|
|
|
extern unsigned drawnSteps, bufferFlushes;
|
|
|
|
GameState game_state = GS_Menu;
|
|
std::string game_locale;
|
|
bool game_running = false;
|
|
bool reload_gui = false;
|
|
|
|
bool fullGC = false;
|
|
|
|
threads::Mutex texDestroyLock;
|
|
std::vector<const render::Texture*> queuedDestroyTextures;
|
|
void queueDestroyTexture(const render::Texture* tex) {
|
|
threads::Lock lock(texDestroyLock);
|
|
queuedDestroyTextures.push_back(tex);
|
|
}
|
|
|
|
void destroyQueuedTextures() {
|
|
if(queuedDestroyTextures.empty())
|
|
return;
|
|
|
|
threads::Lock lock(texDestroyLock);
|
|
for(unsigned i = 0; i < queuedDestroyTextures.size(); ++i)
|
|
delete queuedDestroyTextures[i];
|
|
queuedDestroyTextures.clear();
|
|
}
|
|
|
|
const render::Shader* fsShader = nullptr;
|
|
bool hide_ui = false;
|
|
double ui_scale = 1.0;
|
|
double scale_3d = 1.0;
|
|
double pixelSizeRatio = 1.0;
|
|
double* maxfps = nullptr;
|
|
|
|
//Seconds since last autosave
|
|
double autosaveTimer = 0.0;
|
|
extern double autosaveInterval;
|
|
|
|
threads::Signal scriptTickSignal;
|
|
|
|
extern bool queuedModSwitch;
|
|
extern std::vector<std::string> modSetup;
|
|
|
|
namespace scripts {
|
|
void logException();
|
|
};
|
|
|
|
class RunScriptTick : public processing::Action {
|
|
double time;
|
|
double& logTime;
|
|
bool gcLock;
|
|
scripts::Manager* manager;
|
|
public:
|
|
RunScriptTick(scripts::Manager* Manager, double Time, bool Gc, double& LogTime)
|
|
: time(Time), gcLock(Gc), manager(Manager), logTime(LogTime) {
|
|
}
|
|
|
|
bool run() {
|
|
auto prevSection = enterSection(NS_ScriptTick);
|
|
double start = devices.driver->getAccurateTime();
|
|
#ifndef _DEBUG
|
|
try {
|
|
#endif
|
|
#ifdef TRACE_GC_LOCK
|
|
manager->markGCImpossible();
|
|
#endif
|
|
manager->tick(time);
|
|
devices.network->managerNetworking(manager, time);
|
|
scriptTickSignal.signalDown();
|
|
#ifdef TRACE_GC_LOCK
|
|
manager->markGCPossible();
|
|
#endif
|
|
#ifndef _DEBUG
|
|
}
|
|
catch(...) {
|
|
scripts::logException();
|
|
throw;
|
|
}
|
|
#endif
|
|
logTime = devices.driver->getAccurateTime() - start;
|
|
enterSection(prevSection);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
class RunScriptGC : public processing::Action {
|
|
scripts::Manager* manager;
|
|
bool full;
|
|
public:
|
|
RunScriptGC(scripts::Manager* Manager, bool FullCycle = false)
|
|
: manager(Manager), full(FullCycle) {
|
|
}
|
|
|
|
bool run() {
|
|
double start = devices.driver->getAccurateTime();
|
|
manager->pauseScriptThreads();
|
|
double gcStart = devices.driver->getAccurateTime();
|
|
int gcMode = manager->garbageCollect(full);
|
|
double end = devices.driver->getAccurateTime();
|
|
manager->resumeScriptThreads();
|
|
|
|
#ifdef PROFILE_PROCESSING
|
|
if(end - start > 0.016) {
|
|
const char* name = "Server";
|
|
if(manager == devices.scripts.client)
|
|
name = "Client";
|
|
else if(manager == devices.scripts.menu)
|
|
name = "Menu";
|
|
error("%s GC took %dms (Mode %d)", name, (int)((end - gcStart) * 1.0e3), gcMode);
|
|
if(gcStart - start > 0.01)
|
|
error("%s script pausing took %dms", name, (int)((gcStart - start) * 1.0e3));
|
|
}
|
|
#endif
|
|
|
|
scriptTickSignal.signalDown();
|
|
return true;
|
|
}
|
|
};
|
|
|
|
unsigned animationThreadCount = 6;
|
|
threads::Signal animationSignal, activeAnimCount;
|
|
threads::Mutex animDataLock;
|
|
double nearestNode = 9.0e35, furthestNode = 0.0;
|
|
double animation_s = 0.0, render_s = 0.0, present_s = 0.0;
|
|
threads::atomic_int animIndex(-1), animProcessed;
|
|
|
|
//Animates some nodes, returning how long it processed
|
|
double animateSomeNodes(int maxNodes) {
|
|
if(animIndex < 0)
|
|
return 0.0;
|
|
|
|
double furthest = 0.0;
|
|
double start = devices.driver->getAccurateTime();
|
|
|
|
auto* nodes = &devices.scene->children.front();
|
|
int count = (int)devices.scene->children.size();
|
|
int animCount = count/(animationThreadCount*16);
|
|
if(animCount == 0)
|
|
animCount = 1;
|
|
|
|
int index = (animIndex -= animCount);
|
|
while(index >= 0) {
|
|
int animated = 0;
|
|
for(int i = index; i > index - animCount && i >= 0; --i) {
|
|
auto* node = nodes[i];
|
|
node->animate();
|
|
++animated;
|
|
|
|
double d = node->sortDistance + node->abs_scale;
|
|
if(d > furthest)
|
|
furthest = d;
|
|
}
|
|
|
|
if(animated != 0)
|
|
animProcessed += animated;
|
|
|
|
maxNodes -= animated;
|
|
if(maxNodes < 0)
|
|
break;
|
|
|
|
index = (animIndex -= animCount);
|
|
}
|
|
|
|
animDataLock.lock();
|
|
//if(nearest < nearestNode)
|
|
// nearestNode = nearest;
|
|
if(furthest > furthestNode)
|
|
furthestNode = furthest;
|
|
animDataLock.release();
|
|
|
|
return devices.driver->getAccurateTime() - start;
|
|
}
|
|
|
|
volatile bool EndAnimationThreads = false;
|
|
threads::threadreturn threadcall animateNodes(void* arg) {
|
|
enterSection(NS_Animation);
|
|
double& logTime = *(double*)arg;
|
|
initNewThread();
|
|
activeAnimCount.signalUp();
|
|
//threads::setThreadPriority(threads::TP_High);
|
|
|
|
#ifdef TRACE_GC_LOCK
|
|
devices.scripts.menu->markGCImpossible();
|
|
devices.scripts.client->markGCImpossible();
|
|
#endif
|
|
while(true) {
|
|
while(animIndex < 0 && !EndAnimationThreads)
|
|
threads::sleep(1);
|
|
if(EndAnimationThreads)
|
|
break;
|
|
|
|
animationSignal.signalUp();
|
|
|
|
double /*nearest = 9.0e35,*/ furthest = 0.0;
|
|
double start = devices.driver->getAccurateTime();
|
|
|
|
if(!devices.scene->children.empty()) {
|
|
auto* nodes = &devices.scene->children.front();
|
|
int animCount = (int)devices.scene->children.size()/(animationThreadCount*16);
|
|
if(animCount == 0)
|
|
animCount = 1;
|
|
|
|
int index = (animIndex -= animCount);
|
|
while(index >= 0) {
|
|
int animated = 0;
|
|
for(int i = index; i > index - animCount && i >= 0; --i) {
|
|
auto* node = nodes[i];
|
|
node->animate();
|
|
++animated;
|
|
|
|
double d = node->sortDistance + node->abs_scale;
|
|
if(d > furthest)
|
|
furthest = d;
|
|
}
|
|
|
|
if(animated != 0)
|
|
animProcessed += animated;
|
|
|
|
index = (animIndex -= animCount);
|
|
}
|
|
}
|
|
|
|
logTime = devices.driver->getAccurateTime() - start;
|
|
|
|
animDataLock.lock();
|
|
//if(nearest < nearestNode)
|
|
// nearestNode = nearest;
|
|
if(furthest > furthestNode)
|
|
furthestNode = furthest;
|
|
animDataLock.release();
|
|
|
|
animationSignal.signalDown();
|
|
threads::sleep(1);
|
|
}
|
|
#ifdef TRACE_GC_LOCK
|
|
devices.scripts.menu->markGCPossible();
|
|
devices.scripts.client->markGCPossible();
|
|
#endif
|
|
|
|
activeAnimCount.signalDown();
|
|
cleanupThread();
|
|
return 0;
|
|
}
|
|
|
|
double frameLen_s = 0, frameTime_s = 0;
|
|
double realFrameLen = 0, realFrameTime;
|
|
int frameTime_ms = 0, frameLen_ms = 0;
|
|
unsigned frameNumber = 0;
|
|
|
|
std::vector<double> frames;
|
|
unsigned max_frames = 120;
|
|
|
|
void shader_gameTime(float* pFloats,unsigned short n,void*) {
|
|
do {
|
|
*pFloats = (float)frameTime_s;
|
|
++pFloats;
|
|
} while(--n);
|
|
}
|
|
|
|
void shader_frameTime(float* pFloats,unsigned short n,void*) {
|
|
do {
|
|
*pFloats = (float)realFrameTime;
|
|
++pFloats;
|
|
} while(--n);
|
|
}
|
|
|
|
void shader_gameTime_cycle(float* pFloats,unsigned short n,void* pArgs) {
|
|
float* period = (float*)pArgs;
|
|
do {
|
|
*pFloats = (float)(std::fmod(frameTime_s, double(*period)) / double(*period));
|
|
++period; ++pFloats;
|
|
} while(--n);
|
|
}
|
|
|
|
void shader_frameTime_cycle(float* pFloats,unsigned short n,void* pArgs) {
|
|
float* period = (float*)pArgs;
|
|
do {
|
|
*pFloats = (float)(std::fmod(realFrameTime, double(*period)) / double(*period));
|
|
++period; ++pFloats;
|
|
} while(--n);
|
|
}
|
|
|
|
void shader_gameTime_cycle_abs(float* pFloats,unsigned short n,void* pArgs) {
|
|
float* period = (float*)pArgs;
|
|
do {
|
|
*pFloats = (float)std::fmod(frameTime_s, double(*period));
|
|
++period; ++pFloats;
|
|
} while(--n);
|
|
}
|
|
|
|
void shader_frameTime_cycle_abs(float* pFloats,unsigned short n,void* pArgs) {
|
|
float* period = (float*)pArgs;
|
|
do {
|
|
*pFloats = (float)std::fmod(realFrameTime, double(*period));
|
|
++period; ++pFloats;
|
|
} while(--n);
|
|
}
|
|
|
|
void shader_pixelRatio(float* pFloats,unsigned short n,void* pArgs) {
|
|
*pFloats = (float)pixelSizeRatio;
|
|
}
|
|
|
|
#ifdef PROFILE_LOCKS
|
|
double lockProfileTimer = 0.0;
|
|
bool printLockProfile = false;
|
|
bool requireObserved = false;
|
|
#endif
|
|
|
|
double menuTickTime = 0, serverTickTime = 0, clientTickTime = 0, animationTime = 0;
|
|
double* animTimes = nullptr;
|
|
|
|
extern double lastLockGlobalUpdate, nextTargetUpdateTime, nextScriptGCTime;
|
|
|
|
void resetGameTime() {
|
|
nextTargetUpdateTime = lastLockGlobalUpdate = devices.driver->getGameTime();
|
|
frameTime_s = devices.driver->getGameTime() - 0.25;
|
|
nextScriptGCTime = devices.driver->getFrameTime();
|
|
}
|
|
|
|
void endAnimation() {
|
|
if(animTimes) {
|
|
EndAnimationThreads = true;
|
|
activeAnimCount.wait(0);
|
|
EndAnimationThreads = false;
|
|
delete[] animTimes;
|
|
animTimes = nullptr;
|
|
}
|
|
}
|
|
|
|
void idleLoadResources(int maxPriority) {
|
|
if(devices.library.processTextures(maxPriority, true))
|
|
return;
|
|
if(devices.library.processMeshes(maxPriority, 1))
|
|
return;
|
|
if(devices.library.processTextures(INT_MIN, true))
|
|
return;
|
|
if(devices.library.processMeshes(INT_MIN, 1))
|
|
return;
|
|
}
|
|
|
|
GameState prev_state = GS_Menu;
|
|
void tickGlobal(bool hasScripts) {
|
|
#ifdef TRACE_GC_LOCK
|
|
devices.scripts.menu->markGCImpossible();
|
|
devices.scripts.client->markGCImpossible();
|
|
#endif
|
|
|
|
//Get frame timings
|
|
static int lastRender = 0;
|
|
|
|
if(queuedModSwitch) {
|
|
queuedModSwitch = false;
|
|
destroyMod();
|
|
initMods(modSetup);
|
|
game_state = GS_Menu;
|
|
}
|
|
|
|
if(game_state != prev_state) {
|
|
if(hasScripts) {
|
|
if(game_running && devices.scripts.client)
|
|
devices.scripts.client->stateChange();
|
|
if(devices.scripts.menu)
|
|
devices.scripts.menu->stateChange();
|
|
}
|
|
prev_state = game_state;
|
|
}
|
|
|
|
++frameNumber;
|
|
|
|
double frame_time = devices.driver->getGameTime() - 0.25;
|
|
frameTime_ms = devices.driver->getTime();
|
|
|
|
double real_frame = devices.driver->getFrameTime();
|
|
realFrameLen = real_frame - realFrameTime;
|
|
realFrameTime = real_frame;
|
|
|
|
int frame_ms = frameTime_ms - lastRender;
|
|
lastRender = frameTime_ms;
|
|
|
|
double frame_s = frame_time - frameTime_s;
|
|
frameTime_s = frame_time;
|
|
|
|
if(frame_ms > 250 || frame_s > 0.25) {
|
|
frame_ms = 250;
|
|
frame_s = 0.25;
|
|
}
|
|
else if(frame_ms < 0 || frame_s < 0.0) {
|
|
frame_ms = 0;
|
|
frame_s = 0.0;
|
|
}
|
|
|
|
frameLen_s = frame_s;
|
|
frameLen_ms = frame_ms;
|
|
|
|
frames.push_back(realFrameLen);
|
|
if(frames.size() > max_frames)
|
|
frames.erase(frames.begin());
|
|
|
|
//Run network manager tick
|
|
devices.network->tick(realFrameLen);
|
|
|
|
//Do lock profiling
|
|
#ifdef PROFILE_LOCKS
|
|
lockProfileTimer += frame_s;
|
|
if(lockProfileTimer >= 1.0) {
|
|
lockProfileTimer = 0.0;
|
|
|
|
if(printLockProfile) {
|
|
threads::profileMutexCycle([](threads::Mutex* mtx) {
|
|
if((mtx->observed || !requireObserved) && mtx->profileCount > 0) {
|
|
print("%s: %d locks", mtx->name.c_str(), mtx->profileCount);
|
|
}
|
|
});
|
|
threads::profileReadWriteMutexCycle([](threads::ReadWriteMutex* mtx) {
|
|
if((mtx->observed || !requireObserved) && (mtx->profileReadCount > 0 || mtx->profileWriteCount > 0)) {
|
|
print("%s: %d read, %d write", mtx->name.c_str(), mtx->profileReadCount, mtx->profileWriteCount);
|
|
}
|
|
});
|
|
|
|
printLockProfile = false;
|
|
}
|
|
else {
|
|
threads::profileMutexCycle(0);
|
|
threads::profileReadWriteMutexCycle(0);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
idleLoadResources(isPreloading() ? -10 : INT_MIN);
|
|
|
|
//Do script GCs
|
|
#ifdef TRACE_GC_LOCK
|
|
devices.scripts.menu->markGCPossible();
|
|
devices.scripts.client->markGCPossible();
|
|
#endif
|
|
|
|
if(hasScripts) {
|
|
scriptTickSignal.signal(1);
|
|
processing::queueAction(new RunScriptGC(devices.scripts.menu, fullGC));
|
|
|
|
if(game_running) {
|
|
scriptTickSignal.signalUp(1);
|
|
processing::queueAction(new RunScriptGC(devices.scripts.client, fullGC));
|
|
}
|
|
|
|
fullGC = false;
|
|
|
|
while(!scriptTickSignal.check(0)) {
|
|
processing::run();
|
|
threads::sleep(0);
|
|
}
|
|
}
|
|
|
|
#ifdef TRACE_GC_LOCK
|
|
devices.scripts.menu->markGCImpossible();
|
|
devices.scripts.client->markGCImpossible();
|
|
#endif
|
|
|
|
//Run all the script ticks
|
|
if(hasScripts) {
|
|
scriptTickSignal.signal(1);
|
|
processing::queueAction(new RunScriptTick(devices.scripts.menu, realFrameLen, false, menuTickTime));
|
|
|
|
if(game_running) {
|
|
scriptTickSignal.signalUp(2);
|
|
processing::queueAction(new RunScriptTick(devices.scripts.server, frameLen_s, true, serverTickTime));
|
|
processing::queueAction(new RunScriptTick(devices.scripts.client, realFrameLen, false, clientTickTime));
|
|
}
|
|
}
|
|
|
|
#ifdef TRACE_GC_LOCK
|
|
devices.scripts.menu->markGCPossible();
|
|
devices.scripts.client->markGCPossible();
|
|
#endif
|
|
}
|
|
|
|
std::unordered_map<std::string,time_t> guiModuleTimes;
|
|
void tickGuiReload() {
|
|
if(!devices.scripts.client)
|
|
return;
|
|
for(auto it = devices.scripts.client->modules.begin(); it != devices.scripts.client->modules.end(); ++it) {
|
|
scripts::Module& mod = *it->second;
|
|
scripts::File& fl = *mod.file;
|
|
|
|
time_t mtime = getModifiedTime(fl.path);
|
|
auto f = guiModuleTimes.find(mod.name);
|
|
if(f == guiModuleTimes.end()) {
|
|
guiModuleTimes[mod.name] = mtime;
|
|
}
|
|
else {
|
|
if(f->second < mtime)
|
|
devices.scripts.client->reload(mod.name);
|
|
guiModuleTimes[mod.name] = mtime;
|
|
}
|
|
}
|
|
}
|
|
|
|
static render::Texture* renderTarget = nullptr;
|
|
void getFrameRender(Image& img) {
|
|
if(!game_running || !devices.scripts.client)
|
|
return;
|
|
|
|
auto prev_state = game_state;
|
|
game_state = GS_Menu;
|
|
|
|
devices.scripts.client->preRender(0.0);
|
|
devices.scripts.client->render(0.0);
|
|
|
|
renderTarget->save(img);
|
|
devices.render->setRenderTarget(nullptr);
|
|
|
|
game_state = prev_state;
|
|
}
|
|
|
|
void renderFrame(scripts::Manager* uiScript, scripts::Manager* renderScript) {
|
|
drawnSteps = 0;
|
|
bufferFlushes = 0;
|
|
for(unsigned i = 0; i < render::FC_COUNT; ++i)
|
|
render::vbFlushCounts[i] = 0;
|
|
|
|
destroyQueuedTextures();
|
|
|
|
#ifdef TRACE_GC_LOCK
|
|
devices.scripts.menu->markGCImpossible();
|
|
devices.scripts.client->markGCImpossible();
|
|
#endif
|
|
|
|
vec2i screenSize(devices.driver->win_width,devices.driver->win_height);
|
|
bool render = screenSize.width != 0 && screenSize.height != 0;
|
|
|
|
if(render) {
|
|
if(!renderTarget)
|
|
renderTarget = devices.render->createRenderTarget(screenSize * scale_3d);
|
|
if(renderTarget->size != screenSize * scale_3d) {
|
|
delete renderTarget;
|
|
renderTarget = devices.render->createRenderTarget(screenSize * scale_3d);
|
|
}
|
|
}
|
|
|
|
devices.sound->setListenerData(vec3f(devices.render->cam_pos), vec3f(), vec3f(devices.render->cam_pos + devices.render->cam_facing), vec3f(devices.render->cam_up));
|
|
|
|
if(!Object::GALAXY_CREATION)
|
|
scene::processNodeEvents();
|
|
|
|
if(renderScript)
|
|
renderScript->preRender(realFrameLen);
|
|
|
|
nearestNode = 9.0e35; furthestNode = 0.0;
|
|
|
|
static bool dumpAnimTimes = false;
|
|
if(!animTimes) {
|
|
animationThreadCount = std::max(1u,devices.driver->getProcessorCount()-1);
|
|
animTimes = new double[animationThreadCount]();
|
|
for(unsigned i = 0; i < animationThreadCount; ++i)
|
|
threads::createThread(animateNodes, &animTimes[i]);
|
|
#ifdef PROFILE_ANIMATION
|
|
console.addCommand("anim_times", [](argList& args) {
|
|
dumpAnimTimes = true;
|
|
}, true);
|
|
#endif
|
|
}
|
|
|
|
render::Texture* rt = nullptr;
|
|
const render::Shader* shad = nullptr;
|
|
if(fsShader || scale_3d != 1.0) {
|
|
rt = renderTarget;
|
|
shad = fsShader;
|
|
}
|
|
|
|
devices.library.reloadWatchedResources();
|
|
|
|
if(render) {
|
|
devices.render->setScreenSize(screenSize.x, screenSize.y);
|
|
devices.render->setRenderTarget(rt);
|
|
}
|
|
|
|
if(screenSize.y != 0)
|
|
pixelSizeRatio = (double)screenSize.y / 1024.0;
|
|
|
|
double animTotal = 0.0;
|
|
{
|
|
int nodeCount = (int)devices.scene->children.size();
|
|
animProcessed = 0;
|
|
|
|
//Animate nodes, signaling the animation threads to work if they get time
|
|
animIndex = nodeCount-1;
|
|
unsigned loops = 0;
|
|
while(true) {
|
|
bool waiting = false;
|
|
|
|
if(!scriptTickSignal.check(0)) {
|
|
waiting = true;
|
|
processing::run(true);
|
|
}
|
|
if(animProcessed != nodeCount) {
|
|
waiting = true;
|
|
animTotal += animateSomeNodes(128);
|
|
}
|
|
|
|
if(!waiting)
|
|
break;
|
|
if(++loops % 100 == 0)
|
|
threads::sleep(0);
|
|
}
|
|
|
|
//Sort the catch-all parent
|
|
devices.scene->sortChildren();
|
|
|
|
//Wait for all animation threads to report in
|
|
while(!animationSignal.check(0))
|
|
threads::sleep(0);
|
|
|
|
for(unsigned i = 0; i < animationThreadCount; ++i) {
|
|
double t = animTimes[i];
|
|
animTotal += t;
|
|
}
|
|
#ifdef PROFILE_ANIMATION
|
|
if(dumpAnimTimes)
|
|
scene::dumpAnimationProfile();
|
|
dumpAnimTimes = false;
|
|
#else
|
|
(void)dumpAnimTimes;
|
|
#endif
|
|
}
|
|
|
|
#ifdef TRACE_GC_LOCK
|
|
devices.scripts.menu->markGCImpossible();
|
|
devices.scripts.client->markGCImpossible();
|
|
#endif
|
|
|
|
double animation_end = devices.driver->getAccurateTime();
|
|
animation_s = animTotal;
|
|
|
|
auto prevSection = enterSection(NS_Render);
|
|
|
|
if(render) {
|
|
devices.render->setDefaultRenderState();
|
|
|
|
//Animation system tells us the near and far distances of everything that gets rendered
|
|
devices.render->setNearFarPlanes(1.0, furthestNode * 1.1);
|
|
|
|
//3D prepare is done by scripts, since it needs the camera
|
|
devices.render->clearRenderPrepared();
|
|
if(renderScript)
|
|
renderScript->render(realFrameLen);
|
|
|
|
if(rt) {
|
|
devices.render->setRenderTarget(0);
|
|
|
|
if(devices.render->isRenderPrepared()) {
|
|
render::RenderState rs;
|
|
if(shad)
|
|
rs.shader = shad;
|
|
else
|
|
rs.shader = devices.library["Fullscreen"];
|
|
rs.lighting = false;
|
|
rs.culling = render::FC_None;
|
|
rs.depthWrite = false;
|
|
rs.depthTest = render::DT_NoDepthTest;
|
|
rs.constant = false;
|
|
rs.textures[0] = rt;
|
|
rs.textures[7] = ((render::glFrameBuffer*)rt)->depthTexture; //fuck you framebuffers aren't textures
|
|
|
|
auto* buffer = render::VertexBufferTCV::fetch(&rs);
|
|
auto* verts = buffer->request(1, render::PT_Quads);
|
|
|
|
verts[0].set(vec2f(0,0));
|
|
verts[1].set(vec2f(1,0));
|
|
verts[2].set(vec2f(1,1));
|
|
verts[3].set(vec2f(0,1));
|
|
|
|
buffer->draw();
|
|
}
|
|
}
|
|
}
|
|
|
|
//Check if we should scale the 2D interface
|
|
if(render && !hide_ui) {
|
|
static render::Texture* uirt = 0;
|
|
vec2i uiArea;
|
|
if(ui_scale != 1.0) {
|
|
uiArea = vec2d(devices.driver->win_width, devices.driver->win_height) / ui_scale;
|
|
|
|
if(uirt == 0) {
|
|
uirt = devices.render->createRenderTarget(uiArea);
|
|
}
|
|
else {
|
|
if(uirt->size != uiArea) {
|
|
delete uirt;
|
|
uirt = devices.render->createRenderTarget(uiArea);
|
|
}
|
|
}
|
|
|
|
devices.render->setScreenSize(uiArea.x, uiArea.y);
|
|
devices.render->setRenderTarget(uirt, true);
|
|
}
|
|
|
|
//2D prepare is done before scripts
|
|
devices.render->prepareRender2D();
|
|
if(uiScript)
|
|
uiScript->draw();
|
|
|
|
//Scale the 2D interface
|
|
if(uiArea.x != 0) {
|
|
devices.render->setScreenSize(screenSize.x, screenSize.y);
|
|
devices.render->setRenderTarget(0);
|
|
devices.render->prepareRender2D();
|
|
|
|
render::RenderState rs;
|
|
rs.lighting = false;
|
|
rs.constant = false;
|
|
rs.culling = render::FC_None;
|
|
rs.baseMat = render::MAT_Overlay;
|
|
rs.shader = devices.library["Fullscreen"];
|
|
rs.depthWrite = false;
|
|
rs.depthTest = render::DT_NoDepthTest;
|
|
rs.filterMin = render::TF_Linear;
|
|
rs.filterMag = render::TF_Linear;
|
|
rs.textures[0] = uirt;
|
|
|
|
auto* buffer = render::VertexBufferTCV::fetch(&rs);
|
|
auto* verts = buffer->request(1, render::PT_Quads);
|
|
|
|
verts[0].set(vec2f(0,0));
|
|
verts[1].set(vec2f(1,0));
|
|
verts[2].set(vec2f(1,1));
|
|
verts[3].set(vec2f(0,1));
|
|
|
|
buffer->draw();
|
|
}
|
|
}
|
|
|
|
if(render) {
|
|
if(hide_ui)
|
|
devices.render->prepareRender2D();
|
|
console.render(*devices.render);
|
|
render::renderVertexBuffers();
|
|
}
|
|
else {
|
|
threads::sleep(1);
|
|
}
|
|
|
|
double render_end = devices.driver->getAccurateTime();
|
|
|
|
devices.driver->swapBuffers(maxfps && *maxfps > 0 ? 1.0 / *maxfps : 0.0);
|
|
|
|
double present_end = devices.driver->getAccurateTime();
|
|
|
|
render_s = render_end - animation_end;
|
|
present_s = present_end - render_end;
|
|
|
|
#ifdef TRACE_GC_LOCK
|
|
devices.scripts.menu->markGCPossible();
|
|
devices.scripts.client->markGCPossible();
|
|
#endif
|
|
|
|
#ifdef _DEBUG
|
|
devices.render->reportErrors();
|
|
#endif
|
|
|
|
enterSection(prevSection);
|
|
}
|
|
|
|
void tickConsole() {
|
|
tickGlobal(false);
|
|
renderFrame(0, 0);
|
|
}
|
|
|
|
void tickGame() {
|
|
//General tick
|
|
tickGlobal();
|
|
|
|
if(devices.driver->getGameSpeed() > 0 && !devices.network->isClient) {
|
|
autosaveTimer += realFrameLen;
|
|
|
|
auto* interval = devices.settings.engine.getSetting("dAutosaveMinutes");
|
|
if(interval && interval->getDouble() >= 1.0 && autosaveTimer > interval->getDouble() * 60.0) {
|
|
int maxAutosaves = 1;
|
|
auto* count = devices.settings.engine.getSetting("iAutosaveCount");
|
|
if(count)
|
|
maxAutosaves = count->getInteger();
|
|
std::string prevName;
|
|
if(maxAutosaves > 1) {
|
|
for(int index = maxAutosaves; index > 0; --index) {
|
|
std::string fname = "autosave";
|
|
if(index != 1)
|
|
fname += toString(index);
|
|
fname += ".sr2";
|
|
fname = path_join(devices.mods.getGlobalProfile("saves"), fname);
|
|
|
|
if(fileExists(fname)) {
|
|
if(index == maxAutosaves)
|
|
remove(fname.c_str());
|
|
else
|
|
rename(fname.c_str(), prevName.c_str());
|
|
}
|
|
prevName = fname;
|
|
}
|
|
}
|
|
|
|
processing::pause();
|
|
saveGame(path_join(devices.mods.getGlobalProfile("saves"), "autosave.sr2"));
|
|
processing::resume();
|
|
|
|
autosaveTimer = 0.0;
|
|
}
|
|
}
|
|
|
|
if(reload_gui)
|
|
tickGuiReload();
|
|
|
|
renderFrame(devices.scripts.client, devices.scripts.client);
|
|
inputTick();
|
|
processing::runIsolation();
|
|
}
|
|
|
|
void tickMenu() {
|
|
//General tick
|
|
tickGlobal();
|
|
renderFrame(devices.scripts.menu, devices.scripts.menu);
|
|
inputTick();
|
|
}
|
|
|
|
std::unordered_map<std::string, time_t> monitoredFiles;
|
|
void monitorFile(const std::string& filename) {
|
|
if(monitor_files)
|
|
monitoredFiles[filename] = getModifiedTime(filename);
|
|
}
|
|
|
|
bool tickMonitor() {
|
|
if(isPreloading())
|
|
return false;
|
|
|
|
foreach(it, monitoredFiles) {
|
|
time_t mtime = getModifiedTime(it->first);
|
|
if(mtime > it->second) {
|
|
monitoredFiles.clear();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|