ViewPtr<module::Module> Simulation::useModule(const String& nameSrc, String storePath)
{
String name = nameSrc;
// Find ':' in name - old definition
auto pos = nameSrc.find(':');
if (pos != String::npos)
{
name = nameSrc.substr(0, pos);
storePath = nameSrc.substr(pos + 1);
}
if (storePath.empty())
storePath = name;
// Module exists, return the existing one
if (hasModule(storePath))
return getModule(storePath);
Log::debug("Loading library: ", name);
// Load only library
Log::debug("Create module '", name, "'");
// Create module with given name
auto module = getPluginContext().createModule(name, *this);
// Register module
if (module)
{
if (storePath != name)
{
Log::info("Using module '", name, "' as '", storePath, "'");
}
else
{
Log::info("Using module '", name, "'");
}
return addModule(storePath, std::move(module));
}
Log::warning("Unable to create module '", name, "' (unsupported by library?)");
return nullptr;
}
bool Log::checkModule(const Char8 *module)
{
bool retCode = false;
std::list<Module>::iterator mI;
if(_moduleHandling != LOG_MODULE_NONE)
{
if(_moduleHandling == LOG_MODULE_ALL)
{
retCode = true;
}
else
{
if(module && *module)
{
if(hasModule(module))
{
if(_moduleHandling & LOG_MODULE_KNOWN)
retCode = true;
}
else
{
if(_moduleHandling & LOG_MODULE_UNKNOWN)
retCode = true;
}
}
else
{
if(_moduleHandling & LOG_MODULE_UNDEFINED)
retCode = true;
}
}
}
return retCode;
}
void Simulation::configure(const config::Configuration& config)
{
// Resize world
{
auto size = config.get<SizeVector>("world-size");
if (size.getWidth() == Zero || size.getHeight() == Zero)
throw config::Exception("Width or height is zero!");
setWorldSize(size);
}
// Time step
setTimeStep(config.get<units::Time>("dt"));
if (config.has("length-coefficient"))
{
m_converter.setLengthCoefficient(config.get<RealType>("length-coefficient"));
}
// Set gravity
setGravity(config.get("gravity", getGravity()));
// Number of iterations
setIterations(config.get("iterations", getIterations()));
// Background color
setBackgroundColor(config.get("background", getBackgroundColor()));
#if CONFIG_RENDER_TEXT_ENABLE
setFontColor(config.get("text-color", getBackgroundColor().inverted()));
#endif
#if CONFIG_RENDER_TEXT_ENABLE
setFontSize(config.get("text-size", getFontSize()));
#endif
#if CONFIG_RENDER_TEXT_ENABLE
setSimulationTimeRender(config.get("show-simulation-time", isSimulationTimeRender()));
#endif
#ifdef CECE_ENABLE_RENDER
setVisualized(config.get("visualized", isVisualized()));
#endif
// Parse plugins
for (auto&& pluginConfig : config.getConfigurations("plugin"))
{
// Returns valid pointer or throws an exception
requirePlugin(pluginConfig.get("name"))->configure(*this, pluginConfig);
}
// Parse parameters
for (auto&& parameterConfig : config.getConfigurations("parameter"))
{
setParameter(parameterConfig.get("name"), units::parse(parameterConfig.get("value")));
}
// Register user types
for (auto&& typeConfig : config.getConfigurations("type"))
{
addObjectType({
typeConfig.get("name"),
typeConfig.get("base"),
typeConfig.toMemory()
});
}
// Parse init
for (auto&& initConfig : config.getConfigurations("init"))
{
const String typeName = initConfig.has("language")
? initConfig.get("language")
: initConfig.get("type");
auto initializer = getPluginContext().createInitializer(typeName);
if (initializer)
{
// Configure initializer
initializer->loadConfig(*this, initConfig);
// Register initializer
addInitializer(std::move(initializer));
}
}
// Parse modules
for (auto&& moduleConfig : config.getConfigurations("module"))
{
// Get name
auto name = moduleConfig.get("name");
if (hasModule(name))
continue;
const String typeName = moduleConfig.has("language")
? moduleConfig.get("language")
: moduleConfig.has("type")
? moduleConfig.get("type")
: name
;
auto module = getPluginContext().createModule(typeName, *this);
if (module)
{
module->loadConfig(*this, moduleConfig);
addModule(std::move(name), std::move(module));
}
}
// Parse programs
for (auto&& programConfig : config.getConfigurations("program"))
{
const String typeName = programConfig.has("language")
? programConfig.get("language")
: programConfig.get("type");
auto program = getPluginContext().createProgram(typeName);
if (program)
{
// Configure program
program->loadConfig(*this, programConfig);
// Register program
addProgram(programConfig.get("name"), std::move(program));
}
}
// Parse objects
for (auto&& objectConfig : config.getConfigurations("object"))
{
// Create object
auto object = buildObject(
objectConfig.get("class"),
objectConfig.get("type", object::Object::Type::Dynamic)
);
if (object)
object->configure(objectConfig, *this);
}
if (config.has("data-out-objects-filename"))
{
m_dataOutObjects = makeUnique<OutFileStream>(config.get("data-out-objects-filename"));
*m_dataOutObjects << "iteration;totalTime;id;typeName;posX;posY;velX;velY\n";
}
}