Three.js 三个JS中LOD DAE对象的可见性

我正在尝试在我的ThreeJS场景中使用THREE.LOD对象。我的灵感来自

但我想进一步推动这个想法，并使用DAE模型（使用这个加载程序：）

问题是我无法切换lod级别的可见性。首先，我在渲染函数中尝试了一种自动渲染（基于到摄影机的距离，见示例）：

因为它不起作用（我的所有lod都同时显示）。我尝试了一些更手动的东西。而且，渲染器似乎没有真正使用Object3D.visibility属性，或者子级没有继承该属性

据我所知，该属性用于网格。但我不确定它是否在渲染时被检查

所以这并不像预期的那样有效：

var LodTemporaryObject = new THREE.LOD();
function LoadLod1()
{
    //TEST COLLADA LOADER
    var loader = new THREE.ColladaLoader();
    loader.options.convertUpAxis = true;

    loader.load(Lod2Path, function ( collada ) {

    dae = collada.scene;

    dae.scale.x = dae.scale.y = dae.scale.z = 0.1;
    dae.updateMatrix();
    dae.visible = false;  //THIS HAS NO EFFECT
    LodTemporaryObject.addLevel(dae,100);

    AddLodToScene(LodTemporaryObject ); //where the lod is added to the threeJS scene object
} );

}

---

那么问题：我如何实际设置（在）任何Object3D或subScene可见？

编辑：下面的答案已经过时了。可见性现在被继承。例如，请参见

3.js r.71

---

具有

WebGLRenderer

的子级不会继承可见性

解决方法是使用如下模式：

object.traverse( function( child ) {

    if ( child instanceof THREE.Mesh ) {

        child.visible = false;

    }

}

---

three.js r.64

编辑：下面的答案已经过时了。可见性现在被继承。例如，请参见

3.js r.71

---

具有

WebGLRenderer

的子级不会继承可见性

解决方法是使用如下模式：

object.traverse( function( child ) {

    if ( child instanceof THREE.Mesh ) {

        child.visible = false;

    }

}

---

three.js r.64

对于上述WestLangley答案，我提出了一个递归解决方案：

首先，使用递归函数更新子对象的可见性以匹配父对象的可见性：

function SetChildrenVisible(parent)
{
    if(parent instanceof THREE.Object3D)
    {
        for(var i = 0; i< parent.children.length; i ++)
        {
            parent.children[i].visible = parent.visible;
            SetChildrenVisible(parent.children[i]);
        }
    }
}

函数SetChildrenVisible（父级）
{
if（三个的父实例。Object3D）
{
对于（变量i=0；i

然后在我的渲染循环中：

this.m_Scene.traverse( function ( object ) {

    if ( object instanceof THREE.LOD ) {
        //save all lodLevel state before updating
        var oldVisible =[]; object.visible;
        for(var i = 0; i< object.children.length; i++)
        {
            oldVisible.push(object.children[i].visible)
        }
        //Update Lod 
        object.update( that.m_Camera );

        //Check for changes and update accordingly
        for(var i = 0; i< object.children.length; i++)
        {
            if(oldVisible[i] != object.children[i].visible )
            {
                SetChildrenVisible(object.children[i]);
            }
        }

    }

} );

此.m_场景.遍历（函数（对象）{
if（三个LOD的对象实例）{
//在更新之前保存所有级别状态
var oldVisible=[]；object.visible；
for（var i=0；i

---

目标是只更新属性已更改的对象。

对于上面的WestLangley答案，我提出了一个递归解决方案：

首先，使用递归函数更新子对象的可见性以匹配父对象的可见性：

function SetChildrenVisible(parent)
{
    if(parent instanceof THREE.Object3D)
    {
        for(var i = 0; i< parent.children.length; i ++)
        {
            parent.children[i].visible = parent.visible;
            SetChildrenVisible(parent.children[i]);
        }
    }
}

函数SetChildrenVisible（父级）
{
if（三个的父实例。Object3D）
{
对于（变量i=0；i

然后在我的渲染循环中：

this.m_Scene.traverse( function ( object ) {

    if ( object instanceof THREE.LOD ) {
        //save all lodLevel state before updating
        var oldVisible =[]; object.visible;
        for(var i = 0; i< object.children.length; i++)
        {
            oldVisible.push(object.children[i].visible)
        }
        //Update Lod 
        object.update( that.m_Camera );

        //Check for changes and update accordingly
        for(var i = 0; i< object.children.length; i++)
        {
            if(oldVisible[i] != object.children[i].visible )
            {
                SetChildrenVisible(object.children[i]);
            }
        }

    }

} );

此.m_场景.遍历（函数（对象）{
if（三个LOD的对象实例）{
//在更新之前保存所有级别状态
var oldVisible=[]；object.visible；
for（var i=0；i

目标是只更新属性已更改的对象