Skip to content
The Chat Archive
sonar-pro LMArena Search Arena 24K

q modelo eres

  1. User

    q modelo eres

  2. Assistant

    ¡Hola! Soy un modelo de lenguaje avanzado desarrollado por Perplexity, basado en la arquitectura GPT-4 de OpenAI. Estoy diseñado para responder preguntas, ayudarte con tareas, generar ideas, y mucho más, siempre buscando ofrecer respuestas claras, útiles y bien redactadas.

    Si tienes alguna pregunta específica sobre mis capacidades o sobre cómo puedo ayudarte, ¡adelante!

  3. User
  4. Assistant

    Tu código HTML es un laboratorio interactivo de Mandelbulb (un fractal 3D) hecho en JavaScript moderno usando Three.js y WebGL2, con controles en tiempo real gracias a lil-gui. Aquí tienes un resumen de cómo funciona y qué hace cada parte clave:

    ¿Qué hace este código?

    • Renderiza un fractal Mandelbulb 3D en tiempo real usando shaders GLSL modernos (WebGL 2, GLSL 3.0).
    • Permite rotar la cámara con el ratón y ajustar parámetros del fractal, color, iluminación y efectos de cámara mediante una interfaz gráfica (GUI).
    • Todo ocurre en el navegador, sin dependencias externas más allá de los módulos importados por CDN.

    Componentes principales

    1. Escena Three.js minimalista

    • Crea una escena, una cámara ortográfica y un renderizador WebGL2 a pantalla completa.
    • Usa un "quad" (plano de 2x2) que cubre toda la pantalla, sobre el que se aplica el shader fractal.

    2. Uniformes controlables

    • Variables como potencia del fractal, iteraciones, brillo, saturación, color, rotación de cámara, etc., que se pasan al shader y se pueden modificar en tiempo real.

    3. Shaders GLSL

    • El vertex shader simplemente pasa las coordenadas de textura.
    • El fragment shader implementa el algoritmo de "distance estimation" para el Mandelbulb, calcula normales, iluminación (difusa, especular, ambiental), color HSL, y efectos de profundidad de campo (DoF).

    4. GUI interactiva

    • Usa lil-gui para crear carpetas y sliders que permiten modificar todos los parámetros importantes del fractal y la cámara en tiempo real.

    5. Interacción de usuario

    • Permite rotar la vista arrastrando el ratón y hacer zoom con la rueda.
    • El mensaje de ayuda desaparece al interactuar.

    6. Responsive

    • Se adapta automáticamente al tamaño de la ventana.

    7. Bucle de animación

    • Actualiza el tiempo y renderiza la escena en cada frame, a menos que esté pausado.

    ¿Qué tecnologías usa?

    • Three.js: Librería para gráficos 3D en la web, usada aquí para gestionar la escena, cámara y renderizado, aunque el fractal en sí se calcula en el shader[4][7].
    • WebGL 2 / GLSL 3.0: Permite usar shaders modernos y eficientes para el cálculo del fractal.
    • lil-gui: Pequeña librería para crear interfaces gráficas de usuario (sliders, color pickers, etc.) fácilmente.

    ¿Qué puedes hacer con él?

    • Explorar visualmente el fractal Mandelbulb en 3D.
    • Modificar parámetros matemáticos y visuales para crear diferentes "universos fractales".
    • Aprender sobre shaders, rendering en tiempo real y manipulación de escenas 3D en el navegador.

    ¿Qué NO hace?

    • No carga modelos 3D externos ni texturas.
    • No usa geometría tradicional, todo el fractal es generado por el shader en el plano.
    • No tiene controles de navegación avanzados (solo rotación y zoom).

    En resumen:
    Este código es un laboratorio visual interactivo para explorar el fractal Mandelbulb en 3D, usando tecnologías web modernas (Three.js, WebGL2, GLSL, lil-gui), ideal para aprender y experimentar con gráficos generativos y shaders en el navegador[2][4][7].

  5. User

    ok dame el codigo

  6. Assistant

    ¡Por supuesto! Aquí tienes el código completo listo para copiar y pegar en un archivo .html. Solo necesitas abrirlo en un navegador moderno (que soporte WebGL2 y ES Modules, como Chrome, Firefox, Edge o Safari actualizados).


    <!DOCTYPE html>
    
    <html lang="es">
    <head>
    <meta charset="utf-8"/>
    <title>Mandelbulb Lab • Versión WebGL 2 (ESM Único)</title>
    <style>
      html,body{margin:0;height:100%;overflow:hidden;background:#000;font-family:monospace;}
      #help{position:fixed;top:10px;left:50%;transform:translateX(-50%);
            color:#fff;font-size:14px;pointer-events:none;text-align:center;opacity:0.8;}
      .lil-gui.root { z-index: 10; }
    </style>
    <script type="importmap">
    {
      "imports": {
        "three": "https://cdn.jsdelivr.net/npm/three@0.160/build/three.module.js",
        "three/addons/": "https://cdn.jsdelivr.net/npm/three@0.160/examples/jsm/",
        "lil-gui": "https://cdn.jsdelivr.net/npm/lil-gui@0.18/dist/lil-gui.esm.js"
      }
    }
    </script>
    </head>
    <body>
    <div id="help">Arrastra para rotar • Juega con los sliders ➜ crea tu propio universo 🌀</div>
    <script type="module">
    import * as THREE from 'three';
    import { GUI } from 'lil-gui';
    
    /* ---------- 1. Escena minimal ---------- */
    const scene  = new THREE.Scene();
    const camera = new THREE.OrthographicCamera(-1,1,1,-1,0,1);
    const renderer = new THREE.WebGLRenderer({antialias:false});
    renderer.setSize(innerWidth,innerHeight);
    renderer.setPixelRatio(devicePixelRatio);
    document.body.appendChild(renderer.domElement);
    
    /* ---------- 2. Uniformes controlables ---------- */
    const uniforms = {
      iTime         : {value:0},
      iResolution   : {value:new THREE.Vector2(innerWidth,innerHeight)},
      power         : {value:8.0},
      iterations    : {value:12},
      brightness    : {value:0.8},
      saturation    : {value:0.85},
      colorShift    : {value:0.1},
      camRot        : {value:new THREE.Vector2(0,0)},
      pause         : {value:false},
      ambientLight  : {value:0.15},
      specularColor : {value:new THREE.Color(0.9, 0.85, 0.8)},
      shininess     : {value:30.0},
      focalDistance : {value:4.5},
      aperture      : {value:0.15}
    };
    
    /* ---------- 3. Shaders GLSL 3.0 ---------- */
    const vs = `#version 300 es
    in vec3 position;
    in vec2 uv;
    out vec2 vUv;
    void main(){
      vUv = uv;
      gl_Position = vec4(position,1.0);
    }`;
    
    const fs = `#version 300 es
    precision highp float;
    out vec4 fragColor;
    in  vec2 vUv;
    
    uniform vec2  iResolution;
    uniform float iTime;
    uniform float power;
    uniform int   iterations;
    uniform float brightness;
    uniform float saturation;
    uniform float colorShift;
    uniform vec2  camRot;
    
    uniform float ambientLight;
    uniform vec3  specularColor;
    uniform float shininess;
    uniform float focalDistance;
    uniform float aperture;
    
    /* --- constantes --- */
    #define MAX_STEPS 120
    #define FAR        30.0
    #define EPS        0.0001
    #define PI         3.14159265359
    #define MIN_R_DE   1e-6
    #define MIN_DR_DE  1e-6
    
    mat3 rotX(float a){float s=sin(a),c=cos(a);return mat3(1.,0.,0.,0.,c,-s,0.,s,c);}
    mat3 rotY(float a){float s=sin(a),c=cos(a);return mat3(c,0.,s,0.,1.,0.,-s,0.,c);}
    
    float deMandelbulb(vec3 p){
        vec3 z = p;
        float dr = 1.0;
        float r  = 0.0;
        for(int i=0; i < 20; i++){
            if(i >= iterations) break;
            r = length(z);
            if(r > FAR * 2.0) break;
            if (r < MIN_R_DE) break;
            float theta = acos(clamp(z.z/r, -1.0, 1.0));
            float phi   = atan(z.y, z.x);
            float r_pow_p_minus_1 = pow(r, power-1.0);
            if (isinf(r_pow_p_minus_1) || isnan(r_pow_p_minus_1)) { dr = FAR; break; }
            dr = power * r_pow_p_minus_1 * dr + 1.0;
            float zr = r_pow_p_minus_1 * r;
            theta *= power;
            phi   *= power;
            z = zr * vec3(sin(theta)*cos(phi),
                          sin(phi)*sin(theta),
                          cos(theta)) + p;
        }
        if (r < MIN_R_DE || dr < MIN_DR_DE || isnan(r) || isnan(dr) || isinf(r) || isinf(dr)) {
            return EPS;
        }
        if (r > FAR) return r - FAR * 0.5;
        float dist = 0.5 * log(r) * r / dr;
        if (isnan(dist) || isinf(dist) || dist < EPS * 0.1) {
            return EPS;
        }
        return dist;
    }
    
    vec3 getNormal(vec3 p){
        vec2 e = vec2(EPS,0);
        return normalize(vec3(
            deMandelbulb(p+e.xyy) - deMandelbulb(p-e.xyy),
            deMandelbulb(p+e.yxy) - deMandelbulb(p-e.yxy),
            deMandelbulb(p+e.yyx) - deMandelbulb(p-e.yyx)
        ));
    }
    
    vec3 hsl2rgb(float h, float s, float l) {
        vec3 rgb = clamp(abs(mod(h * 6.0 + vec3(0.0, 4.0, 2.0), 6.0) - 3.0) - 1.0, 0.0, 1.0);
        return l + s * (rgb - 0.5) * (1.0 - abs(2.0 * l - 1.0));
    }
    
    void main(){
        vec2 uv=(vUv-0.5)*vec2(iResolution.x/iResolution.y,1.);
        vec3 camPos = vec3(0,0,5.);
        vec3 camDir = normalize(vec3(uv,-1.5));
        mat3 rot = rotX(camRot.y)*rotY(camRot.x);
        camPos = rot * camPos;
        camDir = rot * camDir;
        float t = 0.;
        vec3  hitPos;
        for(int i=0; i < MAX_STEPS; i++){
            hitPos = camPos + camDir * t;
            float d = deMandelbulb(hitPos);
            if(isnan(d) || isinf(d) || d <= 0.0) {
                t = FAR + 1.0;
                break;
            }
            if(d < EPS || t > FAR) break;
            t += d * 0.75;
        }
        vec3 col = vec3(0);
        if(t < FAR){
            vec3 n = getNormal(hitPos);
            vec3 lightDir = normalize(vec3(0.8, 0.7, 0.5));
            vec3 viewDir  = normalize(camPos - hitPos);
            float diffuse = clamp(dot(n, lightDir), 0.0, 1.0);
            vec3 reflectDir = reflect(-lightDir, n);
            float specAngle = max(dot(reflectDir, viewDir), 0.0);
            float specular = pow(specAngle, shininess);
            float hue = mod(length(hitPos)*0.15 + colorShift + iTime*0.05, 1.0);
            vec3 baseColor = hsl2rgb(hue, saturation, 0.5);
            col = baseColor * (ambientLight + diffuse * brightness) + specularColor * specular * brightness;
            float distToCamera = t;
            float focusAmount = abs(distToCamera - focalDistance) * aperture;
            float dofFactor = pow(1.0 - clamp(focusAmount, 0.0, 1.0), 2.0);
            col = mix(col * 0.3 + dot(col, vec3(0.299,0.587,0.114)) * 0.3, col, dofFactor * saturation);
            col *= mix(0.6, 1.0, dofFactor);
        } else {
            col = vec3(0.02, 0.03, 0.05) + abs(camDir.y) * 0.03 + abs(camDir.x) * 0.01;
        }
        col = pow(col, vec3(0.4545));
        fragColor = vec4(col,1.);
    }`;
    
    /* ---------- 4. Cuadrito full-screen ---------- */
    const quad = new THREE.Mesh(
      new THREE.PlaneGeometry(2,2),
      new THREE.ShaderMaterial({
          uniforms, vertexShader:vs, fragmentShader:fs,
          glslVersion: THREE.GLSL3
      })
    );
    scene.add(quad);
    
    /* ---------- 5. GUI ---------- */
    const gui = new GUI({title:'✨ Mandelbulb Lab+ (ESM Único)', width:320});
    
    const fractalFolder = gui.addFolder('🌀 Fractal');
    fractalFolder.add(uniforms.power,'value',2,16,0.1).name('Potencia');
    fractalFolder.add(uniforms.iterations,'value',3,25,1)
       .name('Iteraciones').onChange(v=>uniforms.iterations.value=v|0);
    fractalFolder.add(uniforms.colorShift,'value',0,1,0.001).name('Desfase Color');
    fractalFolder.add(uniforms,'pause').name('Pausar Animación');
    
    const lightingFolder = gui.addFolder('💡 Iluminación');
    lightingFolder.add(uniforms.brightness,'value',0.1,2.5,0.01).name('Intensidad Global');
    lightingFolder.add(uniforms.saturation,'value',0,1.5,0.01).name('Saturación Color');
    lightingFolder.add(uniforms.ambientLight,'value',0,1,0.01).name('Luz Ambiental');
    lightingFolder.addColor(uniforms.specularColor,'value').name('Color Especular');
    lightingFolder.add(uniforms.shininess,'value',1,256,1).name('Brillo Especular');
    
    const cameraFolder = gui.addFolder('📷 Cámara & Efectos');
    cameraFolder.add(uniforms.focalDistance,'value',1,15,0.1).name('Distancia Focal');
    cameraFolder.add(uniforms.aperture,'value',0.01,1,0.01).name('Apertura (DoF)');
    cameraFolder.add({resetCam:()=>uniforms.camRot.value.set(0,0)},'resetCam').name('Reset Rotación Cámara');
    
    /* ---------- 6. Interacción ratón ---------- */
    let dragging=false, lastX=0, lastY=0;
    const helpDiv = document.getElementById('help');
    let helpTimeout;
    const PI_JS = Math.PI;
    const FAR_JS = 30.0;
    
    addEventListener('pointerdown',e=>{
      if(e.target.closest('.lil-gui')) return;
      dragging=true; lastX=e.clientX; lastY=e.clientY;
      if (helpDiv) {
        clearTimeout(helpTimeout);
        helpDiv.style.transition = 'opacity 0.5s';
        helpDiv.style.opacity = '0';
        helpTimeout = setTimeout(() => { if (helpDiv) helpDiv.style.display = 'none'; }, 500);
      }
    });
    addEventListener('pointermove',e=>{
      if(!dragging) return;
      const dx=(e.clientX-lastX)/innerWidth*PI_JS*1.5;
      const dy=(e.clientY-lastY)/innerHeight*PI_JS*1.5;
      lastX=e.clientX; lastY=e.clientY;
      uniforms.camRot.value.x += dx;
      uniforms.camRot.value.y = Math.max(-PI_JS/2 + 0.01, Math.min(PI_JS/2 - 0.01, uniforms.camRot.value.y + dy));
    });
    addEventListener('pointerup',()=>dragging=false);
    
    addEventListener('wheel', e => {
        if(e.target.closest('.lil-gui')) return;
        e.preventDefault();
        const zoomSpeed = 0.1;
        uniforms.focalDistance.value -= e.deltaY * zoomSpeed * 0.02;
        uniforms.focalDistance.value = Math.max(1.0, Math.min(FAR_JS-1.0, uniforms.focalDistance.value));
    }, {passive: false});
    
    /* ---------- 7. Resize ---------- */
    addEventListener('resize',()=>{
      renderer.setSize(innerWidth,innerHeight);
      uniforms.iResolution.value.set(innerWidth,innerHeight);
      camera.left = -1; camera.right = 1;
      camera.top = 1; camera.bottom = -1;
      camera.updateProjectionMatrix();
    });
    
    /* ---------- 8. Bucle ---------- */
    let tPrev=performance.now();
    function loop(t){
      const dt=(t-tPrev)*0.001;
      tPrev=t;
      if(!uniforms.pause.value) uniforms.iTime.value+=dt;
      renderer.render(scene,camera);
      requestAnimationFrame(loop);
    }
    requestAnimationFrame(loop);
    
    /* ---------- 9. Log de errores GLSL ---------- */
    renderer.debug.checkShaderErrors=true;
    </script>
    </body>
    </html>
    

    ¡Listo!
    Guarda esto como mandelbulb.html y ábrelo en tu navegador.
    Puedes rotar el fractal con el ratón, hacer zoom con la rueda y jugar con los sliders para crear tu propio universo fractal.

    ¿Quieres alguna mejora, explicación o adaptación? ¡Dímelo!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.