void MemoryTest::update(IProgressMonitor* monitor) const {
for (int i = 0; i < getIterations() && (monitor ? !monitor->getAbortRequested() : true); ++i) {
#ifdef WIN32
_sleep(getDelay());
#else
sleep(getDelay());
#endif
if (monitor)
monitor->reportProgress(100.0 * (i + 1) / getIterations());
}
newState->setOutput(boost::make_shared<std::vector<double> >(getSize()));
}
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";
}
}
void Simulation::draw(render::Context& context)
{
context.setStencilBuffer(getWorldSize().getWidth().value(), getWorldSize().getHeight().value());
// Render modules
m_modules.draw(*this, context);
// Draw objects
for (auto& obj : m_objects)
{
Assert(obj);
if (obj->isVisible())
obj->draw(context);
}
#if defined(CECE_ENABLE_RENDER) && defined(CECE_ENABLE_BOX2D_PHYSICS) && defined(CECE_ENABLE_BOX2D_PHYSICS_DEBUG)
if (isDrawPhysics())
m_world.DrawDebugData();
#endif
#if CONFIG_RENDER_TEXT_ENABLE
context.disableStencilBuffer();
if (isSimulationTimeRender())
{
if (!m_font)
{
m_font.create(context, g_fontData);
m_font->setSize(getFontSize());
}
OutStringStream oss;
{
auto time = getTotalTime().value();
unsigned int seconds = time;
unsigned int milliseconds = static_cast<unsigned int>(time * 1000) % 1000;
const unsigned int hours = seconds / (60 * 60);
seconds %= (60 * 60);
const unsigned int minutes = seconds / 60;
seconds %= 60;
if (hours)
{
oss << std::setw(2) << std::setfill('0') << hours << ":";
oss << std::setw(2) << std::setfill('0') << minutes << ":";
}
else if (minutes)
{
oss << std::setw(2) << std::setfill('0') << minutes << ":";
}
oss << std::setw(2) << std::setfill('0') << seconds << ".";
oss << std::setw(3) << std::setfill('0') << milliseconds;
}
if (hasUnlimitedIterations())
{
oss << " (" << getIteration() << " / -)";
}
else
{
oss << " (" << getIteration() << " / " << getIterations() << ")";
}
m_font->draw(context, oss.str(), getFontColor());
}
#endif
}
bool Simulation::update(units::Duration dt)
{
// Initialize simulation
if (!isInitialized())
initialize();
// Increase step number
m_iteration++;
m_totalTime += dt;
// Clear all stored forces
for (auto& obj : m_objects)
obj->setForce(Zero);
// Update modules
updateModules(dt);
// Update objects
updateObjects(dt);
// Detect object that leaved the scene
detectDeserters();
// Delete unused objects
deleteObjects();
// Store data
if (m_dataOutObjects)
{
for (const auto& object : m_objects)
{
const auto pos = object->getPosition();
const auto vel = object->getVelocity();
*m_dataOutObjects <<
// iteration
getIteration() << ";" <<
// totalTime
getTotalTime() << ";" <<
// id
object->getId() << ";" <<
// typeName
object->getTypeName() << ";" <<
// posX
pos.getX() << ";" <<
// posY
pos.getY() << ";" <<
// velX
vel.getX() << ";" <<
// velY
vel.getY() << "\n"
;
}
}
#ifdef CECE_ENABLE_BOX2D_PHYSICS
{
auto _ = measure_time("sim.physics", TimeMeasurementIterationOutput(this));
m_world.Step(getPhysicsEngineTimeStep().value(), 10, 10);
}
#endif
return (hasUnlimitedIterations() || getIteration() <= getIterations());
}
