void CGhost::OnMessage(int MsgType, void *pRawMsg)
{
// check for messages from server
if(MsgType == NETMSGTYPE_SV_KILLMSG)
{
CNetMsg_Sv_KillMsg *pMsg = (CNetMsg_Sv_KillMsg *)pRawMsg;
if(pMsg->m_Victim == m_pClient->m_Snap.m_LocalClientID)
{
if(m_Recording)
StopRecord();
StopRender();
m_LastDeathTick = Client()->GameTick();
}
}
else if(MsgType == NETMSGTYPE_SV_CHAT)
{
CNetMsg_Sv_Chat *pMsg = (CNetMsg_Sv_Chat *)pRawMsg;
if(pMsg->m_ClientID == -1 && m_Recording)
{
char aName[MAX_NAME_LENGTH];
int Time = CRaceHelper::TimeFromFinishMessage(pMsg->m_pMessage, aName, sizeof(aName));
if(Time > 0 && str_comp(aName, m_pClient->m_aClients[m_pClient->m_Snap.m_LocalClientID].m_aName) == 0)
{
StopRecord(Time);
StopRender();
}
}
}
}
void CGhost::OnReset()
{
StopRecord();
StopRender();
m_LastDeathTick = -1;
m_LastRaceTick = -1;
}
void CGhost::CheckStart()
{
int RaceTick = -m_pClient->m_Snap.m_pGameInfoObj->m_WarmupTimer;
int RenderTick = m_NewRenderTick;
if(m_LastRaceTick != RaceTick && Client()->GameTick() - RaceTick < Client()->GameTickSpeed())
{
if(m_Rendering && m_RenderingStartedByServer) // race restarted: stop rendering
StopRender();
if(m_Recording && m_LastRaceTick != -1) // race restarted: activate restarting for local start detection so we have a smooth transition
m_AllowRestart = true;
if(m_LastRaceTick == -1) // no restart: reset rendering preparations
m_NewRenderTick = -1;
if(GhostRecorder()->IsRecording()) // race restarted: stop recording
GhostRecorder()->Stop(0, -1);
int StartTick = RaceTick;
CServerInfo ServerInfo;
Client()->GetServerInfo(&ServerInfo);
if(IsDDRace(&ServerInfo)) // the client recognizes the start one tick earlier than ddrace servers
StartTick--;
StartRecord(StartTick);
RenderTick = StartTick;
}
TryRenderStart(RenderTick, true);
}
void GlutKeyboard(unsigned char key, int x, int y)
{
switch ( key ) {
case 27: // ESC
exit(0);
break;
case ' ':
switch ( mode ) {
case MODE_READY:
mode = MODE_RENDERING;
viewMode = VIEWMODE_IMAGE;
if ( dofImage ) {
Color24 *p = renderImage.GetPixels();
for ( int i=0; i<camera.imgWidth*camera.imgHeight; i++ ) p[i] = dofImage[i];
} else {
DrawScene();
glReadPixels( 0, 0, renderImage.GetWidth(), renderImage.GetHeight(), GL_RGB, GL_UNSIGNED_BYTE, renderImage.GetPixels() );
}
startTime = time(NULL);
BeginRender();
break;
case MODE_RENDERING:
mode = MODE_READY;
StopRender();
glutPostRedisplay();
break;
case MODE_RENDER_DONE:
mode = MODE_READY;
viewMode = VIEWMODE_OPENGL;
glutPostRedisplay();
break;
}
break;
case '1':
viewAngle1 = viewAngle2 = 0;
viewMode = VIEWMODE_OPENGL;
glutPostRedisplay();
break;
case '2':
viewMode = VIEWMODE_IMAGE;
glutPostRedisplay();
break;
case '3':
viewMode = VIEWMODE_Z;
glutPostRedisplay();
break;
case '4':
viewMode = VIEWMODE_SAMPLECOUNT;
glutPostRedisplay();
break;
case '5':
viewMode = VIEWMODE_IRRADCOMP;
glutPostRedisplay();
break;
}
}
void CGhost::CheckStartLocal(bool Predicted)
{
if(Predicted) // rendering
{
int RenderTick = m_NewRenderTick;
vec2 PrevPos = m_pClient->m_PredictedPrevChar.m_Pos;
vec2 Pos = m_pClient->m_PredictedChar.m_Pos;
if(((!m_Rendering && RenderTick == -1) || m_AllowRestart) && CRaceHelper::IsStart(m_pClient, PrevPos, Pos))
{
if(m_Rendering && !m_RenderingStartedByServer) // race restarted: stop rendering
StopRender();
RenderTick = Client()->PredGameTick();
}
TryRenderStart(RenderTick, false);
}
else // recording
{
int PrevTick = m_pClient->m_Snap.m_pLocalPrevCharacter->m_Tick;
int CurTick = m_pClient->m_Snap.m_pLocalCharacter->m_Tick;
vec2 PrevPos = vec2(m_pClient->m_Snap.m_pLocalPrevCharacter->m_X, m_pClient->m_Snap.m_pLocalPrevCharacter->m_Y);
vec2 Pos = vec2(m_pClient->m_Snap.m_pLocalCharacter->m_X, m_pClient->m_Snap.m_pLocalCharacter->m_Y);
// detecting death, needed because race allows immediate respawning
if((!m_Recording || m_AllowRestart) && m_LastDeathTick < PrevTick)
{
// estimate the exact start tick
int RecordTick = -1;
int TickDiff = CurTick - PrevTick;
for(int i = 0; i < TickDiff; i++)
{
if(CRaceHelper::IsStart(m_pClient, mix(PrevPos, Pos, (float)i / TickDiff), mix(PrevPos, Pos, (float)(i + 1) / TickDiff)))
{
RecordTick = PrevTick + i + 1;
if(!m_AllowRestart)
break;
}
}
if(RecordTick != -1)
{
if(GhostRecorder()->IsRecording()) // race restarted: stop recording
GhostRecorder()->Stop(0, -1);
StartRecord(RecordTick);
}
}
}
}
void GlutKeyboard(unsigned char key, int x, int y)
{
switch ( key ) {
case 27: // ESC
exit(0);
break;
case ' ':
switch ( mode ) {
case MODE_READY:
mode = MODE_RENDERING;
viewMode = VIEWMODE_IMAGE;
DrawScene();
glReadPixels( 0, 0, renderImage.GetWidth(), renderImage.GetHeight(), GL_RGB, GL_UNSIGNED_BYTE, renderImage.GetPixels() );
startTime = time(NULL);
BeginRender();
break;
case MODE_RENDERING:
mode = MODE_READY;
StopRender();
glutPostRedisplay();
break;
case MODE_RENDER_DONE:
mode = MODE_READY;
viewMode = VIEWMODE_OPENGL;
glutPostRedisplay();
break;
}
break;
case '1':
viewAngle1 = viewAngle2 = 0;
viewMode = VIEWMODE_OPENGL;
glutPostRedisplay();
break;
case '2':
viewMode = VIEWMODE_IMAGE;
glutPostRedisplay();
break;
case '3':
viewMode = VIEWMODE_Z;
glutPostRedisplay();
break;
}
}
CFDE_RenderContext::~CFDE_RenderContext() {
StopRender();
}
// --[ Method ]---------------------------------------------------------------
//
// - Class : CAviRenderer
// - prototype : ~CAviRenderer()
//
// - Purpose : CAviRenderer's destructor.
//
// -----------------------------------------------------------------------------
CAviRenderer::~CAviRenderer()
{
StopRender();
}
void vfeSession::WorkerThread()
{
WorkerThreadStartup();
if (POVMS_Init() == false)
m_LastError = vfePOVMSInitFailed ;
else if (POVMS_OpenContext (const_cast<void **>(&pov::POVMS_GUI_Context)) != kNoError)
m_LastError = vfeOpenContextFailed ;
else if (POVMS_GetContextAddress (pov::POVMS_GUI_Context, const_cast<void **>(&pov::GUIThreadAddr)) != kNoErr)
m_LastError = vfeConnectFailed ;
if (m_LastError != vfeNoError)
{
m_InitializeEvent.notify_all ();
return;
}
m_BackendThread = povray_init (boost::bind(&vfeSession::BackendThreadNotify, this), const_cast<void **>(&pov::RenderThreadAddr)) ;
POVMS_Output_Context = pov::POVMS_GUI_Context ;
m_Console = shared_ptr<vfeConsole> (new vfeConsole(this, m_ConsoleWidth)) ;
POVMS_Object obj ;
m_Frontend = new VirtualFrontEnd (*this, POVMS_Output_Context, (POVMSAddress) pov::RenderThreadAddr, obj, NULL, m_Console) ;
if (m_Frontend == NULL)
throw POV_EXCEPTION_STRING ("Worker thread failed to create frontend");
m_BackendState = m_Frontend->GetState();
m_InitializeEvent.notify_all ();
try
{
while (m_WorkerThreadShutdownRequest == false)
{
if (m_BackendThreadExited)
{
// the main thread (created by pov_init()) has exited. this is not good.
// we could re-start it, but given it's only supposed to exit under critical
// circumstances, we won't risk it and instead will alert the user. note that
// if we are implementing a detached frontend and are not attached, this may
// not be possible, but there's not a lot we can do about that.
throw vfeCriticalError("Backend worker thread shut down prematurely: please re-start POV-Ray.");
}
try
{
while (POVMS_ProcessMessages (pov::POVMS_GUI_Context, true, true) == kFalseErr)
{
m_MessageCount++ ;
ProcessFrontend () ;
if (m_RenderCancelRequested == true || m_RequestFlag != rqNoRequest || m_WorkerThreadShutdownRequest == true)
break ;
}
ProcessFrontend () ;
if (m_RenderCancelRequested)
{
POV_LONG ts = GetTimestamp() + 2500;
m_RenderCancelled = true;
while (POVMS_ProcessMessages (pov::POVMS_GUI_Context, false, false) == kFalseErr)
{
ProcessFrontend () ;
// don't allow it to take more than 2.5 seconds to process remaining messages
// (this should not happen unless our thread priority is too low)
if (GetTimestamp() > ts)
break;
}
ProcessFrontend () ;
if (ProcessCancelRender() == true)
m_RenderCancelRequested = false;
}
if (m_RequestFlag != rqNoRequest)
{
int rq = m_RequestFlag;
m_RequestFlag = rqNoRequest;
switch (rq)
{
case rqPauseRequest:
m_RequestResult = m_Frontend->Pause() ? 1 : 0;
break;
case rqResumeRequest:
m_RequestResult = m_Frontend->Resume() ? 1 : 0;
break;
}
m_RequestEvent.notify_all ();
}
boost::thread::yield();
}
catch (pov_base::Exception& e)
{
SetFailed();
if (StopRender(e.what()) == false)
m_RenderCancelRequested = true;
}
catch (vfeException& e)
{
SetFailed();
if (StopRender(e.what()) == false)
m_RenderCancelRequested = true;
}
catch (std::exception& e)
{
SetFailed();
if (StopRender(e.what()) == false)
m_RenderCancelRequested = true;
}
}
}
catch (vfeCriticalError& e)
{
m_HadCriticalError = true;
m_Failed = true;
m_LastError = vfeCaughtCriticalError;
NotifyCriticalError (e.what(), e.Filename().c_str(), e.Line()) ;
}
catch (vfeException&)
{
m_Failed = true;
m_LastError = vfeCaughtException;
}
catch (std::exception&)
{
m_Failed = true;
m_LastError = vfeCaughtException;
}
if (m_LastError == vfeCaughtException || m_LastError == vfeCaughtCriticalError)
{
while (POVMS_ProcessMessages (pov::POVMS_GUI_Context, false, false) == kFalseErr)
ProcessFrontend () ;
ProcessFrontend () ;
ProcessCancelRender() ;
}
if (m_LastError == vfeCaughtException || m_LastError == vfeCaughtCriticalError)
NotifyEvent(stCriticalError|stRenderShutdown);
try
{
delete m_Frontend;
m_Frontend = NULL;
WorkerThreadShutdown();
m_Initialized = false;
m_BackendThread = NULL;
povray_terminate();
POVMS_CloseContext (POVMS_Output_Context);
m_CurrentSessionTemporaryHack = NULL;
m_WorkerThreadExited = true;
m_ShutdownEvent.notify_all ();
}
catch (std::runtime_error)
{
// typical cause of an exception here (at least if it is a POVException) is if the destruction
// of m_Frontend takes too long. this can happen if there's a lot of memory blocks to free.
}
}
CXFA_RenderContext::~CXFA_RenderContext() {
StopRender();
}
void FractalEngine::MessageReceived(BMessage* msg)
{
switch (msg->what) {
case MSG_CHANGE_SET:
switch (msg->GetUInt8("set", 0)) {
case 0: fDoSet = &FractalEngine::DoSet_Mandelbrot; break;
case 1: fDoSet = &FractalEngine::DoSet_BurningShip; break;
case 2: fDoSet = &FractalEngine::DoSet_Tricorn; break;
case 3: fDoSet = &FractalEngine::DoSet_Julia; break;
case 4: fDoSet = &FractalEngine::DoSet_OrbitTrap; break;
case 5: fDoSet = &FractalEngine::DoSet_Multibrot; break;
}
break;
case MSG_SET_PALETTE:
switch (msg->GetUInt8("palette", 0)) {
case 0: fColorset = Colorset_Royal; break;
case 1: fColorset = Colorset_DeepFrost; break;
case 2: fColorset = Colorset_Frost; break;
case 3: fColorset = Colorset_Fire; break;
case 4: fColorset = Colorset_Midnight; break;
case 5: fColorset = Colorset_Grassland; break;
case 6: fColorset = Colorset_Lightning; break;
case 7: fColorset = Colorset_Spring; break;
case 8: fColorset = Colorset_HighContrast; break;
}
break;
case MSG_SET_ITERATIONS:
fIterations = msg->GetUInt16("iterations", 0);
break;
case MSG_SET_SUBSAMPLING:
fSubsampling = msg->GetUInt8("subsampling", 1);
break;
case MSG_RESIZE: {
TRACE("Got MSG_RESIZE threads rendering\n");
if (fStopRender) {
// Will be true throughout this whole handler. Set false at the end
TRACE("Breaking out of MSG_RESIZE handler\n");
break;
}
StopRender();
delete fRenderBuffer;
fRenderBuffer = NULL;
fWidth = msg->GetUInt16("width", 320);
fHeight = msg->GetUInt16("height", 240);
TRACE("Creating new buffer. width %u height %u\n", fWidth, fHeight);
fRenderBufferLen = fWidth * fHeight * 3;
fRenderBuffer = new uint8[fRenderBufferLen];
memset(fRenderBuffer, 0, fRenderBufferLen);
BMessage message(MSG_BUFFER_CREATED);
fMessenger.SendMessage(&message);
fStopRender = false;
break;
}
case MSG_RENDER: {
TRACE("Got MSG_RENDER.\n");
StopRender();
fStopRender = false;
Render(msg->GetDouble("locationX", 0), msg->GetDouble("locationY", 0),
msg->GetDouble("size", 0.005));
break;
}
case MSG_THREAD_RENDER_COMPLETE: {
TRACE("Got MSG_THREAD_RENDER_COMPLETE for thread %d\n",
msg->GetUInt8("thread", 0));
int32 threadsStopped;
get_sem_count(fRenderStoppedSem, &threadsStopped);
if (threadsStopped == fThreadCount) {
TRACE("Done rendering!\n");
BMessage message(MSG_RENDER_COMPLETE);
fMessenger.SendMessage(&message);
}
break;
}
default:
BLooper::MessageReceived(msg);
break;
}
}
