webgl+canvas实现递归四面体三维变色动画效果代码-html代码-BFW代码库

代码语言：html
所属分类：三维
代码描述：webgl+canvas实现递归四面体三维变色动画效果代码
下面为部分代码预览，完整代码请点击下载或在bfwstudio webide中打开
<!DOCTYPE html>
<html lang="en" >

<head>
  <meta charset="UTF-8">
  
  
  
<style>
::-webkit-scrollbar {
  width: 0.625rem;
  height: 0.625rem;
}
::-webkit-scrollbar-thumb {
  background: #111;
  border-radius: 0.3125rem;
  box-shadow: inset 0.125rem 0.125rem 0.125rem rgba(255, 255, 255, 0.25),
    inset -0.125rem -0.125rem 0.125rem rgba(0, 0, 0, 0.25);
  cursor: default;
}
::-webkit-scrollbar-track {
  background: #333;
}
::selection {
  background: #fff;
  color: #333;
}
html,
body {
  height: 100vh;
  height: 100dvh;
  margin: 0;
  overflow: hidden;
}
body {
  display: grid;
  grid-template-rows: calc(100dvh - 4rem) 4rem;
  font-family: system-ui, sans-serif;
}
canvas,
.editor,
#controls {
  grid-row: 1;
  grid-column: 1;
}
canvas {
  width: 100%;
  height: auto;
  object-fit: contain;
  background: black;
  touch-action: none;
}
.editor,
.overlay,
#error {
  background: repeating-linear-gradient(0deg, #000a, #1119, #000a .25rem);
  padding: 1em;
}
.editor {
  color: #fefefe;
  tab-size: 2;
  border: none;
  resize: none;
}
.editor:focus {
  outline: none;
}
#error {
  grid-row: 2;
  grid-column: 1;
  margin: 0;
  padding-block: 0;
  padding-top: .5em;
  color: firebrick;
  overflow: auto;
  text-wrap: pretty;
}
#indicator {
  visibility: hidden;
  position: absolute;
  top: calc(var(--top, 0px) - var(--scroll-top, 0px));
  width: 0;
  height: 0;
  border-top: 10px solid transparent;
  border-bottom: 10px solid transparent;
  border-left: 10px solid firebrick;
  transform: translateY(-25%);
}
.overlay {
  position: absolute;
  top: 0;
  left: 0;
  right: 0;
  margin: 0;
}
.editor,
.overlay {
  font-size: 1rem;
  line-height: 1.2;
  white-space: pre;
}
#controls {
  position: fixed;
  top: 1em;
  right: 2em;
}
.controls {
  position: relative;
  display: flex;
  gap: 1.5em;
  padding: .5em 1.25em;
  background: #1111;
  border-radius: 4px;
}
.controls::before,
.controls::after {
  content: '';
  position: absolute;
  z-index: -1;
  inset: 0;
  transform: scale(.95);
  border-radius: inherit;
  opacity: 0;
}
.controls::before {
  background: #aef;
  animation: pulse 2s infinite;
}
.controls::after {
  background: #fefefe66;
  transition: transform 200ms ease-in-out;
}
.controls:hover::before,
.controls:hover::after {
  opacity: 1;
}
.controls:hover::before {
  transform: scale(.98);
  filter: blur(2px);
}
.controls:hover::after {
  transform: scale(1.025, 1.1);
}
.controls:hover {
  background: #111f;
}
@keyframes pulse {
  0% {
    transform: scale(1);
  }
  50% {
    transform: scale(1.0125);
  }
  100% {
    transform: scale(1);
  }
}
.hidden {
  display: none !important;
}
.opaque {
  opacity: 1 !important;
  background: #111 !important;
}
input {
  all: unset;
  opacity: .2;
  filter: saturate(0) invert(1);
  cursor: pointer;
  transition: opacity 200ms ease-in-out;
  padding: .25em .5em;
}
input:hover {
  opacity: 1;
}
.icon {
  text-align: center;
  line-height: 1;
}
#btnToggleView {
  width: 1.25em;
}
#btnToggleView::after {
  content: '👁';
}
#btnToggleView:checked::after {
  content: '✏️';
}
#btnToggleResolution::after {
  content: '1️⃣';
}
#btnToggleResolution:checked::after {
  content: '2️⃣';
}
#btnReset::after {
  content: '⏮️';
}
</style>

  
  
  
</head>

<body >
  <canvas id="canvas"></canvas>
<textarea id="codeEditor" class="editor" spellcheck="false" autocorrect="off" autocapitalize="off" translate="no" oninput="render()"></textarea>
<pre id="error"></pre>
<div id="indicator"></div>
<div id="controls">
  <div class="controls">
    <input id="btnToggleView" class="icon" type="checkbox" name="toggleView" onclick="toggleView()">
    <input id="btnToggleResolution" class="icon" type="checkbox" name="toggleResolution" onchange="toggleResolution()">
    <input id="btnReset" class="icon" type="checkbox" name="reset" onclick="reset()">
  </div>
</div>
<script type="x-shader/x-fragment">#version 300 es
/*********
* made by Matthias Hurrle (@atzedent)
*/ 
precision highp float;
out vec4 O;
uniform float time;
uniform vec2 resolution;
uniform vec2 move;
#define FC gl_FragCoord.xy
#define R resolution
#define T (time+12.)
#define N normalize
#define S smoothstep
#define MN min(R.x,R.y)
#define rot(a) mat2(cos((a)-vec4(0,11,33,0)))
#define hue(a) (.25+.6*cos(6.3*(a)+vec3(0,83,21)))
#define lum(a) dot(vec3(.21,.71,.07),a)

float shape(vec3 p) {
        
        // See details at:
        // http://blog.hvidtfeldts.net/index.php/2011/08/distance-estimated-3d-fractals-iii-folding-space/
        
        float offset=1.2, n=5.;
        
        for (float i=.0; i++<n;) {
                if(p.x+p.y<.0) p.xy=-p.yx; // fold 1
                if(p.x+p.z<.0) p.xz=-p.zx; // fold 2
                if(p.y+p.z<.0) p.zy=-p.yz; // fold 3    
                p=2.*p-offset;
        }
        
        return length(p)*pow(2.,-n)-.052;
}

vec2 map(vec3 p) {
        vec3 q=p;
        //p.y+=.5;
        //p.yz*=rot(-.955);
        //p.xz*=rot(-.78);
        vec2
        a=vec2(shape(p),1),
        b=vec2(q.y+1.215,0);
        
        a=a.x<b.x?a:b;
        return a;
}

vec3 norm(vec3 p) {
        float h=1e-3; vec2 k=vec2(-1,1);
        return N(
                k.xyy*map(p+k.xyy*h).x+
                k.yxy*map(p+k.yxy*h).x+
                k.yyx*map(p+k.yyx*h).x+
                k.xxx*map(p+k.xxx*h).x
        );
}

float calcAO(vec3 p, vec3 n) {
        float o=.0, s=1.;
        for(float i=.0; i++<5.;) {
                float
                h=.01+.12*i/4.,
                d=map(p+h*n).x;
                o+=(h-d)*s;
                s*=.65;
                if(o>.5) break;
        }
        return clamp(1.-3.*o,.0,1.)*(.5+.5*n.y);
}

float shadow(vec3 p, vec3 lp) {
        float shd=1., maxd=length(lp-p);
        vec3 l=N(lp-p);
        for (float i=1e-3; i<maxd;) {
                float d=map(p+l*i).x;
                if (d<1e-3) {
                        shd=.0;
                        break;
                }
                shd=min(shd,48.*d/i);
                i+=d;
        }
        return shd;
}

void cam(inout vec3 p) {
        p.yz*=rot(-(sin(1.5707-move.y*6.3/MN)*.5-.5)+(cos(T*.1)*.5+.5));
        p.xz*=rot(-move.x*6.3/MN+(sin(T*.2)*.5));
}

float box(vec3 p) {
        p=abs(p);
        return max(max(p.x,p.y),p.z);
}

void main() {
        vec2 uv=(FC-.5*R)/MN;
        vec3 col=vec3(0),
        p=vec3(0,0,-10),
        rd=N(vec3(uv,3.-exp(-cos(T*.05)*.3)));
        cam(p); cam(rd);
        float dd=.0;
        for (float i=.0; i++<400.;) {
                vec2 d=map(p);
                if (abs(d.x)<1e-3) {
                        vec3 n=norm(p), lp=vec3(-1,4,-5), l=N(lp-p);
                        float
                        shd=shadow(p+n*3e-3,lp),
                        occ=calcAO(p+n*3e-3,n),
                        diff=clamp(dot(l,n),.0,1.),
                        ref=pow(dot(reflect(rd,n),l),64.);
                        col+=.2+diff*shd*occ;
      // In the next line change box to either length or shape and see what happens
                        col*=1.2*hue(box(p*(d.y>.0?.65:.1))+(d.y>.0?.6-T*.05:-T*.05));
                        if (d.y>.0) col+=sqrt(max(.0,lum(col)));
                        if (ref>.0 && d.y>.0) col+=ref;
                        col/=1.+exp(-col);
                        col=sqrt(col);
                        break;
                }
                if (d.x>200.) break;
                p+=rd*d.x;
                dd+=d.x;
        }
        col=mix(vec3(0),col,exp(-125e-5*dd*dd));
  O=vec4(col,1);
}</script>
  
      <script id="rendered-js" >
/*********
 * made by Matthias Hurrle (@atzedent)
 */
let editMode = false // set to false to hide the code editor on load
let resolution = .5 // set 1 for full resolution or to .5 to start with half resolution on load
let renderDelay = 1000 // delay in ms before rendering the shader after a change
let dpr = Math.max(1, resolution * window.devicePixelRatio)
let frm, source, editor, store, renderer, pointers
const shaderId = 'It Is All Just a Reflection'
window.onload = init

function resize() {
  const { innerWidth: width, innerHeight: height } = window

  canvas.width = width * dpr
  canvas.height = height * dpr

  if (renderer) {
    renderer.updateScale(dpr)
  }
}
function toggleView() {
  editor.hidden = btnToggleView.checked
}
function reset() {
  let shader = source
  editor.text = shader ? shader.textContent : renderer.defaultSource
  store.putShaderSource(shaderId, editor.text)
  renderThis()
}
.........完整代码请登录后点击上方下载按钮下载查看