CSS3DObject is visible through webgl 3D Objects

I am using CSS3DRenderer for rendering HTML on FBX 3d objects. It’s working fine but when I rotate my scene, HTML is visible through 3D objects like transparent. I am new in Threejs. any advice or guidance would be greatly appreciated. I have recorded a video for your reference https://drive.google.com/file/d/1cwjZwuSWOylvCF_tBoI41J2eYbB0zMB7/view

   this.scene = new THREE.Scene();
   this.scene2 = new THREE.Scene();
   this.addRoulettable();
   this.renderThings();

   addRoulettable() {
       let t = this;
       return new Promise((resolve, reject) => {
         t.loader.load('../../assets/models/fbx/roulettetable.fbx',                      function (object) {
           object.traverse(function (child) {

             if (child['isMesh']) {

               child.castShadow = true;
               child.receiveShadow = false;

             }

             if (child instanceof THREE.Mesh) {

               var texture = t.textureLoader.load('../../assets/images/leather.jpg', function (texture) {

          texture.wrapS = texture.wrapT = THREE.RepeatWrapping;
          texture.offset.set(0, 0);
          texture.repeat.set(50, 50);

        });

        var dashboard = t.textureLoader.load('../../assets/images/greencloth.png');

        child.material = [
          new THREE.MeshStandardMaterial({
            map: dashboard,
            blending: THREE.NoBlending,
            roughness: 2,
            side: THREE.DoubleSide,
          }),
          new THREE.MeshPhysicalMaterial({
            map: texture
          }),
          new THREE.MeshPhysicalMaterial({
            map: THREE.ImageUtils.loadTexture('../../assets/images/Gradient Diagonal (Color).jpg'),
            // blending: THREE.NoBlending,
            side: THREE.DoubleSide
          }),
          new THREE.MeshStandardMaterial({
            // map: THREE.ImageUtils.loadTexture('../../assets/images/Gradient Vertical (Color).jpg'),
            // blending: THREE.NoBlending,
            color: 'orange',
            side: THREE.DoubleSide,
            roughness: 0.4,
            metalness: 0.6,
            envMapIntensity: t.settings.envMapIntensity,
            envMap: t.reflectionCube
          }),
          new THREE.MeshStandardMaterial({
            color: 0xffffff,
            roughness: t.settings.roughness,
            metalness: t.settings.metalness,
            envMapIntensity: t.settings.envMapIntensity,
            envMap: t.reflectionCube,
            transparent: true,
            opacity: 0.6
          }),
          new THREE.MeshStandardMaterial({
            color: 0xffffff,
            roughness: 0,
            metalness: 0.7,
            envMapIntensity: t.settings.envMapIntensity,
            envMap: t.reflectionCube
          }),
          new THREE.MeshPhysicalMaterial({
            color: 0x474645
          })
        ];
      }
    });

    object.position.set(0, 400, 37);

    var object3D = new THREE.Object3D;

    object3D.add(object);

    var positionVector = new THREE.Vector3();
    var box = new THREE.Box3().setFromObject(object);
    console.log(box.min, box.max, box.getSize(positionVector));
    var material = new THREE.MeshBasicMaterial({ wireframe: true });
    material.color.set('black')
    material.transparent = true;
    material.opacity = 0;
    material.blending = THREE.NoBlending;

    var geometry = new THREE.PlaneGeometry(positionVector.x * 0.85, positionVector.z * 0.53);
    var planeMesh = new THREE.Mesh(geometry, material);

    planeMesh.position.y = 680;
    planeMesh.position.z = 850;
    planeMesh.rotation.copy(object.rotation);
    planeMesh.rotation.x = -90 * degree;
    planeMesh.scale.copy(object.scale);

    object3D.add(planeMesh);

    t.htmlPlane = planeMesh;
    t.rouletTable = object3D;

    t.scene.add(object3D);
    var dom = document.getElementById('battingUI');
    dom.style.height = positionVector.z * 0.53 + 'px';
    dom.style.width = positionVector.x * 0.85 + 'px';

    t.html = new CSS3DObject(dom);
    t.html.position.copy(planeMesh.position);
    t.html.rotation.copy(planeMesh.rotation);
    t.html.scale.copy(planeMesh.scale);

    t.html.buffersNeedUpdate = true;
    t.html.uvsNeedUpdate = true;

    t.scene2.add(t.html);

    resolve(true);

  }, undefined, (err) => {
    console.error(err);
    reject(err);
  });
});
}

renderThings() {
       let gameContainer = document.getElementById('container');
       this.renderer2 = new CSS3DRenderer();
       this.renderer2.setSize(this.width, this.height);
       this.renderer2.domElement.style.position = 'absolute';
       this.renderer2.domElement.style.top = '0';

       gameContainer.appendChild(this.renderer2.domElement);

       this.renderer = new THREE.WebGLRenderer({ antialias: true });
       this.renderer.setPixelRatio(window.devicePixelRatio);
       this.renderer.setClearColor(0x000000, 0);
       this.renderer.setSize(this.width, this.height);
       this.renderer.domElement.style.zIndex = 1;
       this.renderer.shadowMap.enabled = true;
       this.renderer.shadowMap.type = THREE.PCFSoftShadowMap;

       gameContainer.appendChild(this.renderer.domElement);
}

I’m afraid this is a limitation of CSS3DRenderer. HTML elements are rendered on top of your canvas. They don’t share a common depth test with the actual 3D scene rendered via WebGL.

Consider to implement the current CSS3DObjects as meshes with a PlaneBufferGeometry and appropriate (textured) materials.

1 Like

Shall I use PlaneBufferGeometry instead of PlaneGeometry to resolve this issue?

You can mix CSS3D with the regular scene, but it’s a little tricky https://codepen.io/Fyrestar/pen/QOXJaJ

2 Likes

I did exactly same, see my code. Can you please direct me where should i make changes in code to resolve this issue?

Checked many things but still no progress. Checked Embedding webpages in a 3D Three.js scene example, its working fine, but in my case, when i putting same webgl objects in application, css3dobjects are visible through :frowning:

2 Likes

I’ve had similar problems with CSS3DRender before. You can use ion 3D Engine and unlike CSS3DRenderer, zooming does not not affect the resolution since it is rendered as texture on the plane mesh. Also it won’t be have those visibility issues.