/* virtual */ void av::daemon::KinectTrack::startDevice()
{
if(!parseFeatures())
return;
// initialize
logger.info() << "startDevice: device initialized successfully";
std::cout << "KinectTrack::startDevice\n";
}
AgiEngine::AgiEngine(OSystem *syst, const AGIGameDescription *gameDesc) : AgiBase(syst, gameDesc) {
// Setup mixer
syncSoundSettings();
parseFeatures();
DebugMan.addDebugChannel(kDebugLevelMain, "Main", "Generic debug level");
DebugMan.addDebugChannel(kDebugLevelResources, "Resources", "Resources debugging");
DebugMan.addDebugChannel(kDebugLevelSprites, "Sprites", "Sprites debugging");
DebugMan.addDebugChannel(kDebugLevelInventory, "Inventory", "Inventory debugging");
DebugMan.addDebugChannel(kDebugLevelInput, "Input", "Input events debugging");
DebugMan.addDebugChannel(kDebugLevelMenu, "Menu", "Menu debugging");
DebugMan.addDebugChannel(kDebugLevelScripts, "Scripts", "Scripts debugging");
DebugMan.addDebugChannel(kDebugLevelSound, "Sound", "Sound debugging");
DebugMan.addDebugChannel(kDebugLevelText, "Text", "Text output debugging");
DebugMan.addDebugChannel(kDebugLevelSavegame, "Savegame", "Saving & restoring game debugging");
memset(&_game, 0, sizeof(struct AgiGame));
memset(&_debug, 0, sizeof(struct AgiDebug));
memset(&_mouse, 0, sizeof(struct Mouse));
_game._vm = this;
_game.clockEnabled = false;
_game.state = STATE_INIT;
_keyQueueStart = 0;
_keyQueueEnd = 0;
_allowSynthetic = false;
_intobj = NULL;
_menu = NULL;
_menuSelected = false;
_lastSentence[0] = 0;
memset(&_stringdata, 0, sizeof(struct StringData));
_objects = NULL;
_restartGame = false;
_oldMode = INPUT_NONE;
_firstSlot = 0;
resetControllers();
setupOpcodes();
_game._curLogic = NULL;
_timerHack = 0;
}
std::unique_ptr<Bucket> SymbolLayer::createBucket(StyleBucketParameters& parameters) const {
auto bucket = std::make_unique<SymbolBucket>(parameters.tileID.overscaling,
parameters.tileID.z);
bucket->layout = layout;
StyleCalculationParameters p(parameters.tileID.z);
bucket->layout.placement.calculate(p);
if (bucket->layout.placement.value == PlacementType::Line) {
bucket->layout.icon.rotationAlignment.value = RotationAlignmentType::Map;
bucket->layout.text.rotationAlignment.value = RotationAlignmentType::Map;
};
bucket->layout.spacing.calculate(p);
bucket->layout.avoidEdges.calculate(p);
bucket->layout.icon.allowOverlap.calculate(p);
bucket->layout.icon.ignorePlacement.calculate(p);
bucket->layout.icon.optional.calculate(p);
bucket->layout.icon.rotationAlignment.calculate(p);
bucket->layout.icon.image.calculate(p);
bucket->layout.icon.padding.calculate(p);
bucket->layout.icon.rotate.calculate(p);
bucket->layout.icon.keepUpright.calculate(p);
bucket->layout.icon.offset.calculate(p);
bucket->layout.text.rotationAlignment.calculate(p);
bucket->layout.text.field.calculate(p);
bucket->layout.text.font.calculate(p);
bucket->layout.text.maxWidth.calculate(p);
bucket->layout.text.lineHeight.calculate(p);
bucket->layout.text.letterSpacing.calculate(p);
bucket->layout.text.maxAngle.calculate(p);
bucket->layout.text.rotate.calculate(p);
bucket->layout.text.padding.calculate(p);
bucket->layout.text.ignorePlacement.calculate(p);
bucket->layout.text.optional.calculate(p);
bucket->layout.text.justify.calculate(p);
bucket->layout.text.anchor.calculate(p);
bucket->layout.text.keepUpright.calculate(p);
bucket->layout.text.transform.calculate(p);
bucket->layout.text.offset.calculate(p);
bucket->layout.text.allowOverlap.calculate(p);
bucket->layout.icon.size.calculate(StyleCalculationParameters(18));
bucket->layout.text.size.calculate(StyleCalculationParameters(18));
bucket->layout.iconMaxSize = bucket->layout.icon.size;
bucket->layout.textMaxSize = bucket->layout.text.size;
bucket->layout.icon.size.calculate(StyleCalculationParameters(p.z + 1));
bucket->layout.text.size.calculate(StyleCalculationParameters(p.z + 1));
bucket->parseFeatures(parameters.layer, filter);
if (bucket->needsDependencies(parameters.glyphStore, parameters.spriteStore)) {
parameters.partialParse = true;
}
// We do not add features if the parser is in a "partial" state because
// the layer ordering needs to be respected when calculating text
// collisions. Although, at this point, we requested all the resources
// needed by this tile.
if (!parameters.partialParse) {
bucket->addFeatures(parameters.tileUID,
*spriteAtlas,
parameters.glyphAtlas,
parameters.glyphStore,
parameters.collisionTile);
}
return std::move(bucket);
}
AgiEngine::AgiEngine(OSystem *syst, const AGIGameDescription *gameDesc) : AgiBase(syst, gameDesc) {
// Setup mixer
syncSoundSettings();
parseFeatures();
_rnd = new Common::RandomSource();
g_eventRec.registerRandomSource(*_rnd, "agi");
DebugMan.addDebugChannel(kDebugLevelMain, "Main", "Generic debug level");
DebugMan.addDebugChannel(kDebugLevelResources, "Resources", "Resources debugging");
DebugMan.addDebugChannel(kDebugLevelSprites, "Sprites", "Sprites debugging");
DebugMan.addDebugChannel(kDebugLevelInventory, "Inventory", "Inventory debugging");
DebugMan.addDebugChannel(kDebugLevelInput, "Input", "Input events debugging");
DebugMan.addDebugChannel(kDebugLevelMenu, "Menu", "Menu debugging");
DebugMan.addDebugChannel(kDebugLevelScripts, "Scripts", "Scripts debugging");
DebugMan.addDebugChannel(kDebugLevelSound, "Sound", "Sound debugging");
DebugMan.addDebugChannel(kDebugLevelText, "Text", "Text output debugging");
DebugMan.addDebugChannel(kDebugLevelSavegame, "Savegame", "Saving & restoring game debugging");
memset(&_game, 0, sizeof(struct AgiGame));
memset(&_debug, 0, sizeof(struct AgiDebug));
memset(&_mouse, 0, sizeof(struct Mouse));
_game.clockEnabled = false;
_game.state = STATE_INIT;
_keyQueueStart = 0;
_keyQueueEnd = 0;
_allowSynthetic = false;
_tickTimer = 0;
_lastTickTimer = 0;
_intobj = NULL;
_menu = NULL;
_menuSelected = false;
_lastSentence[0] = 0;
memset(&_stringdata, 0, sizeof(struct StringData));
_objects = NULL;
_restartGame = false;
_oldMode = INPUT_NONE;
_predictiveDialogRunning = false;
_predictiveDictText = NULL;
_predictiveDictLine = NULL;
_predictiveDictLineCount = 0;
_firstSlot = 0;
// NOTE: On game reload the keys do not get set again,
// thus it is incorrect to reset it in agiInit(). Fixes bug #2823762
_game.lastController = 0;
for (int i = 0; i < MAX_DIRS; i++)
_game.controllerOccured[i] = false;
setupOpcodes();
_curLogic = NULL;
_timerHack = 0;
}
void QmlProfilerApplication::parseArguments()
{
setApplicationName(QLatin1String("qmlprofiler"));
setApplicationVersion(QLatin1String(qVersion()));
QCommandLineParser parser;
parser.setSingleDashWordOptionMode(QCommandLineParser::ParseAsLongOptions);
parser.setOptionsAfterPositionalArgumentsMode(QCommandLineParser::ParseAsPositionalArguments);
parser.setApplicationDescription(QChar::LineFeed + tr(
"The QML Profiler retrieves QML tracing data from an application. The data\n"
"collected can then be visualized in Qt Creator. The application to be profiled\n"
"has to enable QML debugging. See the Qt Creator documentation on how to do\n"
"this for different Qt versions."));
QCommandLineOption attach(QStringList() << QLatin1String("a") << QLatin1String("attach"),
tr("Attach to an application already running on <hostname>, "
"instead of starting it locally."),
QLatin1String("hostname"));
parser.addOption(attach);
QCommandLineOption port(QStringList() << QLatin1String("p") << QLatin1String("port"),
tr("Connect to the TCP port <port>. The default is 3768."),
QLatin1String("port"), QLatin1String("3768"));
parser.addOption(port);
QCommandLineOption output(QStringList() << QLatin1String("o") << QLatin1String("output"),
tr("Save tracing data in <file>. By default the data is sent to the "
"standard output."), QLatin1String("file"), QString());
parser.addOption(output);
QCommandLineOption record(QLatin1String("record"),
tr("If set to 'off', don't immediately start recording data when the "
"QML engine starts, but instead either start the recording "
"interactively or with the JavaScript console.profile() function. "
"By default the recording starts immediately."),
QLatin1String("on|off"), QLatin1String("on"));
parser.addOption(record);
QStringList featureList;
for (int i = 0; i < QQmlProfilerDefinitions::MaximumProfileFeature; ++i)
featureList << QLatin1String(features[i]);
QCommandLineOption include(QLatin1String("include"),
tr("Comma-separated list of features to record. By default all "
"features supported by the QML engine are recorded. If --include "
"is specified, only the given features will be recorded. "
"The following features are unserstood by qmlprofiler: %1").arg(
featureList.join(", ")),
QLatin1String("feature,..."));
parser.addOption(include);
QCommandLineOption exclude(QLatin1String("exclude"),
tr("Comma-separated list of features to exclude when recording. By "
"default all features supported by the QML engine are recorded. "
"See --include for the features understood by qmlprofiler."),
QLatin1String("feature,..."));
parser.addOption(exclude);
QCommandLineOption interactive(QLatin1String("interactive"),
tr("Manually control the recording from the command line. The "
"profiler will not terminate itself when the application "
"does so in this case.") + QChar::Space + tr(commandTextC));
parser.addOption(interactive);
QCommandLineOption verbose(QStringList() << QLatin1String("verbose"),
tr("Print debugging output."));
parser.addOption(verbose);
parser.addHelpOption();
parser.addVersionOption();
parser.addPositionalArgument(QLatin1String("program"),
tr("The program to be started and profiled."),
QLatin1String("[program]"));
parser.addPositionalArgument(QLatin1String("parameters"),
tr("Parameters for the program to be started."),
QLatin1String("[parameters...]"));
parser.process(*this);
if (parser.isSet(attach)) {
m_hostName = parser.value(attach);
m_runMode = AttachMode;
}
if (parser.isSet(port)) {
bool isNumber;
m_port = parser.value(port).toUShort(&isNumber);
if (!isNumber) {
logError(tr("'%1' is not a valid port.").arg(parser.value(port)));
parser.showHelp(1);
}
}
m_outputFile = parser.value(output);
m_recording = (parser.value(record) == QLatin1String("on"));
m_interactive = parser.isSet(interactive);
quint64 features = std::numeric_limits<quint64>::max();
if (parser.isSet(include)) {
if (parser.isSet(exclude)) {
logError(tr("qmlprofiler can only process either --include or --exclude, not both."));
parser.showHelp(4);
}
features = parseFeatures(featureList, parser.value(include), false);
}
if (parser.isSet(exclude))
features = parseFeatures(featureList, parser.value(exclude), true);
if (features == 0)
parser.showHelp(4);
m_qmlProfilerClient.setFeatures(features);
if (parser.isSet(verbose))
m_verbose = true;
m_programArguments = parser.positionalArguments();
if (!m_programArguments.isEmpty())
m_programPath = m_programArguments.takeFirst();
if (m_runMode == LaunchMode && m_programPath.isEmpty()) {
logError(tr("You have to specify either --attach or a program to start."));
parser.showHelp(2);
}
if (m_runMode == AttachMode && !m_programPath.isEmpty()) {
logError(tr("--attach cannot be used when starting a program."));
parser.showHelp(3);
}
}
