void AbcWriteJob::perFrameCallback(double iFrame)
{
MBoundingBox bbox;
util::ShapeSet::iterator it = mArgs.dagPaths.begin();
const util::ShapeSet::iterator end = mArgs.dagPaths.end();
for (; it != end; it ++)
{
mCurDag = *it;
MMatrix eMInvMat;
if (mArgs.worldSpace)
{
eMInvMat.setToIdentity();
}
else
{
eMInvMat = mCurDag.exclusiveMatrixInverse();
}
bbox.expand(getBoundingBox(iFrame, eMInvMat));
}
Alembic::Abc::V3d min(bbox.min().x, bbox.min().y, bbox.min().z);
Alembic::Abc::V3d max(bbox.max().x, bbox.max().y, bbox.max().z);
Alembic::Abc::Box3d b(min, max);
mBoxProp.set(b);
processCallback(mArgs.melPerFrameCallback, true, iFrame, bbox);
processCallback(mArgs.pythonPerFrameCallback, false, iFrame, bbox);
}
void TeenAgentEngine::processObject() {
if (dst_object == NULL)
return;
Resources *res = Resources::instance();
switch (action) {
case kActionExamine: {
if (trySelectedObject())
break;
byte *dcall = res->dseg.ptr(0xb5ce);
dcall = res->dseg.ptr(READ_LE_UINT16(dcall + scene->getId() * 2 - 2));
dcall += 2 * dst_object->id - 2;
uint16 callback = READ_LE_UINT16(dcall);
if (callback == 0 || !processCallback(callback))
displayMessage(dst_object->description);
}
break;
case kActionUse: {
if (trySelectedObject())
break;
byte *dcall = res->dseg.ptr(0xb89c);
dcall = res->dseg.ptr(READ_LE_UINT16(dcall + scene->getId() * 2 - 2));
dcall += 2 * dst_object->id - 2;
uint16 callback = READ_LE_UINT16(dcall);
if (!processCallback(callback))
displayMessage(dst_object->description);
}
break;
case kActionNone:
break;
}
}
// write the frame ranges and statistic string on the root
// Also call the post callbacks
void AbcWriteJob::postCallback(double iFrame)
{
std::string statsStr = "";
addToString(statsStr, "TransStaticNum", mStats.mTransStaticNum);
addToString(statsStr, "TransAnimNum", mStats.mTransAnimNum);
addToString(statsStr, "TransColNum", mStats.mTransColNum);
if (statsStr.length() > 0)
{
Alembic::Abc::OStringProperty stats(mRoot.getTop().getProperties(),
"statistics");
stats.set(statsStr);
}
if (mTransTimeIndex != 0)
{
MString propName;
propName += static_cast<int>(mTransTimeIndex);
propName += ".samples";
Alembic::Abc::OUInt32Property samp(mRoot.getTop().getProperties(),
propName.asChar());
samp.set(mTransSamples);
}
MBoundingBox bbox;
processCallback(mArgs.melPostCallback, true, iFrame, bbox);
processCallback(mArgs.pythonPostCallback, false, iFrame, bbox);
}
void AbcWriteJob::perFrameCallback(double iFrame)
{
MBoundingBox bbox;
processCallback(mArgs.melPerFrameCallback, true, iFrame, bbox);
processCallback(mArgs.pythonPerFrameCallback, false, iFrame, bbox);
}
/**
*****************************************************************************
* @ingroup dsaPerformance
* dsaVerifyCb
*
* @description
* handle callbacks due to asymmetric call of cpaDsaVerify
*
*****************************************************************************/
static void dsaVerifyCb(void* pCallbackTag,
CpaStatus status,
void* pOpData,
CpaBoolean verifyStatus)
{
processCallback(pCallbackTag);
}
/*****************************************************************************
* @ingroup IKE_RSA Threads
*
* @description
* Asymmetric callback function: This function is invoked when a
* operation has been processed
*****************************************************************************/
void
ikeRsaCallback(void *pCallbackTag,
CpaStatus status,
void *pOpData,
CpaFlatBuffer *pOut)
{
processCallback(pCallbackTag);
}
/**
* \brief connects to port to listen for incoming data
* \param [in] port port to listen on for incoming connections
**/
bool CommandServer::connect( uint32_t port, std::function<void(bool,std::string)> connectionCallback)
{
if(connectionCallback) {
m_connectionCallback = connectionCallback;
}
SocketServer::m_connectionCallback = [&](int index, bool connected) {
connection(index, connected);
};
bool rc = JsonServer::connect(port,[&](int index, JsonBox::Value value) {
return processCallback(index, value);
});
if(rc) {
std::cout << "Command server listening on port "<<port<<std::endl;
} else {
std::cerr<< "Command server failed to connect to port "<<port<<std::endl;
}
return rc;
}
Common::Error TeenAgentEngine::run() {
Resources *res = Resources::instance();
if (!res->loadArchives(_gameDescription))
return Common::kUnknownError;
Common::EventManager *_event = _system->getEventManager();
initGraphics(320, 200, false);
scene = new Scene;
inventory = new Inventory;
console = new Console(this);
scene->init(this, _system);
inventory->init(this);
init();
CursorMan.pushCursor(res->dseg.ptr(0x00da), 8, 12, 0, 0, 1);
syncSoundSettings();
_mixer->playStream(Audio::Mixer::kMusicSoundType, &_musicHandle, music, -1, Audio::Mixer::kMaxChannelVolume, 0, DisposeAfterUse::NO, false);
setMusic(1);
music->start();
int load_slot = Common::ConfigManager::instance().getInt("save_slot");
if (load_slot >= 0) {
loadGameState(load_slot);
} else {
if (!showCDLogo())
return Common::kNoError;
if (!showLogo())
return Common::kNoError;
if (!showMetropolis())
return Common::kNoError;
scene->intro = true;
scene_busy = true;
processCallback(0x24c);
}
CursorMan.showMouse(true);
uint32 game_timer = 0;
uint32 mark_timer = 0;
Common::Event event;
Common::Point mouse;
uint32 timer = _system->getMillis();
do {
Object *current_object = scene->findObject(mouse);
while (_event->pollEvent(event)) {
if (event.type == Common::EVENT_RTL) {
deinit();
return Common::kNoError;
}
if ((!scene_busy && inventory->processEvent(event)) || scene->processEvent(event))
continue;
//debug(0, "event");
switch (event.type) {
case Common::EVENT_KEYDOWN:
if ((event.kbd.hasFlags(Common::KBD_CTRL) && event.kbd.keycode == Common::KEYCODE_d) ||
event.kbd.ascii == '~' || event.kbd.ascii == '#') {
console->attach();
} else if (event.kbd.hasFlags(0) && event.kbd.keycode == Common::KEYCODE_F5) {
openMainMenuDialog();
} if (event.kbd.hasFlags(Common::KBD_CTRL) && event.kbd.keycode == Common::KEYCODE_f) {
_mark_delay = _mark_delay == 80? 40: 80;
debug(0, "mark_delay = %u", _mark_delay);
}
break;
case Common::EVENT_LBUTTONDOWN:
if (scene->getId() < 0)
break;
examine(event.mouse, current_object);
break;
case Common::EVENT_RBUTTONDOWN:
//if (current_object)
// debug(0, "%d, %s", current_object->id, current_object->name.c_str());
if (scene->getId() < 0)
break;
if (current_object == NULL)
break;
if (res->dseg.get_byte(0) == 3 && current_object->id == 1) {
processCallback(0x5189); //boo!
break;
}
if (res->dseg.get_byte(0) == 4 && current_object->id == 5) {
processCallback(0x99e0); //getting an anchor
break;
}
use(current_object);
break;
case Common::EVENT_MOUSEMOVE:
mouse = event.mouse;
break;
default:
;
}
}
//game delays: slow 16, normal 11, fast 5, crazy 1
//mark delays: 4 * (3 - hero_speed), normal == 1
//game delays in 1/100th of seconds
uint32 new_timer = _system->getMillis();
uint32 delta = new_timer - timer;
timer = new_timer;
bool tick_game = game_timer <= delta;
if (tick_game)
game_timer = _game_delay - ((delta - game_timer) % _game_delay);
else
game_timer -= delta;
bool tick_mark = mark_timer <= delta;
if (tick_mark)
mark_timer = _mark_delay - ((delta - mark_timer) % _mark_delay);
else
mark_timer -= delta;
if (tick_game || tick_mark) {
bool b = scene->render(tick_game, tick_mark, delta);
if (!inventory->active() && !b && action != kActionNone) {
processObject();
action = kActionNone;
dst_object = NULL;
}
scene_busy = b;
}
_system->showMouse(scene->getMessage().empty() && !scene_busy);
bool busy = inventory->active() || scene_busy;
Graphics::Surface *surface = _system->lockScreen();
if (!busy) {
InventoryObject *selected_object = inventory->selectedObject();
if (current_object || selected_object) {
Common::String name;
if (selected_object) {
name += selected_object->name;
name += " & ";
}
if (current_object)
name += current_object->name;
uint w = res->font7.render(NULL, 0, 0, name, 0xd1);
res->font7.render(surface, (320 - w) / 2, 180, name, 0xd1, true);
#if 0
if (current_object) {
current_object->rect.render(surface, 0x80);
current_object->actor_rect.render(surface, 0x81);
}
#endif
}
}
inventory->render(surface, tick_game? 1: 0);
_system->unlockScreen();
_system->updateScreen();
console->onFrame();
uint32 next_tick = MIN(game_timer, mark_timer);
if (next_tick > 0) {
_system->delayMillis(next_tick > 40? 40: next_tick);
}
} while (!shouldQuit());
deinit();
return Common::kNoError;
}
// write the frame ranges and statistic string on the root
// Also call the post callbacks
void AbcWriteJob::postCallback(double iFrame)
{
std::string statsStr = "";
addToString(statsStr, "SubDStaticNum", mStats.mSubDStaticNum);
addToString(statsStr, "SubDAnimNum", mStats.mSubDAnimNum);
addToString(statsStr, "SubDStaticCVs", mStats.mSubDStaticCVs);
addToString(statsStr, "SubDAnimCVs", mStats.mSubDAnimCVs);
addToString(statsStr, "SubDStaticFaces", mStats.mSubDStaticFaces);
addToString(statsStr, "SubDAnimFaces", mStats.mSubDAnimFaces);
addToString(statsStr, "PolyStaticNum", mStats.mPolyStaticNum);
addToString(statsStr, "PolyAnimNum", mStats.mPolyAnimNum);
addToString(statsStr, "PolyStaticCVs", mStats.mPolyStaticCVs);
addToString(statsStr, "PolyAnimCVs", mStats.mPolyAnimCVs);
addToString(statsStr, "PolyStaticFaces", mStats.mPolyStaticFaces);
addToString(statsStr, "PolyAnimFaces", mStats.mPolyAnimFaces);
addToString(statsStr, "CurveStaticNum", mStats.mCurveStaticNum);
addToString(statsStr, "CurveStaticCurves", mStats.mCurveStaticCurves);
addToString(statsStr, "CurveAnimNum", mStats.mCurveAnimNum);
addToString(statsStr, "CurveAnimCurves", mStats.mCurveAnimCurves);
addToString(statsStr, "CurveStaticCVs", mStats.mCurveStaticCVs);
addToString(statsStr, "CurveAnimCVs", mStats.mCurveAnimCVs);
addToString(statsStr, "PointStaticNum", mStats.mPointStaticNum);
addToString(statsStr, "PointAnimNum", mStats.mPointAnimNum);
addToString(statsStr, "PointStaticCVs", mStats.mPointStaticCVs);
addToString(statsStr, "PointAnimCVs", mStats.mPointAnimCVs);
addToString(statsStr, "NurbsStaticNum", mStats.mNurbsStaticNum);
addToString(statsStr, "NurbsAnimNum", mStats.mNurbsAnimNum);
addToString(statsStr, "NurbsStaticCVs", mStats.mNurbsStaticCVs);
addToString(statsStr, "NurbsAnimCVs", mStats.mNurbsAnimCVs);
addToString(statsStr, "TransStaticNum", mStats.mTransStaticNum);
addToString(statsStr, "TransAnimNum", mStats.mTransAnimNum);
addToString(statsStr, "LocatorStaticNum", mStats.mLocatorStaticNum);
addToString(statsStr, "LocatorAnimNum", mStats.mLocatorAnimNum);
addToString(statsStr, "CameraStaticNum", mStats.mCameraStaticNum);
addToString(statsStr, "CameraAnimNum", mStats.mCameraAnimNum);
if (statsStr.length() > 0)
{
Alembic::Abc::OStringProperty stats(mRoot.getTop().getProperties(),
"statistics");
stats.set(statsStr);
}
if (mTransTimeIndex != 0)
{
MString propName;
propName += static_cast<int>(mTransTimeIndex);
propName += ".samples";
Alembic::Abc::OUInt32Property samp(mRoot.getTop().getProperties(),
propName.asChar());
samp.set(mTransSamples);
}
if (mShapeTimeIndex != 0 && mShapeTimeIndex != mTransTimeIndex)
{
MString propName;
propName += static_cast<int>(mShapeTimeIndex);
propName += ".samples";
Alembic::Abc::OUInt32Property samp(mRoot.getTop().getProperties(),
propName.asChar());
samp.set(mShapeSamples);
}
MBoundingBox bbox;
if (mArgs.melPostCallback.find("#BOUNDS#") != std::string::npos ||
mArgs.pythonPostCallback.find("#BOUNDS#") != std::string::npos ||
mArgs.melPostCallback.find("#BOUNDSARRAY#") != std::string::npos ||
mArgs.pythonPostCallback.find("#BOUNDSARRAY#") != std::string::npos)
{
util::ShapeSet::const_iterator it = mArgs.dagPaths.begin();
const util::ShapeSet::const_iterator end = mArgs.dagPaths.end();
for (; it != end; it ++)
{
mCurDag = *it;
MMatrix eMInvMat;
if (mArgs.worldSpace)
{
eMInvMat.setToIdentity();
}
else
{
eMInvMat = mCurDag.exclusiveMatrixInverse();
}
bbox.expand(getBoundingBox(iFrame, eMInvMat));
}
}
processCallback(mArgs.melPostCallback, true, iFrame, bbox);
processCallback(mArgs.pythonPostCallback, false, iFrame, bbox);
}
