javascript - Threejs/EffectComposer - 交互式屏蔽 UnrealBloomPass-6ren

javascript - Threejs/EffectComposer - 交互式屏蔽 UnrealBloomPass

转载作者：行者123 更新时间：2023-11-29 15:59:49

因此，我尝试使用 EffectComposer 动态屏蔽 UnrealBloomPass，但我得到了意想不到的结果。我不确定我是否在这里遗漏了一个关键概念，或者我是否应该尝试以不同的方式实现这一点。任何输入将不胜感激。

Composer 被设置到这些层中:

hexgradientPass(主要内容)
maskingPass(我正在尝试用鼠标动态移动它)
bloomPass(我正试图用 ^ 掩盖它)
clearMaskPass(清除 mask )
effectCopyPass(应用效果)

我一直在尽可能密切地关注教程和示例，但仍然没有骰子。提前致谢。

 <!DOCTYPE html>
<html lang="en">
    <head>
        <title>BloomShader Mask</title>
        <meta charset="utf-8">
        <meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0">
        <style>
            body {
                color: #fff;
                font-family:Monospace;
                font-size:13px;
                text-align:center;
                background-color: #fff;
                margin: 0px;
                overflow: hidden;
            }
            #info {
                position: absolute;
                top: 0px;
                width: 100%;
                padding: 5px;
            }
            #info p {
                max-width: 600px;
                margin-left: auto;
                margin-right: auto;
                padding: 0 2em;
            }
            a {
                color: #2983ff;
            }
        </style>
    </head>
    <body>
        <div id="container"></div>
        <script src="./build/three.js"></script>
        <script src="js/libs/stats.min.js"></script>
        <script src="js/libs/dat.gui.min.js"></script>
        <script src="js/controls/OrbitControls.js"></script>
        <script src="js/loaders/GLTFLoader.js"></script>
        <script src="js/postprocessing/EffectComposer.js"></script>
        <script src="js/postprocessing/RenderPass.js"></script>
        <script src="js/postprocessing/ShaderPass.js"></script>
        <script src="js/postprocessing/MaskPass.js  "></script>
        <script src="js/shaders/CopyShader.js"></script>
        <script src="js/shaders/LuminosityHighPassShader.js"></script>
        <script src="js/postprocessing/UnrealBloomPass.js"></script>
    <script id="gradientShader" type="shader-code">
      uniform vec2 resolution;
      uniform vec2 mousePosition;
      void main() {
        vec2 pos = (gl_FragCoord.xy - mousePosition.xy * 1.2) / resolution.xy;
        gl_FragColor = vec4(1.0, pos.x, pos.y, 1.0);
      }
    </script>
    <script>
      var clock = new THREE.Clock();
      var stats;
      var gui;
      var sceneHexGradient;
      var sceneMask;
      var camera; 
      var orbitControls;
      var pointLight;
      var composer;
      var mixer;
      var maskerMesh;
      var bloomPass;
      var width = 0;
      var height = 0;
      var cameraZoom = 120;
      var mousePositionY = 0;

      var params = {
          exposure: 2,
          bloomStrength: .81,
          bloomThreshold: 0,
          bloomRadius: .05,
          cameraZoom: cameraZoom
      };

      function init() {
        // Init vars (DOM needed)
        gui = initGui();
        stats = initStats();
        width = window.innerWidth;
        height = window.innerHeight;
        pixelRatio = window.devicePixelRatio;

        // Renderer
        var webGLRenderer = new THREE.WebGLRenderer({ antialias: true });
        webGLRenderer.setClearColor(new THREE.Color(0x000000, 1.0));
        webGLRenderer.setPixelRatio(pixelRatio);
        webGLRenderer.setSize(width , height);
        webGLRenderer.toneMapping = THREE.ReinhardToneMapping;
        webGLRenderer.shadowMap.enabled = true;
        appendChild(webGLRenderer.domElement);

        // Scene
        sceneHexGradient = new THREE.Scene();
        sceneMasker = new THREE.Scene();

        // Camera
        camera = new THREE.OrthographicCamera(-width, width, height, -height, -1000, 1000);
        camera.zoom = cameraZoom;
        camera.lookAt(new THREE.Vector3(0, 0, 0));
        camera.updateProjectionMatrix();

        sceneHexGradient.add(camera);
        sceneMasker.add(camera);

        // Orbit
        orbitControls = new THREE.OrbitControls(camera, webGLRenderer.domElement);
        orbitControls.maxPolarAngle = Math.PI * 0.5;
        orbitControls.minDistance = 1;
        orbitControls.maxDistance = 10;

        // Draw onto Scenes
        drawGradientToScene(sceneHexGradient);
        drawHexToScene(sceneHexGradient);
        drawMaskerToScene(sceneMasker);

        // ShaderPass
        var hexgradientPass = new THREE.RenderPass(sceneHexGradient, camera);
        hexgradientPass.clear = false;

        var effectCopyPass = new THREE.ShaderPass(THREE.CopyShader);
        effectCopyPass.renderToScreen = true;

        var maskingPass = new THREE.MaskPass(sceneMasker, camera);
        maskingPass.clear = true;
        // var maskingPass = new THREE.RenderPass(sceneMasker, camera);
        // maskingPass.renderToScreen = true;

        bloomPass = new THREE.UnrealBloomPass(new THREE.Vector2(width, height), 1.5, 0.4, 0.85);
        bloomPass.renderToScreen = true;
        bloomPass.threshold = params.bloomThreshold;
        bloomPass.strength = params.bloomStrength;
        bloomPass.radius = params.bloomRadius;

        var clearMaskPass = new THREE.ClearMaskPass();

        composer = new THREE.EffectComposer(webGLRenderer);
        composer.renderTarget1.stencilBuffer = true;
        composer.renderTarget2.stencilBuffer = true;
        composer.setSize(width, height);
        composer.addPass(hexgradientPass); 
        composer.addPass(maskingPass);
        // composer.addPass(maskingVerticalBlurPass);
        composer.addPass(bloomPass);
        composer.addPass(clearMaskPass);
        composer.addPass(effectCopyPass);

        render();

        function initStats() { // Debug only 
          var stats = new Stats();
          stats.setMode(0);
          stats.domElement.style.position = 'absolute';
          stats.domElement.style.left = '0px';
          stats.domElement.style.top = '0px';
          appendChild(stats.dom);
          return stats;
        }

        function initGui() { // Debug only
                gui = new dat.GUI();

          gui.add(params, 'exposure', 0.1, 2 ).onChange((value) => {
            webGLRenderer.toneMappingExposure = Math.pow(value, 4.0);
          });

          gui.add(params, 'bloomThreshold', 0.0, 1.0).onChange((value) => {
            bloomPass.threshold = Number(value);
          });

          gui.add(params, 'bloomStrength', 0.0, 3.0).onChange((value) => {
            bloomPass.strength = Number(value);
          });

          gui.add(params, 'bloomRadius', 0.0, 1.0).step(0.01).onChange((value) => {
            bloomPass.radius = Number(value);
          });

          gui.add(params, 'cameraZoom', 100, 150).onChange((value) => {
            camera.zoom = Number(value);
            camera.updateProjectionMatrix();
          });

          return gui;
        }

        function appendChild(domElement) {
          var container = document.getElementById('container');
          if (container) {
            return container.appendChild(domElement);
          }
          return false;
        }

        function drawGradientToScene(scene) {
          var gradientUniforms = {};
          gradientUniforms["resolution"] = { type:'v2', value:new THREE.Vector2(width, height)};
          gradientUniforms['mousePosition'] = { type:'v2', value:new THREE.Vector2(0, 0) };
          var shaderCode = document.getElementById('gradientShader').innerHTML;
          var material = new THREE.ShaderMaterial({ uniforms:gradientUniforms, fragmentShader:shaderCode });
          var geometry = new THREE.PlaneBufferGeometry(width, height);
          var mesh = new THREE.Mesh(geometry, material);
          scene.add(mesh);
        }

        function drawHexToScene(scene) {
          var hexes = [];
          var colCount = 100;
          var rowCount = 100;
          var hexDiameter = 1;
          var xStart = -(colCount) * hexDiameter * 0.5;
          var rowSpace = Math.sqrt(3) * (hexDiameter * 0.5);
          var yStart = (rowCount - 1) * (rowSpace * 0.5);

          var hexGeom = new THREE.CylinderGeometry(hexDiameter * .55, hexDiameter * .55, 0.0625, 6, 1);
          hexGeom.rotateX(Math.PI * 0.5);
          for (let j = 0; j < rowCount; j++) {
            for (let i = 0; i < colCount + (j % 2 === 0 ? 0 : 1); i++) {
              let hex = new THREE.Mesh(hexGeom, new THREE.MeshBasicMaterial({
                color: 0x000000,
                wireframe: false,
              }));
              var x = (xStart + i * hexDiameter + (j % 2 === 0 ? 0.5 * hexDiameter : 0));
              var y = (yStart - j * rowSpace);
              hex.position.set(x, y, 0);
              hexes.push(hex);
              scene.add(hex);
            }
          }
        }

        function drawMaskerToScene(scene) {
          var boxGeometry = new THREE.BoxGeometry(width, height, 10);
          var basicMaterial = new THREE.MeshBasicMaterial({ color: 0xffffff });
          maskerMesh = new THREE.Mesh(boxGeometry, basicMaterial);
          maskerMesh.position.y = -height;
          scene.add(maskerMesh);
        }  

        function onResze() {
          camera.position.set(0, 0, -15);
          camera.zoom = cameraZoom;
          camera.updateProjectionMatrix();
                  composer.setSize(width, height);
        }

        function onMouseMove(event) {
          mousePositionY = event.clientY; 
        }

        function render() {
          webGLRenderer.autoClear = false;
          stats.update();

          var delta = clock.getDelta();
          // orbitControls.update(delta);

          requestAnimationFrame(render);

          maskerMesh.position.y = mousePositionY;
          // composer.setSize(window.innerWidth, window.innerHeight);
          composer.render();
        }

        window.addEventListener('mousemove', onMouseMove);
    } // End - init 
    // Listeners
    window.onload = init;
    window.onresize = init.onResze;
        </script>
    </body>
</html>

最佳答案

这实际上是一个问题的组合。主要问题是在通行证上设置标志，以清除或渲染到屏幕。这不是一件容易调试的事情:

<!DOCTYPE html>
<html lang="en">
<head>
    <title>BloomShader Mask</title>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, user-scalable=no, 
    minimum-scale=1.0, maximum-scale=1.0">
    <style>
        body {
            color: #fff;
            font-family:Monospace;
            font-size:13px;
            text-align:center;
            background-color: #fff;
            margin: 0px;
            overflow: hidden;
        }
        #info {
            position: absolute;
            top: 0px;
            width: 100%;
            padding: 5px;
        }
        #info p {
            max-width: 600px;
            margin-left: auto;
            margin-right: auto;
            padding: 0 2em;
        }
        a {
            color: #2983ff;
        }
    </style>
</head>
<body>
    <div id="container"></div>
    <script src="./build/three.js"></script>
    <script src="js/libs/stats.min.js"></script>
    <script src="js/libs/dat.gui.min.js"></script>
<script src="js/controls/OrbitControls.js"></script>
    <script src="js/loaders/GLTFLoader.js"></script>
    <script src="js/postprocessing/EffectComposer.js"></script>
<script src="js/postprocessing/ClearPass.js"></script>
    <script src="js/postprocessing/RenderPass.js"></script>
<script src="js/postprocessing/ShaderPass.js"></script>
<script src="js/postprocessing/MaskPass.js  "></script>
    <script src="js/shaders/CopyShader.js"></script>
    <script src="js/shaders/LuminosityHighPassShader.js"></script>
<script src="js/postprocessing/UnrealBloomPass.js"></script>
<script id="gradientShader" type="shader-code">
  uniform vec2 resolution;
  uniform vec2 mousePosition;
  void main() {
    vec2 pos = ((gl_FragCoord.xy - mousePosition.xy * 1.3) / resolution.xy);
    gl_FragColor = vec4(1.0, pos.x, pos.y, 1.0);
  }
</script>
    <script>
  var clock = new THREE.Clock();
  var stats;
  var gui;
  var sceneHexGradient;
  var sceneBloomMasker;
  var sceneMasker;
  var camera; 
  var orbitControls;
  var pointLight;
  var composer;
  var mixer;
  var maskerMesh;
  var bloomPass;
  var width = 0;
  var height = 0;
  var cameraZoom = 120;
  var mousePositionY = 0;

        var params = {
            exposure: 2, //1.1
            bloomStrength: 1.75,
            bloomThreshold: 0,
    bloomRadius: .16,
    cameraZoom: cameraZoom
        };

  function init() {
    // Init vars (DOM needed)
    gui = initGui();
    stats = initStats();
    width = window.innerWidth;
    height = window.innerHeight;
    pixelRatio = window.devicePixelRatio;

    // Camera
    camera = new THREE.OrthographicCamera(-width, width, height, -height, -1000, 1000);
    camera.zoom = cameraZoom;
    camera.lookAt(new THREE.Vector3(0, 0, 0));
    camera.updateProjectionMatrix();

    // Renderer
    var webGLRenderer = new THREE.WebGLRenderer({ antialias: true });
    webGLRenderer.setClearColor(new THREE.Color(0x000000, 1.0));
    webGLRenderer.setPixelRatio(pixelRatio);
    webGLRenderer.setSize(width , height);
    webGLRenderer.toneMapping = THREE.ReinhardToneMapping;
    webGLRenderer.shadowMap.enabled = true;
    webGLRenderer.autoClear = false;
    appendChild(webGLRenderer.domElement);

    // Scene
    sceneHexGradient = new THREE.Scene();
    sceneBloom = new THREE.Scene();
    sceneMasker = new THREE.Scene();

    sceneHexGradient.add(camera);
    sceneBloom.add(camera);
    sceneMasker.add(camera);

    // Lights (are they needed ? ) 
    sceneBloom.add(new THREE.AmbientLight(0xffffff));

    // Orbit
    orbitControls = new THREE.OrbitControls(camera, webGLRenderer.domElement);
    orbitControls.maxPolarAngle = Math.PI * 0.5;
    orbitControls.minDistance = 1;
    orbitControls.maxDistance = 10;

    // Draw onto Scenes
    drawGradientToScene(sceneHexGradient);
    drawHexToScene(sceneHexGradient);
    drawMaskerToScene(sceneMasker);

    bloomPass = new THREE.UnrealBloomPass(new THREE.Vector2(width, height), 1.5, 0.4, 0.85);
    bloomPass.threshold = params.bloomThreshold;
    bloomPass.strength = params.bloomStrength;
    bloomPass.radius = params.bloomRadius;

    // ShaderPasses
    var clearPass       = new THREE.ClearPass();
    var clearMaskPass   = new THREE.ClearMaskPass();
    var hexgradientPass = new THREE.RenderPass(sceneHexGradient, camera);
    var maskingPass     = new THREE.MaskPass(sceneMasker, camera);
    var outputPass      = new THREE.ShaderPass(THREE.CopyShader);

            outputPass.renderToScreen = true;

    var parameters = {
                minFilter: THREE.LinearFilter,
                magFilter: THREE.LinearFilter,
                format: THREE.RGBFormat,
                stencilBuffer: true
            };

            var renderTarget = new THREE.WebGLRenderTarget(width, height, parameters);

    composer = new THREE.EffectComposer(webGLRenderer, renderTarget);

    composer.addPass(clearPass);
    composer.addPass(hexgradientPass); 
    composer.addPass(maskingPass);
    composer.addPass(bloomPass);
    composer.addPass(clearMaskPass);
    composer.addPass(outputPass);

    function initStats() { // Debug only 
      var stats = new Stats();
      stats.setMode(0);
      stats.domElement.style.position = 'absolute';
      stats.domElement.style.left = '0px';
      stats.domElement.style.top = '0px';
      appendChild(stats.dom);
      return stats;
    }

    function initGui() { // Debug only
            gui = new dat.GUI();

      gui.add(params, 'exposure', 0.1, 2 ).onChange((value) => {
        webGLRenderer.toneMappingExposure = Math.pow(value, 4.0);
      });

      gui.add(params, 'bloomThreshold', 0.0, 1.0).onChange((value) => {
        bloomPass.threshold = Number(value);
      });

      gui.add(params, 'bloomStrength', 0.0, 3.0).onChange((value) => {
        bloomPass.strength = Number(value);
      });

      gui.add(params, 'bloomRadius', 0.0, 1.0).step(0.01).onChange((value) => {
        bloomPass.radius = Number(value);
      });

      gui.add(params, 'cameraZoom', 100, 150).onChange((value) => {
        camera.zoom = Number(value);
        camera.updateProjectionMatrix();
      });

      return gui;
    }

    function appendChild(domElement) {
      var container = document.getElementById('container');
      if (container) {
        return container.appendChild(domElement);
      }
      return false;
    }

    function getRandomNumber(min = 1, max = 100) {
      return Math.floor(Math.random() * (+max - +min)) + +min; 
    }

    function getArrayOfRandomNumbers(count = 1, min = 1, max = 100) {
      const outArr = [];
      for( i = 0; i < count; ++i) {
        outArr.push(getRandomNumber(min, max));
      }
      return outArr.sort();
    }

    function drawBlackoutMask(scene) {
      // var x = 0, y = 0;
      // var hexDiameter = 2;
      // var shapeWidth = 10;

      // var facets = getRandomNumber(1, shapeWidth);
      // var xValuesArr = getArrayOfRandomNumbers(facets, 0, shapeWidth);
      // var yValuesArr = getArrayOfRandomNumbers(facets, 0, shapeWidth);

      // var hexGeom = new THREE.CylinderGeometry(hexDiameter * .55, hexDiameter * .55, 0.0625, 6, 1);
      // hexGeom.rotateX(Math.PI * 0.5);
      // var boxGeometry = new THREE.BoxGeometry(10, 10, 10);
      // var mesh = new THREE.Mesh(boxGeometry, new THREE.MeshBasicMaterial({ color: 0xff0000 }));
      // mesh.position.x = 0;
      // mesh.position.y = 0;
      // scene.add(mesh);  

      // for(var i = 0; i < facets; i++) {
      //   var hexGeom = new THREE.CylinderGeometry(hexDiameter * .55, hexDiameter * .55, 0.0625, 6, 1);
      //   var mesh = new THREE.Mesh(hexGeom, new THREE.MeshBasicMaterial({
      //     color: 0xff0000,
      //     wireframe: false,
      //   }));
      //   mesh.position.x = xValuesArr[i];
      //   mesh.position.y = yValuesArr[i];
      //   scene.add(mesh);
      // }          
    }

    function drawMaskerToScene(scene) {
      var boxGeometry = new THREE.CylinderBufferGeometry(width, height, 10);
      // var basicMaterial = new THREE.MeshBasicMaterial({ color: 0xffffff });
      boxGeometry.computeBoundingBox();
      var material = new THREE.ShaderMaterial({
        uniforms: {
          color1: {
            value: new THREE.Color(0xffffff)
          },
          color2: {
            value: new THREE.Color(0x000000)
          },
          bboxMin: {
            value: boxGeometry.boundingBox.min
          },
          bboxMax: {
            value: boxGeometry.boundingBox.max
          }
        },
        vertexShader: `
          uniform vec3 bboxMin;
          uniform vec3 bboxMax;

          varying vec2 vUv;

          void main() {
            vUv.y = (position.y - bboxMin.y) / (bboxMax.y - bboxMin.y);
            gl_Position = projectionMatrix * modelViewMatrix * vec4(position,1.0);
          }
        `,
        fragmentShader: `
          uniform vec3 color1;
          uniform vec3 color2;

          varying vec2 vUv;

          void main() {
            gl_FragColor = vec4(mix(color1, color2, vUv.y), 1.0);
          }
        `,
        wireframe: false
      });
      maskerMesh = new THREE.Mesh(boxGeometry, material); //basicMaterial);
      // maskerMesh.scale.set(1,1,1);
      // maskerMesh.position.y = -height;
      scene.add(maskerMesh);
    }  

    function drawGradientToScene(scene) {
      var gradientUniforms = {};
      gradientUniforms["resolution"] = { type:'v2', value:new THREE.Vector2(width, height)};
      gradientUniforms['mousePosition'] = { type:'v2', value:new THREE.Vector2(0, 0) };
      var shaderCode = document.getElementById('gradientShader').innerHTML;
      var material = new THREE.ShaderMaterial({ uniforms:gradientUniforms, fragmentShader:shaderCode });
      var geometry = new THREE.PlaneBufferGeometry(width, height);
      var mesh = new THREE.Mesh(geometry, material);
      scene.add(mesh);
    }

    function drawHexToScene(scene) {
      var hexes = [];
      var colCount = 100;
      var rowCount = 100;
      var hexDiameter = 1;
      var xStart = -(colCount) * hexDiameter * 0.5;
      var rowSpace = Math.sqrt(3) * (hexDiameter * 0.5);
      var yStart = (rowCount - 1) * (rowSpace * 0.5);

      var hexGeom = new THREE.CylinderGeometry(hexDiameter * .55, hexDiameter * .55, 0.0625, 6, 1);
      hexGeom.rotateX(Math.PI * 0.5);
      for (let j = 0; j < rowCount; j++) {
        for (let i = 0; i < colCount + (j % 2 === 0 ? 0 : 1); i++) {
          let hex = new THREE.Mesh(hexGeom, new THREE.MeshBasicMaterial({
            color: 0x000000,
            wireframe: false,
          }));
          var x = (xStart + i * hexDiameter + (j % 2 === 0 ? 0.5 * hexDiameter : 0));
          var y = (yStart - j * rowSpace);
          hex.position.set(x, y, 0);
          hexes.push(hex);
          scene.add(hex);
        }
      }
    }

    function onResze() {
      camera.position.set(0, 0, -15);
      camera.zoom = cameraZoom;
      camera.updateProjectionMatrix();
              composer.setSize(width, height);
    }

    function onMouseMove(event) {
      mousePositionY = event.clientY; 
    }

    function render() {
      webGLRenderer.autoClear = false;
      stats.update();

      var delta = clock.getDelta();

      // orbitControls.update(delta);

      requestAnimationFrame(render);

      maskerMesh.position.y = mousePositionY;
      webGLRenderer.clear();
      composer.render(delta);
    }

    window.addEventListener('mousemove', onMouseMove);
    render();
} // End - init 
// Listeners
window.onload = init;
window.onresize = init.onResze;
    </script>
</body>

关于javascript - Threejs/EffectComposer - 交互式屏蔽 UnrealBloomPass，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/54581356/

文章推荐： Javascript call() & apply() vs bind()？

文章推荐： javascript - Angular Http 拦截器 : catchError and return success

文章推荐： mysql - 何时在MySQL中使用单引号，双引号和反引号

文章推荐： javascript - 从当前鼠标位置绘制三 Angular 形

Android 屏蔽
我需要创建一个 View (作为其他 View 的 mask ) 。圆圈是透明的，外部区域是半透明的。我可以使用 canvas.clipRegion(..) 来实现它，但是 http://develo
python爬虫百度搜索屏蔽
踏入爬虫的迷宫多年以来，我一直是一个对编程充满了好奇心的人。探索着代码的世界，便如同探险家踏入密林深处，寻找未知的宝藏。最近，我将目光聚焦在了爬虫技术上，特别是百度搜索屏蔽问题上。百度搜索的诱惑
.htaccess 重定向到子文件夹(屏蔽)
我想将“www.adomain.com”重定向到“www.adomain.com/cms”。 cms 部分应该被屏蔽。我无法让它安静地工作。因此“cms”始终是网址的一部分。我尝试了这个解决方案:
ios - 屏蔽 UIView
我一直在我的 View Controller 中使用以下代码: UIView *view = [[CustomView alloc] init]; UIView *mask = [[CustomMas
iOS开发中使用UIWebView 屏蔽 alert警告框
如果是网页内容里面的alert,我们可以等网页加载完毕,也就是在webViewDidFinishLoad中执行下面的js代码,就可以屏蔽alert了
pyqt4 - 屏蔽 QLineEdit 文本
我正在使用 PyQt4 QLineEdit小部件接受密码。有一个setMasking属性，但不遵循如何设置屏蔽字符。最佳答案 editor = QLineEdit() editor.setEchoM
python - Pandas 中的动态过滤/屏蔽
我有一个包含员工信息的 Pandas 数据框，如下所示: df=pd.DataFrame({ 'Id':[1,2,3,4], 'Name':['Joe','Henry','Sam','
iphone - 屏蔽 CALayer - iPhone
我正在为 iPhone 创建一个自定义开/关切换开关(类似于标准开关)，并且我正在设置 slider 的蒙版，但调用 [[myView [layer] setMask:maskLayer] 设置
objective-c - 屏蔽 NsImageView
我如何能够在 Objective C 中屏蔽 nsimageview？例如，有一个带圆角的 nsimageview。最佳答案你不知道。如果你想以 NSImageView 不支持的方式绘制图像，则需
cocoa-touch - 屏蔽 UIImage
我正在开发一个可以更改边框或矩形 UIImage 的应用程序。边框会有所不同，但看起来 UIImage 是用剪刀剪掉的，或者有什么影响。做到这一点的最佳方法是什么？我的第一个想法是准备一堆具有我正
azure - 屏蔽 Azure 存储库中文件内的数据
我需要屏蔽数据，就像在 Azure Pipelines 中一样，但位于 Azure 存储库文件内。有没有一种方法可以设置与脚本分开存储的变量，例如在 Azure 管道中: variable = $(S
用于密码的 JavaFX TextInputDialog(屏蔽)
我没有找到解决问题的简单方法。我想使用 TextInputDialog，您必须在其中键入用户密码，以重置数据库中的所有数据。 TextInputDialog 的问题是它没有屏蔽文本，我不知道有什么选择
sql - 混淆/屏蔽/打乱个人信息
我正在寻找一种自行开发的方法来扰乱生产数据以用于开发和测试。我已经构建了几个脚本来生成随机社会安全号码、轮类出生日期、打乱电子邮件等。但我在尝试打乱客户姓名时遇到了困难。我想保留真实姓名，这样我们仍然
angularjs:屏蔽 SSN 的前五位数字
我正在尝试使用过滤器来屏蔽 SSN 的前 5 位数字，它应该看起来像这样 XXX-XX-1234 到目前为止我想出了什么: // {{SocialSecurityNumber | ssn}} angu
用于密码的 JavaFX TextInputDialog(屏蔽)
我没有找到解决问题的简单方法。我想使用 TextInputDialog，您必须在其中键入用户密码，以重置数据库中的所有数据。 TextInputDialog 的问题是它没有屏蔽文本，我不知道有什么选择
arrays - 屏蔽 Fortran 数组的更好方法？
我想屏蔽一个 Fortran 数组。这是我目前正在做的方式...... where (my_array <=15.0) mask_array = 1 elsewhere mask_ar
java - 屏蔽 JTextField 中的一些字符
当用户在用户界面上输入时，我需要屏蔽数字，用户应该看到一个屏蔽的数字，但在 Java 代码上，我应该得到整个数字，包括屏蔽的字符用户应该看到什么 4545********9632但在 Java 代码(
java - 屏蔽 javafx 文本字段输入
我正在使用 javafx 文本字段。我需要输入数字以及应符合格式 ###.###.###.### 的小数其中小数点根本不可编辑，数字可以是任何数字；不允许其他输入。并非所有数字占位符都需要填写，例如它
c++ - 屏蔽 C++ 头文件的内容
我必须交付一个小型 C++ 软件。我想用一些实现(我使用了表达式模板)来掩盖头文件，以使最终用户难以辨认，因此他们无法修改它们。我无法将代码包含在静态或动态库中。有什么方法可以屏蔽头文件的内容吗？谢
ios - 屏蔽 UIImage 并改为设置彩色图像
我正在开发一个与 gestureRecognizer 配合使用的应用程序。使用手势可以选择 UIImage(例如 rectangle.png)，并且可以使用 UIPopoverView 通过为所选图

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

javascript - Threejs/EffectComposer - 交互式屏蔽 UnrealBloomPass