ページの比較

Atomsstd::AgentTypePtrstring agentTypecachePath = agent->agentType();
"/atomsDemo/cache/";
std::string agentType = agent->agentType().name();

Atoms::AgentTypePtr agentTypePtr = agent->agentType();
AtomsCore::Archive agentTypeArchive(agentTypeagentTypePtr->memSize());
agentTypeagentTypePtr->serialize(agentTypeArchive);
agentTypeArchive->writeToFile("myAgentTypecachePath + "/agentTypes/"  + agentType + ".agentType")

CACHED_AGENT_TYPE_SCRIPT = '''
import AtomsCore
import Atoms

class AgentTypeEvent$(Atoms.SimulationEvent):
\tagentTypeFile = r'agentTypeFile$'
\teventName = 'agentType$'
\tagentTypeName = 'agentTypeName$'
\tgeoPath = ''
\tskinPath = ''
\tstateMachine = ''

\tdef __init__(self):
\t\tAtoms.SimulationEvent.__init__(self)
\t\tself.setName(self.eventName)

\tdef load(self):
\t\taType = Atoms.AgentType()
\t\taTypeArchive = AtomsCore.Archive()
\t\tif aTypeArchive.readFromFile(self.agentTypeFile):
\t\t\taType.deserialise(aTypeArchive)
\t\telse:
\t\t\treturn

\t\tif self.geoPath:
\t\t\tmeshMap = AtomsCore.MapMetadata()
\t\t\ttypeArchive = AtomsCore.Archive()
\t\t\tif typeArchive.readFromFile(self.geoPath):
\t\t\t\tmeshMap.deserialise(typeArchive)
\t\t\t\taType.metadata()["lowGeo"] = meshMap

\t\tif self.skinPath:
\t\t\tskinMap = AtomsCore.MapMetadata()
\t\t\tskinArchive = AtomsCore.Archive()
\t\t\tif skinArchive.readFromFile(self.skinPath):
\t\t\t\tskinMap.deserialise(skinArchive)
\t\t\t\taType.metadata()["skinGeo"] = skinMap

\t\taType.metadata()["stateMachine"] = AtomsCore.StringMetadata(self.stateMachine)

\t\tAtoms.AgentTypes.instance().addAgentType(self.agentTypeName, aType)
'''

agentType = "atomsRobot"

# This serialize the agent type in python
aType = Atoms.AgentTypes.instance().agentType(agentType)
if aType:
  atArchive = AtomsCore.Archive(aType.memSize())
  aType.serialise(atArchive)
  atArchive.writeToFile(os.path.join(agentTypesPath, "%s.agentType" %
                                               (agentType)))

agentTypesPath = "/atomsDemo/cache/test_cache/agentTypes/"

agentTypeScript = CACHED_AGENT_TYPE_SCRIPT

af = os.path.normpath(os.path.join(agentTypesPath, "%s.agentType" %
                                               (agentType)))

agentTypeScript = agentTypeScript.replace("agentTypeFile$", af)
agentTypeScript = agentTypeScript.replace("agentType$","%sCached" %
                                                      agentType)
agentTypeScript = agentTypeScript.replace("agentTypeName$",
                                                      agentType)
agentTypeScript = agentTypeScript.replace("AgentTypeEvent$",
                                                      "%sCached" % (agentType))

with open(os.path.join(agentTypesPath, "%s.py" % (agentType)), "w") as pyFile:
	pyFile.write(agentTypeScript)
	pyFile.close()

" % (agentType))

with open(os.path.join(agentTypesPath, "%s.py" % (agentType)), "w") as pyFile:
	pyFile.write(agentTypeScript)
	pyFile.close()

#include <Atoms/AtomsCache

std::string cachePath = "/atomsDemo/cache/";
std::string cacheName = "cache_test";
int startFrame = 1;
int endFrame = 2;

// list of agents groups to export
std::vector<AtomsPtr<Atoms::AgentGroup>> agentGroups;

// if you are in maya or houdini you can get the agent groups from the agents simulation
auto sims = Atoms::AgentsSimulations::instance()
auto sim = sims.begin().second;
for(unsigned int i=0; i < sim.numAgentGroups(); i++)
{
	agentGroups.push_back(sim.agentGroup(i));
}

// This maps the agent global id with the cache id 
std::unordered_map<size_t, size_t> cacheIdMap;

std::set<std::string> agentTypes;

// Add compression and use multithread 
size_t tags = AtomsCore::Archive::kRandomAccessCompress | AtomsCore::Archive::kMultithread;


for (unsigned int frame = startFrame; frame < endFrame; frame++)
{
	AtomsCache::exportCacheFrame(cachePath, cacheName, frame, agentGroups, cacheIdMap, agentTypes, tags);
}

// save the agent types
Atoms::AgentTypes& agentTypes = Atoms::AgentTypes::instance();
for(const std::string agentType: agentTypes)
{
	auto agentTypePtr = agentTypes->agentType(agentType);
	if (!agentTypePtr)
		continue;
	AtomsCore::Archive agentTypeArchive(agentTypePtr->memSize());
	agentType->serialize(agentTypeArchive);
	std::string agentTypePath = cachePath  + "/agenTypes/" + agentType + ".agentType";
	agentTypeArchive->writeToFile(agentTypePath);

	//store the python event wrapper
	const std::string pythonEvent =	
	"import AtomsCore\n"
	"import Atoms\n"
	"import imath\n"
	"\n"
	"class "+ agentType +"Cached(Atoms.SimulationEvent):\n"
	"\tagentTypeFile = r'" + agentTypePath + "'\n"
	"\teventName = '" + agentType + "Cached'\n"
	"\tagentTypeName = '+ agentType + '\n"
	"\tgeoPath = ''\n"
	"\tskinPath = ''\n"
	"\tstateMachine = ''\n"
	"\n"
	"\tdef __init__(self):\n"
	"\t\tAtoms.SimulationEvent.__init__(self)\n"
	"\t\tself.setName(self.eventName)\n"
	"\n"
	"\tdef load(self):\n"
	"\t\taType = Atoms.AgentType()\n"
	"\t\taTypeArchive = AtomsCore.Archive()\n"
	"\t\tif aTypeArchive.readFromFile(self.agentTypeFile):\n"
	"\t\t\taType.deserialise(aTypeArchive)\n"
	"\t\telse:\n"
	"\t\t\treturn\n"
	"\n"
	"\t\tif self.geoPath:\n"
	"\t\t\tmeshMap = AtomsCore.MapMetadata()\n"
	"\t\t\ttypeArchive = AtomsCore.Archive()\n"
	"\t\t\tif typeArchive.readFromFile(self.geoPath):\n"
	"\t\t\t\tmeshMap.deserialise(typeArchive)\n"
	"\t\t\t\taType.metadata()["lowGeo"] = meshMap\n"
	"\n"
	"\t\tif self.skinPath:\n"
	"\t\t\tskinMap = AtomsCore.MapMetadata()\n"
	"\t\t\tskinArchive = AtomsCore.Archive()\n"
	"\t\t\tif skinArchive.readFromFile(self.skinPath):\n"
	"\t\t\t\tskinMap.deserialise(skinArchive)\n"
	"\t\t\t\taType.metadata()["skinGeo"] = skinMap\n"
	"\n"
	"\t\taType.metadata()["stateMachine"] = AtomsCore.StringMetadata(self.stateMachine)\n"
	"\n"
	"\t\tAtoms.AgentTypes.instance().addAgentType(self.agentTypeName, aType)\n";

	std::string agentTypeWrapperPath = cachePath  + "/agenTypes/" + agentType + ".py";
	std::ofstream out(agentTypeWrapperPath);
    out << pythonEvent;
    out.close();
}


// write the cache header
AtomsCore::IntArrayMetadata agentIdsMeta;
std::vector<int>& agentIdsVec = agentIdsMeta.get();
agentIdsVec.reserve(cacheIdMap.size());
for (auto it=cacheIdMap.begin(); it != cacheIdMap.end(); it++)
{
	agentIdsVec.pushBack(it->second);
}

std::sort(agentIdsVec.begin(), agentIdsVec.end());

AtomsCore::MapMetadata cacheHeader;
cacheHeader.addEntry("startFrame", &AtomsCore::IntMetadata(startFrame));
cacheHeader.addEntry("endFrame", &AtomsCore::IntMetadata(endFrame));
cacheHeader.addEntry("cacheType", &AtomsCore::StringMetadata("dynamic"));
cacheHeader.addEntry("agentIds", &agentIdsMeta);