API
Return to top
Fog
编辑

场景 / Fog

Fog Class
​

环境雾

环境雾是一种大气效果，可以模拟雾、大气灰尘等渲染真实的大气效果，在场景中制造云雾缭绕的氛围感。

环境雾中的属性与方法均为 static ， Fog 直接调用即可设置环境雾。其中比较常用的有：

  • enabled 静态属性开启设为 TRUE 才可使用环境雾功能。

  • directionalInscatteringColor 静态属性表示雾的颜色。

  • density 静态属性表示雾的密度。

  • startDistance 静态属性表示雾与摄像机的距离。

Table of contents ​

Accessors
​

density(): number client
获取雾密度
directionalInscatteringColor(): LinearColor client
获取太阳光散射颜色,控制定向散射的颜色,该颜色用于近似太阳光的散射.
directionalInscatteringExponent(): number client
获取太阳光散射指数,控制定向散射锥的大小,该圆锥用于近似来自太阳光的散射.
directionalInscatteringStartDistance(): number client
获取太阳光散射初始距离,控制与定向散射查看器的起始距离,定向散射用于近似太阳光的散射.
enabled(): boolean client
获取是否启用环境雾
height(): number client
获取雾高度
heightFalloff(): number client
获取雾衰弱高度(控制密度如何随着高度的降低而增加.值越小,可见过渡越大.)
inscatteringColor(): LinearColor client
获取雾散射颜色
maxOpacity(): number client
获取雾最大透明度(值为1表示雾可以在远处变得完全不透明并完全替换场景颜色,值为0表示根本不会考虑雾颜色.)
startDistance(): number client
获取雾起始距离(到摄像机的距离)

Methods
​

setPreset(presetIndex: FogPreset): void client
设置雾预设

Accessors ​

density
​

• Static get density(): number client

• Static set density(value): void client

获取雾密度

Returns ​

number雾密度

设置雾密度

Parameters ​

value number雾密度
使用示例: 可按如下操作控制编辑器后处理实时效果

创建一个名为"FogExample"的脚本，放置在对象栏中，打开脚本，输入以下代码，运行游戏，你将可以通过1和2键控制雾密度

ts
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加雾密度
                Fog.density += 1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少雾密度
                Fog.density -= 1;
            });
        }
    }
}
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加雾密度
                Fog.density += 1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少雾密度
                Fog.density -= 1;
            });
        }
    }
}
使用示例: 可按如下操作控制编辑器后处理实时效果

创建一个名为"FogExample"的脚本，放置在对象栏中，打开脚本，输入以下代码，运行游戏，你将可以通过1和2键控制雾密度

ts
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加雾密度
                Fog.density += 1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少雾密度
                Fog.density -= 1;
            });
        }
    }
}
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加雾密度
                Fog.density += 1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少雾密度
                Fog.density -= 1;
            });
        }
    }
}

directionalInscatteringColor
​

• Static get directionalInscatteringColor(): LinearColor client

• Static set directionalInscatteringColor(value): void client

获取太阳光散射颜色,控制定向散射的颜色,该颜色用于近似太阳光的散射.

Returns ​

LinearColor太阳光散射颜色

设置太阳光散射颜色,控制定向散射的颜色,该颜色用于近似太阳光的散射.

Parameters ​

value LinearColor太阳光散射颜色
使用示例: 可按如下操作控制编辑器后处理实时效果

创建一个名为"FogExample"的脚本，放置在对象栏中，打开脚本，输入以下代码，运行游戏，你将可以通过1键控制太阳光散射颜色

ts
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 太阳光散射颜色
                Fog.directionalInscatteringColor = LinearColor.red;
            });
        }
    }
}
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 太阳光散射颜色
                Fog.directionalInscatteringColor = LinearColor.red;
            });
        }
    }
}
使用示例: 可按如下操作控制编辑器后处理实时效果

创建一个名为"FogExample"的脚本，放置在对象栏中，打开脚本，输入以下代码，运行游戏，你将可以通过1键控制太阳光散射颜色

ts
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 太阳光散射颜色
                Fog.directionalInscatteringColor = LinearColor.red;
            });
        }
    }
}
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 太阳光散射颜色
                Fog.directionalInscatteringColor = LinearColor.red;
            });
        }
    }
}

directionalInscatteringExponent
​

• Static get directionalInscatteringExponent(): number client

• Static set directionalInscatteringExponent(value): void client

获取太阳光散射指数,控制定向散射锥的大小,该圆锥用于近似来自太阳光的散射.

Returns ​

number太阳光散射指数

设置太阳光散射指数,控制定向散射锥的大小,该圆锥用于近似来自太阳光的散射.

Parameters ​

value number太阳光散射指数
使用示例: 可按如下操作控制编辑器后处理实时效果

创建一个名为"FogExample"的脚本，放置在对象栏中，打开脚本，输入以下代码，运行游戏，你将可以通过1和2键控制太阳光散射指数

ts
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加太阳光散射指数
                Fog.directionalInscatteringExponent += 0.1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少太阳光散射指数
                Fog.directionalInscatteringExponent -= 0.1;
            });
        }
    }
}
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加太阳光散射指数
                Fog.directionalInscatteringExponent += 0.1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少太阳光散射指数
                Fog.directionalInscatteringExponent -= 0.1;
            });
        }
    }
}
使用示例: 可按如下操作控制编辑器后处理实时效果

创建一个名为"FogExample"的脚本，放置在对象栏中，打开脚本，输入以下代码，运行游戏，你将可以通过1和2键控制太阳光散射指数

ts
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加太阳光散射指数
                Fog.directionalInscatteringExponent += 0.1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少太阳光散射指数
                Fog.directionalInscatteringExponent -= 0.1;
            });
        }
    }
}
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加太阳光散射指数
                Fog.directionalInscatteringExponent += 0.1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少太阳光散射指数
                Fog.directionalInscatteringExponent -= 0.1;
            });
        }
    }
}

directionalInscatteringStartDistance
​

• Static get directionalInscatteringStartDistance(): number client

• Static set directionalInscatteringStartDistance(value): void client

获取太阳光散射初始距离,控制与定向散射查看器的起始距离,定向散射用于近似太阳光的散射.

Returns ​

number太阳光散射初始距离

设置太阳光散射初始距离,控制与定向散射查看器的起始距离,定向散射用于近似太阳光的散射.

Parameters ​

value number太阳光散射初始距离
使用示例: 可按如下操作控制编辑器后处理实时效果

创建一个名为"FogExample"的脚本，放置在对象栏中，打开脚本，输入以下代码，运行游戏，你将可以通过1和2键控制太阳光散射初始距离

ts
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加太阳光散射初始距离
                Fog.directionalInscatteringStartDistance += 0.1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少太阳光散射初始距离
                Fog.directionalInscatteringStartDistance -= 0.1;
            });
        }
    }
}
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加太阳光散射初始距离
                Fog.directionalInscatteringStartDistance += 0.1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少太阳光散射初始距离
                Fog.directionalInscatteringStartDistance -= 0.1;
            });
        }
    }
}
使用示例: 可按如下操作控制编辑器后处理实时效果

创建一个名为"FogExample"的脚本，放置在对象栏中，打开脚本，输入以下代码，运行游戏，你将可以通过1和2键控制太阳光散射初始距离

ts
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加太阳光散射初始距离
                Fog.directionalInscatteringStartDistance += 0.1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少太阳光散射初始距离
                Fog.directionalInscatteringStartDistance -= 0.1;
            });
        }
    }
}
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加太阳光散射初始距离
                Fog.directionalInscatteringStartDistance += 0.1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少太阳光散射初始距离
                Fog.directionalInscatteringStartDistance -= 0.1;
            });
        }
    }
}

enabled
​

• Static get enabled(): boolean client

• Static set enabled(value): void client

获取是否启用环境雾

Returns ​

boolean是否启用

设置是否启用环境雾

Parameters ​

value boolean是否启用
使用示例: 可按如下操作控制编辑器后处理实时效果。创建一个名为"FogExample"的脚本，放置在对象栏中，打开脚本，输入以下代码，运行游戏，你将可以通过1和2键控制雾开启关闭
ts
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 开启雾效
                Fog.enabled = true;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 关闭雾效
                Fog.enabled = false;
            });
        }
    }
}
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 开启雾效
                Fog.enabled = true;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 关闭雾效
                Fog.enabled = false;
            });
        }
    }
}
使用示例: 可按如下操作控制编辑器后处理实时效果

创建一个名为"FogExample"的脚本，放置在对象栏中，打开脚本，输入以下代码，运行游戏，你将可以通过1和2键控制雾开启关闭

ts
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 开启雾效
                Fog.enabled = true;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 关闭雾效
                Fog.enabled = false;
            });
        }
    }
}
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 开启雾效
                Fog.enabled = true;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 关闭雾效
                Fog.enabled = false;
            });
        }
    }
}

height
​

• Static get height(): number client

• Static set height(value): void client

获取雾高度

Returns ​

number雾高度

设置雾高度

Parameters ​

value number雾高度
使用示例: 可按如下操作控制编辑器后处理实时效果

创建一个名为"FogExample"的脚本，放置在对象栏中，打开脚本，输入以下代码，运行游戏，你将可以通过1和2键控制雾高度

ts
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加雾高度
                Fog.height += 1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少雾高度
                Fog.height -= 1;
            });
        }
    }
}
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加雾高度
                Fog.height += 1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少雾高度
                Fog.height -= 1;
            });
        }
    }
}
使用示例: 可按如下操作控制编辑器后处理实时效果

创建一个名为"FogExample"的脚本，放置在对象栏中，打开脚本，输入以下代码，运行游戏，你将可以通过1和2键控制雾高度

ts
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加雾高度
                Fog.height += 1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少雾高度
                Fog.height -= 1;
            });
        }
    }
}
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加雾高度
                Fog.height += 1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少雾高度
                Fog.height -= 1;
            });
        }
    }
}

heightFalloff
​

• Static get heightFalloff(): number client

• Static set heightFalloff(value): void client

获取雾衰弱高度(控制密度如何随着高度的降低而增加.值越小,可见过渡越大.)

Returns ​

number雾衰弱高度

设置雾衰弱高度(控制密度如何随着高度的降低而增加.值越小,可见过渡越大.)

Parameters ​

value number雾衰弱高度
使用示例: 可按如下操作控制编辑器后处理实时效果

创建一个名为"FogExample"的脚本，放置在对象栏中，打开脚本，输入以下代码，运行游戏，你将可以通过1和2键控制雾衰弱高度

ts
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加雾衰弱高度
                Fog.heightFalloff += 1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少雾衰弱高度
                Fog.heightFalloff -= 1;
            });
        }
    }
}
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加雾衰弱高度
                Fog.heightFalloff += 1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少雾衰弱高度
                Fog.heightFalloff -= 1;
            });
        }
    }
}
使用示例: 可按如下操作控制编辑器后处理实时效果

创建一个名为"FogExample"的脚本，放置在对象栏中，打开脚本，输入以下代码，运行游戏，你将可以通过1和2键控制雾衰弱高度

ts
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加雾衰弱高度
                Fog.heightFalloff += 1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少雾衰弱高度
                Fog.heightFalloff -= 1;
            });
        }
    }
}
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加雾衰弱高度
                Fog.heightFalloff += 1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少雾衰弱高度
                Fog.heightFalloff -= 1;
            });
        }
    }
}

inscatteringColor
​

• Static get inscatteringColor(): LinearColor client

• Static set inscatteringColor(value): void client

获取雾散射颜色

Returns ​

LinearColor雾散射颜色

设置雾散射颜色

Parameters ​

value LinearColor雾散射颜色
使用示例: 可按如下操作控制编辑器后处理实时效果

创建一个名为"FogExample"的脚本，放置在对象栏中，打开脚本，输入以下代码，运行游戏，你将可以通过1键控制雾散射颜色

ts
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 设置雾散射颜色
                Fog.inscatteringColor = LinearColor.red;
            });
        }
    }
}
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 设置雾散射颜色
                Fog.inscatteringColor = LinearColor.red;
            });
        }
    }
}
使用示例: 可按如下操作控制编辑器后处理实时效果

创建一个名为"FogExample"的脚本，放置在对象栏中，打开脚本，输入以下代码，运行游戏，你将可以通过1键控制雾散射颜色

ts
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 设置雾散射颜色
                Fog.inscatteringColor = LinearColor.red;
            });
        }
    }
}
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 设置雾散射颜色
                Fog.inscatteringColor = LinearColor.red;
            });
        }
    }
}

maxOpacity
​

• Static get maxOpacity(): number client

• Static set maxOpacity(value): void client

获取雾最大透明度(值为1表示雾可以在远处变得完全不透明并完全替换场景颜色,值为0表示根本不会考虑雾颜色.)

Returns ​

number雾最大透明度

设置雾最大透明度(值为1表示雾可以在远处变得完全不透明并完全替换场景颜色,值为0表示根本不会考虑雾颜色.)

Parameters ​

value number雾最大透明度
使用示例: 可按如下操作控制编辑器后处理实时效果

创建一个名为"FogExample"的脚本，放置在对象栏中，打开脚本，输入以下代码，运行游戏，你将可以通过1和2键控制雾最大透明度

ts
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加雾最大透明度
                Fog.maxOpacity += 0.1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少雾最大透明度
                Fog.maxOpacity -= 0.1;
            });
        }
    }
}
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加雾最大透明度
                Fog.maxOpacity += 0.1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少雾最大透明度
                Fog.maxOpacity -= 0.1;
            });
        }
    }
}
使用示例: 可按如下操作控制编辑器后处理实时效果

创建一个名为"FogExample"的脚本，放置在对象栏中，打开脚本，输入以下代码，运行游戏，你将可以通过1和2键控制雾最大透明度

ts
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加雾最大透明度
                Fog.maxOpacity += 0.1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少雾最大透明度
                Fog.maxOpacity -= 0.1;
            });
        }
    }
}
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加雾最大透明度
                Fog.maxOpacity += 0.1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少雾最大透明度
                Fog.maxOpacity -= 0.1;
            });
        }
    }
}

startDistance
​

• Static get startDistance(): number client

• Static set startDistance(value): void client

获取雾起始距离(到摄像机的距离)

Returns ​

number雾起始距离

设置雾起始距离(到摄像机的距离)

Parameters ​

value number雾起始距离
使用示例: 可按如下操作控制编辑器后处理实时效果

创建一个名为"FogExample"的脚本，放置在对象栏中，打开脚本，输入以下代码，运行游戏，你将可以通过1和2键控制雾起始距离

ts
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加雾起始距离
                Fog.startDistance += 0.1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少雾起始距离
                Fog.startDistance -= 0.1;
            });
        }
    }
}
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加雾起始距离
                Fog.startDistance += 0.1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少雾起始距离
                Fog.startDistance -= 0.1;
            });
        }
    }
}
使用示例: 可按如下操作控制编辑器后处理实时效果

创建一个名为"FogExample"的脚本，放置在对象栏中，打开脚本，输入以下代码，运行游戏，你将可以通过1和2键控制雾起始距离

ts
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加雾起始距离
                Fog.startDistance += 0.1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少雾起始距离
                Fog.startDistance -= 0.1;
            });
        }
    }
}
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 增加雾起始距离
                Fog.startDistance += 0.1;
            });
            InputUtil.onKeyDown(Keys.Two, () => {
                // 减少雾起始距离
                Fog.startDistance -= 0.1;
            });
        }
    }
}

Methods ​

setPreset
​

• Static setPreset(presetIndex): void client

设置雾预设

Parameters ​

presetIndex FogPreset雾预设
default:null
使用示例: 可按如下操作控制编辑器后处理实时效果创建一个名为"FogExample"的脚本，放置在对象栏中，打开脚本，输入以下代码，运行游戏，你将可以通过1键控制雾预设
ts
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 雾预设
                Fog.setPreset(FogPreset.NearFog)
            });
        }
    }
}
@Component
export default class FogExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected async onStart(): `Promise`<`void`\> {
        if (SystemUtil.isClient()) {
            InputUtil.onKeyDown(Keys.One, () => {
                // 雾预设
                Fog.setPreset(FogPreset.NearFog)
            });
        }
    }
}