osb/source/game/StarNetworkedAnimator.cpp
2024-03-20 01:53:34 +11:00

1082 lines
42 KiB
C++

#include "StarNetworkedAnimator.hpp"
#include "StarJsonExtra.hpp"
#include "StarIterator.hpp"
#include "StarParticleDatabase.hpp"
#include "StarRoot.hpp"
#include "StarAssets.hpp"
#include "StarLexicalCast.hpp"
#include "StarDataStreamExtra.hpp"
#include "StarRandom.hpp"
#include "StarGameTypes.hpp"
namespace Star {
NetworkedAnimator::DynamicTarget::~DynamicTarget() {
stopAudio();
}
List<AudioInstancePtr> NetworkedAnimator::DynamicTarget::pullNewAudios() {
pendingAudios.exec([this](AudioInstancePtr const& ptr) {
Vec2F audioBasePosition = ptr->position().value();
currentAudioBasePositions[ptr] = audioBasePosition;
ptr->setPosition(position + audioBasePosition);
});
return take(pendingAudios);
}
List<Particle> NetworkedAnimator::DynamicTarget::pullNewParticles() {
pendingParticles.exec([this](Particle& particle) {
particle.position += position;
return particle;
});
return take(pendingParticles);
}
void NetworkedAnimator::DynamicTarget::stopAudio() {
for (auto const& pair : currentAudioBasePositions) {
if (pair.first->loops() != 0)
pair.first->stop();
}
}
void NetworkedAnimator::DynamicTarget::updatePosition(Vec2F const& p) {
clearFinishedAudio();
position = p;
for (auto& audioPair : currentAudioBasePositions)
audioPair.first->setPosition(audioPair.second + p);
}
void NetworkedAnimator::DynamicTarget::clearFinishedAudio() {
for (auto& p : statePersistentSounds) {
if (p.second.audio && p.second.audio->finished())
p.second.audio.reset();
}
for (auto& p : stateImmediateSounds) {
if (p.second.audio && p.second.audio->finished())
p.second.audio.reset();
}
for (auto& p : independentSounds)
eraseWhere(p.second, [](AudioInstancePtr const& audio) { return audio->finished(); });
eraseWhere(currentAudioBasePositions, [](pair<AudioInstancePtr, Vec2F> const& pair) {
return pair.first->finished();
});
}
NetworkedAnimator::NetworkedAnimator() {
m_zoom.set(1.0f);
m_flipped.set(false);
m_flippedRelativeCenterLine.set(0.0f);
m_animationRate.set(1.0f);
setupNetStates();
}
NetworkedAnimator::NetworkedAnimator(Json config, String relativePath) : NetworkedAnimator() {
auto& root = Root::singleton();
if (config.isNull())
return;
if (config.type() == Json::Type::String) {
if (relativePath.empty())
relativePath = config.toString();
config = root.assets()->json(AssetPath::relativeTo(relativePath, config.toString()));
} else {
if (relativePath.empty())
relativePath = "/";
}
m_animatedParts = AnimatedPartSet(config.get("animatedParts", JsonObject()));
m_relativePath = AssetPath::directory(relativePath);
for (auto const& pair : config.get("globalTagDefaults", JsonObject()).iterateObject())
setGlobalTag(pair.first, pair.second.toString());
for (auto const& part : config.get("partTagDefaults", JsonObject()).iterateObject()) {
for (auto const& tag : part.second.iterateObject())
setPartTag(part.first, tag.first, tag.second.toString());
}
for (auto const& pair : config.get("transformationGroups", JsonObject()).iterateObject()) {
auto& tg = m_transformationGroups[pair.first];
tg.interpolated = pair.second.getBool("interpolated", false);
tg.setAffineTransform(Mat3F::identity());
}
for (auto const& pair : config.get("rotationGroups", JsonObject()).iterateObject()) {
String rotationGroupName = pair.first;
Json rotationGroupConfig = pair.second;
RotationGroup& rotationGroup = m_rotationGroups[std::move(rotationGroupName)];
rotationGroup.angularVelocity = rotationGroupConfig.getFloat("angularVelocity", 0.0f);
rotationGroup.rotationCenter = jsonToVec2F(rotationGroupConfig.get("rotationCenter", JsonArray{0, 0}));
}
for (auto const& pair : config.get("particleEmitters", JsonObject()).iterateObject()) {
String particleEmitterName = pair.first;
Json particleEmitterConfig = pair.second;
ParticleEmitter& emitter = m_particleEmitters[std::move(particleEmitterName)];
emitter.emissionRate.set(particleEmitterConfig.getFloat("emissionRate", 1.0f));
emitter.emissionRateVariance = particleEmitterConfig.getFloat("emissionRateVariance", 0.0f);
emitter.offsetRegion.set(particleEmitterConfig.opt("offsetRegion").apply(jsonToRectF).value(RectF::null()));
emitter.anchorPart = particleEmitterConfig.optString("anchorPart");
emitter.transformationGroups = jsonToStringList(particleEmitterConfig.get("transformationGroups", JsonArray()));
emitter.rotationGroup = particleEmitterConfig.optString("rotationGroup");
emitter.rotationCenter = particleEmitterConfig.opt("rotationCenter").apply(jsonToVec2F);
for (auto const& config : particleEmitterConfig.get("particles").iterateArray()) {
auto creator = root.particleDatabase()->particleCreator(config.get("particle"), relativePath);
unsigned count = config.getUInt("count", 1);
Vec2F offset = jsonToVec2F(config.get("offset", JsonArray{0, 0}));
bool flip = config.getBool("flip", false);
emitter.particleList.append({creator, count, offset, flip});
}
// default to one cycle through the particle list in a burst
emitter.burstCount.set(particleEmitterConfig.getUInt("burstCount", 1));
// default to one of each to preserve current behaviour.
emitter.randomSelectCount.set(particleEmitterConfig.getUInt("randomSelectCount", emitter.particleList.size()));
emitter.active.set(particleEmitterConfig.getBool("active", false));
}
for (auto const& pair : config.get("lights", JsonObject()).iterateObject()) {
String lightName = pair.first;
Json lightConfig = pair.second;
Light& light = m_lights[std::move(lightName)];
light.active.set(lightConfig.getBool("active", true));
auto lightPosition = lightConfig.opt("position").apply(jsonToVec2F).value();
light.xPosition.set(lightPosition[0]);
light.yPosition.set(lightPosition[1]);
light.color.set(lightConfig.opt("color").apply(jsonToColor).value(Color::White));
light.anchorPart = lightConfig.optString("anchorPart");
light.transformationGroups = jsonToStringList(lightConfig.get("transformationGroups", JsonArray()));
light.rotationGroup = lightConfig.optString("rotationGroup");
light.rotationCenter = lightConfig.opt("rotationCenter").apply(jsonToVec2F);
if (lightConfig.contains("flickerPeriod")) {
light.flicker = PeriodicFunction<float>(
lightConfig.getFloat("flickerPeriod"),
lightConfig.getFloat("flickerMinIntensity", 0.0),
lightConfig.getFloat("flickerMaxIntensity", 0.0),
lightConfig.getFloat("flickerPeriodVariance", 0.0),
lightConfig.getFloat("flickerIntensityVariance", 0.0)
);
}
light.pointAngle.set(lightConfig.getFloat("pointAngle", 0.0f) * Constants::deg2rad);
light.pointLight = lightConfig.getBool("pointLight", false);
light.pointBeam = lightConfig.getFloat("pointBeam", 0.0f);
light.beamAmbience = lightConfig.getFloat("beamAmbience", 0.0f);
}
for (auto const& pair : config.get("sounds", JsonObject()).iterateObject()) {
String soundName = pair.first;
Json soundConfig = pair.second;
Sound& sound = m_sounds[std::move(soundName)];
if (soundConfig.isType(Json::Type::Array)) {
sound.rangeMultiplier = 1.0f;
sound.soundPool.set(jsonToStringList(soundConfig).transformed(bind(&AssetPath::relativeTo, m_relativePath, _1)));
sound.volumeTarget.set(1.0f);
sound.volumeRampTime.set(0.0f);
sound.pitchMultiplierTarget.set(1.0f);
sound.pitchMultiplierRampTime.set(0.0f);
} else {
sound.rangeMultiplier = soundConfig.getFloat("rangeMultiplier", 1.0f);
auto soundPosition = soundConfig.opt("position").apply(jsonToVec2F).value();
sound.xPosition.set(soundPosition[0]);
sound.yPosition.set(soundPosition[1]);
sound.volumeTarget.set(soundConfig.getFloat("volume", 1.0f));
sound.volumeRampTime.set(soundConfig.getFloat("volumeRampTime", 0.0f));
sound.pitchMultiplierTarget.set(soundConfig.getFloat("pitchMultiplier", 1.0f));
sound.pitchMultiplierRampTime.set(soundConfig.getFloat("pitchMultiplierRampTime", 0.0f));
sound.soundPool.set(jsonToStringList(soundConfig.get("pool", JsonArray())).transformed(bind(&AssetPath::relativeTo, m_relativePath, _1)));
}
}
for (auto const& pair : config.get("effects", JsonObject()).iterateObject()) {
String effectName = pair.first;
Json effectConfig = pair.second;
Effect& effect = m_effects[effectName];
effect.type = effectConfig.getString("type");
effect.time = effectConfig.getFloat("time", 0.0f);
effect.directives = effectConfig.getString("directives");
}
// Sort all the states that contain NetStates handles predictably by key.
m_transformationGroups.sortByKey();
m_rotationGroups.sortByKey();
m_particleEmitters.sortByKey();
m_lights.sortByKey();
m_sounds.sortByKey();
m_effects.sortByKey();
// Make sure that every state type has an entry in the state info map, and
// order it predictably by key.
for (auto const& stateType : m_animatedParts.stateTypes())
m_stateInfo[stateType];
m_stateInfo.sortByKey();
setupNetStates();
}
NetworkedAnimator::NetworkedAnimator(NetworkedAnimator&& animator) {
operator=(std::move(animator));
}
NetworkedAnimator::NetworkedAnimator(NetworkedAnimator const& animator) {
operator=(animator);
}
NetworkedAnimator& NetworkedAnimator::operator=(NetworkedAnimator&& animator) {
m_relativePath = std::move(animator.m_relativePath);
m_animatedParts = std::move(animator.m_animatedParts);
m_stateInfo = std::move(animator.m_stateInfo);
m_transformationGroups = std::move(animator.m_transformationGroups);
m_rotationGroups = std::move(animator.m_rotationGroups);
m_particleEmitters = std::move(animator.m_particleEmitters);
m_lights = std::move(animator.m_lights);
m_sounds = std::move(animator.m_sounds);
m_effects = std::move(animator.m_effects);
m_processingDirectives = std::move(animator.m_processingDirectives);
m_zoom = std::move(animator.m_zoom);
m_flipped = std::move(animator.m_flipped);
m_flippedRelativeCenterLine = std::move(animator.m_flippedRelativeCenterLine);
m_animationRate = std::move(animator.m_animationRate);
m_globalTags = std::move(animator.m_globalTags);
m_partTags = std::move(animator.m_partTags);
m_cachedPartDrawables = std::move(animator.m_cachedPartDrawables);
setupNetStates();
return *this;
}
NetworkedAnimator& NetworkedAnimator::operator=(NetworkedAnimator const& animator) {
m_relativePath = animator.m_relativePath;
m_animatedParts = animator.m_animatedParts;
m_stateInfo = animator.m_stateInfo;
m_transformationGroups = animator.m_transformationGroups;
m_rotationGroups = animator.m_rotationGroups;
m_particleEmitters = animator.m_particleEmitters;
m_lights = animator.m_lights;
m_sounds = animator.m_sounds;
m_effects = animator.m_effects;
m_processingDirectives = animator.m_processingDirectives;
m_zoom = animator.m_zoom;
m_flipped = animator.m_flipped;
m_flippedRelativeCenterLine = animator.m_flippedRelativeCenterLine;
m_animationRate = animator.m_animationRate;
m_globalTags = animator.m_globalTags;
m_partTags = animator.m_partTags;
m_cachedPartDrawables = animator.m_cachedPartDrawables;
setupNetStates();
return *this;
}
StringList NetworkedAnimator::stateTypes() const {
return m_animatedParts.stateTypes();
}
StringList NetworkedAnimator::states(String const& stateType) const {
return m_animatedParts.states(stateType);
}
bool NetworkedAnimator::setState(String const& stateType, String const& state, bool startNew) {
if (m_animatedParts.setActiveState(stateType, state, startNew)) {
m_stateInfo[stateType].startedEvent.trigger();
return true;
} else {
return false;
}
}
String NetworkedAnimator::state(String const& stateType) const {
return m_animatedParts.activeState(stateType).stateName;
}
StringList NetworkedAnimator::parts() const {
return m_animatedParts.parts();
}
Json NetworkedAnimator::stateProperty(String const& stateType, String const& propertyName) const {
return m_animatedParts.activeState(stateType).properties.value(propertyName);
}
Json NetworkedAnimator::partProperty(String const& partName, String const& propertyName) const {
return m_animatedParts.activePart(partName).properties.value(propertyName);
}
Mat3F NetworkedAnimator::globalTransformation() const {
Mat3F transformation = Mat3F::scaling(m_zoom.get());
if (m_flipped.get())
transformation = Mat3F::scaling(Vec2F(-1, 1), Vec2F(m_flippedRelativeCenterLine.get(), 0)) * transformation;
return transformation;
}
Mat3F NetworkedAnimator::groupTransformation(StringList const& transformationGroups) const {
auto mat = Mat3F::identity();
for (auto const& tg : transformationGroups)
mat = m_transformationGroups.get(tg).affineTransform() * mat;
return mat;
}
Mat3F NetworkedAnimator::partTransformation(String const& partName) const {
auto const& part = m_animatedParts.activePart(partName);
Mat3F transformation = Mat3F::identity();
if (auto offset = part.properties.value("offset").opt().apply(jsonToVec2F))
transformation = Mat3F::translation(*offset) * transformation;
auto transformationGroups = jsonToStringList(part.properties.value("transformationGroups", JsonArray()));
transformation = groupTransformation(transformationGroups) * transformation;
if (auto rotationGroupName = part.properties.value("rotationGroup").optString()) {
auto const& rotationGroup = m_rotationGroups.get(*rotationGroupName);
Vec2F rotationCenter = part.properties.value("rotationCenter").opt().apply(jsonToVec2F).value(rotationGroup.rotationCenter);
transformation = Mat3F::rotation(rotationGroup.currentAngle, rotationCenter) * transformation;
}
if (auto anchorPart = part.properties.ptr("anchorPart"))
transformation = partTransformation(anchorPart->toString()) * transformation;
return transformation;
}
Mat3F NetworkedAnimator::finalPartTransformation(String const& partName) const {
return globalTransformation() * partTransformation(partName);
}
Maybe<Vec2F> NetworkedAnimator::partPoint(String const& partName, String const& propertyName) const {
auto const& part = m_animatedParts.activePart(partName);
auto property = part.properties.value(propertyName);
if (!property)
return {};
return finalPartTransformation(partName).transformVec2(jsonToVec2F(property));
}
Maybe<PolyF> NetworkedAnimator::partPoly(String const& partName, String const& propertyName) const {
auto const& part = m_animatedParts.activePart(partName);
auto property = part.properties.value(propertyName, {});
if (!property)
return {};
PolyF poly = jsonToPolyF(property);
poly.transform(finalPartTransformation(partName));
return poly;
}
void NetworkedAnimator::setGlobalTag(String tagName, String tagValue) {
m_globalTags.set(std::move(tagName), std::move(tagValue));
}
void NetworkedAnimator::removeGlobalTag(String const& tagName) {
m_globalTags.remove(tagName);
}
String const* NetworkedAnimator::globalTagPtr(String const& tagName) const {
return m_globalTags.ptr(tagName);
}
void NetworkedAnimator::setPartTag(String const& partType, String tagName, String tagValue) {
m_partTags[partType].set(std::move(tagName), std::move(tagValue));
}
void NetworkedAnimator::setProcessingDirectives(Directives const& directives) {
m_processingDirectives.set(directives);
}
void NetworkedAnimator::setZoom(float zoom) {
m_zoom.set(zoom);
}
bool NetworkedAnimator::flipped() const {
return m_flipped.get();
}
float NetworkedAnimator::flippedRelativeCenterLine() const {
return m_flippedRelativeCenterLine.get();
}
void NetworkedAnimator::setFlipped(bool flipped, float relativeCenterLine) {
m_flipped.set(flipped);
m_flippedRelativeCenterLine.set(relativeCenterLine);
}
void NetworkedAnimator::setAnimationRate(float rate) {
m_animationRate.set(rate);
}
bool NetworkedAnimator::hasRotationGroup(String const& rotationGroup) const {
return m_rotationGroups.contains(rotationGroup);
}
void NetworkedAnimator::rotateGroup(String const& rotationGroup, float targetAngle, bool immediate) {
auto& group = m_rotationGroups.get(rotationGroup);
group.targetAngle.set(targetAngle);
if (immediate) {
group.currentAngle = targetAngle;
group.netImmediateEvent.trigger();
}
}
float NetworkedAnimator::currentRotationAngle(String const& rotationGroup) const {
return m_rotationGroups.get(rotationGroup).currentAngle;
}
bool NetworkedAnimator::hasTransformationGroup(String const& transformationGroup) const {
return m_transformationGroups.contains(transformationGroup);
}
void NetworkedAnimator::translateTransformationGroup(String const& transformationGroup, Vec2F const& translation) {
auto& group = m_transformationGroups.get(transformationGroup);
group.setAffineTransform(Mat3F::translation(translation) * group.affineTransform());
}
void NetworkedAnimator::rotateTransformationGroup(
String const& transformationGroup, float rotation, Vec2F const& rotationCenter) {
auto& group = m_transformationGroups.get(transformationGroup);
group.setAffineTransform(Mat3F::rotation(rotation, rotationCenter) * group.affineTransform());
}
void NetworkedAnimator::scaleTransformationGroup(
String const& transformationGroup, float scale, Vec2F const& scaleCenter) {
auto& group = m_transformationGroups.get(transformationGroup);
group.setAffineTransform(Mat3F::scaling(scale, scaleCenter) * group.affineTransform());
}
void NetworkedAnimator::scaleTransformationGroup(
String const& transformationGroup, Vec2F const& scale, Vec2F const& scaleCenter) {
auto& group = m_transformationGroups.get(transformationGroup);
group.setAffineTransform(Mat3F::scaling(scale, scaleCenter) * group.affineTransform());
}
void NetworkedAnimator::transformTransformationGroup(
String const& transformationGroup, float a, float b, float c, float d, float tx, float ty) {
auto& group = m_transformationGroups.get(transformationGroup);
Mat3F transform = Mat3F(a, b, tx, c, d, ty, 0, 0, 1);
group.setAffineTransform(transform * group.affineTransform());
}
void NetworkedAnimator::resetTransformationGroup(String const& transformationGroup) {
m_transformationGroups.get(transformationGroup).setAffineTransform(Mat3F::identity());
}
bool NetworkedAnimator::hasParticleEmitter(String const& emitterName) const {
return m_particleEmitters.contains(emitterName);
}
void NetworkedAnimator::setParticleEmitterActive(String const& emitterName, bool active) {
m_particleEmitters.get(emitterName).active.set(active);
}
void NetworkedAnimator::setParticleEmitterEmissionRate(String const& emitterName, float emissionRate) {
m_particleEmitters.get(emitterName).emissionRate.set(emissionRate);
}
void NetworkedAnimator::setParticleEmitterOffsetRegion(String const& emitterName, RectF const& offsetRegion) {
m_particleEmitters.get(emitterName).offsetRegion.set(offsetRegion);
}
void NetworkedAnimator::setParticleEmitterBurstCount(String const& emitterName, unsigned burstCount) {
m_particleEmitters.get(emitterName).burstCount.set(burstCount);
}
void NetworkedAnimator::burstParticleEmitter(String const& emitterName) {
m_particleEmitters.get(emitterName).burstEvent.trigger();
}
bool NetworkedAnimator::hasLight(String const& lightName) const {
return m_lights.contains(lightName);
}
void NetworkedAnimator::setLightActive(String const& lightName, bool active) {
m_lights.get(lightName).active.set(active);
}
void NetworkedAnimator::setLightPosition(String const& lightName, Vec2F position) {
auto& light = m_lights.get(lightName);
light.xPosition.set(position[0]);
light.yPosition.set(position[1]);
}
void NetworkedAnimator::setLightColor(String const& lightName, Color color) {
m_lights.get(lightName).color.set(color);
}
void NetworkedAnimator::setLightPointAngle(String const& lightName, float angle) {
m_lights.get(lightName).pointAngle.set(angle * Constants::deg2rad);
}
bool NetworkedAnimator::hasSound(String const& soundName) const {
return m_sounds.contains(soundName);
}
void NetworkedAnimator::setSoundPool(String const& soundName, StringList soundPool) {
m_sounds.get(soundName).soundPool.set(std::move(soundPool));
}
void NetworkedAnimator::setSoundPosition(String const& soundName, Vec2F const& position) {
auto& sound = m_sounds.get(soundName);
sound.xPosition.set(position[0]);
sound.yPosition.set(position[1]);
}
void NetworkedAnimator::setSoundVolume(String const& soundName, float volume, float rampTime) {
auto& sound = m_sounds.get(soundName);
sound.volumeTarget.set(volume);
sound.volumeRampTime.set(rampTime);
}
void NetworkedAnimator::setSoundPitchMultiplier(String const& soundName, float pitchMultiplier, float rampTime) {
auto& sound = m_sounds.get(soundName);
sound.pitchMultiplierTarget.set(pitchMultiplier);
sound.pitchMultiplierRampTime.set(rampTime);
}
void NetworkedAnimator::playSound(String const& soundName, int loops) {
auto& sound = m_sounds.get(soundName);
sound.loops.set(loops);
sound.signals.send(SoundSignal::Play);
}
void NetworkedAnimator::stopAllSounds(String const& soundName, float rampTime) {
auto& sound = m_sounds.get(soundName);
sound.volumeRampTime.set(rampTime);
sound.signals.send(SoundSignal::StopAll);
}
void NetworkedAnimator::setEffectEnabled(String const& effect, bool enabled) {
m_effects.get(effect).enabled.set(enabled);
}
List<Drawable> NetworkedAnimator::drawables(Vec2F const& position) const {
List<Drawable> drawables;
for (auto& p : drawablesWithZLevel(position))
drawables.append(std::move(p.first));
return drawables;
}
List<pair<Drawable, float>> NetworkedAnimator::drawablesWithZLevel(Vec2F const& position) const {
List<Directives> baseProcessingDirectives = { m_processingDirectives.get() };
for (auto& pair : m_effects) {
auto const& effectState = pair.second;
if (effectState.enabled.get()) {
auto const& effect = m_effects.get(pair.first);
if (effect.type == "flash") {
if (effectState.timer > effect.time / 2) {
baseProcessingDirectives.append(effect.directives);
}
} else if (effect.type == "directive") {
baseProcessingDirectives.append(effect.directives);
} else {
throw NetworkedAnimatorException(strf("No such NetworkedAnimator effect type '{}'", effect.type));
}
}
}
List<pair<Drawable, float>> drawables;
m_animatedParts.forEachActivePart([&](String const& partName, AnimatedPartSet::ActivePartInformation const& activePart) {
// Make sure we don't copy the original image
String fallback = "";
Json jImage = activePart.properties.value("image", {});
String const& image = jImage.isType(Json::Type::String) ? *jImage.stringPtr() : fallback;
bool centered = activePart.properties.value("centered").optBool().value(true);
bool fullbright = activePart.properties.value("fullbright").optBool().value(false);
auto maybeZLevel = activePart.properties.value("zLevel").optFloat();
if (m_flipped.get())
maybeZLevel = activePart.properties.value("flippedZLevel").optFloat().orMaybe(maybeZLevel);
float zLevel = maybeZLevel.value(0.0f);
size_t originalDirectivesSize = baseProcessingDirectives.size();
if (auto directives = activePart.properties.value("processingDirectives").optString()) {
baseProcessingDirectives.append(*directives);
}
Maybe<unsigned> frame;
String frameStr;
String frameIndexStr;
if (activePart.activeState) {
unsigned stateFrame = activePart.activeState->frame;
frame = stateFrame;
frameStr = static_cast<String>(toString(stateFrame + 1));
frameIndexStr = static_cast<String>(toString(stateFrame));
if (auto directives = activePart.activeState->properties.value("processingDirectives").optString()) {
baseProcessingDirectives.append(*directives);
}
}
auto const& partTags = m_partTags.get(partName);
Maybe<String> processedImage = image.maybeLookupTagsView([&](StringView tag) -> StringView {
if (tag == "frame") {
if (frame)
return frameStr;
} else if (tag == "frameIndex") {
if (frame)
return frameIndexStr;
} else if (auto p = partTags.ptr(tag)) {
return StringView(*p);
} else if (auto p = m_globalTags.ptr(tag)) {
return StringView(*p);
}
return StringView("default");
});
String const& usedImage = processedImage ? processedImage.get() : image;
if (!usedImage.empty() && usedImage[0] != ':' && usedImage[0] != '?') {
size_t hash = hashOf(usedImage);
auto find = m_cachedPartDrawables.find(partName);
bool fail = find == m_cachedPartDrawables.end() || find->second.first != hash;
if (fail) {
String relativeImage;
if (usedImage[0] != '/')
relativeImage = AssetPath::relativeTo(m_relativePath, usedImage);
Drawable drawable = Drawable::makeImage(!relativeImage.empty() ? relativeImage : usedImage, 1.0f / TilePixels, centered, Vec2F());
if (find == m_cachedPartDrawables.end())
find = m_cachedPartDrawables.emplace(partName, std::pair{ hash, std::move(drawable) }).first;
else {
find->second.first = hash;
find->second.second = std::move(drawable);
}
}
Drawable drawable = find->second.second;
auto& imagePart = drawable.imagePart();
for (Directives const& directives : baseProcessingDirectives)
imagePart.addDirectives(directives, centered);
drawable.transform(partTransformation(partName));
drawable.transform(globalTransformation());
drawable.fullbright = fullbright;
drawable.translate(position);
drawables.append({std::move(drawable), zLevel});
}
baseProcessingDirectives.resize(originalDirectivesSize);
});
sort(drawables, [](auto const& a, auto const& b) { return a.second < b.second; });
return drawables;
}
List<LightSource> NetworkedAnimator::lightSources(Vec2F const& translate) const {
List<LightSource> lightSources;
for (auto const& pair : m_lights) {
if (!pair.second.active.get())
continue;
Vec2F position = {pair.second.xPosition.get(), pair.second.yPosition.get()};
float pointAngle = constrainAngle(pair.second.pointAngle.get());
Mat3F transformation = Mat3F::identity();
if (pair.second.anchorPart)
transformation = partTransformation(*pair.second.anchorPart);
transformation = groupTransformation(pair.second.transformationGroups) * transformation;
position = transformation.transformVec2(position);
pointAngle = transformation.transformAngle(pointAngle);
if (pair.second.rotationGroup) {
auto const& rg = m_rotationGroups.get(*pair.second.rotationGroup);
position = (position - pair.second.rotationCenter.value(rg.rotationCenter)).rotate(rg.currentAngle)
+ pair.second.rotationCenter.value(rg.rotationCenter);
pointAngle += rg.currentAngle;
}
position = globalTransformation().transformVec2(position);
if (m_flipped.get()) {
if (pointAngle > 0)
pointAngle = Constants::pi / 2 + constrainAngle(Constants::pi / 2 - pointAngle);
else
pointAngle = -Constants::pi / 2 - constrainAngle(pointAngle + Constants::pi / 2);
}
Color color = pair.second.color.get();
if (pair.second.flicker)
color.setValue(clamp(color.value() * pair.second.flicker->value(SinWeightOperator<float>()), 0.0f, 1.0f));
lightSources.append(LightSource{
position + translate,
color.toRgbF(),
pair.second.pointLight,
pair.second.pointBeam,
pointAngle,
pair.second.beamAmbience
});
}
return lightSources;
}
void NetworkedAnimator::update(float dt, DynamicTarget* dynamicTarget) {
dt *= m_animationRate.get();
m_animatedParts.update(dt);
m_animatedParts.forEachActiveState([&](String const& stateTypeName, AnimatedPartSet::ActiveStateInformation const& activeState) {
if (dynamicTarget) {
dynamicTarget->clearFinishedAudio();
Json persistentSound = activeState.properties.value("persistentSound", "");
String persistentSoundFile;
if (persistentSound.isType(Json::Type::String))
persistentSoundFile = persistentSound.toString();
else if (persistentSound.isType(Json::Type::Array))
persistentSoundFile = Random::randValueFrom(persistentSound.toArray(), "").toString();
if (!persistentSoundFile.empty())
persistentSoundFile = AssetPath::relativeTo(m_relativePath, persistentSoundFile);
auto& activePersistentSound = dynamicTarget->statePersistentSounds[stateTypeName];
bool changedPersistentSound = persistentSound != activePersistentSound.sound;
if (changedPersistentSound || !activePersistentSound.audio) {
activePersistentSound.sound = std::move(persistentSound);
if (activePersistentSound.audio)
activePersistentSound.audio->stop(activePersistentSound.stopRampTime);
if (!persistentSoundFile.empty()) {
activePersistentSound.audio = make_shared<AudioInstance>(*Root::singleton().assets()->audio(persistentSoundFile));
activePersistentSound.audio->setRangeMultiplier(activeState.properties.value("persistentSoundRangeMultiplier", 1.0f).toFloat());
activePersistentSound.audio->setLoops(-1);
activePersistentSound.audio->setPosition(globalTransformation().transformVec2(Vec2F()));
activePersistentSound.stopRampTime = activeState.properties.value("persistentSoundStopTime", 0.0f).toFloat();
dynamicTarget->pendingAudios.append(activePersistentSound.audio);
} else {
dynamicTarget->statePersistentSounds.remove(stateTypeName);
}
}
Json immediateSound = activeState.properties.value("immediateSound", "");
String immediateSoundFile = "";
if (immediateSound.isType(Json::Type::String))
immediateSoundFile = immediateSound.toString();
else if (immediateSound.isType(Json::Type::Array))
immediateSoundFile = Random::randValueFrom(immediateSound.toArray(), "").toString();
if (!immediateSoundFile.empty())
immediateSoundFile = AssetPath::relativeTo(m_relativePath, immediateSoundFile);
auto& activeImmediateSound = dynamicTarget->stateImmediateSounds[stateTypeName];
bool changedImmediateSound = immediateSound != activeImmediateSound.sound;
if (changedImmediateSound) {
activeImmediateSound.sound = std::move(immediateSound);
if (!immediateSoundFile.empty()) {
activeImmediateSound.audio = make_shared<AudioInstance>(*Root::singleton().assets()->audio(immediateSoundFile));
activeImmediateSound.audio->setRangeMultiplier(activeState.properties.value("immediateSoundRangeMultiplier", 1.0f).toFloat());
activeImmediateSound.audio->setPosition(globalTransformation().transformVec2(Vec2F()));
dynamicTarget->pendingAudios.append(activeImmediateSound.audio);
}
}
}
if (auto lightsOn = activeState.properties.ptr("lightsOn")) {
for (auto const& name : lightsOn->iterateArray())
m_lights.get(name.toString()).active.set(true);
}
if (auto lightsOff = activeState.properties.ptr("lightsOff")) {
for (auto const& name : lightsOff->iterateArray())
m_lights.get(name.toString()).active.set(false);
}
if (auto particleEmittersOn = activeState.properties.ptr("particleEmittersOn")) {
for (auto const& name : particleEmittersOn->iterateArray())
m_particleEmitters.get(name.toString()).active.set(true);
}
if (auto particleEmittersOff = activeState.properties.ptr("particleEmittersOff")) {
for (auto const& name : particleEmittersOff->iterateArray())
m_particleEmitters.get(name.toString()).active.set(false);
}
});
for (auto& pair : m_rotationGroups) {
auto& rotationGroup = pair.second;
if (rotationGroup.angularVelocity == 0.0f)
rotationGroup.currentAngle = rotationGroup.targetAngle.get();
else
rotationGroup.currentAngle = approachAngle(rotationGroup.targetAngle.get(), rotationGroup.currentAngle, rotationGroup.angularVelocity * dt);
}
if (dynamicTarget) {
auto addParticles = [this, dynamicTarget](ParticleEmitter::ParticleConfig const& config, RectF const& offsetRegion, Mat3F const& transformation) {
for (unsigned i = 0; i < config.count; ++i) {
Particle particle = config.creator();
particle.position += config.offset;
if (!offsetRegion.isNull()) {
particle.position[0] += Random::randf() * offsetRegion.width() + offsetRegion.xMin();
particle.position[1] += Random::randf() * offsetRegion.height() + offsetRegion.yMin();
}
float speed = particle.velocity.magnitude();
particle.velocity = Vec2F::withAngle(transformation.transformAngle(particle.velocity.angle())) * speed;
particle.position = transformation.transformVec2(particle.position);
particle.rotation = transformation.transformAngle(particle.rotation);
particle.size *= m_zoom.get();
if (config.flip)
particle.flip = !particle.flip;
if (transformation.determinant() < 0) {
particle.flip = !particle.flip;
particle.rotation += Constants::pi;
}
dynamicTarget->pendingParticles.append(std::move(particle));
}
};
for (auto& pair : m_particleEmitters) {
Mat3F transformation = Mat3F::identity();
if (pair.second.anchorPart)
transformation = partTransformation(*pair.second.anchorPart);
transformation = groupTransformation(pair.second.transformationGroups) * transformation;
if (pair.second.rotationGroup) {
auto const& rg = m_rotationGroups.get(*pair.second.rotationGroup);
Vec2F rotationCenter = pair.second.rotationCenter.value(rg.rotationCenter);
transformation = Mat3F::rotation(rg.currentAngle, rotationCenter) * transformation;
}
transformation = globalTransformation() * transformation;
// assume we emit no particles
unsigned numEmissionCycles = 0;
if (pair.second.active.get()) {
pair.second.timer = min(pair.second.timer, 1.0f / (pair.second.emissionRate.get() + pair.second.emissionRateVariance));
if (pair.second.timer <= 0.0f) {
// timer causes us to emit one set
++numEmissionCycles;
pair.second.timer = 1.0f / (pair.second.emissionRate.get() + Random::randf(-pair.second.emissionRateVariance, pair.second.emissionRateVariance));
} else {
pair.second.timer -= dt;
}
}
auto bursts = pair.second.burstEvent.pullOccurrences();
for (uint64_t i = 0; i < bursts; ++i)
numEmissionCycles += pair.second.burstCount.get();
if (numEmissionCycles > 0) {
RectF rect = pair.second.offsetRegion.get();
unsigned numToSelect = pair.second.randomSelectCount.get();
for (unsigned i = 0; i < numEmissionCycles; ++i) {
if (numToSelect >= pair.second.particleList.size()) {
for (auto const& particleConfig : pair.second.particleList)
addParticles(particleConfig, rect, transformation);
} else {
List<ParticleEmitter::ParticleConfig> shuffledList = pair.second.particleList;
Random::shuffle(shuffledList);
for (unsigned i = 0; i < numToSelect; ++i)
addParticles(shuffledList.at(i), rect, transformation);
}
}
}
}
for (auto& pair : m_sounds) {
auto const& soundName = pair.first;
auto& soundEntry = pair.second;
for (auto signal : soundEntry.signals.receive()) {
if (signal == SoundSignal::StopAll) {
for (auto& sound : take(dynamicTarget->independentSounds[soundName]))
sound->stop(soundEntry.volumeRampTime.get());
} else if (signal == SoundSignal::Play) {
String soundFile = Random::randValueFrom(soundEntry.soundPool.get());
if (!soundFile.empty()) {
auto sound = make_shared<AudioInstance>(*Root::singleton().assets()->audio(soundFile));
sound->setRangeMultiplier(soundEntry.rangeMultiplier);
sound->setLoops(soundEntry.loops.get());
sound->setPosition(globalTransformation().transformVec2(Vec2F(soundEntry.xPosition.get(), soundEntry.yPosition.get())));
sound->setVolume(soundEntry.volumeTarget.get(), soundEntry.volumeRampTime.get());
sound->setPitchMultiplier(soundEntry.pitchMultiplierTarget.get(), soundEntry.pitchMultiplierRampTime.get());
dynamicTarget->independentSounds[soundName].append(sound);
dynamicTarget->pendingAudios.append(std::move(sound));
}
}
}
// Update all still active independent sounds position, volume, and speed
for (auto const& activeIndependentSound : dynamicTarget->independentSounds.value(soundName)) {
if (auto basePosition = dynamicTarget->currentAudioBasePositions.ptr(activeIndependentSound))
*basePosition = globalTransformation().transformVec2(Vec2F(soundEntry.xPosition.get(), soundEntry.yPosition.get()));
activeIndependentSound->setVolume(soundEntry.volumeTarget.get(), soundEntry.volumeRampTime.get());
activeIndependentSound->setPitchMultiplier(soundEntry.pitchMultiplierTarget.get(), soundEntry.pitchMultiplierRampTime.get());
}
}
}
for (auto& pair : m_lights) {
if (pair.second.flicker)
pair.second.flicker->update(dt);
}
for (auto& pair : m_effects) {
if (pair.second.enabled.get()) {
auto& effect = pair.second;
if (effect.timer <= 0.0f)
effect.timer = effect.time;
else
effect.timer -= dt;
}
}
}
void NetworkedAnimator::finishAnimations() {
m_animatedParts.finishAnimations();
}
Mat3F NetworkedAnimator::TransformationGroup::affineTransform() const {
return Mat3F(
xScale.get() * cos(xShear.get()), xScale.get() * sin(xShear.get()), xTranslation.get(),
yScale.get() * sin(yShear.get()), yScale.get() * cos(yShear.get()), yTranslation.get(),
0, 0, 1
);
}
void NetworkedAnimator::TransformationGroup::setAffineTransform(Mat3F const& matrix) {
xTranslation.set(matrix[0][2]);
yTranslation.set(matrix[1][2]);
xScale.set(sqrt(square(matrix[0][0]) + square(matrix[0][1])));
yScale.set(sqrt(square(matrix[1][0]) + square(matrix[1][1])));
xShear.set(atan2(matrix[0][1], matrix[0][0]));
yShear.set(atan2(matrix[1][0], matrix[1][1]));
}
void NetworkedAnimator::setupNetStates() {
clearNetElements();
addNetElement(&m_processingDirectives);
addNetElement(&m_zoom);
addNetElement(&m_flipped);
addNetElement(&m_flippedRelativeCenterLine);
addNetElement(&m_animationRate);
m_animationRate.setInterpolator(lerp<float, float>);
addNetElement(&m_globalTags);
for (auto const& part : sorted(m_animatedParts.parts()))
addNetElement(&m_partTags[part]);
for (auto& pair : m_stateInfo) {
addNetElement(&pair.second.stateIndex);
addNetElement(&pair.second.startedEvent);
}
for (auto& pair : m_transformationGroups) {
addNetElement(&pair.second.xTranslation);
addNetElement(&pair.second.yTranslation);
addNetElement(&pair.second.xScale);
addNetElement(&pair.second.yScale);
addNetElement(&pair.second.xShear);
addNetElement(&pair.second.yShear);
if (pair.second.interpolated) {
pair.second.xTranslation.setInterpolator(lerp<float, float>);
pair.second.yTranslation.setInterpolator(lerp<float, float>);
pair.second.xScale.setInterpolator(lerp<float, float>);
pair.second.yScale.setInterpolator(lerp<float, float>);
pair.second.xShear.setInterpolator(angleLerp<float, float>);
pair.second.yShear.setInterpolator(angleLerp<float, float>);
}
}
for (auto& pair : m_rotationGroups) {
addNetElement(&pair.second.targetAngle);
addNetElement(&pair.second.netImmediateEvent);
}
for (auto& pair : m_particleEmitters) {
addNetElement(&pair.second.emissionRate);
addNetElement(&pair.second.burstCount);
addNetElement(&pair.second.randomSelectCount);
addNetElement(&pair.second.offsetRegion);
addNetElement(&pair.second.active);
addNetElement(&pair.second.burstEvent);
pair.second.burstEvent.setIgnoreOccurrencesOnNetLoad(true);
}
for (auto& pair : m_lights) {
addNetElement(&pair.second.active);
addNetElement(&pair.second.xPosition);
addNetElement(&pair.second.yPosition);
addNetElement(&pair.second.color);
addNetElement(&pair.second.pointAngle);
pair.second.xPosition.setFixedPointBase(0.0125f);
pair.second.yPosition.setFixedPointBase(0.0125f);
pair.second.pointAngle.setFixedPointBase(0.01f);
pair.second.xPosition.setInterpolator(lerp<float, float>);
pair.second.yPosition.setInterpolator(lerp<float, float>);
pair.second.pointAngle.setInterpolator(angleLerp<float, float>);
}
for (auto& pair : m_sounds) {
addNetElement(&pair.second.soundPool);
addNetElement(&pair.second.xPosition);
addNetElement(&pair.second.yPosition);
addNetElement(&pair.second.volumeTarget);
addNetElement(&pair.second.volumeRampTime);
addNetElement(&pair.second.pitchMultiplierTarget);
addNetElement(&pair.second.pitchMultiplierRampTime);
addNetElement(&pair.second.loops);
addNetElement(&pair.second.signals);
pair.second.xPosition.setFixedPointBase(0.0125f);
pair.second.yPosition.setFixedPointBase(0.0125f);
pair.second.xPosition.setInterpolator(lerp<float, float>);
pair.second.yPosition.setInterpolator(lerp<float, float>);
}
for (auto& pair : m_effects)
addNetElement(&pair.second.enabled);
}
void NetworkedAnimator::netElementsNeedLoad(bool initial) {
for (auto& pair : m_stateInfo) {
if (pair.second.startedEvent.pullOccurred() || initial)
m_animatedParts.setActiveStateIndex(pair.first, pair.second.stateIndex.get(), true);
}
for (auto& pair : m_rotationGroups) {
if (pair.second.netImmediateEvent.pullOccurred() || initial)
pair.second.currentAngle = pair.second.targetAngle.get();
}
}
void NetworkedAnimator::netElementsNeedStore() {
for (auto& pair : m_stateInfo)
pair.second.stateIndex.set(m_animatedParts.activeStateIndex(pair.first));
}
}