constructor(octaves,falloff,zoom,zZoom,xOff,yOff,zOff){

this.octaves = octaves || 4;

this.falloff = falloff || 0.5;

this.zoom = zoom || 100;

this.zZoom = zZoom || this.zoom;

this.xOff = xOff || 0;

this.yOff = yOff || 0;

this.zOff = zOff || 0;

}

get(x,y,z,xo,yo,zo){

x = x || 0;

y = y || 0;

z = z || 0;

xo = xo!==undefined ? xo : this.xOff;

yo = yo!==undefined ? yo : this.yOff;

zo = zo!==undefined ? zo : this.zOff;

noiseDetail(this.octaves,this.falloff);

return noise(x/this.zoom+xo,y/this.zoom+yo,z/this.zZoom+zo);

}

constructor(basin,field,index,loadData,octaves,falloff,zoom,zZoom,wMax,zWMax,wRFac){

let r = NC_OFFSET_RANDOM_FACTOR;

super(octaves,falloff,zoom,zZoom,random(r),random(r),random(r));

this.wobbleMax = wMax || 1;

this.zWobbleMax = zWMax || this.wobbleMax;

this.wobbleRotFactor = wRFac || PI/16;

this.wobbleVector = p5.Vector.random2D();

this.basin = basin instanceof Basin && basin;

this.field = field;

this.index = index;

if(loadData instanceof LoadData) this.load(loadData);

}

get(x,y,z){

let o = this.fetchOffsets(z);

if(!o) throw ENVDATA_NOT_FOUND_ERROR;

let {xo, yo, zo} = o;

return super.get(x,y,z,xo,yo,zo);

}

fetchOffsets(t){

let basin = this.basin;

if(t>=basin.tick) return {

xo: this.xOff,

yo: this.yOff,

zo: this.zOff

};

else{

t = floor(t/ADVISORY_TICKS)*ADVISORY_TICKS;

let s = basin.getSeason(t);

t = (t-basin.seasonTick(s))/ADVISORY_TICKS;

let d = basin.fetchSeason(s);

if(d && d.envData && d.envData[this.field] && d.envData[this.field][this.index]){

t -= d.envData[this.field][this.index].recordStart;

if(t >= 0){

let o = d.envData[this.field][this.index].val[t];

return {

xo: o.x,

yo: o.y,

zo: o.z

};

}

}

}

}

wobble(){

let v = this.wobbleVector;

v.setMag(random(0.0001,this.wobbleMax));

this.xOff += v.x/this.zoom;

this.yOff += v.y/this.zoom;

this.zOff += random(-this.zWobbleMax,this.zWobbleMax)/this.zZoom;

v.rotate(random(-this.wobbleRotFactor,this.wobbleRotFactor));

}

record(){

let basin = this.basin;

let seas = basin.fetchSeason(-1,true,true);

let s = seas;

// let startingRecord;

if(!s.envData){

s.envData = {};

// startingRecord = true;

}

s = s.envData;

if(!s[this.field]){

s[this.field] = {};

// startingRecord = true;

}

s = s[this.field];

if(!s[this.index]){

s[this.index] = {

val: [],

recordStart: floor(basin.tick/ADVISORY_TICKS)-basin.seasonTick()/ADVISORY_TICKS

};

// startingRecord = true;

}

s = s[this.index].val;

// if(startingRecord) seas.envRecordStarts = floor(basin.tick/ADVISORY_TICKS)-basin.seasonTick()/ADVISORY_TICKS;

s.push({

x: this.xOff,

y: this.yOff,

z: this.zOff

});

seas.modified = true;

}

save(){

let obj = {};

let w = obj.wobbleVector = {};

w.x = this.wobbleVector.x;

w.y = this.wobbleVector.y;

for(let p of ['xOff','yOff','zOff']) obj[p] = this[p];

return obj;

}

load(data){

if(data instanceof LoadData){

let wx;

let wy;

if(data.format>=FORMAT_WITH_INDEXEDDB){

let obj = data.value;

for(let p of ['xOff','yOff','zOff']) if(obj[p]) this[p] = obj[p];

wx = obj.wobbleVector && obj.wobbleVector.x;

wy = obj.wobbleVector && obj.wobbleVector.y;

}else{

let str = data.value;

let arr = decodeB36StringArray(str);

this.xOff = arr.pop() || this.xOff;

this.yOff = arr.pop() || this.yOff;

this.zOff = arr.pop() || this.zOff;

wx = arr.pop();

wy = arr.pop();

}

if(wx!==undefined && wy!==undefined) this.wobbleVector = createVector(wx,wy);

}

}

constructor(basin,name,loadData,attribs){

this.basin = basin instanceof Basin && basin;

this.name = name;

if(attribs.displayName)

this.displayName = attribs.displayName;

else

this.displayName = name;

this.noise = [];

this.accurateAfter = -1;

this.version = attribs.version;

if(loadData instanceof LoadData && loadData.value){

if(loadData.value.version!==this.version) this.accurateAfter = this.basin.tick;

else this.accurateAfter = loadData.value.accurateAfter;

}

this.isVectorField = attribs.vector;

this.noVectorFlip = attribs.noVectorFlip; // do not reflect the output vector over the y-axis in the southern hemisphere if this is true

this.noWobble = attribs.noWobble;

if(attribs.hueMap)

this.hueMap = attribs.hueMap;

else if(!this.isVectorField)

this.hueMap = [0,1,0,300];

else

this.hueMap = null;

this.magMap = attribs.magMap || [0,1,0,10];

if(attribs.displayFormat instanceof Function)

this.displayFormat = attribs.displayFormat;

else if(this.isVectorField)

this.displayFormat = v=>{

let m = v.mag();

let h = v.heading();

return "(a: " + (round(h*1000)/1000) + ", m: " + (round(m*1000)/1000) + ")";

};

else

this.displayFormat = v=>''+round(v*1000)/1000;

this.invisible = attribs.invisible;

this.oceanic = attribs.oceanic;

this.modifiers = attribs.modifiers;

if(this.isVectorField) this.vec = createVector();

if(attribs.mapFunc instanceof Function) this.mapFunc = attribs.mapFunc;

let a = null;

if(attribs.noiseChannels instanceof Array){

let noiseC = attribs.noiseChannels;

for(let i=0;i<noiseC.length;i++){

if(noiseC[i] instanceof Array || (noiseC[i]==='' && a instanceof Array)){

let d;

if(loadData instanceof LoadData && loadData.value && loadData.value.noiseData && loadData.value.noiseData[i]){

d = loadData.value.noiseData[i];

d = loadData.sub(d);

}

if(noiseC[i] instanceof Array) a = noiseC[i];

let c = new EnvNoiseChannel(this.basin,this.name,i,d,...a);

this.noise.push(c);

}

}

}

}

get(x,y,z,noHem){

try{

let longlat = Coordinate.convertFromXY(this.basin.mapType, x, y);

if(!noHem) y = this.basin.hemY(y);

if(this.mapFunc){

let u = {}; // utility argument

u.noise = (num,x1,y1,z1)=>{ // get noise channel value (coordinates optional as they default to the main "get" coordinates)

if(x1===undefined) x1 = x;

if(y1===undefined) y1 = y;

if(z1===undefined) z1 = z;

return this.noise[num].get(x1,y1,z1);

};

u.basin = this.basin;

u.field = (name,x1,y1,z1)=>{ // get value of another env field (coordinates optional)

if(x1===undefined) x1 = x;

if(y1===undefined) y1 = y;

if(z1===undefined) z1 = z;

if(this.basin.env.fields[name].accurateAfter>this.accurateAfter) this.accurateAfter = this.basin.env.fields[name].accurateAfter;

return this.basin.env.get(name,x1,y1,z1,true);

};

u.yearfrac = z=>(z%YEAR_LENGTH)/YEAR_LENGTH; // fraction of the way through the year for a tick (SHem year begins July 1 so this value is climatologically the same for both hemispheres)

u.piecewise = (s,arr)=>{

// constructs and evaluates an interpolation function defined piecewise with linear segments

// s is a year fraction in the range 0 to 1 (the argument to the interpolation function)

// arr is an array of "points" expressed as length-2 arrays

// first value of each "point" ("x") represents a number of months through the year (range 0 to 12)

// second value of each "point" ("y") represents the value to interpolate from

let m = s*12;

let x = [arr[arr.length-1][0]-12,arr[arr.length-1][1]];

for(let q of arr){

if(m<q[0]) return map(m,x[0],q[0],x[1],q[1]);

x = q;

}

return map(m,x[0],arr[0][0]+12,x[1],arr[0][1]);

};

u.coord = longlat;

u.vec = this.vec;

u.modifiers = this.modifiers || {};

let res = this.mapFunc(u,x,y,z);

if(this.isVectorField && !this.noVectorFlip) res.y = this.basin.hem(res.y);

return res;

}

if(this.isVectorField){

this.vec.set(1);

this.vec.rotate(map(this.noise[0].get(x,y,z),0,1,0,4*TAU));

if(!this.noVectorFlip) this.vec.y = this.basin.hem(this.vec.y);

return this.vec;

}

return this.noise[0].get(x,y,z);

}catch(err){

if(!noHem && err===ENVDATA_NOT_FOUND_ERROR) return null;

throw err;

}

}

wobble(){

if(!this.noWobble){

for(let i=0;i<this.noise.length;i++){

this.noise[i].wobble();

}

}

}

render(){

envLayer.noFill();

let tileSize = ceil(ENV_LAYER_TILE_SIZE*scaler);

for(let i=0;i<WIDTH;i+=ENV_LAYER_TILE_SIZE){

for(let j=0;j<HEIGHT;j+=ENV_LAYER_TILE_SIZE){

let x = i+ENV_LAYER_TILE_SIZE/2;

let y = j+ENV_LAYER_TILE_SIZE/2;

if(!this.oceanic || land.tileContainsOcean(x,y)){

let v = this.get(x,y,viewTick);

if(this.isVectorField){

envLayer.push();

envLayer.scale(scaler);

envLayer.translate(x,y);

if(v!==null){

envLayer.rotate(v.heading());

let mg = v.mag();

let mp = this.magMap;

let l = map(mg,mp[0],mp[1],mp[2],mp[3]);

let h = this.hueMap;

let c;

if(h instanceof Function)

c = h(mg);

else if(h instanceof Array)

c = color(map(mg,h[0],h[1],h[2],h[3]),100,100);

else

c = 'black';

envLayer.stroke(c);

envLayer.line(0,0,l,0);

envLayer.noStroke();

envLayer.fill(c);

envLayer.triangle(l+5,0,l,3,l,-3);

}else{

envLayer.stroke(0);

envLayer.line(-3,-3,3,3);

envLayer.line(-3,3,3,-3);

}

envLayer.pop();

}else{

if(v!==null){

let h = this.hueMap;

if(h instanceof Function) envLayer.fill(h(v));

else envLayer.fill(map(v,h[0],h[1],h[2],h[3]),100,100);

}else envLayer.fill(0,0,50);

envLayer.rect(i*scaler,j*scaler,tileSize,tileSize);

if(v===null){

envLayer.fill(0,0,60);

envLayer.triangle(i*scaler,j*scaler,i*scaler+tileSize,j*scaler,i*scaler,j*scaler+tileSize);

}

}

}

}

}

if(simSettings.showMagGlass) this.renderMagGlass();

}

renderMagGlass(){

let centerX = getMouseX();

let centerY = getMouseY();

magnifyingGlass.noFill();

let vCenter = this.get(centerX,centerY,viewTick);

if(this.isVectorField){

if(coordinateInCanvas(centerX,centerY) && (!this.oceanic || (land.tileContainsOcean(centerX,centerY) && !land.get(Coordinate.convertFromXY(this.basin.mapType,centerX,centerY))))){

let v = vCenter;

magnifyingGlass.push();

magnifyingGlass.stroke(0);

magnifyingGlass.scale(scaler);

let magMeta = buffers.get(magnifyingGlass);

magnifyingGlass.translate(magMeta.baseWidth/2,magMeta.baseHeight/2);

if(v!==null){

magnifyingGlass.rotate(v.heading());

let mg = v.mag();

let mp = this.magMap;

let l = map(mg,mp[0],mp[1],mp[2],mp[3]);

magnifyingGlass.line(0,0,l,0);

magnifyingGlass.noStroke();

magnifyingGlass.fill(0);

magnifyingGlass.triangle(l+5,0,l,3,l,-3);

}else{

magnifyingGlass.line(-3,-3,3,3);

magnifyingGlass.line(-3,3,3,-3);

}

magnifyingGlass.pop();

}

}else{

if(vCenter!==null){

for(let i=floor(magnifyingGlass.width/4);i<3*magnifyingGlass.width/4;i++){

for(let j=floor(magnifyingGlass.height/4);j<3*magnifyingGlass.height/4;j++){

let i1 = i-magnifyingGlass.width/2;

let j1 = j-magnifyingGlass.height/2;

if(sqrt(sq(i1)+sq(j1))<magnifyingGlass.width/4){

let x = centerX+i1/scaler;

let y = centerY+j1/scaler;

if(coordinateInCanvas(x,y) && (!this.oceanic || (land.tileContainsOcean(x,y) && !land.get(Coordinate.convertFromXY(this.basin.mapType,x,y))))){

let v = this.get(x,y,viewTick);

if(v!==null){

let h = this.hueMap;

if(h instanceof Function) magnifyingGlass.fill(h(v));

else magnifyingGlass.fill(map(v,h[0],h[1],h[2],h[3]),100,100);

}else magnifyingGlass.fill(0,0,50);

magnifyingGlass.rect(i,j,1,1);

}

}

}

}

}else{

magnifyingGlass.fill(0,0,50);

magnifyingGlass.ellipse(magnifyingGlass.width/2,magnifyingGlass.height/2,magnifyingGlass.width,magnifyingGlass.height);

}

}

}

record(){

if(!this.noWobble){

for(let i=0;i<this.noise.length;i++){

this.noise[i].record();

}

}

}

constructor(basin){

this.basin = basin instanceof Basin && basin;

this.fields = {};

this.fieldList = [];

this.displaying = -1;

this.layerIsOceanic = false;

this.layerIsVector = false;

}

addField(name,...fieldArgs){

this.fields[name] = new EnvField(this.basin,name,...fieldArgs);

this.fieldList.push(name);

}

wobble(){

for(let i in this.fields) this.fields[i].wobble();

}

record(){

for(let i in this.fields) this.fields[i].record();

}

get(field,x,y,z,noHem){

if(!this.fields[field]){

console.error('Field "' + field + '" does not exist in simulation mode ' + this.basin.actMode);

return 0;

}

return this.fields[field].get(x,y,z,noHem);

}

getDisplayName(field){

if(!this.fields[field]){

console.error('Field "' + field + '" does not exist in simulation mode ' + this.basin.actMode);

return 0;

}

return this.fields[field].displayName;

}

formatFieldValue(field,val){

if(!this.fields[field]){

console.error('Field "' + field + '" does not exist in simulation mode ' + this.basin.actMode);

return 0;

}

return this.fields[field].displayFormat(val);

}

displayLayer(){

envLayer.clear();

magnifyingGlass.clear();

if(this.displaying>=0) this.fields[this.fieldList[this.displaying]].render();

}

displayNext(){

do this.displaying++;

while(this.displaying<this.fieldList.length && this.fields[this.fieldList[this.displaying]].invisible);

if(this.displaying>=this.fieldList.length) this.displaying = -1;

else{

this.layerIsOceanic = this.fields[this.fieldList[this.displaying]].oceanic;

this.layerIsVector = this.fields[this.fieldList[this.displaying]].isVectorField;

}

this.displayLayer();

}

updateMagGlass(){

magnifyingGlass.clear();

if(simSettings.showMagGlass && this.displaying>=0) this.fields[this.fieldList[this.displaying]].renderMagGlass();

}

init(data){

if(data instanceof LoadData && data.format<FORMAT_WITH_IMPROVED_ENV){ // Hardcoded conversion of data structure to Format 3 (doesn't affect values, thus old format number should cascade)

let newData = {};

let v = data.value;

let o = (...d)=>{return {

version: 0,

accurateAfter: -1,

noiseData: d

};};

newData.jetstream = o(v[8]);

newData.LLSteering = o(v[7],v[6],v[5],v[4]);

newData.ULSteering = o(v[3],v[2]);

newData.shear = o();

newData.SSTAnomaly = o(v[1]);

newData.SST = o();

newData.moisture = o(v[0]);

data = data.sub(newData);

}

for(let f in ENV_DEFS[this.basin.actMode]){ // add all fields specified for the basin's simulation mode

let attribs = {};

attribs.modifiers = {};

if(ENV_DEFS.defaults[f]){

// field attributes shared among simulation modes

let defs = ENV_DEFS.defaults[f];

for(let a in defs){

if(a==='modifiers'){

for(let m in defs.modifiers) attribs.modifiers[m] = defs.modifiers[m];

}else attribs[a] = defs[a];

}

}

// field attributes unique to this basin's simulation mode

let defs = ENV_DEFS[this.basin.actMode][f];

for(let a in defs){

if(a==='modifiers'){

for(let m in defs.modifiers) attribs.modifiers[m] = defs.modifiers[m];

}else attribs[a] = defs[a];

}

let d = data instanceof LoadData && data.sub(data.value[f]);

this.addField(f,d,attribs);

}

}

constructor(basin, mapImg){

this.basin = basin instanceof Basin && basin;

let mapTypeDef = MAP_TYPES[this.basin.mapType];

this.earth = mapTypeDef.form === 'earth';

const {fullW: W, fullH: H} = fullDimensions();

this.map = createImage(W, H);

if(this.earth){

this.westBound = mapTypeDef.west;

this.eastBound = mapTypeDef.east;

this.northBound = mapTypeDef.north;

this.southBound = mapTypeDef.south;

this.wholeEarthMap = mapImg;

}else if(mapImg){

this.map.copy(mapImg, 0, 0, mapImg.width, mapImg.height, 0, 0, W, H);

}

this.noise = new NoiseChannel(9,0.5,100);

this.oceanTile = [];

this.mapDefinition = undefined;

this.drawn = false;

this.snowDrawn = false;

this.shaderDrawn = false;

this.calculate();

}

get(long, lat){

if(long instanceof Coordinate)

({longitude: long, latitude: lat} = long);

if(this.earth){

let img = this.wholeEarthMap;

long = (long + 180) % 360 - 180;

let x1 = floor(map(long,-180,180,0,img.width));

let y1 = floor(map(lat,90,-90,0,img.height-1));

let index = 4 * (y1*img.width*sq(img._pixelDensity)+x1*img._pixelDensity);

let hVal = img.pixels[index];

let lVal = img.pixels[index+1];

if(!lVal)

return 0;

else

return map(sqrt(map(hVal,12,150,0,1,true)),0,1,0.501,1);

}else{

let img = this.map;

let d = this.mapDefinition;

let {x, y} = Coordinate.convertToXY(this.basin.mapType, long, lat);

x = floor(x*d);

y = floor(y*d);

if(img && x >= 0 && x < img.width && y >= 0 && y < img.height){

let d0 = img._pixelDensity;

let index = 4 * (y * img.width * d0 * d0 + x * d0);

let hVal = img.pixels[index];

let lVal = img.pixels[index + 1];

if(!lVal)

return 0;

else

return hVal / 255;

}else return 0;

}

}

getSubBasin(long, lat){

if(long instanceof Coordinate)

({longitude: long, latitude: lat} = long);

if(this.earth){

let img = this.wholeEarthMap;

long = (long + 180) % 360 - 180;

let x1 = floor(map(long,-180,180,0,img.width));

let y1 = floor(map(lat,90,-90,0,img.height-1));

let index = 4 * (y1*img.width*sq(img._pixelDensity)+x1*img._pixelDensity);

return img.pixels[index+2];

}else{

let img = this.map;

let d = this.mapDefinition;

let {x, y} = Coordinate.convertToXY(this.basin.mapType, long, lat);

x = floor(x*d);

y = floor(y*d);

if(img && x >= 0 && x < img.width && y >= 0 && y < img.height){

let d0 = img._pixelDensity;

let index = 4 * (y * img.width * d0 * d0 + x * d0);

return img.pixels[index + 2];

}else return 0;

}

}

inBasin(long, lat){

let r = this.getSubBasin(long, lat);

return this.basin.subInBasin(r);

}

calculate(){

const {fullW: W, fullH: H} = fullDimensions();

let mapTypeControls = MAP_TYPES[this.basin.mapType];

let mapForm = mapTypeControls.form;

if(this.earth){ // crop whole earth map to the map type's sector, used for drawing (but not getting)

let earth = this.wholeEarthMap;

let sector = this.map;

let west_x = floor(map(this.westBound,-180,180,0,earth.width));

let east_x = floor(map(this.eastBound,-180,180,0,earth.width));

let north_y = floor(map(this.northBound,90,-90,0,earth.height-1));

let south_y = floor(map(this.southBound,90,-90,0,earth.height-1));

if(this.eastBound < this.westBound){

let idl_x = W * (180 - this.westBound) / (this.eastBound + 360 - this.westBound);

sector.copy(earth, west_x, north_y, earth.width - west_x, south_y - north_y, 0, 0, idl_x, H);

sector.copy(earth, 0, north_y, east_x, south_y - north_y, idl_x, 0, W - idl_x, H);

}else{

sector.copy(earth, west_x, north_y, east_x - west_x, south_y - north_y, 0, 0, W, H);

}

sector.loadPixels();

// for(let i = 0; i < sector.pixels.length; i += 4){

// let h = map(sqrt(map(sector.pixels[i],12,150,0,1,true)),0,1,0.501,1);

// sector.pixels[i] = floor(h * 255);

// }

// sector.updatePixels();

}else if(mapForm === 'pixelmap'){ // map is already given; calculate ocean tile values

let img = this.map;

let mapDef = this.mapDefinition = W/WIDTH;

let density = img._pixelDensity;

let pixels = img.pixels;

for(let i = 0; i < W; i++){

for(let j = 0; j < H; j++){

let x = i/mapDef;

let y = j/mapDef;

let index = 4 * (j * W * density * density + i * density);

let landVal = pixels[index] / 255;

let ox = floor(x/ENV_LAYER_TILE_SIZE);

let oy = floor(y/ENV_LAYER_TILE_SIZE);

if(!this.oceanTile[ox])

this.oceanTile[ox] = [];

if(landVal <= 0.5)

this.oceanTile[ox][oy] = true;

}

}

}else{ // procedurally generate map from noise and store in this.map image

let img = this.map;

let mapDef = this.mapDefinition = W/WIDTH;

img.loadPixels();

let pixels = img.pixels;

let density = img._pixelDensity;

for(let i=0;i<W;i++){

for(let j=0;j<H;j++){

let index = 4 * (j * W * density * density + i * density);

let landVal;

let x = i/mapDef;

let y = j/mapDef;

let n = this.noise.get(x,y);

let landBiasFactors = mapTypeControls.landBiasFactors;

let landBias;

if(mapTypeControls.form == "linear"){

let landBiasAnchor = WIDTH * landBiasFactors[0];

landBias = x < landBiasAnchor ?

map(x,0,landBiasAnchor,landBiasFactors[1],landBiasFactors[2]) :

map(x-landBiasAnchor,0,WIDTH-landBiasAnchor,landBiasFactors[2],landBiasFactors[3]);

}else if(mapTypeControls.form == "radial"){

let EWAnchor = WIDTH * landBiasFactors[0];

let NSAnchor = HEIGHT * landBiasFactors[1];

let pointDist = sqrt(sq(x-EWAnchor)+sq(y-NSAnchor));

let distAnchor1 = landBiasFactors[2] * sqrt(WIDTH*HEIGHT);

let distAnchor2 = landBiasFactors[3] * sqrt(WIDTH*HEIGHT);

landBias = pointDist < distAnchor1 ?

map(pointDist,0,distAnchor1,landBiasFactors[4],landBiasFactors[5]) : pointDist < distAnchor2 ?

map(pointDist,distAnchor1,distAnchor2,landBiasFactors[5],landBiasFactors[6]) :

landBiasFactors[6];

}

landVal = n + landBias;

pixels[index] = floor(landVal * 255);

pixels[index + 1] = landVal > 0.5 ? 255 : 0;

let ox = floor(x/ENV_LAYER_TILE_SIZE);

let oy = floor(y/ENV_LAYER_TILE_SIZE);

if(!this.oceanTile[ox])

this.oceanTile[ox] = [];

if(landVal <= 0.5)

this.oceanTile[ox][oy] = true;

}

}

img.updatePixels();

}

}

*draw(){

yield "Rendering land...";

const {fullW: W, fullH: H} = fullDimensions();

const src = this.map.pixels; // source image for land data; red channel is elevation; green channel is land/water; blue channel is sub-basin id

// abbreviate pixel arrays of images to draw to

const landPx = landBuffer.pixels;

const coastPx = coastLine.pixels;

const outBasinPx = outBasinBuffer.pixels;

// cache colors for 256 possible land height values to avoid expensive calculations in pixel loop

const C = COLORS.land;

const colorCache = [];

for(let i = 255, ci = 0; i >= 0; i--){

let l;

if(this.earth)

l = map(sqrt(map(i,12,150,0,1,true)),0,1,0.501,1);

else

l = Math.max(i / 255, 0.501);

if(C[ci] && l <= C[ci][0])

ci++;

if(ci >= C.length)

colorCache[i] = {r: 0, g: 0, b: 0};

else{

let color = C[ci][1];

if(simSettings.smoothLandColor && ci > 0){

const color1 = C[ci - 1][1];

const f = map(l, C[ci][0], C[ci - 1][0], 0, 1);

color = lerpColor(color, color1, f);

}

colorCache[i] = {r: red(color), g: green(color), b: blue(color)};

}

}

colorCache.outBasin = {r: red(COLORS.outBasin), g: green(COLORS.outBasin), b: blue(COLORS.outBasin)};

// cache of booleans of whether a sub-basin is out-basin or not; cached as-needed from within pixel loop as sub-basin ids are assumed unknown

const outBasinCache = {};

for(let i=0;i<W;i++){

for(let j=0;j<H;j++){

let index = 4 * (j * W + i);

if(src[index + 1]){ // if pixel is on land

const v = src[index]; // land elevation value

landPx[index] = colorCache[v].r;

landPx[index + 1] = colorCache[v].g;

landPx[index + 2] = colorCache[v].b;

landPx[index + 3] = 255;

let touchingOcean = false;

if(i>0 && !src[index - 4 + 1]) touchingOcean = true;

if(j>0 && !src[index - 4 * W + 1]) touchingOcean = true;

if(i<W-1 && !src[index + 4 + 1]) touchingOcean = true;

if(j<H-1 && !src[index + 4 * W + 1]) touchingOcean = true;

if(touchingOcean){

coastPx[index] = 0;

coastPx[index + 1] = 0;

coastPx[index + 2] = 0;

coastPx[index + 3] = 255;

}else

coastPx[index + 3] = 0;

outBasinPx[index + 3] = 0;

}else{

landBuffer.pixels[index + 3] = 0;

coastPx[index + 3] = 0;

const sb = src[index + 2]; // sub-basin id

if(outBasinCache[sb] === undefined)

outBasinCache[sb] = !this.basin.subInBasin(sb);

if(outBasinCache[sb]){

outBasinPx[index] = colorCache.outBasin.r;

outBasinPx[index + 1] = colorCache.outBasin.g;

outBasinPx[index + 2] = colorCache.outBasin.b;

outBasinPx[index + 3] = 255;

}else

outBasinPx[index + 3] = 0;

}

}

}

landBuffer.updatePixels();

outBasinBuffer.updatePixels();

coastLine.updatePixels();

if(simSettings.snowLayers && !this.snowDrawn){

yield* this.drawSnow();

}

if(simSettings.useShadows && !this.shaderDrawn){

yield* this.drawShader();

}

this.drawn = true;

}

*drawSnow(){

yield "Rendering " + (random()<0.02 ? "sneaux" : "snow") + "...";

const {fullW: W, fullH: H} = fullDimensions();

const src = this.map.pixels; // source image for land data; red channel is elevation; green channel is land/water; blue channel is sub-basin id

const eleCache = []; // cache elevation values to avoid expensive function calls in pixel loop

for(let i = 255; i >= 0; i--){

let l;

if(this.earth)

l = map(sqrt(map(i,12,150,0,1,true)),0,1,0.501,1);

else

l = Math.max(i / 255, 0.501);

eleCache[i] = l;

}

const snowColor = {r: red(COLORS.snow), g: green(COLORS.snow), b: blue(COLORS.snow)};

const SHem = this.basin.SHem;

const snowLayers = simSettings.snowLayers * 10;

for(let i=0;i<W;i++){

for(let j=0;j<H;j++){

let index = 4 * (j * W + i);

if(src[index + 1]){ // if pixel is on land

let l = 1 - j / H;

if(SHem)

l = 1 - l;

let h = 0.95 - eleCache[src[index]];

let p = l > 0 ? Math.ceil((snowLayers / 0.3) * (h / l - 0.15)) : h < 0 ? 0 : snowLayers;

for(let k = 0; k < snowLayers; k++){

if(k >= p){

snow[k].pixels[index] = snowColor.r;

snow[k].pixels[index + 1] = snowColor.g;

snow[k].pixels[index + 2] = snowColor.b;

snow[k].pixels[index + 3] = 255;

}else

snow[k].pixels[index + 3] = 0;

}

}else{

for(let k = 0; k < snowLayers; k++){

snow[k].pixels[index + 3] = 0;

}

}

}

}

for(let k = 0; k < snowLayers; k++){

snow[k].updatePixels();

}

this.snowDrawn = true;

}

*drawShader(){

yield "Rendering shadows...";

const {fullW: W, fullH: H} = fullDimensions();

const src = this.map.pixels; // source image for land data; red channel is elevation; green channel is land/water; blue channel is sub-basin id

const eleCache = []; // cache elevation values to avoid expensive function calls in pixel loop

for(let i = 255; i >= 0; i--){

let l;

if(this.earth)

l = map(sqrt(map(i,12,150,0,1,true)),0,1,0.501,1);

else

l = Math.max(i / 255, 0.501);

eleCache[i] = l;

}

for(let i=0;i<W;i++){

for(let j=0;j<H;j++){

let index = 4 * (j * W + i);

let v = src[index + 1] ? eleCache[src[index]] : 0.5;

let m = 0;

for(let k = 1; k < 6; k++){

let s = eleCache[src[index - 4 * k * W - 4 * k]] - v - k * 0.0008;

s = Math.min(Math.max(s * 191 / 0.14, 0), 191);

if(s > m) m = s;

}

if(m > 0){

landShadows.pixels[index] = 0;

landShadows.pixels[index + 1] = 0;

landShadows.pixels[index + 2] = 0;

landShadows.pixels[index + 3] = Math.floor(m);

}else

landShadows.pixels[index + 3] = 0;

}

}

landShadows.updatePixels();

this.shaderDrawn = true;

}

tileContainsOcean(x,y){

if(this.earth)

return true;

x = floor(x/ENV_LAYER_TILE_SIZE);

y = floor(y/ENV_LAYER_TILE_SIZE);

return this.oceanTile[x][y];

}

clearSnow(){

// for(let i=0;i<MAX_SNOW_LAYERS;i++) snow[i].clear();

this.snowDrawn = false;

}

clear(){

// landBuffer.clear();

// outBasinBuffer.clear();

// coastLine.clear();

// landShadows.clear();

this.clearSnow();

this.drawn = false;

this.shaderDrawn = false;

}

off = off===undefined ? 5/12 : off;

return sin((TAU*(t-YEAR_LENGTH*off))/YEAR_LENGTH);

}