435 lines
13 KiB
JavaScript
435 lines
13 KiB
JavaScript
const island_vertecies = `
|
|
#include <common>
|
|
#include <shadowmap_pars_vertex>
|
|
|
|
varying vec3 vNormal;
|
|
varying vec3 vViewDir;
|
|
varying vec2 vUv;
|
|
varying vec3 FragPos;
|
|
|
|
void main() {
|
|
vUv = uv;
|
|
#include <beginnormal_vertex>
|
|
#include <defaultnormal_vertex>
|
|
|
|
#include <begin_vertex>
|
|
|
|
#include <worldpos_vertex>
|
|
#include <shadowmap_vertex>
|
|
|
|
vec4 modelPosition = modelMatrix * vec4(position, 1.0);
|
|
vec4 viewPosition = viewMatrix * modelPosition;
|
|
vec4 clipPosition = projectionMatrix * viewPosition;
|
|
|
|
vNormal = normalize(normal);
|
|
// vNormal = normalize(normalMatrix * normal);
|
|
vViewDir = normalize(-viewPosition.xyz);
|
|
|
|
FragPos = vec3(modelMatrix * vec4(position, 1.0));
|
|
|
|
gl_Position = clipPosition;
|
|
|
|
}
|
|
`;
|
|
const island_fragments = `
|
|
#include <common>
|
|
#include <packing>
|
|
#include <lights_pars_begin>
|
|
#include <shadowmap_pars_fragment>
|
|
#include <shadowmask_pars_fragment>
|
|
|
|
uniform sampler2D texture1;
|
|
uniform sampler2D texture2;
|
|
uniform sampler2D texture3;
|
|
uniform float intensity;
|
|
uniform float pointLightsPosX;
|
|
uniform float pointLightsPosY;
|
|
uniform float pointLightsPosZ;
|
|
|
|
varying vec3 vNormal;
|
|
varying vec3 FragPos;
|
|
varying vec2 vUv;
|
|
|
|
void main() {
|
|
vec3 pointLightsPos = vec3(9.0, 10.0, -16.0);
|
|
vec3 pointLightsColor = pointLights[0].color;
|
|
|
|
|
|
vec4 t1 = texture2D( texture1, vUv );
|
|
vec4 t2 = texture2D( texture2, vUv );
|
|
vec4 t3 = texture2D( texture3, vUv );
|
|
|
|
vec4 interrim = mix( t1, t2, t2.a );
|
|
vec4 interrim2 = mix( interrim, t3, t3.a );
|
|
|
|
// vec3 lightDir = normalize(pointLightsPos - FragPos);
|
|
vec3 lightDir = normalize(pointLightsPos);
|
|
|
|
float diff = max(dot(vNormal, -lightDir), 0.0);
|
|
vec3 diffuse = diff * pointLightsColor * interrim2.rgb;
|
|
|
|
vec3 result = ( (ambientLightColor + diffuse) / 14.0);
|
|
vec4 color = vec4(result, 1.0);
|
|
|
|
gl_FragColor = vec4(color);
|
|
}
|
|
`;
|
|
|
|
const palm_vertecies = `
|
|
#define STANDARD
|
|
uniform float uTime;
|
|
varying vec3 vViewPosition;
|
|
#ifdef USE_TRANSMISSION
|
|
varying vec3 vWorldPosition;
|
|
#endif
|
|
#include <common>
|
|
#include <uv_pars_vertex>
|
|
#include <uv2_pars_vertex>
|
|
#include <displacementmap_pars_vertex>
|
|
#include <color_pars_vertex>
|
|
#include <fog_pars_vertex>
|
|
#include <normal_pars_vertex>
|
|
#include <morphtarget_pars_vertex>
|
|
#include <skinning_pars_vertex>
|
|
#include <shadowmap_pars_vertex>
|
|
#include <logdepthbuf_pars_vertex>
|
|
#include <clipping_planes_pars_vertex>
|
|
|
|
|
|
void main() {
|
|
#include <uv_vertex>
|
|
#include <uv2_vertex>
|
|
#include <color_vertex>
|
|
#include <morphcolor_vertex>
|
|
#include <beginnormal_vertex>
|
|
#include <morphnormal_vertex>
|
|
#include <skinbase_vertex>
|
|
#include <skinnormal_vertex>
|
|
#include <defaultnormal_vertex>
|
|
#include <normal_vertex>
|
|
#include <begin_vertex>
|
|
#include <morphtarget_vertex>
|
|
#include <skinning_vertex>
|
|
#include <displacementmap_vertex>
|
|
#include <project_vertex>
|
|
#include <logdepthbuf_vertex>
|
|
#include <clipping_planes_vertex>
|
|
vViewPosition = - mvPosition.xyz;
|
|
#include <worldpos_vertex>
|
|
#include <shadowmap_vertex>
|
|
#include <fog_vertex>
|
|
|
|
vUv = uv;
|
|
|
|
vec3 delta = normal * sin(position.x * position.y * uTime * 0.0001) * 10.0;
|
|
vec3 newPosition = position + delta;
|
|
|
|
gl_Position = projectionMatrix * modelViewMatrix * vec4(newPosition, 1.0);
|
|
|
|
#ifdef USE_TRANSMISSION
|
|
vWorldPosition = worldPosition.xyz;
|
|
#endif
|
|
}`;
|
|
const palm_fragments = `
|
|
#define STANDARD
|
|
#ifdef PHYSICAL
|
|
#define IOR
|
|
#define SPECULAR
|
|
#endif
|
|
uniform vec3 diffuse;
|
|
uniform vec3 emissive;
|
|
uniform float roughness;
|
|
uniform float metalness;
|
|
uniform float opacity;
|
|
#ifdef IOR
|
|
uniform float ior;
|
|
#endif
|
|
#ifdef SPECULAR
|
|
uniform float specularIntensity;
|
|
uniform vec3 specularColor;
|
|
#ifdef USE_SPECULARINTENSITYMAP
|
|
uniform sampler2D specularIntensityMap;
|
|
#endif
|
|
#ifdef USE_SPECULARCOLORMAP
|
|
uniform sampler2D specularColorMap;
|
|
#endif
|
|
#endif
|
|
#ifdef USE_CLEARCOAT
|
|
uniform float clearcoat;
|
|
uniform float clearcoatRoughness;
|
|
#endif
|
|
#ifdef USE_IRIDESCENCE
|
|
uniform float iridescence;
|
|
uniform float iridescenceIOR;
|
|
uniform float iridescenceThicknessMinimum;
|
|
uniform float iridescenceThicknessMaximum;
|
|
#endif
|
|
#ifdef USE_SHEEN
|
|
uniform vec3 sheenColor;
|
|
uniform float sheenRoughness;
|
|
#ifdef USE_SHEENCOLORMAP
|
|
uniform sampler2D sheenColorMap;
|
|
#endif
|
|
#ifdef USE_SHEENROUGHNESSMAP
|
|
uniform sampler2D sheenRoughnessMap;
|
|
#endif
|
|
#endif
|
|
varying vec3 vViewPosition;
|
|
#include <common>
|
|
#include <packing>
|
|
#include <dithering_pars_fragment>
|
|
#include <color_pars_fragment>
|
|
#include <uv_pars_fragment>
|
|
#include <uv2_pars_fragment>
|
|
#include <map_pars_fragment>
|
|
#include <alphamap_pars_fragment>
|
|
#include <alphatest_pars_fragment>
|
|
#include <aomap_pars_fragment>
|
|
#include <lightmap_pars_fragment>
|
|
#include <emissivemap_pars_fragment>
|
|
#include <bsdfs>
|
|
#include <iridescence_fragment>
|
|
#include <cube_uv_reflection_fragment>
|
|
#include <envmap_common_pars_fragment>
|
|
#include <envmap_physical_pars_fragment>
|
|
#include <fog_pars_fragment>
|
|
#include <lights_pars_begin>
|
|
#include <normal_pars_fragment>
|
|
#include <lights_physical_pars_fragment>
|
|
#include <transmission_pars_fragment>
|
|
#include <shadowmap_pars_fragment>
|
|
#include <bumpmap_pars_fragment>
|
|
#include <normalmap_pars_fragment>
|
|
#include <clearcoat_pars_fragment>
|
|
#include <iridescence_pars_fragment>
|
|
#include <roughnessmap_pars_fragment>
|
|
#include <metalnessmap_pars_fragment>
|
|
#include <logdepthbuf_pars_fragment>
|
|
#include <clipping_planes_pars_fragment>
|
|
void main() {
|
|
#include <clipping_planes_fragment>
|
|
vec4 diffuseColor = vec4( diffuse, opacity );
|
|
ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
|
|
vec3 totalEmissiveRadiance = emissive;
|
|
#include <logdepthbuf_fragment>
|
|
#include <map_fragment>
|
|
#include <color_fragment>
|
|
#include <alphamap_fragment>
|
|
#include <alphatest_fragment>
|
|
#include <roughnessmap_fragment>
|
|
#include <metalnessmap_fragment>
|
|
#include <normal_fragment_begin>
|
|
#include <normal_fragment_maps>
|
|
#include <clearcoat_normal_fragment_begin>
|
|
#include <clearcoat_normal_fragment_maps>
|
|
#include <emissivemap_fragment>
|
|
#include <lights_physical_fragment>
|
|
#include <lights_fragment_begin>
|
|
#include <lights_fragment_maps>
|
|
#include <lights_fragment_end>
|
|
#include <aomap_fragment>
|
|
vec3 totalDiffuse = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;
|
|
vec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;
|
|
#include <transmission_fragment>
|
|
vec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;
|
|
#ifdef USE_SHEEN
|
|
float sheenEnergyComp = 1.0 - 0.157 * max3( material.sheenColor );
|
|
outgoingLight = outgoingLight * sheenEnergyComp + sheenSpecular;
|
|
#endif
|
|
#ifdef USE_CLEARCOAT
|
|
float dotNVcc = saturate( dot( geometry.clearcoatNormal, geometry.viewDir ) );
|
|
vec3 Fcc = F_Schlick( material.clearcoatF0, material.clearcoatF90, dotNVcc );
|
|
outgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + clearcoatSpecular * material.clearcoat;
|
|
#endif
|
|
#include <output_fragment>
|
|
#include <tonemapping_fragment>
|
|
#include <encodings_fragment>
|
|
#include <fog_fragment>
|
|
#include <premultiplied_alpha_fragment>
|
|
#include <dithering_fragment>
|
|
}
|
|
`;
|
|
const particle_vertecies = `
|
|
attribute float rots;
|
|
varying float vRots;
|
|
varying vec3 pos;
|
|
varying vec2 vUv;
|
|
uniform float time;
|
|
attribute float size;
|
|
uniform float scale;
|
|
#include <common>
|
|
#include <color_pars_vertex>
|
|
#include <fog_pars_vertex>
|
|
#include <morphtarget_pars_vertex>
|
|
#include <logdepthbuf_pars_vertex>
|
|
#include <clipping_planes_pars_vertex>
|
|
|
|
vec3 mod289(vec3 x) {
|
|
return x - floor(x * (1.0 / 289.0)) * 289.0;
|
|
}
|
|
|
|
vec4 mod289(vec4 x) {
|
|
return x - floor(x * (1.0 / 289.0)) * 289.0;
|
|
}
|
|
|
|
vec4 permute(vec4 x) {
|
|
return mod289(((x*34.0)+1.0)*x);
|
|
}
|
|
|
|
vec4 taylorInvSqrt(vec4 r)
|
|
{
|
|
return 1.79284291400159 - 0.85373472095314 * r;
|
|
}
|
|
|
|
float snoise(vec3 v) {
|
|
const vec2 C = vec2(1.0/6.0, 1.0/3.0) ;
|
|
const vec4 D = vec4(0.0, 0.5, 1.0, 2.0);
|
|
|
|
// First corner
|
|
vec3 i = floor(v + dot(v, C.yyy) );
|
|
vec3 x0 = v - i + dot(i, C.xxx) ;
|
|
|
|
// Other corners
|
|
vec3 g = step(x0.yzx, x0.xyz);
|
|
vec3 l = 1.0 - g;
|
|
vec3 i1 = min( g.xyz, l.zxy );
|
|
vec3 i2 = max( g.xyz, l.zxy );
|
|
|
|
// x0 = x0 - 0.0 + 0.0 * C.xxx;
|
|
// x1 = x0 - i1 + 1.0 * C.xxx;
|
|
// x2 = x0 - i2 + 2.0 * C.xxx;
|
|
// x3 = x0 - 1.0 + 3.0 * C.xxx;
|
|
vec3 x1 = x0 - i1 + C.xxx;
|
|
vec3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y
|
|
vec3 x3 = x0 - D.yyy; // -1.0+3.0*C.x = -0.5 = -D.y
|
|
|
|
// Permutations
|
|
i = mod289(i);
|
|
vec4 p = permute( permute( permute(
|
|
i.z + vec4(0.0, i1.z, i2.z, 1.0 ))
|
|
+ i.y + vec4(0.0, i1.y, i2.y, 1.0 ))
|
|
+ i.x + vec4(0.0, i1.x, i2.x, 1.0 ));
|
|
|
|
// Gradients: 7x7 points over a square, mapped onto an octahedron.
|
|
// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
|
|
float n_ = 0.142857142857; // 1.0/7.0
|
|
vec3 ns = n_ * D.wyz - D.xzx;
|
|
|
|
vec4 j = p - 49.0 * floor(p * ns.z * ns.z); // mod(p,7*7)
|
|
|
|
vec4 x_ = floor(j * ns.z);
|
|
vec4 y_ = floor(j - 7.0 * x_ ); // mod(j,N)
|
|
|
|
vec4 x = x_ *ns.x + ns.yyyy;
|
|
vec4 y = y_ *ns.x + ns.yyyy;
|
|
vec4 h = 1.0 - abs(x) - abs(y);
|
|
|
|
vec4 b0 = vec4( x.xy, y.xy );
|
|
vec4 b1 = vec4( x.zw, y.zw );
|
|
|
|
//vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
|
|
//vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
|
|
vec4 s0 = floor(b0)*2.0 + 1.0;
|
|
vec4 s1 = floor(b1)*2.0 + 1.0;
|
|
vec4 sh = -step(h, vec4(0.0));
|
|
|
|
vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
|
|
vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;
|
|
|
|
vec3 p0 = vec3(a0.xy,h.x);
|
|
vec3 p1 = vec3(a0.zw,h.y);
|
|
vec3 p2 = vec3(a1.xy,h.z);
|
|
vec3 p3 = vec3(a1.zw,h.w);
|
|
|
|
// Normalise gradients
|
|
vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
|
|
p0 *= norm.x;
|
|
p1 *= norm.y;
|
|
p2 *= norm.z;
|
|
p3 *= norm.w;
|
|
|
|
// Mix final noise value
|
|
vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
|
|
m = m * m;
|
|
return 42.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1),
|
|
dot(p2,x2), dot(p3,x3) ) );
|
|
}
|
|
|
|
void main() {
|
|
#include <color_vertex>
|
|
#include <morphcolor_vertex>
|
|
#include <begin_vertex>
|
|
#include <morphtarget_vertex>
|
|
#include <project_vertex>
|
|
gl_PointSize = size;
|
|
pos = position;
|
|
float noiseFreq = 3.5;
|
|
float noiseAmp = 0.15;
|
|
vec3 noisePos = vec3(pos.x * noiseFreq + ${Math.random() * 0.5 + 0.1}, pos.y, pos.z);
|
|
gl_Position.x += snoise(noisePos) * noiseAmp * 10.0;
|
|
gl_Position.y += snoise(noisePos) * noiseAmp * 1.0;
|
|
#ifdef USE_SIZEATTENUATION
|
|
bool isPerspective = isPerspectiveMatrix( projectionMatrix );
|
|
if ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );
|
|
#endif
|
|
#include <logdepthbuf_vertex>
|
|
#include <clipping_planes_vertex>
|
|
#include <worldpos_vertex>
|
|
#include <fog_vertex>
|
|
vRots = rots;
|
|
}
|
|
`;
|
|
const particle_fragments = `
|
|
varying float vRots;
|
|
uniform sampler2D tDiffuse;
|
|
varying vec2 vUv;
|
|
uniform vec3 diffuse;
|
|
uniform float opacity;
|
|
varying vec3 pos;
|
|
|
|
#include <common>
|
|
#include <color_pars_fragment>
|
|
#include <map_particle_pars_fragment>
|
|
#include <alphatest_pars_fragment>
|
|
#include <fog_pars_fragment>
|
|
#include <logdepthbuf_pars_fragment>
|
|
#include <clipping_planes_pars_fragment>
|
|
|
|
// float rand(vec2 co)
|
|
// {
|
|
// float a = 12.9898;
|
|
// float b = 78.233;
|
|
// float c = 43758.5453;
|
|
// float dt= dot(co.xy ,vec2(a,b));
|
|
// float sn= mod(dt,3.14);
|
|
// return fract(sin(sn) * c);
|
|
// }
|
|
|
|
void main() {
|
|
#include <clipping_planes_fragment>
|
|
vec3 outgoingLight = vec3( 0.0 );
|
|
vec4 diffuseColor = vec4( diffuse, opacity );
|
|
|
|
if ( length( gl_PointCoord - vec2( 0.5, 0.5 ) ) > 0.475 ) discard;
|
|
|
|
// outgoingLight = diffuseColor.rgb + sin(rand(vec2( time, time) ) );
|
|
// gl_FragColor.a = 0.1;
|
|
// gl_FragColor = texture2D(tDiffuse, vUv);
|
|
// gl_FragColor.r = 256.0;
|
|
// gl_FragColor.g = 256.0;
|
|
// gl_FragColor = diffuseColor;
|
|
|
|
#include <logdepthbuf_fragment>
|
|
#include <map_particle_fragment>
|
|
#include <color_fragment>
|
|
#include <alphatest_fragment>
|
|
|
|
outgoingLight = diffuseColor.rgb + rand(vec2( pos.x, pos.y) ) ;
|
|
|
|
#include <output_fragment>
|
|
#include <tonemapping_fragment>
|
|
#include <encodings_fragment>
|
|
#include <fog_fragment>
|
|
#include <premultiplied_alpha_fragment>
|
|
}
|
|
` |