Files
cocos4/cocos/rendering/custom/define.ts
T
2022-11-23 10:03:13 +08:00

1071 lines
47 KiB
TypeScript

import { ClearFlagBit, Color, Format, LoadOp, Rect, StoreOp, Viewport } from '../../gfx';
import { Camera, CSMLevel, DirectionalLight, Light, LightType, ReflectionProbe, ShadowType, SKYBOX_FLAG, SpotLight } from '../../render-scene/scene';
import { supportsR32FloatTexture } from '../define';
import { Pipeline } from './pipeline';
import { AccessType, AttachmentType, ComputeView, LightInfo, QueueHint, RasterView, ResourceResidency, SceneFlags } from './types';
import { Vec4, macro, geometry, toRadian, cclegacy } from '../../core';
import { Material } from '../../asset/assets';
import { SRGBToLinear } from '../pipeline-funcs';
import { ReflectionProbeManager } from '../reflection-probe-manager';
import { RenderWindow } from '../../render-scene/core/render-window';
// Anti-aliasing type, other types will be gradually added in the future
export enum AntiAliasing {
NONE,
FXAA,
FXAAHQ,
}
export function validPunctualLightsCulling (pipeline: Pipeline, camera: Camera) {
const sceneData = pipeline.pipelineSceneData;
const validPunctualLights = sceneData.validPunctualLights;
validPunctualLights.length = 0;
const _sphere = geometry.Sphere.create(0, 0, 0, 1);
const { spotLights } = camera.scene!;
for (let i = 0; i < spotLights.length; i++) {
const light = spotLights[i];
if (light.baked) {
continue;
}
geometry.Sphere.set(_sphere, light.position.x, light.position.y, light.position.z, light.range);
if (geometry.intersect.sphereFrustum(_sphere, camera.frustum)) {
validPunctualLights.push(light);
}
}
const { sphereLights } = camera.scene!;
for (let i = 0; i < sphereLights.length; i++) {
const light = sphereLights[i];
if (light.baked) {
continue;
}
geometry.Sphere.set(_sphere, light.position.x, light.position.y, light.position.z, light.range);
if (geometry.intersect.sphereFrustum(_sphere, camera.frustum)) {
validPunctualLights.push(light);
}
}
}
const _cameras: Camera[] = [];
export function getCameraUniqueID (camera: Camera) {
if (!_cameras.includes(camera)) {
_cameras.push(camera);
}
return _cameras.indexOf(camera);
}
export function getLoadOpOfClearFlag (clearFlag: ClearFlagBit, attachment: AttachmentType): LoadOp {
let loadOp = LoadOp.CLEAR;
if (!(clearFlag & ClearFlagBit.COLOR)
&& attachment === AttachmentType.RENDER_TARGET) {
if (clearFlag & SKYBOX_FLAG) {
loadOp = LoadOp.CLEAR;
} else {
loadOp = LoadOp.LOAD;
}
}
if ((clearFlag & ClearFlagBit.DEPTH_STENCIL) !== ClearFlagBit.DEPTH_STENCIL
&& attachment === AttachmentType.DEPTH_STENCIL) {
if (!(clearFlag & ClearFlagBit.DEPTH)) loadOp = LoadOp.LOAD;
if (!(clearFlag & ClearFlagBit.STENCIL)) loadOp = LoadOp.LOAD;
}
return loadOp;
}
export function getRenderArea (camera: Camera, width: number, height: number, light: Light | null = null, level = 0): Rect {
const out = new Rect();
const vp = camera ? camera.viewport : new Rect(0, 0, 1, 1);
const w = width;
const h = height;
out.x = vp.x * w;
out.y = vp.y * h;
out.width = vp.width * w;
out.height = vp.height * h;
if (light) {
switch (light.type) {
case LightType.DIRECTIONAL: {
const mainLight = light as DirectionalLight;
if (mainLight.shadowFixedArea || mainLight.csmLevel === CSMLevel.LEVEL_1) {
out.x = 0;
out.y = 0;
out.width = w;
out.height = h;
} else {
const screenSpaceSignY = cclegacy.director.root.device.capabilities.screenSpaceSignY;
out.x = level % 2 * 0.5 * w;
if (screenSpaceSignY) {
out.y = (1 - Math.floor(level / 2)) * 0.5 * h;
} else {
out.y = Math.floor(level / 2) * 0.5 * h;
}
out.width = 0.5 * w;
out.height = 0.5 * h;
}
break;
}
case LightType.SPOT: {
out.x = 0;
out.y = 0;
out.width = w;
out.height = h;
break;
}
default:
}
}
return out;
}
class FxaaData {
declare fxaaMaterial: Material;
private _updateFxaaPass () {
if (!this.fxaaMaterial) return;
const combinePass = this.fxaaMaterial.passes[0];
combinePass.beginChangeStatesSilently();
combinePass.tryCompile();
combinePass.endChangeStatesSilently();
}
private _init () {
if (this.fxaaMaterial) return;
this.fxaaMaterial = new Material();
this.fxaaMaterial._uuid = 'builtin-fxaa-material';
this.fxaaMaterial.initialize({ effectName: 'pipeline/fxaa-hq' });
for (let i = 0; i < this.fxaaMaterial.passes.length; ++i) {
this.fxaaMaterial.passes[i].tryCompile();
}
this._updateFxaaPass();
}
constructor () {
this._init();
}
}
let fxaaData: FxaaData | null = null;
export function buildFxaaPass (camera: Camera,
ppl: Pipeline,
inputRT: string) {
if (!fxaaData) {
fxaaData = new FxaaData();
}
const cameraID = getCameraUniqueID(camera);
const cameraName = `Camera${cameraID}`;
let width = camera.window.width;
let height = camera.window.height;
const area = getRenderArea(camera, width, height);
width = area.width;
height = area.height;
// Start
const clearColor = new Color(0, 0, 0, 1);
if (camera.clearFlag & ClearFlagBit.COLOR) {
clearColor.x = camera.clearColor.x;
clearColor.y = camera.clearColor.y;
clearColor.z = camera.clearColor.z;
}
clearColor.w = camera.clearColor.w;
const fxaaPassRTName = `dsFxaaPassColor${cameraName}`;
const fxaaPassDSName = `dsFxaaPassDS${cameraName}`;
// ppl.updateRenderWindow(inputRT, camera.window);
if (!ppl.containsResource(fxaaPassRTName)) {
ppl.addRenderTarget(fxaaPassRTName, Format.RGBA8, width, height, ResourceResidency.MANAGED);
ppl.addDepthStencil(fxaaPassDSName, Format.DEPTH_STENCIL, width, height, ResourceResidency.MANAGED);
}
ppl.updateRenderTarget(fxaaPassRTName, width, height);
ppl.updateDepthStencil(fxaaPassDSName, width, height);
const fxaaPassIdx = 0;
const fxaaPass = ppl.addRasterPass(width, height, 'fxaa');
fxaaPass.name = `CameraFxaaPass${cameraID}`;
fxaaPass.setViewport(new Viewport(area.x, area.y, width, height));
if (ppl.containsResource(inputRT)) {
const computeView = new ComputeView();
computeView.name = 'sceneColorMap';
fxaaPass.addComputeView(inputRT, computeView);
}
const fxaaPassView = new RasterView('_',
AccessType.WRITE, AttachmentType.RENDER_TARGET,
LoadOp.CLEAR, StoreOp.STORE,
camera.clearFlag,
clearColor);
fxaaPass.addRasterView(fxaaPassRTName, fxaaPassView);
fxaaData.fxaaMaterial.setProperty('texSize', new Vec4(width, height, 1.0 / width, 1.0 / height), fxaaPassIdx);
fxaaPass.addQueue(QueueHint.RENDER_TRANSPARENT).addCameraQuad(
camera, fxaaData.fxaaMaterial, fxaaPassIdx,
SceneFlags.NONE,
);
return { rtName: fxaaPassRTName, dsName: fxaaPassDSName };
}
export const MAX_BLOOM_FILTER_PASS_NUM = 6;
export const BLOOM_PREFILTERPASS_INDEX = 0;
export const BLOOM_DOWNSAMPLEPASS_INDEX = 1;
export const BLOOM_UPSAMPLEPASS_INDEX = BLOOM_DOWNSAMPLEPASS_INDEX + MAX_BLOOM_FILTER_PASS_NUM;
export const BLOOM_COMBINEPASS_INDEX = BLOOM_UPSAMPLEPASS_INDEX + MAX_BLOOM_FILTER_PASS_NUM;
class BloomData {
declare bloomMaterial: Material;
threshold = 0.1;
iterations = 2;
intensity = 0.8;
private _updateBloomPass () {
if (!this.bloomMaterial) return;
const prefilterPass = this.bloomMaterial.passes[BLOOM_PREFILTERPASS_INDEX];
prefilterPass.beginChangeStatesSilently();
prefilterPass.tryCompile();
prefilterPass.endChangeStatesSilently();
for (let i = 0; i < MAX_BLOOM_FILTER_PASS_NUM; ++i) {
const downsamplePass = this.bloomMaterial.passes[BLOOM_DOWNSAMPLEPASS_INDEX + i];
downsamplePass.beginChangeStatesSilently();
downsamplePass.tryCompile();
downsamplePass.endChangeStatesSilently();
const upsamplePass = this.bloomMaterial.passes[BLOOM_UPSAMPLEPASS_INDEX + i];
upsamplePass.beginChangeStatesSilently();
upsamplePass.tryCompile();
upsamplePass.endChangeStatesSilently();
}
const combinePass = this.bloomMaterial.passes[BLOOM_COMBINEPASS_INDEX];
combinePass.beginChangeStatesSilently();
combinePass.tryCompile();
combinePass.endChangeStatesSilently();
}
private _init () {
if (this.bloomMaterial) return;
this.bloomMaterial = new Material();
this.bloomMaterial._uuid = 'builtin-bloom-material';
this.bloomMaterial.initialize({ effectName: 'pipeline/bloom' });
for (let i = 0; i < this.bloomMaterial.passes.length; ++i) {
this.bloomMaterial.passes[i].tryCompile();
}
this._updateBloomPass();
}
constructor () {
this._init();
}
}
let bloomData: BloomData | null = null;
export function buildBloomPass (camera: Camera,
ppl: Pipeline,
inputRT: string,
threshold = 0.1,
iterations = 2,
intensity = 0.8) {
if (!bloomData) {
bloomData = new BloomData();
}
bloomData.threshold = threshold;
bloomData.iterations = iterations;
bloomData.intensity = intensity;
const cameraID = getCameraUniqueID(camera);
const cameraName = `Camera${cameraID}`;
let width = camera.window.width;
let height = camera.window.height;
const area = getRenderArea(camera, width, height);
width = area.width;
height = area.height;
// Start bloom
const bloomClearColor = new Color(0, 0, 0, 1);
if (camera.clearFlag & ClearFlagBit.COLOR) {
bloomClearColor.x = camera.clearColor.x;
bloomClearColor.y = camera.clearColor.y;
bloomClearColor.z = camera.clearColor.z;
}
bloomClearColor.w = camera.clearColor.w;
// ==== Bloom prefilter ===
const bloomPassPrefilterRTName = `dsBloomPassPrefilterColor${cameraName}`;
const bloomPassPrefilterDSName = `dsBloomPassPrefilterDS${cameraName}`;
width >>= 1;
height >>= 1;
if (!ppl.containsResource(bloomPassPrefilterRTName)) {
ppl.addRenderTarget(bloomPassPrefilterRTName, Format.RGBA8, width, height, ResourceResidency.MANAGED);
ppl.addDepthStencil(bloomPassPrefilterDSName, Format.DEPTH_STENCIL, width, height, ResourceResidency.MANAGED);
}
ppl.updateRenderTarget(bloomPassPrefilterRTName, width, height);
ppl.updateDepthStencil(bloomPassPrefilterDSName, width, height);
const bloomPrefilterPass = ppl.addRasterPass(width, height, 'Bloom_Prefilter');
bloomPrefilterPass.name = `CameraBloomPrefilterPass${cameraID}`;
bloomPrefilterPass.setViewport(new Viewport(area.x, area.y, width, height));
if (ppl.containsResource(inputRT)) {
const computeView = new ComputeView();
computeView.name = 'outputResultMap';
bloomPrefilterPass.addComputeView(inputRT, computeView);
}
const prefilterPassView = new RasterView('_',
AccessType.WRITE, AttachmentType.RENDER_TARGET,
LoadOp.CLEAR, StoreOp.STORE,
camera.clearFlag,
bloomClearColor);
bloomPrefilterPass.addRasterView(bloomPassPrefilterRTName, prefilterPassView);
bloomData.bloomMaterial.setProperty('texSize', new Vec4(0, 0, bloomData.threshold, 0), 0);
bloomPrefilterPass.addQueue(QueueHint.RENDER_TRANSPARENT).addCameraQuad(
camera, bloomData.bloomMaterial, 0,
SceneFlags.NONE,
);
// === Bloom downSampler ===
for (let i = 0; i < bloomData.iterations; ++i) {
const texSize = new Vec4(width, height, 0, 0);
const bloomPassDownSampleRTName = `dsBloomPassDownSampleColor${cameraName}${i}`;
const bloomPassDownSampleDSName = `dsBloomPassDownSampleDS${cameraName}${i}`;
width >>= 1;
height >>= 1;
if (!ppl.containsResource(bloomPassDownSampleRTName)) {
ppl.addRenderTarget(bloomPassDownSampleRTName, Format.RGBA8, width, height, ResourceResidency.MANAGED);
ppl.addDepthStencil(bloomPassDownSampleDSName, Format.DEPTH_STENCIL, width, height, ResourceResidency.MANAGED);
}
ppl.updateRenderTarget(bloomPassDownSampleRTName, width, height);
ppl.updateDepthStencil(bloomPassDownSampleDSName, width, height);
const bloomDownSamplePass = ppl.addRasterPass(width, height, `Bloom_Downsample${i}`);
bloomDownSamplePass.name = `CameraBloomDownSamplePass${cameraID}${i}`;
bloomDownSamplePass.setViewport(new Viewport(area.x, area.y, width, height));
const computeView = new ComputeView();
computeView.name = 'bloomTexture';
if (i === 0) {
bloomDownSamplePass.addComputeView(bloomPassPrefilterRTName, computeView);
} else {
bloomDownSamplePass.addComputeView(`dsBloomPassDownSampleColor${cameraName}${i - 1}`, computeView);
}
const downSamplePassView = new RasterView('_',
AccessType.WRITE, AttachmentType.RENDER_TARGET,
LoadOp.CLEAR, StoreOp.STORE,
camera.clearFlag,
bloomClearColor);
bloomDownSamplePass.addRasterView(bloomPassDownSampleRTName, downSamplePassView);
bloomData.bloomMaterial.setProperty('texSize', texSize, BLOOM_DOWNSAMPLEPASS_INDEX + i);
bloomDownSamplePass.addQueue(QueueHint.RENDER_TRANSPARENT).addCameraQuad(
camera, bloomData.bloomMaterial, BLOOM_DOWNSAMPLEPASS_INDEX + i,
SceneFlags.NONE,
);
}
// === Bloom upSampler ===
for (let i = 0; i < bloomData.iterations; ++i) {
const texSize = new Vec4(width, height, 0, 0);
const bloomPassUpSampleRTName = `dsBloomPassUpSampleColor${cameraName}${bloomData.iterations - 1 - i}`;
const bloomPassUpSampleDSName = `dsBloomPassUpSampleDS${cameraName}${bloomData.iterations - 1 - i}`;
width <<= 1;
height <<= 1;
if (!ppl.containsResource(bloomPassUpSampleRTName)) {
ppl.addRenderTarget(bloomPassUpSampleRTName, Format.RGBA8, width, height, ResourceResidency.MANAGED);
ppl.addDepthStencil(bloomPassUpSampleDSName, Format.DEPTH_STENCIL, width, height, ResourceResidency.MANAGED);
}
ppl.updateRenderTarget(bloomPassUpSampleRTName, width, height);
ppl.updateDepthStencil(bloomPassUpSampleDSName, width, height);
const bloomUpSamplePass = ppl.addRasterPass(width, height, `Bloom_Upsample${i}`);
bloomUpSamplePass.name = `CameraBloomUpSamplePass${cameraID}${bloomData.iterations - 1 - i}`;
bloomUpSamplePass.setViewport(new Viewport(area.x, area.y, width, height));
const computeView = new ComputeView();
computeView.name = 'bloomTexture';
if (i === 0) {
bloomUpSamplePass.addComputeView(`dsBloomPassDownSampleColor${cameraName}${bloomData.iterations - 1}`, computeView);
} else {
bloomUpSamplePass.addComputeView(`dsBloomPassUpSampleColor${cameraName}${bloomData.iterations - i}`, computeView);
}
const upSamplePassView = new RasterView('_',
AccessType.WRITE, AttachmentType.RENDER_TARGET,
LoadOp.CLEAR, StoreOp.STORE,
camera.clearFlag,
bloomClearColor);
bloomUpSamplePass.addRasterView(bloomPassUpSampleRTName, upSamplePassView);
bloomData.bloomMaterial.setProperty('texSize', texSize, BLOOM_UPSAMPLEPASS_INDEX + i);
bloomUpSamplePass.addQueue(QueueHint.RENDER_TRANSPARENT).addCameraQuad(
camera, bloomData.bloomMaterial, BLOOM_UPSAMPLEPASS_INDEX + i,
SceneFlags.NONE,
);
}
// === Bloom Combine Pass ===
const bloomPassCombineRTName = `dsBloomPassCombineColor${cameraName}`;
const bloomPassCombineDSName = `dsBloomPassCombineDS${cameraName}`;
width = area.width;
height = area.height;
if (!ppl.containsResource(bloomPassCombineRTName)) {
ppl.addRenderTarget(bloomPassCombineRTName, Format.RGBA8, width, height, ResourceResidency.MANAGED);
ppl.addDepthStencil(bloomPassCombineDSName, Format.DEPTH_STENCIL, width, height, ResourceResidency.MANAGED);
}
ppl.updateRenderTarget(bloomPassCombineRTName, width, height);
ppl.updateDepthStencil(bloomPassCombineDSName, width, height);
const bloomCombinePass = ppl.addRasterPass(width, height, 'Bloom_Combine');
bloomCombinePass.name = `CameraBloomCombinePass${cameraID}`;
bloomCombinePass.setViewport(new Viewport(area.x, area.y, width, height));
const computeViewOut = new ComputeView();
computeViewOut.name = 'outputResultMap';
bloomCombinePass.addComputeView(inputRT, computeViewOut);
const computeViewBt = new ComputeView();
computeViewBt.name = 'bloomTexture';
bloomCombinePass.addComputeView(`dsBloomPassUpSampleColor${cameraName}${0}`, computeViewBt);
const combinePassView = new RasterView('_',
AccessType.WRITE, AttachmentType.RENDER_TARGET,
LoadOp.CLEAR, StoreOp.STORE,
camera.clearFlag,
bloomClearColor);
bloomCombinePass.addRasterView(bloomPassCombineRTName, combinePassView);
bloomData.bloomMaterial.setProperty('texSize', new Vec4(0, 0, 0, bloomData.intensity), BLOOM_COMBINEPASS_INDEX);
bloomCombinePass.addQueue(QueueHint.RENDER_TRANSPARENT).addCameraQuad(
camera, bloomData.bloomMaterial, BLOOM_COMBINEPASS_INDEX,
SceneFlags.NONE,
);
return { rtName: bloomPassCombineRTName, dsName: bloomPassCombineDSName };
}
class PostInfo {
declare postMaterial: Material;
antiAliasing: AntiAliasing = AntiAliasing.NONE;
private _init () {
this.postMaterial = new Material();
this.postMaterial.name = 'builtin-post-process-material';
if (macro.ENABLE_ANTIALIAS_FXAA) {
this.antiAliasing = AntiAliasing.FXAA;
}
this.postMaterial.initialize({
effectName: 'pipeline/post-process',
defines: {
// Anti-aliasing type, currently only fxaa, so 1 means fxaa
ANTIALIAS_TYPE: this.antiAliasing,
},
});
for (let i = 0; i < this.postMaterial.passes.length; ++i) {
this.postMaterial.passes[i].tryCompile();
}
}
constructor (antiAliasing: AntiAliasing = AntiAliasing.NONE) {
this.antiAliasing = antiAliasing;
this._init();
}
}
let postInfo: PostInfo | null = null;
export function buildPostprocessPass (camera: Camera,
ppl: Pipeline,
inputTex: string,
antiAliasing: AntiAliasing = AntiAliasing.NONE) {
if (!postInfo || (postInfo && postInfo.antiAliasing !== antiAliasing)) {
postInfo = new PostInfo(antiAliasing);
}
const cameraID = getCameraUniqueID(camera);
const area = getRenderArea(camera, camera.window.width, camera.window.height);
const width = area.width;
const height = area.height;
const postprocessPassRTName = `postprocessPassRTName${cameraID}`;
const postprocessPassDS = `postprocessPassDS${cameraID}`;
if (!ppl.containsResource(postprocessPassRTName)) {
ppl.addRenderTexture(postprocessPassRTName, Format.RGBA8, width, height, camera.window);
ppl.addDepthStencil(postprocessPassDS, Format.DEPTH_STENCIL, width, height, ResourceResidency.MANAGED);
}
ppl.updateRenderWindow(postprocessPassRTName, camera.window);
ppl.updateDepthStencil(postprocessPassDS, width, height);
const postprocessPass = ppl.addRasterPass(width, height, 'Postprocess');
postprocessPass.name = `CameraPostprocessPass${cameraID}`;
postprocessPass.setViewport(new Viewport(area.x, area.y, area.width, area.height));
if (ppl.containsResource(inputTex)) {
const computeView = new ComputeView();
computeView.name = 'outputResultMap';
postprocessPass.addComputeView(inputTex, computeView);
}
const postClearColor = new Color(0, 0, 0, camera.clearColor.w);
if (camera.clearFlag & ClearFlagBit.COLOR) {
postClearColor.x = camera.clearColor.x;
postClearColor.y = camera.clearColor.y;
postClearColor.z = camera.clearColor.z;
}
const postprocessPassView = new RasterView('_',
AccessType.WRITE, AttachmentType.RENDER_TARGET,
getLoadOpOfClearFlag(camera.clearFlag, AttachmentType.RENDER_TARGET),
StoreOp.STORE,
camera.clearFlag,
postClearColor);
const postprocessPassDSView = new RasterView('_',
AccessType.WRITE, AttachmentType.DEPTH_STENCIL,
getLoadOpOfClearFlag(camera.clearFlag, AttachmentType.DEPTH_STENCIL),
StoreOp.STORE,
camera.clearFlag,
new Color(camera.clearDepth, camera.clearStencil, 0, 0));
postprocessPass.addRasterView(postprocessPassRTName, postprocessPassView);
postprocessPass.addRasterView(postprocessPassDS, postprocessPassDSView);
postprocessPass.addQueue(QueueHint.NONE).addFullscreenQuad(
postInfo.postMaterial, 0, SceneFlags.NONE,
);
postprocessPass.addQueue(QueueHint.RENDER_TRANSPARENT).addSceneOfCamera(camera, new LightInfo(),
SceneFlags.UI | SceneFlags.PROFILER);
return { rtName: postprocessPassRTName, dsName: postprocessPassDS };
}
export function buildForwardPass (camera: Camera,
ppl: Pipeline,
isOffScreen: boolean) {
const cameraID = getCameraUniqueID(camera);
const cameraName = `Camera${cameraID}`;
const cameraInfo = buildShadowPasses(cameraName, camera, ppl);
const area = getRenderArea(camera, camera.window.width, camera.window.height);
const width = area.width;
const height = area.height;
const forwardPassRTName = `dsForwardPassColor${cameraName}`;
const forwardPassDSName = `dsForwardPassDS${cameraName}`;
if (!ppl.containsResource(forwardPassRTName)) {
if (!isOffScreen) {
ppl.addRenderTexture(forwardPassRTName, Format.RGBA8, width, height, camera.window);
} else {
ppl.addRenderTarget(forwardPassRTName, Format.RGBA16F, width, height, ResourceResidency.MANAGED);
}
ppl.addDepthStencil(forwardPassDSName, Format.DEPTH_STENCIL, width, height, ResourceResidency.MANAGED);
}
if (!isOffScreen) {
ppl.updateRenderWindow(forwardPassRTName, camera.window);
} else {
ppl.updateRenderTarget(forwardPassRTName, width, height);
ppl.updateDepthStencil(forwardPassDSName, width, height);
}
const forwardPass = ppl.addRasterPass(width, height, 'default');
forwardPass.name = `CameraForwardPass${cameraID}`;
forwardPass.setViewport(new Viewport(area.x, area.y, width, height));
for (const dirShadowName of cameraInfo.mainLightShadowNames) {
if (ppl.containsResource(dirShadowName)) {
const computeView = new ComputeView();
forwardPass.addComputeView(dirShadowName, computeView);
}
}
for (const spotShadowName of cameraInfo.spotLightShadowNames) {
if (ppl.containsResource(spotShadowName)) {
const computeView = new ComputeView();
forwardPass.addComputeView(spotShadowName, computeView);
}
}
const passView = new RasterView('_',
AccessType.WRITE, AttachmentType.RENDER_TARGET,
isOffScreen ? LoadOp.CLEAR : getLoadOpOfClearFlag(camera.clearFlag, AttachmentType.RENDER_TARGET),
StoreOp.STORE,
camera.clearFlag,
new Color(camera.clearColor.x, camera.clearColor.y, camera.clearColor.z, camera.clearColor.w));
const passDSView = new RasterView('_',
AccessType.WRITE, AttachmentType.DEPTH_STENCIL,
isOffScreen ? LoadOp.CLEAR : getLoadOpOfClearFlag(camera.clearFlag, AttachmentType.DEPTH_STENCIL),
StoreOp.STORE,
camera.clearFlag,
new Color(camera.clearDepth, camera.clearStencil, 0, 0));
forwardPass.addRasterView(forwardPassRTName, passView);
forwardPass.addRasterView(forwardPassDSName, passDSView);
forwardPass
.addQueue(QueueHint.RENDER_OPAQUE)
.addSceneOfCamera(camera, new LightInfo(),
SceneFlags.OPAQUE_OBJECT | SceneFlags.PLANAR_SHADOW | SceneFlags.CUTOUT_OBJECT
| SceneFlags.DEFAULT_LIGHTING | SceneFlags.DRAW_INSTANCING);
let sceneFlags = SceneFlags.TRANSPARENT_OBJECT | SceneFlags.GEOMETRY;
if (!isOffScreen) {
sceneFlags |= SceneFlags.UI | SceneFlags.PROFILER;
}
forwardPass
.addQueue(QueueHint.RENDER_TRANSPARENT)
.addSceneOfCamera(camera, new LightInfo(), sceneFlags);
return { rtName: forwardPassRTName, dsName: forwardPassDSName };
}
export function buildShadowPass (passName: Readonly<string>,
ppl: Pipeline,
camera: Camera, light: Light, level: number,
width: Readonly<number>, height: Readonly<number>) {
const fboW = width;
const fboH = height;
const area = getRenderArea(camera, width, height, light, level);
width = area.width;
height = area.height;
const device = ppl.device;
const shadowMapName = passName;
if (!ppl.containsResource(shadowMapName)) {
const format = supportsR32FloatTexture(device) ? Format.R32F : Format.RGBA8;
ppl.addRenderTarget(shadowMapName, format, fboW, fboH, ResourceResidency.MANAGED);
ppl.addDepthStencil(`${shadowMapName}Depth`, Format.DEPTH_STENCIL, fboW, fboH, ResourceResidency.MANAGED);
}
ppl.updateRenderTarget(shadowMapName, fboW, fboH);
ppl.updateDepthStencil(`${shadowMapName}Depth`, fboW, fboH);
const pass = ppl.addRasterPass(width, height, 'default');
pass.name = passName;
pass.setViewport(new Viewport(area.x, area.y, area.width, area.height));
pass.addRasterView(shadowMapName, new RasterView('_',
AccessType.WRITE, AttachmentType.RENDER_TARGET,
LoadOp.CLEAR, StoreOp.STORE,
ClearFlagBit.COLOR,
new Color(1, 1, 1, camera.clearColor.w)));
pass.addRasterView(`${shadowMapName}Depth`, new RasterView('_',
AccessType.WRITE, AttachmentType.DEPTH_STENCIL,
LoadOp.CLEAR, StoreOp.DISCARD,
ClearFlagBit.DEPTH_STENCIL,
new Color(camera.clearDepth, camera.clearStencil, 0, 0)));
const queue = pass.addQueue(QueueHint.RENDER_OPAQUE);
queue.addSceneOfCamera(camera, new LightInfo(light, level),
SceneFlags.SHADOW_CASTER);
}
export function buildReflectionProbePasss (camera: Camera,
ppl: Pipeline,
isOffScreen: boolean) {
const probes = ReflectionProbeManager.probeManager.getProbes();
if (probes.length === 0) {
return;
}
for (let i = 0; i < probes.length; i++) {
const probe = probes[i];
if (probe.needRender) {
for (let faceIdx = 0; faceIdx < probe.bakedCubeTextures.length; faceIdx++) {
buildReflectionProbePass(camera, ppl, probe, probe.bakedCubeTextures[faceIdx].window!, faceIdx);
}
probe.needRender = false;
}
}
}
export function buildReflectionProbePass (camera: Camera,
ppl: Pipeline, probe: ReflectionProbe, renderWindow: RenderWindow, faceIdx: number) {
const cameraName = `Camera${faceIdx}`;
const area = probe.renderArea();
const width = area.x;
const height = area.y;
const probeCamera = probe.camera;
const probePassRTName = `reflectionProbePassColor${cameraName}`;
const probePassDSName = `reflectionProbePassDS${cameraName}`;
probe.updateCameraDir(faceIdx);
if (!ppl.containsResource(probePassRTName)) {
ppl.addRenderTexture(probePassRTName, Format.RGBA8, width, height, renderWindow);
ppl.addDepthStencil(probePassDSName, Format.DEPTH_STENCIL, width, height, ResourceResidency.MANAGED);
}
ppl.updateRenderWindow(probePassRTName, renderWindow);
ppl.updateDepthStencil(probePassDSName, width, height);
const probePass = ppl.addRasterPass(width, height, 'default');
probePass.name = `ReflectionProbePass${faceIdx}`;
probePass.setViewport(new Viewport(0, 0, width, height));
const passView = new RasterView('_',
AccessType.WRITE, AttachmentType.RENDER_TARGET,
getLoadOpOfClearFlag(probeCamera.clearFlag, AttachmentType.RENDER_TARGET),
StoreOp.STORE,
probeCamera.clearFlag,
new Color(probeCamera.clearColor.x, probeCamera.clearColor.y, probeCamera.clearColor.z, probeCamera.clearColor.w));
const passDSView = new RasterView('_',
AccessType.WRITE, AttachmentType.DEPTH_STENCIL,
getLoadOpOfClearFlag(probeCamera.clearFlag, AttachmentType.DEPTH_STENCIL),
StoreOp.STORE,
probeCamera.clearFlag,
new Color(probeCamera.clearDepth, probeCamera.clearStencil, 0, 0));
probePass.addRasterView(probePassRTName, passView);
probePass.addRasterView(probePassDSName, passDSView);
const passBuilder = probePass.addQueue(QueueHint.RENDER_OPAQUE);
passBuilder.addSceneOfCamera(camera, new LightInfo(), SceneFlags.REFLECTION_PROBE);
updateCameraUBO(passBuilder as unknown as any, probeCamera, ppl);
}
class CameraInfo {
shadowEnabled = false;
mainLightShadowNames = new Array<string>();
spotLightShadowNames = new Array<string>();
}
export function buildShadowPasses (cameraName: string, camera: Camera, ppl: Pipeline): CameraInfo {
validPunctualLightsCulling(ppl, camera);
const pipeline = ppl;
const shadowInfo = pipeline.pipelineSceneData.shadows;
const validPunctualLights = ppl.pipelineSceneData.validPunctualLights;
const cameraInfo = new CameraInfo();
const shadows = ppl.pipelineSceneData.shadows;
if (!shadowInfo.enabled || shadowInfo.type !== ShadowType.ShadowMap) { return cameraInfo; }
cameraInfo.shadowEnabled = true;
const _validLights: Light[] = [];
let n = 0;
let m = 0;
for (;n < shadowInfo.maxReceived && m < validPunctualLights.length;) {
const light = validPunctualLights[m];
if (light.type === LightType.SPOT) {
const spotLight = light as SpotLight;
if (spotLight.shadowEnabled) {
_validLights.push(light);
n++;
}
}
m++;
}
const { mainLight } = camera.scene!;
// build shadow map
const mapWidth = shadows.size.x;
const mapHeight = shadows.size.y;
if (mainLight && mainLight.shadowEnabled) {
cameraInfo.mainLightShadowNames[0] = `MainLightShadow${cameraName}`;
if (mainLight.shadowFixedArea) {
buildShadowPass(cameraInfo.mainLightShadowNames[0], ppl,
camera, mainLight, 0, mapWidth, mapHeight);
} else {
const csmLevel = pipeline.pipelineSceneData.csmSupported ? mainLight.csmLevel : 1;
for (let i = 0; i < csmLevel; i++) {
cameraInfo.mainLightShadowNames[i] = `MainLightShadow${cameraName}`;
buildShadowPass(cameraInfo.mainLightShadowNames[i], ppl,
camera, mainLight, i, mapWidth, mapHeight);
}
}
}
for (let l = 0; l < _validLights.length; l++) {
const light = _validLights[l];
const passName = `SpotLightShadow${l.toString()}${cameraName}`;
cameraInfo.spotLightShadowNames[l] = passName;
buildShadowPass(passName, ppl,
camera, light, 0, mapWidth, mapHeight);
}
return cameraInfo;
}
export class GBufferInfo {
color!: string;
normal!: string;
emissive!: string;
ds!: string;
}
// deferred passes
export function buildGBufferPass (camera: Camera,
ppl: Pipeline) {
const cameraID = getCameraUniqueID(camera);
const area = getRenderArea(camera, camera.window.width, camera.window.height);
const width = area.width;
const height = area.height;
const gBufferPassRTName = `gBufferPassColorCamera`;
const gBufferPassNormal = `gBufferPassNormal`;
const gBufferPassEmissive = `gBufferPassEmissive`;
const gBufferPassDSName = `gBufferPassDSCamera`;
if (!ppl.containsResource(gBufferPassRTName)) {
const colFormat = Format.RGBA16F;
ppl.addRenderTarget(gBufferPassRTName, colFormat, width, height, ResourceResidency.MANAGED);
ppl.addRenderTarget(gBufferPassNormal, colFormat, width, height, ResourceResidency.MANAGED);
ppl.addRenderTarget(gBufferPassEmissive, colFormat, width, height, ResourceResidency.MANAGED);
ppl.addDepthStencil(gBufferPassDSName, Format.DEPTH_STENCIL, width, height, ResourceResidency.MANAGED);
}
ppl.updateRenderTarget(gBufferPassRTName, width, height);
ppl.updateRenderTarget(gBufferPassNormal, width, height);
ppl.updateRenderTarget(gBufferPassEmissive, width, height);
ppl.updateDepthStencil(gBufferPassDSName, width, height);
// gbuffer pass
const gBufferPass = ppl.addRasterPass(width, height, 'Geometry');
gBufferPass.name = `CameraGBufferPass${cameraID}`;
gBufferPass.setViewport(new Viewport(area.x, area.y, area.width, area.height));
const rtColor = new Color(0, 0, 0, 0);
if (camera.clearFlag & ClearFlagBit.COLOR) {
if (ppl.pipelineSceneData.isHDR) {
SRGBToLinear(rtColor, camera.clearColor);
} else {
rtColor.x = camera.clearColor.x;
rtColor.y = camera.clearColor.y;
rtColor.z = camera.clearColor.z;
}
}
const passColorView = new RasterView('_',
AccessType.WRITE, AttachmentType.RENDER_TARGET,
LoadOp.CLEAR, StoreOp.STORE,
camera.clearFlag,
rtColor);
const passNormalView = new RasterView('_',
AccessType.WRITE, AttachmentType.RENDER_TARGET,
LoadOp.CLEAR, StoreOp.STORE,
camera.clearFlag,
new Color(0, 0, 0, 0));
const passEmissiveView = new RasterView('_',
AccessType.WRITE, AttachmentType.RENDER_TARGET,
LoadOp.CLEAR, StoreOp.STORE,
camera.clearFlag,
new Color(0, 0, 0, 0));
const passDSView = new RasterView('_',
AccessType.WRITE, AttachmentType.DEPTH_STENCIL,
LoadOp.CLEAR, StoreOp.STORE,
camera.clearFlag,
new Color(camera.clearDepth, camera.clearStencil, 0, 0));
gBufferPass.addRasterView(gBufferPassRTName, passColorView);
gBufferPass.addRasterView(gBufferPassNormal, passNormalView);
gBufferPass.addRasterView(gBufferPassEmissive, passEmissiveView);
gBufferPass.addRasterView(gBufferPassDSName, passDSView);
gBufferPass
.addQueue(QueueHint.RENDER_OPAQUE)
.addSceneOfCamera(camera, new LightInfo(), SceneFlags.OPAQUE_OBJECT | SceneFlags.CUTOUT_OBJECT);
const gBufferInfo = new GBufferInfo();
gBufferInfo.color = gBufferPassRTName;
gBufferInfo.normal = gBufferPassNormal;
gBufferInfo.emissive = gBufferPassEmissive;
gBufferInfo.ds = gBufferPassDSName;
return gBufferInfo;
}
class LightingInfo {
declare deferredLightingMaterial: Material;
private _init () {
this.deferredLightingMaterial = new Material();
this.deferredLightingMaterial.name = 'builtin-deferred-material';
this.deferredLightingMaterial.initialize({
effectName: 'pipeline/deferred-lighting',
defines: { CC_RECEIVE_SHADOW: 1 },
});
for (let i = 0; i < this.deferredLightingMaterial.passes.length; ++i) {
this.deferredLightingMaterial.passes[i].tryCompile();
}
}
constructor () {
this._init();
}
}
let lightingInfo: LightingInfo | null = null;
// deferred lighting pass
export function buildLightingPass (camera: Camera, ppl: Pipeline, gBuffer: GBufferInfo) {
if (!lightingInfo) {
lightingInfo = new LightingInfo();
}
const cameraID = getCameraUniqueID(camera);
const cameraName = `Camera${cameraID}`;
const cameraInfo = buildShadowPasses(cameraName, camera, ppl);
const area = getRenderArea(camera, camera.window.width, camera.window.height);
const width = area.width;
const height = area.height;
const deferredLightingPassRTName = `deferredLightingPassRTName`;
const deferredLightingPassDS = `deferredLightingPassDS`;
if (!ppl.containsResource(deferredLightingPassRTName)) {
ppl.addRenderTarget(deferredLightingPassRTName, Format.RGBA8, width, height, ResourceResidency.MANAGED);
ppl.addDepthStencil(deferredLightingPassDS, Format.DEPTH_STENCIL, width, height, ResourceResidency.MANAGED);
}
ppl.updateRenderTarget(deferredLightingPassRTName, width, height);
ppl.updateDepthStencil(deferredLightingPassDS, width, height);
// lighting pass
const lightingPass = ppl.addRasterPass(width, height, 'Lighting');
lightingPass.name = `CameraLightingPass${cameraID}`;
lightingPass.setViewport(new Viewport(area.x, area.y, width, height));
for (const dirShadowName of cameraInfo.mainLightShadowNames) {
if (ppl.containsResource(dirShadowName)) {
const computeView = new ComputeView();
lightingPass.addComputeView(dirShadowName, computeView);
}
}
for (const spotShadowName of cameraInfo.spotLightShadowNames) {
if (ppl.containsResource(spotShadowName)) {
const computeView = new ComputeView();
lightingPass.addComputeView(spotShadowName, computeView);
}
}
if (ppl.containsResource(gBuffer.color)) {
const computeView = new ComputeView();
computeView.name = 'gbuffer_albedoMap';
lightingPass.addComputeView(gBuffer.color, computeView);
const computeNormalView = new ComputeView();
computeNormalView.name = 'gbuffer_normalMap';
lightingPass.addComputeView(gBuffer.normal, computeNormalView);
const computeEmissiveView = new ComputeView();
computeEmissiveView.name = 'gbuffer_emissiveMap';
lightingPass.addComputeView(gBuffer.emissive, computeEmissiveView);
const computeDepthView = new ComputeView();
computeDepthView.name = 'depth_stencil';
lightingPass.addComputeView(gBuffer.ds, computeDepthView);
}
const lightingClearColor = new Color(0, 0, 0, 0);
if (camera.clearFlag & ClearFlagBit.COLOR) {
lightingClearColor.x = camera.clearColor.x;
lightingClearColor.y = camera.clearColor.y;
lightingClearColor.z = camera.clearColor.z;
}
lightingClearColor.w = 0;
const lightingPassView = new RasterView('_',
AccessType.WRITE, AttachmentType.RENDER_TARGET,
LoadOp.CLEAR, StoreOp.STORE,
camera.clearFlag,
lightingClearColor);
lightingPass.addRasterView(deferredLightingPassRTName, lightingPassView);
lightingPass.addQueue(QueueHint.RENDER_TRANSPARENT).addCameraQuad(
camera, lightingInfo.deferredLightingMaterial, 0,
SceneFlags.VOLUMETRIC_LIGHTING,
);
lightingPass.addQueue(QueueHint.RENDER_TRANSPARENT).addSceneOfCamera(camera, new LightInfo(),
SceneFlags.TRANSPARENT_OBJECT | SceneFlags.PLANAR_SHADOW | SceneFlags.GEOMETRY);
return { rtName: deferredLightingPassRTName, dsName: deferredLightingPassDS };
}
function getClearFlags (attachment: AttachmentType, clearFlag: ClearFlagBit, loadOp: LoadOp): ClearFlagBit {
switch (attachment) {
case AttachmentType.DEPTH_STENCIL:
if (loadOp === LoadOp.CLEAR) {
if (clearFlag & ClearFlagBit.DEPTH_STENCIL) {
return clearFlag;
} else {
return ClearFlagBit.DEPTH_STENCIL;
}
} else {
return ClearFlagBit.NONE;
}
case AttachmentType.RENDER_TARGET:
default:
if (loadOp === LoadOp.CLEAR) {
return ClearFlagBit.COLOR;
} else {
return ClearFlagBit.NONE;
}
}
}
export function buildNativeForwardPass (camera: Camera, ppl: Pipeline) {
const cameraID = getCameraUniqueID(camera);
const cameraName = `Camera${cameraID}`;
const area = getRenderArea(camera, camera.window.width, camera.window.height);
const width = area.width;
const height = area.height;
// Resources
const forwardPassRTName = `dsForwardPassColor${cameraName}`;
const forwardPassDSName = `dsForwardPassDS${cameraName}`;
if (!ppl.containsResource(forwardPassRTName)) {
ppl.addRenderTexture(forwardPassRTName, Format.BGRA8, width, height, camera.window);
ppl.addDepthStencil(forwardPassDSName, Format.DEPTH_STENCIL, width, height, ResourceResidency.MANAGED);
}
ppl.updateRenderWindow(forwardPassRTName, camera.window);
ppl.updateDepthStencil(forwardPassDSName, width, height);
// Passes
const forwardPass = ppl.addRasterPass(width, height, 'default');
forwardPass.name = `CameraForwardPass${cameraID}`;
forwardPass.setViewport(new Viewport(area.x, area.y, width, height));
const cameraRenderTargetLoadOp = getLoadOpOfClearFlag(camera.clearFlag, AttachmentType.RENDER_TARGET);
const cameraDepthStencilLoadOp = getLoadOpOfClearFlag(camera.clearFlag, AttachmentType.DEPTH_STENCIL);
forwardPass.addRasterView(forwardPassRTName,
new RasterView('_',
AccessType.WRITE, AttachmentType.RENDER_TARGET,
cameraRenderTargetLoadOp,
StoreOp.STORE,
getClearFlags(AttachmentType.RENDER_TARGET, camera.clearFlag, cameraRenderTargetLoadOp),
new Color(camera.clearColor.x, camera.clearColor.y, camera.clearColor.z, camera.clearColor.w)));
forwardPass.addRasterView(forwardPassDSName,
new RasterView('_',
AccessType.WRITE, AttachmentType.DEPTH_STENCIL,
cameraDepthStencilLoadOp,
StoreOp.STORE,
getClearFlags(AttachmentType.DEPTH_STENCIL, camera.clearFlag, cameraDepthStencilLoadOp),
new Color(camera.clearDepth, camera.clearStencil, 0, 0)));
forwardPass
.addQueue(QueueHint.RENDER_OPAQUE)
.addSceneOfCamera(camera, new LightInfo(),
SceneFlags.OPAQUE_OBJECT
| SceneFlags.PLANAR_SHADOW
| SceneFlags.CUTOUT_OBJECT
| SceneFlags.DEFAULT_LIGHTING
| SceneFlags.DRAW_INSTANCING);
forwardPass
.addQueue(QueueHint.RENDER_TRANSPARENT)
.addSceneOfCamera(camera, new LightInfo(),
SceneFlags.TRANSPARENT_OBJECT
| SceneFlags.GEOMETRY);
forwardPass
.addQueue(QueueHint.RENDER_TRANSPARENT)
.addSceneOfCamera(camera, new LightInfo(),
SceneFlags.UI
| SceneFlags.PROFILER);
}
export function buildNativeDeferredPipeline (camera: Camera, ppl: Pipeline) {
const cameraID = getCameraUniqueID(camera);
const area = getRenderArea(camera, camera.window.width, camera.window.height);
const width = area.width;
const height = area.height;
if (!ppl.containsResource('Albedo')) {
// GBuffers
ppl.addRenderTarget('Albedo', Format.RGBA16F, width, height, ResourceResidency.MANAGED);
ppl.addRenderTarget('Normal', Format.RGBA16F, width, height, ResourceResidency.MANAGED);
ppl.addRenderTarget('Emissive', Format.RGBA16F, width, height, ResourceResidency.MANAGED);
ppl.addDepthStencil('DepthStencil', Format.DEPTH_STENCIL, width, height, ResourceResidency.MANAGED);
// Lighting
ppl.addRenderTexture('Color', Format.BGRA8, width, height, camera.window);
}
if (!lightingInfo) {
lightingInfo = new LightingInfo();
}
// GeometryPass
{
const gBufferPass = ppl.addRasterPass(width, height, 'default');
gBufferPass.name = 'GeometryPass';
gBufferPass.setViewport(new Viewport(area.x, area.y, area.width, area.height));
gBufferPass.addRasterView('Albedo', new RasterView('_',
AccessType.WRITE, AttachmentType.RENDER_TARGET,
LoadOp.CLEAR, StoreOp.STORE, ClearFlagBit.COLOR));
gBufferPass.addRasterView('Normal', new RasterView('_',
AccessType.WRITE, AttachmentType.RENDER_TARGET,
LoadOp.CLEAR, StoreOp.STORE, ClearFlagBit.COLOR));
gBufferPass.addRasterView('Emissive', new RasterView('_',
AccessType.WRITE, AttachmentType.RENDER_TARGET,
LoadOp.CLEAR, StoreOp.STORE, ClearFlagBit.COLOR));
gBufferPass.addRasterView('DepthStencil', new RasterView('_',
AccessType.WRITE, AttachmentType.DEPTH_STENCIL,
LoadOp.CLEAR, StoreOp.STORE,
ClearFlagBit.DEPTH_STENCIL,
new Color(1, 0, 0, 0)));
gBufferPass
.addQueue(QueueHint.RENDER_OPAQUE)
.addSceneOfCamera(camera, new LightInfo(), SceneFlags.OPAQUE_OBJECT | SceneFlags.CUTOUT_OBJECT);
}
// LightingPass
{
const lightingPass = ppl.addRasterPass(width, height, 'default');
lightingPass.name = 'LightingPass';
lightingPass.setViewport(new Viewport(area.x, area.y, width, height));
const lightingClearColor = new Color(0, 0, 0, 0);
if (camera.clearFlag & ClearFlagBit.COLOR) {
lightingClearColor.x = camera.clearColor.x;
lightingClearColor.y = camera.clearColor.y;
lightingClearColor.z = camera.clearColor.z;
}
lightingClearColor.w = 1;
lightingPass.addRasterView('Color', new RasterView('_',
AccessType.WRITE, AttachmentType.RENDER_TARGET,
LoadOp.CLEAR, StoreOp.STORE,
camera.clearFlag,
lightingClearColor));
lightingPass.addComputeView('Albedo', new ComputeView('gbuffer_albedoMap'));
lightingPass.addComputeView('Normal', new ComputeView('gbuffer_normalMap'));
lightingPass.addComputeView('Emissive', new ComputeView('gbuffer_emissiveMap'));
lightingPass.addComputeView('DepthStencil', new ComputeView('depth_stencil'));
lightingPass.addQueue(QueueHint.RENDER_TRANSPARENT).addCameraQuad(
camera, lightingInfo.deferredLightingMaterial, 0,
SceneFlags.VOLUMETRIC_LIGHTING,
);
lightingPass.addQueue(QueueHint.RENDER_TRANSPARENT).addSceneOfCamera(camera,
new LightInfo(),
SceneFlags.TRANSPARENT_OBJECT | SceneFlags.PLANAR_SHADOW | SceneFlags.GEOMETRY);
}
}
export function updateCameraUBO (setter: any, camera: Readonly<Camera>, ppl: Readonly<Pipeline>) {
const pipeline = cclegacy.director.root.pipeline;
const sceneData = ppl.pipelineSceneData;
const skybox = sceneData.skybox;
setter.addConstant('CCCamera');
setter.setMat4('cc_matView', camera.matView);
setter.setMat4('cc_matViewInv', camera.node.worldMatrix);
setter.setMat4('cc_matProj', camera.matProj);
setter.setMat4('cc_matProjInv', camera.matProjInv);
setter.setMat4('cc_matViewProj', camera.matViewProj);
setter.setMat4('cc_matViewProjInv', camera.matViewProjInv);
setter.setVec4('cc_cameraPos', new Vec4(camera.position.x, camera.position.y, camera.position.z, pipeline.getCombineSignY()));
// eslint-disable-next-line max-len
setter.setVec4('cc_surfaceTransform', new Vec4(camera.surfaceTransform, 0.0, Math.cos(toRadian(skybox.getRotationAngle())), Math.sin(toRadian(skybox.getRotationAngle()))));
// eslint-disable-next-line max-len
setter.setVec4('cc_screenScale', new Vec4(sceneData.shadingScale, sceneData.shadingScale, 1.0 / sceneData.shadingScale, 1.0 / sceneData.shadingScale));
setter.setVec4('cc_exposure', new Vec4(camera.exposure, 1.0 / camera.exposure, sceneData.isHDR ? 1.0 : 0.0, 1.0 / Camera.standardExposureValue));
}