void Game::loadTalkTable(const Common::UString &tlk, const Common::UString &suffix,
Aurora::Language language, uint32 priority, ChangeList &changes) {
Common::UString tlkM = tlk + DragonAge2Engine::getLanguageString(language) + suffix;
Common::UString tlkF = tlk + DragonAge2Engine::getLanguageString(language) + suffix + "_f";
changes.push_back(Common::ChangeID());
TalkMan.addTable(tlkM, tlkF, false, priority, &changes.back());
}
//##############################################################################
//##############################################################################
uint64_t
BerkeleyDBCXXDb::version() const
{
RANGE_LOG_FUNCTION();
ChangeList changes = this->read_changelist();
uint64_t version = changes.current_version();
auto txn = current_txn_.lock();
if(txn && txn->pending() > 0) {
++version;
}
return version;
}
//##############################################################################
//##############################################################################
uint64_t
BerkeleyDB::range_version() const
{
RANGE_LOG_FUNCTION();
this->init_info();
std::string buf = info_->get_record(record_type::GRAPH_META,
"range_changelist");
if(!buf.empty()) {
ChangeList changes;
changes.ParseFromString(buf);
return changes.current_version();
}
return 0;
}
//##############################################################################
//##############################################################################
void
BerkeleyDB::set_wanted_version(uint64_t version) {
RANGE_LOG_FUNCTION();
this->init_info();
std::string buf = info_->get_record(record_type::GRAPH_META,
"range_changelist");
ChangeList changes;
if(!buf.empty()) {
changes.ParseFromString(buf);
}
for (uint32_t c_idx = changes.change_size() - 1; c_idx >= version; --c_idx) {
for (int i_idx = 0; i_idx < changes.change(c_idx).items_size(); ++i_idx) {
auto item = changes.change(c_idx).items(i_idx);
graph_wanted_version_map_[item.key()] = item.version();
}
}
}
//##############################################################################
//##############################################################################
BerkeleyDB::range_changelist_t
BerkeleyDB::get_changelist()
{
RANGE_LOG_FUNCTION();
this->init_info();
std::string buf = info_->get_record(record_type::GRAPH_META,
"range_changelist");
ChangeList changes;
if(!buf.empty()) {
changes.ParseFromString(buf);
} else {
return range_changelist_t();
}
range_changelist_t changelist;
for (int c_idx = 0; c_idx < changes.change_size(); ++c_idx) {
range_change_t c;
std::time_t t;
for (int i_idx = 0; i_idx < changes.change(c_idx).items_size(); ++i_idx) {
auto item = changes.change(c_idx).items(i_idx);
c[item.key()] = item.version();
auto ts = changes.change(c_idx).timestamp();
t = ts.seconds();
}
changelist.push_back(std::make_tuple(t, c_idx, c));
}
return changelist;
}
//##############################################################################
//##############################################################################
BerkeleyDBCXXDb::history_list_t
BerkeleyDBCXXDb::get_change_history() const
{
RANGE_LOG_FUNCTION();
ChangeList changes = this->read_changelist();
history_list_t history_list;
for (int v = 0; v < changes.change_size(); ++v) {
ChangeList_Change v_change = changes.change(v);
changelist_t clist;
for (int i = 0; i < v_change.items_size(); ++i) {
ChangeList_Change_Item item = v_change.items(i);
record_type type = get_type_from_keyname(item.key());
std::string key = item.key().substr(key_prefix(type).size());
clist.push_back(std::make_tuple(type, key, item.version(), ""));
}
history_list.push_back(clist);
}
return history_list;
}
//##############################################################################
//##############################################################################
void
BerkeleyDB::add_new_range_version()
{
RANGE_LOG_FUNCTION();
this->init_info();
auto lock = info_->write_lock(record_type::GRAPH_META, "graph_list");
std::string buf = info_->get_record(record_type::GRAPH_META,
"range_changelist");
ChangeList changes;
if(!buf.empty()) {
changes.ParseFromString(buf);
}
std::unordered_map<std::string, uint64_t> vermap;
for (auto &gname : listGraphInstances()) {
auto ginst = getGraphInstance(gname);
vermap[gname] = ginst->version();
}
ChangeList_Change *c = changes.add_change();
for(auto &verinfo : vermap) {
auto item = c->add_items();
item->set_key(verinfo.first);
item->set_version(verinfo.second);
}
struct timeval cur_time;
gettimeofday(&cur_time, NULL);
auto ts = c->mutable_timestamp();
ts->set_seconds(cur_time.tv_sec);
ts->set_msec(cur_time.tv_usec / 1000);
changes.set_current_version(changes.current_version() + 1);
info_->commit_record(std::make_tuple(record_type::GRAPH_META, "range_changelist", 0, changes.SerializeAsString()));
}
//##############################################################################
//##############################################################################
ChangeList
BerkeleyDBCXXDb::read_changelist() const
{
RANGE_LOG_FUNCTION();
std::string buf = this->get_record(record_type::GRAPH_META, "changelist");
ChangeList changes;
if(!buf.empty()) {
changes.ParseFromString(buf);
if(!changes.IsInitialized()) {
THROW_STACK(DatabaseVersioningError("Changelist cannot be initialized"));
}
return changes;
}
changes.set_current_version(0);
changes.mutable_change();
changes.mutable_unknown_fields();
return changes;
//THROW_STACK(DatabaseVersioningError("Changelist cannot be read"));
}
uint32 ClingoPropagatorInit::init(uint32 lastStep, Potassco::AbstractSolver& s) {
POTASSCO_REQUIRE(s.id() < 64, "Invalid solver id");
int16 sId = static_cast<int16>(s.id());
if (history_ && (step_ - lastStep) > 1) {
for (History::const_iterator it = history_->begin(), end = history_->end(); it != end; ++it) {
if (test_bit(it->second, sId)) { Change(it->first, AddWatch, sId).apply(s); }
}
}
ChangeList changesForSolver;
for (ChangeList::const_iterator it = changes_.begin(), end = changes_.end(); it != end; ++it) {
if (it->sId < 0 || it->sId == sId) { changesForSolver.push_back(*it); }
}
std::stable_sort(changesForSolver.begin(), changesForSolver.end());
for (ChangeList::const_iterator it = changesForSolver.begin(), end = changesForSolver.end(); it != end; ++it) {
Lit_t lit = it->lit;
// skip all but the last change for a given literal
while ((it + 1) != end && (it + 1)->lit == lit) { ++it; }
it->apply(s);
}
return step_;
}
void FieldContainer::subReferenceRecorded(void)
{
#ifndef OSG_FIELDCONTAINER_DEBUG_SILENT
FINFO(("FieldContainer::subReference [%p] [%d] [%s] START - [%d %d]\n",
this, this->getId(),
this->getType().getCName(),
this->_iRefCount,
this->_iWeakRefCount));
#endif
RefCountStore tmpRefCnt = osgAtomicExchangeAndAdd(&_iRefCount, -1);
ChangeList *pChangeList = Thread::getCurrentChangeList();
if(tmpRefCnt <= 1)
{
pChangeList->incSubRefLevel();
this->resolveLinks();
pChangeList->decSubRefLevel();
pChangeList->addSubRefd (Inherited::getId());
osgSpinLock(&_uiContainerId, SpinLockBit);
RefCountStore tmpWeakRefCnt = OSG_AREAD(_iWeakRefCount);
_uiContainerId |= DeadContainerBit;
osgSpinLockRelease(&_uiContainerId, SpinLockClearMask);
if(tmpWeakRefCnt <= 0)
{
#ifdef OSG_MT_CPTR_ASPECT
this->onDestroyAspect(Inherited::getId(),
Thread::getCurrentAspect());
if(_pAspectStore->getRefCount() == 1)
{
this->deregister(Inherited::getId());
this->onDestroy (Inherited::getId());
}
_pAspectStore->removePtrForAspect(Thread::getCurrentAspect());
OSG::subRef(_pAspectStore);
_pAspectStore = NULL;
#else
this->deregister (Inherited::getId() );
this->onDestroyAspect(Inherited::getId(), 0);
this->onDestroy (Inherited::getId() );
#endif
delete this;
}
else
{
#ifndef OSG_FIELDCONTAINER_DEBUG_SILENT
FINFO(
("FieldContainer::subReference [%p] [%d] [%s] STOP A [%d %d]\n",
this,
this->getId(),
this->getType().getCName(),
this->_iRefCount,
this->_iWeakRefCount));
#endif
}
}
else
{
#ifndef OSG_FIELDCONTAINER_DEBUG_SILENT
FINFO(
("FieldContainer::subReference [%p] [%d] [%s] STOP B [%d %d]\n",
this,
this->getId(),
this->getType().getCName(),
this->_iRefCount,
this->_iWeakRefCount));
#endif
pChangeList->addSubRefd(Inherited::getId());
}
}
void RemoteAspect::receiveSync(Connection &connection, bool applyToChangelist)
{
bool finish = false;
UInt8 cmd;
FieldContainerFactoryBase *fcFactory = FieldContainerFactory::the();
FieldContainerVector newContainers;
RemoteAspectFieldContainerMapper mapper;
ChangeList *pChangeList =
Thread::getCurrentChangeList();
if(_statistics)
{
_statistics->getElem(statSyncTime)->start();
}
connection.selectChannel();
connection.getValue(_remoteAspectId);
// register mapper into factory
mapper._remoteAspect = this;
fcFactory->setMapper(&mapper);
do
{
connection.getValue(cmd);
switch(cmd)
{
case SYNCENDED:
{
finish = true;
#ifndef OSG_REMOTE_ASPECT_SILENT
SLOG << "Receive SYNCENDED\n";
#endif
}
break;
case NEWTYPE:
{
receiveNewType(connection, fcFactory);
}
break;
case CREATED:
{
receiveCreated(connection, fcFactory, newContainers);
}
break;
case CHANGED:
{
receiveChanged(connection, fcFactory);
}
break;
case ADDREFED:
{
receiveAddRefed(connection, fcFactory, pChangeList);
}
break;
case SUBREFED:
{
receiveSubRefed(connection, fcFactory, pChangeList);
}
break;
case IDMAPPING:
{
receiveIdMapping(connection);
}
break;
default:
{
SFATAL << "Unknown tag:" << Int32(cmd) << std::endl;
throw RemoteSyncError();
}
}
}
while(!finish);
#ifndef OSG_REMOTE_ASPECT_SILENT
PLOG << std::flush;
#endif
pChangeList->commitDelayedSubRefs();
#ifdef OSG_DEBUG
FieldContainerVector::const_iterator fcIt = newContainers.begin();
FieldContainerVector::const_iterator fcEnd = newContainers.end ();
for(; fcIt != fcEnd; ++fcIt)
{
if((*fcIt)->getRefCount() <= 1)
{
SWARNING << "New container type '" << (*fcIt)->getType().getName()
<< "' local id '" << (*fcIt)->getId()
<< "' remote id '"
<< static_cast<UInt32>(_remoteFC[(*fcIt)->getId()])
<< "' dies because of missing ref counts."
<< std::endl;
}
}
#endif // OSG_DEBUG
if(applyToChangelist)
{
Thread::getCurrentChangeList()->commitChanges(ChangedOrigin::Sync);
}
else
{
Thread::getCurrentChangeList()->commitChangesAndClear(ChangedOrigin::Sync);
}
// unregister mapper into factory
fcFactory->setMapper(NULL);
if(_statistics)
{
_statistics->getElem(statSyncTime)->stop();
}
}
OSG_USING_NAMESPACE
/*! \class OSG::SortLastWindow
Cluster rendering configuration for sort first image composition
*/
/*----------------------------- static grouping functions -----------------*/
void SortLastWindow::buildGroups(void)
{
UInt32 v = 0;
DrawableListT drawables;
UInt32 groupCount = 0;
bool rebuild = false;
// check for new nodes.
FieldContainerFactoryBase *fcFactory = FieldContainerFactory::the();
FieldContainer *fcPtr = NULL;
ChangeList::ChangedStoreConstIt createdI;
ChangeList *changeList = OSG::Thread::getCurrentChangeList();
for(createdI = changeList->beginCreated();
createdI != changeList->endCreated();
createdI++)
{
UInt32 uiId = (*createdI)->uiContainerId;
fcPtr = fcFactory->getContainer(uiId);
if(fcPtr != NULL && dynamic_cast<Node *>(fcPtr) != NULL)
rebuild = true;
}
// is rebuild neccessary ?
if(!rebuild && getMFGroupNodes()->size())
return;
groupCount = getMFServers()->size32();
if(getComposer() != NULL)
{
groupCount = getComposer()->getUsableServers();
if(getComposer()->getClientRendering())
groupCount++;
}
// build groups for all viewports
clearGroupNodes();
editMFGroupLengths()->clear();
for(v = 0; v < getMFPort()->size(); ++v)
{
Viewport *vp = getPort(v);
Node *root = vp->getRoot();
drawables.clear();
collectDrawables(root, drawables);
if(drawables.size())
splitDrawables(drawables, groupCount, false);
}
}
void Game::unloadTalkTables(ChangeList &changes) {
for (std::list<Common::ChangeID>::iterator t = changes.begin(); t != changes.end(); ++t)
TalkMan.removeTable(*t);
changes.clear();
}
