Files
cocos4/cocos/rendering/custom/effect.ts
T
2022-11-23 19:02:59 +08:00

373 lines
16 KiB
TypeScript

import { EffectAsset } from '../../asset/assets';
import { CollectVisitor, WebDescriptorHierarchy } from './web-descriptor-hierarchy';
// eslint-disable-next-line max-len
import { DescriptorBlockData, DescriptorDB, LayoutGraph, LayoutGraphData, LayoutGraphValue, ShaderProgramData } from './layout-graph';
import { LayoutGraphBuilder, Pipeline } from './pipeline';
import { ShaderStageFlagBit, Type, UniformBlock } from '../../gfx';
import { Descriptor, DescriptorBlock, DescriptorBlockFlattened, DescriptorBlockIndex, DescriptorTypeOrder,
ParameterType, UpdateFrequency } from './types';
import { depthFirstSearch, GraphColor, MutableVertexPropertyMap } from './graph';
import { SetIndex } from '../define';
function descriptorBlock2Flattened (block: DescriptorBlock, flattened: DescriptorBlockFlattened): void {
block.descriptors.forEach((value, key) => {
const name: string = key;
const d: Descriptor = value;
flattened.descriptorNames.push(name);
flattened.descriptors.push(d);
});
block.uniformBlocks.forEach((value, key) => {
const name: string = key;
const u: UniformBlock = value;
flattened.uniformBlockNames.push(name);
flattened.uniformBlocks.push(u);
});
flattened.count = block.count;
flattened.capacity = block.capacity;
}
export function buildLayoutGraphDataImpl (graph: LayoutGraph, lgData: LayoutGraphBuilder) {
for (const v of graph.vertices()) {
const db: DescriptorDB = graph.getDescriptors(v);
let vid = 0;
if (graph.id(v) === LayoutGraphValue.RenderStage) {
vid = lgData.addRenderStage(graph.getName(v));
}
if (graph.id(v) === LayoutGraphValue.RenderPhase) {
vid = lgData.addRenderPhase(graph.getName(v), graph.getParent(v));
const phase = graph.getRenderPhase(vid);
for (const shaderName of phase.shaders) {
lgData.addShader(shaderName, vid);
}
}
db.blocks.forEach((value, key) => {
const index: DescriptorBlockIndex = JSON.parse(key) as DescriptorBlockIndex;
const block: DescriptorBlock = value;
const flattened = new DescriptorBlockFlattened();
descriptorBlock2Flattened(block, flattened);
if (block.capacity > 0) {
lgData.addDescriptorBlock(vid, index, flattened);
}
for (let i = 0; i < flattened.uniformBlockNames.length; ++i) {
lgData.addUniformBlock(vid, index, flattened.uniformBlockNames[i], flattened.uniformBlocks[i]);
}
});
}
}
enum BloomStage {
PREFILTER,
DOWNSAMPLE,
UPSAMPLE,
COMBINE
}
function buildBloomDownSample (lg, idx: number) {
const bloomDownsampleID = lg.addRenderStage(`Bloom_Downsample${idx}`, BloomStage.DOWNSAMPLE);
lg.addRenderPhase('Queue', bloomDownsampleID);
const bloomDownsampleDescriptors = lg.layoutGraph.getDescriptors(bloomDownsampleID);
const bloomDownsampleUniformBlock = lg.getLayoutBlock(UpdateFrequency.PER_PASS,
ParameterType.TABLE,
DescriptorTypeOrder.UNIFORM_BUFFER,
ShaderStageFlagBit.ALL,
bloomDownsampleDescriptors);
const bloomDownsampleUBO: UniformBlock = lg.getUniformBlock(SetIndex.MATERIAL,
0, 'BloomUBO', bloomDownsampleUniformBlock);
lg.setUniform(bloomDownsampleUBO, 'texSize', Type.FLOAT4, 1);
lg.setDescriptor(bloomDownsampleUniformBlock, 'BloomUBO', Type.UNKNOWN);
const bloomDownsamplePassBlock = lg.getLayoutBlock(UpdateFrequency.PER_PASS,
ParameterType.TABLE,
DescriptorTypeOrder.SAMPLER_TEXTURE,
ShaderStageFlagBit.FRAGMENT,
bloomDownsampleDescriptors);
lg.setDescriptor(bloomDownsamplePassBlock, 'bloomTexture', Type.SAMPLER2D);
lg.merge(bloomDownsampleDescriptors);
lg.mergeDescriptors(bloomDownsampleID);
}
function buildBloomUpSample (lg, idx: number) {
const bloomUpsampleID = lg.addRenderStage(`Bloom_Upsample${idx}`, BloomStage.UPSAMPLE);
lg.addRenderPhase('Queue', bloomUpsampleID);
const bloomUpsampleDescriptors = lg.layoutGraph.getDescriptors(bloomUpsampleID);
const bloomUpsampleUniformBlock = lg.getLayoutBlock(UpdateFrequency.PER_PASS,
ParameterType.TABLE,
DescriptorTypeOrder.UNIFORM_BUFFER,
ShaderStageFlagBit.ALL,
bloomUpsampleDescriptors);
const bloomUpsampleUBO: UniformBlock = lg.getUniformBlock(SetIndex.MATERIAL,
0, 'BloomUBO', bloomUpsampleUniformBlock);
lg.setUniform(bloomUpsampleUBO, 'texSize', Type.FLOAT4, 1);
lg.setDescriptor(bloomUpsampleUniformBlock, 'BloomUBO', Type.UNKNOWN);
const bloomUpsamplePassBlock = lg.getLayoutBlock(UpdateFrequency.PER_PASS,
ParameterType.TABLE,
DescriptorTypeOrder.SAMPLER_TEXTURE,
ShaderStageFlagBit.FRAGMENT,
bloomUpsampleDescriptors);
lg.setDescriptor(bloomUpsamplePassBlock, 'bloomTexture', Type.SAMPLER2D);
lg.merge(bloomUpsampleDescriptors);
lg.mergeDescriptors(bloomUpsampleID);
}
export function buildForwardLayout (ppl: Pipeline) {
const lg = new WebDescriptorHierarchy();
const defaultID = lg.addGlobal('default', true, true, true, true, true, true, true, true);
lg.mergeDescriptors(defaultID);
// 1.=== Bloom prefilter ===
const bloomPrefilterID = lg.addRenderStage('Bloom_Prefilter', BloomStage.PREFILTER);
lg.addRenderPhase('Queue', bloomPrefilterID);
const bloomPrefilterDescriptors = lg.layoutGraph.getDescriptors(bloomPrefilterID);
// unifom
const bloomPrefilterUniformBlock = lg.getLayoutBlock(UpdateFrequency.PER_PASS,
ParameterType.TABLE,
DescriptorTypeOrder.UNIFORM_BUFFER,
ShaderStageFlagBit.ALL,
bloomPrefilterDescriptors);
const bloomPrefilterUBO: UniformBlock = lg.getUniformBlock(SetIndex.MATERIAL,
0, 'BloomUBO', bloomPrefilterUniformBlock);
lg.setUniform(bloomPrefilterUBO, 'texSize', Type.FLOAT4, 1);
lg.setDescriptor(bloomPrefilterUniformBlock, 'BloomUBO', Type.UNKNOWN);
// texture
const bloomPrefilterPassBlock = lg.getLayoutBlock(UpdateFrequency.PER_PASS,
ParameterType.TABLE,
DescriptorTypeOrder.SAMPLER_TEXTURE,
ShaderStageFlagBit.FRAGMENT,
bloomPrefilterDescriptors);
lg.setDescriptor(bloomPrefilterPassBlock, 'outputResultMap', Type.SAMPLER2D);
lg.merge(bloomPrefilterDescriptors);
lg.mergeDescriptors(bloomPrefilterID);
// 2.=== Bloom downsample ===
buildBloomDownSample(lg, 0);
buildBloomDownSample(lg, 1);
// 3.=== Bloom upsample ===
buildBloomUpSample(lg, 0);
buildBloomUpSample(lg, 1);
// 4.=== Bloom combine ===
const bloomCombineSampleID = lg.addRenderStage('Bloom_Combine', BloomStage.COMBINE);
lg.addRenderPhase('Queue', bloomCombineSampleID);
const bloomCombineSampleDescriptors = lg.layoutGraph.getDescriptors(bloomCombineSampleID);
const bloomCombinesampleUniformBlock = lg.getLayoutBlock(UpdateFrequency.PER_PASS,
ParameterType.TABLE,
DescriptorTypeOrder.UNIFORM_BUFFER,
ShaderStageFlagBit.ALL,
bloomCombineSampleDescriptors);
const bloomCombinesampleUBO: UniformBlock = lg.getUniformBlock(SetIndex.MATERIAL,
0, 'BloomUBO', bloomCombinesampleUniformBlock);
lg.setUniform(bloomCombinesampleUBO, 'texSize', Type.FLOAT4, 1);
lg.setDescriptor(bloomCombinesampleUniformBlock, 'BloomUBO', Type.UNKNOWN);
const bloomCombineSamplePassBlock = lg.getLayoutBlock(UpdateFrequency.PER_PASS,
ParameterType.TABLE,
DescriptorTypeOrder.SAMPLER_TEXTURE,
ShaderStageFlagBit.FRAGMENT,
bloomCombineSampleDescriptors);
lg.setDescriptor(bloomCombineSamplePassBlock, 'outputResultMap', Type.SAMPLER2D);
const bloomCombineSamplePassBlock2 = lg.getLayoutBlock(UpdateFrequency.PER_PASS,
ParameterType.TABLE,
DescriptorTypeOrder.SAMPLER_TEXTURE,
ShaderStageFlagBit.FRAGMENT,
bloomCombineSampleDescriptors);
lg.setDescriptor(bloomCombineSamplePassBlock2, 'bloomTexture', Type.SAMPLER2D);
lg.merge(bloomCombineSampleDescriptors);
lg.mergeDescriptors(bloomCombineSampleID);
// 5.=== Postprocess ===
const postPassID = lg.addRenderStage('Postprocess', DeferredStage.POST);
const postDescriptors = lg.layoutGraph.getDescriptors(postPassID);
const postPassBlock = lg.getLayoutBlock(UpdateFrequency.PER_PASS,
ParameterType.TABLE,
DescriptorTypeOrder.SAMPLER_TEXTURE,
ShaderStageFlagBit.FRAGMENT,
postDescriptors);
lg.setDescriptor(postPassBlock, 'outputResultMap', Type.SAMPLER2D);
lg.merge(postDescriptors);
lg.mergeDescriptors(postPassID);
// 6.=== FxaaHQ ===
const fxaaID = lg.addRenderStage('fxaa', 1);
lg.addRenderPhase('Queue', fxaaID);
const fxaaDescriptors = lg.layoutGraph.getDescriptors(fxaaID);
// unifom
const fxaaUniformBlock = lg.getLayoutBlock(UpdateFrequency.PER_PASS,
ParameterType.TABLE,
DescriptorTypeOrder.UNIFORM_BUFFER,
ShaderStageFlagBit.ALL,
fxaaDescriptors);
const fxaaUBO: UniformBlock = lg.getUniformBlock(SetIndex.MATERIAL,
0, 'fxaaUBO', fxaaUniformBlock);
lg.setUniform(fxaaUBO, 'texSize', Type.FLOAT4, 1);
lg.setDescriptor(fxaaUniformBlock, 'fxaaUBO', Type.UNKNOWN);
// texture
const fxaaPassBlock = lg.getLayoutBlock(UpdateFrequency.PER_PASS,
ParameterType.TABLE,
DescriptorTypeOrder.SAMPLER_TEXTURE,
ShaderStageFlagBit.FRAGMENT,
fxaaDescriptors);
lg.setDescriptor(fxaaPassBlock, 'sceneColorMap', Type.SAMPLER2D);
lg.merge(fxaaDescriptors);
lg.mergeDescriptors(fxaaID);
const builder = ppl.layoutGraphBuilder;
builder.clear();
buildLayoutGraphDataImpl(lg.layoutGraph, builder);
}
enum DeferredStage {
GEOMETRY,
LIGHTING,
POST
}
export class VectorGraphColorMap implements MutableVertexPropertyMap<GraphColor> {
constructor (sz: number) {
this.colors = new Array<GraphColor>(sz);
}
get (u: number): GraphColor {
return this.colors[u];
}
put (u: number, value: GraphColor): void {
this.colors[u] = value;
}
readonly colors: Array<GraphColor>;
}
export function buildDeferredLayout (ppl: Pipeline) {
const lg = new WebDescriptorHierarchy();
const defaultID = lg.addGlobal('default', true, true, true, true, true, true, true, true);
lg.mergeDescriptors(defaultID);
const geometryPassID = lg.addRenderStage('Geometry', DeferredStage.GEOMETRY);
const lightingPassID = lg.addRenderStage('Lighting', DeferredStage.LIGHTING);
const postPassID = lg.addRenderStage('Postprocess', DeferredStage.POST);
const geometryQueueID = lg.addRenderPhase('Queue', geometryPassID);
const lightingQueueID = lg.addRenderPhase('Queue', lightingPassID);
const postQueueID = lg.addRenderPhase('Queue', postPassID);
const lightingDescriptors = lg.layoutGraph.getDescriptors(lightingQueueID);
const lightingPassBlock = lg.getLayoutBlock(UpdateFrequency.PER_PASS,
ParameterType.TABLE,
DescriptorTypeOrder.SAMPLER_TEXTURE,
ShaderStageFlagBit.FRAGMENT,
lightingDescriptors);
lg.setDescriptor(lightingPassBlock, 'gbuffer_albedoMap', Type.FLOAT4);
lg.setDescriptor(lightingPassBlock, 'gbuffer_normalMap', Type.FLOAT4);
lg.setDescriptor(lightingPassBlock, 'gbuffer_emissiveMap', Type.FLOAT4);
lg.setDescriptor(lightingPassBlock, 'depth_stencil', Type.FLOAT4);
const visitor = new CollectVisitor();
const colorMap = new VectorGraphColorMap(lg.layoutGraph.numVertices());
depthFirstSearch(lg.layoutGraph, visitor, colorMap);
lg.mergeDescriptors(lightingPassID);
// Postprocess
const postDescriptors = lg.layoutGraph.getDescriptors(postPassID);
const postPassBlock = lg.getLayoutBlock(UpdateFrequency.PER_PASS,
ParameterType.TABLE,
DescriptorTypeOrder.SAMPLER_TEXTURE,
ShaderStageFlagBit.FRAGMENT,
postDescriptors);
lg.setDescriptor(postPassBlock, 'outputResultMap', Type.FLOAT4);
lg.merge(postDescriptors);
lg.mergeDescriptors(postPassID);
if (visitor.error) {
console.log(visitor.error);
}
const builder = ppl.layoutGraphBuilder;
builder.clear();
buildLayoutGraphDataImpl(lg.layoutGraph, builder);
}
function applyBinding (lg: Readonly<LayoutGraphData>,
descId: number,
srcBlock: EffectAsset.IBlockInfo | EffectAsset.IBufferInfo | EffectAsset.ISamplerTextureInfo | EffectAsset.ISamplerInfo,
dstBlock: DescriptorBlockData) {
if (lg.attributeIndex.get(srcBlock.name) === descId) {
srcBlock.stageFlags = dstBlock.visibility;
srcBlock.binding = dstBlock.offset;
}
}
function updateShaderBinding (lg: Readonly<LayoutGraphData>,
shaderData: Readonly<ShaderProgramData>,
shader: EffectAsset.IShaderInfo) {
for (const pair of shaderData.layout.descriptorSets) {
const updateFrequency = pair[0];
if (updateFrequency === UpdateFrequency.PER_BATCH
|| updateFrequency === UpdateFrequency.PER_INSTANCE) {
continue;
}
const descData = pair[1];
for (const descBlock of descData.descriptorSetLayoutData.descriptorBlocks) {
for (let j = 0; j < descBlock.descriptors.length; ++j) {
const descData = descBlock.descriptors[j];
const descriptorId = descData.descriptorID;
for (const block of shader.blocks) {
applyBinding(lg, descriptorId, block, descBlock);
}
for (const buff of shader.buffers) {
applyBinding(lg, descriptorId, buff, descBlock);
}
for (const img of shader.images) {
applyBinding(lg, descriptorId, img, descBlock);
}
for (const samplerTex of shader.samplerTextures) {
applyBinding(lg, descriptorId, samplerTex, descBlock);
}
for (const sampler of shader.samplers) {
applyBinding(lg, descriptorId, sampler, descBlock);
}
for (const tex of shader.textures) {
applyBinding(lg, descriptorId, tex, descBlock);
}
for (const subpassInput of shader.subpassInputs) {
applyBinding(lg, descriptorId, subpassInput, descBlock);
}
}
}
}
}
export function replacePerBatchOrInstanceShaderInfo (lg: LayoutGraphData,
asset: EffectAsset, stageName: string) {
const stageID = lg.locateChild(lg.nullVertex(), stageName);
let phaseName;
for (let i = 0; i < asset.techniques.length; ++i) {
const tech = asset.techniques[i];
for (let j = 0; j < tech.passes.length; ++j) {
const pass = tech.passes[j];
const passPhase = pass.phase;
if (phaseName && phaseName === `${stageName}_` && !passPhase) {
continue;
}
if (passPhase === undefined) {
phaseName = `${stageName}_`;
} else if (typeof passPhase === 'number') {
phaseName = passPhase.toString();
} else {
phaseName = passPhase;
}
const phaseID = lg.locateChild(stageID, phaseName);
if (phaseID === 0xFFFFFFFF) { continue; }
const phaseData = lg.getRenderPhase(phaseID);
const shaderID = phaseData.shaderIndex.get(pass.program);
const shader = asset.shaders.find((val) => val.name === pass.program)!;
if (shaderID) {
const shaderData = phaseData.shaderPrograms[shaderID];
updateShaderBinding(lg, shaderData, shader);
}
}
}
}