10 examples of 'useeffect before render' in JavaScript

312
viewEffect() {
313
  this.effectComposer.render(this.renderer, this.effectPack, true);
314
}

12
PostRender (ctx: minerva.core.render.RenderContext) {
13
}

42
render(engine: RenderGraphBackEnd, enableGraphDebugging: boolean = false) {
43
  this.passes.forEach((pass, index) => {
44
    const output = pass.outputTarget;
45
    output.updateSize(engine);
46
    let framebuffer: Nullable = null;
47
48
    if (!output.isScreenNode) {
49
      framebuffer = this.keptFramebuffer.get(output)!
50
      if (framebuffer === undefined) {
51
        framebuffer = this.framebufferPool.requestFramebuffer(output)
52
      }
53
    }
54
55
    pass.uniformRenderTargetNodeMap.forEach((targetDepend, uniformName) => {
56
      let inputFBO = this.keptFramebuffer.get(targetDepend);
57
58
      // if input not exist, its never initialized(empty fbo). created now!
59
      if (inputFBO === undefined) {
60
        targetDepend.updateSize(engine);
61
        inputFBO = this.framebufferPool.requestFramebuffer(targetDepend)
62
        this.keptFramebuffer.set(targetDepend, inputFBO);
63
      }
64
65
      pass.uniformNameFBOMap.set(uniformName, inputFBO.name)
66
    })
67
  
68
    if (!this.hasAllPassIsValidChecked) {
69
      pass.checkIsValid(); 
70
    }
71
72
    
73
    pass.passNode._beforePassExecute.notifyObservers(pass.passNode);
74
75
    pass.execute(engine, framebuffer, enableGraphDebugging);
76
    
77
    pass.passNode._afterPassExecute.notifyObservers(pass.passNode);
78
79
    if (!output.isScreenNode) {
80
      this.keptFramebuffer.set(output, framebuffer!);
81
    }
82
    
83
    output._afterContentReceived.notifyObservers(output);
84
85
    this.framebufferDropList[index].forEach(target => {
86
      this.framebufferPool.returnFramebuffer(this.keptFramebuffer.get(target)!)
87
      this.keptFramebuffer.delete(target)
88
    })
89
90
  });
91
  this.hasAllPassIsValidChecked = true;
92
}

32
_applyEffect() {
33
  super._applyEffect();
34
  const player = this.game.player;
35
  this.effectTypes.forEach((effectType) => {
36
    const amount = this._getAmountForEffect(effectType);
37
    if(amount !== null) {
38
      const event = Mediator.publish(EffectItemMessages.APPLY, {
39
        source: this.entity,
40
        effectType: effectType,
41
        amount: amount
42
      });
43
      if(event.process) {
44
        switch (event.args.effectType) {
45
          case ItemEffectType.HEALTH:
46
            player.increaseHealth(event.args.amount);
47
            break;
48
          case ItemEffectType.POINTS:
49
            player.increasePoints(event.args.amount);
50
            break;
51
          case ItemEffectType.MONEY:
52
            player.increaseMoney(event.args.amount);
53
            break;
54
        }
55
      }
56
    }
57
  });
58
}

51
function Effect() {
52
  const { gl, scene, camera, size } = useThree()
53
54
  const [bloom, final] = useMemo(() => {
55
    const renderScene = new RenderPass(scene, camera)
56
57
    const comp = new EffectComposer(gl)
58
    comp.renderToScreen = false
59
    comp.addPass(renderScene)
60
    comp.addPass(new UnrealBloomPass(new THREE.Vector2(size.width, size.height), 1.25, 1, 0))
61
62
    const finalComposer = new EffectComposer(gl)
63
    finalComposer.addPass(renderScene)
64
    const finalPass = new ShaderPass(
65
      new THREE.ShaderMaterial({
66
        uniforms: { baseTexture: { value: null }, bloomTexture: { value: comp.renderTarget2.texture } },
67
        vertexShader:
68
          'varying vec2 vUv; void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 ); }',
69
        fragmentShader:
70
          'uniform sampler2D baseTexture; uniform sampler2D bloomTexture; varying vec2 vUv; vec4 getTexture( sampler2D texelToLinearTexture ) { return mapTexelToLinear( texture2D( texelToLinearTexture , vUv ) ); } void main() { gl_FragColor = ( getTexture( baseTexture ) + vec4( 1.0 ) * getTexture( bloomTexture ) ); }',
71
      }),
72
      'baseTexture'
73
    )
74
    finalPass.needsSwap = true
75
    finalComposer.addPass(finalPass)
76
77
    const fxaa = new ShaderPass(FXAAShader)
78
    fxaa.material.uniforms['resolution'].value.x = 1 / size.width
79
    fxaa.material.uniforms['resolution'].value.y = 1 / size.height
80
    finalComposer.addPass(fxaa)
81
82
    return [comp, finalComposer]
83
  }, [])
84
85
  useEffect(() => {
86
    bloom.setSize(size.width, size.height)
87
    final.setSize(size.width, size.height)
88
  }, [bloom, final, size])
89
90
  useFrame(() => {
91
    // https://github.com/mrdoob/three.js/blob/master/examples/webgl_postprocessing_unreal_bloom_selective.html
92
    // this seems kinda dirty, it mutates the scene and overwrites materials
93
    scene.traverse(darkenNonBloomed)
94
    bloom.render()
95
    scene.traverse(restoreMaterial)
96
    // then writes the normal scene on top
97
    final.render()
98
  }, 1)
99
  return null
100
}

435
function updateEffectFn(camera)
436
{
437
    // Custom update effect to project particles in world space
438
    var techniqueParameters = this.techniqueParameters;
439
    techniqueParameters.worldViewProjection = camera.viewProjectionMatrix;
440
441
    // As we update the geometry we need to propagate the changes to the drawParameters.
442
    this.drawParameters[0].firstIndex = this.surface.first;
443
    this.drawParameters[0].count = this.surface.numIndices;
444
}

88
export function useLayoutEffect(effect: Effect, arg?: TArg) {
89
    useEffectInternal(true, effect, arg)
90
}

112
effect() {
113
    if (this.length > 0) {
114
        this.length--;
115
        this.owner.hp = this.savedHP;
116
        if (this.length === 0) {
117
            this.savedHP = 0;
118
            this.owner.attackBuff -= this.bonus;
119
            this.owner.update();
120
        }
121
    }
122
}

19
onEffect(effect) {
20
    var {canvas} = this.state;
21
    canvas.deactivateAll();
22
    var overlayImageUrl = canvas.toDataURL('png');
23
    var imageDOM = ReactDOM.findDOMNode(this.imageBuffer);
24
    imageDOM.setAttribute('src', overlayImageUrl);
25
    imageDOM.setAttribute('crossOrigin', 'anonymous');
26
    var filterImageUrl = imageDOM.getAttribute('src');
27
    // patch fabric for cross domain image jazz
28
    
29
    fabric.Image.fromURL(filterImageUrl, function(img) {
30
        switch (effect) {
31
            case 'grayscale':
32
                img.filters.push(new fabric.Image.filters.Grayscale());
33
                break;
34
            case 'sepia':
35
                img.filters.push(new fabric.Image.filters.Sepia());
36
                break;
37
            case 'sepia2':
38
                img.filters.push(new fabric.Image.filters.Sepia2());
39
                break;
40
            case 'invert':
41
                img.filters.push(new fabric.Image.filters.Invert());
42
                break;
43
        }
44
        img.applyFilters(canvas.renderAll.bind(canvas));
45
        canvas.add(img);
46
    }, {
47
        crossOrigin: 'anonymous'
48
    });
49
    canvas.deactivateAll().renderAll();
50
}

51
PreRender (ctx: minerva.core.render.RenderContext) {
52
    var color = this.Color;
53
    var opacity = color.A * this.Opacity;
54
55
    var radius = Math.min(this.BlurRadius, DropShadowEffect.MAX_BLUR_RADIUS);
56
    var depth = Math.min(Math.max(0, this.ShadowDepth), DropShadowEffect.MAX_SHADOW_DEPTH);
57
    var direction = this.Direction * Math.PI / 180.0;
58
    var offsetX = Math.cos(direction) * depth;
59
    var offsetY = -Math.sin(direction) * depth;
60
61
    var raw = ctx.raw;
62
    raw.shadowColor = "rgba(" + color.R + "," + color.G + "," + color.B + "," + opacity + ")";
63
    raw.shadowBlur = radius;
64
    raw.shadowOffsetX = offsetX;
65
    raw.shadowOffsetY = offsetY;
66
}