CCEffect %{
  temporaries:
    b1: &b1
      targets:
      - blend: true
        blendSrc: src_alpha
        blendDst: one
        blendSrcAlpha: src_alpha
        blendDstAlpha: one
    b2: &b2
      targets:
      - blend: true
        blendSrc: one
        blendDst: one_minus_src_alpha
        blendSrcAlpha: one
        blendDstAlpha: one_minus_src_alpha
    d1: &d1 { depthTest: true, depthWrite: false }
    r1: &r1 { cullMode: none }
    p1: &p1
      mainTexture:            { value: grey }
      mainTiling_Offset:      { value: [1, 1, 0, 0]  }
    p2: &p2
      <<: *p1
      tintColor:              { value: [0.5, 0.5, 0.5, 0.5], editor: { type: color } }

  techniques:
  - name: add
    passes:
    - vert: vert:vs_main
      frag: tinted-fs:add
      rasterizerState: *r1
      depthStencilState: *d1
      blendState: *b1
      properties: *p2
    - vert: vert:vs_main
      frag: tinted-fs:add
      phase: deferred-forward
      rasterizerState: *r1
      depthStencilState: *d1
      blendState: *b1
      propertyIndex: 0
  - name: alpha-blend
    passes:
    - vert: vert:vs_main
      frag: tinted-fs:add
      rasterizerState: *r1
      depthStencilState: *d1
      blendState: *b2
      properties: *p2
    - vert: vert:vs_main
      frag: tinted-fs:add
      phase: deferred-forward
      rasterizerState: *r1
      depthStencilState: *d1
      blendState: *b1
      propertyIndex: 0
  - name: add-multiply
    passes:
    - vert: vert:vs_main
      frag: tinted-fs:multiply
      rasterizerState: *r1
      depthStencilState: *d1
      blendState: *b2
      properties: *p2
    - vert: vert:vs_main
      frag: tinted-fs:multiply
      phase: deferred-forward
      rasterizerState: *r1
      depthStencilState: *d1
      blendState: *b2
      propertyIndex: 0
  - name: add-smooth
    passes:
    - vert: vert:vs_main
      frag: no-tint-fs:addSmooth
      rasterizerState: *r1
      depthStencilState: *d1
      blendState: *b2
      properties: *p1
    - vert: vert:vs_main
      frag: no-tint-fs:addSmooth
      phase: deferred-forward
      rasterizerState: *r1
      depthStencilState: *d1
      blendState: *b2
      propertyIndex: 0
  - name: premultiply-blend
    passes:
    - vert: vert:vs_main
      frag: no-tint-fs:premultiplied
      rasterizerState: *r1
      depthStencilState: *d1
      blendState: *b2
      properties: *p1
    - vert: vert:vs_main
      frag: no-tint-fs:premultiplied
      phase: deferred-forward
      rasterizerState: *r1
      depthStencilState: *d1
      blendState: *b2
      propertyIndex: 0
}%

// TODO: soft particle

CCProgram vert %{
  precision mediump float;
  #include <builtin/internal/particle-common>
  #pragma define CC_RENDER_MODE RENDER_MODE_BILLBOARD
  in vec3 a_position; // center position
  in vec2 a_texCoord;  // texcoord
  in vec4 a_color;

  uniform builtin {
    vec4 cc_size_rotation;
  };

  vec4 vs_main() {
    vec4 pos = vec4(a_position, 1);

    pos = cc_matWorld * pos;

    vec2 vertOffset = a_texCoord.xy - 0.5;
    computeVertPos(pos, vertOffset, quaternionFromEuler(vec3(0., 0., cc_size_rotation.z)), vec3(cc_size_rotation.xy, 0.), cc_matViewInv);
    pos = cc_matViewProj * pos;
    uv = a_texCoord.xy;
    color = a_color;
    return pos;
  }
}%

CCProgram tinted-fs %{
  precision mediump float;
  #include <legacy/output>
  #include <builtin/internal/embedded-alpha>

  in vec2 uv;
  in vec4 color;

  uniform sampler2D mainTexture;
  uniform FragConstants {
    vec4 tintColor;
  };

  vec4 add () {
    vec4 col = 2.0 * color * tintColor * CCSampleWithAlphaSeparated(mainTexture, uv);
    return CCFragOutput(col);
  }

  vec4 multiply () {
    vec4 col;
    vec4 texColor = CCSampleWithAlphaSeparated(mainTexture, uv);
    col.rgb = tintColor.rgb * texColor.rgb * color.rgb * vec3(2.0);
    col.a = (1.0 - texColor.a) * (tintColor.a * color.a * 2.0);
    return CCFragOutput(col);
  }
}%

CCProgram no-tint-fs %{
  precision mediump float;
  #include <legacy/output>
  #include <builtin/internal/embedded-alpha>

  in vec2 uv;
  in vec4 color;

  uniform sampler2D mainTexture;

  vec4 addSmooth () {
    vec4 col = color * CCSampleWithAlphaSeparated(mainTexture, uv);
    col.rgb *= col.a;
    return CCFragOutput(col);
  }

  vec4 premultiplied () {
    vec4 col = color * CCSampleWithAlphaSeparated(mainTexture, uv) * color.a;
    return CCFragOutput(col);
  }
}%