mirror of
https://github.com/cocos/cocos4.git
synced 2026-11-20 23:52:40 +08:00
Compare commits
20 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| 0c3f4534b8 | |||
| 7f806abad6 | |||
| df98a99bb6 | |||
| a5090e5ae4 | |||
| 3b71bf6935 | |||
| 54fd070848 | |||
| 6722aac669 | |||
| 68552314c0 | |||
| 550eb15641 | |||
| c438c2d3f8 | |||
| f5eaf97ce7 | |||
| 69d3d6033a | |||
| 469614cf0b | |||
| f81094f226 | |||
| 825362fac1 | |||
| 609512f8da | |||
| 09b63786f4 | |||
| 2b7b438768 | |||
| 6b5c8556a2 | |||
| ff436d6a27 |
+1
-1
@@ -3983,4 +3983,4 @@ Spine version not supported.
|
||||
|
||||
### 16420
|
||||
|
||||
Start time must bigger than end time.
|
||||
End time must bigger than start time.
|
||||
|
||||
@@ -76,10 +76,11 @@ simpleTextureProto._onGFXTextureUpdated = function (gfxTexture) {
|
||||
simpleTextureProto._onAfterAssignImage = function (image) {
|
||||
if (macro.CLEANUP_IMAGE_CACHE) {
|
||||
const deps = dependUtil.getDeps(this._uuid);
|
||||
const index = deps.indexOf(image._uuid);
|
||||
if (index !== -1) {
|
||||
let index = deps.indexOf(image._uuid);
|
||||
while (index !== -1) {
|
||||
js.array.fastRemoveAt(deps, index);
|
||||
image.decRef();
|
||||
index = deps.indexOf(image._uuid);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
@@ -194,10 +194,12 @@ export class SimpleTexture extends TextureBase {
|
||||
|
||||
if (macro.CLEANUP_IMAGE_CACHE) {
|
||||
const deps = dependUtil.getDeps(this._uuid);
|
||||
const index = deps.indexOf(image._uuid);
|
||||
if (index !== -1) {
|
||||
let index = deps.indexOf(image._uuid);
|
||||
while (index !== -1) {
|
||||
js.array.fastRemoveAt(deps, index);
|
||||
image.decRef();
|
||||
// The same UUID may occur more than once; find the next dependency edge.
|
||||
index = deps.indexOf(image._uuid);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -88,6 +88,14 @@ export abstract class CommandBuffer extends GFXObject {
|
||||
return this._numTris;
|
||||
}
|
||||
|
||||
/**
|
||||
* @en Number of compute dispatches currently recorded.
|
||||
* @zh 计算调度(dispatch)次数。
|
||||
*/
|
||||
get numDispatches (): number {
|
||||
return this._numDispatches;
|
||||
}
|
||||
|
||||
/** @mangle */
|
||||
protected _queue: Queue | null = null;
|
||||
/** @mangle */
|
||||
@@ -95,6 +103,8 @@ export abstract class CommandBuffer extends GFXObject {
|
||||
/** @mangle */
|
||||
protected _numDrawCalls = 0;
|
||||
/** @mangle */
|
||||
protected _numDispatches = 0;
|
||||
/** @mangle */
|
||||
protected _numInstances = 0;
|
||||
/** @mangle */
|
||||
protected _numTris = 0;
|
||||
|
||||
@@ -127,6 +127,14 @@ export abstract class Device {
|
||||
return this._numTris;
|
||||
}
|
||||
|
||||
/**
|
||||
* @en Number of compute dispatches currently recorded.
|
||||
* @zh 计算调度(dispatch)次数。
|
||||
*/
|
||||
get numDispatches (): number {
|
||||
return this._numDispatches;
|
||||
}
|
||||
|
||||
/**
|
||||
* @en Total memory size currently allocated.
|
||||
* @zh 内存状态。
|
||||
@@ -168,6 +176,8 @@ export abstract class Device {
|
||||
/** @mangle */
|
||||
protected _numDrawCalls = 0;
|
||||
/** @mangle */
|
||||
protected _numDispatches = 0;
|
||||
/** @mangle */
|
||||
protected _numInstances = 0;
|
||||
/** @mangle */
|
||||
protected _numTris = 0;
|
||||
|
||||
@@ -2702,7 +2702,7 @@ export function WebGLCmdFuncCopyBuffersToTexture (
|
||||
offset.x = regionTexOffset.x === 0 ? 0 : alignTo(regionTexOffset.x, blockSizeWidth);
|
||||
offset.y = regionTexOffset.y === 0 ? 0 : alignTo(regionTexOffset.y, blockSizeHeight);
|
||||
extent.width = regionTexExtentWidth < blockSizeWidth ? regionTexExtentWidth : alignTo(regionTexExtentWidth, blockSizeWidth);
|
||||
extent.height = regionTexExtentHeight < blockSizeHeight ? regionTexExtentWidth
|
||||
extent.height = regionTexExtentHeight < blockSizeHeight ? regionTexExtentHeight
|
||||
: alignTo(regionTexExtentHeight, blockSizeHeight);
|
||||
stride.width = regionBuffStride > 0 ? regionBuffStride : extent.width;
|
||||
stride.height = region.buffTexHeight > 0 ? region.buffTexHeight : extent.height;
|
||||
@@ -2773,7 +2773,7 @@ export function WebGLCmdFuncCopyBuffersToTexture (
|
||||
offset.x = regionTexOffset.x === 0 ? 0 : alignTo(regionTexOffset.x, blockSizeWidth);
|
||||
offset.y = regionTexOffset.y === 0 ? 0 : alignTo(regionTexOffset.y, blockSizeHeight);
|
||||
extent.width = regionTexExtentWidth < blockSizeWidth ? regionTexExtentWidth : alignTo(regionTexExtentWidth, blockSizeWidth);
|
||||
extent.height = regionTexExtentHeight < blockSizeHeight ? regionTexExtentWidth
|
||||
extent.height = regionTexExtentHeight < blockSizeHeight ? regionTexExtentHeight
|
||||
: alignTo(regionTexExtentHeight, blockSizeHeight);
|
||||
stride.width = region.buffStride > 0 ? region.buffStride : extent.width;
|
||||
stride.height = region.buffTexHeight > 0 ? region.buffTexHeight : extent.height;
|
||||
|
||||
@@ -2811,7 +2811,7 @@ export function WebGL2CmdFuncCopyBuffersToTexture (
|
||||
offset.x = regionTexOffset.x === 0 ? 0 : alignTo(regionTexOffset.x, blockSizeWidth);
|
||||
offset.y = regionTexOffset.y === 0 ? 0 : alignTo(regionTexOffset.y, blockSizeHeight);
|
||||
extent.width = regionTexExtentWidth < blockSizeWidth ? regionTexExtentWidth : alignTo(regionTexExtentWidth, blockSizeWidth);
|
||||
extent.height = regionTexExtentHeight < blockSizeHeight ? regionTexExtentWidth
|
||||
extent.height = regionTexExtentHeight < blockSizeHeight ? regionTexExtentHeight
|
||||
: alignTo(regionTexExtentHeight, blockSizeHeight);
|
||||
stride.width = regionBuffStride > 0 ? regionBuffStride : extent.width;
|
||||
stride.height = region.buffTexHeight > 0 ? region.buffTexHeight : extent.height;
|
||||
@@ -2883,7 +2883,7 @@ export function WebGL2CmdFuncCopyBuffersToTexture (
|
||||
offset.x = regionTexOffset.x === 0 ? 0 : alignTo(regionTexOffset.x, blockSizeWidth);
|
||||
offset.y = regionTexOffset.y === 0 ? 0 : alignTo(regionTexOffset.y, blockSizeHeight);
|
||||
extent.width = regionTexExtentWidth < blockSizeWidth ? regionTexExtentWidth : alignTo(regionTexExtentWidth, blockSizeWidth);
|
||||
extent.height = regionTexExtentHeight < blockSizeHeight ? regionTexExtentWidth
|
||||
extent.height = regionTexExtentHeight < blockSizeHeight ? regionTexExtentHeight
|
||||
: alignTo(regionTexExtentHeight, blockSizeHeight);
|
||||
extent.depth = 1;
|
||||
stride.width = regionBuffStride > 0 ? regionBuffStride : extent.width;
|
||||
@@ -2965,7 +2965,7 @@ export function WebGL2CmdFuncCopyBuffersToTexture (
|
||||
offset.y = regionTexOffset.y === 0 ? 0 : alignTo(regionTexOffset.y, blockSizeHeight);
|
||||
offset.z = regionTexOffset.z;
|
||||
extent.width = regionTexExtentWidth < blockSizeWidth ? regionTexExtentWidth : alignTo(regionTexExtentWidth, blockSizeWidth);
|
||||
extent.height = regionTexExtentHeight < blockSizeHeight ? regionTexExtentWidth
|
||||
extent.height = regionTexExtentHeight < blockSizeHeight ? regionTexExtentHeight
|
||||
: alignTo(regionTexExtentHeight, blockSizeHeight);
|
||||
extent.depth = regionTexExtent.depth;
|
||||
stride.width = regionBuffStride > 0 ? regionBuffStride : extent.width;
|
||||
@@ -2986,7 +2986,7 @@ export function WebGL2CmdFuncCopyBuffersToTexture (
|
||||
|
||||
if (!isCompressed) {
|
||||
gl.texSubImage3D(
|
||||
WebGLConstants.TEXTURE_2D_ARRAY,
|
||||
WebGLConstants.TEXTURE_3D,
|
||||
mipLevel,
|
||||
offset.x,
|
||||
offset.y,
|
||||
@@ -3000,7 +3000,7 @@ export function WebGL2CmdFuncCopyBuffersToTexture (
|
||||
);
|
||||
} else if (gpuTexture.glInternalFmt !== WebGL2EXT.COMPRESSED_RGB_ETC1_WEBGL as number) {
|
||||
gl.compressedTexSubImage3D(
|
||||
WebGLConstants.TEXTURE_2D_ARRAY,
|
||||
WebGLConstants.TEXTURE_3D,
|
||||
mipLevel,
|
||||
offset.x,
|
||||
offset.y,
|
||||
@@ -3013,7 +3013,7 @@ export function WebGL2CmdFuncCopyBuffersToTexture (
|
||||
);
|
||||
} else { // WEBGL_compressed_texture_etc1
|
||||
gl.compressedTexImage3D(
|
||||
WebGLConstants.TEXTURE_2D_ARRAY,
|
||||
WebGLConstants.TEXTURE_3D,
|
||||
mipLevel,
|
||||
gpuTexture.glInternalFmt,
|
||||
destWidth,
|
||||
@@ -3043,7 +3043,7 @@ export function WebGL2CmdFuncCopyBuffersToTexture (
|
||||
offset.x = regionTexOffset.x === 0 ? 0 : alignTo(regionTexOffset.x, blockSizeWidth);
|
||||
offset.y = regionTexOffset.y === 0 ? 0 : alignTo(regionTexOffset.y, blockSizeHeight);
|
||||
extent.width = regionTexExtentWidth < blockSizeWidth ? regionTexExtentWidth : alignTo(regionTexExtentWidth, blockSizeWidth);
|
||||
extent.height = regionTexExtentHeight < blockSizeHeight ? regionTexExtentWidth
|
||||
extent.height = regionTexExtentHeight < blockSizeHeight ? regionTexExtentHeight
|
||||
: alignTo(regionTexExtentHeight, blockSizeHeight);
|
||||
stride.width = regionBuffStride > 0 ? regionBuffStride : extent.width;
|
||||
stride.height = region.buffTexHeight > 0 ? region.buffTexHeight : extent.height;
|
||||
|
||||
@@ -40,6 +40,7 @@ import {
|
||||
TextureBlit,
|
||||
DescriptorSetInfo,
|
||||
Format,
|
||||
DispatchInfo,
|
||||
} from '../base/define';
|
||||
import { Framebuffer } from '../base/framebuffer';
|
||||
import { InputAssembler } from '../base/input-assembler';
|
||||
@@ -179,6 +180,7 @@ export class WebGPUCommandBuffer extends CommandBuffer {
|
||||
private _wgpuRenderPass!: WebGPURenderPass;
|
||||
|
||||
private _renderPassFuncQueue: ((renPassEncoder: GPURenderPassEncoder) => void)[] = [];
|
||||
private _computeFuncQueue: ((computePassEncoder: GPUComputePassEncoder) => void)[] = [];
|
||||
|
||||
public initialize (info: CommandBufferInfo): boolean {
|
||||
this._type = info.type;
|
||||
@@ -222,13 +224,16 @@ export class WebGPUCommandBuffer extends CommandBuffer {
|
||||
this._curStencilWriteMask = null;
|
||||
this._curStencilCompareMask = null;
|
||||
this._numDrawCalls = 0;
|
||||
this._numDispatches = 0;
|
||||
this._numInstances = 0;
|
||||
this._numTris = 0;
|
||||
this._computeFuncQueue.length = 0;
|
||||
}
|
||||
|
||||
public end (): void {
|
||||
this._isStateValid = false;
|
||||
this._isInRenderPass = false;
|
||||
this._computeFuncQueue.length = 0;
|
||||
}
|
||||
|
||||
public beginRenderPass (
|
||||
@@ -650,22 +655,20 @@ export class WebGPUCommandBuffer extends CommandBuffer {
|
||||
this.cmdPackage.cmds.concat(cmdPackage.cmds.array);
|
||||
|
||||
this._numDrawCalls += WebGPUCmdBuff._numDrawCalls;
|
||||
this._numDispatches += WebGPUCmdBuff._numDispatches;
|
||||
this._numInstances += WebGPUCmdBuff._numInstances;
|
||||
this._numTris += WebGPUCmdBuff._numTris;
|
||||
}
|
||||
}
|
||||
|
||||
protected bindStates (): void {
|
||||
if (!this._curGPUPipelineState) {
|
||||
return;
|
||||
}
|
||||
const gpuPipelineLayout = this._curGPUPipelineState.gpuPipelineLayout as IWebGPUGPUPipelineLayout;
|
||||
private _prepareDescriptorSets (): void {
|
||||
const wgpuPipLayout = (currPipelineState?.pipelineLayout as WebGPUPipelineLayout);
|
||||
const device = WebGPUDeviceManager.instance;
|
||||
for (let i = 0; i < groupSets.length; i++) {
|
||||
const currSetIdx = groupSets[i];
|
||||
const currDesc = descriptorSets[currSetIdx];
|
||||
if (currDesc && currDesc.gpuDescriptorSet) {
|
||||
// prepare() builds the bind group if it was never created, or rebuilds it on resource change.
|
||||
currDesc.prepare();
|
||||
} else {
|
||||
const currLayout = wgpuPipLayout.setLayouts[currSetIdx];
|
||||
@@ -675,23 +678,13 @@ export class WebGPUCommandBuffer extends CommandBuffer {
|
||||
newDescSet.prepare(true);
|
||||
}
|
||||
}
|
||||
const gpuIA = this._curGPUInputAssembler!;
|
||||
// only 4x MSAA is supported
|
||||
gpuIA.samples = samples > 1 ? 4 : 1;
|
||||
this._curWebGPUPipelineState!.prepare(gpuIA);
|
||||
// ----------------------------wgpu pipline state-----------------------------
|
||||
const wgpuPipeline = this._curGPUPipelineState.nativePipeline as GPURenderPipeline;
|
||||
const pplFunc = (passEncoder: GPURenderPassEncoder): void => {
|
||||
passEncoder.setPipeline(wgpuPipeline);
|
||||
};
|
||||
this._renderPassFuncQueue.push(pplFunc);
|
||||
if (this._curGPUPipelineState.pipelineState?.depthStencil) {
|
||||
const stencilRef = this._curGPUPipelineState.stencilRef;
|
||||
const stencilRefFunc = (passEncoder: GPURenderPassEncoder): void => {
|
||||
passEncoder.setStencilReference(stencilRef);
|
||||
};
|
||||
this._renderPassFuncQueue.push(stencilRefFunc);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Collect the bind groups and dynamic offsets for the currently bound descriptor sets.
|
||||
* Shared by the draw (bindStates) and compute (dispatch) paths.
|
||||
*/
|
||||
private _collectBindGroups (): { wgpuBindGroups: GPUBindGroup[]; wgpuDynOffsets: number[][] } {
|
||||
const currGPUDescSize = groupSets.length;
|
||||
const wgpuBindGroups = new Array<GPUBindGroup>(currGPUDescSize);
|
||||
const wgpuDynOffsets = new Array<number[]>(currGPUDescSize);
|
||||
@@ -703,7 +696,7 @@ export class WebGPUCommandBuffer extends CommandBuffer {
|
||||
wgpuDynOffsets[currSetIdx] = [...this._curDynamicOffsets[currSetIdx]];
|
||||
if (!descObj.dynamicOffsetCount) {
|
||||
wgpuDynOffsets[currSetIdx] = [];
|
||||
} else if (descObj && descObj.dynamicOffsetCount !== wgpuDynOffsets[currSetIdx].length) {
|
||||
} else if (descObj.dynamicOffsetCount !== wgpuDynOffsets[currSetIdx].length) {
|
||||
wgpuDynOffsets[currSetIdx].length = descObj.dynamicOffsetCount;
|
||||
for (let j = 0; j < descObj.dynamicOffsetCount; j++) {
|
||||
const currOffset = wgpuDynOffsets[currSetIdx][j];
|
||||
@@ -719,16 +712,84 @@ export class WebGPUCommandBuffer extends CommandBuffer {
|
||||
}
|
||||
}
|
||||
}
|
||||
return { wgpuBindGroups, wgpuDynOffsets };
|
||||
}
|
||||
|
||||
public dispatch (info: DispatchInfo): void {
|
||||
if (!this._curGPUPipelineState) {
|
||||
return;
|
||||
}
|
||||
// Prepare descriptor sets (same logic as bindStates)
|
||||
this._prepareDescriptorSets();
|
||||
|
||||
// Create compute pipeline
|
||||
this._curWebGPUPipelineState!.prepare(null!);
|
||||
|
||||
const computePipeline = this._curGPUPipelineState.nativePipeline as GPUComputePipeline;
|
||||
|
||||
// Build bind groups for compute pass
|
||||
const { wgpuBindGroups, wgpuDynOffsets } = this._collectBindGroups();
|
||||
|
||||
const func = (passEncoder: GPUComputePassEncoder): void => {
|
||||
passEncoder.setPipeline(computePipeline);
|
||||
const gpuBindGroupSize = wgpuBindGroups.length;
|
||||
for (let i = 0; i < gpuBindGroupSize; i++) {
|
||||
passEncoder.setBindGroup(i, wgpuBindGroups[i], wgpuDynOffsets[i]);
|
||||
}
|
||||
passEncoder.dispatchWorkgroups(info.groupCountX, info.groupCountY, info.groupCountZ);
|
||||
};
|
||||
this._computeFuncQueue.push(func);
|
||||
++this._numDispatches;
|
||||
this._isStateValid = false;
|
||||
}
|
||||
|
||||
public submitComputePass (): void {
|
||||
if (this._computeFuncQueue.length === 0) {
|
||||
return;
|
||||
}
|
||||
const device = WebGPUDeviceManager.instance;
|
||||
const nativeDevice = device.nativeDevice!;
|
||||
const cmdEncoder = nativeDevice.createCommandEncoder();
|
||||
const computePassEncoder = cmdEncoder.beginComputePass();
|
||||
this._computeFuncQueue.forEach((cb) => {
|
||||
cb(computePassEncoder);
|
||||
});
|
||||
computePassEncoder.end();
|
||||
nativeDevice.queue.submit([cmdEncoder.finish()]);
|
||||
this._computeFuncQueue.length = 0;
|
||||
}
|
||||
|
||||
protected bindStates (): void {
|
||||
if (!this._curGPUPipelineState) {
|
||||
return;
|
||||
}
|
||||
const gpuPipelineLayout = this._curGPUPipelineState.gpuPipelineLayout as IWebGPUGPUPipelineLayout;
|
||||
this._prepareDescriptorSets();
|
||||
const gpuIA = this._curGPUInputAssembler!;
|
||||
// only 4x MSAA is supported
|
||||
gpuIA.samples = samples > 1 ? 4 : 1;
|
||||
this._curWebGPUPipelineState!.prepare(gpuIA);
|
||||
// ----------------------------wgpu pipline state-----------------------------
|
||||
const wgpuPipeline = this._curGPUPipelineState.nativePipeline as GPURenderPipeline;
|
||||
const pplFunc = (passEncoder: GPURenderPassEncoder): void => {
|
||||
passEncoder.setPipeline(wgpuPipeline);
|
||||
};
|
||||
this._renderPassFuncQueue.push(pplFunc);
|
||||
const pipelineDesc = this._curGPUPipelineState.pipelineState;
|
||||
if (pipelineDesc && 'depthStencil' in pipelineDesc && pipelineDesc.depthStencil) {
|
||||
const stencilRef = this._curGPUPipelineState.stencilRef;
|
||||
const stencilRefFunc = (passEncoder: GPURenderPassEncoder): void => {
|
||||
passEncoder.setStencilReference(stencilRef);
|
||||
};
|
||||
this._renderPassFuncQueue.push(stencilRefFunc);
|
||||
}
|
||||
const { wgpuBindGroups, wgpuDynOffsets } = this._collectBindGroups();
|
||||
|
||||
const bgfunc = (passEncoder: GPURenderPassEncoder): void => {
|
||||
const gpuBindGroupSize = wgpuBindGroups.length;
|
||||
for (let i = 0; i < gpuBindGroupSize; i++) {
|
||||
let currBindGroup = wgpuBindGroups[i];
|
||||
if (!currBindGroup) {
|
||||
currBindGroup = (device.defaultResource.descSet as WebGPUDescriptorSet).gpuDescriptorSet.bindGroup;
|
||||
}
|
||||
// FIXME: this is a special sentence that 2 in 3 parameters I'm not certain.
|
||||
passEncoder.setBindGroup(i, currBindGroup, wgpuDynOffsets[i]);
|
||||
passEncoder.setBindGroup(i, wgpuBindGroups[i], wgpuDynOffsets[i]);
|
||||
}
|
||||
};
|
||||
this._renderPassFuncQueue.push(bgfunc);
|
||||
|
||||
@@ -35,6 +35,7 @@ import {
|
||||
TextureUsageBit,
|
||||
ShaderStageFlags,
|
||||
DescriptorType,
|
||||
MemoryAccessBit,
|
||||
Color, Rect, Viewport, BufferTextureCopy,
|
||||
SamplerInfo,
|
||||
FormatSize,
|
||||
@@ -1423,11 +1424,15 @@ export function createBindGroupLayoutEntry (currBind: DescriptorSetLayoutBinding
|
||||
|
||||
case DescriptorType.STORAGE_BUFFER:
|
||||
case DescriptorType.DYNAMIC_STORAGE_BUFFER:
|
||||
entry.buffer = {
|
||||
type: 'storage',
|
||||
hasDynamicOffset: type === DescriptorType.DYNAMIC_STORAGE_BUFFER,
|
||||
minBindingSize: undefined,
|
||||
};
|
||||
{
|
||||
const readOnly = (currBind.access & MemoryAccessBit.READ_ONLY) !== 0
|
||||
&& (currBind.access & MemoryAccessBit.WRITE_ONLY) === 0;
|
||||
entry.buffer = {
|
||||
type: readOnly ? 'read-only-storage' : 'storage',
|
||||
hasDynamicOffset: type === DescriptorType.DYNAMIC_STORAGE_BUFFER,
|
||||
minBindingSize: undefined,
|
||||
};
|
||||
}
|
||||
break;
|
||||
|
||||
case DescriptorType.SAMPLER_TEXTURE:
|
||||
|
||||
@@ -170,9 +170,17 @@ export class WebGPUDescriptorSet extends DescriptorSet {
|
||||
if (descType & (DescriptorType.DYNAMIC_STORAGE_BUFFER | DescriptorType.DYNAMIC_UNIFORM_BUFFER)) {
|
||||
this._dynamicOffsets.push(bindIdx);
|
||||
}
|
||||
} else if (descType & DESCRIPTOR_SAMPLER_TYPE) {
|
||||
if ((descType & DescriptorType.SAMPLER) !== DescriptorType.SAMPLER) {
|
||||
// texture
|
||||
} else if (descType & (DESCRIPTOR_SAMPLER_TYPE | DescriptorType.STORAGE_IMAGE)) {
|
||||
const isStorageImage = (descType & DescriptorType.STORAGE_IMAGE) === DescriptorType.STORAGE_IMAGE;
|
||||
if (isStorageImage) {
|
||||
// storage texture (compute read/write): bind the texture view, no sampler
|
||||
let currTex = this._textures[i] as WebGPUTexture;
|
||||
if (!currTex || (currTex.hasChange && !currTex.gpuTexture)) {
|
||||
currTex = device.defaultResource.texture;
|
||||
}
|
||||
this._bindTextureEntry(binding, currTex);
|
||||
} else if ((descType & DescriptorType.SAMPLER) !== DescriptorType.SAMPLER) {
|
||||
// sampled texture
|
||||
let currTex = this._textures[i] as WebGPUTexture;
|
||||
// null or destroyed?
|
||||
if (!currTex || (currTex.hasChange && !currTex.gpuTexture)) {
|
||||
@@ -185,9 +193,9 @@ export class WebGPUDescriptorSet extends DescriptorSet {
|
||||
this._bindTextureEntry(binding, currTex);
|
||||
}
|
||||
|
||||
if (!((descType & DescriptorType.STORAGE_IMAGE) === DescriptorType.STORAGE_IMAGE
|
||||
|| (descType & DescriptorType.INPUT_ATTACHMENT) === DescriptorType.INPUT_ATTACHMENT
|
||||
|| (descType & DescriptorType.TEXTURE) === DescriptorType.TEXTURE)) {
|
||||
if (!isStorageImage
|
||||
&& !((descType & DescriptorType.INPUT_ATTACHMENT) === DescriptorType.INPUT_ATTACHMENT
|
||||
|| (descType & DescriptorType.TEXTURE) === DescriptorType.TEXTURE)) {
|
||||
// sampler
|
||||
const currSampler = (this._samplers[i] || device.defaultResource.sampler) as WebGPUSampler;
|
||||
this._bindSamplerEntry(binding, currSampler);
|
||||
@@ -219,7 +227,12 @@ export class WebGPUDescriptorSet extends DescriptorSet {
|
||||
}
|
||||
|
||||
public prepare (force: boolean = false): void {
|
||||
const breakUpdate = !this._isResourceChange() && !force;
|
||||
const gpuDescriptorSet = this._gpuDescriptorSet;
|
||||
if (!gpuDescriptorSet) {
|
||||
return;
|
||||
}
|
||||
// Rebuild when forced, when the bind group has never been built, or when resources changed.
|
||||
const breakUpdate = gpuDescriptorSet.bindGroup && !this._isResourceChange() && !force;
|
||||
if (breakUpdate) return;
|
||||
this._isDirty = true;
|
||||
this._applyBindGroup();
|
||||
|
||||
@@ -53,7 +53,7 @@ import { WebGPUTexture } from './webgpu-texture';
|
||||
import { DefaultResources, hashCombineNum, hashCombineStr, webGPU, WebGPUDeviceManager } from './define';
|
||||
import {
|
||||
Filter, Format,
|
||||
QueueType, Feature, BufferTextureCopy, Rect, DescriptorSetInfo,
|
||||
QueueType, Feature, BufferTextureCopy, Rect, Size, DescriptorSetInfo,
|
||||
BufferInfo, BufferViewInfo, CommandBufferInfo, DeviceInfo,
|
||||
FramebufferInfo, InputAssemblerInfo, QueueInfo, RenderPassInfo, SamplerInfo,
|
||||
ShaderInfo, PipelineLayoutInfo, DescriptorSetLayoutInfo, TextureInfo, TextureViewInfo, GeneralBarrierInfo, TextureBarrierInfo,
|
||||
@@ -552,6 +552,22 @@ export class WebGPUDevice extends Device {
|
||||
this._caps.max3DTextureSize = limits.maxTextureDimension3D;
|
||||
this._caps.uboOffsetAlignment = limits.minUniformBufferOffsetAlignment;
|
||||
|
||||
// Compute limits are read from the device (not the adapter): no elevated
|
||||
// compute limits are requested, so these are the values validation enforces.
|
||||
const deviceLimits = device.limits;
|
||||
this._caps.maxComputeSharedMemorySize = deviceLimits.maxComputeWorkgroupStorageSize;
|
||||
this._caps.maxComputeWorkGroupInvocations = deviceLimits.maxComputeInvocationsPerWorkgroup;
|
||||
this._caps.maxComputeWorkGroupSize = new Size(
|
||||
deviceLimits.maxComputeWorkgroupSizeX,
|
||||
deviceLimits.maxComputeWorkgroupSizeY,
|
||||
deviceLimits.maxComputeWorkgroupSizeZ,
|
||||
);
|
||||
this._caps.maxComputeWorkGroupCount = new Size(
|
||||
deviceLimits.maxComputeWorkgroupsPerDimension,
|
||||
deviceLimits.maxComputeWorkgroupsPerDimension,
|
||||
deviceLimits.maxComputeWorkgroupsPerDimension,
|
||||
);
|
||||
|
||||
const features = this._adapter!.features;
|
||||
// FIXME: require by query
|
||||
this._multiDrawIndirect = false;
|
||||
@@ -560,6 +576,7 @@ export class WebGPUDevice extends Device {
|
||||
this._features[Feature.ELEMENT_INDEX_UINT] = true;
|
||||
this._features[Feature.INSTANCED_ARRAYS] = true;
|
||||
this._features[Feature.MULTIPLE_RENDER_TARGETS] = true;
|
||||
this._features[Feature.COMPUTE_SHADER] = true;
|
||||
this.initFormatFeatures(features);
|
||||
|
||||
this._queue = this.createQueue(new QueueInfo(QueueType.GRAPHICS));
|
||||
@@ -684,6 +701,7 @@ export class WebGPUDevice extends Device {
|
||||
public present (): void {
|
||||
const queue = (this._queue as unknown as WebGPUQueue);
|
||||
this._numDrawCalls = queue.numDrawCalls;
|
||||
this._numDispatches = queue.numDispatches;
|
||||
this._numInstances = queue.numInstances;
|
||||
this._numTris = queue.numTris;
|
||||
queue.clear();
|
||||
|
||||
@@ -241,8 +241,8 @@ export interface IWebGPUGPUPipelineState {
|
||||
bs: BlendState;
|
||||
dynamicStates: DynamicStateFlagBit[];
|
||||
gpuRenderPass: IWebGPUGPURenderPass | null;
|
||||
pipelineState: GPURenderPipelineDescriptor | undefined;
|
||||
nativePipeline: GPUPipelineBase | undefined;
|
||||
pipelineState: GPURenderPipelineDescriptor | GPUComputePipelineDescriptor | undefined;
|
||||
nativePipeline: GPURenderPipeline | GPUComputePipeline | undefined;
|
||||
}
|
||||
|
||||
export interface IWebGPUGPUDescriptor {
|
||||
|
||||
@@ -26,7 +26,7 @@ import { PipelineState, PipelineStateInfo } from '../base/pipeline-state';
|
||||
import { IWebGPUGPUInputAssembler, IWebGPUGPUPipelineState } from './webgpu-gpu-objects';
|
||||
import { WebGPURenderPass } from './webgpu-render-pass';
|
||||
import { WebGPUShader } from './webgpu-shader';
|
||||
import { BlendOp, CullMode, DynamicStateFlagBit, Format, FormatInfos, PrimitiveMode, ShaderStageFlagBit } from '../base/define';
|
||||
import { BlendOp, CullMode, DynamicStateFlagBit, Format, FormatInfos, PipelineBindPoint, PrimitiveMode, ShaderStageFlagBit } from '../base/define';
|
||||
import { WebGPUPipelineLayout } from './webgpu-pipeline-layout';
|
||||
import {
|
||||
GFXFormatToWGPUFormat,
|
||||
@@ -81,124 +81,156 @@ export class WebGPUPipelineState extends PipelineState {
|
||||
}
|
||||
}
|
||||
|
||||
// colorstates
|
||||
const colorAttachments = this._renderPass.colorAttachments;
|
||||
const colorDescs: GPUColorTargetState[] = [];
|
||||
const colAttachmentSize = colorAttachments.length;
|
||||
const pipelineLayoutObj = info.pipelineLayout as WebGPUPipelineLayout;
|
||||
for (let i = 0; i < colAttachmentSize; i++) {
|
||||
const colDesc: GPUColorTargetState = {
|
||||
format: GFXFormatToWGPUFormat(colorAttachments[i].format),
|
||||
writeMask: WebGPUBlendMask(this._bs.targets[i].blendColorMask),
|
||||
};
|
||||
if (this._bs.targets[i].blend) {
|
||||
colDesc.blend = {
|
||||
color: {
|
||||
dstFactor: WebGPUBlendFactors[this._bs.targets[i].blendDst],
|
||||
operation: WebGPUBlendOps[this._bs.targets[i].blendEq === BlendOp.MAX ? BlendOp.ADD : this._bs.targets[i].blendEq],
|
||||
srcFactor: WebGPUBlendFactors[this._bs.targets[i].blendSrc],
|
||||
},
|
||||
alpha: {
|
||||
dstFactor: WebGPUBlendFactors[this._bs.targets[i].blendDstAlpha],
|
||||
operation: WebGPUBlendOps[this._bs.targets[i].blendAlphaEq === BlendOp.MAX ? BlendOp.ADD : this._bs.targets[i].blendAlphaEq],
|
||||
srcFactor: WebGPUBlendFactors[this._bs.targets[i].blendSrcAlpha],
|
||||
},
|
||||
};
|
||||
}
|
||||
colorDescs.push(colDesc);
|
||||
}
|
||||
|
||||
let vertexStage: GPUProgrammableStage;
|
||||
let fragmentStage: GPUProgrammableStage;
|
||||
const shaderStages = (this._shader as WebGPUShader).gpuShader.gpuStages;
|
||||
const stageSize = shaderStages.length;
|
||||
for (let i = 0; i < stageSize; i++) {
|
||||
if (shaderStages[i].type === ShaderStageFlagBit.VERTEX) { vertexStage = shaderStages[i].gpuShader!; }
|
||||
if (shaderStages[i].type === ShaderStageFlagBit.FRAGMENT) { fragmentStage = shaderStages[i].gpuShader!; }
|
||||
}
|
||||
|
||||
const gpuShader = info.shader as WebGPUShader;
|
||||
const pipelineLayoutObj = info.pipelineLayout as WebGPUPipelineLayout;
|
||||
const shaderStages = gpuShader.gpuShader.gpuStages;
|
||||
|
||||
const shaderAttrs = gpuShader.attributes;
|
||||
const attrsSize = shaderAttrs.length;
|
||||
for (let i = 0; i < attrsSize; i++) {
|
||||
this._locations.set(shaderAttrs[i].name, shaderAttrs[i].location);
|
||||
}
|
||||
const stripTopology = (info.primitive === PrimitiveMode.LINE_STRIP || info.primitive === PrimitiveMode.TRIANGLE_STRIP);
|
||||
const renderPplDesc: GPURenderPipelineDescriptor = {
|
||||
layout: pipelineLayoutObj.gpuPipelineLayout!.nativePipelineLayout,
|
||||
vertex: {
|
||||
module: vertexStage!.module,
|
||||
entryPoint: 'main',
|
||||
buffers: [],
|
||||
},
|
||||
primitive: {
|
||||
topology: WebPUPrimitives[info.primitive],
|
||||
frontFace: this._rs.isFrontFaceCCW ? 'ccw' : 'cw',
|
||||
cullMode: this._rs.cullMode === CullMode.NONE ? 'none' : (this._rs.cullMode === CullMode.FRONT) ? 'front' : 'back',
|
||||
},
|
||||
|
||||
fragment: {
|
||||
module: fragmentStage!.module,
|
||||
entryPoint: 'main',
|
||||
targets: colorDescs,
|
||||
},
|
||||
};
|
||||
if (stripTopology) renderPplDesc.primitive!.stripIndexFormat = 'uint16';
|
||||
|
||||
// depthstencil states
|
||||
let stencilRef = 0;
|
||||
if (this._renderPass.depthStencilAttachment?.format !== Format.UNKNOWN) {
|
||||
const dssDesc = {} as GPUDepthStencilState;
|
||||
dssDesc.format = GFXFormatToWGPUFormat(this._renderPass.depthStencilAttachment!.format);
|
||||
dssDesc.depthWriteEnabled = this._dss.depthWrite;
|
||||
dssDesc.depthCompare = this._dss.depthTest ? WebGPUCompereFunc[this._dss.depthFunc] : 'always';
|
||||
let stencilReadMask = 0;
|
||||
let stencilWriteMask = 0;
|
||||
|
||||
if (this._dss.stencilTestFront) {
|
||||
dssDesc.stencilFront = {
|
||||
compare: WebGPUCompereFunc[this._dss.stencilFuncFront],
|
||||
depthFailOp: WebGPUStencilOp[this._dss.stencilZFailOpFront],
|
||||
passOp: WebGPUStencilOp[this._dss.stencilPassOpFront],
|
||||
failOp: WebGPUStencilOp[this._dss.stencilFailOpFront],
|
||||
};
|
||||
stencilReadMask |= this._dss.stencilReadMaskFront;
|
||||
stencilWriteMask |= this._dss.stencilWriteMaskFront;
|
||||
stencilRef |= this._dss.stencilRefFront;
|
||||
if (info.bindPoint === PipelineBindPoint.COMPUTE) {
|
||||
// ---- Compute Pipeline ----
|
||||
let computeStage: GPUProgrammableStage | undefined;
|
||||
const stageSize = shaderStages.length;
|
||||
for (let i = 0; i < stageSize; i++) {
|
||||
if (shaderStages[i].type === ShaderStageFlagBit.COMPUTE) {
|
||||
computeStage = shaderStages[i].gpuShader!;
|
||||
}
|
||||
}
|
||||
if (this._dss.stencilTestBack) {
|
||||
dssDesc.stencilBack = {
|
||||
compare: WebGPUCompereFunc[this._dss.stencilFuncBack],
|
||||
depthFailOp: WebGPUStencilOp[this._dss.stencilZFailOpBack],
|
||||
passOp: WebGPUStencilOp[this._dss.stencilPassOpBack],
|
||||
failOp: WebGPUStencilOp[this._dss.stencilFailOpBack],
|
||||
};
|
||||
stencilReadMask |= this._dss.stencilReadMaskBack;
|
||||
stencilWriteMask |= this._dss.stencilWriteMaskBack;
|
||||
stencilRef |= this._dss.stencilRefBack;
|
||||
}
|
||||
dssDesc.stencilReadMask = stencilReadMask;
|
||||
dssDesc.stencilWriteMask = stencilWriteMask;
|
||||
dssDesc.depthBias = this._rs.depthBias;
|
||||
dssDesc.depthBiasSlopeScale = this._rs.depthBiasSlop;
|
||||
dssDesc.depthBiasClamp = this._rs.depthBiasClamp;
|
||||
renderPplDesc.depthStencil = dssDesc;
|
||||
}
|
||||
|
||||
this._gpuPipelineState = {
|
||||
gpuPrimitive: WebPUPrimitives[info.primitive],
|
||||
gpuShader: gpuShader.gpuShader,
|
||||
gpuPipelineLayout: pipelineLayoutObj.gpuPipelineLayout,
|
||||
rs: info.rasterizerState,
|
||||
dss: info.depthStencilState,
|
||||
stencilRef,
|
||||
bs: info.blendState,
|
||||
gpuRenderPass: (info.renderPass as WebGPURenderPass).gpuRenderPass,
|
||||
dynamicStates,
|
||||
pipelineState: renderPplDesc,
|
||||
nativePipeline: undefined,
|
||||
};
|
||||
const computeDesc: GPUComputePipelineDescriptor = {
|
||||
layout: pipelineLayoutObj.gpuPipelineLayout!.nativePipelineLayout,
|
||||
compute: computeStage!,
|
||||
};
|
||||
|
||||
this._gpuPipelineState = {
|
||||
gpuPrimitive: 'triangle-list' as GPUPrimitiveTopology,
|
||||
gpuShader: gpuShader.gpuShader,
|
||||
gpuPipelineLayout: pipelineLayoutObj.gpuPipelineLayout,
|
||||
rs: info.rasterizerState,
|
||||
dss: info.depthStencilState,
|
||||
stencilRef: 0,
|
||||
bs: info.blendState,
|
||||
gpuRenderPass: null,
|
||||
dynamicStates,
|
||||
pipelineState: computeDesc,
|
||||
nativePipeline: undefined,
|
||||
};
|
||||
} else {
|
||||
// ---- Render Pipeline ----
|
||||
// colorstates
|
||||
const colorAttachments = this._renderPass.colorAttachments;
|
||||
const colorDescs: GPUColorTargetState[] = [];
|
||||
const colAttachmentSize = colorAttachments.length;
|
||||
for (let i = 0; i < colAttachmentSize; i++) {
|
||||
const colDesc: GPUColorTargetState = {
|
||||
format: GFXFormatToWGPUFormat(colorAttachments[i].format),
|
||||
writeMask: WebGPUBlendMask(this._bs.targets[i].blendColorMask),
|
||||
};
|
||||
if (this._bs.targets[i].blend) {
|
||||
colDesc.blend = {
|
||||
color: {
|
||||
dstFactor: WebGPUBlendFactors[this._bs.targets[i].blendDst],
|
||||
operation: WebGPUBlendOps[this._bs.targets[i].blendEq === BlendOp.MAX ? BlendOp.ADD : this._bs.targets[i].blendEq],
|
||||
srcFactor: WebGPUBlendFactors[this._bs.targets[i].blendSrc],
|
||||
},
|
||||
alpha: {
|
||||
dstFactor: WebGPUBlendFactors[this._bs.targets[i].blendDstAlpha],
|
||||
operation: WebGPUBlendOps[
|
||||
this._bs.targets[i].blendAlphaEq === BlendOp.MAX ? BlendOp.ADD : this._bs.targets[i].blendAlphaEq],
|
||||
srcFactor: WebGPUBlendFactors[this._bs.targets[i].blendSrcAlpha],
|
||||
},
|
||||
};
|
||||
}
|
||||
colorDescs.push(colDesc);
|
||||
}
|
||||
|
||||
let vertexStage: GPUProgrammableStage;
|
||||
let fragmentStage: GPUProgrammableStage;
|
||||
const stageSize = shaderStages.length;
|
||||
for (let i = 0; i < stageSize; i++) {
|
||||
if (shaderStages[i].type === ShaderStageFlagBit.VERTEX) { vertexStage = shaderStages[i].gpuShader!; }
|
||||
if (shaderStages[i].type === ShaderStageFlagBit.FRAGMENT) { fragmentStage = shaderStages[i].gpuShader!; }
|
||||
}
|
||||
|
||||
const shaderAttrs = gpuShader.attributes;
|
||||
const attrsSize = shaderAttrs.length;
|
||||
for (let i = 0; i < attrsSize; i++) {
|
||||
this._locations.set(shaderAttrs[i].name, shaderAttrs[i].location);
|
||||
}
|
||||
const stripTopology = (info.primitive === PrimitiveMode.LINE_STRIP || info.primitive === PrimitiveMode.TRIANGLE_STRIP);
|
||||
const renderPplDesc: GPURenderPipelineDescriptor = {
|
||||
layout: pipelineLayoutObj.gpuPipelineLayout!.nativePipelineLayout,
|
||||
vertex: {
|
||||
module: vertexStage!.module,
|
||||
entryPoint: 'main',
|
||||
buffers: [],
|
||||
},
|
||||
primitive: {
|
||||
topology: WebPUPrimitives[info.primitive],
|
||||
frontFace: this._rs.isFrontFaceCCW ? 'ccw' : 'cw',
|
||||
cullMode: this._rs.cullMode === CullMode.NONE ? 'none' : (this._rs.cullMode === CullMode.FRONT) ? 'front' : 'back',
|
||||
},
|
||||
|
||||
fragment: {
|
||||
module: fragmentStage!.module,
|
||||
entryPoint: 'main',
|
||||
targets: colorDescs,
|
||||
},
|
||||
};
|
||||
if (stripTopology) renderPplDesc.primitive!.stripIndexFormat = 'uint16';
|
||||
|
||||
// depthstencil states
|
||||
let stencilRef = 0;
|
||||
if (this._renderPass.depthStencilAttachment?.format !== Format.UNKNOWN) {
|
||||
const dssDesc = {} as GPUDepthStencilState;
|
||||
dssDesc.format = GFXFormatToWGPUFormat(this._renderPass.depthStencilAttachment!.format);
|
||||
dssDesc.depthWriteEnabled = this._dss.depthWrite;
|
||||
dssDesc.depthCompare = this._dss.depthTest ? WebGPUCompereFunc[this._dss.depthFunc] : 'always';
|
||||
let stencilReadMask = 0;
|
||||
let stencilWriteMask = 0;
|
||||
|
||||
if (this._dss.stencilTestFront) {
|
||||
dssDesc.stencilFront = {
|
||||
compare: WebGPUCompereFunc[this._dss.stencilFuncFront],
|
||||
depthFailOp: WebGPUStencilOp[this._dss.stencilZFailOpFront],
|
||||
passOp: WebGPUStencilOp[this._dss.stencilPassOpFront],
|
||||
failOp: WebGPUStencilOp[this._dss.stencilFailOpFront],
|
||||
};
|
||||
stencilReadMask |= this._dss.stencilReadMaskFront;
|
||||
stencilWriteMask |= this._dss.stencilWriteMaskFront;
|
||||
stencilRef |= this._dss.stencilRefFront;
|
||||
}
|
||||
if (this._dss.stencilTestBack) {
|
||||
dssDesc.stencilBack = {
|
||||
compare: WebGPUCompereFunc[this._dss.stencilFuncBack],
|
||||
depthFailOp: WebGPUStencilOp[this._dss.stencilZFailOpBack],
|
||||
passOp: WebGPUStencilOp[this._dss.stencilPassOpBack],
|
||||
failOp: WebGPUStencilOp[this._dss.stencilFailOpBack],
|
||||
};
|
||||
stencilReadMask |= this._dss.stencilReadMaskBack;
|
||||
stencilWriteMask |= this._dss.stencilWriteMaskBack;
|
||||
stencilRef |= this._dss.stencilRefBack;
|
||||
}
|
||||
dssDesc.stencilReadMask = stencilReadMask;
|
||||
dssDesc.stencilWriteMask = stencilWriteMask;
|
||||
dssDesc.depthBias = this._rs.depthBias;
|
||||
dssDesc.depthBiasSlopeScale = this._rs.depthBiasSlop;
|
||||
dssDesc.depthBiasClamp = this._rs.depthBiasClamp;
|
||||
renderPplDesc.depthStencil = dssDesc;
|
||||
}
|
||||
|
||||
this._gpuPipelineState = {
|
||||
gpuPrimitive: WebPUPrimitives[info.primitive],
|
||||
gpuShader: gpuShader.gpuShader,
|
||||
gpuPipelineLayout: pipelineLayoutObj.gpuPipelineLayout,
|
||||
rs: info.rasterizerState,
|
||||
dss: info.depthStencilState,
|
||||
stencilRef,
|
||||
bs: info.blendState,
|
||||
gpuRenderPass: (info.renderPass as WebGPURenderPass).gpuRenderPass,
|
||||
dynamicStates,
|
||||
pipelineState: renderPplDesc,
|
||||
nativePipeline: undefined,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
protected _getShaderLocation (name: string): number | undefined {
|
||||
@@ -215,9 +247,22 @@ export class WebGPUPipelineState extends PipelineState {
|
||||
if (this._gpuPipelineState!.nativePipeline && !forceUpdate) {
|
||||
return;
|
||||
}
|
||||
const webgpuDevice = (WebGPUDeviceManager.instance);
|
||||
const nativeDevice = webgpuDevice.nativeDevice;
|
||||
|
||||
const pipelineState = this._gpuPipelineState!.pipelineState!;
|
||||
// Compute pipeline: no vertex attributes, no multisample
|
||||
if ('compute' in pipelineState) {
|
||||
const nativePipeline = nativeDevice?.createComputePipeline(
|
||||
pipelineState,
|
||||
);
|
||||
this._gpuPipelineState!.nativePipeline = nativePipeline;
|
||||
return;
|
||||
}
|
||||
|
||||
// Render pipeline
|
||||
const gpuShader = this.shader;
|
||||
const shaderAttrs = gpuShader.attributes;
|
||||
const pipelineState = this._gpuPipelineState!.pipelineState!;
|
||||
const vertexAttrs: GPUVertexBufferLayout[] = [];
|
||||
const emptyPushAttr: string[] = [];
|
||||
const streamCount = ia.gpuVertexBuffers.length;
|
||||
@@ -272,8 +317,6 @@ export class WebGPUPipelineState extends PipelineState {
|
||||
|
||||
pipelineState.vertex.buffers = vertexAttrs;
|
||||
pipelineState.multisample = { count: ia.samples };
|
||||
const webgpuDevice = (WebGPUDeviceManager.instance);
|
||||
const nativeDevice = webgpuDevice.nativeDevice;
|
||||
const nativePipeline = nativeDevice?.createRenderPipeline(pipelineState);
|
||||
this._gpuPipelineState!.nativePipeline = nativePipeline;
|
||||
}
|
||||
|
||||
@@ -29,6 +29,7 @@ import { QueueInfo } from '../base/define';
|
||||
|
||||
export class WebGPUQueue extends Queue {
|
||||
public numDrawCalls = 0;
|
||||
public numDispatches = 0;
|
||||
public numInstances = 0;
|
||||
public numTris = 0;
|
||||
|
||||
@@ -51,6 +52,7 @@ export class WebGPUQueue extends Queue {
|
||||
for (let i = 0; i < cmdBuffSize; i++) {
|
||||
const cmdBuff = cmdBuffs[i] as WebGPUCommandBuffer;
|
||||
this.numDrawCalls += cmdBuff.numDrawCalls;
|
||||
this.numDispatches += cmdBuff.numDispatches;
|
||||
this.numInstances += cmdBuff.numInstances;
|
||||
this.numTris += cmdBuff.numTris;
|
||||
}
|
||||
@@ -59,6 +61,7 @@ export class WebGPUQueue extends Queue {
|
||||
|
||||
public clear (): void {
|
||||
this.numDrawCalls = 0;
|
||||
this.numDispatches = 0;
|
||||
this.numInstances = 0;
|
||||
this.numTris = 0;
|
||||
}
|
||||
|
||||
@@ -52,6 +52,7 @@ class Particle {
|
||||
public pos = new Vec2(0, 0);
|
||||
public startPos = new Vec2(0, 0);
|
||||
public color = new Color(0, 0, 0, 255);
|
||||
public curColor = { r: 0, g: 0, b: 0, a: 255 };
|
||||
public deltaColor = { r: 0, g: 0, b: 0, a: 255 };
|
||||
public size = 0;
|
||||
public deltaSize = 0;
|
||||
@@ -81,6 +82,8 @@ const pool = new ParticlePool((par: Particle): void => {
|
||||
par.pos.set(Vec2.ZERO);
|
||||
par.startPos.set(Vec2.ZERO);
|
||||
par.color.set(0, 0, 0, 255);
|
||||
par.curColor.r = par.curColor.g = par.curColor.b = 0;
|
||||
par.curColor.a = 255;
|
||||
par.deltaColor.r = par.deltaColor.g = par.deltaColor.b = 0;
|
||||
par.deltaColor.a = 255;
|
||||
par.size = 0;
|
||||
@@ -111,6 +114,7 @@ export class Simulator {
|
||||
private elapsed = 0;
|
||||
private emitCounter = 0;
|
||||
private _worldRotation = 0;
|
||||
private _parentAlpha = 0.0;
|
||||
private declare sys: ParticleSystem2D;
|
||||
|
||||
constructor (system) {
|
||||
@@ -169,10 +173,10 @@ export class Simulator {
|
||||
const endColor = psys.endColor;
|
||||
const endColorVar = psys.endColorVar;
|
||||
|
||||
particle.color.r = sr = clamp(startColor.r + startColorVar.r * (random() - 0.5) * 2, 0, 255);
|
||||
particle.color.g = sg = clamp(startColor.g + startColorVar.g * (random() - 0.5) * 2, 0, 255);
|
||||
particle.color.b = sb = clamp(startColor.b + startColorVar.b * (random() - 0.5) * 2, 0, 255);
|
||||
particle.color.a = sa = clamp(startColor.a + startColorVar.a * (random() - 0.5) * 2, 0, 255);
|
||||
particle.curColor.r = sr = clamp(startColor.r + startColorVar.r * (random() - 0.5) * 2, 0, 255);
|
||||
particle.curColor.g = sg = clamp(startColor.g + startColorVar.g * (random() - 0.5) * 2, 0, 255);
|
||||
particle.curColor.b = sb = clamp(startColor.b + startColorVar.b * (random() - 0.5) * 2, 0, 255);
|
||||
particle.curColor.a = sa = clamp(startColor.a + startColorVar.a * (random() - 0.5) * 2, 0, 255);
|
||||
particle.deltaColor.r = (clamp(endColor.r + endColorVar.r * (random() - 0.5) * 2, 0, 255) - sr) / timeToLive;
|
||||
particle.deltaColor.g = (clamp(endColor.g + endColorVar.g * (random() - 0.5) * 2, 0, 255) - sg) / timeToLive;
|
||||
particle.deltaColor.b = (clamp(endColor.b + endColorVar.b * (random() - 0.5) * 2, 0, 255) - sb) / timeToLive;
|
||||
@@ -329,6 +333,14 @@ export class Simulator {
|
||||
Vec4.toArray(vbuf, _col, offset + 32);
|
||||
}
|
||||
|
||||
private _updateColor (): void {
|
||||
const selfNode = this.sys.node;
|
||||
const parentNode = selfNode.parent;
|
||||
const uiProps = selfNode._uiProps;
|
||||
const parentOpacity = parentNode ? parentNode._uiProps.opacity : 1.0;
|
||||
this._parentAlpha = uiProps.localOpacity * parentOpacity;
|
||||
}
|
||||
|
||||
public step (dt: number): void {
|
||||
const assembler = this.sys.assembler as Particle2DAssembler;
|
||||
const psys = this.sys;
|
||||
@@ -379,6 +391,8 @@ export class Simulator {
|
||||
this.updateUVs();
|
||||
}
|
||||
|
||||
this._updateColor();
|
||||
|
||||
// Used to reduce memory allocation / creation within the loop
|
||||
let particleIdx = 0;
|
||||
while (particleIdx < particles.length) {
|
||||
@@ -431,10 +445,15 @@ export class Simulator {
|
||||
}
|
||||
|
||||
// color
|
||||
particle.color.r += particle.deltaColor.r * dt;
|
||||
particle.color.g += particle.deltaColor.g * dt;
|
||||
particle.color.b += particle.deltaColor.b * dt;
|
||||
particle.color.a += particle.deltaColor.a * dt;
|
||||
particle.curColor.r += particle.deltaColor.r * dt;
|
||||
particle.curColor.g += particle.deltaColor.g * dt;
|
||||
particle.curColor.b += particle.deltaColor.b * dt;
|
||||
particle.curColor.a += particle.deltaColor.a * dt;
|
||||
|
||||
particle.color.r = particle.curColor.r;
|
||||
particle.color.g = particle.curColor.g;
|
||||
particle.color.b = particle.curColor.b;
|
||||
particle.color.a = particle.curColor.a * this._parentAlpha;
|
||||
|
||||
// size
|
||||
particle.size += particle.deltaSize * dt;
|
||||
|
||||
@@ -797,7 +797,7 @@ export class ParticleSystem2D extends UIRenderer {
|
||||
}
|
||||
|
||||
private _startPreview (): void {
|
||||
if (this._preview) {
|
||||
if (!this._preview) {
|
||||
this.resetSystem();
|
||||
}
|
||||
}
|
||||
|
||||
+10
-1
@@ -25,7 +25,7 @@
|
||||
import { ccclass, help, executeInEditMode, menu, tooltip, displayOrder, type, serializable,
|
||||
range, visible, override, displayName } from 'cc.decorator';
|
||||
import { Material, Texture2D } from '../asset/assets';
|
||||
import { Vec3, cclegacy, Vec4, Vec2, CCBoolean } from '../core';
|
||||
import { Vec3, cclegacy, Vec4, Vec2, CCBoolean, Color } from '../core';
|
||||
import { LineModel } from './models/line-model';
|
||||
import { builtinResMgr } from '../asset/asset-manager';
|
||||
import CurveRange from './animator/curve-range';
|
||||
@@ -296,6 +296,15 @@ export class Line extends ModelRenderer {
|
||||
}
|
||||
}
|
||||
|
||||
public updateColor (): void {
|
||||
if (this._color) {
|
||||
if (this._models[0]) {
|
||||
const lineModel = this._models[0] as LineModel;
|
||||
lineModel.addLineVertexData(this._positions, this._width, this._color);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
protected _onMaterialModified (index: number, material: Material | null): void {
|
||||
super._onMaterialModified(index, material);
|
||||
const matIns = this.getMaterialInstance(0);
|
||||
|
||||
@@ -60,6 +60,7 @@ interface IProfilerState {
|
||||
frame: ICounterOption;
|
||||
fps: ICounterOption;
|
||||
draws: ICounterOption;
|
||||
dispatches: ICounterOption;
|
||||
instances: ICounterOption;
|
||||
tricount: ICounterOption;
|
||||
logic: ICounterOption;
|
||||
@@ -73,6 +74,7 @@ interface IProfilerState {
|
||||
const _profileInfo = {
|
||||
fps: { desc: `Framerate (FPS)`, below: 30, average: _average, isInteger: true },
|
||||
draws: { desc: 'Draw call', isInteger: true },
|
||||
dispatches: { desc: 'Dispatch call', isInteger: true },
|
||||
frame: { desc: 'Frame time (ms)', min: 0, max: 50, average: _average },
|
||||
instances: { desc: 'Instance Count', isInteger: true },
|
||||
tricount: { desc: 'Triangle', isInteger: true },
|
||||
@@ -586,6 +588,8 @@ export class Profiler extends System {
|
||||
|
||||
const device = this._device!;
|
||||
(profilerStats.draws.counter as PerfCounter).value = device.numDrawCalls;
|
||||
// Native (JSB) devices expose no dispatch stats yet; WebGPU does. Treat missing as 0.
|
||||
(profilerStats.dispatches.counter as PerfCounter).value = device.numDispatches ?? 0;
|
||||
(profilerStats.instances.counter as PerfCounter).value = device.numInstances;
|
||||
(profilerStats.bufferMemory.counter as PerfCounter).value = device.memoryStatus.bufferSize / (1024 * 1024);
|
||||
(profilerStats.textureMemory.counter as PerfCounter).value = device.memoryStatus.textureSize / (1024 * 1024);
|
||||
|
||||
@@ -22,7 +22,6 @@
|
||||
THE SOFTWARE.
|
||||
****************************************************************************/
|
||||
import { Buffer, Framebuffer, Texture, Viewport } from '../../gfx';
|
||||
import { genHashValue } from './define';
|
||||
import { VectorGraphColorMap } from './effect';
|
||||
import { DefaultVisitor, depthFirstSearch, ReferenceGraphView } from './graph';
|
||||
import { LayoutGraphData } from './layout-graph';
|
||||
@@ -199,7 +198,6 @@ class PassVisitor implements RenderGraphVisitor {
|
||||
resourceGraph.visitVertex(this._resVisitor, vertID);
|
||||
}
|
||||
}
|
||||
genHashValue(pass);
|
||||
}
|
||||
}
|
||||
applyID (id: number, resId: number): void {
|
||||
@@ -233,7 +231,21 @@ class PassVisitor implements RenderGraphVisitor {
|
||||
compute (value: ComputePass): void {
|
||||
this._currPass = value;
|
||||
const rg = context.renderGraph;
|
||||
if (rg.getValid(this.passID)) {
|
||||
// Avoid revisiting a valid pass and recursive dependency cycles.
|
||||
return;
|
||||
}
|
||||
rg.setValid(this.passID, true);
|
||||
// Trace READ dependencies only; WRITE dependencies are produced by this pass.
|
||||
const resourceGraph = this.context.resourceGraph;
|
||||
for (const [computeName, cViews] of value.computeViews) {
|
||||
if (!cViews.length || cViews[0].accessType !== AccessType.READ) continue;
|
||||
const vertID = resourceGraph.find(computeName);
|
||||
if (vertID !== 0xFFFFFFFF) {
|
||||
this._resVisitor.resID = vertID;
|
||||
resourceGraph.visitVertex(this._resVisitor, vertID);
|
||||
}
|
||||
}
|
||||
}
|
||||
resolve (value: ResolvePass): void {
|
||||
// noop
|
||||
|
||||
@@ -48,6 +48,7 @@ import {
|
||||
Device,
|
||||
deviceManager,
|
||||
DispatchInfo,
|
||||
Feature,
|
||||
Format,
|
||||
Framebuffer,
|
||||
FramebufferInfo,
|
||||
@@ -56,9 +57,7 @@ import {
|
||||
InputAssemblerInfo,
|
||||
LoadOp,
|
||||
MemoryUsageBit,
|
||||
PipelineBindPoint,
|
||||
PipelineState,
|
||||
PipelineStateInfo,
|
||||
Rect,
|
||||
RenderPass,
|
||||
RenderPassInfo,
|
||||
@@ -1910,26 +1909,23 @@ class PreRenderVisitor extends BaseRenderVisitor implements RenderGraphVisitor {
|
||||
renderScene.preRecord();
|
||||
}
|
||||
dispatch (value: Dispatch): void {
|
||||
if (!context.device.hasFeature(Feature.COMPUTE_SHADER)) return;
|
||||
let pso: PipelineState | null = null;
|
||||
const devicePass = this.currPass as DeviceComputePass;
|
||||
const pass = value.material?.passes[value.passID];
|
||||
pass?.update();
|
||||
const shader = pass?.getShaderVariant();
|
||||
|
||||
if (pass !== null && shader !== null) {
|
||||
const psoInfo = new PipelineStateInfo(
|
||||
shader,
|
||||
pass?.pipelineLayout,
|
||||
);
|
||||
psoInfo.bindPoint = PipelineBindPoint.COMPUTE;
|
||||
pso = deviceManager.gfxDevice.createPipelineState(psoInfo);
|
||||
if (pass && shader) {
|
||||
pso = PipelineStateManager.getOrCreateComputePipelineState(deviceManager.gfxDevice, pass, shader);
|
||||
}
|
||||
const cmdBuff = context.commandBuffer;
|
||||
if (pso) {
|
||||
if (pso && pass) {
|
||||
cmdBuff.bindPipelineState(pso);
|
||||
const layoutStage = devicePass.renderLayout;
|
||||
const layoutDesc = layoutStage!.descriptorSet!;
|
||||
cmdBuff.bindDescriptorSet(SetIndex.GLOBAL, layoutDesc);
|
||||
cmdBuff.bindDescriptorSet(SetIndex.MATERIAL, pass.descriptorSet);
|
||||
}
|
||||
|
||||
const gx = value.threadGroupCountX;
|
||||
@@ -1965,10 +1961,12 @@ class PostRenderVisitor extends BaseRenderVisitor implements RenderGraphVisitor
|
||||
computeSubpass (value: ComputeSubpass): void {
|
||||
// do nothing
|
||||
}
|
||||
resolve (value: ResolvePass): void {
|
||||
// do nothing
|
||||
}
|
||||
compute (value: ComputePass): void {
|
||||
if (!context.device.hasFeature(Feature.COMPUTE_SHADER)) return;
|
||||
const cmdBuff = context.commandBuffer;
|
||||
(cmdBuff as any).submitComputePass();
|
||||
}
|
||||
resolve (value: ResolvePass): void {
|
||||
// do nothing
|
||||
}
|
||||
copy (value: CopyPass): void {
|
||||
|
||||
@@ -195,10 +195,13 @@ function sceneCulling (
|
||||
}
|
||||
models.push(model);
|
||||
} else if (probe.probeType === ProbeType.CUBE) {
|
||||
if (!wBounds || !model.bakeToReflectionProbe) {
|
||||
continue;
|
||||
}
|
||||
if (!isVisible(model, visibility)) {
|
||||
continue;
|
||||
}
|
||||
if (wBounds && isIntersectAABB(wBounds, probe.boundingBox!)) {
|
||||
if (isIntersectAABB(wBounds, probe.boundingBox!)) {
|
||||
continue;
|
||||
}
|
||||
models.push(model);
|
||||
@@ -475,7 +478,8 @@ export class SceneCulling {
|
||||
);
|
||||
|
||||
// Get or create render queue
|
||||
const renderQueueID = this.getOrCreateRenderQueue(renderQueueKey, sceneData.flags, sceneData.camera);
|
||||
const renderCamera = sceneData.light.probe ? sceneData.light.probe.camera : sceneData.camera;
|
||||
const renderQueueID = this.getOrCreateRenderQueue(renderQueueKey, sceneData.flags, renderCamera);
|
||||
|
||||
// add render queue query
|
||||
const renderQueueQuery = this.cullingPools.renderQueueQueryRecycle.add();
|
||||
|
||||
@@ -258,9 +258,19 @@ export class WebRenderQueueBuilder extends WebSetter implements RenderQueueBuild
|
||||
|
||||
addSceneOfCamera (camera: Camera, light: LightInfo, sceneFlags = SceneFlags.NONE, name = 'Camera'): void {
|
||||
const lightTarget = light.light;
|
||||
this.addScene(camera, sceneFlags, lightTarget);
|
||||
const scene = light.probe?.node?.scene?.renderScene || undefined;
|
||||
this._addScene(camera, sceneFlags, lightTarget, scene, light);
|
||||
}
|
||||
addScene (camera: Camera, sceneFlags = SceneFlags.NONE, light: Light | undefined | null = null, scene: RenderScene | undefined = undefined): SceneBuilder {
|
||||
return this._addScene(camera, sceneFlags, light, scene);
|
||||
}
|
||||
private _addScene (
|
||||
camera: Camera,
|
||||
sceneFlags: SceneFlags,
|
||||
light: Light | undefined | null,
|
||||
scene: RenderScene | undefined,
|
||||
lightInfo: LightInfo | null = null,
|
||||
): SceneBuilder {
|
||||
const sceneData = renderGraphPool.createSceneData(
|
||||
scene || camera.scene,
|
||||
camera,
|
||||
@@ -268,6 +278,9 @@ export class WebRenderQueueBuilder extends WebSetter implements RenderQueueBuild
|
||||
light && !(sceneFlags & SceneFlags.SHADOW_CASTER) ? CullingFlags.CAMERA_FRUSTUM | CullingFlags.LIGHT_BOUNDS : CullingFlags.CAMERA_FRUSTUM,
|
||||
light,
|
||||
);
|
||||
if (lightInfo) {
|
||||
sceneData.light.reset(lightInfo.light, lightInfo.level, lightInfo.culledByLight, lightInfo.probe);
|
||||
}
|
||||
const renderData = renderGraphPool.createRenderData();
|
||||
const sceneId = this._renderGraph.addVertex<RenderGraphValue.Scene>(RenderGraphValue.Scene, sceneData, 'Scene', '', renderData, !DEBUG, this._vertID);
|
||||
if (!(sceneFlags & SceneFlags.NON_BUILTIN)) {
|
||||
@@ -851,7 +864,11 @@ export class WebComputePassBuilder extends WebSetter implements ComputePassBuild
|
||||
this._renderGraph.setName(this._vertID, name);
|
||||
}
|
||||
addTexture (name: string, slotName: string, sampler: Sampler | null = null): void {
|
||||
throw new Error('Method not implemented.');
|
||||
this._addComputeResource(name, AccessType.READ, slotName);
|
||||
if (sampler) {
|
||||
const descriptorID = this._lg.attributeIndex.get(slotName)!;
|
||||
this._data.samplers.set(descriptorID, sampler);
|
||||
}
|
||||
}
|
||||
addStorageBuffer (name: string, accessType: AccessType, slotName: string): void {
|
||||
this._addComputeResource(name, accessType, slotName);
|
||||
@@ -1650,13 +1667,16 @@ export class WebPipeline extends WebSetter implements BasicPipeline {
|
||||
this._compiler = new Compiler(this, this._renderGraph, this._resourceGraph, this._lg);
|
||||
}
|
||||
this._compiler.compile(this._renderGraph);
|
||||
} else {
|
||||
this._renderGraph.x.forEach((vert) => {
|
||||
if (vert.t === RenderGraphValue.RasterPass) {
|
||||
genHashValue(vert.j as RasterPass);
|
||||
}
|
||||
});
|
||||
}
|
||||
this._renderGraph.x.forEach((vert, v) => {
|
||||
if (vert.t !== RenderGraphValue.RasterPass) {
|
||||
return;
|
||||
}
|
||||
if (DEBUG && !this._renderGraph!.getValid(v)) {
|
||||
return;
|
||||
}
|
||||
genHashValue(vert.j as RasterPass);
|
||||
});
|
||||
}
|
||||
|
||||
execute (): void {
|
||||
|
||||
@@ -131,6 +131,11 @@ export class InstancedBuffer {
|
||||
stride,
|
||||
shader,
|
||||
descriptorSet,
|
||||
lightingMap,
|
||||
useReflectionProbeType,
|
||||
reflectionProbeCubemap,
|
||||
reflectionProbePlanarMap,
|
||||
reflectionProbeBlendCubemap,
|
||||
);
|
||||
}
|
||||
|
||||
@@ -157,14 +162,20 @@ export class InstancedBuffer {
|
||||
stride: number,
|
||||
shader: Shader,
|
||||
descriptorSet: DescriptorSet,
|
||||
lightingMap: Texture,
|
||||
useReflectionProbeType: number,
|
||||
reflectionProbeCubemap: Texture,
|
||||
reflectionProbePlanarMap: Texture,
|
||||
reflectionProbeBlendCubemap: Texture | null,
|
||||
): void {
|
||||
const newSize = stride * INITIAL_CAPACITY;
|
||||
const vb = this._device.createBuffer(new BufferInfo(
|
||||
BufferUsageBit.VERTEX | BufferUsageBit.TRANSFER_DST,
|
||||
MemoryUsageBit.HOST | MemoryUsageBit.DEVICE,
|
||||
stride * INITIAL_CAPACITY,
|
||||
newSize,
|
||||
stride,
|
||||
));
|
||||
const data = new Uint8Array(stride * INITIAL_CAPACITY);
|
||||
const data = new Uint8Array(newSize);
|
||||
const vertexBuffers = sourceIA.vertexBuffers.slice();
|
||||
const attributes = sourceIA.attributes.slice();
|
||||
const indexBuffer = sourceIA.indexBuffer;
|
||||
@@ -188,6 +199,11 @@ export class InstancedBuffer {
|
||||
stride,
|
||||
shader,
|
||||
descriptorSet,
|
||||
lightingMap,
|
||||
reflectionProbeCubemap,
|
||||
reflectionProbePlanarMap,
|
||||
useReflectionProbeType,
|
||||
reflectionProbeBlendCubemap,
|
||||
} as IInstancedItem;
|
||||
this.instances.push(instance);
|
||||
let mappedInstances = this._instanceMap.get(key);
|
||||
|
||||
@@ -22,7 +22,7 @@
|
||||
THE SOFTWARE.
|
||||
*/
|
||||
|
||||
import { Shader, RenderPass, InputAssembler, Device, PipelineState, InputState, PipelineStateInfo } from '../gfx';
|
||||
import { Shader, RenderPass, InputAssembler, Device, PipelineState, InputState, PipelineStateInfo, PipelineBindPoint } from '../gfx';
|
||||
import { Pass } from '../render-scene/core/pass';
|
||||
|
||||
export class PipelineStateManager {
|
||||
@@ -30,6 +30,8 @@ export class PipelineStateManager {
|
||||
|
||||
private static _PSOHashMap: Map<number, PipelineState> = new Map<number, PipelineState>();
|
||||
|
||||
private static _computePSOHashMap: Map<number, PipelineState> = new Map<number, PipelineState>();
|
||||
|
||||
// pass is only needed on TS.
|
||||
static getOrCreatePipelineState (device: Device, pass: Pass, shader: Shader, renderPass: RenderPass, ia: InputAssembler): PipelineState {
|
||||
const hash1 = pass.hash;
|
||||
@@ -59,4 +61,33 @@ export class PipelineStateManager {
|
||||
|
||||
return pso;
|
||||
}
|
||||
|
||||
/**
|
||||
* @en Get or create a compute pipeline state.
|
||||
* A compute pipeline only depends on the shader variant and the pipeline layout,
|
||||
* both carried by the pass, so the cache key is `pass.hash ^ shader.typedID`,
|
||||
* mirroring the graphics-side hash mechanism without renderPass/inputState factors.
|
||||
* @zh 获取或创建计算管线状态。
|
||||
* 计算管线仅依赖于着色器变体与管线布局(均由 pass 携带),
|
||||
* 因此缓存键为 `pass.hash ^ shader.typedID`,与图形侧哈希机制一致但不包含 renderPass/顶点布局因子。
|
||||
*/
|
||||
static getOrCreateComputePipelineState (device: Device, pass: Pass, shader: Shader): PipelineState {
|
||||
const hash1 = pass.hash;
|
||||
const hash2 = shader.typedID;
|
||||
|
||||
const newHash = hash1 ^ hash2;
|
||||
let pso = this._computePSOHashMap.get(newHash);
|
||||
if (!pso) {
|
||||
const pipelineLayout = pass.pipelineLayout;
|
||||
const psoInfo = new PipelineStateInfo(
|
||||
shader,
|
||||
pipelineLayout,
|
||||
);
|
||||
psoInfo.bindPoint = PipelineBindPoint.COMPUTE;
|
||||
pso = device.createPipelineState(psoInfo);
|
||||
this._computePSOHashMap.set(newHash, pso);
|
||||
}
|
||||
|
||||
return pso;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1815,11 +1815,11 @@ export class Terrain extends Component {
|
||||
* @zh 获得纹理层
|
||||
*/
|
||||
public getLayer (id: number): TerrainLayer | null {
|
||||
if (id === -1) {
|
||||
if (id === -1 || id === undefined) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return this._layerList[id];
|
||||
return this._layerList[id] || null;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -2584,7 +2584,8 @@ export class Terrain extends Component {
|
||||
const index1 = j * this.blockCount[0] + i;
|
||||
|
||||
for (let l = 0; l < TERRAIN_MAX_BLEND_LAYERS; ++l) {
|
||||
layerBuffer[index0 * TERRAIN_MAX_BLEND_LAYERS + l] = this._layerBuffer[index1 * TERRAIN_MAX_BLEND_LAYERS + l];
|
||||
const oldVal = this._layerBuffer[index1 * TERRAIN_MAX_BLEND_LAYERS + l];
|
||||
layerBuffer[index0 * TERRAIN_MAX_BLEND_LAYERS + l] = oldVal !== undefined ? oldVal : -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -204,7 +204,7 @@ function align (node: Node, widget: Widget): void {
|
||||
// TODO: type is hack, Change to the type actually used (Node or BaseNode) when BaseNode complete
|
||||
function visitNode (node: any): void {
|
||||
const widget = node.getComponent(Widget);
|
||||
if (widget && widget.enabled) {
|
||||
if (widget && widget.enabled && cclegacy.isValid(widget, true)) {
|
||||
if (DEV) {
|
||||
widget._validateTargetInDEV();
|
||||
}
|
||||
|
||||
@@ -852,6 +852,9 @@ export class Widget extends Component {
|
||||
}
|
||||
|
||||
public onDestroy (): void {
|
||||
// `onDisable` is skipped when the component was never enabled by the scheduler
|
||||
// (`IsOnEnableCalled` unset), so unregister here as well.
|
||||
cclegacy._widgetManager?.remove(this);
|
||||
this._removeParentEvent();
|
||||
}
|
||||
|
||||
|
||||
@@ -669,8 +669,8 @@ export class BuiltinForwardPassBuilder implements rendering.PipelinePassBuilder
|
||||
// Rendering
|
||||
const probePass = ppl.addRenderPass(width, height, 'default');
|
||||
probePass.name = `PlanarReflectionProbe${probeID}`;
|
||||
this._buildReflectionProbePass(probePass, cameraConfigs, id, reflectionCamera,
|
||||
colorName, depthStencilName, mainLight, scene);
|
||||
this._buildReflectionProbePass(probePass, cameraConfigs, id, reflectionCamera, probe,
|
||||
colorName, depthStencilName, mainLight);
|
||||
} else if (EDITOR) {
|
||||
for (let faceIdx = 0; faceIdx < probe.bakedCubeTextures.length; faceIdx++) {
|
||||
probe.updateCameraDir(faceIdx);
|
||||
@@ -686,8 +686,8 @@ export class BuiltinForwardPassBuilder implements rendering.PipelinePassBuilder
|
||||
// Rendering
|
||||
const probePass = ppl.addRenderPass(width, height, 'default');
|
||||
probePass.name = `CubeProbe${probeID}${faceIdx}`;
|
||||
this._buildReflectionProbePass(probePass, cameraConfigs, id, probe.camera,
|
||||
colorName, depthStencilName, mainLight, scene);
|
||||
this._buildReflectionProbePass(probePass, cameraConfigs, id, probe.camera, probe,
|
||||
colorName, depthStencilName, mainLight);
|
||||
}
|
||||
probe.needRender = false;
|
||||
}
|
||||
@@ -702,10 +702,10 @@ export class BuiltinForwardPassBuilder implements rendering.PipelinePassBuilder
|
||||
cameraConfigs: Readonly<CameraConfigs & ForwardPassConfigs>,
|
||||
id: number,
|
||||
camera: renderer.scene.Camera,
|
||||
probe: renderer.scene.ReflectionProbe,
|
||||
colorName: string,
|
||||
depthStencilName: string,
|
||||
mainLight: renderer.scene.DirectionalLight | null,
|
||||
scene: renderer.RenderScene | null = null,
|
||||
): void {
|
||||
const QueueHint = rendering.QueueHint;
|
||||
const SceneFlags = rendering.SceneFlags;
|
||||
@@ -749,11 +749,11 @@ export class BuiltinForwardPassBuilder implements rendering.PipelinePassBuilder
|
||||
// TODO(zhouzhenglong): Separate OPAQUE and MASK queue
|
||||
|
||||
// add opaque and mask queue
|
||||
const lightInfo = new rendering.LightInfo(mainLight || null, 0, false, probe);
|
||||
pass.addQueue(QueueHint.NONE, 'reflect-map') // Currently we put OPAQUE and MASK into one queue, so QueueHint is NONE
|
||||
.addScene(camera,
|
||||
SceneFlags.OPAQUE | SceneFlags.MASK | SceneFlags.REFLECTION_PROBE,
|
||||
mainLight || undefined,
|
||||
scene ? scene : undefined);
|
||||
.addSceneOfCamera(camera,
|
||||
lightInfo,
|
||||
SceneFlags.OPAQUE | SceneFlags.MASK | SceneFlags.REFLECTION_PROBE);
|
||||
}
|
||||
private _addForwardRadiancePasses(
|
||||
ppl: rendering.BasicPipeline,
|
||||
|
||||
@@ -623,7 +623,7 @@ ccstd::unordered_map<uint32_t, ccstd::string> debugInfos = {
|
||||
{ 16417, "'clearTrack' interface can not be invoked in cached mode." },
|
||||
{ 16418, "Debug bones or slots is invalid in cached mode." },
|
||||
{ 16419, "Spine version not supported." },
|
||||
{ 16420, "Start time must bigger than end time." },
|
||||
{ 16420, "End time must bigger than start time." },
|
||||
|
||||
};
|
||||
}//namespace cc
|
||||
|
||||
@@ -99,8 +99,8 @@ CCWGPUDevice::CCWGPUDevice() : Device() {
|
||||
|
||||
_caps.maxComputeSharedMemorySize = 32768;
|
||||
_caps.maxComputeWorkGroupInvocations = 256;
|
||||
_caps.maxComputeWorkGroupSize = {65535, 65535, 65535};
|
||||
_caps.maxComputeWorkGroupCount = {256, 256, 64};
|
||||
_caps.maxComputeWorkGroupSize = {256, 256, 64};
|
||||
_caps.maxComputeWorkGroupCount = {65535, 65535, 65535};
|
||||
|
||||
instance = this;
|
||||
}
|
||||
@@ -582,8 +582,8 @@ void CCWGPUDevice::initLimits() {
|
||||
|
||||
_caps.maxComputeSharedMemorySize = limits.maxComputeWorkgroupStorageSize;
|
||||
_caps.maxComputeWorkGroupInvocations = limits.maxComputeInvocationsPerWorkgroup;
|
||||
_caps.maxComputeWorkGroupSize = {limits.maxComputeWorkgroupsPerDimension, limits.maxComputeWorkgroupsPerDimension, limits.maxComputeWorkgroupsPerDimension};
|
||||
_caps.maxComputeWorkGroupCount = {limits.maxComputeWorkgroupSizeX, limits.maxComputeWorkgroupSizeY, limits.maxComputeWorkgroupSizeZ};
|
||||
_caps.maxComputeWorkGroupSize = {limits.maxComputeWorkgroupSizeX, limits.maxComputeWorkgroupSizeY, limits.maxComputeWorkgroupSizeZ};
|
||||
_caps.maxComputeWorkGroupCount = {limits.maxComputeWorkgroupsPerDimension, limits.maxComputeWorkgroupsPerDimension, limits.maxComputeWorkgroupsPerDimension};
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
@@ -22,8 +22,11 @@
|
||||
THE SOFTWARE.
|
||||
****************************************************************************/
|
||||
|
||||
#include "InstancedBuffer.h"
|
||||
#include <algorithm>
|
||||
|
||||
#include "Define.h"
|
||||
#include "InstancedBuffer.h"
|
||||
#include "base/StringUtil.h"
|
||||
#include "gfx-base/GFXBuffer.h"
|
||||
#include "gfx-base/GFXCommandBuffer.h"
|
||||
#include "gfx-base/GFXDescriptorSet.h"
|
||||
@@ -49,6 +52,7 @@ void InstancedBuffer::destroy() {
|
||||
CC_FREE(instance.data);
|
||||
}
|
||||
_instances.clear();
|
||||
_instancesMap.clear();
|
||||
}
|
||||
|
||||
void InstancedBuffer::merge(scene::SubModel *subModel, uint32_t passIdx) {
|
||||
@@ -66,9 +70,9 @@ void InstancedBuffer::merge(scene::SubModel *subModel, uint32_t passIdx, gfx::Sh
|
||||
auto *lightingMap = descriptorSet->getTexture(LIGHTMAPTEXTURE::BINDING);
|
||||
auto *reflectionProbeCubemap = descriptorSet->getTexture(REFLECTIONPROBECUBEMAP::BINDING);
|
||||
auto *reflectionProbePlanarMap = descriptorSet->getTexture(REFLECTIONPROBEPLANARMAP::BINDING);
|
||||
gfx::Texture *reflectionProbeBlendCubemap = ENABLE_PROBE_BLEND
|
||||
? descriptorSet->getTexture(REFLECTIONPROBEBLENDCUBEMAP::BINDING)
|
||||
: nullptr;
|
||||
auto *reflectionProbeBlendCubemap = ENABLE_PROBE_BLEND
|
||||
? descriptorSet->getTexture(REFLECTIONPROBEBLENDCUBEMAP::BINDING)
|
||||
: nullptr;
|
||||
const uint32_t reflectionProbeType = subModel->getReflectionProbeType();
|
||||
auto *shader = shaderImplant;
|
||||
if (!shader) {
|
||||
@@ -81,65 +85,91 @@ void InstancedBuffer::merge(scene::SubModel *subModel, uint32_t passIdx, gfx::Sh
|
||||
_sortRender.hash = hash;
|
||||
_sortRender.shaderID = shaderId;
|
||||
_sortRender.passIndex = passIdx;
|
||||
for (auto &instance : _instances) {
|
||||
if (instance.ia->getIndexBuffer() != sourceIA->getIndexBuffer() || instance.drawInfo.instanceCount >= MAX_CAPACITY) {
|
||||
continue;
|
||||
const ccstd::string key = StringUtil::format("%u/%u/%u/%u/%u/%u/%u",
|
||||
sourceIA->getIndexBuffer() ? sourceIA->getIndexBuffer()->getObjectID() : 0,
|
||||
lightingMap ? lightingMap->getObjectID() : 0,
|
||||
reflectionProbeType,
|
||||
reflectionProbeCubemap ? reflectionProbeCubemap->getObjectID() : 0,
|
||||
reflectionProbePlanarMap ? reflectionProbePlanarMap->getObjectID() : 0,
|
||||
reflectionProbeBlendCubemap ? reflectionProbeBlendCubemap->getObjectID() : 0,
|
||||
stride);
|
||||
const auto iter = _instancesMap.find(key);
|
||||
if (iter != _instancesMap.end()) {
|
||||
for (size_t idx : iter->second) {
|
||||
auto &instance = _instances[idx];
|
||||
if (instance.drawInfo.instanceCount >= MAX_CAPACITY) {
|
||||
continue;
|
||||
}
|
||||
appendInstance(instance, attrs.buffer, shader, descriptorSet);
|
||||
return;
|
||||
}
|
||||
|
||||
// check same binding
|
||||
if (instance.lightingMap != lightingMap) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (instance.reflectionProbeType != reflectionProbeType) {
|
||||
continue;
|
||||
}
|
||||
if (instance.reflectionProbeCubemap != reflectionProbeCubemap) {
|
||||
continue;
|
||||
}
|
||||
if (instance.reflectionProbePlanarMap != reflectionProbePlanarMap) {
|
||||
continue;
|
||||
}
|
||||
if (instance.reflectionProbeBlendCubemap != reflectionProbeBlendCubemap) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (instance.stride != stride) {
|
||||
continue;
|
||||
}
|
||||
if (instance.drawInfo.instanceCount >= instance.capacity) { // resize buffers
|
||||
instance.capacity <<= 1;
|
||||
const auto newSize = instance.stride * instance.capacity;
|
||||
// NOLINTNEXTLINE(bugprone-suspicious-realloc-usage)
|
||||
instance.data = static_cast<uint8_t *>(CC_REALLOC(instance.data, newSize));
|
||||
instance.vb->resize(newSize);
|
||||
}
|
||||
if (instance.shader != shader) {
|
||||
instance.shader = shader;
|
||||
}
|
||||
if (instance.descriptorSet != descriptorSet) {
|
||||
instance.descriptorSet = descriptorSet;
|
||||
}
|
||||
memcpy(instance.data + static_cast<size_t>(instance.stride) * instance.drawInfo.instanceCount++, attrs.buffer.buffer()->getData(), stride);
|
||||
_hasPendingModels = true;
|
||||
return;
|
||||
}
|
||||
|
||||
// Create a new instance
|
||||
createInstance(
|
||||
key,
|
||||
sourceIA,
|
||||
attrs.attributes,
|
||||
attrs.buffer,
|
||||
stride,
|
||||
shader,
|
||||
descriptorSet,
|
||||
lightingMap,
|
||||
reflectionProbeType,
|
||||
reflectionProbeCubemap,
|
||||
reflectionProbePlanarMap,
|
||||
reflectionProbeBlendCubemap);
|
||||
}
|
||||
|
||||
void InstancedBuffer::appendInstance(InstancedItem &instance,
|
||||
Uint8Array &buffer,
|
||||
gfx::Shader *shader,
|
||||
gfx::DescriptorSet *descriptorSet) {
|
||||
if (instance.drawInfo.instanceCount >= instance.capacity) { // resize buffers
|
||||
instance.capacity = std::min(instance.capacity << 1, MAX_CAPACITY);
|
||||
const auto newSize = instance.stride * instance.capacity;
|
||||
// NOLINTNEXTLINE(bugprone-suspicious-realloc-usage)
|
||||
instance.data = static_cast<uint8_t *>(CC_REALLOC(instance.data, newSize));
|
||||
instance.vb->resize(newSize);
|
||||
}
|
||||
if (instance.shader != shader) {
|
||||
instance.shader = shader;
|
||||
}
|
||||
if (instance.descriptorSet != descriptorSet) {
|
||||
instance.descriptorSet = descriptorSet;
|
||||
}
|
||||
auto *destination = instance.data + static_cast<size_t>(instance.stride) * instance.drawInfo.instanceCount;
|
||||
CC_ASSERT(destination);
|
||||
memcpy(destination, buffer.buffer()->getData(), instance.stride);
|
||||
instance.drawInfo.instanceCount++;
|
||||
_hasPendingModels = true;
|
||||
}
|
||||
|
||||
void InstancedBuffer::createInstance(const ccstd::string &key,
|
||||
gfx::InputAssembler *sourceIA,
|
||||
const ccstd::vector<gfx::Attribute> &attributes,
|
||||
Uint8Array &buffer,
|
||||
uint32_t stride,
|
||||
gfx::Shader *shader,
|
||||
gfx::DescriptorSet *descriptorSet,
|
||||
gfx::Texture *lightingMap,
|
||||
uint32_t reflectionProbeType,
|
||||
gfx::Texture *reflectionProbeCubemap,
|
||||
gfx::Texture *reflectionProbePlanarMap,
|
||||
gfx::Texture *reflectionProbeBlendCubemap) {
|
||||
const auto newSize = stride * INITIAL_CAPACITY;
|
||||
auto *vb = _device->createBuffer({
|
||||
gfx::BufferUsageBit::VERTEX | gfx::BufferUsageBit::TRANSFER_DST,
|
||||
gfx::MemoryUsageBit::DEVICE,
|
||||
gfx::MemoryUsageBit::HOST | gfx::MemoryUsageBit::DEVICE,
|
||||
static_cast<uint32_t>(newSize),
|
||||
static_cast<uint32_t>(stride),
|
||||
});
|
||||
|
||||
auto *data = static_cast<uint8_t *>(CC_MALLOC(newSize));
|
||||
auto vertexBuffers = sourceIA->getVertexBuffers();
|
||||
auto attributes = sourceIA->getAttributes();
|
||||
auto iaAttributes = sourceIA->getAttributes();
|
||||
auto *indexBuffer = sourceIA->getIndexBuffer();
|
||||
|
||||
for (const auto &attribute : attrs.attributes) {
|
||||
attributes.emplace_back(gfx::Attribute{
|
||||
for (const auto &attribute : attributes) {
|
||||
iaAttributes.emplace_back(gfx::Attribute{
|
||||
attribute.name,
|
||||
attribute.format,
|
||||
attribute.isNormalized,
|
||||
@@ -147,17 +177,22 @@ void InstancedBuffer::merge(scene::SubModel *subModel, uint32_t passIdx, gfx::Sh
|
||||
true,
|
||||
attribute.location});
|
||||
}
|
||||
CC_ASSERT(data);
|
||||
memcpy(data, buffer.buffer()->getData(), stride);
|
||||
|
||||
auto *data = static_cast<uint8_t *>(CC_MALLOC(newSize));
|
||||
memcpy(data, attrs.buffer.buffer()->getData(), stride);
|
||||
vertexBuffers.emplace_back(vb);
|
||||
const gfx::InputAssemblerInfo iaInfo = {attributes, vertexBuffers, indexBuffer};
|
||||
const gfx::InputAssemblerInfo iaInfo = {iaAttributes, vertexBuffers, indexBuffer};
|
||||
auto *ia = _device->createInputAssembler(iaInfo);
|
||||
InstancedItem item = {INITIAL_CAPACITY, vb, data, ia, stride, shader, descriptorSet,
|
||||
lightingMap, reflectionProbeCubemap, reflectionProbePlanarMap, reflectionProbeType, reflectionProbeBlendCubemap,
|
||||
lightingMap,
|
||||
reflectionProbeCubemap,
|
||||
reflectionProbePlanarMap,
|
||||
reflectionProbeType,
|
||||
reflectionProbeBlendCubemap,
|
||||
ia->getDrawInfo()};
|
||||
item.drawInfo.instanceCount = 1;
|
||||
_instances.emplace_back(item);
|
||||
_instancesMap[key].emplace_back(_instances.size() - 1);
|
||||
_hasPendingModels = true;
|
||||
}
|
||||
|
||||
@@ -165,7 +200,16 @@ void InstancedBuffer::uploadBuffers(gfx::CommandBuffer *cmdBuff) const {
|
||||
for (const auto &instance : _instances) {
|
||||
if (!instance.drawInfo.instanceCount) continue;
|
||||
|
||||
cmdBuff->updateBuffer(instance.vb, instance.data, instance.vb->getSize());
|
||||
// `instance.data` is only guaranteed to hold `instance.capacity * instance.stride` bytes.
|
||||
// If `instance.vb` was resized to a larger size than the CPU-side `instance.data`
|
||||
// buffer (e.g. due to a bug in the resize/append logic), copying `instance.vb->getSize()`
|
||||
// bytes from `instance.data` would read out of bounds and crash. Clamp to the smaller
|
||||
// of the two to avoid reading past the end of `instance.data`.
|
||||
const uint32_t dataCapacity = instance.capacity * instance.stride;
|
||||
const uint32_t validSize = instance.drawInfo.instanceCount * instance.stride;
|
||||
CC_ASSERT(validSize <= instance.vb->getSize());
|
||||
CC_ASSERT(validSize <= dataCapacity);
|
||||
cmdBuff->updateBuffer(instance.vb, instance.data, validSize);
|
||||
instance.ia->setInstanceCount(instance.drawInfo.instanceCount);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -78,14 +78,37 @@ public:
|
||||
inline const DynamicOffsetList &dynamicOffsets() const { return _dynamicOffsets; }
|
||||
|
||||
private:
|
||||
InstancedItemList _instances;
|
||||
RenderPass _sortRender;
|
||||
void appendInstance(InstancedItem &instance,
|
||||
Uint8Array &buffer,
|
||||
gfx::Shader *shader,
|
||||
gfx::DescriptorSet *descriptorSet);
|
||||
void createInstance(const ccstd::string &key,
|
||||
gfx::InputAssembler *sourceIA,
|
||||
const ccstd::vector<gfx::Attribute> &attributes,
|
||||
Uint8Array &buffer,
|
||||
uint32_t stride,
|
||||
gfx::Shader *shader,
|
||||
gfx::DescriptorSet *descriptorSet,
|
||||
gfx::Texture *lightingMap,
|
||||
uint32_t reflectionProbeType,
|
||||
gfx::Texture *reflectionProbeCubemap,
|
||||
gfx::Texture *reflectionProbePlanarMap,
|
||||
gfx::Texture *reflectionProbeBlendCubemap);
|
||||
|
||||
// weak reference
|
||||
const scene::Pass *_pass{nullptr};
|
||||
bool _hasPendingModels{false};
|
||||
DynamicOffsetList _dynamicOffsets;
|
||||
// weak reference
|
||||
gfx::Device *_device{nullptr};
|
||||
|
||||
bool _hasPendingModels{false};
|
||||
|
||||
RenderPass _sortRender;
|
||||
|
||||
InstancedItemList _instances;
|
||||
DynamicOffsetList _dynamicOffsets;
|
||||
// Maps a merge key to the indices (into `_instances`) of items sharing that key.
|
||||
// Storing indices (not copies or references) keeps this in sync with `_instances`
|
||||
// and remains valid across `_instances` reallocation, since indices don't dangle.
|
||||
ccstd::unordered_map<ccstd::string, ccstd::vector<size_t>> _instancesMap;
|
||||
};
|
||||
|
||||
} // namespace pipeline
|
||||
|
||||
@@ -44,7 +44,9 @@
|
||||
#include "details/GraphView.h"
|
||||
#include "details/GslUtils.h"
|
||||
#include "details/Range.h"
|
||||
|
||||
#if CC_USE_DEBUG_RENDERER
|
||||
#include "cocos/renderer/pipeline/helper/Utils.h"
|
||||
#endif
|
||||
#if CC_USE_GEOMETRY_RENDERER
|
||||
#include "cocos/renderer/pipeline/GeometryRenderer.h"
|
||||
#endif
|
||||
@@ -793,7 +795,13 @@ struct RenderGraphVisitor : boost::dfs_visitor<> {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
#if CC_USE_DEBUG_RENDERER
|
||||
if (blit.blitType == BlitType::DRAW_PROFILE) {
|
||||
auto* renderPass = ctx.currentPass;
|
||||
auto* cmdBuff = ctx.cmdBuff;
|
||||
renderDebugRenderer(renderPass, cmdBuff, ctx.ppl->getPipelineSceneData(), cc::pipeline::profilerCamera);
|
||||
}
|
||||
#endif
|
||||
tryBindPassDescriptorSet(vertID);
|
||||
tryBindQueueDescriptorSets(vertID);
|
||||
|
||||
|
||||
@@ -3,6 +3,6 @@
|
||||
"type": "github",
|
||||
"owner": "cocos",
|
||||
"name": "cocos-engine-external",
|
||||
"checkout": "v4.0.0-7"
|
||||
"checkout": "v4.0.0-9"
|
||||
}
|
||||
}
|
||||
Generated
+2
-2
@@ -1,12 +1,12 @@
|
||||
{
|
||||
"name": "cocos-creator",
|
||||
"version": "4.0.0-alpha.31",
|
||||
"version": "4.0.0-alpha.33",
|
||||
"lockfileVersion": 3,
|
||||
"requires": true,
|
||||
"packages": {
|
||||
"": {
|
||||
"name": "cocos-creator",
|
||||
"version": "4.0.0-alpha.31",
|
||||
"version": "4.0.0-alpha.33",
|
||||
"hasInstallScript": true,
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "cocos-creator",
|
||||
"version": "4.0.0-alpha.31",
|
||||
"version": "4.0.0-alpha.33",
|
||||
"description": "Cocos Creator is a cross-platform 2D & 3D game engine written in C++ and TypeScript, licensed under MIT.",
|
||||
"homepage": "http://www.cocos.com",
|
||||
"license": "MIT",
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
import { execSync, spawn } from 'child_process';
|
||||
import { execSync } from 'child_process';
|
||||
import * as fs from 'fs-extra';
|
||||
import * as ps from 'path';
|
||||
import * as os from 'os';
|
||||
import { CocosParams } from '../base/default';
|
||||
import { cchelper, toolHelper, Paths } from "../utils";
|
||||
import { cchelper, toolHelper } from "../utils";
|
||||
import { MacOSPackTool } from "./mac-os";
|
||||
|
||||
export interface IOrientation {
|
||||
@@ -115,13 +115,8 @@ export class IOSPackTool extends MacOSPackTool {
|
||||
throw new Error("Error: Try to build iphoneos application but no developer team id was given!");
|
||||
}
|
||||
const nativePrjDir = this.paths.nativePrjDir;
|
||||
|
||||
const simulatorArch = this.getIosSimulatorArch();
|
||||
const projName = this.params.projectName;
|
||||
const os = require('os');
|
||||
const cpus = os.cpus();
|
||||
const model = (cpus && cpus[0] && cpus[0].model) ? cpus[0].model : '';
|
||||
// check mac architecture
|
||||
// const platform = /Apple/.test(model) ? `-arch arm64` : `-arch x86_64`;
|
||||
// get xcode workspace
|
||||
const regex = new RegExp(projName + '.xcworkspace$');
|
||||
const files = fs.readdirSync(nativePrjDir);
|
||||
@@ -145,7 +140,7 @@ export class IOSPackTool extends MacOSPackTool {
|
||||
await toolHelper.runCmake([projCompileParams, '-sdk', 'iphoneos', `-arch arm64`]);
|
||||
}
|
||||
if (options.simulator) {
|
||||
await toolHelper.runCmake([projCompileParams, '-sdk', 'iphonesimulator', `-arch x86_64`]); //force compile x86_64 app for iPhone simulator on Mac
|
||||
await toolHelper.runCmake([projCompileParams, '-sdk', 'iphonesimulator', `-arch ${simulatorArch}`]);
|
||||
}
|
||||
}
|
||||
return true;
|
||||
|
||||
@@ -51,10 +51,36 @@ export abstract class MacOSPackTool extends NativePackTool {
|
||||
return /Apple/.test(model) && process.platform === 'darwin';
|
||||
}
|
||||
|
||||
protected getXcodeMajorVerion(): number {
|
||||
protected compareVersion(a: string, b: string): number {
|
||||
const aParts = a.split('.').map((part) => Number.parseInt(part, 10) || 0);
|
||||
const bParts = b.split('.').map((part) => Number.parseInt(part, 10) || 0);
|
||||
const maxLength = Math.max(aParts.length, bParts.length);
|
||||
|
||||
for (let i = 0; i < maxLength; i++) {
|
||||
const aValue = aParts[i] ?? 0;
|
||||
const bValue = bParts[i] ?? 0;
|
||||
if (aValue !== bValue) {
|
||||
return aValue - bValue;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
protected getXcodeVersion(): string {
|
||||
try {
|
||||
const output = execSync('xcrun xcodebuild -version').toString('utf8');
|
||||
return Number.parseInt(output.match(/Xcode\s(\d+)\.\d+/)![1]);
|
||||
const match = output.match(/Xcode\s+(\d+(?:\.\d+)+)/);
|
||||
return match?.[1] || '0.0';
|
||||
} catch (e) {
|
||||
console.error(e);
|
||||
return '0.0';
|
||||
}
|
||||
}
|
||||
|
||||
protected getXcodeMajorVerion(): number {
|
||||
try {
|
||||
return Number.parseInt(this.getXcodeVersion().split('.')[0] || '0', 10);
|
||||
} catch (e) {
|
||||
console.error(e);
|
||||
// fallback to default Xcode version
|
||||
@@ -62,6 +88,14 @@ export abstract class MacOSPackTool extends NativePackTool {
|
||||
}
|
||||
}
|
||||
|
||||
protected getIosSimulatorArch(): 'arm64' | 'x86_64' {
|
||||
// Xcode 14.3+ no longer supports running iOS Simulator under Rosetta on Apple Silicon.
|
||||
if (this.isAppleSilicon() && this.compareVersion(this.getXcodeVersion(), '14.3') >= 0) {
|
||||
return 'arm64';
|
||||
}
|
||||
return 'x86_64';
|
||||
}
|
||||
|
||||
async modifyXcodeProject() {
|
||||
if (this.params.platformParams.skipUpdateXcodeProject) {
|
||||
if (this.getXcodeMajorVerion() < 12) {
|
||||
|
||||
@@ -6,7 +6,7 @@ endif()
|
||||
|
||||
if(POLICY CMP0111)
|
||||
# https://cmake.org/cmake/help/latest/policy/CMP0111.html
|
||||
cmake_policy(SET CMP0111 OLD)
|
||||
cmake_policy(SET CMP0111 NEW)
|
||||
endif()
|
||||
|
||||
# set(CC_REGISTERED_PLUGINS)
|
||||
|
||||
@@ -49,8 +49,9 @@ endmacro()
|
||||
|
||||
|
||||
macro(cc_windows_after_target _target_name)
|
||||
|
||||
source_group(TREE ${RES_DIR}/data PREFIX "Resources" FILES ${CC_ASSET_FILES})
|
||||
|
||||
get_filename_component(CC_ASSET_ROOT "${RES_DIR}/data" ABSOLUTE)
|
||||
source_group(TREE ${CC_ASSET_ROOT} PREFIX "Resources" FILES ${CC_ASSET_FILES})
|
||||
source_group(TREE ${CC_PROJECT_DIR} PREFIX "Source Files" FILES ${CC_PROJ_SOURCES})
|
||||
source_group(TREE ${CC_PROJECT_DIR}/../common PREFIX "Source Files" FILES ${CC_COMMON_SOURCES})
|
||||
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
cmake_minimum_required(VERSION 3.8)
|
||||
cmake_minimum_required(VERSION 3.28)
|
||||
|
||||
set(CMAKE_SYSTEM_NAME iOS)
|
||||
set(APP_NAME "CocosGame" CACHE STRING "Project Name")
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
cmake_minimum_required(VERSION 3.8)
|
||||
cmake_minimum_required(VERSION 3.28)
|
||||
|
||||
set(APP_NAME "CocosGame" CACHE STRING "Project Name")
|
||||
option(ENABLE_SANDBOX "enable sandbox entitlements.plist" ON)
|
||||
|
||||
@@ -1,27 +1,45 @@
|
||||
import { Texture2D } from "../../cocos/asset/assets/texture-2d";
|
||||
import { Details } from "../../cocos/serialization/deserialize";
|
||||
import { ImageAsset } from '../../cocos/asset/assets/image-asset';
|
||||
import { Texture2D } from '../../cocos/asset/assets/texture-2d';
|
||||
import { dependMap } from '../../cocos/asset/asset-manager/depend-maps';
|
||||
import dependUtil from '../../cocos/asset/asset-manager/depend-util';
|
||||
import { setProperties } from '../../cocos/asset/asset-manager/utilities';
|
||||
import { macro } from '../../cocos/core';
|
||||
|
||||
// issue: https://github.com/cocos/cocos-engine/issues/16693
|
||||
test('Texture2D serialize', function () {
|
||||
const texture = new Texture2D();
|
||||
texture._mipmaps = [{ _uuid: '09f4f3e7-268b-478c-a7af-bbdf574ec3c6@6c48a' }];
|
||||
const ctxForExporting = {
|
||||
_depends: [] as string[],
|
||||
dependsOn(propName: string, uuid: string) {
|
||||
this._depends.push(propName, uuid);
|
||||
},
|
||||
_compressUuid: this.mustCompresseUuid,
|
||||
};
|
||||
texture._serialize(ctxForExporting);
|
||||
expect(ctxForExporting._depends).toEqual(['_textureSource', '09f4f3e7-268b-478c-a7af-bbdf574ec3c6@6c48a']);
|
||||
const textureUuid = 'f41e5c8f-0e9a-4c38-bb1d-texture2d';
|
||||
|
||||
afterEach(() => {
|
||||
dependUtil.remove(textureUuid);
|
||||
});
|
||||
|
||||
test('Texture2D deserialize', function () {
|
||||
const data = { base: '2,2,2,2,0,0', mipmaps: ['09f4f3e7-268b-478c-a7af-bbdf574ec3c6'] };
|
||||
const result = new Details();
|
||||
result.init();
|
||||
const handle = { result };
|
||||
const texture = new Texture2D();
|
||||
texture._deserialize(data, handle);
|
||||
expect(handle.result.uuidList).toEqual(['09f4f3e7-268b-478c-a7af-bbdf574ec3c6']);
|
||||
});
|
||||
test('releases every Texture2D dependency edge for an uploaded image', () => {
|
||||
const cleanupImageCache = macro.CLEANUP_IMAGE_CACHE;
|
||||
macro.CLEANUP_IMAGE_CACHE = true;
|
||||
|
||||
try {
|
||||
const texture = new Texture2D();
|
||||
texture._uuid = textureUuid;
|
||||
const image = new ImageAsset({
|
||||
_data: new Uint8Array(4),
|
||||
width: 1,
|
||||
height: 1,
|
||||
});
|
||||
image._uuid = '6d35c119-b763-4295-96e7-image';
|
||||
const deps = [
|
||||
{ uuid: image._uuid, owner: texture, prop: '_textureSource' },
|
||||
{ uuid: image._uuid, owner: texture._mipmaps, prop: '0' },
|
||||
];
|
||||
const assetsMap = { [`${image._uuid}@import`]: image };
|
||||
|
||||
dependMap.set(texture, deps);
|
||||
dependUtil._depends.add(textureUuid, { deps: deps.map((dep) => dep.uuid) });
|
||||
setProperties(textureUuid, texture, assetsMap);
|
||||
expect(image.refCount).toBe(2);
|
||||
|
||||
texture.onLoaded();
|
||||
|
||||
expect(image.refCount).toBe(0);
|
||||
expect(dependUtil.getDeps(textureUuid)).toEqual([]);
|
||||
} finally {
|
||||
macro.CLEANUP_IMAGE_CACHE = cleanupImageCache;
|
||||
}
|
||||
});
|
||||
|
||||
Reference in New Issue
Block a user