LibGDX-Partikelemitterrotation

Ich habe ein libGDX-Spiel, in dem ich mit Partikeln einen Eisatem-ähnlichen Effekt erzielen möchte. Bisher haben wir einen kegelförmigen Effekt erzielt. Ich kann es damit erhalten und auf dem Bildschirm rendern.

ParticleEffectPool.PooledEffect effect = breathPool.obtain();
effect.setPosition(x,y);
ps.add(effect);

Aber ich sehe keine Möglichkeit, das gesamte Partikelsystem in eine bestimmte Richtung zu drehen . Gibt es eine Möglichkeit, dies zu erreichen?

Sie können versuchen, die angleEigenschaft Ihres Emitters (oder der Emitter, wenn Sie viele haben) auszuwählen und die Werte manuell so anzupassen, dass sie um einen bestimmten Winkel zentriert werden.

ParticleEffect effect = /* your effect */
ParticleEmitter emitter = effect.findEmitter("some_name"); // find the emitter you want to     rotate here
float targetAngle = /* your target angle */

ScaledNumericValue angle = emitter.getAngle();

/* find angle property and adjust that by letting the min, max of low and high span their current size around your angle */

float angleHighMin = angle.getHighMin();
float angleHighMax = angle.getHighMax();
float spanHigh = angleHighMax - angleHighMin;
angle.setHigh(angle - spanHigh / 2.0f, angle + spanHigh / 2.0f);

float angleLowMin = angle.getLowhMin();
float angleLowMax = angle.getLowMax();
float spanLow = angleLowMax - angleLowMin;
angle.setLow(angle - spanLow / 2.0f, angle + spanLow / 2.0f);

Beachten Sie, dass die oben würde nur einstellen , was die hohe und niedrige , und Sie werden wahrscheinlich Notwendigkeit, etwas dagegen zu umwickeln.

Hier ist meine eigene Lösung für 90 ° -Drehungen:

/**
 * Created on 2018-02-09.
 *
 * @author Alexander Winter
 */
public class RotatableParticleEffect extends ParticleEffect {
    public RotatableParticleEffect() {}

    public RotatableParticleEffect(ParticleEffect effect) {
        super(effect);
    }

    public void rotateBy(int turnQuarter) {
        while(turnQuarter < 0)
            turnQuarter += 4;

        turnQuarter %= 4;

        for(ParticleEmitter emitter : getEmitters()) {
            ScaledNumericValue angle = emitter.getAngle();

            angle.setHighMax(angle.getHighMax() + turnQuarter * -90f);
            angle.setHighMin(angle.getHighMin() + turnQuarter * -90f);

            angle.setLowMax(angle.getLowMax() + turnQuarter * -90f);
            angle.setLowMin(angle.getLowMin() + turnQuarter * -90f);

            ScaledNumericValue rot = emitter.getRotation();

            rot.setHighMax(rot.getHighMax() + turnQuarter * -90f);
            rot.setHighMin(rot.getHighMin() + turnQuarter * -90f);

            rot.setLowMax(rot.getLowMax() + turnQuarter * -90f);
            rot.setLowMin(rot.getLowMin() + turnQuarter * -90f);

            for(int i = 0; i < turnQuarter; i++) {
                swapFields(emitter.getXOffsetValue(), emitter.getYOffsetValue());

                emitter.getYOffsetValue().setLowMin(-emitter.getYOffsetValue().getLowMin());
                emitter.getYOffsetValue().setLowMax(-emitter.getYOffsetValue().getLowMax());
            }
        }
    }

    private static void swapFields(Object o1, Object o2) {
        if(o1 == null || o2 == null)
            throw new IllegalArgumentException("Objects must not be null");

        if(!o1.getClass().equals(o2.getClass()))
            throw new IllegalArgumentException("Objects are not the same type");

        Class<?> type = o1.getClass();

        while(type != null) {
            for(Field field : type.getDeclaredFields()) {
                if(!field.isAccessible())
                    field.setAccessible(true);

                try {
                    Object tmp = field.get(o1);
                    field.set(o1, field.get(o2));
                    field.set(o2, tmp);
                } catch(IllegalAccessException ex) {
                    throw new RuntimeException(ex);
                }
            }

            type = type.getSuperclass();
        }
    }
}

Mit dieser Lösung können Sie nicht mit einem beliebigen Winkel drehen. Wenn Sie möchten, müssen Sie die X- und Y-Offsets mit einer Drehung anpassen. offsetY = originalOffsetY * sin(angle)und das gleiche für X mit cos(). Ich habe die vollständige Lösung für keinen Winkel implementiert, weil ich sie nicht brauchte. Ich kann jedoch bestätigen, dass diese einfachere Lösung für mich funktioniert.

Fügen Sie den Partikeleffekt einer Gruppe mit aktivierter Transformation hinzu (Standard).