pubgv3/assets/scripts/shaders/FluxaySuper.js

const renderEngine = cc.renderer.renderEngine;
const renderer = renderEngine.renderer;
let ShaderMaterial = require('ShaderMaterial');

const shader = {
    name: 'FluxaySuper',
    params: [
        { name: 'time', type: renderer.PARAM_FLOAT },
        { name: 'coloraddr', type: renderer.PARAM_FLOAT },
        { name: 'coloraddg', type: renderer.PARAM_FLOAT },
        { name: 'coloraddb', type: renderer.PARAM_FLOAT },
        { name: 'palpha', type: renderer.PARAM_FLOAT },
        { name: 'blackv', type: renderer.PARAM_FLOAT },
    ],

    start(material,params) {
         material.cusparmas = {}
         material.cusparmas._start = 0
         material.setParamValue('coloraddr', params.r);
         material.setParamValue('coloraddg', params.g);
         material.setParamValue('coloraddb', params.b);
         material.setParamValue('palpha', 1.0);
         material.setParamValue('blackv', 1.0);
    },

    update(material, dt) {
        material.cusparmas._start+=dt
        material.setParamValue('time',  material.cusparmas._start);
    },

    defines:[],

    // vert: `
    //     uniform mat4 viewProj;
    //     attribute vec3 a_position;
    //     attribute vec2 a_uv0;
    //     varying vec2 uv0;
    //     void main () {
    //         vec4 pos = viewProj * vec4(a_position, 1);
    //         gl_Position = pos;
    //         uv0 = a_uv0;
    //     }`,
    vert:ShaderMaterial.spinevert,
    // frag:
    //     `#define TAU 6.12
    //     #define MAX_ITER 5
    //     uniform sampler2D texture;
    //     uniform vec4 color;
    //     uniform float time;
    //     uniform float coloraddr;
    //     uniform float coloraddg;
    //     uniform float coloraddb;
    //     uniform float blackv;
    //     varying vec2 uv0;
    //     uniform vec4 UVoffset;
    //     uniform float rotated;
    //     uniform float palpha;
    //     void main()
    //     {
    //         float time = time * .5+5.;
    //         // uv should be the 0-1 uv of texture...
    //         vec2 UVnormalize;
    //         UVnormalize.x = (uv0.x-UVoffset.x)/(UVoffset.z-UVoffset.x);
    //         UVnormalize.y = (uv0.y-UVoffset.y)/(UVoffset.w-UVoffset.y);
    //         if(rotated > 0.5)
    //         {
    //             float temp = UVnormalize.x;
    //             UVnormalize.x = UVnormalize.y;
    //             UVnormalize.y = 1.0 - temp;
    //         }


    //         vec2 uv = UVnormalize.xy;//fragCoord.xy / iResolution.xy;
            
    //         vec2 p = mod(uv*TAU, TAU)-250.0;
        
    //         vec2 i = vec2(p);
    //         float c = 1.0;
    //         float inten = .0045;
        
    //         for (int n = 0; n < MAX_ITER; n++) 
    //         {
    //             float t =  time * (1.0 - (3.5 / float(n+1)));
    //             i = p + vec2(cos(t - i.x) + sin(t + i.y), sin(t - i.y) + cos(1.5*t + i.x));
    //             c += 1.0/length(vec2(p.x / (cos(i.x+t)/inten),p.y / (cos(i.y+t)/inten)));
    //         }
    //         c /= float(MAX_ITER);
    //         c = 1.17-pow(c, 1.8);
    //         vec4 tex = texture2D(texture,uv0);
    //         vec3 colour = vec3(pow(abs(c), 20.0));
    //         colour = clamp(colour + vec3(0.0, 0.0, .0), 0.0, tex.a);
    //         
    //         float alpha = c*tex[3];  

    //         tex[0] = tex[0]*blackv + colour[0]*coloraddr*alpha; 
    //         tex[1] = tex[1]*blackv + colour[1]*coloraddg*alpha; 
    //         tex[2] = tex[2]*blackv + colour[2]*coloraddb*alpha; 

    //         gl_FragColor =  tex;
    //         gl_FragColor.a = gl_FragColor.a*palpha;
    //     }`,


        frag:`

            #define TAU 6.12
            #define MAX_ITER 5

            uniform sampler2D texture;
            varying mediump vec2 uv0;
            #ifdef alphaTest
              uniform lowp float alphaThreshold;
              #endif
            varying lowp vec4 v_light;
            #ifdef useTint
              varying lowp vec4 v_dark;
              #endif

            uniform float coloraddr;
            uniform float coloraddg;
            uniform float coloraddb;
            uniform float blackv;
            uniform float palpha;
            uniform float time;

            void main () {
              vec4 texColor = texture2D(texture, uv0);
              vec4 finalColor;
              #ifdef useTint
                finalColor.a = v_light.a * texColor.a;
                finalColor.rgb = ((texColor.a - 1.0) * v_dark.a + 1.0 - texColor.rgb) * v_dark.rgb + texColor.rgb * v_light.rgb;
              #else
                finalColor = texColor * v_light;
              #endif
              #ifdef alphaTest
                if (finalColor.a <= alphaThreshold)
                  discard;
              #endif

              vec2 p = mod(uv0*TAU, TAU)-250.0;
              vec2 i = vec2(p);
              float c = 1.0;
              float inten = .0045;

            for (int n = 0; n < MAX_ITER; n++) 
            {
                float t =  time * (1.0 - (3.5 / float(n+1)));
                i = p + vec2(cos(t - i.x) + sin(t + i.y), sin(t - i.y) + cos(1.5*t + i.x));
                c += 1.0/length(vec2(p.x / (cos(i.x+t)/inten),p.y / (cos(i.y+t)/inten)));
            }
            c /= float(MAX_ITER);
            c = 1.17-pow(c, 1.8);
          
            vec3 colour = vec3(pow(abs(c), 20.0));
            colour = clamp(colour + vec3(0.0, 0.0, .0), 0.0, finalColor.a);
           
            float alpha = c*finalColor[3];  

            finalColor[0] = finalColor[0]*blackv + colour[0]*coloraddr*alpha; 
            finalColor[1] = finalColor[1]*blackv + colour[1]*coloraddg*alpha; 
            finalColor[2] = finalColor[2]*blackv + colour[2]*coloraddb*alpha; 




              gl_FragColor = finalColor;
            }
        `
};

ShaderMaterial.addShader(shader);