GDevelop/Extensions/3D/BloomEffect.ts at c022acdc634fc8de3ae8d9a2a0062d82586527c5 · 4ian/GDevelop · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
namespace gdjs {
  interface BloomFilterNetworkSyncData {
    s?: number;
    strength?: number;

    r?: number;
    radius?: number;

    t?: number;
    threshold?: number;
  }
  gdjs.PixiFiltersTools.registerFilterCreator(
    'Scene3D::Bloom',
    new (class implements gdjs.PixiFiltersTools.FilterCreator {
      makeFilter(
        target: EffectsTarget,
        effectData: EffectData
      ): gdjs.PixiFiltersTools.Filter {
        if (typeof THREE === 'undefined') {
          return new gdjs.PixiFiltersTools.EmptyFilter();
        }
        return new (class implements gdjs.PixiFiltersTools.Filter {
          shaderPass: THREE_ADDONS.UnrealBloomPass;
          _isEnabled: boolean;

          constructor() {
            this.shaderPass = new THREE_ADDONS.UnrealBloomPass(
              new THREE.Vector2(256, 256),
              1,
              0,
              0
            );
            this._isEnabled = false;
          }

          isEnabled(target: EffectsTarget): boolean {
            return this._isEnabled;
          }
          setEnabled(target: EffectsTarget, enabled: boolean): boolean {
            if (this._isEnabled === enabled) {
              return true;
            }
            if (enabled) {
              return this.applyEffect(target);
            } else {
              return this.removeEffect(target);
            }
          }
          applyEffect(target: EffectsTarget): boolean {
            if (!(target instanceof gdjs.Layer)) {
              return false;
            }
            target.getRenderer().addPostProcessingPass(this.shaderPass);
            this._isEnabled = true;
            return true;
          }
          removeEffect(target: EffectsTarget): boolean {
            if (!(target instanceof gdjs.Layer)) {
              return false;
            }
            target.getRenderer().removePostProcessingPass(this.shaderPass);
            this._isEnabled = false;
            return true;
          }
          updatePreRender(target: gdjs.EffectsTarget): any {}
          updateDoubleParameter(parameterName: string, value: number): void {
            if (parameterName === 'strength') {
              this.shaderPass.strength = value;
            }
            if (parameterName === 'radius') {
              this.shaderPass.radius = value;
            }
            if (parameterName === 'threshold') {
              this.shaderPass.threshold = value;
            }
          }
          getDoubleParameter(parameterName: string): number {
            if (parameterName === 'strength') {
              return this.shaderPass.strength;
            }
            if (parameterName === 'radius') {
              return this.shaderPass.radius;
            }
            if (parameterName === 'threshold') {
              return this.shaderPass.threshold;
            }
            return 0;
          }
          updateStringParameter(parameterName: string, value: string): void {}
          updateColorParameter(parameterName: string, value: number): void {}
          getColorParameter(parameterName: string): number {
            return 0;
          }
          updateBooleanParameter(parameterName: string, value: boolean): void {}
          getNetworkSyncData(
            syncOptions: GetNetworkSyncDataOptions
          ): BloomFilterNetworkSyncData {
            const getKey = (abbrev: string, full: string) =>
              syncOptions.useFullNames ? full : abbrev;
            return {
              [getKey('s', 'strength')]: this.shaderPass.strength,
              [getKey('r', 'radius')]: this.shaderPass.radius,
              [getKey('t', 'threshold')]: this.shaderPass.threshold,
            } as BloomFilterNetworkSyncData;
          }
          updateFromNetworkSyncData(data: BloomFilterNetworkSyncData) {
            if (data.s !== undefined) this.shaderPass.strength = data.s;
            if (data.r !== undefined) this.shaderPass.radius = data.r;
            if (data.t !== undefined) this.shaderPass.threshold = data.t;
          }
        })();
      }
    })()
  );
}