TeslaRel410/restoration/source410/MUNGA/APPTASK.CPP

//===========================================================================//
// File:	apptask.cpp                                                         //
// Project: MUNGA           Brick: Application								  		  //
// Contents: Interface specification for Application								  //
//---------------------------------------------------------------------------//
//   Date    Who  Modification                                               //
// --------  ---  ---------------------------------------------------------- //
// 08/24/94  ECH  Initial coding.                                            //
//---------------------------------------------------------------------------//
// Copyright (C) 1994-1995, Virtual World Entertainment, Inc.                //
// All Rights reserved worldwide                                             //
// This unpublished sourcecode is PROPRIETARY and CONFIDENTIAL               //
//===========================================================================//

#include <munga.hpp>
#pragma hdrstop

#if !defined(APPTASK_HPP)
#	include <apptask.hpp>
#endif

#if !defined(RENDERER_HPP)
#	include	<renderer.hpp>
#endif

#if !defined(AUDREND_HPP)
#	include	<audrend.hpp>
#endif

#if !defined(APP_HPP)
#	include <app.hpp>
#endif

#if !defined(NTTMGR_HPP)
#	include <nttmgr.hpp>
#endif

#if !defined(GAUGEREND_HPP)
#	include <gaugrend.hpp>
#endif

#if defined(TRACE_COMPLETE_CYCLES)
	BitTrace Complete_Cycles("Complete Cycles");
#endif

#if defined(TRACE_DEATH_ROW)
	BitTrace Death_Row("Death Row");
#endif

//#############################################################################
//###########################    ApplicationTask    ###########################
//#############################################################################

ApplicationTask::ApplicationTask(ClassID class_ID):
	Component(class_ID)
{
}

ApplicationTask::~ApplicationTask()
{
}

//#############################################################################
//###########################    BackgroundTasks    ###########################
//#############################################################################

BackgroundTasks::BackgroundTasks():
	taskSocket(NULL)
{
	taskIterator = new SChainIteratorOf<ApplicationTask*>(&taskSocket);
	Register_Object(taskIterator);
}

BackgroundTasks::~BackgroundTasks()
{
	Check(taskIterator);
   taskIterator->DeletePlugs();
	Unregister_Object(taskIterator);
	delete taskIterator;
}

Logical
	BackgroundTasks::TestInstance() const
{
	Component::TestInstance();
	Check(&taskSocket);
	Check(taskIterator);
	return True;
}

void
	BackgroundTasks::AddTask(ApplicationTask *task)
{
	Check(this);
   Check(task);
	taskSocket.Add(task);
}

void
	BackgroundTasks::Execute()
{
	Check(this);

	Check(taskIterator);
	if (taskIterator->GetCurrent() == NULL)
	{
		taskIterator->First();
	}

	ApplicationTask *task = taskIterator->GetCurrent();
	Check(task);
	task->Execute();
	taskIterator->Next();
}

//
// RING-TASK TICK SUMS (gauge-starvation probe; counters defined in app.cpp,
// printed on the [stack] line).  The single background slot per frame eats
// ~8 unaccounted ticks -- these say which task's Execute holds the clock.
//
extern long taskRouteTicks;
extern long taskEventTicks;
extern long taskAudioTicks;
extern long taskGaugeTicks;
extern long taskNetTicks;
extern long taskCyclesTicks;
extern long taskFryTicks;

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~ NetworkManagerTask ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

void
	NetworkManagerTask::Execute()
{
	Check(this);
	Check(application);
	Check(application->GetNetworkManager());
	{
#if defined(BT_TICK_PROBES)
		Time probe_t0 = Now();
		application->GetNetworkManager()->ExecuteBackground();
		taskNetTicks += (long)(Now().ticks - probe_t0.ticks);
#else
		application->GetNetworkManager()->ExecuteBackground();
#endif
	}
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~ RoutePacketTask ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

void
	RoutePacketTask::Execute()
{
	Check(this);

	Check(application);
	Check(application->GetNetworkManager());
	{
#if defined(BT_TICK_PROBES)
		Time probe_t0 = Now();
		application->GetNetworkManager()->RoutePacket();
		taskRouteTicks += (long)(Now().ticks - probe_t0.ticks);
#else
		application->GetNetworkManager()->RoutePacket();
#endif
	}
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ProcessEventTask ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

void
	ProcessEventTask::Execute()
{
	Check(this);
	Check(application);
	{
#if defined(BT_TICK_PROBES)
		Time probe_t0 = Now();
		application->ProcessOneEvent();
		taskEventTicks += (long)(Now().ticks - probe_t0.ticks);
#else
		application->ProcessOneEvent();
#endif
	}
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~ AudioRendererTask ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

void
	AudioRendererTask::Execute()
{
	Check(this);
	Check(application);
	if (application->GetAudioRenderer() != NULL)
	{
		Check(application->GetAudioRenderer());
	{
#if defined(BT_TICK_PROBES)
		Time probe_t0 = Now();
			application->GetAudioRenderer()->ExecuteBackground();
		taskAudioTicks += (long)(Now().ticks - probe_t0.ticks);
#else
			application->GetAudioRenderer()->ExecuteBackground();
#endif
	}
	}
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GaugeRendererTask ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

void
	GaugeRendererTask::Execute()
{
	Check(this);
	Check(application);
	if (application->GetGaugeRenderer() != NULL)
	{
		Check(application->GetGaugeRenderer());
	{
#if defined(BT_TICK_PROBES)
		Time probe_t0 = Now();
			application->GetGaugeRenderer()->ExecuteBackground();
		taskGaugeTicks += (long)(Now().ticks - probe_t0.ticks);
#else
			application->GetGaugeRenderer()->ExecuteBackground();
#endif
	}
	}
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~ CompleteCyclesTask ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

void
	CompleteCyclesTask::Execute()
{
	SET_COMPLETE_CYCLES();

	Check(this);
	Check(application);
	Check(application->GetRendererManager());
	{
#if defined(BT_TICK_PROBES)
		Time probe_t0 = Now();
		application->GetRendererManager()->CompleteCycles();
		taskCyclesTicks += (long)(Now().ticks - probe_t0.ticks);
#else
		application->GetRendererManager()->CompleteCycles();
#endif
	}

	CLEAR_COMPLETE_CYCLES();
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ FryDeathRowTask ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

void
	FryDeathRowTask::Execute()
{
	SET_DEATH_ROW();

	Check(this);
	Check(application);
	Check(application->GetEntityManager());
	{
#if defined(BT_TICK_PROBES)
		Time probe_t0 = Now();
		application->GetEntityManager()->FryDeathRow();
		taskFryTicks += (long)(Now().ticks - probe_t0.ticks);
#else
		application->GetEntityManager()->FryDeathRow();
#endif
	}

	CLEAR_DEATH_ROW();
}