dali-scene3d/internal/graphics/shaders/default-physically-based-shader.vert

   1 #version 300 es
   2
   3 // Original Code
   4 // https://github.com/KhronosGroup/glTF-Sample-Viewer/blob/glTF-WebGL-PBR/shaders/pbr-vert.glsl
   5 // Commit dc84b5e374fb3d23153d2248a338ef88173f9eb6
   6
   7 #define MORPH defined(MORPH_POSITION) || defined(MORPH_NORMAL) || defined(MORPH_TANGENT)
   8
   9 #ifdef HIGHP
  10   precision highp float;
  11 #else
  12   precision mediump float;
  13 #endif
  14
  15 in vec3 aPosition;
  16 in vec2 aTexCoord;
  17 in vec3 aNormal;
  18
  19 #ifdef VEC4_TANGENT
  20 in vec4 aTangent;
  21 #else
  22 in vec3 aTangent;
  23 #endif
  24
  25 in vec4 aVertexColor;
  26
  27 #ifdef MORPH
  28   uniform highp sampler2D sBlendShapeGeometry;
  29 #endif
  30
  31 out mediump vec2 vUV;
  32 out lowp mat3 vTBN;
  33 out lowp vec4 vColor;
  34 out highp vec3 vPositionToCamera;
  35
  36 uniform highp mat4 uViewMatrix;
  37 uniform mat3 uNormalMatrix;
  38 uniform mat4 uModelMatrix;
  39 uniform mat4 uProjection;
  40
  41 #ifdef SKINNING
  42   in vec4 aJoints;
  43   in vec4 aWeights;
  44   #define MAX_BONES 80
  45   uniform mat4 uBone[MAX_BONES];
  46   uniform mediump vec3 uYDirection;
  47 #endif
  48
  49 #ifdef MORPH
  50 #define MAX_BLEND_SHAPE_NUMBER 128
  51 uniform int uNumberOfBlendShapes;                                         ///< Total number of blend shapes loaded.
  52 uniform highp float uBlendShapeWeight[MAX_BLEND_SHAPE_NUMBER];            ///< The weight of each blend shape.
  53 #ifdef MORPH_VERSION_2_0
  54 uniform highp float uBlendShapeUnnormalizeFactor;                         ///< Factor used to unnormalize the geometry of the blend shape.
  55 #else
  56 uniform highp float uBlendShapeUnnormalizeFactor[MAX_BLEND_SHAPE_NUMBER]; ///< Factor used to unnormalize the geometry of the blend shape.
  57 #endif
  58 uniform highp int uBlendShapeComponentSize;                               ///< The size in the texture of either the vertices, normals or tangents. Used to calculate the offset to address them.
  59 #endif
  60
  61 // Shadow
  62 uniform lowp int uIsShadowEnabled;
  63 uniform highp mat4 uShadowLightViewProjectionMatrix;
  64 out highp vec3 positionFromLightView;
  65
  66 void main()
  67 {
  68   highp vec4 position = vec4(aPosition, 1.0);
  69   highp vec3 normal = aNormal;
  70   highp vec3 tangent = aTangent.xyz;
  71
  72 #ifdef MORPH
  73   int width = textureSize( sBlendShapeGeometry, 0 ).x;
  74
  75   highp int blendShapeBufferOffset = 0;
  76
  77   for( int index = 0; index < uNumberOfBlendShapes; ++index )
  78   {
  79     highp vec3 diff = vec3(0.0);
  80     highp int vertexId = 0;
  81     highp int x = 0;
  82     highp int y = 0;
  83     highp float weight = clamp(uBlendShapeWeight[index], 0.0, 1.0);
  84
  85 #ifdef MORPH_POSITION
  86     // Calculate the index to retrieve the geometry from the texture.
  87     vertexId = gl_VertexID + blendShapeBufferOffset;
  88     x = vertexId % width;
  89     y = vertexId / width;
  90
  91     // Retrieves the blend shape geometry from the texture, unnormalizes it and multiply by the weight.
  92     if(0.0 != weight)
  93     {
  94 #ifdef MORPH_VERSION_2_0
  95        highp float unnormalizeFactor = uBlendShapeUnnormalizeFactor;
  96 #else
  97        highp float unnormalizeFactor = uBlendShapeUnnormalizeFactor[index];
  98 #endif
  99
 100       diff = weight * unnormalizeFactor * ( texelFetch( sBlendShapeGeometry, ivec2(x, y), 0 ).xyz - 0.5 );
 101     }
 102
 103     position.xyz += diff;
 104
 105     blendShapeBufferOffset += uBlendShapeComponentSize;
 106 #endif
 107
 108 #ifdef MORPH_NORMAL
 109     // Calculate the index to retrieve the normal from the texture.
 110     vertexId = gl_VertexID + blendShapeBufferOffset;
 111     x = vertexId % width;
 112     y = vertexId / width;
 113
 114     // Retrieves the blend shape normal from the texture, unnormalizes it and multiply by the weight.
 115     if(0.0 != weight)
 116     {
 117       diff = weight * 2.0 * ( texelFetch( sBlendShapeGeometry, ivec2(x, y), 0 ).xyz - 0.5 );
 118     }
 119
 120     normal += diff.xyz;
 121
 122     blendShapeBufferOffset += uBlendShapeComponentSize;
 123 #endif
 124
 125 #ifdef MORPH_TANGENT
 126     // Calculate the index to retrieve the tangent from the texture.
 127     vertexId = gl_VertexID + blendShapeBufferOffset;
 128     x = vertexId % width;
 129     y = vertexId / width;
 130
 131     // Retrieves the blend shape tangent from the texture, unnormalizes it and multiply by the weight.
 132     if(0.0 != weight)
 133     {
 134       diff = weight * 2.0 * ( texelFetch( sBlendShapeGeometry, ivec2(x, y), 0 ).xyz - 0.5 );
 135     }
 136
 137     tangent += diff.xyz;
 138
 139     blendShapeBufferOffset += uBlendShapeComponentSize;
 140 #endif
 141   }
 142
 143 #endif
 144
 145 #ifdef SKINNING
 146   highp mat4 bone = uBone[int(aJoints.x)] * aWeights.x +
 147     uBone[int(aJoints.y)] * aWeights.y +
 148     uBone[int(aJoints.z)] * aWeights.z +
 149     uBone[int(aJoints.w)] * aWeights.w;
 150   position = bone * position;
 151   normal = uYDirection * (bone * vec4(normal, 0.0)).xyz;
 152   tangent = uYDirection * (bone * vec4(tangent, 0.0)).xyz;
 153
 154   highp vec4 positionW = position;
 155 #else
 156   highp vec4 positionW = uModelMatrix * position;
 157 #endif
 158   highp vec4 positionV = uViewMatrix * positionW;
 159
 160   vPositionToCamera = transpose(mat3(uViewMatrix)) * -vec3(positionV.xyz / positionV.w);
 161
 162   normal = normalize(normal);
 163   tangent = normalize(tangent);
 164   vec3 bitangent = cross(normal, tangent);
 165 #ifdef VEC4_TANGENT
 166   bitangent *= aTangent.w;
 167 #endif
 168   vTBN = mat3(uModelMatrix) * mat3(tangent, bitangent, normal);
 169
 170 #ifdef FLIP_V
 171   vUV = vec2(aTexCoord.x, 1.0 - aTexCoord.y);
 172 #else
 173   vUV = aTexCoord;
 174 #endif
 175
 176   vColor = aVertexColor;
 177
 178   positionFromLightView = vec3(1.0);
 179   if(uIsShadowEnabled > 0)
 180   {
 181     highp vec4 positionInLightView = uShadowLightViewProjectionMatrix * positionW;
 182     positionFromLightView = ((positionInLightView.xyz / positionInLightView.w) * 0.5) + vec3(0.5);
 183   }
 184
 185   gl_Position = uProjection * positionV;
 186 }