Where is the procedural water script?


#1

Franny i think and soem otehrs use procedural water script. but cannot find it back on the forum. Possible somewhere hidden in other topic with wrong words.

Anybody know where it’s hidden on the forum., i hope the same page explain how to use it.


#2

@Richardus.Raymaker This may be what you’re looking for in the forums: https://alphas.highfidelity.io/t/some-inspiration-for-water-ocean/6148

Haven’t tried out water myself.


#3

Thanks david, but it’s not the water one i have seen. It’s the page about this one. i know on the forum there’s more info. https://www.shadertoy.com/view/MdlXz8


#4

@Richardus.Raymaker This one?
https://alphas.highfidelity.io/t/random-picture-thread/244/3036

https://dl.dropboxusercontent.com/u/48725104/water4.fs


#5

https://dl.dropboxusercontent.com/u/48725104/water4.fs
that seems to match what I used.
Good luck!


#6

The dropbox link doesn’t work for me - but maybe someone still have a copy of that script for me? I am looking for a solution to get a animated water/ocean similar to SL.


#7

This one works, but has really heavy seas.

The method is to create a zone, make it big, set the background mode to Skybox.

Create a blank text file and call it water.fs (anything dot fs)
paste the code below, save, upload to your webserver, save the URL.

/***********************************************************************************
* Shader: seascape_clouds
* Author: Juels Dreki
* Sources: For details look into the function comments.
*
* Noise based on Morgan (BSD license).
*
* Clouds based on Mark Sleith
*
* seascape based on Alexander Alekseev and Alpha​VersionD
* License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
************************************************************************************/
#line 2

//#define CLOUD_COVER	0.75
#define CLOUD_COVER		0.65
#define CLOUD_SHARPNESS	0.035

//Resolution X, Y, Z (ratio , by default 1.0)
vec3 iResolution = vec3(iWorldScale.xz, 1.0);
vec2 mouse = vec2(0);

// We set the seconds of time to iGlobalTime, which contains the current date in seconds
//float time = iGlobalTime;
float time = iGlobalTime*2.0;

const int NUM_STEPS = 8;
const float PI	 	= 3.1415;
const float EPSILON	= 1e-3;
float EPSILON_NRM	= 0.1 / 1024.;

// sea
const int ITER_GEOMETRY = 3;
const int ITER_FRAGMENT = 5;
const float SEA_HEIGHT = 0.6;
const float SEA_CHOPPY = 4.0;
//const float SEA_SPEED = 0.26;
const float SEA_SPEED = 0.8;
const float SEA_FREQ = 0.16;
const vec3 SEA_BASE = vec3(0.1,0.19,0.22);
const vec3 SEA_WATER_COLOR = vec3(0.8,0.9,0.6);
float SEA_TIME = iGlobalTime * SEA_SPEED;
mat2 octave_m = mat2(1.6,1.2,-1.2,1.6);

/***************************************************************************************
* Based on Morgan
* https://www.shadertoy.com/view/4dS3Wd
* https://github.com/tangrams/GLSL-live-editor/blob/master/glsl/raymarchingSphere.frag
****************************************************************************************/
float random (in float _x) {
    return fract(sin(_x)*1e4);
}

/***************************************************************************************
* Based on Morgan
* https://www.shadertoy.com/view/4dS3Wd
* https://github.com/tangrams/GLSL-live-editor/blob/master/glsl/raymarchingSphere.frag
****************************************************************************************/
float noise_clouds (in vec3 _p) {
    const vec3 step = vec3(110.0, 241.0, 171.0);

    vec3 i = floor(_p);
    vec3 f = fract(_p);
 
    // For performance, compute the base input to a 1D random from the integer part of the argument and the 
    // incremental change to the 1D based on the 3D -> 1D wrapping
    float n = dot(i, step);

    vec3 u = f * f * (3.0 - 2.0 * f);
    return mix(mix(mix( random(n + dot(step, vec3(0, 0, 0))), random(n + dot(step, vec3(1, 0, 0))), u.x),
                   mix( random(n + dot(step, vec3(0, 1, 0))), random(n + dot(step, vec3(1, 1, 0))), u.x), u.y),
               mix(mix( random(n + dot(step, vec3(0, 0, 1))), random(n + dot(step, vec3(1, 0, 1))), u.x),
                   mix( random(n + dot(step, vec3(0, 1, 1))), random(n + dot(step, vec3(1, 1, 1))), u.x), u.y), u.z);
}

/***************************************************************************************
* Based on Morgan
* https://www.shadertoy.com/view/4dS3Wd
* https://github.com/tangrams/GLSL-live-editor/blob/master/glsl/raymarchingSphere.frag
****************************************************************************************/
float fbm ( in vec3 _p) {
    float v = 0.0;
    float a = 0.5;
    vec3 shift = vec3(100);
    //for (int i = 0; i < NUM_OCTAVES; ++i) {
    for (int i = 0; i < 8; ++i) {
        v += a * noise_clouds(_p);
        _p = _p * 2.0 + shift;
        a *= 0.5;
    }
    return v;
}

/**************************************************************************************
* Based on:
* @title 	Cloud Demo 
* @version 	v0.3
* @author 	Mark Sleith
* @website 	www.cngames.co.uk/portfolio
* @date 	15/08/2012
*
* @note	Noise and fBm from iq's latest live coding video, "a simple eye ball". (originally)
*
* @todo	Add varying cloud density, cloud illumination.
* purtified a bit by psonice
****************************************************************************************/
void calculateClouds( out float f, out float f2, in vec3 fragCoord ) {
	
	// Wind - Used to animate the clouds
	vec3 wind_vec = vec3(0.001 + time*0.01, 1.0 ,0.003 + time * 0.01);

	// Set up domain
	vec3 q = ( fragCoord.xyz / iResolution.xyz );
	vec3 p = -1.0 + 3.0 * q + wind_vec;

	// Fix aspect ratio
	p.x *= iResolution.x / iResolution.y;

	// Create noise using fBm
	f = fbm(4.0*p);
	f2 = fbm(p);
	
	float cover = CLOUD_COVER + sin(q.x * 8. - time * .2) *.15 + sin(q.y * 6. - time * .1) * .25;
	float sharpness = CLOUD_SHARPNESS;
	
	float c = f - (1.0 - cover);
	if ( c < 0.0 )
		c = 0.0;
	
	f = 1.0 - (pow(sharpness, c));
	f2 = 1.0 - (pow(sharpness, c));
}

/*******************************************************************************************
* Based on:
* "Seascape" by Alexander Alekseev aka TDM - 2014
* License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
********************************************************************************************/
mat3 fromEuler(vec3 ang) {
	vec2 a1 = vec2(sin(ang.x),cos(ang.x));
    vec2 a2 = vec2(sin(ang.y),cos(ang.y));	
    vec2 a3 = vec2(sin(ang.z),cos(ang.z));
    mat3 m;
    m[0] = vec3(a1.y*a3.y+a1.x*a2.x*a3.x,a1.y*a2.x*a3.x+a3.y*a1.x,-a2.y*a3.x);
	m[1] = vec3(-a2.y*a1.x,a1.y*a2.y,a2.x);
	m[2] = vec3(a3.y*a1.x*a2.x+a1.y*a3.x,a1.x*a3.x-a1.y*a3.y*a2.x,a2.y*a3.y);
	return m;
}

/*******************************************************************************************
* Based on:
* "Seascape" by Alexander Alekseev aka TDM - 2014
* License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
********************************************************************************************/
float hash( vec2 p ) {
	float h = dot(p,vec2(127.1,311.7));	
    return fract(sin(h)*43758.5453123);
}

/*******************************************************************************************
* Based on:
* "Seascape" by Alexander Alekseev aka TDM - 2014
* License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
********************************************************************************************/
float noise_ocean( in vec2 p ) {
    vec2 i = floor( p );
    vec2 f = fract( p );	
	vec2 u = f*f*(3.0-2.0*f);
    return -1.0+2.0*mix( mix( hash( i + vec2(0.0,0.0) ), 
                     hash( i + vec2(1.0,0.0) ), u.x),
                mix( hash( i + vec2(0.0,1.0) ), 
                     hash( i + vec2(1.0,1.0) ), u.x), u.y);
}

/*******************************************************************************************
* Based on:
* "Seascape" by Alexander Alekseev aka TDM - 2014
* License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
********************************************************************************************/
float diffuse(vec3 n,vec3 l,float p) {
    return pow(dot(n,l) * 0.4 + 0.6,p);
}

/*******************************************************************************************
* Based on:
* "Seascape" by Alexander Alekseev aka TDM - 2014
* License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
********************************************************************************************/
float specular(vec3 n,vec3 l,vec3 e,float s) {    
    float nrm = (s + 8.0) / (3.1415 * 8.0);
    return pow(max(dot(reflect(e,n),l),0.0),s) * nrm;
}

/*******************************************************************************************
* Based on:
* "Seascape" by Alexander Alekseev aka TDM - 2014
* License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
********************************************************************************************/
vec3 getSkyColor(vec3 e)
{
    e.y = max(e.y,0.0);
    vec3 ret;
    ret.x = pow(1.0-e.y,2.0);
    ret.y = 1.0-e.y;
    ret.z = 0.6+(1.0-e.y)*0.4;
	
	float f,f2;
	calculateClouds(f,f2,e);
	
	ret = mix( ret, vec3(1.0), f );		
	ret = mix( ret, vec3(0.55), 0.5*f2 );		
	
    return ret;
}

/*******************************************************************************************
* Based on:
* "Seascape" by Alexander Alekseev aka TDM - 2014
* License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
********************************************************************************************/
float sea_octave(vec2 uv, float choppy) {
    uv += noise_ocean(uv);        
    vec2 wv = 1.0-abs(sin(uv));
    vec2 swv = abs(cos(uv));    
    wv = mix(wv,swv,wv);
    return pow(1.0-pow(wv.x * wv.y,0.65),choppy);
}

/*******************************************************************************************
* Based on:
* "Seascape" by Alexander Alekseev aka TDM - 2014
* License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
********************************************************************************************/
float map(vec3 p) {
    float freq = SEA_FREQ;
    float amp = SEA_HEIGHT;
    float choppy = SEA_CHOPPY;
    vec2 uv = p.xz; uv.x *= 0.75;
    
    float d, h = 0.0;    
    for(int i = 0; i < ITER_GEOMETRY; i++) {        
    	d = sea_octave((uv+SEA_TIME)*freq,choppy);
    	d += sea_octave((uv-SEA_TIME)*freq,choppy);
        h += d * amp;        
    	uv *= octave_m; freq *= 1.9; amp *= 0.22;
        choppy = mix(choppy,1.0,0.2);
    }
    return p.y - h;
}

/*******************************************************************************************
* Based on:
* "Seascape" by Alexander Alekseev aka TDM - 2014
* License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
********************************************************************************************/
float map_detailed(vec3 p) {
    float freq = SEA_FREQ;
    float amp = SEA_HEIGHT;
    float choppy = SEA_CHOPPY;
    vec2 uv = p.xz; uv.x *= 0.75;
    
    float d, h = 0.0;    
    for(int i = 0; i < ITER_FRAGMENT; i++) {        
    	d = sea_octave((uv+SEA_TIME)*freq,choppy);
    	d += sea_octave((uv-SEA_TIME)*freq,choppy);
        h += d * amp;        
    	uv *= octave_m; freq *= 1.9; amp *= 0.22;
        choppy = mix(choppy,1.0,0.2);
    }
    return p.y - h;
}

/*******************************************************************************************
* Based on:
* "Seascape" by Alexander Alekseev aka TDM - 2014
* License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
********************************************************************************************/
vec3 getSeaColor(vec3 p, vec3 n, vec3 l, vec3 eye, vec3 dist) {  
    float fresnel = 1.0 - max(dot(n,-eye),0.0);
    fresnel = pow(fresnel,3.0) * 0.65;
        
    vec3 reflected = getSkyColor(reflect(eye,n));    
    vec3 refracted = SEA_BASE + diffuse(n,l,80.0) * SEA_WATER_COLOR * 0.12; 
    
    vec3 color = mix(refracted,reflected,fresnel);
    
    float atten = max(1.0 - dot(dist,dist) * 0.001, 0.0);
    color += SEA_WATER_COLOR * (p.y - SEA_HEIGHT) * 0.18 * atten;
    
    color += vec3(specular(n,l,eye,60.0));
    
    return color;
}

/*******************************************************************************************
* Based on:
* "Seascape" by Alexander Alekseev aka TDM - 2014
* License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
********************************************************************************************/
vec3 getNormal(vec3 p, float eps) {
    vec3 n;
    n.y = map_detailed(p);    
    n.x = map_detailed(vec3(p.x+eps,p.y,p.z)) - n.y;
    n.z = map_detailed(vec3(p.x,p.y,p.z+eps)) - n.y;
    n.y = eps;
    return normalize(n);
}

/*******************************************************************************************
* Based on:
* "Seascape" by Alexander Alekseev aka TDM - 2014
* License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
********************************************************************************************/
float heightMapTracing(vec3 ori, vec3 dir, out vec3 p) {  
    float tm = 0.0;
    float tx = 1000.0;    
    float hx = map(ori + dir * tx);
    if(hx > 0.0) return tx;   
    float hm = map(ori + dir * tm);    
    float tmid = 0.0;
    for(int i = 0; i < NUM_STEPS; i++) {
        tmid = mix(tm,tx, hm/(hm-hx));                   
        p = ori + dir * tmid;                   
    	float hmid = map(p);
		if(hmid < 0.0) {
        	tx = tmid;
            hx = hmid;
        } else {
            tm = tmid;
            hm = hmid;
        }
    }
    return tmid;
}

/*******************************************************************************************
* Based on:
* "Seascape" by Alexander Alekseev aka TDM - 2014
* License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
*
* modified by: Alpha​VersionD
* http://metaversecafe.com/HighFidelity/QueenCity/shaders/oceanSkybox_v4.fs
********************************************************************************************/
vec3 getSkyboxColor(){
	vec2 uv = _normal.xy;
    float time = iGlobalTime / 1000.;        
    // ray
    vec3 ang = vec3(0.0,0.0,0.5);    
    vec3 ori = vec3(0.0,3.5,time*5.0);
    vec3 dir = normalize(_normal);	
    dir = normalize(dir) * fromEuler(ang);
    
    // tracing
    vec3 p;
    heightMapTracing(ori,dir,p);
    vec3 dist = p - ori;
    vec3 n = getNormal(p, dot(dist,dist) * EPSILON_NRM);
    vec3 light = normalize(vec3(0.0,1.0,0.8)); 
             
    // color
    vec3 color = mix(
        getSkyColor(dir),
        getSeaColor(p,n,light,dir,dist),
    	pow(smoothstep(0.0,-0.05,dir.y),0.3));
        
    // post
	vec4 fragColor = vec4(0.0);
	fragColor = vec4(pow(color,vec3(0.75)), 1.0);
	
	return fragColor.rgb;
}

Now put the following little bit of code into the User Data section of the zone entity edit window. Replacing your-full-url with the url you uploaded the script to.
{
“ProceduralEntity”:{
“shaderUrl”:“your-full-url/water.fs”
}
}


#8

u spellud mah naime wrong. :smiley:

https://alphas.highfidelity.io/t/seascape-skybox-hang-ten-in-hifi/7212

hifi://open


#9

Hi Adrian, thanks for posting the script - and AlphaVersionD for scripting it :sunny: !