// OczkoSieOdlepiloTemuMisiu_LAMERS
//
//uzyto:pgc4d,oklab,agx,chemikowy ggx raymacz iq itd. :)
//
#define DEBUG_MODE 0
#define PROBKI_AA 1
const float PI=3.14159265358979;
const float TAU=6.28318530717959;
mat2 rot2(float a){
vec2 cs=normalize(vec2(cos(a),sin(a)));
return mat2(cs.x,cs.y,-cs.y,cs.x);
}
uint pcgHash(uint v){
uint state=v * 747796405u + 2891336453u;
uint word=((state >>((state >> 28u)+ 4u))^ state)* 277803737u;
return(word >> 22u)^ word;
}
uvec3 pcg3d(uvec3 v){
v=v * 1664525u + 1013904223u;
v.x +=v.y * v.z;
v.y +=v.z * v.x;
v.z +=v.x * v.y;
v ^=v >> 16u;
v.x +=v.y * v.z;
v.y +=v.z * v.x;
v.z +=v.x * v.y;
return v;
}
float uintToUnit(uint h){return float(h >> 8u)*(1.0 / 16777216.0);}
vec2 uintToUnit(uvec2 h){return vec2(h >> 8u)*(1.0 / 16777216.0);}
vec3 uintToUnit(uvec3 h){return vec3(h >> 8u)*(1.0 / 16777216.0);}
vec4 uintToUnit(uvec4 h){return vec4(h >> 8u)*(1.0 / 16777216.0);}
float hash12(vec2 p){
uvec2 q=uvec2(ivec2(floor(p)));
return uintToUnit(pcgHash(q.x + pcgHash(q.y)));
}
vec2 hash22(vec2 p){
ivec2 q=ivec2(floor(p));
return uintToUnit(pcg3d(uvec3(q.x,q.y,0x2545u))).xy;
}
vec3 hash33(vec3 p){return uintToUnit(pcg3d(uvec3(ivec3(floor(p)))));}
float sdSphere(vec3 p,float r){return length(p)- r;}
float sdRoundBox(vec3 p,vec3 b,float r){
vec3 q=abs(p)- b + r;
return length(max(q,0.0))+ min(max(q.x,max(q.y,q.z)),0.0)- r;
}
float sdEllipsoid(vec3 p,vec3 r){
float k0=length(p / r);
float k1=length(p /(r * r));
if(k1 < 1e-8)return -min(r.x,min(r.y,r.z));
return k0 *(k0 - 1.0)/ k1;
}
float sdCircle(vec2 p,float r){return length(p)- r;}
vec2 sminBlend(float a,float b,float k){
float h=clamp(0.5 + 0.5 *(b - a)/ k,0.0,1.0);
return vec2(mix(b,a,h)- k * h *(1.0 - h),h);
}
#define ZERO (min(iFrame, 0))
vec2 map(vec3 p);
const int RAYMARCH_MAX_STEPS=256;
vec3 raymarch(vec3 ro,vec3 rd,float tmin,float tmax,float stepScale){
float t=tmin;
for(int i=ZERO;i < RAYMARCH_MAX_STEPS;i++){
vec2 h=map(ro + rd * t);
if(abs(h.x)< max(0.0002 * t,1e-5))return vec3(t,h.y,float(i));
t +=h.x * stepScale;
if(t > tmax)break;
}
return vec3(-1.0,-1.0,float(RAYMARCH_MAX_STEPS));
}
vec3 calcNormal(vec3 p,float eps){
vec3 n=vec3(0.0);
for(int i=ZERO;i < 4;i++){
vec3 e=0.5773 *(2.0 * vec3((((i + 3)>> 1)& 1),((i >> 1)& 1),(i & 1))- 1.0);
n +=e * map(p + e * eps).x;
}
return normalize(n);
}
mat3 cameraMatrix(vec3 ro,vec3 ta,float roll){
vec3 w=normalize(ta - ro);
vec3 up=vec3(sin(roll),cos(roll),0.0);
vec3 u=normalize(cross(w,up));
vec3 v=cross(u,w);
return mat3(u,v,w);
}
vec3 cameraRay(mat3 cam,vec2 uv,float focal){
return normalize(cam * vec3(uv,focal));
}
vec3 fresnelSchlick(float u,vec3 f0){
float m=clamp(1.0 - u,0.0,1.0);
float m2=m * m;
return f0 +(1.0 - f0)*(m2 * m2 * m);
}
float distributionGGX(vec3 n,vec3 h,float NoH,float alpha2){
vec3 NxH=cross(n,h);
float d=dot(NxH,NxH)+ alpha2 * NoH * NoH;
return alpha2 /(PI * d * d);
}
float visibilitySmithGGX_ADDICT(float NoV,float NoL,float alpha2){
vec2 nvl=vec2(NoV,NoL);
vec2 roots=sqrt(nvl * nvl *(1.0 - alpha2)+ alpha2);
return 0.5 / max(dot(nvl.yx,roots),1e-6);
}
vec3 specularGGX(vec3 n,vec3 v,vec3 l,float roughness,vec3 f0){
vec3 h=normalize(v + l);
float NoL=clamp(dot(n,l),0.0,1.0);
float NoV=max(dot(n,v),1e-4);
float NoH=clamp(dot(n,h),0.0,1.0);
float VoH=clamp(dot(v,h),0.0,1.0);
float alpha=max(roughness,0.045);
alpha *=alpha;
float alpha2=alpha * alpha;
return PI * distributionGGX(n,h,NoH,alpha2)
* visibilitySmithGGX_ADDICT(NoV,NoL,alpha2)
* fresnelSchlick(VoH,f0)* NoL;
}
vec3 shadePBR(vec3 n,vec3 v,vec3 l,vec3 albedo,float roughness,float metallic){
vec3 f0=mix(vec3(0.04),albedo,metallic);
float NoL=clamp(dot(n,l),0.0,1.0);
vec3 F=fresnelSchlick(max(dot(n,v),0.0),f0);
vec3 diffuse=albedo *(1.0 - metallic)*(1.0 - F)* NoL;
return diffuse + specularGGX(n,v,l,roughness,f0);
}
vec3 envBRDFApprox(vec3 f0,float NoV,float roughness){
vec4 r=roughness * vec4(-1.0,-0.0275,-0.572,0.022)+ vec4(1.0,0.0425,1.04,-0.04);
float a=min(r.x * r.x,exp2(-9.28 * NoV))* r.x + r.y;
vec2 ab=vec2(-1.04,1.04)* a + r.zw;
return f0 * ab.x + ab.y;
}
vec3 hemisphereLight(vec3 n,vec3 skyColor,vec3 groundColor){
return mix(groundColor,skyColor,0.5 + 0.5 * n.y);
}
vec3 srgbToLinear(vec3 c){
c=max(c,0.0);
return mix(c / 12.92,pow((c + 0.055)/ 1.055,vec3(2.4)),step(0.04045,c));
}
vec3 linearToSrgb(vec3 c){
c=max(c,0.0);
return mix(c * 12.92,1.055 * pow(c,vec3(1.0 / 2.4))- 0.055,step(0.0031308,c));
}
float luminance(vec3 c){return dot(c,vec3(0.2126,0.7152,0.0722));}
vec3 linearSrgbToOklab(vec3 c){
vec3 lms=c * mat3(0.4122214708,0.5363325363,0.0514459929,
0.2119034982,0.6806995451,0.1073969566,
0.0883024619,0.2817188376,0.6299787005);
lms=sign(lms)* pow(abs(lms),vec3(1.0 / 3.0));
return lms * mat3(0.2104542553,0.7936177850,-0.0040720468,
1.9779984951,-2.4285922050,0.4505937099,
0.0259040371,0.7827717662,-0.8086757660);
}
vec3 oklabToLinearSrgb(vec3 lab){
vec3 lms=lab * mat3(1.0,0.3963377774,0.2158037573,
1.0,-0.1055613458,-0.0638541728,
1.0,-0.0894841775,-1.2914855480);
lms=lms * lms * lms;
return lms * mat3(4.0767416621,-3.3077115913,0.2309699292,
-1.2684380046,2.6097574011,-0.3413193965,
-0.0041960863,-0.7034186147,1.7076147010);
}
vec3 mixOklab(vec3 a,vec3 b,float t){
return oklabToLinearSrgb(mix(linearSrgbToOklab(a),linearSrgbToOklab(b),t));
}
vec3 tonemapAgX(vec3 c){
const mat3 inset=mat3(0.842479062253094,0.0423282422610123,0.0423756549057051,
0.0784335999999992,0.878468636469772,0.0784336,
0.0792237451477643,0.0791661274605434,0.879142973793104);
const mat3 outset=mat3(1.19687900512017,-0.0528968517574562,-0.0529716355144438,
-0.0980208811401368,1.15190312990417,-0.0980434501171241,
-0.0990297440797205,-0.0989611768448433,1.15107367264116);
const float minEv=-12.47393,maxEv=4.026069;
c=inset * max(c,0.0);
c=clamp((log2(max(c,1e-10))- minEv)/(maxEv - minEv),0.0,1.0);
vec3 x2=c * c,x4=x2 * x2;
c=15.5 * x4 * x2 - 40.14 * x4 * c + 31.96 * x4 - 6.868 * x2 * c + 0.4298 * x2 + 0.1191 * c - 0.00232;
c=outset * c;
return pow(max(c,0.0),vec3(2.2));
}
vec2 aaOffset(int i){
return fract(0.5 + float(i)* vec2(0.7548776662,0.5698402910))- 0.5;
}
vec3 ditherTPDF(vec2 fragCoord,int frame){
vec2 r=hash22(vec2(floor(fragCoord)+ 7919.0 * float(frame % 1024)));
return vec3((r.x + r.y - 1.0)/ 255.0);
}
vec3 debugDistance(float d){
vec3 col=(d > 0.0)? vec3(0.9,0.6,0.3): vec3(0.4,0.7,0.85);
col *=1.0 - exp(-4.0 * abs(d));
col *=0.8 + 0.2 * cos(TAU * d / 0.1);
return mix(col,vec3(1.0),1.0 - smoothstep(0.0,0.01,abs(d)));
}
vec3 debugNormal(vec3 n){return 0.5 + 0.5 * n;}
vec3 debugIdColor(float id){
return 0.55 + 0.45 * cos(TAU *(0.618034 * id + vec3(0.0,0.33,0.67)));
}
vec3 debugHeat(float t){
t=clamp(t,0.0,1.0);
return clamp(vec3(1.5 * t,1.6 * t * t * t - 0.1,0.9 * sin(PI * t)+ 0.2 * t * t),0.0,1.0);
}
const float CZAS_SKOKU=1.70;
const float CZAS_DEMA=53.0;
const float PREDKOSC_COFANIA=6.0;
const float CZAS_PETLI=80.85;
const float START_MISIA=65.0;
const float KONIEC_MISIA=80.80;
const float START_SPADANIA_OKA=12.45;
const float CZAS_SPADANIA_OKA=2.20;
const float START_OBROTU=0.78;
const float KONIEC_OBROTU=0.97;
const float SILA_WGNIECENIA=0.115;
const float LACZENIE_SFER=0.105;
const int LICZBA_SFER=10;
const int LICZBA_BRYL=20;
const float EKSPOZYCJA=1.18;
const float OGNISKOWA=2.30;
const vec4 SCENA_GLOWNA=vec4(3.70,4.05,13.75,14.10);
const vec4 SCENA_DEFORMACJI=vec4(15.70,16.05,25.75,26.10);
const vec4 SCENA_MORFU=vec4(25.70,26.05,37.75,38.10);
const vec4 SCENA_FINALOWA=vec4(37.65,38.05,52.60,52.98);
const vec2 ZAKRES_MORFU=vec2(25.60,38.20);
const vec2 ZAKRES_FINALU=vec2(37.60,53.00);
const float START_FINALU=38.0;
const vec3 KIERUNEK_SLONCA=normalize(vec3(-0.58,0.72,-0.38));
const vec3 KOLOR_SLONCA=vec3(3.5,3.25,2.95);
const vec3 TLO_GORA=vec3(0.70,0.94,0.82);
const vec3 TLO_DOL=vec3(0.50,0.84,0.69);
const vec3 PASTELOWY_ROZ=vec3(0.98,0.66,0.78);
const vec3 PASTELOWY_BLEKIT=vec3(0.55,0.76,0.98);
const vec3 PASTELOWA_MIETA=vec3(0.58,0.94,0.80);
const vec3 PASTELOWA_BRZOSKWINIA=vec3(1.00,0.76,0.58);
float tPet,tAnim,tMis;
void przygotujSekwencje(){
tPet=mod(iTime,CZAS_PETLI);
tMis=max(tPet - START_MISIA,0.0);
if(tPet <=CZAS_DEMA)tAnim=tPet;
else if(tPet <=55.0)tAnim=CZAS_DEMA;
else tAnim=max(0.0,CZAS_DEMA
-(tPet - 55.0)* PREDKOSC_COFANIA);
}
float skokowyObrot(float t){
float numerSkoku=floor(t / CZAS_SKOKU);
float czasLokalny=fract(t / CZAS_SKOKU);
float ruch=smoothstep(START_OBROTU,KONIEC_OBROTU,czasLokalny);
ruch=ruch * ruch *(3.0 - 2.0 * ruch);
return(numerSkoku + ruch)* 1.57079632679;
}
float oknoSceny(float faza,float startWejscia,float kWej,float startWyjscia,float kWyj){
return smoothstep(startWejscia,kWej,faza)*(1.0 - smoothstep(startWyjscia,kWyj,faza));
}
float maskaSceny(float czas,vec4 zakres){
return oknoSceny(czas,zakres.x,zakres.y,zakres.z,zakres.w);
}
float oknoSkokowe(float czas,float poczatek,float koniec){
return step(poczatek,czas)*(1.0 - step(koniec,czas));
}
float surowyCzasPetli(){
return tPet;
}
float czyScenaMisia(){
return step(START_MISIA,surowyCzasPetli());
}
float czasMisia(){
return tMis;
}
float czasAnimacji(){
return tAnim;
}
float czasSekwencji(){
return czasAnimacji();
}
float czasFinalu(){
return max(czasSekwencji()- START_FINALU,0.0);
}
float widocznoscCofania(){
float t=surowyCzasPetli();
return smoothstep(53.0,53.16,t)
*(1.0 - smoothstep(63.65,63.83,t));
}
float widocznoscLogo(){
float t=czasSekwencji();
float wstep=1.0 - smoothstep(3.60,4.0,t);
float prLogo=oknoSceny(t,13.65,14.05,15.60,16.0);
return max(wstep,prLogo)*(1.0 - czyScenaMisia());
}
float widocznoscFinalu(){
return maskaSceny(czasSekwencji(),SCENA_FINALOWA);
}
float czyFinal(){
float t=czasSekwencji();
return oknoSkokowe(t,ZAKRES_FINALU.x,ZAKRES_FINALU.y);
}
float widocznoscObiektu(){
float t=czasSekwencji();
float scA=max(maskaSceny(t,SCENA_GLOWNA),
maskaSceny(t,SCENA_DEFORMACJI));
float scB=max(maskaSceny(t,SCENA_MORFU),
widocznoscFinalu());
return max(scA,scB);
}
float widocznoscDuzegoCuba(){
const vec4 zakres=vec4(15.70,16.25,25.50,26.10);
return maskaSceny(czasSekwencji(),zakres);
}
float sferOn(){
float t=czasSekwencji();
return oknoSkokowe(t,ZAKRES_MORFU.x,ZAKRES_MORFU.y);
}
float powiekszenieObiektu(){
float czasLokalny=max(czasSekwencji()- 16.0,0.0);
float cell=floor(czasLokalny / 3.4);
float faza=fract(czasLokalny / 3.4);
float losRoz=hash12(vec2(cell,419.0));
float aktywny=step(0.22,hash12(vec2(cell,887.0)));
float skImp=oknoSkokowe(faza,0.12,0.67)* aktywny;
float aktywnaScena=oknoSkokowe(czasSekwencji(),16.0,26.0);
return aktywnaScena *(0.25 + skImp * mix(0.20,0.52,losRoz));
}
float najazdKamery(){
float t=czasSekwencji();
float pierwszy=oknoSceny(t,5.0,5.08,6.0,6.10);
float drugi=oknoSceny(t,8.0,8.08,9.0,9.10);
float trzeci=oknoSceny(t,11.0,11.08,12.0,12.10);
float kamGlow=max(pierwszy,max(drugi,trzeci));
float czwarty=oknoSkokowe(t,17.5,18.8);
float piaty=oknoSkokowe(t,20.5,21.8);
float szosty=oknoSkokowe(t,23.3,24.6);
float kamDef=max(czwarty,max(piaty,szosty));
return max(0.30 * kamGlow,0.30 * kamDef);
}
float morphSfery(){
float t=czasSekwencji();
float glownaSfera=step(7.0,t)*(1.0 - step(11.0,t));
float sferMor=sferOn()
*(1.0 - smoothstep(25.70,27.70,t));
return max(glownaSfera,sferMor);
}
float impulsDema(){
float puls=0.5 + 0.5 * sin(czasAnimacji()* 3.05);
return puls * puls * puls * puls;
}
float widocznoscLinii(){
float faza=fract((czasSekwencji()- 2.5)/ 6.8);
float okresowyPuls=oknoSceny(faza,0.07,0.14,0.38,0.48);
return okresowyPuls * widocznoscObiektu()*(1.0 - sferOn());
}
float katObrotuObiektu(){
float czas=czasAnimacji();
float obrot=skokowyObrot(czas);
float startPet=czas - czasSekwencji();
float obrDyn=skokowyObrot(startPet + 16.0)
+(czas - 16.0)* 1.35;
if(czas >=15.70 && czas < 26.20)obrot=obrDyn;
float tObS=max(czas - 26.0,0.0);
float obrS=min(tObS,10.0)* 0.82
- max(tObS - 10.0,0.0)* 0.82;
float obrotSfery=skokowyObrot(startPet + 26.0)+ obrS;
if(czas >=25.70 && czas < 38.20)obrot=obrotSfery;
return obrot;
}
vec3 przestrzenObiektu(vec3 p){
vec3 q=p;
float obrot=katObrotuObiektu();
q.xz=rot2(obrot)* q.xz;
q.yz=rot2(0.28 * obrot + 0.17)* q.yz;
return q;
}
vec3 obiektDoSwiata(vec3 q,float obrot){
q.yz=rot2(-(0.28 * obrot + 0.17))* q.yz;
q.xz=rot2(-obrot)* q.xz;
return q;
}
float spadajaceSfery(vec3 p,out float matKul,out float impHit){
float d=1e5;
matKul=3.0;
impHit=0.0;
float czas=czasAnimacji();
float udzialSfery=morphSfery();
float obrotObiektu=katObrotuObiektu();
for(int i=0;i < LICZBA_SFER;++i){
float fi=float(i);
vec2 rnd=hash22(vec2(fi,19.0));
float opSpad=0.20 + fi * 0.45 + 0.80 * hash12(vec2(fi,61.0));
float czasSpadania=mix(2.20,3.60,hash12(vec2(fi,7.0)));
float wiek=czas - 4.0 - opSpad;
float faza=clamp(wiek / czasSpadania,0.0,1.0);
float aktywny=step(0.0,wiek);
float trafiaObiekt=1.0;
if(i==0 || i==5 || i==6 || i==9)trafiaObiekt=0.0;
vec2 cel=vec2(mix(-0.72,0.72,hash12(vec2(fi,17.0))),
mix(-0.68,0.68,hash12(vec2(fi + 53.0,29.0))));
float bok=(i==0 || i==5)? -1.0 : 1.0;
cel.x=mix(cel.x,bok *(1.85 + 0.20 * abs(cel.x)),1.0 - trafiaObiekt);
float dolot=smoothstep(0.08,0.78,faza);
dolot *=dolot;
float poslizg=smoothstep(0.72,1.0,faza);
float swSpad=smoothstep(0.02,1.0,faza);
swSpad *=swSpad;
float losRozmiaru=hash12(vec2(fi + 151.0,307.0));
float rBaz=mix(0.055,0.185,pow(losRozmiaru,1.7));
rBaz +=0.175 * smoothstep(0.78,0.98,losRozmiaru);
float promien=rBaz * mix(1.0 - smoothstep(0.86,1.0,faza),
1.0,trafiaObiekt);
float tPow=max(wiek - czasSpadania * 0.72,0.0);
float katPlyniecia=tPow * mix(0.22,0.42,rnd.x)+ fi * 1.7;
float wysokoscPrzelotu=mix(2.85 + 0.35 * rnd.y,-2.35,swSpad);
vec3 pSpad=vec3(cel.x,wysokoscPrzelotu,cel.y);
pSpad.x +=0.055 * sin(3.2 * czas + fi);
pSpad.z +=0.045 * cos(2.7 * czas + fi * 1.7);
vec3 kierunekStartowy=normalize(vec3(cel.x,0.83,cel.y)+ vec3(0.001));
float szerokosc=katPlyniecia * mix(0.53,0.79,rnd.y)+ fi * 0.91;
vec3 kierunekOrbity=vec3(cos(katPlyniecia)* cos(szerokosc),
sin(szerokosc),
sin(katPlyniecia)* cos(szerokosc));
float postep=smoothstep(0.0,2.6,tPow);
vec3 dirMix=mix(kierunekStartowy,kierunekOrbity,postep);
vec3 szlak=normalize(dirMix + vec3(0.0001,0.0002,0.0003));
float maksymalnaOs=max(max(abs(szlak.x),abs(szlak.y)),abs(szlak.z));
vec3 powCub=szlak / max(maksymalnaOs,0.001)*(0.74 + 0.475 * rBaz);
vec3 powSfer=normalize(szlak + vec3(0.001,0.002,0.003))
*(0.86 + 0.475 * rBaz);
vec3 powLok=powCub;
if(udzialSfery > 0.5)powLok=powSfer;
powLok.y -=0.025 * sin(3.14159265359 * poslizg);
vec3 pKlej=obiektDoSwiata(powLok,obrotObiektu);
vec3 srodek=mix(pSpad,pKlej,trafiaObiekt * dolot);
float sfera=sdSphere(p - srodek,max(promien,0.002));
if(aktywny < 0.5)sfera=1e5;
if(trafiaObiekt < 0.5 && faza > 0.995)sfera=1e5;
if(sfera < d){
d=sfera;
float losMat=hash12(vec2(fi + 37.0,211.0));
matKul=4.0;
if(losMat < 0.46)matKul=3.0;
if(losMat > 0.82)matKul=5.0;
}
float fHit=(faza - 0.78)/ 0.075;
impHit +=aktywny * trafiaObiekt * exp(-fHit * fHit * 2.2);
}
return d;
}
float ksztaltSferaSzescian(vec3 q,float promienSfery,
vec3 boxSize,float zaokraglenie,
float udzialSfery){
float szescian=sdRoundBox(q,boxSize,zaokraglenie);
float sfera=sdSphere(q,promienSfery);
return mix(szescian,sfera,clamp(udzialSfery,0.0,1.0));
}
float zdeformowanySzescian(vec3 q,float impHit,float morfowanie){
float baza=ksztaltSferaSzescian(q,0.86,vec3(0.72),0.075,
morfowanie);
float czas=czasAnimacji();
float wagaPow=exp(-8.0 * abs(baza));
float garb=exp(-3.0 * dot(q.xz,q.xz))* smoothstep(-0.2,0.75,q.y);
float scisB=0.55 + 0.45 * cos(3.14159265359 * q.y / 0.9);
float deformacja=SILA_WGNIECENIA * clamp(impHit,0.0,1.35)
* garb * scisB;
float falaDem=sin(10.0 * q.x + czas * 4.2)
* sin(11.0 * q.y - czas * 3.1)
* sin(9.0 * q.z + czas * 3.7);
falaDem +=0.45 * sin(18.0 * length(q.xz)- czas * 7.0);
float defFin=widocznoscDuzegoCuba()*(0.055 + 0.055 * impulsDema())* falaDem;
float morDr=sferOn()
* smoothstep(30.80,31.15,czas);
float defMor=morDr
*(0.085 + 0.045 * impulsDema())
* falaDem;
return baza - wagaPow
*(deformacja + defFin + defMor);
}
float kulePrzyciagane(vec3 p,out float materialKuli){
float d=1e5;
materialKuli=8.0;
float czasLokalny=czasFinalu();
for(int i=0;i < LICZBA_BRYL;++i){
float fi=float(i);
vec3 rnd=hash33(vec3(fi + 11.0,fi + 97.0,fi + 241.0));
vec3 kierunek=normalize(rnd * 2.0 - 1.0 + vec3(0.001,0.002,0.003));
float obrotOrbity=czasLokalny * mix(0.10,0.22,rnd.z)+ fi * 0.17;
kierunek.xz=rot2(obrotOrbity)* kierunek.xz;
float opoznienie=mix(0.0,2.5,rnd.x);
float przyci=smoothstep(opoznienie,opoznienie + 7.0,czasLokalny);
przyci *=przyci;
float rStart=mix(1.75,2.85,rnd.y);
float losRozmiaru=hash12(vec2(fi + 53.0,811.0));
float rozmiar=mix(0.13,0.285,losRozmiaru);
rozmiar +=0.105 * step(0.87,losRozmiaru);
float rCel=0.73 + 0.58 * rozmiar;
float rOrb=mix(rStart,rCel,przyci);
vec3 srodek=kierunek * rOrb;
srodek +=(1.0 - przyci)
* vec3(0.16 * sin(czasLokalny * 0.74 + fi * 1.7),
0.14 * cos(czasLokalny * 0.63 + fi * 2.1),
0.13 * sin(czasLokalny * 0.69 + fi * 1.3));
float kula=sdSphere(p - srodek,rozmiar);
if(kula < d){
float losMaterialu=hash12(vec2(fi + 313.0,557.0));
materialKuli=8.0 + floor(losMaterialu * 4.0);
}
d=min(d,kula);
}
return d;
}
float rdzenPrzyciagania(vec3 p){
float czasLokalny=czasFinalu();
float morfowanie=smoothstep(10.0,12.0,czasLokalny);
vec3 q=p;
float obrot=0.34 * czasLokalny;
q.xz=rot2(obrot)* q.xz;
q.xy=rot2(0.61 * obrot + 0.24)* q.xy;
float baza=ksztaltSferaSzescian(q,0.78,vec3(0.68),0.12,
1.0 - morfowanie);
float fale=sin(7.0 * q.x + czasLokalny * 2.2)
* sin(6.2 * q.y - czasLokalny * 1.7)
* cos(6.7 * q.z + czasLokalny * 1.9);
float deformacja=morfowanie *(0.045 + 0.028 * impulsDema())* fale;
return baza - deformacja;
}
vec3 przestrzenMisia(vec3 p){
float czas=czasMisia();
vec3 q=p - vec3(0.0,0.025 * sin(czas * 1.2),0.0);
float obrot=6.28318530718 * min(czas / 12.3,1.0);
q.xz=rot2(-obrot)* q.xz;
q.yz=rot2(-0.045 * sin(czas * 0.95))* q.yz;
q.x=-q.x;
return q;
}
vec2 mapaMisia(vec3 p){
float otoczka=length(p)- 1.70;
if(otoczka > 0.25)return vec2(otoczka,21.0);
vec3 q=przestrzenMisia(p);
float glowa=sdSphere(q,0.82);
vec2 wynik=vec2(glowa,21.0);
float leweUcho=sdEllipsoid(q - vec3(-0.79,0.62,0.08),
vec3(0.36,0.36,0.20));
vec3 prawe=q - vec3(0.56,0.87,0.07);
prawe.xy=rot2(-0.24)* prawe.xy;
float praweUcho=sdEllipsoid(prawe,vec3(0.23,0.33,0.21));
float uszy=min(leweUcho,praweUcho);
if(uszy < wynik.x)wynik=vec2(uszy,22.0);
float uchoL=sdEllipsoid(q - vec3(-0.84,0.64,-0.105),
vec3(0.24,0.25,0.075));
float uchoP=sdEllipsoid(q - vec3(0.57,0.89,-0.11),
vec3(0.14,0.20,0.075));
float wnetrzeUszu=min(uchoL,uchoP);
if(wnetrzeUszu < wynik.x)wynik=vec2(wnetrzeUszu,23.0);
float pyszczek=sdEllipsoid(q - vec3(0.0,-0.34,-0.61),
vec3(0.49,0.42,0.31));
float lewyPlatek=sdEllipsoid(q - vec3(-0.22,-0.42,-0.67),
vec3(0.27,0.31,0.24));
float prawyPlatek=sdEllipsoid(q - vec3(0.22,-0.42,-0.67),
vec3(0.27,0.31,0.24));
pyszczek=sminBlend(pyszczek,lewyPlatek,0.12).x;
pyszczek=sminBlend(pyszczek,prawyPlatek,0.12).x;
if(pyszczek < wynik.x)wynik=vec2(pyszczek,24.0);
for(int i=0;i < 2;++i){
float strona=(i==0)? -1.0 : 1.0;
vec3 srodekOka=vec3(strona * 0.33,0.09,-0.77);
float spadek=0.0;
if(i==0){
spadek=clamp((czasMisia()- START_SPADANIA_OKA)
/ CZAS_SPADANIA_OKA,0.0,1.0);
}
float obwodka=sdEllipsoid(q -(srodekOka + vec3(0.0,0.0,0.04)),
vec3(0.12,0.115,0.07))
+ 0.16 * smoothstep(0.03,0.20,spadek);
if(obwodka < wynik.x)wynik=vec2(obwodka,25.0);
if(i==0){
srodekOka +=vec3(-0.10 * spadek,
-1.20 * spadek * spadek,
-0.42 * spadek);
}
float oko=sdSphere(q - srodekOka,0.079);
if(oko < wynik.x)wynik=vec2(oko,26.0);
float blysk=sdSphere(q -(srodekOka + vec3(-0.023,0.025,-0.071)),
0.016);
if(blysk < wynik.x)wynik=vec2(blysk,27.0);
}
float nos=sdSphere(q - vec3(0.0,-0.23,-0.925),0.093);
if(nos < wynik.x)wynik=vec2(nos,28.0);
return wynik;
}
vec2 map(vec3 p){
if(czyScenaMisia()> 0.5)return mapaMisia(p);
if(czyFinal()> 0.5){
float materialKuli;
float kule=kulePrzyciagane(p,materialKuli);
float rdzen=rdzenPrzyciagania(p);
float czasLokalny=czasFinalu();
float stapianie=smoothstep(6.0,13.0,czasLokalny);
float polFin=mix(min(rdzen,kule),
sminBlend(rdzen,kule,0.13).x,
stapianie);
float matFin=materialKuli;
if(rdzen < kule + 0.025)matFin=12.0;
return vec2(polFin,matFin);
}
float matKul;
float impHit;
float sfery=spadajaceSfery(p,matKul,impHit);
if(sferOn()> 0.5)sfery=1e5;
vec3 q=przestrzenObiektu(p);
float szescian=zdeformowanySzescian(q,impHit,morphSfery());
vec2 polaczone=sminBlend(szescian,sfery,LACZENIE_SFER);
float matId=2.0;
if(sfery < szescian + 0.025)matId=matKul;
return vec2(polaczone.x,matId);
}
float znakLogo(vec2 p);
vec3 kolorMaterialuMisia(float id,vec3 p,out float szorstkosc){
vec3 q=przestrzenMisia(p);
if(id < 21.5){
szorstkosc=0.53;
float gora=smoothstep(-0.72,0.74,q.y);
vec3 kolorGlowy=mixOklab(srgbToLinear(vec3(0.72,0.38,0.25)),
srgbToLinear(vec3(0.87,0.53,0.34)),gora);
vec2 uvLogo=q.xy * 1.34;
float znak=1.0 - smoothstep(-0.012,0.012,znakLogo(uvLogo));
float tylGlowy=smoothstep(0.20,0.45,q.z);
vec3 tusz=srgbToLinear(vec3(0.16,0.18,0.19));
return mix(kolorGlowy,tusz,znak * tylGlowy * 0.95);
}
if(id < 22.5){
szorstkosc=0.56;
return srgbToLinear(vec3(0.67,0.36,0.26));
}
if(id < 23.5){
szorstkosc=0.68;
return srgbToLinear(vec3(0.46,0.25,0.22));
}
if(id < 24.5){
szorstkosc=0.61;
return srgbToLinear(vec3(0.98,0.96,0.91));
}
if(id < 25.5){
szorstkosc=0.72;
return srgbToLinear(vec3(0.50,0.30,0.24));
}
if(id < 26.5){
szorstkosc=0.075;
return srgbToLinear(vec3(0.018,0.016,0.021));
}
if(id < 27.5){
szorstkosc=0.10;
return srgbToLinear(vec3(1.0,0.98,0.94));
}
if(id < 28.5){
szorstkosc=0.12;
return srgbToLinear(vec3(0.055,0.046,0.049));
}
szorstkosc=0.64;
return srgbToLinear(vec3(0.39,0.30,0.28));
}
vec3 kolorMaterialu(float id,vec3 p,out float szorstkosc){
if(id < 2.5){
vec3 q=przestrzenObiektu(p);
float czas=czasAnimacji();
float udzialSfery=morphSfery();
float finOn=sferOn();
float mixPal=smoothstep(-0.82,0.82,q.y + 0.20 * q.x - 0.12 * q.z);
szorstkosc=0.34;
vec3 kolorBazowy=mixOklab(srgbToLinear(PASTELOWY_BLEKIT),srgbToLinear(PASTELOWA_MIETA),mixPal);
float polePasteli=0.5 + 0.5 * sin(2.8 * q.x + czas * 0.32)
* sin(2.35 * q.y - czas * 0.24)
* cos(2.60 * q.z + czas * 0.28);
vec3 pastelSfery=mixOklab(srgbToLinear(PASTELOWY_ROZ),
srgbToLinear(PASTELOWY_BLEKIT),polePasteli);
pastelSfery=mixOklab(pastelSfery,srgbToLinear(PASTELOWA_MIETA),
0.35 + 0.30 * polePasteli);
kolorBazowy=mix(kolorBazowy,pastelSfery,0.82 * finOn);
float pAtr=sin(2.05 * q.x + czas * 0.18)
+ sin(2.30 * q.y - czas * 0.13)
+ sin(1.85 * q.z + czas * 0.16);
float mAtr=smoothstep(1.05,2.15,pAtr);
float silAtr=mix(0.28,0.82,widocznoscDuzegoCuba())
*(1.0 - finOn);
vec3 kolAtr=srgbToLinear(vec3(0.025,0.050,0.043));
kolorBazowy=mix(kolorBazowy,kolAtr,mAtr * silAtr);
vec3 aq=abs(q);
vec2 uvSciany=q.xy;
if(aq.x > aq.y && aq.x > aq.z)uvSciany=q.zy;
if(aq.y > aq.x && aq.y > aq.z)uvSciany=q.xz;
float falaA=length(uvSciany - vec2(0.24,-0.18));
float falaB=length(uvSciany + vec2(0.31,-0.12));
float interf=sin(72.0 * falaA - 19.0 * falaB
- czas * 1.8 + 2.2 * sin(uvSciany.x * 5.0));
float ciemnaLinia=1.0 - smoothstep(0.0,0.115,abs(interf));
float jasnaFala=sin(72.0 * falaA - 19.0 * falaB
- czas * 1.8 + 2.2 * sin(uvSciany.x * 5.0)+ 0.34);
float jasnaLinia=1.0 - smoothstep(0.0,0.075,abs(jasnaFala));
vec3 ciemnyPasek=srgbToLinear(vec3(0.008,0.015,0.014));
vec3 jasnyPasek=srgbToLinear(vec3(0.84,0.94,0.90));
vec3 kolInt=mix(kolorBazowy,ciemnyPasek,ciemnaLinia);
kolInt=mix(kolInt,jasnyPasek,jasnaLinia);
kolorBazowy=mix(kolorBazowy,kolInt,0.82 * widocznoscLinii());
float dLogo=znakLogo(uvSciany * 1.08);
float maskaLogo=1.0 - smoothstep(-0.018,0.018,dLogo);
float promien=max(length(q),0.001);
float dlGeo=atan(q.z,q.x)/ 6.28318530718;
float szerokosc=asin(clamp(q.y / promien,-1.0,1.0))/ 1.57079632679;
float dlKaf=fract(dlGeo * 3.0 + 0.5)- 0.5;
vec2 uvLogoSfery=vec2(dlKaf * 2.0,szerokosc * 1.55);
float dLogS=znakLogo(uvLogoSfery);
float mLogS=1.0 - smoothstep(-0.018,0.018,dLogS);
vec3 kolLogS=srgbToLinear(vec3(0.76,0.85,0.89));
float mLogPow=mix(maskaLogo,mLogS,
udzialSfery);
return mix(kolorBazowy,kolLogS,
mLogPow * 0.72 * finOn);
}
if(id < 3.5){
szorstkosc=0.20;
return srgbToLinear(vec3(1.0));
}
if(id > 4.5 && id < 5.5){
szorstkosc=0.08;
return vec3(1.0);
}
if(id > 7.5 && id < 8.5){
szorstkosc=0.24;
return srgbToLinear(PASTELOWY_ROZ);
}
if(id > 8.5 && id < 9.5){
szorstkosc=0.18;
return srgbToLinear(vec3(1.0));
}
if(id > 9.5 && id < 10.5){
szorstkosc=0.24;
return srgbToLinear(PASTELOWY_BLEKIT);
}
if(id > 11.5){
szorstkosc=0.28;
float mieszanie=0.5 + 0.5 * sin(2.2 * p.x - 1.8 * p.y + 2.5 * p.z);
vec3 kolRdz=mixOklab(srgbToLinear(PASTELOWY_ROZ),
srgbToLinear(PASTELOWY_BLEKIT),
mieszanie);
float pasma=smoothstep(0.45,1.55,
sin(3.4 * p.x + czasAnimacji()* 0.7)
+ sin(3.1 * p.y - czasAnimacji()* 0.5));
return mix(kolRdz,
srgbToLinear(vec3(0.018,0.020,0.024)),
pasma * 0.42);
}
if(id > 10.5){
szorstkosc=0.24;
return srgbToLinear(PASTELOWA_BRZOSKWINIA);
}
szorstkosc=0.25;
return mixOklab(srgbToLinear(PASTELOWY_ROZ),srgbToLinear(PASTELOWA_BRZOSKWINIA),0.45);
}
float znakLogo(vec2 p){
float zewnetrzny=sdCircle(p,0.72);
float otwory=sdCircle(p,0.145);
for(int i=0;i < 3;++i){
float a=1.0471975512 + float(i)* 2.0943951024;
vec2 srodek=0.47 * vec2(cos(a),sin(a));
otwory=min(otwory,sdCircle(p - srodek,0.29));
}
return max(zewnetrzny,-otwory);
}
vec3 pasteloweTlo(vec2 uv){
float gradient=smoothstep(-0.85,0.90,uv.y);
vec3 kolor=mix(srgbToLinear(TLO_DOL),srgbToLinear(TLO_GORA),gradient);
float poswiata=exp(-1.15 * dot(uv,uv));
kolor +=srgbToLinear(vec3(0.08,0.14,0.09))* poswiata;
return kolor;
}
float najazdKameryFinal(){
float t=czasSekwencji();
float pierwszy=oknoSkokowe(t,40.2,41.5);
float drugi=oknoSkokowe(t,47.8,49.2);
return 0.28 * max(pierwszy,drugi);
}
float odlegloscOdcinka(vec2 p,vec2 a,vec2 b){
vec2 pa=p - a;
vec2 ba=b - a;
float h=clamp(dot(pa,ba)/ max(dot(ba,ba),1e-5),0.0,1.0);
return length(pa - ba * h);
}
float znakiCofania(vec2 uv){
float d=1e5;
for(int i=0;i < 3;++i){
float fi=float(i);
float srodekX=(fi - 1.0)* 0.43;
vec2 p=uv - vec2(srodekX,0.0);
d=min(d,odlegloscOdcinka(p,vec2(0.22,0.43),vec2(-0.22,0.0)));
d=min(d,odlegloscOdcinka(p,vec2(-0.22,0.0),vec2(0.22,-0.43)));
}
return 1.0 - smoothstep(0.030,0.065,d);
}
vec3 renderujMisia(vec2 wspPiksela){
vec2 uv=(2.0 * wspPiksela - iResolution.xy)/ iResolution.y;
vec3 tlo=pasteloweTlo(uv);
tlo +=srgbToLinear(vec3(0.09,0.08,0.06))
* exp(-1.65 * dot(uv,uv));
vec3 okoKamery=vec3(0.0,0.08,-3.20);
vec3 celKamery=vec3(0.0,0.03,0.0);
vec3 promien=cameraRay(cameraMatrix(okoKamery,celKamery,0.0),
uv,2.30);
vec3 trafienie=raymarch(okoKamery,promien,0.1,8.0,0.62);
if(trafienie.x < 0.0)return tlo;
vec3 punkt=okoKamery + promien * trafienie.x;
vec3 normalna=calcNormal(punkt,0.00055 * trafienie.x);
vec3 widz=-promien;
float szorstkosc;
vec3 albedo=kolorMaterialuMisia(trafienie.y,punkt,szorstkosc);
vec3 dirLamp=normalize(vec3(-0.62,0.80,-0.75));
vec3 lGlow=shadePBR(normalna,widz,dirLamp,
albedo,szorstkosc,0.0)
* vec3(2.35,2.18,2.08);
vec3 wypelnienie=albedo * hemisphereLight(normalna,
vec3(0.66,0.78,0.73),
vec3(0.24,0.22,0.25))* 0.72;
float obrys=pow(1.0 - max(dot(normalna,widz),0.0),3.0);
vec3 kontur=vec3(0.17,0.24,0.22)* obrys;
vec3 kolor=lGlow + wypelnienie + kontur;
if(trafienie.y > 26.5 && trafienie.y < 27.5)
kolor +=vec3(0.38,0.36,0.32);
return kolor;
}
vec3 renderuj(vec2 wspPiksela){
if(czyScenaMisia()> 0.5)return renderujMisia(wspPiksela);
vec2 uv=(2.0 * wspPiksela - iResolution.xy)/ iResolution.y;
vec3 ta=vec3(0.0,0.08,0.0);
vec3 bazowaKamera=vec3(2.52,1.61,-2.862);
float skKamD=0.42 * powiekszenieObiektu();
float zbKam=max(najazdKamery(),skKamD);
zbKam=max(zbKam,0.48 * sferOn());
vec3 ro=ta +(bazowaKamera - ta)*(1.0 - zbKam);
float finOn=widocznoscFinalu();
float czasFinalowy=czasFinalu();
vec3 celOrbity=vec3(0.0,0.02 * sin(czasFinalowy * 0.37),0.08);
float katOrbity=-0.72 + czasFinalowy * 0.31;
float rOrb=4.05 *(1.0 - najazdKameryFinal());
vec3 kamOrb=celOrbity
+ vec3(rOrb * cos(katOrbity),
1.30 + 0.48 * sin(czasFinalowy * 0.23),
rOrb * sin(katOrbity));
ro=mix(ro,kamOrb,finOn);
ta=mix(ta,celOrbity,finOn);
vec3 rd=cameraRay(cameraMatrix(ro,ta,0.0),uv,OGNISKOWA);
vec3 tlo=pasteloweTlo(uv);
if(widocznoscObiektu()< 0.01)return tlo;
#if DEBUG_MODE == 1
return debugDistance(map(vec3(uv * 1.35,0.0)).x);
#endif
float krokRay=mix(0.57,0.78,finOn);
vec3 trafienie=raymarch(ro,rd,0.1,12.0,krokRay);
#if DEBUG_MODE == 4
return debugHeat(trafienie.z / float(RAYMARCH_MAX_STEPS));
#endif
if(trafienie.x < 0.0)return tlo;
vec3 p=ro + rd * trafienie.x;
vec3 n=calcNormal(p,0.00055 * trafienie.x);
vec3 v=-rd;
float szorstkosc;
vec3 albedo=kolorMaterialu(trafienie.y,p,szorstkosc);
float cien=0.84 + 0.16 * max(dot(n,KIERUNEK_SLONCA),0.0);
float ao=0.88 + 0.12 * smoothstep(-0.7,0.8,n.y);
vec3 lGlow=shadePBR(n,v,KIERUNEK_SLONCA,albedo,szorstkosc,0.0)* KOLOR_SLONCA * cien;
vec3 lFill=albedo * hemisphereLight(n,vec3(0.48,0.62,0.60),vec3(0.18,0.16,0.20))* ao;
float mKraw=pow(1.0 - max(dot(n,v),0.0),3.0);
vec3 lRim=mix(vec3(0.42,0.65,1.0),vec3(1.0,0.48,0.72),0.5 + 0.5 * n.x)
* mKraw * 0.40;
vec3 otoczenie=mix(srgbToLinear(TLO_DOL),srgbToLinear(TLO_GORA),0.5 + 0.5 * n.y);
vec3 odbicie=envBRDFApprox(vec3(0.04),max(dot(n,v),0.0),szorstkosc)* otoczenie * ao;
vec3 emisja=vec3(0.0);
if(trafienie.y > 4.5 && trafienie.y < 5.5)emisja=vec3(4.5,4.35,4.1);
#if DEBUG_MODE == 2
return debugNormal(n);
#elif DEBUG_MODE == 3
return debugIdColor(trafienie.y);
#elif DEBUG_MODE == 5
float matTest,impTest;
spadajaceSfery(p,matTest,impTest);
return vec3(clamp(impTest,0.0,1.0));
#elif DEBUG_MODE == 6
return vec3(luminance(lGlow),luminance(lFill),luminance(lRim + odbicie));
#endif
vec3 kolObj=lGlow + lFill + lRim + odbicie + emisja;
return mix(tlo,kolObj,widocznoscObiektu());
}
void mainImage(out vec4 kolorPiksela,in vec2 wspPiksela){
przygotujSekwencje();
vec3 sumaKoloru=vec3(0.0);
for(int i=0;i < PROBKI_AA;++i){
vec2 przesuniecie=vec2(0.0);
if(PROBKI_AA > 1)przesuniecie=aaOffset(i);
vec2 wspProbki=wspPiksela + przesuniecie;
#if DEBUG_MODE == 0
float tGl=floor(czasAnimacji()* 7.0);
float pasGl=floor(wspProbki.y / 38.0);
float losGl=hash12(vec2(pasGl,tGl));
float glOn=step(4.10,czasSekwencji());
float glLogo=widocznoscLogo()* glOn;
float glBryl=widocznoscFinalu();
float progGl=mix(0.88,0.54,glLogo);
progGl=mix(progGl,0.76,glBryl);
float gateGl=step(progGl,losGl)* impulsDema()
*(1.0 + 1.05 * glLogo + 0.35 * glBryl)
* glOn;
float zasGl=26.4
*(1.0 + 1.25 * glLogo + 0.65 * glBryl);
wspProbki.x +=(losGl - 0.5)* zasGl * gateGl;
#endif
vec3 kolor=renderuj(wspProbki);
vec2 uvLogo=(2.0 * wspProbki - iResolution.xy)/ iResolution.y;
float zegarLogo=mod(czasAnimacji(),2.20);
float krokLogo=floor(min(zegarLogo / 0.7333333333,2.0));
float skalaLogo=0.86;
if(krokLogo > 0.5)skalaLogo=1.30;
if(krokLogo > 1.5)skalaLogo=1.06;
float obrotLogo=czasAnimacji()* 0.34;
uvLogo=rot2(obrotLogo)* uvLogo / skalaLogo;
float dLogo=znakLogo(uvLogo * 0.92);
float maskaLogo=(1.0 - smoothstep(-0.012,0.012,dLogo))* widocznoscLogo();
vec3 kolLogE=srgbToLinear(vec3(0.16,0.18,0.19));
kolor=mix(kolor,kolLogE,maskaLogo);
#if DEBUG_MODE == 0
kolor=tonemapAgX(kolor * EKSPOZYCJA);
#endif
sumaKoloru +=kolor;
}
vec3 kolor=sumaKoloru / float(PROBKI_AA);
#if DEBUG_MODE == 0
kolor=linearToSrgb(kolor)+ ditherTPDF(wspPiksela,iFrame);
float glOn=step(4.10,czasSekwencji());
float efektLogo=widocznoscLogo()* glOn;
float efektBryl=widocznoscFinalu();
float blyskRytmu=1.0 + 0.0275 * impulsDema()*(1.0 + 1.15 * efektLogo);
kolor *=blyskRytmu;
vec2 uvEkranu=(2.0 * wspPiksela - iResolution.xy)/ iResolution.y;
float winieta=1.0 - 0.13 * smoothstep(0.55,1.55,length(uvEkranu));
kolor *=winieta;
float pChr=impulsDema()* smoothstep(0.25,1.10,abs(uvEkranu.x))
* glOn;
kolor +=vec3(0.0154,-0.0055,0.0198)* pChr
*(1.0 + 1.20 * efektLogo + 0.70 * efektBryl);
float efektCofania=widocznoscCofania();
float strzalki=znakiCofania(uvEkranu)* efektCofania;
float blinkArr=step(0.0,sin(surowyCzasPetli()* 12.0));
kolor=mix(kolor,vec3(1.0),strzalki * 0.30 * blinkArr);
float czasSurowy=surowyCzasPetli();
float fadeIn=smoothstep(0.0,0.55,czasSurowy);
float wyjscieDema=1.0 - smoothstep(63.83,64.78,czasSurowy);
float wejscieMisia=smoothstep(START_MISIA,START_MISIA + 0.55,
czasSurowy);
float wyjscieMisia=1.0 - smoothstep(KONIEC_MISIA - 0.70,
KONIEC_MISIA,czasSurowy);
float jasnoscSceny=mix(fadeIn * wyjscieDema,
wejscieMisia * wyjscieMisia,
czyScenaMisia());
kolor *=jasnoscSceny;
#endif
kolorPiksela=vec4(kolor,1.0);
}
