export const shader = {
  vertex: `
		uniform vec3 color;
		varying vec3 pixelNormal;
		
		void main() {
			
			pixelNormal = normal;
			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
			
		}`,

  vertexClipping: `
		uniform vec3 color;
		uniform vec3 clippingLow;
		uniform vec3 clippingHigh;
		
		varying vec3 pixelNormal;
		varying vec4 worldPosition;
		varying vec3 camPosition;
		varying vec3 vNormal;
		varying vec3 vPosition;
		varying vec2 vUv;
		
		void main() {
			vUv = uv;
			vec4 vPos = modelViewMatrix * vec4( position, 1.0 );
			vPosition = vPos.xyz;

			vNormal = normalMatrix * normal;
			pixelNormal = normal;
			worldPosition = modelMatrix * vec4( position, 1.0 );
			camPosition = cameraPosition;
			
			// gl_Position = projectionMatrix * vPos;
			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
			
		}`,

  fragment: `
		uniform vec3 color;
		varying vec3 pixelNormal;

		varying vec3 vNormal;
		varying vec3 vPosition;

		// uniform vec3 spotLightPosition; // in world space		
		// uniform vec3 clight;
		// uniform vec3 cspec;
		// uniform float roughness;
		const float PI = 3.14159;
		
		
		void main( void ) {
			
			float shade = (
				  3.0 * pow ( abs ( pixelNormal.y ), 2.0 )
				+ 2.0 * pow ( abs ( pixelNormal.z ), 2.0 )
				+ 1.0 * pow ( abs ( pixelNormal.x ), 2.0 )
			) / 3.0;

			gl_FragColor = vec4( color * shade, 1.0 );
			//gl_FragColor = vec4(color, 1.0);
			
			// vec4 lPosition = viewMatrix * vec4( spotLightPosition, 1.0 );
			// vec3 l = normalize(lPosition.xyz - vPosition.xyz);			
			// vec3 n = normalize( vNormal );  // interpolation destroys normalization, so we have to normalize
			// vec3 v = normalize( -vPosition);
			// vec3 h = normalize( v + l);
					
			// // small quantity to prevent divisions by 0
			// float nDotl = max(dot( n, l ),0.000001);
			// float lDoth = max(dot( l, h ),0.000001);			
			// float nDoth = max(dot( n, h ),0.000001);			
			// float vDoth = max(dot( v, h ),0.000001);			
			// float nDotv = max(dot( n, v ),0.000001);
			
			// vec3 specularBRDF = FSchlick(lDoth)*GSmith(nDotv,nDotl)*DGGX(nDoth,roughness*roughness)/(4.0*nDotl*nDotv);	
			// vec3 outRadiance = (PI* clight * nDotl * specularBRDF);			
			
			// gl_FragColor = vec4(pow( outRadiance, vec3(1.0/2.2)), 1.0);		
			
		}`,

  fragmentClippingFront: `
		uniform sampler2D map;
		uniform vec3 color;
		uniform vec3 clippingLow;
		uniform vec3 clippingHigh;
		uniform float clippingScale;
		uniform float percent;
		
		varying vec3 pixelNormal;
		varying vec4 worldPosition;
		varying vec3 camPosition;
		varying vec2 vUv;
		
		void main( void ) {
			
			float shade = (
				  3.0 * pow ( abs ( pixelNormal.y ), 2.0 )
				+ 2.0 * pow ( abs ( pixelNormal.z ), 2.0 )
				+ 1.0 * pow ( abs ( pixelNormal.x ), 2.0 )
			) / 3.0;
			
			if (
				   worldPosition.x < clippingLow.x  
				|| worldPosition.x > clippingHigh.x 
				|| worldPosition.y < clippingLow.y  
				|| worldPosition.y > clippingHigh.y
				|| worldPosition.z < (clippingLow.z * clippingScale)
				|| worldPosition.z >  (clippingHigh.z * clippingScale)
			 ) {
				discard;
			} else {
				gl_FragColor = texture2D(map, vUv);
				gl_FragColor.a = percent;
			}
			
		}`,

  vertexMeshStandard: `
  		#define STANDARD

		varying vec3 vViewPosition;
		varying vec4 worldPosition;

		#include <common>
		#include <uv_pars_vertex>
		#include <color_pars_vertex>
		#include <fog_pars_vertex>
		#include <shadowmap_pars_vertex>
		#include <logdepthbuf_pars_vertex>
		#include <clipping_planes_pars_vertex>

		void main() {
    		#include <uv_vertex>
    		#include <color_vertex>

    		#include <beginnormal_vertex>
    		#include <defaultnormal_vertex>

    		#include <begin_vertex>
    		#include <project_vertex>
    		#include <logdepthbuf_vertex>
    		#include <clipping_planes_vertex>

    		vViewPosition = -mvPosition.xyz;

    		worldPosition = modelMatrix * vec4(position, 1.0);

    		#include <shadowmap_vertex>
    		#include <fog_vertex>
		}
		`,

  fragmentClippingMeshStandard: `
 		#define STANDARD

 		uniform vec3 diffuse;
 		uniform vec3 emissive;
 		uniform float roughness;
 		uniform float metalness;
 		uniform float opacity;

 		varying vec3 vViewPosition;
 		varying vec4 worldPosition;

 		uniform vec3 clippingLow;
 		uniform vec3 clippingHigh;		
 		uniform float clippingScale;

 		#include <common>
 		#include <packing>
 		#include <dithering_pars_fragment>
 		#include <color_pars_fragment>
 		#include <uv_pars_fragment>
 		#include <map_pars_fragment>
 		#include <alphamap_pars_fragment>
 		#include <aomap_pars_fragment>
 		#include <emissivemap_pars_fragment>
 		#include <bsdfs>
 		#include <transmission_pars_fragment>
 		#include <envmap_physical_pars_fragment>
 		#include <fog_pars_fragment>
 		#include <lights_pars_begin>
 		#include <lights_physical_pars_fragment>
 		#include <shadowmap_pars_fragment>
 		#include <normalmap_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;
  
	 		#ifdef TRANSMISSION
				 float totalTransmission = transmission;
				 float thicknessFactor = thickness;
	 		#endif
  
	 		#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 <emissivemap_fragment>
  
	 		vec3 rawDiffuseColor = diffuseColor.rgb;
	 		#include <transmission_fragment>
  
	 		// Lighting calculations
	 		#include <lights_physical_fragment>
	 		#include <lights_fragment_maps>
  
	 		// Ambient occlusion
	 		#include <aomap_fragment>
  
	 		vec3 outgoingLight = reflectedLight.directDiffuse 
								 + reflectedLight.indirectDiffuse 
								 + reflectedLight.directSpecular 
								 + reflectedLight.indirectSpecular 
								 + totalEmissiveRadiance;
  
	 		// Clipping logic
	 		if (any(greaterThan(worldPosition.xyz, clippingHigh)) || any(lessThan(worldPosition.xyz, clippingLow))) {
				discard;
	 		}
  
		gl_FragColor = vec4(outgoingLight, diffuseColor.a);
  }
  `,

  invisibleVertexShader: `
		void main() {
			vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
			gl_Position = projectionMatrix * mvPosition;
		}`,

  invisibleFragmentShader: `
		void main( void ) {
			gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );
			discard;
		}`,
};