void BillboardMarker::LoadResources(Ogre::SceneManager* ogreMgr)
{
if(!_loaded)
{
auto def = GetBillboardMarkerDefinition();
Ogre::BillboardSet* billSet= ogreMgr->createBillboardSet(def->GetPoolSize());
billSet->setMaterialName(def->GetMaterialName(), def->GetMaterialGroup());
billSet->setBillboardType((Ogre::BillboardType)def->GetBillboardType());
billSet->setCommonUpVector(def->GetCommonUpVector());
billSet->setCommonDirection(def->GetCommonDirection());
billSet->setBillboardsInWorldSpace(def->GetIsBillboardInWorldSpace());
billSet->setBillboardOrigin((Ogre::BillboardOrigin)def->GetBillboardOrigin());
billSet->setDefaultDimensions(def->GetDefaultBillboardSize().x,
def->GetDefaultBillboardSize().y);
billSet->setAutoextend(true);
billSet->setAutoUpdate(def->GetBillboardAutoUpdate());
billSet->setUseIdentityProjection(def->GetUseIdentityProjection());
billSet->setUseIdentityView(def->GetUseIdentityView());
billSet->Ogre::MovableObject::setUserAny(Ogre::Any(this));
billSet->setBillboardRotationType(Ogre::BBR_VERTEX);
_sceneObject = billSet;
SceneMarker::LoadResources(ogreMgr);
_loaded = true;
}
}
void cOptScenarioImitateEval::OutputPoseErr(const std::string& out_file) const
{
double tau_err = 0;
int total_count = 0;
for (int i = 0; i < GetPoolSize(); ++i)
{
double curr_err = 0;
int curr_count = 0;
auto imitate_scene = std::dynamic_pointer_cast<cScenarioImitateEval>(mEvalPool[i]);
imitate_scene->GetPoseErrResult(curr_err, curr_count);
tau_err = cMathUtil::AddAverage(tau_err, total_count, curr_err, curr_count);
total_count += curr_count;
}
if (total_count > 0)
{
std::string str = std::to_string(tau_err);
str += "\n";
bool succ = cFileUtil::AppendText(str, out_file);
if (!succ)
{
printf("Failed to output results to %s\n", out_file.c_str());
}
}
}
void RequestThreadsManager::DoAllocPool(ROAnything args)
{
StartTrace(RequestThreadsManager.DoAllocPool);
TraceAny(args, "args");
RequestProcessor *processor = SafeCast(args["processor"].AsIFAObject(0), RequestProcessor);
if (processor) {
fProcessor = processor;
} else {
const char *msg = "OOPS, couldn't find a RequestProcessor in args";
Trace(msg);
SYSERROR(msg);
}
fRequests = new HandleRequest[GetPoolSize()];
}
void cScenarioTrainHike::BuildScenePool()
{
cScenarioImitateTarget::BuildScenePool();
for (int i = 0; i < GetPoolSize(); ++i)
{
auto& curr_exp = mExpPool[i];
auto exp_hike = std::dynamic_pointer_cast<cScenarioExpHike>(curr_exp);
if (i == 0)
{
mLLCExpParams = exp_hike->GetLLCExpParams();
}
exp_hike->SetLLCExpParams(mLLCInitExpParams);
}
}
void cScenarioTrainHike::InitLLCLearners()
{
#if defined(HACK_SOCCER_LLC)
return;
#endif
int pool_size = GetPoolSize();
mLLCLearners.resize(pool_size);
for (int i = 0; i < pool_size; ++i)
{
auto& curr_learner = mLLCLearners[i];
mLLCTrainer->RequestLearner(curr_learner);
auto& exp_scene = GetExpScene(i);
const auto& character = exp_scene->GetCharacter();
SetupLLCLearner(character, curr_learner);
curr_learner->Init();
}
}
void cOptScenarioImitateEval::BuildScene(int id, std::shared_ptr<cScenarioPoliEval>& out_scene) const
{
auto eval_scene = std::shared_ptr<cScenarioImitateEval>(new cScenarioImitateEval());
int total_episodes = mMaxEpisodes;
int num_episodes = CalcHelperMaxEpisode(id);
int episode_offset = 0;
for (int i = 0; i < id; ++i)
{
episode_offset += CalcHelperMaxEpisode(i);
}
int pool_size = GetPoolSize();
double min_phase = static_cast<double>(episode_offset) / total_episodes;
double max_phase = static_cast<double>(episode_offset + num_episodes) / total_episodes;
eval_scene->SetResetPhaseSamples(num_episodes);
eval_scene->SetResetPhase(min_phase, max_phase);
out_scene = eval_scene;
}
