void DockWindow::FloatAnimate(DockCont &dc, Rect target)
{
int max = dockpane[0].GetAnimMaxTicks();
dc.IgnoreMinSize(true);
Rect dr = dc.GetRect();
target -= dr;
target.top += 16; // Fudge for titlebar. Should get from OS?
target.left /= max;
target.right /= max;
target.top /= max;
target.bottom /= max;
for (int i = 0; i < max; i++) {
dr += target;
dc.SetRect(dr);
ProcessEvents();
Sleep(dockpane[0].GetAnimInterval());
}
dc.IgnoreMinSize(false);
}
void Player::Update(sf::Time deltaTime)
{
ProcessEvents();
float seconds = deltaTime.asSeconds();
if (rotation_ != 0)
{
float angle = rotation_ * 250 * seconds;
sprite_.rotate(angle);
}
if (is_moving_)
{
float angle = sprite_.getRotation() / 180 * M_PI - M_PI / 2;
speed_ = sf::Vector2f(Configuration::max_speed_ * std::cos(angle), Configuration::max_speed_ * std::sin(angle));
//speed_ += sf::Vector2f(std::cos(angle), std::sin(angle)) * 100.f * seconds; //ship like movement
}
sprite_.move(seconds * speed_);
rotation_ = 0;
//is_moving_ = 0;
}
void Threads::Process(const FractalJobHandeler & job)
{
ProgressInfo statTotal(statusBar);
rows = inp_row.GetData();
cols = inp_col.GetData();
densityR = picbox.GetSize().cy / rows;
densityC = picbox.GetSize().cx / cols;
maxIter = inp_iter.GetData();
logmax= log10((double)maxIter);
max_threads = inp_threads.GetData();
statTotal.Set(0,rows*cols);
TimeStop startTime;
for (int r = 0; r < rows; r++){
for (int c = 0; c < cols; c++)
{
while(threads >= max_threads)
waitforfinish.Wait();
AtomicInc(threads);
Thread().Run(callback4(this, &Threads::ThreadRenderJob, r, c, job, 0));
INTERLOCKED_(job_lock)
active.Add((r * cols + c), 0);
statTotal.Text(Format("Invoking calculations for sector R:%02d C:%02d",r,c));
time.Set(FormatTS(startTime.Elapsed()));
picbox.Refresh();
statTotal.Set(r * cols + c,rows*cols);
ProcessEvents();
}
}
while(threads > 0)
waitforfinish.Wait();
time.Set(FormatTS(startTime.Elapsed()));
picbox.Refresh();
}
String Gdb::Cmd(const char *command)
{
if(!dbg || !dbg->IsRunning() || IdeIsDebugLock()) return Null;
#ifdef _DEBUG
TimeStop ts;
#endif
Lock();
if(command) {
LLOG("========= Cmd: " << command);
dbg->Write(String(command) + "\n");
PutVerbose(command);
}
String result;
int ms0 = msecs();
while(dbg) {
String s;
if(!dbg->Read(s)) {
PutVerbose(result);
PutVerbose("Debugger terminated");
break;
}
if(!s.IsEmpty() && Result(result, s)) {
LLOG(result);
PutVerbose(result);
break;
}
if(ms0 != msecs()) {
ProcessEvents();
ms0 = msecs();
}
// if(s.GetCount() == 0)
GuiSleep(0);
if(TTYQuit())
Stop();
}
Unlock();
#ifdef _DEBUG
if(command)
LLOG("Cmd Time of `" << command <<"` " << ts);
#endif
return result;
}
int main(int argc, char* argv[])
{ //Start SDL
engine.NMSInit(WIDTH,HEIGHT,16,"Nemesis Engine",false);
obj.LoadModel("models/drfreak/drfreak.md2","models/drfreak/drfreak.tga");
obj.SetAnim(BOOM);
//TEXMANAGER.LoadTexture("Texture.tga",5666); //Load the crate model
while(true)
{
ProcessEvents(); // elabora gli eventi
if(engine.running)
{
DrawScene(); // Draw the scene
engine.CalculateFrameRate(); // Calculate the framerate
}
else
break;
}
engine.NMSQuit();
return 0;
};
bool ClassDemoApp::UpdateAndRender() {
float ticks = (float)SDL_GetTicks() / 1000.0f;
float elapsed = ticks - lastFrameTicks;
lastFrameTicks = ticks;
float fixedElapsed = elapsed + timeLeftOver;
if (fixedElapsed > FIXED_TIMESTEP * MAX_TIMESTEPS) {
fixedElapsed = FIXED_TIMESTEP * MAX_TIMESTEPS;
}
while (fixedElapsed >=FIXED_TIMESTEP) {
fixedElapsed -= FIXED_TIMESTEP;
Update(FIXED_TIMESTEP);
}
timeLeftOver = fixedElapsed;
ProcessEvents();
// Update(elapsed);
return done;
}
bool GameApp::UpdateAndRender(){
float ticks = (float)SDL_GetTicks() / 1000.0f;
float elapsed = ticks - lastFrameTicks;
lastFrameTicks = ticks;
ProcessEvents();
EnemyActions();
float fixed_elapsed = elapsed;
if (fixed_elapsed > MAX_TIMESTEP * FIXED_TIMESTEP){
fixed_elapsed = MAX_TIMESTEP*FIXED_TIMESTEP;
}
while (fixed_elapsed >= FIXED_TIMESTEP){
fixed_elapsed -= FIXED_TIMESTEP;
Update(FIXED_TIMESTEP);
}
Update(fixed_elapsed);
Render();
return done;
}
void Game::Run()
{
sf::Clock clock;
sf::Time timeSinceLastUpdate = sf::Time::Zero;
while (mWindow.isOpen())
{
sf::Time elapsedTime = clock.restart();
timeSinceLastUpdate += elapsedTime;
while (timeSinceLastUpdate > TimePerFrame)
{
timeSinceLastUpdate -= TimePerFrame;
ProcessEvents();
Update(TimePerFrame);
}
UpdateStatistics(elapsedTime);
Render();
}
}
void StartProgram(RenderWindow & window, Pendulum & pendulum)
{
Clock frameClock;
int timeSinceLastFrame;
while (window.isOpen())
{
timeSinceLastFrame = frameClock.getElapsedTime().asMilliseconds();
ProcessEvents(window);
if (timeSinceLastFrame >= TIME_PER_FRAME)
{
frameClock.restart();
ComputePhysics(pendulum);
UpdatePendulum(pendulum);
window.clear(Color::White);
Draw(window, pendulum);
window.display();
}
}
};
bool
XInterface::CheckActivity()
{
setjmp(jmp);
if(!g_connected)
{
// If we can't connect, we don't know anything....
if( Connect() == false )
{
return false;
}
}
bool cursor_active = false;
bool xss_active = false;
bool input_active = ProcessEvents();
if ( ! input_active)
{
// TJ: the old code didn't check for pointer movement when there were events -- but I'm not sure that's the right thing to do.
cursor_active = QueryPointer();
xss_active = QuerySSExtension();
}
if (input_active || cursor_active || xss_active) {
if (input_active) {
dprintf(D_FULLDEBUG,"saw input_active\n");
}
if (cursor_active) {
dprintf(D_FULLDEBUG,"saw cursor active\n");
}
if (xss_active) {
dprintf(D_FULLDEBUG,"screensaver reported recent activity\n");
}
} else {
dprintf(D_FULLDEBUG,"saw Idle for %.3f sec\n", (double)time(NULL) - _last_event);
}
return input_active || cursor_active;
}
int
MT_WaitForTasks(gboolean(*pCallback) (gpointer), int callbackTime, int autosave)
{
int callbackLoops = callbackTime / UI_UPDATETIME;
int waits = 0;
int polltime = callbackLoops ? UI_UPDATETIME : callbackTime;
guint as_source = 0;
/* Set total tasks to wait for */
td.totalTasks = td.addedTasks;
#if USE_GTK
GTKSuspendInput();
#endif
if (autosave)
as_source = g_timeout_add(nAutoSaveTime * 60000, save_autosave, NULL);
multi_debug("Waiting for all tasks");
while (!WaitForAllTasks(polltime)) {
waits++;
if (pCallback && waits >= callbackLoops) {
waits = 0;
pCallback(NULL);
}
ProcessEvents();
}
if (autosave) {
g_source_remove(as_source);
save_autosave(NULL);
}
multi_debug("Done waiting for all tasks");
td.doneTasks = td.addedTasks = 0;
td.totalTasks = -1;
#if USE_GTK
GTKResumeInput();
#endif
return td.result;
}
static void DOT_StartupWindow(void)
{
WindoW w;
GrouP c, cg;
DOTStartDataPtr sdata;
PaneL p;
w = FixedWindow (-50, -33, -10, -10, "Welcome to D-Viewer", StdCloseWindowProc);
p = SimplePanel (w, 28 * stdCharWidth, 4 * stdLineHeight, DOT_DrawAbout);
sdata=(DOTStartDataPtr)MemNew(sizeof(DOTStartData));
sdata->hStart=w;
cg=HiddenGroup(w, 4, 0, NULL);
sdata->dot=CheckBox(cg, "Dot plot", DOT_CheckDot);
SetStatus(sdata->dot, TRUE);
sdata->reg_blast=CheckBox(cg, "Bl2Seqs", DOT_CheckRegBlast);
SetStatus(sdata->reg_blast, FALSE);
sdata->auto_blast = CheckBox(cg, "Scoop", DOT_CheckAutoBlast);
SetStatus(sdata->auto_blast, FALSE);
sdata->seqa=CheckBox(cg, "SeqAnnote File", DOT_CheckSA);
SetStatus(sdata->seqa, FALSE);
c = HiddenGroup (w, 1, 3, NULL);
SetGroupMargins(c, 10, 10);
SetGroupSpacing (c, 10, 10);
sdata->entrez=PushButton (c, "Fetch from Entrez", DOT_GetFromNetwork);
Enable(sdata->entrez);
sdata->file=PushButton (c, "Open Local Files", DOT_readExisting);
Enable(sdata->file);
PushButton (c, "Quit Program", DOT_quitProgram);
SetObjectExtra(w, (Pointer)sdata, StdCleanupExtraProc);
AlignObjects (ALIGN_CENTER, (HANDLE) p, (HANDLE) c, NULL, NULL);
Select(w);
Show(w);
ProcessEvents();
}
void StartProgram(RenderWindow & window, Car & car, Physics & physics, const RectangleShape & ground)
{
Clock frameClock;
int timeSinceLastFrame;
while (window.isOpen())
{
timeSinceLastFrame = frameClock.getElapsedTime().asMilliseconds();
ProcessEvents(window);
if (timeSinceLastFrame >= TIME_PER_FRAME)
{
frameClock.restart();
ComputePhysics(physics);
UpdateCar(car, physics);
window.clear(Color::White);
Draw(window, car, ground);
window.display();
}
}
}
bool ExponentialTransformationInterface::GenerateRealTimePreview( UInt16Image& image, const View& view, int zoomLevel, String& ) const
{
m_realTimeThread = new RealTimeThread;
for ( ;; )
{
ExponentialTransformationInstance previewInstance( instance );
if ( zoomLevel < 0 )
previewInstance.sigma /= -zoomLevel;
m_realTimeThread->Reset( image, previewInstance );
m_realTimeThread->Start();
while ( m_realTimeThread->IsActive() )
{
ProcessEvents();
if ( !IsRealTimePreviewActive() )
{
m_realTimeThread->Abort();
m_realTimeThread->Wait();
delete m_realTimeThread;
m_realTimeThread = 0;
return false;
}
}
if ( !m_realTimeThread->IsAborted() )
{
image.Assign( m_realTimeThread->m_image );
delete m_realTimeThread;
m_realTimeThread = 0;
return true;
}
}
}
ReturnValue WindowsEventLoop::Run(ActivityHandler* pActivityHandler)
{
m_pActivityHandler = pActivityHandler;
m_isRunning=true;
InitializeDisplay();
m_pActivityHandler->onActivate();
// Global step loop.
while(m_isRunning)
{
ProcessEvents();
if(m_pActivityHandler->onStep() != RETURN_VALUE_OK)
{
m_isRunning=false;
}
SwapBuffers();
}
m_pActivityHandler->onDeactivate();
DestroyDisplay();
return RETURN_VALUE_OK;
}
int
MT_WaitForTasks(gboolean(*pCallback) (gpointer), int callbackTime, int autosave)
{
GList *member;
guint cb_source = 0;
guint as_source = 0;
td.doneTasks = 0;
#if USE_GTK
GTKSuspendInput();
#endif
multi_debug("Waiting for all tasks");
pCallback(NULL);
cb_source = g_timeout_add(1000, pCallback, NULL);
if (autosave)
as_source = g_timeout_add(nAutoSaveTime * 60000, save_autosave, NULL);
for (member = g_list_first(td.tasks); member; member = member->next, td.doneTasks++) {
Task *task = member->data;
task->fun(task->data);
free(task->pLinkedTask);
free(task);
ProcessEvents();
}
g_list_free(td.tasks);
if (autosave) {
g_source_remove(as_source);
save_autosave(NULL);
}
td.tasks = NULL;
#if USE_GTK
GTKResumeInput();
#endif
return td.result;
}
///////////////////////////////////////////////////////
// RADEventsXML::ConstructXMLDoc
//
// Constructs the XML document from the RADEventList 'rel'.
// Note: the current XML document is replaced, not updated,
// by this operation.
//
// Input/Output:
// rel - the RADEventsList instance that is converted to an
// XML document.
//
///////////////////////////////////////////////////////
bool RADEventsXML::ConstructXMLDoc(RADEventsList& rel)
{
_bstr_t bstr;
HRESULT hr;
IXMLDOMNode *pColNode = NULL;
IXMLDOMNode *pIXMLDOMNode = NULL;
if (this->m_pXMLDom != NULL)
{
if (this->m_pIRNode == NULL)
// might need to create the entire tree, the file didn't exist
// or might need to just create the tree down to the Events level
{
this->m_pIRNode = ConstructEventParentNodeTree();
}
if (this->m_pIRNode == NULL )
return false; // attempt to create IR/Events has failed
bstr = m_xcolpath;
HRCALL(m_pXMLDom->selectSingleNode(bstr, &pColNode), "selectSingleNode");
if (pColNode == NULL)
{
pColNode = ConstructColumnsNode();
if (pColNode)
{
HRCALL(m_pIRNode->appendChild(pColNode,&pIXMLDOMNode), "");
AddWhiteSpaceToNode(bstr_wsnt, m_pIRNode);
} else // if (pColNode == NULL)
return false; // forced re-selection of the newly constructed node tree has failed
}
}
else
return false; // no DOM means punt
clean:
return ProcessEvents(rel, false); // build the event list on the IR/Events tree
}
int main()
{
//set the system to use the PLL and crank the frequency up to 72Mhz (max for processor)
pllInit();
//set up the timer used all over to wait for delays
DelayTimerInit();
//set up the timer used to schedule ffts
FFTTimerInit();
//set up pins for ads communication
InitPinsForAdsCommunication();
//ads boots up with 250sps data ready pin, stop this
stopAdsConversions();
//start up the uart - bluetooth connection. Do this last in case we get something right away
uartInit();
LPC_IOCON->PIO3_2 = 0xD8;
LPC_GPIO3->DIR |= (1<<2);
LPC_GPIO3->DATA &= ~(1<<2);
//pwup();
//pwdnTimerInit();
//startPwdnTimer();
while(1)
{
// event processing loop to deal with deadlocks if everything were to run straight from interrupts
ProcessEvents();
//delay(60000);
}
}
int main(int argc, char* argv[]) {
int c;
int ok = 0;
for (c = 1; c < argc; ++c) {
const char* file = NULL;
const uint8_t* webp = NULL;
size_t webp_size = 0;
if (!strcmp(argv[c], "-h")) {
printf("Usage: %s [-h] image.webp [more_files.webp...]\n", argv[0]);
return 0;
} else {
file = argv[c];
}
if (file == NULL) continue;
if (!ImgIoUtilReadFile(file, &webp, &webp_size)) {
fprintf(stderr, "Error opening file: %s\n", file);
goto Error;
}
if (webp_size != (size_t)(int)webp_size) {
fprintf(stderr, "File too large.\n");
goto Error;
}
ok = WebpToSDL((const char*)webp, (int)webp_size);
free((void*)webp);
if (!ok) {
fprintf(stderr, "Error decoding file %s\n", file);
goto Error;
}
ProcessEvents();
}
ok = 1;
Error:
SDL_Quit();
return ok ? 0 : 1;
}
void ComidaGame::Loop(){
wnd->setFramerateLimit(60);
wnd->setVisible(true);
while(wnd->isOpen()){
if(!ProcessEvents())
return;
//updates
tablero->Update();
wnd->clear();
//draws
tablero->Draw(wnd);
wnd->display();
}
}
void Ide::DoProcessEvents()
{
ProcessEvents();
}
void cyclic_space::step()
{
calculate();
Refresh();
ProcessEvents();
}
int main(){
auto pLogger = CB::Log::CLogger::GetInstance();
pLogger->AddStream(CB::IO::File::Open(L"main.log", CB::IO::File::AccessType::WriteOnly, CB::IO::File::OpenAction::AlwaysCreate).Cast<CB::IO::IStream>());
pLogger->AddStream(CB::IO::Console::Create().Cast<CB::IO::IStream>(), CB::Log::CTextFormatter::Create(CB::String::Encoding::ANSI).Cast<CB::Log::IEntryFormatter>());
pLogger->SetDebugMode(true);
try{
auto pWinDriver = CB::Window::LoadDriver(L"MSWindowDriver");
auto pGraphicDriver = CB::Graphic::LoadDriver(L"OGLGraphicDriver");
{
auto pWinManager = pWinDriver->CreateManager();
auto pGraphicManager = pGraphicDriver->CreateManager(pWinManager);
CB::Math::CSize outSize(640, 480);
auto pWindow = pWinManager->CreateWindow(L"GraphicTest", CB::Window::Style::Single, outSize);
auto pGraphicAdapter = pGraphicManager->GetDefaultAdapter();
CB::Graphic::CDisplayMode dispMode(pWindow->GetSize(), 0, CB::Graphic::BufferFormat::B8G8R8X8);
CB::Graphic::CDeviceDesc devDesc(pWindow, dispMode, CB::Graphic::BufferFormat::D24S8, false);
CB::Collection::CList<CB::Graphic::FeatureLevel> featureLevels;
featureLevels.Add(CB::Graphic::FeatureLevel::Level_1);
auto pGraphicDevice = pGraphicAdapter->CreateDevice(pWindow, devDesc, featureLevels);
pWindow->OnClose += CB::Signals::CFunc<const bool, CB::CRefPtr<CB::Window::IWindow>>(CloseEvent);
pWindow->SetVisible(true);
CB::Graphic::CDepthStencilStateDesc depthDesc;
depthDesc.bDepthTestEnabled = true;
depthDesc.uDepthFunction = CB::Graphic::CompareFunc::LessEqual;
auto pDepthState = pGraphicDevice->CreateState(depthDesc);
pGraphicDevice->SetState(pDepthState.Cast<CB::Graphic::IDeviceState>());
CB::Graphic::CRasterizerStateDesc rastDesc;
rastDesc.uCullMode = CB::Graphic::CullMode::None;
auto pRastState = pGraphicDevice->CreateState(rastDesc);
pGraphicDevice->SetState(pRastState.Cast<CB::Graphic::IDeviceState>());
CB::Graphic::CBlendStateDesc blendDesc;
blendDesc.ColorBlend.uDestOperand = CB::Graphic::BlendOption::OneMinusSourceAlpha;
blendDesc.ColorBlend.uSourceOperand = CB::Graphic::BlendOption::SourceAlpha;
blendDesc.ColorBlend.uOperation = CB::Graphic::BlendOperation::Add;
blendDesc.AlphaBlend.uDestOperand = CB::Graphic::BlendOption::OneMinusSourceAlpha;
blendDesc.AlphaBlend.uSourceOperand = CB::Graphic::BlendOption::SourceAlpha;
blendDesc.AlphaBlend.uOperation = CB::Graphic::BlendOperation::Add;
blendDesc.bEnabled[0] = true;
auto pBlendState = pGraphicDevice->CreateState(blendDesc);
pGraphicDevice->SetState(pBlendState.Cast<CB::Graphic::IDeviceState>());
auto pFontManager = CB::Font::CManager::Create();
auto pFontStream = CB::IO::File::Open(L"Assets/font.ttf").Cast<CB::IO::IStream>();
auto pFont = pFontManager->Load(pFontStream);
pFont->SelectFace(0);
pFont->SetSize(24);
CB::Collection::CList<CB::Tools::CFontCharDesc> charDescs;
CB::Tools::CFontTextureGenerator fontGen(pGraphicDevice);
fontGen.MaxTextureSize.Set(512, 512);
auto pTexture = fontGen.Generate(pFont, charDescs);
CB::Tools::CTextMeshGenerator textGen(charDescs);
CB::Tools::CMeshRawIVT textMesh;
textGen.Generate(L"Marek M³ynarski!", textMesh);
CB::Collection::CList<CB::Graphic::CVertexElement> vEls;
vEls.Add(CB::Graphic::CVertexElement(0, L"vinput.vPosition", CB::Graphic::VertexType::Float, 3, 0));
vEls.Add(CB::Graphic::CVertexElement(1, L"vinput.vTexCoord", CB::Graphic::VertexType::Float, 2, 0));
GraphicTest::CShaderLoader shaders(pGraphicDevice, L"Shaders/TextureShader.cg");
auto pTextDecl = pGraphicDevice->CreateVertexDeclaration(shaders.pVertexShader, vEls);
auto pTextVertexBuffer = pGraphicDevice->CreateBuffer(CB::Graphic::BufferType::Vertex, CB::Graphic::BufferUsage::Dynamic, CB::Graphic::BufferAccess::Write, textMesh.Vertices);
auto pTextTCoordBuffer = pGraphicDevice->CreateBuffer(CB::Graphic::BufferType::Vertex, CB::Graphic::BufferUsage::Dynamic, CB::Graphic::BufferAccess::Write, textMesh.TexCoords);
auto pTextIndexBuffer = pGraphicDevice->CreateBuffer(CB::Graphic::BufferType::Index, CB::Graphic::BufferUsage::Dynamic, CB::Graphic::BufferAccess::Write, textMesh.Indices);
float32 fAspect = (float32)outSize.Width / (float32)outSize.Height;
CB::Math::CMatrix mProj = CB::Math::CMatrix::GetPerspective(fAspect, 60.0f, 1.0f, 100.0f);
CB::Math::CMatrix mView = CB::Math::CMatrix::GetTranslation(-4.0f, 0.0f, -3.4f);
CB::Math::CMatrix mModel = CB::Math::CMatrix::GetIdentity();
shaders.pFragmentShader->SetSampler(L"texDiffuse", pTexture.Cast<CB::Graphic::IBaseTexture>());
pTexture->SetFilters(CB::Graphic::TextureFilter::Linear, CB::Graphic::TextureFilter::Linear, CB::Graphic::TextureFilter::Linear);
pTexture->SetAnisotropy(8);
//g_pTexture = texture.pTexture;
while(g_bRun){
pGraphicDevice->Clear(1.0f, 1);
pGraphicDevice->Clear(CB::Math::CColor(1.0f, 0.5f, 0.0f, 1.0f));
pGraphicDevice->BeginRender();
pGraphicDevice->SetShader(shaders.pVertexShader);
pGraphicDevice->SetShader(shaders.pFragmentShader);
static float32 fV = 0.0f;
fV += 20 * g_Timer.GetTimeDelta();
mModel = CB::Math::CMatrix::GetRotation(CB::Math::AxisOrientation::AxisX, fV);
shaders.pVertexShader->SetUniform(L"vinput.mProj", mProj);
shaders.pVertexShader->SetUniform(L"vinput.mView", mView);
shaders.pVertexShader->SetUniform(L"vinput.mModel", mModel);
pGraphicDevice->SetVertexDeclaration(pTextDecl);
pGraphicDevice->SetVertexBuffer(0, pTextVertexBuffer);
pGraphicDevice->SetVertexBuffer(1, pTextTCoordBuffer);
pGraphicDevice->SetIndexBuffer(pTextIndexBuffer);
pGraphicDevice->RenderIndexed(textMesh.uNumberOfPolygons);
pGraphicDevice->EndRender();
g_Timer.Update();
pWinManager->ProcessEvents();
float fFPS = 1.0f / (g_Timer.GetTimeDelta() == 0.0f ? 1.0f : g_Timer.GetTimeDelta());
uint32 uFPS = (uint32)fFPS;
textMesh.Clear();
textGen.Generate(L"FPS: " + CB::String::ToString(uFPS), textMesh);
pTextVertexBuffer->LoadData(textMesh.Vertices);
pTextTCoordBuffer->LoadData(textMesh.TexCoords);
pTextIndexBuffer->LoadData(textMesh.Indices);
pGraphicDevice->Swap();
}
g_pTexture.Release();
}
}
catch(CB::Exception::CException& Exception){
CB::Log::Write(Exception, CB::Log::LogLevel::Fatal);
CB::Message::Show(Exception, CB::Message::Icon::Error);
}
return 0;
}
void CGameClient::OnNewSnapshot()
{
m_NewTick = true;
// clear out the invalid pointers
mem_zero(&g_GameClient.m_Snap, sizeof(g_GameClient.m_Snap));
m_Snap.m_LocalCid = -1;
// secure snapshot
{
int Num = Client()->SnapNumItems(IClient::SNAP_CURRENT);
for(int Index = 0; Index < Num; Index++)
{
IClient::CSnapItem Item;
void *pData = Client()->SnapGetItem(IClient::SNAP_CURRENT, Index, &Item);
if(m_NetObjHandler.ValidateObj(Item.m_Type, pData, Item.m_DataSize) != 0)
{
if(g_Config.m_Debug)
dbg_msg("game", "invalidated index=%d type=%d (%s) size=%d id=%d", Index, Item.m_Type, m_NetObjHandler.GetObjName(Item.m_Type), Item.m_DataSize, Item.m_Id);
Client()->SnapInvalidateItem(IClient::SNAP_CURRENT, Index);
}
}
}
ProcessEvents();
if(g_Config.m_DbgStress)
{
if((Client()->GameTick()%100) == 0)
{
char aMessage[64];
int MsgLen = rand()%(sizeof(aMessage)-1);
for(int i = 0; i < MsgLen; i++)
aMessage[i] = 'a'+(rand()%('z'-'a'));
aMessage[MsgLen] = 0;
CNetMsg_Cl_Say Msg;
Msg.m_Team = rand()&1;
Msg.m_pMessage = aMessage;
Client()->SendPackMsg(&Msg, MSGFLAG_VITAL);
}
}
// go trough all the items in the snapshot and gather the info we want
{
m_Snap.m_aTeamSize[0] = m_Snap.m_aTeamSize[1] = 0;
int Num = Client()->SnapNumItems(IClient::SNAP_CURRENT);
for(int i = 0; i < Num; i++)
{
IClient::CSnapItem Item;
const void *pData = Client()->SnapGetItem(IClient::SNAP_CURRENT, i, &Item);
if(Item.m_Type == NETOBJTYPE_CLIENTINFO)
{
const CNetObj_ClientInfo *pInfo = (const CNetObj_ClientInfo *)pData;
int Cid = Item.m_Id;
IntsToStr(&pInfo->m_Name0, 6, m_aClients[Cid].m_aName);
IntsToStr(&pInfo->m_Skin0, 6, m_aClients[Cid].m_aSkinName);
m_aClients[Cid].m_UseCustomColor = pInfo->m_UseCustomColor;
m_aClients[Cid].m_ColorBody = pInfo->m_ColorBody;
m_aClients[Cid].m_ColorFeet = pInfo->m_ColorFeet;
// prepare the info
if(m_aClients[Cid].m_aSkinName[0] == 'x' || m_aClients[Cid].m_aSkinName[1] == '_')
str_copy(m_aClients[Cid].m_aSkinName, "default", 64);
m_aClients[Cid].m_SkinInfo.m_ColorBody = m_pSkins->GetColor(m_aClients[Cid].m_ColorBody);
m_aClients[Cid].m_SkinInfo.m_ColorFeet = m_pSkins->GetColor(m_aClients[Cid].m_ColorFeet);
m_aClients[Cid].m_SkinInfo.m_Size = 64;
// find new skin
m_aClients[Cid].m_SkinId = g_GameClient.m_pSkins->Find(m_aClients[Cid].m_aSkinName);
if(m_aClients[Cid].m_SkinId < 0)
{
m_aClients[Cid].m_SkinId = g_GameClient.m_pSkins->Find("default");
if(m_aClients[Cid].m_SkinId < 0)
m_aClients[Cid].m_SkinId = 0;
}
if(m_aClients[Cid].m_UseCustomColor)
m_aClients[Cid].m_SkinInfo.m_Texture = g_GameClient.m_pSkins->Get(m_aClients[Cid].m_SkinId)->m_ColorTexture;
else
{
m_aClients[Cid].m_SkinInfo.m_Texture = g_GameClient.m_pSkins->Get(m_aClients[Cid].m_SkinId)->m_OrgTexture;
m_aClients[Cid].m_SkinInfo.m_ColorBody = vec4(1,1,1,1);
m_aClients[Cid].m_SkinInfo.m_ColorFeet = vec4(1,1,1,1);
}
m_aClients[Cid].UpdateRenderInfo();
g_GameClient.m_Snap.m_NumPlayers++;
}
else if(Item.m_Type == NETOBJTYPE_PLAYERINFO)
{
const CNetObj_PlayerInfo *pInfo = (const CNetObj_PlayerInfo *)pData;
m_aClients[pInfo->m_ClientId].m_Team = pInfo->m_Team;
m_Snap.m_paPlayerInfos[pInfo->m_ClientId] = pInfo;
if(pInfo->m_Local)
{
m_Snap.m_LocalCid = Item.m_Id;
m_Snap.m_pLocalInfo = pInfo;
if (pInfo->m_Team == -1)
m_Snap.m_Spectate = true;
}
// calculate team-balance
if(pInfo->m_Team != -1)
m_Snap.m_aTeamSize[pInfo->m_Team]++;
}
else if(Item.m_Type == NETOBJTYPE_CHARACTER)
{
const void *pOld = Client()->SnapFindItem(IClient::SNAP_PREV, NETOBJTYPE_CHARACTER, Item.m_Id);
if(pOld)
{
m_Snap.m_aCharacters[Item.m_Id].m_Active = true;
m_Snap.m_aCharacters[Item.m_Id].m_Prev = *((const CNetObj_Character *)pOld);
m_Snap.m_aCharacters[Item.m_Id].m_Cur = *((const CNetObj_Character *)pData);
if(m_Snap.m_aCharacters[Item.m_Id].m_Prev.m_Tick)
Evolve(&m_Snap.m_aCharacters[Item.m_Id].m_Prev, Client()->PrevGameTick());
if(m_Snap.m_aCharacters[Item.m_Id].m_Cur.m_Tick)
Evolve(&m_Snap.m_aCharacters[Item.m_Id].m_Cur, Client()->GameTick());
}
}
else if(Item.m_Type == NETOBJTYPE_GAME)
m_Snap.m_pGameobj = (CNetObj_Game *)pData;
else if(Item.m_Type == NETOBJTYPE_FLAG)
m_Snap.m_paFlags[Item.m_Id%2] = (const CNetObj_Flag *)pData;
}
}
// setup local pointers
if(m_Snap.m_LocalCid >= 0)
{
CSnapState::CCharacterInfo *c = &m_Snap.m_aCharacters[m_Snap.m_LocalCid];
if(c->m_Active)
{
m_Snap.m_pLocalCharacter = &c->m_Cur;
m_Snap.m_pLocalPrevCharacter = &c->m_Prev;
m_LocalCharacterPos = vec2(m_Snap.m_pLocalCharacter->m_X, m_Snap.m_pLocalCharacter->m_Y);
}
}
else
m_Snap.m_Spectate = true;
CTuningParams StandardTuning;
CServerInfo CurrentServerInfo;
Client()->GetServerInfo(&CurrentServerInfo);
if(CurrentServerInfo.m_aGameType[0] != '0')
{
if(str_comp(CurrentServerInfo.m_aGameType, "DM") != 0 && str_comp(CurrentServerInfo.m_aGameType, "TDM") != 0 && str_comp(CurrentServerInfo.m_aGameType, "CTF") != 0)
m_ServerMode = SERVERMODE_MOD;
else if(mem_comp(&StandardTuning, &m_Tuning, sizeof(CTuningParams)) == 0)
m_ServerMode = SERVERMODE_PURE;
else
m_ServerMode = SERVERMODE_PUREMOD;
}
// update render info
for(int i = 0; i < MAX_CLIENTS; i++)
m_aClients[i].UpdateRenderInfo();
}
int main(int argc, char *argv[])
{
SDL_Event event;
bool done = false;
float lastFrameTicks = 0.0f;
float ball_angle = 0.0f;
srand(time(NULL));
Matrix projectionMatrix;
Matrix viewMatrix;
Setup(&displayWindow, &projectionMatrix);
GLuint paddle = LoadTexture("blue_panel.png", GL_RGBA);
Matrix leftM;
Entity leftPaddle(paddle);
leftPaddle.width = 0.3f;
leftPaddle.x = -3.2f;
leftPaddle.speed = 2.0f;
Matrix rightM;
Entity rightPaddle(paddle);
rightPaddle.width = 0.3f;
rightPaddle.x = 3.2f;
rightPaddle.speed = 2.0f;
Matrix ballM;
GLuint ballT = LoadTexture("green_panel.png", GL_RGBA);
Entity ball(ballT);
ball.height = 0.25f;
ball.width = 0.25f;
ball.speed = 3.0f;
if (rand() % 1){
ball_angle = (rand() % 90 + 135);
}
else{
ball_angle = (rand() % 90 + 316);
}
std::vector<Entity> entities;
entities.push_back(leftPaddle);
entities.push_back(rightPaddle);
std::vector<Matrix> modelM;
modelM.push_back(leftM);
modelM.push_back(rightM);
ShaderProgram program(RESOURCE_FOLDER"vertex_textured.glsl", RESOURCE_FOLDER"fragment_textured.glsl");
glUseProgram(program.programID);
while (!done) {
float ticks = (float)SDL_GetTicks() / 1000.0f;
float elapsed = ticks - lastFrameTicks;
lastFrameTicks = ticks;
ProcessEvents(&event, &done, elapsed, entities);
Update(entities,ball,ball_angle,elapsed);
glClear(GL_COLOR_BUFFER_BIT);
Render(&program, &projectionMatrix,&viewMatrix, modelM, entities,ball,ballM);
}
SDL_Quit();
return 0;
}
void CGameClient::OnNewSnapshot()
{
m_NewTick = true;
// clear out the invalid pointers
mem_zero(&g_GameClient.m_Snap, sizeof(g_GameClient.m_Snap));
m_Snap.m_LocalClientID = -1;
// secure snapshot
{
int Num = Client()->SnapNumItems(IClient::SNAP_CURRENT);
for(int Index = 0; Index < Num; Index++)
{
IClient::CSnapItem Item;
void *pData = Client()->SnapGetItem(IClient::SNAP_CURRENT, Index, &Item);
if(m_NetObjHandler.ValidateObj(Item.m_Type, pData, Item.m_DataSize) != 0)
{
if(g_Config.m_Debug)
{
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "invalidated index=%d type=%d (%s) size=%d id=%d", Index, Item.m_Type, m_NetObjHandler.GetObjName(Item.m_Type), Item.m_DataSize, Item.m_ID);
Console()->Print(IConsole::OUTPUT_LEVEL_DEBUG, "game", aBuf);
}
Client()->SnapInvalidateItem(IClient::SNAP_CURRENT, Index);
}
}
}
ProcessEvents();
if(g_Config.m_DbgStress)
{
if((Client()->GameTick()%100) == 0)
{
char aMessage[64];
int MsgLen = rand()%(sizeof(aMessage)-1);
for(int i = 0; i < MsgLen; i++)
aMessage[i] = 'a'+(rand()%('z'-'a'));
aMessage[MsgLen] = 0;
CNetMsg_Cl_Say Msg;
Msg.m_Team = rand()&1;
Msg.m_pMessage = aMessage;
Client()->SendPackMsg(&Msg, MSGFLAG_VITAL);
}
}
// go trough all the items in the snapshot and gather the info we want
{
m_Snap.m_aTeamSize[TEAM_RED] = m_Snap.m_aTeamSize[TEAM_BLUE] = 0;
int Num = Client()->SnapNumItems(IClient::SNAP_CURRENT);
for(int i = 0; i < Num; i++)
{
IClient::CSnapItem Item;
const void *pData = Client()->SnapGetItem(IClient::SNAP_CURRENT, i, &Item);
if(Item.m_Type == NETOBJTYPE_CLIENTINFO)
{
const CNetObj_ClientInfo *pInfo = (const CNetObj_ClientInfo *)pData;
int ClientID = Item.m_ID;
IntsToStr(&pInfo->m_Name0, 4, m_aClients[ClientID].m_aName);
IntsToStr(&pInfo->m_Clan0, 3, m_aClients[ClientID].m_aClan);
m_aClients[ClientID].m_Country = pInfo->m_Country;
IntsToStr(&pInfo->m_Skin0, 6, m_aClients[ClientID].m_aSkinName);
m_aClients[ClientID].m_UseCustomColor = pInfo->m_UseCustomColor;
m_aClients[ClientID].m_ColorBody = pInfo->m_ColorBody;
m_aClients[ClientID].m_ColorFeet = pInfo->m_ColorFeet;
// prepare the info
if(m_aClients[ClientID].m_aSkinName[0] == 'x' || m_aClients[ClientID].m_aSkinName[1] == '_')
str_copy(m_aClients[ClientID].m_aSkinName, "default", 64);
m_aClients[ClientID].m_SkinInfo.m_ColorBody = m_pSkins->GetColorV4(m_aClients[ClientID].m_ColorBody);
m_aClients[ClientID].m_SkinInfo.m_ColorFeet = m_pSkins->GetColorV4(m_aClients[ClientID].m_ColorFeet);
m_aClients[ClientID].m_SkinInfo.m_Size = 64;
// find new skin
m_aClients[ClientID].m_SkinID = g_GameClient.m_pSkins->Find(m_aClients[ClientID].m_aSkinName);
if(m_aClients[ClientID].m_SkinID < 0)
{
m_aClients[ClientID].m_SkinID = g_GameClient.m_pSkins->Find("default");
if(m_aClients[ClientID].m_SkinID < 0)
m_aClients[ClientID].m_SkinID = 0;
}
if(m_aClients[ClientID].m_UseCustomColor)
m_aClients[ClientID].m_SkinInfo.m_Texture = g_GameClient.m_pSkins->Get(m_aClients[ClientID].m_SkinID)->m_ColorTexture;
else
{
m_aClients[ClientID].m_SkinInfo.m_Texture = g_GameClient.m_pSkins->Get(m_aClients[ClientID].m_SkinID)->m_OrgTexture;
m_aClients[ClientID].m_SkinInfo.m_ColorBody = vec4(1,1,1,1);
m_aClients[ClientID].m_SkinInfo.m_ColorFeet = vec4(1,1,1,1);
}
m_aClients[ClientID].UpdateRenderInfo();
}
else if(Item.m_Type == NETOBJTYPE_PLAYERINFO)
{
const CNetObj_PlayerInfo *pInfo = (const CNetObj_PlayerInfo *)pData;
m_aClients[pInfo->m_ClientID].m_Team = pInfo->m_Team;
m_aClients[pInfo->m_ClientID].m_Active = true;
m_Snap.m_paPlayerInfos[pInfo->m_ClientID] = pInfo;
m_Snap.m_NumPlayers++;
if(pInfo->m_Local)
{
m_Snap.m_LocalClientID = Item.m_ID;
m_Snap.m_pLocalInfo = pInfo;
if(pInfo->m_Team == TEAM_SPECTATORS)
{
m_Snap.m_SpecInfo.m_Active = true;
m_Snap.m_SpecInfo.m_SpectatorID = SPEC_FREEVIEW;
}
}
// calculate team-balance
if(pInfo->m_Team != TEAM_SPECTATORS)
m_Snap.m_aTeamSize[pInfo->m_Team]++;
}
else if(Item.m_Type == NETOBJTYPE_CHARACTER)
{
const void *pOld = Client()->SnapFindItem(IClient::SNAP_PREV, NETOBJTYPE_CHARACTER, Item.m_ID);
m_Snap.m_aCharacters[Item.m_ID].m_Cur = *((const CNetObj_Character *)pData);
if(pOld)
{
m_Snap.m_aCharacters[Item.m_ID].m_Active = true;
m_Snap.m_aCharacters[Item.m_ID].m_Prev = *((const CNetObj_Character *)pOld);
if(m_Snap.m_aCharacters[Item.m_ID].m_Prev.m_Tick)
Evolve(&m_Snap.m_aCharacters[Item.m_ID].m_Prev, Client()->PrevGameTick());
if(m_Snap.m_aCharacters[Item.m_ID].m_Cur.m_Tick)
Evolve(&m_Snap.m_aCharacters[Item.m_ID].m_Cur, Client()->GameTick());
}
}
else if(Item.m_Type == NETOBJTYPE_SPECTATORINFO)
{
m_Snap.m_pSpectatorInfo = (const CNetObj_SpectatorInfo *)pData;
m_Snap.m_pPrevSpectatorInfo = (const CNetObj_SpectatorInfo *)Client()->SnapFindItem(IClient::SNAP_PREV, NETOBJTYPE_SPECTATORINFO, Item.m_ID);
m_Snap.m_SpecInfo.m_SpectatorID = m_Snap.m_pSpectatorInfo->m_SpectatorID;
}
else if(Item.m_Type == NETOBJTYPE_GAMEINFO)
{
static bool s_GameOver = 0;
m_Snap.m_pGameInfoObj = (const CNetObj_GameInfo *)pData;
if(!s_GameOver && m_Snap.m_pGameInfoObj->m_GameStateFlags&GAMESTATEFLAG_GAMEOVER)
OnGameOver();
else if(s_GameOver && !(m_Snap.m_pGameInfoObj->m_GameStateFlags&GAMESTATEFLAG_GAMEOVER))
OnStartGame();
s_GameOver = m_Snap.m_pGameInfoObj->m_GameStateFlags&GAMESTATEFLAG_GAMEOVER;
}
else if(Item.m_Type == NETOBJTYPE_GAMEDATA)
{
m_Snap.m_pGameDataObj = (const CNetObj_GameData *)pData;
m_Snap.m_GameDataSnapID = Item.m_ID;
if(m_Snap.m_pGameDataObj->m_FlagCarrierRed == FLAG_TAKEN)
{
if(m_FlagDropTick[TEAM_RED] == 0)
m_FlagDropTick[TEAM_RED] = Client()->GameTick();
}
else if(m_FlagDropTick[TEAM_RED] != 0)
m_FlagDropTick[TEAM_RED] = 0;
if(m_Snap.m_pGameDataObj->m_FlagCarrierBlue == FLAG_TAKEN)
{
if(m_FlagDropTick[TEAM_BLUE] == 0)
m_FlagDropTick[TEAM_BLUE] = Client()->GameTick();
}
else if(m_FlagDropTick[TEAM_BLUE] != 0)
m_FlagDropTick[TEAM_BLUE] = 0;
}
else if(Item.m_Type == NETOBJTYPE_FLAG)
m_Snap.m_paFlags[Item.m_ID%2] = (const CNetObj_Flag *)pData;
}
}
// setup local pointers
if(m_Snap.m_LocalClientID >= 0)
{
CSnapState::CCharacterInfo *c = &m_Snap.m_aCharacters[m_Snap.m_LocalClientID];
if(c->m_Active)
{
m_Snap.m_pLocalCharacter = &c->m_Cur;
m_Snap.m_pLocalPrevCharacter = &c->m_Prev;
m_LocalCharacterPos = vec2(m_Snap.m_pLocalCharacter->m_X, m_Snap.m_pLocalCharacter->m_Y);
}
else if(Client()->SnapFindItem(IClient::SNAP_PREV, NETOBJTYPE_CHARACTER, m_Snap.m_LocalClientID))
{
// player died
m_pControls->OnPlayerDeath();
}
}
else
{
m_Snap.m_SpecInfo.m_Active = true;
if(Client()->State() == IClient::STATE_DEMOPLAYBACK && DemoPlayer()->GetDemoType() == IDemoPlayer::DEMOTYPE_SERVER &&
m_DemoSpecID != SPEC_FREEVIEW && m_Snap.m_aCharacters[m_DemoSpecID].m_Active)
m_Snap.m_SpecInfo.m_SpectatorID = m_DemoSpecID;
else
m_Snap.m_SpecInfo.m_SpectatorID = SPEC_FREEVIEW;
}
// clear out unneeded client data
for(int i = 0; i < MAX_CLIENTS; ++i)
{
if(!m_Snap.m_paPlayerInfos[i] && m_aClients[i].m_Active)
m_aClients[i].Reset();
}
// update friend state
for(int i = 0; i < MAX_CLIENTS; ++i)
{
if(i == m_Snap.m_LocalClientID || !m_Snap.m_paPlayerInfos[i] || !Friends()->IsFriend(m_aClients[i].m_aName, m_aClients[i].m_aClan, true))
m_aClients[i].m_Friend = false;
else
m_aClients[i].m_Friend = true;
}
// sort player infos by score
mem_copy(m_Snap.m_paInfoByScore, m_Snap.m_paPlayerInfos, sizeof(m_Snap.m_paInfoByScore));
for(int k = 0; k < MAX_CLIENTS-1; k++) // ffs, bubblesort
{
for(int i = 0; i < MAX_CLIENTS-k-1; i++)
{
if(m_Snap.m_paInfoByScore[i+1] && (!m_Snap.m_paInfoByScore[i] || m_Snap.m_paInfoByScore[i]->m_Score < m_Snap.m_paInfoByScore[i+1]->m_Score))
{
const CNetObj_PlayerInfo *pTmp = m_Snap.m_paInfoByScore[i];
m_Snap.m_paInfoByScore[i] = m_Snap.m_paInfoByScore[i+1];
m_Snap.m_paInfoByScore[i+1] = pTmp;
}
}
}
// sort player infos by team
int Teams[3] = { TEAM_RED, TEAM_BLUE, TEAM_SPECTATORS };
int Index = 0;
for(int Team = 0; Team < 3; ++Team)
{
for(int i = 0; i < MAX_CLIENTS && Index < MAX_CLIENTS; ++i)
{
if(m_Snap.m_paPlayerInfos[i] && m_Snap.m_paPlayerInfos[i]->m_Team == Teams[Team])
m_Snap.m_paInfoByTeam[Index++] = m_Snap.m_paPlayerInfos[i];
}
}
CTuningParams StandardTuning;
CServerInfo CurrentServerInfo;
Client()->GetServerInfo(&CurrentServerInfo);
if(CurrentServerInfo.m_aGameType[0] != '0')
{
if(str_comp(CurrentServerInfo.m_aGameType, "DM") != 0 && str_comp(CurrentServerInfo.m_aGameType, "TDM") != 0 && str_comp(CurrentServerInfo.m_aGameType, "CTF") != 0)
m_ServerMode = SERVERMODE_MOD;
else if(mem_comp(&StandardTuning, &m_Tuning, sizeof(CTuningParams)) == 0)
m_ServerMode = SERVERMODE_PURE;
else
m_ServerMode = SERVERMODE_PUREMOD;
}
// add tuning to demo
if(DemoRecorder()->IsRecording() && mem_comp(&StandardTuning, &m_Tuning, sizeof(CTuningParams)) != 0)
{
CMsgPacker Msg(NETMSGTYPE_SV_TUNEPARAMS);
int *pParams = (int *)&m_Tuning;
for(unsigned i = 0; i < sizeof(m_Tuning)/sizeof(int); i++)
Msg.AddInt(pParams[i]);
Client()->SendMsg(&Msg, MSGFLAG_RECORD|MSGFLAG_NOSEND);
}
if(!m_DDRaceMsgSent && m_Snap.m_pLocalInfo)
{
CNetMsg_Cl_IsDDRace Msg;
Client()->SendPackMsg(&Msg, MSGFLAG_VITAL);
m_DDRaceMsgSent = true;
}
if(m_ShowOthers == -1 || (m_ShowOthers != -1 && m_ShowOthers != g_Config.m_ClShowOthers))
{
// no need to send, default settings
//if(!(m_ShowOthers == -1 && g_Config.m_ClShowOthers))
{
CNetMsg_Cl_ShowOthers Msg;
Msg.m_Show = g_Config.m_ClShowOthers;
Client()->SendPackMsg(&Msg, MSGFLAG_VITAL);
}
// update state
m_ShowOthers = g_Config.m_ClShowOthers;
}
}
static void Run ( intf_thread_t *p_intf )
{
intf_sys_t *p_sys = p_intf->p_sys;
mtime_t i_last_run = mdate();
for( ;; )
{
int canc = vlc_savecancel();
vlc_mutex_lock( &p_sys->lock );
int i_watches = vlc_array_count( p_sys->p_watches );
struct pollfd *p_fds = calloc( i_watches, sizeof( struct pollfd ) );
int i_fds = GetPollFds( p_intf, p_fds );
mtime_t i_now = mdate(), i_loop_interval = i_now - i_last_run;
msg_Dbg( p_intf,
"%lld µs elapsed since last wakeup",
(long long) i_loop_interval );
int i_next_timeout = UpdateTimeouts( p_intf, i_loop_interval );
i_last_run = i_now;
vlc_mutex_unlock( &p_sys->lock );
if( -1 != i_next_timeout )
msg_Dbg( p_intf, "next timeout is in %d ms", i_next_timeout );
msg_Dbg( p_intf, "Sleeping until something happens" );
/* thread cancellation is allowed while the main loop sleeps */
vlc_restorecancel( canc );
int i_pollres = poll( p_fds, i_fds, i_next_timeout );
int i_errsv = errno;
canc = vlc_savecancel();
msg_Dbg( p_intf, "the main loop has been woken up" );
if( -1 == i_pollres )
{ /* XXX: What should we do when poll() fails ? */
char buf[64];
msg_Err( p_intf, "poll() failed: %s", strerror_r( i_errsv, buf, 64 ) );
free( p_fds ); p_fds = NULL;
vlc_restorecancel( canc );
continue;
}
/* Was the main loop woken up manually ? */
if( 0 < i_pollres && ( p_fds[0].revents & POLLIN ) )
{
char buf;
msg_Dbg( p_intf, "Removing a byte from the self-pipe" );
(void)read( p_fds[0].fd, &buf, 1 );
}
/* We need to lock the mutex while building lists of events,
* timeouts and watches to process but we can't keep the lock while
* processing them, or else we risk a deadlock:
*
* The signal functions could lock mutex X while p_events is locked;
* While some other function in vlc (playlist) might lock mutex X
* and then set a variable which would call AllCallback(), which itself
* needs to lock p_events to add a new event.
*/
vlc_mutex_lock( &p_intf->p_sys->lock );
/* Get the list of timeouts to process */
unsigned int i_timeouts = vlc_array_count( p_sys->p_timeouts );
DBusTimeout *p_timeouts[i_timeouts];
for( unsigned int i = 0; i < i_timeouts; i++ )
{
p_timeouts[i] = vlc_array_item_at_index( p_sys->p_timeouts, i );
}
/* Get the list of watches to process */
i_watches = vlc_array_count( p_sys->p_watches );
DBusWatch *p_watches[i_watches];
for( int i = 0; i < i_watches; i++ )
{
p_watches[i] = vlc_array_item_at_index( p_sys->p_watches, i );
}
/* Get the list of events to process */
int i_events = vlc_array_count( p_intf->p_sys->p_events );
callback_info_t* p_info[i_events];
for( int i = i_events - 1; i >= 0; i-- )
{
p_info[i] = vlc_array_item_at_index( p_intf->p_sys->p_events, i );
vlc_array_remove( p_intf->p_sys->p_events, i );
}
/* now we can release the lock and process what's pending */
vlc_mutex_unlock( &p_intf->p_sys->lock );
ProcessEvents( p_intf, p_info, i_events );
ProcessWatches( p_intf, p_watches, i_watches, p_fds, i_fds );
free( p_fds ); p_fds = NULL;
ProcessTimeouts( p_intf, p_timeouts, i_timeouts );
DispatchDBusMessages( p_intf );
vlc_restorecancel( canc );
}
}
void CCDFrameInterface::StartExposureButton_Click(Button& sender, bool checked){
if (ThePixInsightINDIInterface!=0){
#if defined(WIN32)
const char* tmpDir = getenv("TMP");
#else
const char* tmpDir = getenv("TMPDIR");
#endif
if (tmpDir!=NULL) {
PixInsightINDIInstance* pInstance=&ThePixInsightINDIInterface->instance;
if (pInstance==NULL)
return;
GUI->StartExposure_PushButton.Disable();
INDIPropertyListItem uploadLocal;
bool serverSendsImage=true;
if (pInstance->getINDIPropertyItem(m_Device,"UPLOAD_MODE","UPLOAD_LOCAL",uploadLocal)){
serverSendsImage=!(uploadLocal.PropertyValue==String("ON"));
}
for (int num=0; num<m_NumOfExposures;++num){
GUI->ExpFrame_Edit.SetText(String(num));
INDINewPropertyListItem newPropertyListItem;
newPropertyListItem.Device=m_Device;
newPropertyListItem.Property=String("CCD_EXPOSURE");
newPropertyListItem.Element=String("CCD_EXPOSURE_VALUE");
newPropertyListItem.PropertyType=String("INDI_NUMBER");
newPropertyListItem.NewPropertyValue=String(m_ExposureDuration);
GUI->ExposureDuration_Timer.Start();
bool send_ok = pInstance->sendNewPropertyValue(newPropertyListItem,true/*isAsynchCall*/);
if (!send_ok){
break;
}
// TODO enable abort
if (serverSendsImage){
while (!pInstance->getImageDownloadedFlag() && !pInstance->getInternalAbortFlag()){Sleep(1);ProcessEvents();}
pInstance->setImageDownloadedFlag(false);
} else {
INDIPropertyListItem ccdExposure;
bool serverExposureIsBusy=false;
// timimg problem: wait until server sends BUSY
do {
pInstance->getINDIPropertyItem(m_Device,"CCD_EXPOSURE","CCD_EXPOSURE_VALUE",ccdExposure);
Sleep(1);
ProcessEvents();
serverExposureIsBusy = ccdExposure.PropertyState==IPS_BUSY ;
} while (!serverExposureIsBusy && (GUI->ExpDur_Edit.Text().ToFloat() < pcl_timeout) && !pInstance->getInternalAbortFlag());
do {
pInstance->getINDIPropertyItem(m_Device,"CCD_EXPOSURE","CCD_EXPOSURE_VALUE",ccdExposure);
Sleep(1);
ProcessEvents();
} while((ccdExposure.PropertyState==IPS_BUSY)&& !pInstance->getInternalAbortFlag());
}
if (pInstance->getInternalAbortFlag()){
// stop timer
GUI->ExposureDuration_Timer.Stop();
GUI->ExposureDelay_Timer.Stop();
break;
}
if (serverSendsImage) {
Array<ImageWindow> imgArray = ImageWindow::Open(String(tmpDir)+ String("/Image.fits"), IsoString("image"));
if (imgArray.Length()!=0){
imgArray[0].ZoomToFit( false ); // don't allow zoom > 1
imgArray[0].Show();
}
if (m_saveFrame) {
IsoString source = IsoString(String(tmpDir)+ String("/Image.fits"));
IsoString dest = IsoString(m_FrameFolder) + IsoString(this->m_FramePrefix) + IsoString("_") + IsoString(num) + IsoString(".fits");
std::ifstream infile(source.c_str(), std::ifstream::binary);
std::ofstream outfile(dest.c_str(), std::ofstream::binary);
// get size of file
infile.seekg(0, infile.end);
long size = infile.tellg();
infile.seekg(0);
// allocate memory for file content
char* buffer = new char[size];
// read content of infile
infile.read(buffer, size);
// write to outfile
outfile.write(buffer, size);
// release dynamically-allocated memory
delete[] buffer;
outfile.close();
infile.close();
}
}
// wait until next exposure
if (GUI->ExpDelayTime_Edit.Text().ToInt()!=0){
GUI->ExposureDelay_Timer.Start();
m_isWaiting=true;
}
while (m_isWaiting){ProcessEvents();}
}
pInstance->setInternalAbortFlag(false);
GUI->StartExposure_PushButton.Enable();
}
}
}
void VMenu2::Resize(bool force)
{
if(!force && (!ProcessEvents() || SendMessage(DM_ENABLEREDRAW, -1, nullptr)<0))
{
NeedResize=true;
return;
}
NeedResize=false;
FarListInfo info={sizeof(FarListInfo)};
SendMessage(DM_LISTINFO, 0, &info);
int X1 = m_X1;
int Y1 = m_Y1;
if(!ShortBox)
{
if(X1>1)
X1-=2;
if(Y1>0)
Y1-=1;
}
int width=info.MaxLength+(ShortBox?2:6) + 3;
if(m_X2>0)
width=m_X2-X1+1;
if(width>ScrX+1)
width=ScrX+1;
int height=GetShowItemCount();
if(MaxHeight && height>MaxHeight)
height=MaxHeight;
height+=ShortBox?2:4;
if(m_Y2>0)
height=m_Y2-Y1+1;
int mh=Y1<0 ? ScrY : ScrY-Y1;
mh+=ShortBox ? 1 : 2;
if(mh<0)
mh=0;
if(height>mh)
{
if(m_Y2<=0 && Y1>=ScrY/2)
{
Y1+=ShortBox?1:3;
if(height>Y1)
height=Y1;
Y1-=height;
}
else
height=mh;
}
int X=X1;
if(X>0 && (X+width>ScrX))
X-=X+width-ScrX;
COORD size;
size.X=width;
size.Y=height;
SendMessage(DM_RESIZEDIALOG, true, &size);
SMALL_RECT ipos;
if(ShortBox)
{
ipos.Left=0;
ipos.Top=0;
ipos.Right=width-1;
ipos.Bottom=height-1;
}
else
{
ipos.Left=2;
ipos.Top=1;
ipos.Right=width-3;
ipos.Bottom=height-2;
}
SendMessage(DM_SETITEMPOSITION, 0, &ipos);
COORD pos;
pos.X=X;
pos.Y=Y1;
SendMessage(DM_MOVEDIALOG, true, &pos);
}
int DoRun()
{
// we must ensure that OnExit() is called even if an exception is thrown
// from inside ProcessEvents() but we must call it from Exit() in normal
// situations because it is supposed to be called synchronously,
// wxModalEventLoop depends on this (so we can't just use ON_BLOCK_EXIT or
// something similar here)
#if wxUSE_EXCEPTIONS
for( ; ; )
{
try
{
#endif // wxUSE_EXCEPTIONS
// this is the event loop itself
for( ; ; )
{
// generate and process idle events for as long as we don't
// have anything else to do
while ( !m_shouldExit && !Pending() && ProcessIdle() )
;
if ( m_shouldExit )
break;
// a message came or no more idle processing to do, dispatch
// all the pending events and call Dispatch() to wait for the
// next message
if ( !ProcessEvents() )
{
// we got WM_QUIT
break;
}
}
// Process the remaining queued messages, both at the level of the
// underlying toolkit level (Pending/Dispatch()) and wx level
// (Has/ProcessPendingEvents()).
//
// We do run the risk of never exiting this loop if pending event
// handlers endlessly generate new events but they shouldn't do
// this in a well-behaved program and we shouldn't just discard the
// events we already have, they might be important.
for( ; ; )
{
bool hasMoreEvents = false;
if ( wxTheApp && wxTheApp->HasPendingEvents() )
{
wxTheApp->ProcessPendingEvents();
hasMoreEvents = true;
}
if ( Pending() )
{
Dispatch();
hasMoreEvents = true;
}
if ( !hasMoreEvents )
break;
}
#if wxUSE_EXCEPTIONS
// exit the outer loop as well
break;
}
catch ( ... )
{
try
{
if ( !wxTheApp || !wxTheApp->OnExceptionInMainLoop() )
{
OnExit();
break;
}
//else: continue running the event loop
}
catch ( ... )
{
// OnException() throwed, possibly rethrowing the same
// exception again: very good, but we still need OnExit() to
// be called
OnExit();
throw;
}
}
}
#endif // wxUSE_EXCEPTIONS
return m_exitcode;
}