BT411/engine/MUNGA/WATCHER.h

#pragma once
#include <cstdlib>

#include "cmpnnt.h"
#include "slot.h"
#include "memstrm.h"

class PlugStream;
class Simulation;
class Entity;

//##########################################################################
//###########################    AttributeWatcher    #######################
//##########################################################################

class AttributeWatcher:
	public Component
{
public:
	//
	//-----------------------------------------------------------------------
	// Destructor
	//-----------------------------------------------------------------------
	//
	~AttributeWatcher();

	Logical
		TestInstance() const;

	//
	//-----------------------------------------------------------------------
	// DidAttributeChange
	//
	// Returns True if attribute has changed since the last time
	// DidAttributeChange was called.
	//-----------------------------------------------------------------------
	//
	Logical
		DidAttributeChange();

protected:
	//
	//-----------------------------------------------------------------------
	// Constructor
	//-----------------------------------------------------------------------
	//
	AttributeWatcher(
		PlugStream *stream,
		Entity *entity
	);

	//
	//-----------------------------------------------------------------------
	// SendNotificationOfChange
	//-----------------------------------------------------------------------
	//
	virtual void
		SendNotificationOfChange();

	//
	//-----------------------------------------------------------------------
	// BuildFromPage
	//-----------------------------------------------------------------------
	//
	static void
		BuildFromPage(
			PlugStream *stream,
			NameList *name_list,
			ClassID class_ID,
			ObjectID object_ID
		);

	//
	//-----------------------------------------------------------------------
	// Protected data
	//-----------------------------------------------------------------------
	//
	Simulation*
		simulation;
	void*
		attributePointer;
	Logical
		attributeChanged;
	Logical
		sendNotificationOnChange;
};

//##########################################################################
//###########################    AttributeWatcherOf    #####################
//##########################################################################

template <class T> class AttributeWatcherOf:
	public AttributeWatcher
{
public:
	~AttributeWatcherOf();

	//
	//-----------------------------------------------------------------------
	// Accessors
	//-----------------------------------------------------------------------
	//
	T
		GetCurrentValue()
			{return currentValue;}
	T*
		GetCurrentPointer()
			{return &currentValue;}

	//
	//-----------------------------------------------------------------------
	// Execute
	//-----------------------------------------------------------------------
	//
	void
		Execute();

	//
	//-----------------------------------------------------------------------
	// PrimeWatcher
	//-----------------------------------------------------------------------
	//
	void
		PrimeWatcher();

protected:
	//
	//-----------------------------------------------------------------------
	// Constructor
	//-----------------------------------------------------------------------
	//
	AttributeWatcherOf(
		PlugStream *stream,
		Entity *entity
	);

	//
	//-----------------------------------------------------------------------
	// BuildFromPage
	//-----------------------------------------------------------------------
	//
	static void
		BuildFromPage(
			PlugStream *stream,
			NameList *name_list,
			ClassID class_ID,
			ObjectID object_ID
		);

private:
	//
	//-----------------------------------------------------------------------
	// InitializeCurrentValue
	//-----------------------------------------------------------------------
	//
	void
		InitializeCurrentValue();

protected:
	//
	//-----------------------------------------------------------------------
	// GrabCurrentValue -- protected (task #50): AudioScaleOf's per-poll
	// Execute override calls it directly (see AUDWTHR.h).
	//-----------------------------------------------------------------------
	//
	void
		GrabCurrentValue();

private:

	//
	//-----------------------------------------------------------------------
	// DumpValue
	//-----------------------------------------------------------------------
	//
	virtual void
		DumpValue(const T *attribute_ptr);

	//
	//-----------------------------------------------------------------------
	// Private data
	//-----------------------------------------------------------------------
	//
	T
		currentValue;
	#if DEBUG_LEVEL>0
		Logical
			dumpValue;
	#endif
};

//~~~~~~~~~~~~~~~~~~~~~~~~ AttributeWatcherOf templates ~~~~~~~~~~~~~~~~~~~~

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T>
	AttributeWatcherOf<T>::~AttributeWatcherOf()
{
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T>
	AttributeWatcherOf<T>::AttributeWatcherOf(
		PlugStream *stream,
		Entity *entity
	):
		AttributeWatcher(stream, entity)
{
	Check_Pointer(this);

	Logical dump_value;

	MemoryStream_Read(stream, &dump_value);

	#if DEBUG_LEVEL>0
		dumpValue = dump_value;
		if (dumpValue)
		{
			Tell(
				"AttributeWatcherOf<T>::AttributeWatcherOf - " <<
				*(T*)attributePointer <<
				"\n"
			);
		}
	#endif

	InitializeCurrentValue();
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T> void
	AttributeWatcherOf<T>::BuildFromPage(
		PlugStream *stream,
		NameList *name_list,
		ClassID class_ID,
		ObjectID object_ID
	)
{
	Check(stream);
	Check(name_list);

	AttributeWatcher::BuildFromPage(stream, name_list, class_ID, object_ID);

	//
	// Store dump_value
	//
	MEM_STRM_WRITE_ENTRY(*stream, name_list, Logical, dump_value);
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T> void
	AttributeWatcherOf<T>::PrimeWatcher()
{
	Check(this);
	#if DEBUG_LEVEL>0
		if (dumpValue)
		{
			DumpValue((T*)attributePointer);
		}
	#endif
	GrabCurrentValue();
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T> void
	AttributeWatcherOf<T>::Execute()
{
	Check(this);

	Check_Pointer(attributePointer);
	if (getenv("BT_AUDIO_SPATIAL")) {	// poll-rate probe: total watcher polls + change events
		static long s_polls=0; if ((++s_polls % 2000)==0)
			DEBUG_STREAM << "[watchpoll] total polls=" << s_polls << "\n" << std::flush;
		extern void *g_btFootStepAddr;	// DIAG: uncapped tracer on THE footstep watcher
		if ((void*)attributePointer == g_btFootStepAddr) {
			static long s_fsp=0;
			if ((++s_fsp % 120)==0 || !(currentValue == *(T*)attributePointer))
				DEBUG_STREAM << "[fswatch] poll#" << s_fsp << " cur=" << (int)*(int*)&currentValue
					<< " mem=" << *(int*)attributePointer << "\n" << std::flush;
		}
		extern void *g_btAccelAddr;		// DIAG: poll-vs-change split on the accel attr
		if ((void*)attributePointer == g_btAccelAddr) {
			static long s_ap=0, s_ac=0;
			int changed = !(currentValue == *(T*)attributePointer);
			if (changed) ++s_ac;
			if ((++s_ap % 120)==0 || (changed && (s_ac % 30)==0))
				DEBUG_STREAM << "[accwatch] t=" << (GetTickCount() % 1000000)
					<< " poll#" << s_ap << " changes=" << s_ac
					<< " memY=" << ((float*)attributePointer)[1]
					<< " curY=" << ((float*)&currentValue)[1] << "\n" << std::flush;
		}
	}
	if (!(currentValue == *(T*)attributePointer))
	{
		if (getenv("BT_AUDIO_SPATIAL")) { static int s_chg=0; if (s_chg++<60)
			DEBUG_STREAM << "[watchpoll] CHANGE attrPtr=" << (void*)attributePointer << "\n" << std::flush; }
		#if DEBUG_LEVEL>0
			if (dumpValue)
			{
				DumpValue((T*)attributePointer);
			}
		#endif
		GrabCurrentValue();
	}
	Check_Fpu();
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T> void
	AttributeWatcherOf<T>::InitializeCurrentValue()
{
	Check_Pointer(attributePointer);
	currentValue = *(T*)attributePointer;
	Verify(currentValue == *(T*)attributePointer);
	Check_Fpu();
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T> void
	AttributeWatcherOf<T>::GrabCurrentValue()
{
  InitializeCurrentValue();
	attributeChanged = True;
	if (sendNotificationOnChange)
	{
		SendNotificationOfChange();
	}
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#if DEBUG_LEVEL>0
template <class T> void
	AttributeWatcherOf<T>::DumpValue(const T *attribute_ptr)
#else
template <class T> void
	AttributeWatcherOf<T>::DumpValue(const T*)
#endif
{
	Check_Pointer(attribute_ptr);
	Tell((void *)attribute_ptr << " = " << *attribute_ptr << "\n");
}