vec3 diffuse(PBRInfo pbrInputs)
{
    return pbrInputs.diffuseColor / M_PI;
}

//Trowbridge-Reitz GGX
float microfacetDistribution(PBRInfo pbrInputs)
{
    float roughnessSq = pbrInputs.alphaRoughness * pbrInputs.alphaRoughness;
    float f = (pbrInputs.NdotH * roughnessSq - pbrInputs.NdotH) * pbrInputs.NdotH + 1.0;
    return roughnessSq / (M_PI * f * f);
}

//Fresnel-Schlick近似(Fresnel-Schlick Approximation)
float geometricOcclusion(PBRInfo pbrInputs)
{
    float NdotL = pbrInputs.NdotL;
    float NdotV = pbrInputs.NdotV;
    float r = pbrInputs.alphaRoughness;

    float attenuationL = 2.0 * NdotL / (NdotL + sqrt(r * r + (1.0 - r * r) * (NdotL * NdotL)));
    float attenuationV = 2.0 * NdotV / (NdotV + sqrt(r * r + (1.0 - r * r) * (NdotV * NdotV)));
    return attenuationL * attenuationV;
}

//Smith’s Schlick-GGX
vec3 specularReflection(PBRInfo pbrInputs)
{
    return pbrInputs.reflectance0 + (pbrInputs.reflectance90 - pbrInputs.reflectance0) * pow(clamp(1.0 - pbrInputs.VdotH, 0.0, 1.0), 5.0);
}

vec3 diffuseContrib = (1.0 - F) * diffuse(pbrInputs);

vec3 specContrib = F * G * D / (4.0 * NdotL * NdotV);

// Obtain final intensity as reflectance (BRDF) scaled by the energy of the light (cosine law)

vec3 color = NdotL * u_LightColor * (diffuseContrib + specContrib);

#ifdef USE_IBL
vec3 getIBLContribution(PBRInfo pbrInputs, vec3 n, vec3 reflection)
{
    //预计算贴图tLUT
    vec3 brdf = SRGBtoLINEAR(texture(tLUT, vec2(pbrInputs.NdotV, 1.0 - pbrInputs.perceptualRoughness))).rgb;
    // CubeMap
    vec3 diffuseLight = SRGBtoLINEAR(texture(tEnvDiffuse, n)).rgb;
    vec3 specularLight = SRGBtoLINEAR(texture(tEnvSpecular, reflection)).rgb;


    vec3 diffuse = diffuseLight * pbrInputs.diffuseColor;
    vec3 specular = specularLight * (pbrInputs.specularColor * brdf.x + brdf.y);


    return diffuse + specular;
}
#endif

// Calculate lighting contribution from image based lighting source (IBL)
#ifdef USE_IBL

    color += getIBLContribution(pbrInputs, n, reflection);

#endif


// Apply optional PBR terms for additional (optional) shading
// AO MAP
#ifdef HAS_OCCLUSIONMAP

    float ao = texture(u_OcclusionSampler, vUv).r;

    color = mix(color, color * ao, u_OcclusionStrength);

#endif

//EMISSIVE MAP
#ifdef HAS_EMISSIVEMAP

    vec3 emissive = SRGBtoLINEAR(texture(u_EmissiveSampler, vUv)).rgb * u_EmissiveFactor;

    color += emissive;

#endif

FragColor = vec4(color, baseColor.a);

jointMatrix(j) =
  globalTransformOfNodeThatTheMeshIsAttachedTo^-1 *
  globalTransformOfJointNode(j) *
  inverseBindMatrixForJoint(j);

vec4 Pos = vec4(position, 1.0);
vec4 transformed = skinMatrix * Pos;

gl_Position = projectionMatrix * viewMatrix * transformed; //model already calculate in boneMatrix

this.boneTexture = new Texture(this.gl, {
    image: this.boneMatrices,

    generateMipmaps: false,

    type: this.gl.FLOAT,

    internalFormat: this.gl.renderer.isWebgl2 ? this.gl.RGBA16F : this.gl.RGBA,

    flipY: false,

    width: size,

});

uniform sampler2D boneTexture;
uniform int boneTextureSize;

mat4 getBoneMatrix(const in float i) {
    float j = i * 4.0;
    float x = mod(j, float(boneTextureSize)); //所在行

    float y = floor(j / float(boneTextureSize)); //所在列


    float dx = 1.0 / float(boneTextureSize);
    float dy = 1.0 / float(boneTextureSize);

    y = dy * (y + 0.5);

    vec4 v1 = texture2D(boneTexture, vec2(dx * (x + 0.5), y)); //转换回UV范围内坐标

    vec4 v2 = texture2D(boneTexture, vec2(dx * (x + 1.5), y));
    vec4 v3 = texture2D(boneTexture, vec2(dx * (x + 2.5), y));
    vec4 v4 = texture2D(boneTexture, vec2(dx * (x + 3.5), y)); 


    return mat4(v1, v2, v3, v4);
}

"animations" : [
    {

       "channels" : [

          {

             "sampler" : 0,

             "target" : {

                "node" : 0,  // => 要进行动画的节点

                "path" : "rotation" // => 所进行的动画类型（translation、rotation、scale、weight）

             }

           }

       ],

       "samplers" : [

          {

             "input" : 0, // => KeyTime 动画的时间帧

             "interpolation" : "LINEAR", // => 两帧之间的插值方法

             "output" : 1 // => 具体的动画帧数据（从accessors取）

          }

       ]

    }
]

loader.load( animationModel, null, gltf => {
    let glTF = gltf.scene;

    // Animation

    animationSys = gltf.animations;

    if ( animationSys ){

         animationSys.speed = 0.5; //控制动画速度

    }

    scene.addChild(glTF);

 });

requestAnimationFrame(update);

let deltaTime = 0;

let lastTime = Date.now();

function update() {

    deltaTime = (Date.now() - lastTime)/1000;

    lastTime = Date.now();

    if(animationSys) animationSys.update(deltaTime); //更新动画

    renderer.render({ scene, camera });

    requestAnimationFrame(update);

}

update(dt) {
    for (let animation of this.group) {

        if (dt > 0.016) dt = 0.016;

        for (let channel of animation.channels) {

            this.playStep(animation, channel, dt);

        }

    }

}