mirror of
https://github.com/cocos/cocos4.git
synced 2026-11-20 15:42:39 +08:00
Compare commits
60 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| fffd9a514a | |||
| 5678d0d17c | |||
| 2ce7b89be5 | |||
| 6b455561f4 | |||
| 60f9352c56 | |||
| f66365f959 | |||
| a3c3fcbea5 | |||
| 2a75cfb9da | |||
| 0c3f4534b8 | |||
| 7f806abad6 | |||
| df98a99bb6 | |||
| a5090e5ae4 | |||
| 3b71bf6935 | |||
| 54fd070848 | |||
| 6722aac669 | |||
| 68552314c0 | |||
| 550eb15641 | |||
| c438c2d3f8 | |||
| f5eaf97ce7 | |||
| 69d3d6033a | |||
| 469614cf0b | |||
| f81094f226 | |||
| 825362fac1 | |||
| 609512f8da | |||
| 09b63786f4 | |||
| 2b7b438768 | |||
| 6b5c8556a2 | |||
| ff436d6a27 | |||
| 09c38ea03f | |||
| 926bd5b619 | |||
| e317c04512 | |||
| 140068ddb1 | |||
| 80a9d0619e | |||
| a01046e391 | |||
| 2b6ec3b4f0 | |||
| 6060f58d1a | |||
| 18456b6706 | |||
| 62b55a0c48 | |||
| 0eac18be1a | |||
| 01983b75f2 | |||
| 2d003cc616 | |||
| b710cb6e9b | |||
| f948b5900e | |||
| b7883f18ba | |||
| 3ab299035a | |||
| c2ab919e9d | |||
| 5690d1b8a5 | |||
| ed0751652b | |||
| 97e402c3dc | |||
| f378a866cb | |||
| 7253ee4a7f | |||
| db5462603e | |||
| 9f0e30acb3 | |||
| a0a2e97c00 | |||
| 90e551b4a1 | |||
| 0a21bb9397 | |||
| 2c91155928 | |||
| 6f90cec3d4 | |||
| d5f24e6170 | |||
| e778833d15 |
@@ -20,8 +20,14 @@ if ($env:GITHUB_BASE_REF) {
|
||||
# Push
|
||||
$gitHubEvent = Get-Content $env:GITHUB_EVENT_PATH | ConvertFrom-Json
|
||||
Write-Host "GitHub event: $gitHubEvent"
|
||||
git fetch origin $gitHubEvent.before --depth=1
|
||||
$diffFiles = git diff --name-only --diff-filter=$diffFilter $gitHubEvent.before $env:GITHUB_SHA
|
||||
$beforeSha = $gitHubEvent.before
|
||||
# On tag creation or initial push, before is all zeros - skip diff in that case
|
||||
if ($beforeSha -match '^0+$') {
|
||||
Write-Host "No previous commit (tag creation or initial push). Skipping diff."
|
||||
return
|
||||
}
|
||||
git fetch origin $beforeSha --depth=1
|
||||
$diffFiles = git diff --name-only --diff-filter=$diffFilter $beforeSha $env:GITHUB_SHA
|
||||
}
|
||||
|
||||
Write-Host "Diff files: $diffFiles"
|
||||
|
||||
@@ -18,6 +18,7 @@ jobs:
|
||||
with:
|
||||
token: ${{ github.token }}
|
||||
ref: ${{ github.head_sha }}
|
||||
fetch-depth: 0
|
||||
|
||||
- id: get_change_files
|
||||
uses: fish9167/file-changes-action@v1.2.3
|
||||
@@ -25,18 +26,13 @@ jobs:
|
||||
output: ' '
|
||||
fileOutput: ' '
|
||||
|
||||
- name: Echo change files
|
||||
run: |
|
||||
cat $HOME/files.txt
|
||||
mv $HOME/files.txt ${{github.workspace}}/files.txt
|
||||
|
||||
- uses: fish9167/clang-format-lint-action@master
|
||||
- uses: DoozyX/clang-format-lint-action@v0.18
|
||||
with:
|
||||
source: ./native
|
||||
exclude: ./native/cocos/bindings/auto
|
||||
exclude: ./native/cocos/bindings/auto ./native/cocos/base/std ./native/cocos/editor-support/spine-wasm ./native/cocos/editor-support/spine ./native/cocos/gi/light-probe/predicates.cpp ./native/cocos/gi/light-probe/tetgen.cpp ./native/cocos/gi/light-probe/tetgen.h ./native/cocos/platform/openharmony/napi ./native/tools ./native/vendor ./native/cocos/cocos-version.h
|
||||
extensions: 'c,h,hpp,cpp,cxx'
|
||||
style: file
|
||||
inplace: True
|
||||
inplace: true
|
||||
clangFormatVersion: 12
|
||||
|
||||
- name: Create Pull Request
|
||||
|
||||
@@ -28,6 +28,7 @@ jobs:
|
||||
with:
|
||||
node-version: ${{ matrix.node-version }}
|
||||
- run: npm ci --ignore-scripts
|
||||
- run: node scripts/spread-pal.cjs
|
||||
- run: npm run build:debug-infos
|
||||
- name: Download external
|
||||
run: |
|
||||
|
||||
@@ -46,3 +46,11 @@ platforms/runtime/platforms/vivo-mini-game/ral.min.js
|
||||
@types/consts.d.ts
|
||||
|
||||
__TS_ENGINE__/
|
||||
|
||||
# pal 由 @cocos/engine-pal 在 postinstall 挂载(软链/复制),不入库
|
||||
/pal
|
||||
|
||||
# platforms 源码已抽到 @cocos/engine-platforms;其预打包 adapter 由 postinstall 的
|
||||
# spread-adapter.cjs 复制到 bin/adapter(/bin 已忽略)。platforms 源码不再入库。
|
||||
/platforms
|
||||
|
||||
|
||||
+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.
|
||||
|
||||
+44
-44
@@ -382,70 +382,70 @@
|
||||
"test": "context.buildTimeConstants && context.buildTimeConstants.HTML5",
|
||||
"isVirtualModule": true,
|
||||
"overrides": {
|
||||
"pal/minigame": "pal/minigame/non-minigame.ts",
|
||||
"pal/audio": "pal/audio/web/player.ts",
|
||||
"pal/system-info": "pal/system-info/web/system-info.ts",
|
||||
"pal/screen-adapter": "pal/screen-adapter/web/screen-adapter.ts",
|
||||
"pal/input": "pal/input/web/index.ts",
|
||||
"pal/env": "pal/env/web/env.ts",
|
||||
"pal/pacer": "pal/pacer/pacer-web.ts",
|
||||
"pal/wasm": "pal/wasm/wasm-web.ts"
|
||||
"pal/minigame": "pal/minigame/non-minigame.js",
|
||||
"pal/audio": "pal/audio/web/player.js",
|
||||
"pal/system-info": "pal/system-info/web/system-info.js",
|
||||
"pal/screen-adapter": "pal/screen-adapter/web/screen-adapter.js",
|
||||
"pal/input": "pal/input/web/index.js",
|
||||
"pal/env": "pal/env/web/env.js",
|
||||
"pal/pacer": "pal/pacer/pacer-web.js",
|
||||
"pal/wasm": "pal/wasm/wasm-web.js"
|
||||
}
|
||||
},
|
||||
{
|
||||
"test": "context.buildTimeConstants && context.buildTimeConstants.NATIVE",
|
||||
"isVirtualModule": true,
|
||||
"overrides": {
|
||||
"pal/minigame": "pal/minigame/non-minigame.ts",
|
||||
"pal/audio": "pal/audio/native/player.ts",
|
||||
"pal/system-info": "pal/system-info/native/system-info.ts",
|
||||
"pal/screen-adapter": "pal/screen-adapter/native/screen-adapter.ts",
|
||||
"pal/input": "pal/input/native/index.ts",
|
||||
"pal/env": "pal/env/native/env.ts",
|
||||
"pal/pacer": "pal/pacer/pacer-native.ts",
|
||||
"pal/wasm": "pal/wasm/wasm-native.ts"
|
||||
"pal/minigame": "pal/minigame/non-minigame.js",
|
||||
"pal/audio": "pal/audio/native/player.js",
|
||||
"pal/system-info": "pal/system-info/native/system-info.js",
|
||||
"pal/screen-adapter": "pal/screen-adapter/native/screen-adapter.js",
|
||||
"pal/input": "pal/input/native/index.js",
|
||||
"pal/env": "pal/env/native/env.js",
|
||||
"pal/pacer": "pal/pacer/pacer-native.js",
|
||||
"pal/wasm": "pal/wasm/wasm-native.js"
|
||||
}
|
||||
},
|
||||
{
|
||||
"test": "context.buildTimeConstants && context.buildTimeConstants.MINIGAME",
|
||||
"isVirtualModule": true,
|
||||
"overrides": {
|
||||
"pal/minigame": "pal/minigame/{{context.platform.toLowerCase()}}.ts",
|
||||
"pal/audio": "pal/audio/minigame/player.ts",
|
||||
"pal/system-info": "pal/system-info/minigame/system-info.ts",
|
||||
"pal/screen-adapter": "pal/screen-adapter/minigame/screen-adapter.ts",
|
||||
"pal/input": "pal/input/minigame/index.ts",
|
||||
"pal/env": "pal/env/minigame/env.ts",
|
||||
"pal/pacer": "pal/pacer/pacer-minigame.ts",
|
||||
"pal/wasm": "pal/wasm/wasm-minigame.ts"
|
||||
"pal/minigame": "pal/minigame/{{context.platform.toLowerCase()}}.js",
|
||||
"pal/audio": "pal/audio/minigame/player.js",
|
||||
"pal/system-info": "pal/system-info/minigame/system-info.js",
|
||||
"pal/screen-adapter": "pal/screen-adapter/minigame/screen-adapter.js",
|
||||
"pal/input": "pal/input/minigame/index.js",
|
||||
"pal/env": "pal/env/minigame/env.js",
|
||||
"pal/pacer": "pal/pacer/pacer-minigame.js",
|
||||
"pal/wasm": "pal/wasm/wasm-minigame.js"
|
||||
}
|
||||
},
|
||||
{
|
||||
"test": "context.buildTimeConstants && context.buildTimeConstants.RUNTIME_BASED",
|
||||
"isVirtualModule": true,
|
||||
"overrides": {
|
||||
"pal/minigame": "pal/minigame/runtime.ts",
|
||||
"pal/audio": "pal/audio/minigame/player.ts",
|
||||
"pal/system-info": "pal/system-info/minigame/system-info.ts",
|
||||
"pal/screen-adapter": "pal/screen-adapter/minigame/screen-adapter.ts",
|
||||
"pal/input": "pal/input/minigame/index.ts",
|
||||
"pal/env": "pal/env/runtime/env.ts",
|
||||
"pal/pacer": "pal/pacer/pacer-minigame.ts",
|
||||
"pal/wasm": "pal/wasm/wasm-minigame.ts"
|
||||
"pal/minigame": "pal/minigame/runtime.js",
|
||||
"pal/audio": "pal/audio/minigame/player.js",
|
||||
"pal/system-info": "pal/system-info/minigame/system-info.js",
|
||||
"pal/screen-adapter": "pal/screen-adapter/minigame/screen-adapter.js",
|
||||
"pal/input": "pal/input/minigame/index.js",
|
||||
"pal/env": "pal/env/runtime/env.js",
|
||||
"pal/pacer": "pal/pacer/pacer-minigame.js",
|
||||
"pal/wasm": "pal/wasm/wasm-minigame.js"
|
||||
}
|
||||
},
|
||||
{
|
||||
"test": "context.buildTimeConstants && context.buildTimeConstants.NODEJS",
|
||||
"isVirtualModule": true,
|
||||
"overrides": {
|
||||
"pal/minigame": "pal/minigame/non-minigame.ts",
|
||||
"pal/audio": "pal/audio/nodejs/player.ts",
|
||||
"pal/system-info": "pal/system-info/nodejs/system-info.ts",
|
||||
"pal/screen-adapter": "pal/screen-adapter/nodejs/screen-adapter.ts",
|
||||
"pal/input": "pal/input/nodejs/index.ts",
|
||||
"pal/env": "pal/env/nodejs/env.ts",
|
||||
"pal/pacer": "pal/pacer/pacer-nodejs.ts",
|
||||
"pal/wasm": "pal/wasm/wasm-nodejs.ts"
|
||||
"pal/minigame": "pal/minigame/non-minigame.js",
|
||||
"pal/audio": "pal/audio/nodejs/player.js",
|
||||
"pal/system-info": "pal/system-info/nodejs/system-info.js",
|
||||
"pal/screen-adapter": "pal/screen-adapter/nodejs/screen-adapter.js",
|
||||
"pal/input": "pal/input/nodejs/index.js",
|
||||
"pal/env": "pal/env/nodejs/env.js",
|
||||
"pal/pacer": "pal/pacer/pacer-nodejs.js",
|
||||
"pal/wasm": "pal/wasm/wasm-nodejs.js"
|
||||
}
|
||||
},
|
||||
{
|
||||
@@ -885,10 +885,10 @@
|
||||
"cocos/asset/asset-manager/weak-cache.ts",
|
||||
"cocos/2d/framework/ui-skew-utils.ts",
|
||||
"cocos/spine/lib/spine-binary.ts",
|
||||
"pal/input/minigame/gamepad-input.ts",
|
||||
"pal/input/minigame/handheld-input.ts",
|
||||
"pal/input/minigame/handle-input.ts",
|
||||
"pal/input/minigame/hmd-input.ts"
|
||||
"pal/input/minigame/gamepad-input.js",
|
||||
"pal/input/minigame/handheld-input.js",
|
||||
"pal/input/minigame/handle-input.js",
|
||||
"pal/input/minigame/hmd-input.js"
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
@@ -172,13 +172,18 @@ export function createMesh (geometry: IGeometry, out?: Mesh, options?: ICreateMe
|
||||
// Fill index buffer.
|
||||
let indexBuffer: ArrayBuffer | null = null;
|
||||
let idxCount = 0;
|
||||
const idxStride = 2;
|
||||
let idxStride = 2;
|
||||
let indexFormat = Format.R16UI;
|
||||
if (geometry.indices) {
|
||||
const { indices } = geometry;
|
||||
idxCount = indices.length;
|
||||
if (indices.some((i) => i > 0xFFFF)) {
|
||||
idxStride = 4;
|
||||
indexFormat = Format.R32UI;
|
||||
}
|
||||
indexBuffer = new ArrayBuffer(idxStride * idxCount);
|
||||
const indexBufferView = new DataView(indexBuffer);
|
||||
writeBuffer(indexBufferView, indices, Format.R16UI);
|
||||
writeBuffer(indexBufferView, indices, indexFormat);
|
||||
}
|
||||
|
||||
// Create primitive.
|
||||
|
||||
@@ -384,10 +384,10 @@ export class ReflectionProbe extends Component {
|
||||
}
|
||||
}
|
||||
}
|
||||
if (this.probeType === ProbeType.PLANAR && this.sourceCamera) {
|
||||
if (!EDITOR_NOT_IN_PREVIEW && this.probeType === ProbeType.PLANAR && this.sourceCamera) {
|
||||
if ((this.sourceCamera.node.hasChangedFlags & TransformBit.TRS)
|
||||
|| !this._sourceCameraPos.equals(this.sourceCamera.node.getWorldPosition())) {
|
||||
this._sourceCameraPos = this.sourceCamera.node.getWorldPosition();
|
||||
this._sourceCameraPos.set(this.sourceCamera.node.getWorldPosition());
|
||||
this.probe.renderPlanarReflection(this.sourceCamera.camera);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -69,6 +69,58 @@ export function approx (a: number, b: number, maxDiff?: number): boolean {
|
||||
return mathAbs(a - b) <= maxDiff;
|
||||
}
|
||||
|
||||
/**
|
||||
* @en Tests whether or not the first argument is approximately greater than or equal to the second
|
||||
* @zh 测试第一个参数是否近似大于或等于第二个参数
|
||||
* @param a The first number to test
|
||||
* @param b The second number to test
|
||||
* @param maxDiff Maximum difference (default: EPSILON)
|
||||
* @return True if a is approximately greater than or equal to b, false otherwise
|
||||
*/
|
||||
export function approxGE (a: number, b: number, maxDiff?: number): boolean {
|
||||
maxDiff = maxDiff || EPSILON;
|
||||
return a >= b - maxDiff;
|
||||
}
|
||||
|
||||
/**
|
||||
* @en Tests whether or not the first argument is approximately less than or equal to the second
|
||||
* @zh 测试第一个参数是否近似小于或等于第二个参数
|
||||
* @param a The first number to test
|
||||
* @param b The second number to test
|
||||
* @param maxDiff Maximum difference (default: EPSILON)
|
||||
* @return True if a is approximately less than or equal to b, false otherwise
|
||||
*/
|
||||
export function approxLE (a: number, b: number, maxDiff?: number): boolean {
|
||||
maxDiff = maxDiff || EPSILON;
|
||||
return a <= b + maxDiff;
|
||||
}
|
||||
|
||||
/**
|
||||
* @en Tests whether or not the first argument is approximately greater than the second
|
||||
* @zh 测试第一个参数是否近似大于第二个参数
|
||||
* @param a The first number to test
|
||||
* @param b The second number to test
|
||||
* @param maxDiff Maximum difference (default: EPSILON)
|
||||
* @return True if a is approximately greater than b, false otherwise
|
||||
*/
|
||||
export function approxGT (a: number, b: number, maxDiff?: number): boolean {
|
||||
maxDiff = maxDiff || EPSILON;
|
||||
return a > b + maxDiff;
|
||||
}
|
||||
|
||||
/**
|
||||
* @en Tests whether or not the first argument is approximately less than the second
|
||||
* @zh 测试第一个参数是否近似小于第二个参数
|
||||
* @param a The first number to test
|
||||
* @param b The second number to test
|
||||
* @param maxDiff Maximum difference (default: EPSILON)
|
||||
* @return True if a is approximately less than b, false otherwise
|
||||
*/
|
||||
export function approxLT (a: number, b: number, maxDiff?: number): boolean {
|
||||
maxDiff = maxDiff || EPSILON;
|
||||
return a < b - maxDiff;
|
||||
}
|
||||
|
||||
/**
|
||||
* @en Clamps a value between a minimum float and maximum float value.<br/>
|
||||
* @zh 返回最小浮点数和最大浮点数之间的一个数值。可以使用 clamp 函数将不断变化的数值限制在范围内。
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -23,7 +23,7 @@
|
||||
*/
|
||||
|
||||
import { ccclass, type, serializable, editable, range } from 'cc.decorator';
|
||||
import { repeat } from '../core/math';
|
||||
import { approxGE, approxLT, repeat } from '../core/math';
|
||||
import CurveRange from './animator/curve-range';
|
||||
import type { ParticleSystem } from './particle-system';
|
||||
|
||||
@@ -108,7 +108,7 @@ export default class Burst {
|
||||
let preFrameTime = repeat(psys.time - psys.startDelay.evaluate(0, 1), psys.duration) - dt;
|
||||
preFrameTime = (preFrameTime > 0.0) ? preFrameTime : 0.0;
|
||||
const curFrameTime = repeat(psys.time - psys.startDelay.evaluate(0, 1), psys.duration);
|
||||
if (this._curTime >= preFrameTime && this._curTime < curFrameTime) {
|
||||
if (approxGE(this._curTime, preFrameTime) && approxLT(this._curTime, curFrameTime)) {
|
||||
psys.emit(this.count.evaluate(this._curTime / psys.duration, 1), dt - (curFrameTime - this._curTime));
|
||||
this._curTime += this.repeatInterval;
|
||||
--this._remainingCount;
|
||||
|
||||
+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);
|
||||
|
||||
+14
-4
@@ -29,7 +29,8 @@ import { Vec2, Vec3 } from '../core/math';
|
||||
* @zh 此类生成噪声纹理。
|
||||
*/
|
||||
export class ParticleNoise {
|
||||
private permutation: number[] = [151, 160, 137, 91, 90, 15,
|
||||
private static readonly DEFAULT_PERMUTATION: readonly number[] = [
|
||||
151, 160, 137, 91, 90, 15,
|
||||
131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23,
|
||||
190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33,
|
||||
88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71, 134, 139, 48, 27, 166,
|
||||
@@ -44,9 +45,19 @@ export class ParticleNoise {
|
||||
138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180,
|
||||
];
|
||||
|
||||
private static build512 (src: readonly number[] | number[]): Uint8Array {
|
||||
const p = new Uint8Array(512);
|
||||
for (let i = 0; i < 256; i++) { p[256 + i] = p[i] = src[i]; }
|
||||
return p;
|
||||
}
|
||||
|
||||
private permutation: number[] = ParticleNoise.DEFAULT_PERMUTATION as number[];
|
||||
private permutation512: Uint8Array = ParticleNoise.build512(ParticleNoise.DEFAULT_PERMUTATION);
|
||||
|
||||
constructor (permutation?: number[]) {
|
||||
if (permutation) {
|
||||
this.permutation = permutation;
|
||||
this.permutation = permutation.slice();
|
||||
this.permutation512 = ParticleNoise.build512(this.permutation);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -61,8 +72,7 @@ export class ParticleNoise {
|
||||
* @returns @en Texture pixel generated. @zh 返回生成的噪声纹理值。
|
||||
*/
|
||||
public noise (x: number, y: number, z: number, min = 0, max = 1): number {
|
||||
const p: number[] = new Array(512);
|
||||
for (let i = 0; i < 256; i++) { p[256 + i] = p[i] = this.permutation[i]; }
|
||||
const p: Uint8Array = this.permutation512;
|
||||
|
||||
const X = Math.floor(x) & 255; // FIND UNIT CUBE THAT
|
||||
const Y = Math.floor(y) & 255; // CONTAINS POINT.
|
||||
|
||||
@@ -747,6 +747,12 @@ export default class ParticleSystemRendererCPU extends ParticleSystemRendererBas
|
||||
this._defines[ROTATION_OVER_TIME_MODULE_ENABLE] = enable;
|
||||
this._defines[INSTANCE_PARTICLE] = this._useInstance;
|
||||
|
||||
const matIns: MaterialInstance | null = ps.getMaterialInstance(0);
|
||||
if (matIns === null || matIns === undefined) {
|
||||
ps.setSharedMaterial(mat.parent, 0); // set material[0] as material for ui-mesh-renderer to use
|
||||
ps.setMaterialInstance(mat, 0);
|
||||
}
|
||||
|
||||
mat.recompileShaders(this._defines);
|
||||
if (this._model) {
|
||||
this._model.updateMaterial(mat);
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -31,7 +31,7 @@ import { murmurhash2_32_gc, errorID, assertID, cclegacy, warnID } from '../../co
|
||||
import {
|
||||
BufferUsageBit, DynamicStateFlagBit, DynamicStateFlags, Feature, GetTypeSize, MemoryUsageBit, PrimitiveMode, Type, Color,
|
||||
BlendState, BlendTarget, Buffer, BufferInfo, BufferViewInfo, DepthStencilState, DescriptorSet,
|
||||
DescriptorSetInfo, DescriptorSetLayout, Device, RasterizerState, Sampler, Texture, Shader, PipelineLayout, deviceManager, UniformBlock,
|
||||
DescriptorSetInfo, DescriptorSetLayout, Device, RasterizerState, Sampler, SampleCount, Texture, Shader, PipelineLayout, deviceManager, UniformBlock,
|
||||
} from '../../gfx';
|
||||
import { EffectAsset } from '../../asset/assets/effect-asset';
|
||||
import { IProgramInfo, programLib } from './program-lib';
|
||||
@@ -139,6 +139,28 @@ export class Pass {
|
||||
if (bsInfo.isA2C !== undefined) { bs.isA2C = bsInfo.isA2C; }
|
||||
if (bsInfo.isIndepend !== undefined) { bs.isIndepend = bsInfo.isIndepend; }
|
||||
if (bsInfo.blendColor !== undefined) { bs.blendColor = bsInfo.blendColor as Color; }
|
||||
|
||||
// A2C (Alpha to Coverage) requires MSAA to be effective.
|
||||
// Without multiple subsamples, A2C behaves like alpha-test at ~0.5 and should be disabled.
|
||||
// Disable A2C when neither the pass nor the global framebuffer has MSAA enabled:
|
||||
// - passWantsMultisample: pass explicitly requests isMultisample
|
||||
// - globalMsaaEnabled: swapchain has MSAA (native: colorTexture.samples > X1;
|
||||
// WebGL: antialias from gl.getContextAttributes(), since WebGL
|
||||
// MSAA is controlled at context level, not texture level)
|
||||
if (bs.isA2C) {
|
||||
const gfxDevice = deviceManager.gfxDevice as any;
|
||||
const gl: WebGL2RenderingContext | WebGLRenderingContext | null = gfxDevice.gl || null;
|
||||
const ctxAttrs = gl && gl.getContextAttributes();
|
||||
const antialias: boolean = !!(ctxAttrs && ctxAttrs.antialias);
|
||||
const passWantsMultisample = (info.rasterizerState && info.rasterizerState.isMultisample === true);
|
||||
const swapchain = deviceManager.swapchain;
|
||||
const colorTex = swapchain && swapchain.colorTexture;
|
||||
const msaaDisabled = (!colorTex || (colorTex && colorTex.samples <= SampleCount.X1))
|
||||
|| !antialias || !passWantsMultisample;
|
||||
if (msaaDisabled) {
|
||||
bs.isA2C = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
pass._rs.assign(info.rasterizerState as RasterizerState);
|
||||
pass._dss.assign(info.depthStencilState as DepthStencilState);
|
||||
|
||||
@@ -21,12 +21,14 @@
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
*/
|
||||
import { DEBUG } from 'internal:constants';
|
||||
import { screenAdapter } from 'pal/screen-adapter';
|
||||
import { Orientation } from '../../../pal/screen-adapter/enum-type';
|
||||
import {
|
||||
TextureType, TextureUsageBit, Format, RenderPass, Texture, Framebuffer,
|
||||
RenderPassInfo, Device, TextureInfo, FramebufferInfo, Swapchain, SurfaceTransform, TextureFlagBit, TextureFlags,
|
||||
} from '../../gfx';
|
||||
import { warn } from '../../core/platform/debug';
|
||||
import { Root } from '../../root';
|
||||
import { Camera } from '../scene';
|
||||
|
||||
@@ -41,7 +43,10 @@ export interface IRenderWindowInfo {
|
||||
externalFlag?: TextureFlags; // external texture type normal or oes
|
||||
}
|
||||
|
||||
const orientationMap: Record<Orientation, SurfaceTransform> = {
|
||||
// NOTE: `Orientation` is a flag enum whose composite members (LANDSCAPE, AUTO) are never
|
||||
// actual runtime orientations, so this map intentionally only covers the physical ones.
|
||||
// It is therefore typed as Partial rather than a total Record<Orientation, ...>.
|
||||
const orientationMap: Partial<Record<Orientation, SurfaceTransform>> = {
|
||||
[Orientation.PORTRAIT]: SurfaceTransform.IDENTITY,
|
||||
[Orientation.LANDSCAPE_RIGHT]: SurfaceTransform.ROTATE_90,
|
||||
[Orientation.PORTRAIT_UPSIDE_DOWN]: SurfaceTransform.ROTATE_180,
|
||||
@@ -253,7 +258,11 @@ export class RenderWindow {
|
||||
*/
|
||||
public resize (width: number, height: number): void {
|
||||
if (this._swapchain) {
|
||||
this._swapchain.resize(width, height, orientationMap[screenAdapter.orientation]);
|
||||
const surfaceTransform = orientationMap[screenAdapter.orientation];
|
||||
if (DEBUG && surfaceTransform === undefined) {
|
||||
warn(`Unexpected screen orientation: ${screenAdapter.orientation}`);
|
||||
}
|
||||
this._swapchain.resize(width, height, surfaceTransform || SurfaceTransform.IDENTITY);
|
||||
this._width = this._swapchain.width;
|
||||
this._height = this._swapchain.height;
|
||||
} else {
|
||||
|
||||
@@ -91,6 +91,9 @@ export class PointLight extends Light {
|
||||
* @en The luminance of the light source in LDR mode.
|
||||
* @zh LDR 模式下光源的亮度。
|
||||
*/
|
||||
get luminanceLDR (): number {
|
||||
return this._luminanceLDR;
|
||||
}
|
||||
set luminanceLDR (value: number) {
|
||||
this._luminanceLDR = value;
|
||||
}
|
||||
|
||||
@@ -67,11 +67,13 @@ export class ReflectionProbe {
|
||||
protected readonly _size = v3(1, 1, 1);
|
||||
|
||||
/**
|
||||
* @en Render cubemap's camera
|
||||
* @zh 渲染cubemap的相机
|
||||
* @en Camera used for probe rendering (cubemap capture or planar reflection).
|
||||
* @zh 用于探针渲染的相机(cubemap 采集或平面反射)
|
||||
*/
|
||||
private _camera: Camera | null = null;
|
||||
|
||||
private _previewCamera: Camera | null = null;
|
||||
|
||||
/**
|
||||
* @en Unique id of probe.
|
||||
* @zh probe的唯一id
|
||||
@@ -184,6 +186,9 @@ export class ReflectionProbe {
|
||||
set visibility (val) {
|
||||
this._visibility = val;
|
||||
this._camera!.visibility = this._visibility;
|
||||
if (this._previewCamera) {
|
||||
this._previewCamera.visibility = this._visibility;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -320,6 +325,21 @@ export class ReflectionProbe {
|
||||
this._needRender = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* @engineInternal
|
||||
* @mangle
|
||||
*/
|
||||
public renderPreviewPlanarReflection (sourceCamera: Camera): Camera {
|
||||
if (!this._previewCamera) {
|
||||
this._createCamera(new Node(`${this.cameraNode.name} Preview Reflection`), true);
|
||||
}
|
||||
const previewCamera = this._previewCamera!;
|
||||
this._syncCameraParams(sourceCamera, previewCamera);
|
||||
this._transformReflectionCamera(sourceCamera, previewCamera);
|
||||
this._needRender = true;
|
||||
return previewCamera;
|
||||
}
|
||||
|
||||
public switchProbeType (type: ProbeType, sourceCamera: Camera | null): void {
|
||||
if (type === ProbeType.CUBE) {
|
||||
this._needRender = false;
|
||||
@@ -357,6 +377,12 @@ export class ReflectionProbe {
|
||||
this._camera.destroy();
|
||||
this._camera = null;
|
||||
}
|
||||
if (this._previewCamera) {
|
||||
const cameraNode = this._previewCamera.node;
|
||||
this._previewCamera.destroy();
|
||||
this._previewCamera = null;
|
||||
cameraNode.destroy();
|
||||
}
|
||||
for (let i = 0; i < this.bakedCubeTextures.length; i++) {
|
||||
this.bakedCubeTextures[i].destroy();
|
||||
}
|
||||
@@ -410,48 +436,54 @@ export class ReflectionProbe {
|
||||
return true;
|
||||
}
|
||||
|
||||
private _syncCameraParams (camera: Camera): void {
|
||||
this.camera.projectionType = camera.projectionType;
|
||||
this.camera.orthoHeight = camera.orthoHeight;
|
||||
this.camera.nearClip = camera.nearClip;
|
||||
this.camera.farClip = camera.farClip;
|
||||
this.camera.fov = camera.fov;
|
||||
this.camera.clearFlag = camera.clearFlag;
|
||||
this.camera.clearColor = camera.clearColor;
|
||||
this.camera.priority = camera.priority - 1;
|
||||
this.camera.resize(camera.width, camera.height);
|
||||
private _syncCameraParams (camera: Camera, targetCamera: Camera = this.camera): void {
|
||||
targetCamera.projectionType = camera.projectionType;
|
||||
targetCamera.orthoHeight = camera.orthoHeight;
|
||||
targetCamera.nearClip = camera.nearClip;
|
||||
targetCamera.farClip = camera.farClip;
|
||||
targetCamera.fov = camera.fov;
|
||||
targetCamera.clearFlag = camera.clearFlag;
|
||||
targetCamera.clearColor = camera.clearColor;
|
||||
targetCamera.priority = camera.priority - 1;
|
||||
targetCamera.resize(camera.width, camera.height);
|
||||
}
|
||||
|
||||
private _createCamera (cameraNode: Node): Camera | null {
|
||||
private _createCamera (cameraNode: Node, preview = false): Camera | null {
|
||||
const root = cclegacy.director.root;
|
||||
if (!this._camera) {
|
||||
this._camera = root.createCamera();
|
||||
if (!this._camera) return null;
|
||||
this._camera.initialize({
|
||||
let camera = preview ? this._previewCamera : this._camera;
|
||||
if (!camera) {
|
||||
camera = root.createCamera();
|
||||
if (!camera) return null;
|
||||
camera.initialize({
|
||||
name: cameraNode.name,
|
||||
node: cameraNode,
|
||||
projection: CameraProjection.PERSPECTIVE,
|
||||
window: EDITOR ? root && root.mainWindow : root && root.tempWindow,
|
||||
window: preview || EDITOR ? root.mainWindow : root.tempWindow,
|
||||
priority: 0,
|
||||
cameraType: CameraType.DEFAULT,
|
||||
trackingType: TrackingType.NO_TRACKING,
|
||||
});
|
||||
if (preview) {
|
||||
this._previewCamera = camera;
|
||||
} else {
|
||||
this._camera = camera;
|
||||
}
|
||||
}
|
||||
this._camera.setViewportInOrientedSpace(new Rect(0, 0, 1, 1));
|
||||
this._camera.fovAxis = CameraFOVAxis.VERTICAL;
|
||||
this._camera.fov = toRadian(90);
|
||||
this._camera.orthoHeight = 10;
|
||||
this._camera.nearClip = 1;
|
||||
this._camera.farClip = 1000;
|
||||
this._camera.clearColor = this._backgroundColor;
|
||||
this._camera.clearDepth = 1.0;
|
||||
this._camera.clearStencil = 0.0;
|
||||
this._camera.clearFlag = this._clearFlag;
|
||||
this._camera.visibility = this._visibility;
|
||||
this._camera.aperture = CameraAperture.F16_0;
|
||||
this._camera.shutter = CameraShutter.D125;
|
||||
this._camera.iso = CameraISO.ISO100;
|
||||
return this._camera;
|
||||
camera.setViewportInOrientedSpace(new Rect(0, 0, 1, 1));
|
||||
camera.fovAxis = CameraFOVAxis.VERTICAL;
|
||||
camera.fov = toRadian(90);
|
||||
camera.orthoHeight = 10;
|
||||
camera.nearClip = 1;
|
||||
camera.farClip = 1000;
|
||||
camera.clearColor = this._backgroundColor;
|
||||
camera.clearDepth = 1.0;
|
||||
camera.clearStencil = 0.0;
|
||||
camera.clearFlag = this._clearFlag;
|
||||
camera.visibility = this._visibility;
|
||||
camera.aperture = CameraAperture.F16_0;
|
||||
camera.shutter = CameraShutter.D125;
|
||||
camera.iso = CameraISO.ISO100;
|
||||
return camera;
|
||||
}
|
||||
|
||||
private _resetCameraParams (): void {
|
||||
@@ -478,10 +510,10 @@ export class ReflectionProbe {
|
||||
return rt;
|
||||
}
|
||||
|
||||
private _transformReflectionCamera (sourceCamera: Camera): void {
|
||||
private _transformReflectionCamera (sourceCamera: Camera, targetCamera: Camera = this.camera): void {
|
||||
const offset = Vec3.dot(this.node.worldPosition, this.node.up);
|
||||
this._reflect(this._cameraWorldPos, sourceCamera.node.worldPosition, this.node.up, offset);
|
||||
this.cameraNode.worldPosition = this._cameraWorldPos;
|
||||
targetCamera.node.worldPosition = this._cameraWorldPos;
|
||||
|
||||
Vec3.transformQuat(this._forward, Vec3.FORWARD, sourceCamera.node.worldRotation);
|
||||
this._reflect(this._forward, this._forward, this.node.up, 0);
|
||||
@@ -494,14 +526,14 @@ export class ReflectionProbe {
|
||||
|
||||
Quat.fromViewUp(this._cameraWorldRotation, this._forward, this._up);
|
||||
|
||||
this.cameraNode.worldRotation = this._cameraWorldRotation;
|
||||
targetCamera.node.worldRotation = this._cameraWorldRotation;
|
||||
|
||||
this.camera.update(true);
|
||||
targetCamera.update(true);
|
||||
|
||||
// Transform the plane from world space to reflection camera space use the inverse transpose matrix
|
||||
const viewSpaceProbe = new Vec4(this.node.up.x, this.node.up.y, this.node.up.z, -Vec3.dot(this.node.up, this.node.worldPosition));
|
||||
viewSpaceProbe.transformMat4(this.camera.matView.clone().invert().transpose());
|
||||
this.camera.calculateObliqueMat(viewSpaceProbe);
|
||||
viewSpaceProbe.transformMat4(targetCamera.matView.clone().invert().transpose());
|
||||
targetCamera.calculateObliqueMat(viewSpaceProbe);
|
||||
}
|
||||
|
||||
private _reflect (out: Vec3, point: Vec3, normal: Vec3, offset: number): Vec3 {
|
||||
|
||||
@@ -102,6 +102,9 @@ export class SphereLight extends Light {
|
||||
* @en The luminance of the light source in LDR mode
|
||||
* @zh LDR 模式下光源的亮度
|
||||
*/
|
||||
get luminanceLDR (): number {
|
||||
return this._luminanceLDR;
|
||||
}
|
||||
set luminanceLDR (value: number) {
|
||||
this._luminanceLDR = value;
|
||||
}
|
||||
|
||||
@@ -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();
|
||||
@@ -556,7 +560,11 @@ export class SceneCulling {
|
||||
|
||||
private executeSphereLightCulling (light: SphereLight, frustumCullingResult: Array<Model>, lightBoundsCullingResult: Array<Model>): void {
|
||||
const lightAABB = light.aabb;
|
||||
const visibility = light.visibility;
|
||||
for (const model of frustumCullingResult) {
|
||||
if (!isVisible(model, visibility)) {
|
||||
continue;
|
||||
}
|
||||
const modelBounds = model.worldBounds;
|
||||
if (!modelBounds || intersect.aabbWithAABB(modelBounds, lightAABB)) {
|
||||
lightBoundsCullingResult.push(model);
|
||||
@@ -567,7 +575,11 @@ export class SceneCulling {
|
||||
private executeSpotLightCulling (light: SpotLight, frustumCullingResult: Array<Model>, lightBoundsCullingResult: Array<Model>): void {
|
||||
const lightAABB = light.aabb;
|
||||
const lightFrustum: Frustum = light.frustum;
|
||||
const visibility = light.visibility;
|
||||
for (const model of frustumCullingResult) {
|
||||
if (!isVisible(model, visibility)) {
|
||||
continue;
|
||||
}
|
||||
const modelBounds = model.worldBounds;
|
||||
if (!modelBounds || (intersect.aabbWithAABB(lightAABB, modelBounds) && intersect.aabbFrustum(modelBounds, lightFrustum))) {
|
||||
lightBoundsCullingResult.push(model);
|
||||
@@ -577,7 +589,11 @@ export class SceneCulling {
|
||||
|
||||
private executePointLightCulling (light: PointLight, frustumCullingResult: Array<Model>, lightBoundsCullingResult: Array<Model>): void {
|
||||
const lightAABB = light.aabb;
|
||||
const visibility = light.visibility;
|
||||
for (const model of frustumCullingResult) {
|
||||
if (!isVisible(model, visibility)) {
|
||||
continue;
|
||||
}
|
||||
const modelBounds = model.worldBounds;
|
||||
if (!modelBounds || intersect.aabbWithAABB(lightAABB, modelBounds)) {
|
||||
lightBoundsCullingResult.push(model);
|
||||
@@ -590,8 +606,12 @@ export class SceneCulling {
|
||||
frustumCullingResult: Array<Model>,
|
||||
lightBoundsCullingResult: Array<Model>,
|
||||
): void {
|
||||
const visibility = light.visibility;
|
||||
rangedDirLightBoundingBox.transform(light.node!.worldMatrix, null, null, null, lightAABB);
|
||||
for (const model of frustumCullingResult) {
|
||||
if (!isVisible(model, visibility)) {
|
||||
continue;
|
||||
}
|
||||
const modelBounds = model.worldBounds;
|
||||
if (!modelBounds || intersect.aabbWithAABB(lightAABB, modelBounds)) {
|
||||
lightBoundsCullingResult.push(model);
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -1264,15 +1264,6 @@ export class WebProgramLibrary implements ProgramLibrary {
|
||||
if (passSet) {
|
||||
info.setLayouts.push(passSet);
|
||||
}
|
||||
const phaseSet = getDescriptorSetLayout(
|
||||
this.layoutGraph,
|
||||
subpassOrPassID,
|
||||
phaseID,
|
||||
UpdateFrequency.PER_PHASE,
|
||||
);
|
||||
if (phaseSet) {
|
||||
info.setLayouts.push(phaseSet);
|
||||
}
|
||||
const batchSet = getProgramDescriptorSetLayout(
|
||||
device,
|
||||
lg,
|
||||
@@ -1293,6 +1284,15 @@ export class WebProgramLibrary implements ProgramLibrary {
|
||||
if (instanceSet) {
|
||||
info.setLayouts.push(instanceSet);
|
||||
}
|
||||
const phaseSet = getDescriptorSetLayout(
|
||||
this.layoutGraph,
|
||||
subpassOrPassID,
|
||||
phaseID,
|
||||
UpdateFrequency.PER_PHASE,
|
||||
);
|
||||
if (phaseSet) {
|
||||
info.setLayouts.push(phaseSet);
|
||||
}
|
||||
programData.pipelineLayout = device.createPipelineLayout(info);
|
||||
return programData.pipelineLayout;
|
||||
}
|
||||
|
||||
@@ -28,8 +28,9 @@ import { UNIFORM_LIGHTMAP_TEXTURE_BINDING, UNIFORM_REFLECTION_PROBE_BLEND_CUBEMA
|
||||
UNIFORM_REFLECTION_PROBE_TEXTURE_BINDING, ENABLE_PROBE_BLEND,
|
||||
IRenderPass,
|
||||
getPassPool } from './define';
|
||||
import { BufferUsageBit, MemoryUsageBit, Device, Texture, InputAssembler, InputAssemblerInfo,
|
||||
import { BufferUsageBit, MemoryUsageBit, Device, InputAssembler, InputAssemblerInfo,
|
||||
Attribute, Buffer, BufferInfo, CommandBuffer, Shader, DescriptorSet } from '../gfx';
|
||||
import type { Texture } from '../gfx';
|
||||
import { RecyclePool } from '../core/memop';
|
||||
|
||||
export function instancingCompareFn (l: InstancedBuffer, r: InstancedBuffer): number {
|
||||
@@ -65,6 +66,7 @@ export class InstancedBuffer {
|
||||
public sortRender: IRenderPass;
|
||||
private declare _passPool: RecyclePool<IRenderPass>;
|
||||
private declare _device: Device;
|
||||
private readonly _instanceMap = new Map<string, IInstancedItem[]>();
|
||||
constructor (pass: Pass) {
|
||||
this._device = pass.device;
|
||||
this.pass = pass;
|
||||
@@ -81,6 +83,7 @@ export class InstancedBuffer {
|
||||
});
|
||||
this._passPool.reset();
|
||||
this.instances.length = 0;
|
||||
this._instanceMap.clear();
|
||||
}
|
||||
|
||||
public merge (subModel: SubModel, passIdx: number, shaderImplant: Shader | null = null): void {
|
||||
@@ -106,72 +109,109 @@ export class InstancedBuffer {
|
||||
this.sortRender.hash = hash;
|
||||
this.sortRender.shaderId = shader.typedID;
|
||||
this.sortRender.passIdx = passIdx;
|
||||
for (let i = 0; i < this.instances.length; ++i) {
|
||||
const instance = this.instances[i];
|
||||
if (instance.ia.indexBuffer?.objectID !== sourceIA.indexBuffer?.objectID || instance.count >= MAX_CAPACITY) { continue; }
|
||||
|
||||
// check same binding
|
||||
if (instance.lightingMap.objectID !== lightingMap.objectID) {
|
||||
continue;
|
||||
const key = `${sourceIA.indexBuffer?.objectID ?? 0}/${lightingMap.objectID}/${useReflectionProbeType}/`
|
||||
+ `${reflectionProbeCubemap.objectID}/${reflectionProbePlanarMap.objectID}/`
|
||||
+ `${ENABLE_PROBE_BLEND ? reflectionProbeBlendCubemap!.objectID : 0}/${stride}`;
|
||||
const mappedInstances = this._instanceMap.get(key);
|
||||
if (mappedInstances) {
|
||||
for (let i = 0; i < mappedInstances.length; ++i) {
|
||||
const instance = mappedInstances[i];
|
||||
if (instance.count >= MAX_CAPACITY) { continue; }
|
||||
this._appendInstance(instance, attrs.buffer, shader, descriptorSet);
|
||||
return;
|
||||
}
|
||||
|
||||
if (instance.useReflectionProbeType !== useReflectionProbeType) {
|
||||
continue;
|
||||
}
|
||||
if (instance.reflectionProbeCubemap.objectID !== reflectionProbeCubemap.objectID) {
|
||||
continue;
|
||||
}
|
||||
if (instance.reflectionProbePlanarMap.objectID !== reflectionProbePlanarMap.objectID) {
|
||||
continue;
|
||||
}
|
||||
if (ENABLE_PROBE_BLEND && instance.reflectionProbeBlendCubemap!.objectID !== reflectionProbeBlendCubemap!.objectID) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (instance.stride !== stride) {
|
||||
// we allow this considering both baked and non-baked
|
||||
// skinning models may be present in the same buffer
|
||||
continue;
|
||||
}
|
||||
if (instance.count >= instance.capacity) { // resize buffers
|
||||
instance.capacity <<= 1;
|
||||
const newSize = instance.stride * instance.capacity;
|
||||
const oldData = instance.data;
|
||||
instance.data = new Uint8Array(newSize);
|
||||
instance.data.set(oldData);
|
||||
instance.vb.resize(newSize);
|
||||
}
|
||||
instance.shader = shader;
|
||||
instance.descriptorSet = descriptorSet;
|
||||
instance.data.set(attrs.buffer, instance.stride * instance.count++);
|
||||
this.hasPendingModels = true;
|
||||
return;
|
||||
}
|
||||
|
||||
// Create a new instance
|
||||
this._createInstance(
|
||||
key,
|
||||
sourceIA,
|
||||
attrs.attributes,
|
||||
attrs.buffer,
|
||||
stride,
|
||||
shader,
|
||||
descriptorSet,
|
||||
lightingMap,
|
||||
useReflectionProbeType,
|
||||
reflectionProbeCubemap,
|
||||
reflectionProbePlanarMap,
|
||||
reflectionProbeBlendCubemap,
|
||||
);
|
||||
}
|
||||
|
||||
private _appendInstance (instance: IInstancedItem, data: Uint8Array, shader: Shader, descriptorSet: DescriptorSet): void {
|
||||
if (instance.count >= instance.capacity) { // resize buffers
|
||||
instance.capacity = Math.min(instance.capacity << 1, MAX_CAPACITY);
|
||||
const newSize = instance.stride * instance.capacity;
|
||||
const oldData = instance.data;
|
||||
instance.data = new Uint8Array(newSize);
|
||||
instance.data.set(oldData);
|
||||
instance.vb.resize(newSize);
|
||||
}
|
||||
instance.shader = shader;
|
||||
instance.descriptorSet = descriptorSet;
|
||||
instance.data.set(data, instance.stride * instance.count++);
|
||||
this.hasPendingModels = true;
|
||||
}
|
||||
|
||||
private _createInstance (
|
||||
key: string,
|
||||
sourceIA: InputAssembler,
|
||||
instancedAttributes: Attribute[],
|
||||
instanceData: Uint8Array,
|
||||
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;
|
||||
|
||||
for (let i = 0; i < attrs.attributes.length; i++) {
|
||||
const attr = attrs.attributes[i];
|
||||
for (let i = 0; i < instancedAttributes.length; i++) {
|
||||
const attr = instancedAttributes[i];
|
||||
const newAttr = new Attribute(attr.name, attr.format, attr.isNormalized, vertexBuffers.length, true);
|
||||
attributes.push(newAttr);
|
||||
}
|
||||
data.set(attrs.buffer);
|
||||
data.set(instanceData);
|
||||
|
||||
vertexBuffers.push(vb);
|
||||
const iaInfo = new InputAssemblerInfo(attributes, vertexBuffers, indexBuffer);
|
||||
const ia = this._device.createInputAssembler(iaInfo);
|
||||
// eslint-disable-next-line max-len
|
||||
this.instances.push({ count: 1, capacity: INITIAL_CAPACITY, vb, data, ia, stride, shader, descriptorSet, lightingMap, reflectionProbeCubemap, reflectionProbePlanarMap, useReflectionProbeType, reflectionProbeBlendCubemap });
|
||||
const instance = {
|
||||
count: 1,
|
||||
capacity: INITIAL_CAPACITY,
|
||||
vb,
|
||||
data,
|
||||
ia,
|
||||
stride,
|
||||
shader,
|
||||
descriptorSet,
|
||||
lightingMap,
|
||||
reflectionProbeCubemap,
|
||||
reflectionProbePlanarMap,
|
||||
useReflectionProbeType,
|
||||
reflectionProbeBlendCubemap,
|
||||
} as IInstancedItem;
|
||||
this.instances.push(instance);
|
||||
let mappedInstances = this._instanceMap.get(key);
|
||||
if (!mappedInstances) {
|
||||
mappedInstances = [];
|
||||
this._instanceMap.set(key, mappedInstances);
|
||||
}
|
||||
mappedInstances.push(instance);
|
||||
this.hasPendingModels = true;
|
||||
}
|
||||
|
||||
@@ -180,7 +220,7 @@ export class InstancedBuffer {
|
||||
const instance = this.instances[i];
|
||||
if (!instance.count) { continue; }
|
||||
instance.ia.instanceCount = instance.count;
|
||||
cmdBuff.updateBuffer(instance.vb, instance.data);
|
||||
cmdBuff.updateBuffer(instance.vb, instance.data.buffer as ArrayBuffer, instance.count * instance.stride);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -27,7 +27,7 @@ import { IRenderFlowInfo, RenderFlow } from '../render-flow';
|
||||
import { ReflectionProbeStage } from './reflection-probe-stage';
|
||||
import { RenderFlowTag } from '../pipeline-serialization';
|
||||
import { RenderPipeline } from '../render-pipeline';
|
||||
import { Camera } from '../../render-scene/scene/camera';
|
||||
import { Camera, CameraUsage } from '../../render-scene/scene/camera';
|
||||
import { ProbeType, ReflectionProbe } from '../../render-scene/scene/reflection-probe';
|
||||
import { cclegacy } from '../../core';
|
||||
|
||||
@@ -65,7 +65,13 @@ export class ReflectionProbeFlow extends RenderFlow {
|
||||
const probes = cclegacy.internal.reflectionProbeManager.getProbes() as ReflectionProbe[];
|
||||
for (let i = 0; i < probes.length; i++) {
|
||||
if (probes[i].needRender) {
|
||||
if (EDITOR || probes[i].probeType === ProbeType.PLANAR) {
|
||||
if (probes[i].probeType === ProbeType.PLANAR) {
|
||||
let reflectionCamera: Camera | undefined;
|
||||
if (EDITOR && camera.cameraUsage === CameraUsage.PREVIEW) {
|
||||
reflectionCamera = probes[i].renderPreviewPlanarReflection(camera);
|
||||
}
|
||||
this._renderStage(camera, probes[i], reflectionCamera);
|
||||
} else if (EDITOR) {
|
||||
this._renderStage(camera, probes[i]);
|
||||
}
|
||||
}
|
||||
@@ -75,12 +81,12 @@ export class ReflectionProbeFlow extends RenderFlow {
|
||||
public destroy (): void {
|
||||
super.destroy();
|
||||
}
|
||||
private _renderStage (camera: Camera, probe: ReflectionProbe): void {
|
||||
private _renderStage (camera: Camera, probe: ReflectionProbe, reflectionCamera?: Camera): void {
|
||||
for (let i = 0; i < this._stages.length; i++) {
|
||||
const probeStage = this._stages[i] as ReflectionProbeStage;
|
||||
if (probe.probeType === ProbeType.PLANAR) {
|
||||
cclegacy.internal.reflectionProbeManager.updatePlanarMap(probe, null);
|
||||
probeStage.setUsageInfo(probe, probe.realtimePlanarTexture!.window!.framebuffer);
|
||||
probeStage.setUsageInfo(probe, probe.realtimePlanarTexture!.window!.framebuffer, reflectionCamera);
|
||||
probeStage.render(camera);
|
||||
cclegacy.internal.reflectionProbeManager.updatePlanarMap(probe, probe.realtimePlanarTexture!.getGFXTexture());
|
||||
} else {
|
||||
|
||||
@@ -55,6 +55,7 @@ export class ReflectionProbeStage extends RenderStage {
|
||||
private _frameBuffer: Framebuffer | null = null;
|
||||
private _renderArea = new Rect();
|
||||
private _probe: ReflectionProbe | null = null;
|
||||
private _reflectionCamera: Camera | null = null;
|
||||
private _probeRenderQueue!: RenderReflectionProbeQueue;
|
||||
private _rgbeColor = new Vec3();
|
||||
|
||||
@@ -68,9 +69,10 @@ export class ReflectionProbeStage extends RenderStage {
|
||||
* @param probe
|
||||
* @param frameBuffer
|
||||
*/
|
||||
public setUsageInfo (probe: ReflectionProbe, frameBuffer: Framebuffer): void {
|
||||
public setUsageInfo (probe: ReflectionProbe, frameBuffer: Framebuffer, reflectionCamera?: Camera): void {
|
||||
this._probe = probe;
|
||||
this._frameBuffer = frameBuffer;
|
||||
this._reflectionCamera = reflectionCamera ?? null;
|
||||
}
|
||||
|
||||
public destroy (): void {
|
||||
@@ -108,8 +110,9 @@ export class ReflectionProbeStage extends RenderStage {
|
||||
public render (camera: Camera): void {
|
||||
const pipeline = this._pipeline;
|
||||
const cmdBuff = pipeline.commandBuffers[0];
|
||||
this._probeRenderQueue.gatherRenderObjects(this._probe!, camera, cmdBuff);
|
||||
pipeline.pipelineUBO.updateCameraUBO(this._probe!.camera);
|
||||
const probeCamera = this._reflectionCamera ?? this._probe!.camera;
|
||||
this._probeRenderQueue.gatherRenderObjects(this._probe!, camera, cmdBuff, probeCamera);
|
||||
pipeline.pipelineUBO.updateCameraUBO(probeCamera);
|
||||
|
||||
this._renderArea.x = 0;
|
||||
this._renderArea.y = 0;
|
||||
@@ -118,10 +121,10 @@ export class ReflectionProbeStage extends RenderStage {
|
||||
|
||||
const renderPass = this._frameBuffer!.renderPass;
|
||||
|
||||
if (this._probe!.camera.clearFlag & ClearFlagBit.COLOR) {
|
||||
this._rgbeColor.x = this._probe!.camera.clearColor.x;
|
||||
this._rgbeColor.y = this._probe!.camera.clearColor.y;
|
||||
this._rgbeColor.z = this._probe!.camera.clearColor.z;
|
||||
if (probeCamera.clearFlag & ClearFlagBit.COLOR) {
|
||||
this._rgbeColor.x = probeCamera.clearColor.x;
|
||||
this._rgbeColor.y = probeCamera.clearColor.y;
|
||||
this._rgbeColor.z = probeCamera.clearColor.z;
|
||||
const rgbe = packRGBE(this._rgbeColor);
|
||||
colors[0].x = rgbe.x;
|
||||
colors[0].y = rgbe.y;
|
||||
@@ -134,8 +137,8 @@ export class ReflectionProbeStage extends RenderStage {
|
||||
this._frameBuffer!,
|
||||
this._renderArea,
|
||||
colors,
|
||||
this._probe!.camera.clearDepth,
|
||||
this._probe!.camera.clearStencil,
|
||||
probeCamera.clearDepth,
|
||||
probeCamera.clearStencil,
|
||||
);
|
||||
cmdBuff.bindDescriptorSet(SetIndex.GLOBAL, pipeline.descriptorSet);
|
||||
|
||||
|
||||
@@ -79,13 +79,14 @@ export class RenderReflectionProbeQueue {
|
||||
public constructor (pipeline: PipelineRuntime) {
|
||||
this._pipeline = pipeline;
|
||||
}
|
||||
public gatherRenderObjects (probe: ReflectionProbe, camera: Camera, cmdBuff: CommandBuffer): void {
|
||||
public gatherRenderObjects (probe: ReflectionProbe, camera: Camera, cmdBuff: CommandBuffer, reflectionCamera?: Camera): void {
|
||||
this.clear();
|
||||
const scene = camera.scene!;
|
||||
const sceneData = this._pipeline.pipelineSceneData;
|
||||
const skybox = sceneData.skybox;
|
||||
const probeCamera = reflectionCamera ?? probe.camera;
|
||||
|
||||
if (skybox.enabled && skybox.model && (probe.camera.clearFlag & SkyBoxFlagValue.VALUE)) {
|
||||
if (skybox.enabled && skybox.model && (probeCamera.clearFlag & SkyBoxFlagValue.VALUE)) {
|
||||
this.add(skybox.model);
|
||||
}
|
||||
|
||||
@@ -105,7 +106,7 @@ export class RenderReflectionProbeQueue {
|
||||
if (geometry.intersect.aabbWithAABB(model.worldBounds, probe.boundingBox!)) {
|
||||
this.add(model);
|
||||
}
|
||||
} else if (geometry.intersect.aabbFrustum(model.worldBounds, probe.camera.frustum)) {
|
||||
} else if (geometry.intersect.aabbFrustum(model.worldBounds, probeCamera.frustum)) {
|
||||
this.add(model);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -850,14 +850,12 @@ export class Skeleton extends UIRenderer {
|
||||
warnID(16410);
|
||||
}
|
||||
const skeletonInfo = this._skeletonCache!.getSkeletonInfo(this._skeletonData!);
|
||||
if (this._skeletonInfo !== skeletonInfo) {
|
||||
if (this._skeletonInfo !== skeletonInfo || (!this._skeletonInfo && !skeletonInfo)) {
|
||||
this._destroySkeletonInfo(this._skeletonCache);
|
||||
if (!skeletonInfo && this._cacheMode === SpineAnimationCacheMode.PRIVATE_CACHE) {
|
||||
this._animCache = this._skeletonCache!.initAnimationCache(this.skeletonData!.uuid, this._skeletonData!, this._animationName);
|
||||
}
|
||||
this._skeletonInfo = this._skeletonCache!.createSkeletonInfo(this._skeletonData!);
|
||||
}
|
||||
if (this._skeletonInfo) {
|
||||
this._skeleton = this._skeletonInfo.skeleton!;
|
||||
}
|
||||
} else {
|
||||
@@ -1589,7 +1587,7 @@ export class Skeleton extends UIRenderer {
|
||||
const socket = this._sockets[i];
|
||||
if (socket.path && socket.target) {
|
||||
const boneIdx = this._cachedSockets.get(socket.path);
|
||||
if (!boneIdx) {
|
||||
if (boneIdx == null || boneIdx < 0) {
|
||||
error(`Skeleton data does not contain path ${socket.path}`);
|
||||
continue;
|
||||
}
|
||||
|
||||
@@ -1537,6 +1537,7 @@ export class Terrain extends Component {
|
||||
* @zh 获得地形信息
|
||||
*/
|
||||
@type(TerrainInfo)
|
||||
@visible(false)
|
||||
public get info (): TerrainInfo {
|
||||
const ti = new TerrainInfo();
|
||||
ti.tileSize = this.tileSize;
|
||||
@@ -1815,11 +1816,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 +2585,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();
|
||||
}
|
||||
|
||||
|
||||
@@ -222,7 +222,9 @@ vec4 CCStandardShadingBase (StandardSurface s, vec4 shadowPos) {
|
||||
vec3 R = normalize(reflect(-V, N));
|
||||
#if CC_USE_REFLECTION_PROBE == REFLECTION_PROBE_TYPE_CUBE
|
||||
if(s.reflectionProbeId < 0.0){
|
||||
env = SampleReflectionProbe(cc_environment, R, s.roughness, cc_ambientGround.w, CC_USE_IBL == IBL_RGBE);
|
||||
#if CC_USE_IBL
|
||||
env = SampleReflectionProbe(cc_environment, R, s.roughness, cc_ambientGround.w, CC_USE_IBL == IBL_RGBE);
|
||||
#endif
|
||||
}else{
|
||||
vec3 centerPos, boxHalfSize;
|
||||
float mipCount;
|
||||
@@ -247,7 +249,9 @@ vec4 CCStandardShadingBase (StandardSurface s, vec4 shadowPos) {
|
||||
env = unpackRGBE(probe);
|
||||
#elif CC_USE_REFLECTION_PROBE == REFLECTION_PROBE_TYPE_BLEND || CC_USE_REFLECTION_PROBE == REFLECTION_PROBE_TYPE_BLEND_AND_SKYBOX
|
||||
if (s.reflectionProbeId < 0.0) {
|
||||
env = SampleReflectionProbe(cc_environment, R, s.roughness, cc_ambientGround.w, CC_USE_IBL == IBL_RGBE);
|
||||
#if CC_USE_IBL
|
||||
env = SampleReflectionProbe(cc_environment, R, s.roughness, cc_ambientGround.w, CC_USE_IBL == IBL_RGBE);
|
||||
#endif
|
||||
} else {
|
||||
vec3 centerPos, boxHalfSize;
|
||||
float mipCount;
|
||||
@@ -256,7 +260,10 @@ vec4 CCStandardShadingBase (StandardSurface s, vec4 shadowPos) {
|
||||
|
||||
env = SampleReflectionProbe(cc_reflectionProbeCubemap, fixedR.xyz, s.roughness, mipCount, isReflectProbeUsingRGBE(s.reflectionProbeId));
|
||||
if (s.reflectionProbeBlendId < 0.0) {
|
||||
vec3 skyBoxEnv = SampleReflectionProbe(cc_environment, R, s.roughness, cc_ambientGround.w, CC_USE_IBL == IBL_RGBE) * lightIntensity;
|
||||
vec3 skyBoxEnv = vec3(0.0);
|
||||
#if CC_USE_IBL
|
||||
skyBoxEnv = SampleReflectionProbe(cc_environment, R, s.roughness, cc_ambientGround.w, CC_USE_IBL == IBL_RGBE) * lightIntensity;
|
||||
#endif
|
||||
#if CC_USE_REFLECTION_PROBE == REFLECTION_PROBE_TYPE_BLEND_AND_SKYBOX
|
||||
//blend with skybox
|
||||
env = mix(env, skyBoxEnv, s.reflectionProbeBlendFactor);
|
||||
|
||||
@@ -99,7 +99,10 @@ vec3 SampleEnvironmentSpecular(samplerCube tex, in LightingIntermediateData ligh
|
||||
vec4 fixedR = CalculateBoxProjectedDirection(R, worldPos, cubeCenterPos, boxHalfSize);
|
||||
R = fixedR.xyz;
|
||||
|
||||
vec3 envmap = SampleEnvironmentSpecular(cc_environment, lightingData, cc_ambientGround.w).xyz * cc_ambientSky.w;
|
||||
vec3 envmap = vec3(0.0);
|
||||
#if CC_USE_IBL
|
||||
envmap = SampleEnvironmentSpecular(cc_environment, lightingData, cc_ambientGround.w).xyz * cc_ambientSky.w;
|
||||
#endif
|
||||
#if CC_SURFACES_LIGHTING_ANISOTROPIC && CC_SURFACES_LIGHTING_ANISOTROPIC_ENVCONVOLUTION_COUNT
|
||||
envSpec = EnvAnisotropicReflection(tex, fixedR.xyz, roughness, mipCount, lightingData.anisotropyShape, lightingData.V, lightingData.N, lightingData.T, lightingData.B);
|
||||
#if CC_USE_REFLECTION_PROBE == REFLECTION_PROBE_TYPE_CUBE
|
||||
@@ -159,7 +162,9 @@ vec3 CalculateEnvironmentSpecular(in LightingIntermediateData lightingData, floa
|
||||
|
||||
#if CC_USE_REFLECTION_PROBE == REFLECTION_PROBE_TYPE_CUBE
|
||||
if(FSInput_reflectionProbeId < 0.0){
|
||||
#if CC_USE_IBL
|
||||
envSpec = SampleEnvironmentSpecular(cc_environment, lightingData, cc_ambientGround.w);
|
||||
#endif
|
||||
}else{
|
||||
vec3 centerPos, boxHalfSize;
|
||||
float mipCount;
|
||||
@@ -181,7 +186,9 @@ vec3 CalculateEnvironmentSpecular(in LightingIntermediateData lightingData, floa
|
||||
}
|
||||
#elif CC_USE_REFLECTION_PROBE == REFLECTION_PROBE_TYPE_BLEND || CC_USE_REFLECTION_PROBE == REFLECTION_PROBE_TYPE_BLEND_AND_SKYBOX
|
||||
if(FSInput_reflectionProbeId < 0.0){
|
||||
#if CC_USE_IBL
|
||||
envSpec = SampleEnvironmentSpecular(cc_environment, lightingData, cc_ambientGround.w);
|
||||
#endif
|
||||
}else{
|
||||
vec3 centerPos, boxHalfSize;
|
||||
float mipCount;
|
||||
@@ -197,7 +204,10 @@ vec3 CalculateEnvironmentSpecular(in LightingIntermediateData lightingData, floa
|
||||
|
||||
if(FSInput_reflectionProbeBlendId < 0.0)
|
||||
{
|
||||
vec3 skyBoxEnv = SampleEnvironmentSpecular(cc_environment, lightingData, cc_ambientGround.w).rgb * lightIntensity;
|
||||
vec3 skyBoxEnv = vec3(0.0);
|
||||
#if CC_USE_IBL
|
||||
skyBoxEnv = SampleEnvironmentSpecular(cc_environment, lightingData, cc_ambientGround.w).rgb * lightIntensity;
|
||||
#endif
|
||||
#if CC_USE_REFLECTION_PROBE == REFLECTION_PROBE_TYPE_BLEND_AND_SKYBOX
|
||||
//blend with skybox
|
||||
envSpec = mix(envSpec, skyBoxEnv, blendFactor);
|
||||
|
||||
@@ -434,7 +434,8 @@ export class BuiltinForwardPassBuilder implements rendering.PipelinePassBuilder
|
||||
// Reflection Probe
|
||||
cameraConfigs.enablePlanarReflectionProbe = cameraConfigs.isMainGameWindow
|
||||
|| camera.cameraUsage === CameraUsage.SCENE_VIEW
|
||||
|| camera.cameraUsage === CameraUsage.GAME_VIEW;
|
||||
|| camera.cameraUsage === CameraUsage.GAME_VIEW
|
||||
|| camera.cameraUsage === CameraUsage.PREVIEW;
|
||||
|
||||
// MSAA
|
||||
cameraConfigs.enableMSAA = cameraConfigs.settings.msaa.enabled
|
||||
@@ -551,7 +552,7 @@ export class BuiltinForwardPassBuilder implements rendering.PipelinePassBuilder
|
||||
ppl, camera, pplConfigs.mobileMaxSpotLightShadowMaps);
|
||||
}
|
||||
|
||||
this._tryAddReflectionProbePasses(ppl, cameraConfigs, id, mainLight, camera.scene);
|
||||
this._tryAddReflectionProbePasses(ppl, cameraConfigs, id, mainLight, camera.scene, camera);
|
||||
|
||||
if (cameraConfigs.remainingPasses > 0 || cameraConfigs.enableShadingScale) {
|
||||
context.colorName = cameraConfigs.enableShadingScale
|
||||
@@ -630,6 +631,7 @@ export class BuiltinForwardPassBuilder implements rendering.PipelinePassBuilder
|
||||
id: number,
|
||||
mainLight: renderer.scene.DirectionalLight | null,
|
||||
scene: renderer.RenderScene | null,
|
||||
sourceCamera: renderer.scene.Camera,
|
||||
): void {
|
||||
const reflectionProbeManager = cclegacy.internal.reflectionProbeManager as ReflectionProbeManager | undefined;
|
||||
if (!reflectionProbeManager) {
|
||||
@@ -651,6 +653,10 @@ export class BuiltinForwardPassBuilder implements rendering.PipelinePassBuilder
|
||||
if (!cameraConfigs.enablePlanarReflectionProbe) {
|
||||
continue;
|
||||
}
|
||||
let reflectionCamera = probe.camera;
|
||||
if (EDITOR && sourceCamera.cameraUsage === CameraUsage.PREVIEW) {
|
||||
reflectionCamera = probe.renderPreviewPlanarReflection(sourceCamera);
|
||||
}
|
||||
const window: renderer.RenderWindow = probe.realtimePlanarTexture!.window!;
|
||||
const colorName = `PlanarProbeRT${probeID}`;
|
||||
const depthStencilName = `PlanarProbeDS${probeID}`;
|
||||
@@ -663,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, probe.camera,
|
||||
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);
|
||||
@@ -680,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;
|
||||
}
|
||||
@@ -696,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;
|
||||
@@ -743,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,
|
||||
|
||||
@@ -298,7 +298,7 @@ module.exports = link(mixin({
|
||||
illuminance: 'Illuminance of the light',
|
||||
luminous_power: 'Luminous power of the light',
|
||||
luminance: 'Luminance of the light',
|
||||
visibility: 'Visibility mask, declaring a set of node layers that will be visible to this valid punctual Light(Does not work with directional light)',
|
||||
visibility: 'Visibility mask, declaring a set of node layers that will be visible in the current light source',
|
||||
term: 'The photometric term currently being used',
|
||||
size: 'Size of the light',
|
||||
range: 'Range of the light',
|
||||
|
||||
@@ -288,7 +288,7 @@ module.exports = link(mixin({
|
||||
illuminance: '光源强度',
|
||||
luminous_flux: '光通量',
|
||||
luminance: '光亮度',
|
||||
visibility: '可见性掩码,声明在当前精确光源中可见的节点层级集合(对方向光不生效)',
|
||||
visibility: '可见性掩码,声明在当前光源中可见的节点层级集合',
|
||||
term: '当前使用的光度学计量单位',
|
||||
size: '光源大小',
|
||||
range: '光源范围',
|
||||
|
||||
@@ -1,5 +1,12 @@
|
||||
# ignore third_party code from clang-format checks
|
||||
./cocos/bindings/auto/*
|
||||
./cocos/base/std/**
|
||||
./cocos/cocos-version.h
|
||||
./cocos/editor-support/spine-wasm/**
|
||||
./cocos/editor-support/spine/**
|
||||
./cocos/gi/light-probe/predicates.cpp
|
||||
./cocos/gi/light-probe/tetgen.cpp
|
||||
./cocos/gi/light-probe/tetgen.h
|
||||
./cocos/platform/openharmony/napi/**
|
||||
./tools/**
|
||||
./vendor/**
|
||||
|
||||
@@ -40,16 +40,16 @@ int32_t sorting2DCount{0};
|
||||
|
||||
CC_FORCE_INLINE void fillIndexBuffers(RenderDrawInfo* drawInfo) { // NOLINT(readability-convert-member-functions-to-static)
|
||||
uint16_t* ib = drawInfo->getIDataBuffer();
|
||||
|
||||
|
||||
UIMeshBuffer* buffer = drawInfo->getMeshBuffer();
|
||||
uint32_t indexOffset = buffer->getIndexOffset();
|
||||
|
||||
|
||||
uint16_t* indexb = drawInfo->getIbBuffer();
|
||||
uint32_t indexCount = drawInfo->getIbCount();
|
||||
|
||||
|
||||
memcpy(&ib[indexOffset], indexb, indexCount * sizeof(uint16_t));
|
||||
indexOffset += indexCount;
|
||||
|
||||
|
||||
buffer->setIndexOffset(indexOffset);
|
||||
}
|
||||
|
||||
@@ -83,7 +83,7 @@ CC_FORCE_INLINE void fillColor(RenderEntity* entity, RenderDrawInfo* drawInfo) {
|
||||
uint32_t size = drawInfo->getVbCount() * stride;
|
||||
float* vbBuffer = drawInfo->getVbBuffer();
|
||||
Color temp = entity->getColor();
|
||||
|
||||
|
||||
uint32_t offset = 0;
|
||||
for (int i = 0; i < size; i += stride) {
|
||||
offset = i + 5;
|
||||
@@ -91,9 +91,9 @@ CC_FORCE_INLINE void fillColor(RenderEntity* entity, RenderDrawInfo* drawInfo) {
|
||||
// Spine set 'UIRenderer._useVertexOpacity = true', it uses RGBA32 (4 bytes) color and fills color in Skeleton._updateColor and spine/simple.ts assembler.
|
||||
// So for Spine rendering, it will never go here to fill color.
|
||||
vbBuffer[offset] = static_cast<float>(temp.r) / 255.0F;
|
||||
vbBuffer[offset+1] = static_cast<float>(temp.g) / 255.0F;
|
||||
vbBuffer[offset+2] = static_cast<float>(temp.b) / 255.0F;
|
||||
vbBuffer[offset+3] = entity->getOpacity();
|
||||
vbBuffer[offset + 1] = static_cast<float>(temp.g) / 255.0F;
|
||||
vbBuffer[offset + 2] = static_cast<float>(temp.b) / 255.0F;
|
||||
vbBuffer[offset + 3] = entity->getOpacity();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -110,7 +110,7 @@ Batcher2d::Batcher2d(Root* root)
|
||||
_root = root;
|
||||
_device = _root->getDevice();
|
||||
_stencilManager = StencilManager::getInstance();
|
||||
|
||||
|
||||
_recordedRendererInfoQueue.reserve(100);
|
||||
}
|
||||
|
||||
@@ -138,7 +138,7 @@ Batcher2d::~Batcher2d() { // NOLINT
|
||||
_maskAttributes.clear();
|
||||
}
|
||||
|
||||
ccstd::vector<RecordedRendererInfo> &Batcher2d::getRecordedRendererInfoQueue() {
|
||||
ccstd::vector<RecordedRendererInfo>& Batcher2d::getRecordedRendererInfoQueue() {
|
||||
return _recordedRendererInfoQueue;
|
||||
}
|
||||
|
||||
@@ -170,11 +170,11 @@ void Batcher2d::fillBuffersAndMergeBatches() {
|
||||
for (auto* rootNode : _rootNodeArr) {
|
||||
// _batches will add by generateBatch
|
||||
walk(rootNode, 1, false);
|
||||
|
||||
|
||||
if (ENABLE_SORTING_2D && sorting2DCount > 0) {
|
||||
flushRecordedUIRenderers();
|
||||
}
|
||||
|
||||
|
||||
generateBatch(_currEntity, _currDrawInfo);
|
||||
|
||||
auto* scene = rootNode->getScene()->getRenderScene();
|
||||
@@ -186,7 +186,7 @@ void Batcher2d::fillBuffersAndMergeBatches() {
|
||||
}
|
||||
}
|
||||
|
||||
void Batcher2d::handleUIRenderer(RenderEntity *entity) { // NOLINT(misc-no-recursion)
|
||||
void Batcher2d::handleUIRenderer(RenderEntity* entity) { // NOLINT(misc-no-recursion)
|
||||
uint32_t size = entity->getRenderDrawInfosSize();
|
||||
for (uint32_t i = 0; i < size; i++) {
|
||||
auto* drawInfo = entity->getRenderDrawInfoAt(i);
|
||||
@@ -195,25 +195,25 @@ void Batcher2d::handleUIRenderer(RenderEntity *entity) { // NOLINT(misc-no-recur
|
||||
entity->setVBColorDirty(false);
|
||||
}
|
||||
|
||||
int32_t Batcher2d::recordUIRenderer(RenderEntity *entity) {
|
||||
int32_t Batcher2d::recordUIRenderer(RenderEntity* entity) {
|
||||
if (!ENABLE_SORTING_2D) return -1;
|
||||
auto &queue = getRecordedRendererInfoQueue();
|
||||
auto &info = queue.emplace_back();
|
||||
auto& queue = getRecordedRendererInfoQueue();
|
||||
auto& info = queue.emplace_back();
|
||||
info.renderEntity = entity;
|
||||
return static_cast<int32_t>(queue.size() - 1);
|
||||
}
|
||||
|
||||
void Batcher2d::flushRecordedUIRenderers() { // NOLINT(misc-no-recursion)
|
||||
if (!ENABLE_SORTING_2D) return;
|
||||
auto &queue = getRecordedRendererInfoQueue();
|
||||
auto& queue = getRecordedRendererInfoQueue();
|
||||
if (queue.empty()) return;
|
||||
|
||||
std::stable_sort(queue.begin(), queue.end(), [](const auto &a, const auto &b){
|
||||
std::stable_sort(queue.begin(), queue.end(), [](const auto& a, const auto& b) {
|
||||
return a.renderEntity->getPriority() < b.renderEntity->getPriority();
|
||||
});
|
||||
|
||||
for (const auto &info : queue) {
|
||||
auto *entity = info.renderEntity;
|
||||
for (const auto& info : queue) {
|
||||
auto* entity = info.renderEntity;
|
||||
if (entity) {
|
||||
handleUIRenderer(entity);
|
||||
}
|
||||
@@ -227,13 +227,13 @@ void Batcher2d::walk(Node* node, float parentOpacity, bool parentColorDirty) { /
|
||||
}
|
||||
bool breakWalk = false;
|
||||
auto* entity = static_cast<RenderEntity*>(node->getUserData());
|
||||
|
||||
|
||||
const bool isCurrentColorDirty = node->_isColorDirty() || parentColorDirty;
|
||||
const float localOpacity = node->_getLocalOpacity();
|
||||
// Keep the same logic as which in batcher-2d.ts
|
||||
const float finalOpacity = parentOpacity * localOpacity * (entity ? entity->getColorAlpha() : 1.F);
|
||||
node->_setFinalOpacity(finalOpacity);
|
||||
|
||||
|
||||
const bool visible = math::isNotEqualF(finalOpacity, 0);
|
||||
|
||||
if (entity) {
|
||||
@@ -244,7 +244,7 @@ void Batcher2d::walk(Node* node, float parentOpacity, bool parentColorDirty) { /
|
||||
entity->setOpacity(finalOpacity);
|
||||
entity->setVBColorDirty(true);
|
||||
}
|
||||
|
||||
|
||||
if (ENABLE_SORTING_2D && sorting2DCount > 0) {
|
||||
if (entity->getIsMask()) {
|
||||
flushRecordedUIRenderers();
|
||||
@@ -257,7 +257,7 @@ void Batcher2d::walk(Node* node, float parentOpacity, bool parentColorDirty) { /
|
||||
handleUIRenderer(entity);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (entity->getRenderEntityType() == RenderEntityType::CROSSED) {
|
||||
breakWalk = true;
|
||||
}
|
||||
@@ -271,7 +271,7 @@ void Batcher2d::walk(Node* node, float parentOpacity, bool parentColorDirty) { /
|
||||
walk(child, thisOpacity, isCurrentColorDirty);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (isCurrentColorDirty) {
|
||||
node->_setColorDirty(false);
|
||||
}
|
||||
@@ -283,7 +283,7 @@ void Batcher2d::walk(Node* node, float parentOpacity, bool parentColorDirty) { /
|
||||
flushRecordedUIRenderers();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (visible && _stencilManager->getMaskStackSize() > 0) {
|
||||
handlePostRender(entity);
|
||||
}
|
||||
@@ -521,7 +521,7 @@ void Batcher2d::generateBatch(RenderEntity* entity, RenderDrawInfo* drawInfo) {
|
||||
curdrawBatch->setFirstIndex(indexOffset);
|
||||
curdrawBatch->setIndexCount(indexCount);
|
||||
curdrawBatch->fillPass(_currMaterial, depthStencil, dssHash);
|
||||
const auto &passes = curdrawBatch->getPasses();
|
||||
const auto& passes = curdrawBatch->getPasses();
|
||||
if (!passes.empty()) {
|
||||
const auto& pass = passes.at(0);
|
||||
if (entity->getUseLocal()) {
|
||||
@@ -695,6 +695,8 @@ void Batcher2d::reset() {
|
||||
_currSampler = nullptr;
|
||||
|
||||
// stencilManager
|
||||
_stencilManager->setMaskStackSize(0);
|
||||
_stencilManager->setStencilStage(static_cast<uint32_t>(StencilStage::DISABLED));
|
||||
}
|
||||
|
||||
void Batcher2d::insertMaskBatch(RenderEntity* entity) {
|
||||
|
||||
@@ -41,13 +41,13 @@ using UIMeshBufferArray = ccstd::vector<UIMeshBuffer*>;
|
||||
using UIMeshBufferMap = ccstd::unordered_map<uint16_t, UIMeshBufferArray>;
|
||||
|
||||
struct RecordedRendererInfo {
|
||||
RenderEntity *renderEntity{nullptr};
|
||||
RenderEntity* renderEntity{nullptr};
|
||||
};
|
||||
|
||||
class Batcher2d final {
|
||||
public:
|
||||
static void setSorting2DCount(int32_t v);
|
||||
|
||||
|
||||
Batcher2d();
|
||||
explicit Batcher2d(Root* root);
|
||||
~Batcher2d();
|
||||
@@ -87,10 +87,10 @@ private:
|
||||
void createClearModel();
|
||||
|
||||
gfx::DescriptorSet* getDescriptorSet(gfx::Texture* texture, gfx::Sampler* sampler, const gfx::DescriptorSetLayout* dsLayout);
|
||||
|
||||
ccstd::vector<RecordedRendererInfo> &getRecordedRendererInfoQueue();
|
||||
void handleUIRenderer(RenderEntity *entity);
|
||||
int32_t recordUIRenderer(RenderEntity *entity);
|
||||
|
||||
ccstd::vector<RecordedRendererInfo>& getRecordedRendererInfoQueue();
|
||||
void handleUIRenderer(RenderEntity* entity);
|
||||
int32_t recordUIRenderer(RenderEntity* entity);
|
||||
void flushRecordedUIRenderers();
|
||||
|
||||
StencilManager* _stencilManager{nullptr};
|
||||
@@ -103,7 +103,7 @@ private:
|
||||
// manage memory manually
|
||||
ccstd::vector<scene::DrawBatch2D*> _batches;
|
||||
memop::Pool<scene::DrawBatch2D> _drawBatchPool;
|
||||
|
||||
|
||||
ccstd::vector<RecordedRendererInfo> _recordedRendererInfoQueue;
|
||||
|
||||
// weak reference
|
||||
|
||||
@@ -24,8 +24,8 @@
|
||||
|
||||
#pragma once
|
||||
#include "2d/renderer/UIMeshBuffer.h"
|
||||
#include "base/Ptr.h"
|
||||
#include "base/Macros.h"
|
||||
#include "base/Ptr.h"
|
||||
#include "base/TypeDef.h"
|
||||
#include "bindings/utils/BindingUtils.h"
|
||||
#include "core/ArrayBuffer.h"
|
||||
@@ -115,7 +115,7 @@ public:
|
||||
inline void setIsMeshBuffer(bool isMeshBuffer) {
|
||||
_drawInfoAttrs._isMeshBuffer = isMeshBuffer ? 1 : 0;
|
||||
}
|
||||
|
||||
|
||||
inline bool isVertexPositionInWorld() const {
|
||||
return _drawInfoAttrs._isVertexPositionInWorld != 0;
|
||||
}
|
||||
@@ -262,9 +262,9 @@ private:
|
||||
struct DrawInfoAttrs {
|
||||
RenderDrawInfoType _drawInfoType{RenderDrawInfoType::COMP};
|
||||
bool _vertDirty{false};
|
||||
uint8_t _isMeshBuffer: 1;
|
||||
uint8_t _isVertexPositionInWorld: 1;
|
||||
uint8_t _padding: 6;
|
||||
uint8_t _isMeshBuffer : 1;
|
||||
uint8_t _isVertexPositionInWorld : 1;
|
||||
uint8_t _padding : 6;
|
||||
uint8_t _stride{0};
|
||||
uint16_t _bufferId{0};
|
||||
uint16_t _accId{0};
|
||||
|
||||
@@ -33,11 +33,11 @@ RenderEntity::RenderEntity(RenderEntityType type) : _renderEntityType(type) {
|
||||
} else {
|
||||
ccnew_placement(&_dynamicDrawInfos) ccstd::vector<RenderDrawInfo*>();
|
||||
}
|
||||
|
||||
|
||||
_entityAttrLayout.enabledIndex = 0;
|
||||
_entityAttrLayout.useLocal = 0;
|
||||
_entityAttrLayout.paddings = 0;
|
||||
|
||||
|
||||
_entitySharedBufferActor.initialize(&_entityAttrLayout, sizeof(EntityAttrLayout));
|
||||
}
|
||||
|
||||
|
||||
@@ -49,7 +49,7 @@ enum class MaskMode : uint8_t {
|
||||
MASK_NODE_INVERTED
|
||||
};
|
||||
|
||||
enum class FillColorType: uint8_t {
|
||||
enum class FillColorType : uint8_t {
|
||||
COLOR = 0,
|
||||
VERTEX,
|
||||
};
|
||||
@@ -62,9 +62,9 @@ struct EntityAttrLayout {
|
||||
uint8_t colorA{255};
|
||||
uint8_t maskMode{0};
|
||||
FillColorType fillColorType{FillColorType::COLOR};
|
||||
uint8_t enabledIndex: 1;
|
||||
uint8_t useLocal: 1;
|
||||
uint8_t paddings: 6;
|
||||
uint8_t enabledIndex : 1;
|
||||
uint8_t useLocal : 1;
|
||||
uint8_t paddings : 6;
|
||||
uint8_t paddings2{0};
|
||||
};
|
||||
|
||||
@@ -99,7 +99,7 @@ public:
|
||||
inline void setUseLocal(bool useLocal) {
|
||||
_entityAttrLayout.useLocal = useLocal;
|
||||
}
|
||||
|
||||
|
||||
inline FillColorType getFillColorType() const { return _entityAttrLayout.fillColorType; }
|
||||
|
||||
inline Node* getNode() const { return _node; }
|
||||
@@ -142,7 +142,7 @@ public:
|
||||
inline RenderDrawInfo* getRenderDrawInfoAt(uint32_t index) {
|
||||
return _renderEntityType == RenderEntityType::STATIC ? &(_staticDrawInfos[index]) : _dynamicDrawInfos[index];
|
||||
}
|
||||
|
||||
|
||||
inline uint32_t getPriority() const { return _entityAttrLayout.priority; }
|
||||
|
||||
private:
|
||||
@@ -152,7 +152,7 @@ private:
|
||||
|
||||
// weak reference
|
||||
Node* _renderTransform{nullptr};
|
||||
|
||||
|
||||
bindings::NativeMemorySharedToScriptActor _entitySharedBufferActor;
|
||||
|
||||
union {
|
||||
@@ -160,13 +160,13 @@ private:
|
||||
ccstd::vector<RenderDrawInfo*> _dynamicDrawInfos;
|
||||
};
|
||||
EntityAttrLayout _entityAttrLayout;
|
||||
|
||||
|
||||
StencilStage _stencilStage{StencilStage::DISABLED};
|
||||
RenderEntityType _renderEntityType{RenderEntityType::STATIC};
|
||||
uint8_t _staticDrawInfoSize{0};
|
||||
bool _vbColorDirty{true};
|
||||
uint8_t _paddings[1];
|
||||
|
||||
|
||||
float _opacity{1.0F};
|
||||
};
|
||||
|
||||
|
||||
@@ -23,12 +23,12 @@
|
||||
****************************************************************************/
|
||||
|
||||
#pragma once
|
||||
#include "base/Ptr.h"
|
||||
#include "base/Macros.h"
|
||||
#include "base/Ptr.h"
|
||||
#include "base/TypeDef.h"
|
||||
#include "renderer/gfx-base/GFXInputAssembler.h"
|
||||
#include "renderer/gfx-base/GFXDef-common.h"
|
||||
#include "renderer/gfx-base/GFXBuffer.h"
|
||||
#include "renderer/gfx-base/GFXDef-common.h"
|
||||
#include "renderer/gfx-base/GFXInputAssembler.h"
|
||||
|
||||
namespace cc {
|
||||
|
||||
|
||||
@@ -58,13 +58,13 @@ void UIModelProxy::activeSubModels() {
|
||||
auto* vertexBuffer = _device->createBuffer({
|
||||
gfx::BufferUsageBit::VERTEX | gfx::BufferUsageBit::TRANSFER_DST,
|
||||
gfx::MemoryUsageBit::DEVICE,
|
||||
65536 * _stride, // Uint16 can address 65536 vertices (indices 0–65535)
|
||||
65536 * _stride, // Uint16 can address 65536 vertices (indices 0–65535)
|
||||
_stride,
|
||||
});
|
||||
auto* indexBuffer = _device->createBuffer({
|
||||
gfx::BufferUsageBit::INDEX | gfx::BufferUsageBit::TRANSFER_DST,
|
||||
gfx::MemoryUsageBit::DEVICE,
|
||||
65536 * sizeof(uint16_t) * 2, // Uint16 can address 65536 vertices (indices 0–65535)
|
||||
65536 * sizeof(uint16_t) * 2, // Uint16 can address 65536 vertices (indices 0–65535)
|
||||
sizeof(uint16_t),
|
||||
});
|
||||
gfx::BufferList vbReference;
|
||||
@@ -133,8 +133,8 @@ void UIModelProxy::clear() {
|
||||
return;
|
||||
}
|
||||
const auto& subModels = _model->getSubModels();
|
||||
for (const auto &subModel : subModels) {
|
||||
auto *ia = subModel->getInputAssembler();
|
||||
for (const auto& subModel : subModels) {
|
||||
auto* ia = subModel->getInputAssembler();
|
||||
ia->setVertexCount(0);
|
||||
ia->setIndexCount(0);
|
||||
}
|
||||
|
||||
@@ -531,14 +531,14 @@ void Mesh::initialize() {
|
||||
uint32_t vertexCount = _struct.vertexBundles[prim.vertexBundelIndices[0]].view.count;
|
||||
#if CC_OPTIMIZE_MESH_DATA
|
||||
if (vertexCount <= 65536) { // Uint16 can address 65536 vertices (indices 0–65535)
|
||||
dstStride >>= 1; // Reduce to short.
|
||||
dstStride >>= 1; // Reduce to short.
|
||||
dstSize >>= 1;
|
||||
} else if (!gfxDevice->hasFeature(gfx::Feature::ELEMENT_INDEX_UINT)) {
|
||||
continue; // Ignore this primitive
|
||||
}
|
||||
#else
|
||||
if (!gfxDevice->hasFeature(gfx::Feature::ELEMENT_INDEX_UINT)) {
|
||||
if (vertexCount > 65536) { // Uint16 can address 65536 vertices (indices 0–65535)
|
||||
if (vertexCount > 65536) { // Uint16 can address 65536 vertices (indices 0–65535)
|
||||
CC_LOG_WARNING("Device does not support UINT element index type and vertexCount (%u) is larger than ushort", vertexCount);
|
||||
continue;
|
||||
}
|
||||
|
||||
@@ -222,13 +222,22 @@ Mesh::ICreateInfo MeshUtils::createMeshInfo(const IGeometry &geometry, const ccs
|
||||
// Fill index buffer.
|
||||
ArrayBuffer::Ptr indexBuffer;
|
||||
uint32_t idxCount = 0;
|
||||
const uint32_t idxStride = 2;
|
||||
uint32_t idxStride = 2;
|
||||
gfx::Format indexFormat = gfx::Format::R16UI;
|
||||
if (geometry.indices.has_value()) {
|
||||
const ccstd::vector<uint32_t> &indices = geometry.indices.value();
|
||||
uint32_t maxIndex = 0;
|
||||
for (uint32_t idx : indices) {
|
||||
maxIndex = std::max(maxIndex, idx);
|
||||
}
|
||||
if (maxIndex > std::numeric_limits<uint16_t>::max()) {
|
||||
idxStride = 4;
|
||||
indexFormat = gfx::Format::R32UI;
|
||||
}
|
||||
idxCount = static_cast<uint32_t>(indices.size());
|
||||
indexBuffer = ccnew ArrayBuffer(idxStride * idxCount);
|
||||
DataView indexBufferView(indexBuffer);
|
||||
writeBuffer(indexBufferView, indices, gfx::Format::R16UI);
|
||||
writeBuffer(indexBufferView, indices, indexFormat);
|
||||
}
|
||||
|
||||
// Create primitive.
|
||||
@@ -310,7 +319,7 @@ Mesh::ICreateInfo MeshUtils::createDynamicMeshInfo(const IDynamicGeometry &geome
|
||||
if (aOptions.has_value()) {
|
||||
options = aOptions.value();
|
||||
}
|
||||
|
||||
|
||||
gfx::AttributeList attributes;
|
||||
uint32_t stream = 0U;
|
||||
|
||||
|
||||
@@ -25,8 +25,8 @@
|
||||
|
||||
#define LOG_TAG "AudioDecoderSLES"
|
||||
|
||||
#include "base/Macros.h"
|
||||
#include "audio/android/AudioDecoderSLES.h"
|
||||
#include "base/Macros.h"
|
||||
#include "platform/FileUtils.h"
|
||||
|
||||
#include <mutex>
|
||||
|
||||
@@ -29,9 +29,9 @@
|
||||
#include <unistd.h>
|
||||
// for native asset manager
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
#include <android/asset_manager.h>
|
||||
#include <android/asset_manager_jni.h>
|
||||
#include <android/log.h>
|
||||
#include <android/asset_manager.h>
|
||||
#include <android/asset_manager_jni.h>
|
||||
#include <android/log.h>
|
||||
#endif
|
||||
|
||||
#include <sys/types.h>
|
||||
@@ -45,11 +45,11 @@
|
||||
#include "base/UTF8.h"
|
||||
#include "base/memory/Memory.h"
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
#include "platform/android/FileUtils-android.h"
|
||||
#include "platform/java/jni/JniHelper.h"
|
||||
#include "platform/java/jni/JniImp.h"
|
||||
#include "platform/android/FileUtils-android.h"
|
||||
#include "platform/java/jni/JniHelper.h"
|
||||
#include "platform/java/jni/JniImp.h"
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
#include "cocos/platform/openharmony/FileUtils-OpenHarmony.h"
|
||||
#include "cocos/platform/openharmony/FileUtils-OpenHarmony.h"
|
||||
#endif
|
||||
|
||||
#include "audio/android/AudioDecoder.h"
|
||||
@@ -68,20 +68,20 @@ namespace {
|
||||
AudioEngineImpl *gAudioImpl = nullptr;
|
||||
int outputSampleRate = 44100;
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
int bufferSizeInFrames = 192;
|
||||
int bufferSizeInFrames = 192;
|
||||
#endif
|
||||
|
||||
void getAudioInfo() {
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
JNIEnv * env = JniHelper::getEnv();
|
||||
jclass audioSystem = env->FindClass("android/media/AudioSystem");
|
||||
jmethodID method = env->GetStaticMethodID(audioSystem, "getPrimaryOutputSamplingRate", "()I");
|
||||
outputSampleRate = env->CallStaticIntMethod(audioSystem, method);
|
||||
method = env->GetStaticMethodID(audioSystem, "getPrimaryOutputFrameCount", "()I");
|
||||
bufferSizeInFrames = env->CallStaticIntMethod(audioSystem, method);
|
||||
JNIEnv *env = JniHelper::getEnv();
|
||||
jclass audioSystem = env->FindClass("android/media/AudioSystem");
|
||||
jmethodID method = env->GetStaticMethodID(audioSystem, "getPrimaryOutputSamplingRate", "()I");
|
||||
outputSampleRate = env->CallStaticIntMethod(audioSystem, method);
|
||||
method = env->GetStaticMethodID(audioSystem, "getPrimaryOutputFrameCount", "()I");
|
||||
bufferSizeInFrames = env->CallStaticIntMethod(audioSystem, method);
|
||||
#else
|
||||
// In openharmony, setting to 48K does not cause audio delays
|
||||
outputSampleRate = 48000;
|
||||
outputSampleRate = 48000;
|
||||
#endif
|
||||
}
|
||||
} // namespace
|
||||
@@ -123,8 +123,8 @@ static int fdGetter(const ccstd::string &url, off_t *start, off_t *length) {
|
||||
AAsset_close(asset);
|
||||
}
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
FileUtilsOpenHarmony* fileUtils = dynamic_cast<FileUtilsOpenHarmony*>(FileUtils::getInstance());
|
||||
if(fileUtils) {
|
||||
FileUtilsOpenHarmony *fileUtils = dynamic_cast<FileUtilsOpenHarmony *>(FileUtils::getInstance());
|
||||
if (fileUtils) {
|
||||
RawFileDescriptor64 descriptor;
|
||||
fileUtils->getRawFileDescriptor(url, descriptor);
|
||||
fd = descriptor.fd;
|
||||
@@ -189,27 +189,27 @@ bool AudioEngineImpl::init() {
|
||||
CC_LOG_ERROR("get the engine interface fail");
|
||||
break;
|
||||
}
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
// create output mix
|
||||
const SLInterfaceID outputMixIIDs[] = {};
|
||||
const SLboolean outputMixReqs[] = {};
|
||||
result = (*_engineEngine)->CreateOutputMix(_engineEngine, &_outputMixObject, 0, outputMixIIDs, outputMixReqs);
|
||||
if (SL_RESULT_SUCCESS != result) {
|
||||
CC_LOG_ERROR("create output mix fail");
|
||||
break;
|
||||
}
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
// create output mix
|
||||
const SLInterfaceID outputMixIIDs[] = {};
|
||||
const SLboolean outputMixReqs[] = {};
|
||||
result = (*_engineEngine)->CreateOutputMix(_engineEngine, &_outputMixObject, 0, outputMixIIDs, outputMixReqs);
|
||||
if (SL_RESULT_SUCCESS != result) {
|
||||
CC_LOG_ERROR("create output mix fail");
|
||||
break;
|
||||
}
|
||||
|
||||
// realize the output mix
|
||||
result = (*_outputMixObject)->Realize(_outputMixObject, SL_BOOLEAN_FALSE);
|
||||
if (SL_RESULT_SUCCESS != result) {
|
||||
CC_LOG_ERROR("realize the output mix fail");
|
||||
break;
|
||||
}
|
||||
// realize the output mix
|
||||
result = (*_outputMixObject)->Realize(_outputMixObject, SL_BOOLEAN_FALSE);
|
||||
if (SL_RESULT_SUCCESS != result) {
|
||||
CC_LOG_ERROR("realize the output mix fail");
|
||||
break;
|
||||
}
|
||||
|
||||
_audioPlayerProvider = ccnew AudioPlayerProvider(_engineEngine, _outputMixObject, outputSampleRate, bufferSizeInFrames, fdGetter, &gCallerThreadUtils);
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
_audioPlayerProvider = ccnew AudioPlayerProvider(_engineEngine, outputSampleRate, fdGetter, &gCallerThreadUtils);
|
||||
#endif
|
||||
_audioPlayerProvider = ccnew AudioPlayerProvider(_engineEngine, _outputMixObject, outputSampleRate, bufferSizeInFrames, fdGetter, &gCallerThreadUtils);
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
_audioPlayerProvider = ccnew AudioPlayerProvider(_engineEngine, outputSampleRate, fdGetter, &gCallerThreadUtils);
|
||||
#endif
|
||||
ret = true;
|
||||
} while (false);
|
||||
|
||||
@@ -227,14 +227,14 @@ int AudioEngineImpl::play2d(const ccstd::string &filePath, bool loop, float volu
|
||||
auto audioId = AudioEngine::INVALID_AUDIO_ID;
|
||||
|
||||
do {
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
if (_engineEngine == nullptr || _audioPlayerProvider == nullptr) {
|
||||
break;
|
||||
}
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
if (_audioPlayerProvider == nullptr)
|
||||
break;
|
||||
#endif
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
if (_engineEngine == nullptr || _audioPlayerProvider == nullptr) {
|
||||
break;
|
||||
}
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
if (_audioPlayerProvider == nullptr)
|
||||
break;
|
||||
#endif
|
||||
|
||||
auto fullPath = FileUtils::getInstance()->fullPathForFilename(filePath);
|
||||
|
||||
@@ -443,12 +443,12 @@ PCMHeader AudioEngineImpl::getPCMHeader(const char *url) {
|
||||
CC_LOG_DEBUG("file %s pcm data already cached", url);
|
||||
return header;
|
||||
}
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
AudioDecoder *decoder = AudioDecoderProvider::createAudioDecoder(_engineEngine, fileFullPath, bufferSizeInFrames, outputSampleRate, fdGetter);
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
AudioDecoder *decoder = AudioDecoderProvider::createAudioDecoder(
|
||||
_engineEngine, fileFullPath, _audioPlayerProvider->getBufferSizeInFrames(), outputSampleRate, fdGetter);
|
||||
#endif
|
||||
#endif
|
||||
if (decoder == nullptr) {
|
||||
CC_LOG_DEBUG("decode %s failed, the file formate might not support", url);
|
||||
return header;
|
||||
@@ -482,12 +482,12 @@ ccstd::vector<uint8_t> AudioEngineImpl::getOriginalPCMBuffer(const char *url, ui
|
||||
if (_audioPlayerProvider->getPcmData(url, data)) {
|
||||
CC_LOG_DEBUG("file %s pcm data already cached", url);
|
||||
} else {
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
AudioDecoder *decoder = AudioDecoderProvider::createAudioDecoder(_engineEngine, fileFullPath, bufferSizeInFrames, outputSampleRate, fdGetter);
|
||||
#else
|
||||
#else
|
||||
AudioDecoder *decoder = AudioDecoderProvider::createAudioDecoder(
|
||||
_engineEngine, fileFullPath, _audioPlayerProvider->getBufferSizeInFrames(), outputSampleRate, fdGetter);
|
||||
#endif
|
||||
#endif
|
||||
if (decoder == nullptr) {
|
||||
CC_LOG_DEBUG("decode %s failed, the file formate might not support", url);
|
||||
return pcmData;
|
||||
|
||||
@@ -26,9 +26,9 @@
|
||||
|
||||
#include <SLES/OpenSLES.h>
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
#include <SLES/OpenSLES_Android.h>
|
||||
#include <SLES/OpenSLES_Android.h>
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
#include <SLES/OpenSLES_Platform.h>
|
||||
#include <SLES/OpenSLES_Platform.h>
|
||||
#endif
|
||||
#include <functional>
|
||||
#include "audio/include/AudioDef.h"
|
||||
|
||||
@@ -17,9 +17,9 @@
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
#include <sys/types.h>
|
||||
#include <pthread.h>
|
||||
#include <sys/types.h>
|
||||
#include <cstdint>
|
||||
|
||||
#include "audio/android/AudioBufferProvider.h"
|
||||
#include "audio/android/AudioResamplerPublic.h"
|
||||
@@ -160,7 +160,7 @@ private:
|
||||
struct track_t;
|
||||
|
||||
typedef void (*hook_t)(track_t *t, int32_t *output, size_t numOutFrames, int32_t *temp, int32_t *aux); //NOLINT(modernize-use-using)
|
||||
static const int BLOCKSIZE = 16; // 4 cache lines
|
||||
static const int BLOCKSIZE = 16; // 4 cache lines
|
||||
|
||||
struct track_t {
|
||||
uint32_t needs;
|
||||
@@ -288,19 +288,19 @@ private:
|
||||
};
|
||||
|
||||
// bitmask of allocated track names, where bit 0 corresponds to TRACK0 etc.
|
||||
uint32_t mTrackNames;// NOLINT(readability-identifier-naming)
|
||||
uint32_t mTrackNames; // NOLINT(readability-identifier-naming)
|
||||
|
||||
// bitmask of configured track names; ~0 if maxNumTracks == MAX_NUM_TRACKS,
|
||||
// but will have fewer bits set if maxNumTracks < MAX_NUM_TRACKS
|
||||
const uint32_t mConfiguredNames;// NOLINT(readability-identifier-naming)
|
||||
const uint32_t mConfiguredNames; // NOLINT(readability-identifier-naming)
|
||||
|
||||
const uint32_t mSampleRate;// NOLINT(readability-identifier-naming)
|
||||
const uint32_t mSampleRate; // NOLINT(readability-identifier-naming)
|
||||
|
||||
//cjh NBLog::Writer mDummyLog;
|
||||
public:
|
||||
//cjh void setLog(NBLog::Writer* log);
|
||||
private:
|
||||
state_t mState __attribute__((aligned(32)));// NOLINT(readability-identifier-naming)
|
||||
state_t mState __attribute__((aligned(32))); // NOLINT(readability-identifier-naming)
|
||||
|
||||
// Call after changing either the enabled status of a track, or parameters of an enabled track.
|
||||
// OK to call more often than that, but unnecessary.
|
||||
@@ -309,19 +309,19 @@ private:
|
||||
bool setChannelMasks(int name,
|
||||
audio_channel_mask_t trackChannelMask, audio_channel_mask_t mixerChannelMask);
|
||||
|
||||
static void track__genericResample(track_t *t, int32_t *out, size_t numFrames, int32_t *temp, int32_t *aux);// NOLINT(bugprone-reserved-identifier, readability-identifier-naming)
|
||||
static void track__nop(track_t *t, int32_t *out, size_t numFrames, int32_t *temp, int32_t *aux);// NOLINT(bugprone-reserved-identifier, readability-identifier-naming)
|
||||
static void track__16BitsStereo(track_t *t, int32_t *out, size_t numFrames, int32_t *temp, int32_t *aux);// NOLINT(bugprone-reserved-identifier, readability-identifier-naming)
|
||||
static void track__16BitsMono(track_t *t, int32_t *out, size_t numFrames, int32_t *temp, int32_t *aux);// NOLINT(bugprone-reserved-identifier, readability-identifier-naming)
|
||||
static void track__genericResample(track_t *t, int32_t *out, size_t numFrames, int32_t *temp, int32_t *aux); // NOLINT(bugprone-reserved-identifier, readability-identifier-naming)
|
||||
static void track__nop(track_t *t, int32_t *out, size_t numFrames, int32_t *temp, int32_t *aux); // NOLINT(bugprone-reserved-identifier, readability-identifier-naming)
|
||||
static void track__16BitsStereo(track_t *t, int32_t *out, size_t numFrames, int32_t *temp, int32_t *aux); // NOLINT(bugprone-reserved-identifier, readability-identifier-naming)
|
||||
static void track__16BitsMono(track_t *t, int32_t *out, size_t numFrames, int32_t *temp, int32_t *aux); // NOLINT(bugprone-reserved-identifier, readability-identifier-naming)
|
||||
static void volumeRampStereo(track_t *t, int32_t *out, size_t frameCount, int32_t *temp, int32_t *aux);
|
||||
static void volumeStereo(track_t *t, int32_t *out, size_t frameCount, int32_t *temp,
|
||||
int32_t *aux);
|
||||
|
||||
static void process__validate(state_t *state, int64_t pts);// NOLINT(bugprone-reserved-identifier, readability-identifier-naming)
|
||||
static void process__nop(state_t *state, int64_t pts);// NOLINT(bugprone-reserved-identifier, readability-identifier-naming)
|
||||
static void process__genericNoResampling(state_t *state, int64_t pts);// NOLINT(bugprone-reserved-identifier, readability-identifier-naming)
|
||||
static void process__genericResampling(state_t *state, int64_t pts);// NOLINT(bugprone-reserved-identifier, readability-identifier-naming)
|
||||
static void process__OneTrack16BitsStereoNoResampling(state_t *state, int64_t pts);// NOLINT(bugprone-reserved-identifier, readability-identifier-naming)
|
||||
static void process__validate(state_t *state, int64_t pts); // NOLINT(bugprone-reserved-identifier, readability-identifier-naming)
|
||||
static void process__nop(state_t *state, int64_t pts); // NOLINT(bugprone-reserved-identifier, readability-identifier-naming)
|
||||
static void process__genericNoResampling(state_t *state, int64_t pts); // NOLINT(bugprone-reserved-identifier, readability-identifier-naming)
|
||||
static void process__genericResampling(state_t *state, int64_t pts); // NOLINT(bugprone-reserved-identifier, readability-identifier-naming)
|
||||
static void process__OneTrack16BitsStereoNoResampling(state_t *state, int64_t pts); // NOLINT(bugprone-reserved-identifier, readability-identifier-naming)
|
||||
|
||||
static int64_t calculateOutputPTS(const track_t &t, int64_t basePTS,
|
||||
int outputFrameIndex);
|
||||
@@ -347,11 +347,11 @@ private:
|
||||
|
||||
// multi-format process hooks
|
||||
template <int MIXTYPE, typename TO, typename TI, typename TA>
|
||||
static void process_NoResampleOneTrack(state_t *state, int64_t pts);// NOLINT(bugprone-reserved-identifier, readability-identifier-naming)
|
||||
static void process_NoResampleOneTrack(state_t *state, int64_t pts); // NOLINT(bugprone-reserved-identifier, readability-identifier-naming)
|
||||
|
||||
// multi-format track hooks
|
||||
template <int MIXTYPE, typename TO, typename TI, typename TA>
|
||||
static void track__Resample(track_t *t, TO *out, size_t frameCount, TO *temp __unused, TA *aux);// NOLINT(bugprone-reserved-identifier, readability-identifier-naming)
|
||||
static void track__Resample(track_t *t, TO *out, size_t frameCount, TO *temp __unused, TA *aux); // NOLINT(bugprone-reserved-identifier, readability-identifier-naming)
|
||||
template <int MIXTYPE, typename TO, typename TI, typename TA>
|
||||
static void track__NoResample(track_t *t, TO *out, size_t frameCount, TO *temp __unused, TA *aux); // NOLINT(bugprone-reserved-identifier, readability-identifier-naming)
|
||||
|
||||
|
||||
@@ -33,8 +33,8 @@
|
||||
#include "base/std/container/vector.h"
|
||||
|
||||
#if CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
// for openharmony platform, buffer size is 4458 in normal latency mode, 240 in fast latency mode
|
||||
#define MAX_AUDIO_BUFFER_SIZE 4458
|
||||
// for openharmony platform, buffer size is 4458 in normal latency mode, 240 in fast latency mode
|
||||
#define MAX_AUDIO_BUFFER_SIZE 4458
|
||||
#endif
|
||||
|
||||
namespace cc {
|
||||
|
||||
@@ -42,14 +42,14 @@
|
||||
#include "base/ThreadPool.h"
|
||||
#include "base/memory/Memory.h"
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
#include <sys/system_properties.h>
|
||||
#include "audio/android/UrlAudioPlayer.h"
|
||||
#include "audio/android/PcmAudioService.h"
|
||||
#include <sys/system_properties.h>
|
||||
#include "audio/android/PcmAudioService.h"
|
||||
#include "audio/android/UrlAudioPlayer.h"
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
#include "cocos/platform/FileUtils.h"
|
||||
#include "cocos/platform/openharmony/FileUtils-OpenHarmony.h"
|
||||
#include "audio/openharmony/UrlAudioPlayer.h"
|
||||
#include "audio/openharmony/PcmAudioService.h"
|
||||
#include "audio/openharmony/PcmAudioService.h"
|
||||
#include "audio/openharmony/UrlAudioPlayer.h"
|
||||
#include "cocos/platform/FileUtils.h"
|
||||
#include "cocos/platform/openharmony/FileUtils-OpenHarmony.h"
|
||||
#endif
|
||||
#include <algorithm> // for std::find_if
|
||||
#include <cstdlib>
|
||||
@@ -107,12 +107,9 @@ AudioPlayerProvider::AudioPlayerProvider(SLEngineItf engineItf, SLObjectItf outp
|
||||
}
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
AudioPlayerProvider::AudioPlayerProvider(SLEngineItf engineItf, int deviceSampleRate,
|
||||
const FdGetterCallback &fdGetterCallback,
|
||||
const FdGetterCallback &fdGetterCallback,
|
||||
ICallerThreadUtils *callerThreadUtils)
|
||||
: _engineItf(engineItf), _deviceSampleRate(deviceSampleRate), _fdGetterCallback(fdGetterCallback),
|
||||
_callerThreadUtils(callerThreadUtils), _pcmAudioService(nullptr),
|
||||
_mixController(nullptr), _threadPool(LegacyThreadPool::newCachedThreadPool(1, 8, 5, 2, 2))
|
||||
{
|
||||
: _engineItf(engineItf), _deviceSampleRate(deviceSampleRate), _fdGetterCallback(fdGetterCallback), _callerThreadUtils(callerThreadUtils), _pcmAudioService(nullptr), _mixController(nullptr), _threadPool(LegacyThreadPool::newCachedThreadPool(1, 8, 5, 2, 2)) {
|
||||
_mixController = ccnew AudioMixerController(_deviceSampleRate, 2);
|
||||
_pcmAudioService = ccnew PcmAudioService();
|
||||
_pcmAudioService->init(_mixController, 2, deviceSampleRate, &_bufferSizeInFrames);
|
||||
@@ -364,13 +361,13 @@ AudioPlayerProvider::AudioFileInfo AudioPlayerProvider::getFileInfo(
|
||||
fileSize = length;
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
RawFileDescriptor64 descriptor;
|
||||
FileUtilsOpenHarmony* fileUtils = static_cast<FileUtilsOpenHarmony*>(FileUtils::getInstance());
|
||||
if(!fileUtils) {
|
||||
FileUtilsOpenHarmony *fileUtils = static_cast<FileUtilsOpenHarmony *>(FileUtils::getInstance());
|
||||
if (!fileUtils) {
|
||||
return info;
|
||||
}
|
||||
FileUtils::Status status = fileUtils->getRawFileDescriptor(audioFilePath, descriptor);
|
||||
|
||||
if(status != FileUtils::Status::OK || descriptor.fd<= 0) {
|
||||
if (status != FileUtils::Status::OK || descriptor.fd <= 0) {
|
||||
ALOGE("Failed to open file descriptor for %s", audioFilePath.c_str());
|
||||
return info;
|
||||
}
|
||||
@@ -412,9 +409,9 @@ bool AudioPlayerProvider::isSmallFile(const AudioFileInfo &info) { //NOLINT(read
|
||||
extension = audioFileInfo.url.substr(pos);
|
||||
}
|
||||
auto *iter = std::find_if(std::begin(gAudioFileIndicator), std::end(gAudioFileIndicator),
|
||||
[&extension](const AudioFileIndicator &judge) -> bool {
|
||||
return judge.extension == extension;
|
||||
});
|
||||
[&extension](const AudioFileIndicator &judge) -> bool {
|
||||
return judge.extension == extension;
|
||||
});
|
||||
|
||||
if (iter != std::end(gAudioFileIndicator)) {
|
||||
// ALOGV("isSmallFile: found: %s: ", iter->extension.c_str());
|
||||
@@ -472,19 +469,18 @@ UrlAudioPlayer *AudioPlayerProvider::createUrlAudioPlayer(
|
||||
}
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
SLuint32 locatorType = info.assetFd->getFd() > 0 ? SL_DATALOCATOR_ANDROIDFD : SL_DATALOCATOR_URI;
|
||||
auto *urlPlayer = new (std::nothrow) UrlAudioPlayer(_engineItf, _outputMixObject, _callerThreadUtils);
|
||||
bool ret = urlPlayer->prepare(info.url, locatorType, info.assetFd, info.start, info.length);
|
||||
auto *urlPlayer = new (std::nothrow) UrlAudioPlayer(_engineItf, _outputMixObject, _callerThreadUtils);
|
||||
bool ret = urlPlayer->prepare(info.url, locatorType, info.assetFd, info.start, info.length);
|
||||
if (!ret) {
|
||||
SL_SAFE_DELETE(urlPlayer);
|
||||
}
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
auto urlPlayer = new (std::nothrow) UrlAudioPlayer(_callerThreadUtils);
|
||||
bool ret = urlPlayer->prepare(info.url, info.assetFd, info.start, info.length);
|
||||
if (!ret)
|
||||
{
|
||||
if (urlPlayer != nullptr) {
|
||||
if (!ret) {
|
||||
if (urlPlayer != nullptr) {
|
||||
delete urlPlayer;
|
||||
urlPlayer = nullptr;
|
||||
urlPlayer = nullptr;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -18,9 +18,9 @@
|
||||
|
||||
#include <cstdint>
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
#include <android/log.h>
|
||||
#include <sys/system_properties.h>
|
||||
#include <sys/types.h>
|
||||
#include <android/log.h>
|
||||
#include <sys/system_properties.h>
|
||||
#include <sys/types.h>
|
||||
#endif
|
||||
|
||||
#include "audio/android/AudioBufferProvider.h"
|
||||
@@ -108,21 +108,20 @@ protected:
|
||||
|
||||
int64_t calculateOutputPTS(int outputFrameIndex);
|
||||
|
||||
|
||||
const int32_t mChannelCount;// NOLINT(readability-identifier-naming)
|
||||
const int32_t mSampleRate;// NOLINT(readability-identifier-naming)
|
||||
int32_t mInSampleRate;// NOLINT(readability-identifier-naming)
|
||||
AudioBufferProvider::Buffer mBuffer;// NOLINT(readability-identifier-naming)
|
||||
const int32_t mChannelCount; // NOLINT(readability-identifier-naming)
|
||||
const int32_t mSampleRate; // NOLINT(readability-identifier-naming)
|
||||
int32_t mInSampleRate; // NOLINT(readability-identifier-naming)
|
||||
AudioBufferProvider::Buffer mBuffer; // NOLINT(readability-identifier-naming)
|
||||
union {
|
||||
int16_t mVolume[2];// NOLINT(readability-identifier-naming)
|
||||
uint32_t mVolumeRL;// NOLINT(readability-identifier-naming)
|
||||
int16_t mVolume[2]; // NOLINT(readability-identifier-naming)
|
||||
uint32_t mVolumeRL; // NOLINT(readability-identifier-naming)
|
||||
};
|
||||
int16_t mTargetVolume[2];// NOLINT(readability-identifier-naming)
|
||||
size_t mInputIndex;// NOLINT(readability-identifier-naming)
|
||||
int32_t mPhaseIncrement;// NOLINT(readability-identifier-naming)
|
||||
uint32_t mPhaseFraction;// NOLINT(readability-identifier-naming)
|
||||
uint64_t mLocalTimeFreq;// NOLINT(readability-identifier-naming)
|
||||
int64_t mPTS;// NOLINT(readability-identifier-naming)
|
||||
int16_t mTargetVolume[2]; // NOLINT(readability-identifier-naming)
|
||||
size_t mInputIndex; // NOLINT(readability-identifier-naming)
|
||||
int32_t mPhaseIncrement; // NOLINT(readability-identifier-naming)
|
||||
uint32_t mPhaseFraction; // NOLINT(readability-identifier-naming)
|
||||
uint64_t mLocalTimeFreq; // NOLINT(readability-identifier-naming)
|
||||
int64_t mPTS; // NOLINT(readability-identifier-naming)
|
||||
|
||||
// returns the inFrameCount required to generate outFrameCount frames.
|
||||
//
|
||||
@@ -155,7 +154,7 @@ protected:
|
||||
return (static_cast<size_t>(outFrameCount) * mInSampleRate + (mSampleRate - 1)) / mSampleRate;
|
||||
}
|
||||
|
||||
inline float clampFloatVol(float volume) {//NOLINT(readability-identifier-naming, readability-convert-member-functions-to-static)
|
||||
inline float clampFloatVol(float volume) { //NOLINT(readability-identifier-naming, readability-convert-member-functions-to-static)
|
||||
float ret = 0.0F;
|
||||
if (volume > UNITY_GAIN_FLOAT) {
|
||||
ret = UNITY_GAIN_FLOAT;
|
||||
@@ -166,7 +165,7 @@ protected:
|
||||
}
|
||||
|
||||
private:
|
||||
const src_quality mQuality;// NOLINT(readability-identifier-naming)
|
||||
const src_quality mQuality; // NOLINT(readability-identifier-naming)
|
||||
|
||||
// Return 'true' if the quality level is supported without explicit request
|
||||
static bool qualityIsSupported(src_quality quality);
|
||||
|
||||
@@ -19,8 +19,8 @@
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
#include "audio/android/AudioResampler.h"
|
||||
#include "audio/android/AudioBufferProvider.h"
|
||||
#include "audio/android/AudioResampler.h"
|
||||
|
||||
namespace cc {
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
@@ -29,9 +29,9 @@
|
||||
|
||||
#include <SLES/OpenSLES.h>
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
#include <SLES/OpenSLES_Android.h>
|
||||
#include <SLES/OpenSLES_Android.h>
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
#include <SLES/OpenSLES_Platform.h>
|
||||
#include <SLES/OpenSLES_Platform.h>
|
||||
#endif
|
||||
|
||||
#include <functional>
|
||||
|
||||
@@ -25,28 +25,28 @@
|
||||
|
||||
#define LOG_TAG "PcmAudioService"
|
||||
|
||||
#include "base/Macros.h"
|
||||
#include "audio/android/PcmAudioService.h"
|
||||
#include "audio/android/AudioMixerController.h"
|
||||
#include "audio/android/utils/Compat.h"
|
||||
#include "base/Macros.h"
|
||||
|
||||
namespace cc {
|
||||
|
||||
static ccstd::vector<char> __silenceData;//NOLINT(bugprone-reserved-identifier, readability-identifier-naming)
|
||||
static ccstd::vector<char> __silenceData; //NOLINT(bugprone-reserved-identifier, readability-identifier-naming)
|
||||
|
||||
#define AUDIO_PLAYER_BUFFER_COUNT (2)
|
||||
|
||||
class SLPcmAudioPlayerCallbackProxy {
|
||||
public:
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
static void samplePlayerCallback(CCSLBufferQueueItf bq, void *context) {
|
||||
static void samplePlayerCallback(CCSLBufferQueueItf bq, void *context){
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
static void samplePlayerCallback(CCSLBufferQueueItf bq, void *context, SLuint32 size) {
|
||||
#endif
|
||||
auto *thiz = reinterpret_cast<PcmAudioService *>(context);
|
||||
thiz->bqFetchBufferCallback(bq);
|
||||
}
|
||||
};
|
||||
thiz->bqFetchBufferCallback(bq);
|
||||
}
|
||||
}; // namespace cc
|
||||
|
||||
PcmAudioService::PcmAudioService(SLEngineItf engineItf, SLObjectItf outputMixObject)
|
||||
: _engineItf(engineItf), _outputMixObj(outputMixObject), _playObj(nullptr), _playItf(nullptr), _volumeItf(nullptr), _bufferQueueItf(nullptr), _numChannels(-1), _sampleRate(-1), _bufferSizeInBytes(0), _controller(nullptr) {
|
||||
@@ -59,12 +59,12 @@ PcmAudioService::~PcmAudioService() {
|
||||
}
|
||||
|
||||
bool PcmAudioService::enqueue() {
|
||||
#if CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
// We need to call this interface in openharmony, otherwise there will be noise
|
||||
SLuint8 *buffer = nullptr;
|
||||
SLuint32 size = 0;
|
||||
(*_bufferQueueItf)->GetBuffer(_bufferQueueItf, &buffer, &size);
|
||||
#endif
|
||||
#if CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
// We need to call this interface in openharmony, otherwise there will be noise
|
||||
SLuint8 *buffer = nullptr;
|
||||
SLuint32 size = 0;
|
||||
(*_bufferQueueItf)->GetBuffer(_bufferQueueItf, &buffer, &size);
|
||||
#endif
|
||||
if (_controller->hasPlayingTacks()) {
|
||||
if (_controller->isPaused()) {
|
||||
SLresult r = (*_bufferQueueItf)->Enqueue(_bufferQueueItf, __silenceData.data(), __silenceData.size());
|
||||
@@ -141,7 +141,7 @@ bool PcmAudioService::init(AudioMixerController *controller, int numChannels, in
|
||||
|
||||
SLresult r;
|
||||
|
||||
r = (*_engineItf)->CreateAudioPlayer(_engineItf, &_playObj, &source, &sink, sizeof(ids) / sizeof(ids[0]), ids, req);//NOLINT(bugprone-sizeof-expression)
|
||||
r = (*_engineItf)->CreateAudioPlayer(_engineItf, &_playObj, &source, &sink, sizeof(ids) / sizeof(ids[0]), ids, req); //NOLINT(bugprone-sizeof-expression)
|
||||
SL_RETURN_VAL_IF_FAILED(r, false, "CreateAudioPlayer failed");
|
||||
|
||||
r = (*_playObj)->Realize(_playObj, SL_BOOLEAN_FALSE);
|
||||
@@ -162,12 +162,12 @@ bool PcmAudioService::init(AudioMixerController *controller, int numChannels, in
|
||||
if (__silenceData.empty()) {
|
||||
__silenceData.resize(_numChannels * _bufferSizeInBytes, 0x00);
|
||||
}
|
||||
#if CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
// We need to call this interface in openharmony, otherwise there will be noise
|
||||
SLuint8 *buffer = nullptr;
|
||||
SLuint32 size = 0;
|
||||
(*_bufferQueueItf)->GetBuffer(_bufferQueueItf, &buffer, &size);
|
||||
#endif
|
||||
#if CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
// We need to call this interface in openharmony, otherwise there will be noise
|
||||
SLuint8 *buffer = nullptr;
|
||||
SLuint32 size = 0;
|
||||
(*_bufferQueueItf)->GetBuffer(_bufferQueueItf, &buffer, &size);
|
||||
#endif
|
||||
r = (*_bufferQueueItf)->Enqueue(_bufferQueueItf, __silenceData.data(), __silenceData.size());
|
||||
SL_RETURN_VAL_IF_FAILED(r, false, "_bufferQueueItf Enqueue failed");
|
||||
|
||||
|
||||
@@ -26,17 +26,17 @@
|
||||
#define LOG_TAG "UrlAudioPlayer"
|
||||
|
||||
#include "audio/android/UrlAudioPlayer.h"
|
||||
#include "audio/android/ICallerThreadUtils.h"
|
||||
#include "base/std/container/vector.h"
|
||||
#include "base/Macros.h"
|
||||
#include <cmath>
|
||||
#include <algorithm> // for std::find
|
||||
#include <cmath>
|
||||
#include "audio/android/ICallerThreadUtils.h"
|
||||
#include "base/Macros.h"
|
||||
#include "base/std/container/vector.h"
|
||||
|
||||
namespace {
|
||||
|
||||
std::mutex __playerContainerMutex;//NOLINT(bugprone-reserved-identifier,readability-identifier-naming)
|
||||
ccstd::vector<cc::UrlAudioPlayer *> __playerContainer;//NOLINT(bugprone-reserved-identifier,readability-identifier-naming)
|
||||
std::once_flag __onceFlag;//NOLINT(bugprone-reserved-identifier,readability-identifier-naming)
|
||||
std::mutex __playerContainerMutex; //NOLINT(bugprone-reserved-identifier,readability-identifier-naming)
|
||||
ccstd::vector<cc::UrlAudioPlayer *> __playerContainer; //NOLINT(bugprone-reserved-identifier,readability-identifier-naming)
|
||||
std::once_flag __onceFlag; //NOLINT(bugprone-reserved-identifier,readability-identifier-naming)
|
||||
|
||||
} // namespace
|
||||
|
||||
@@ -216,7 +216,7 @@ float UrlAudioPlayer::getDuration() const {
|
||||
|
||||
if (duration == SL_TIME_UNKNOWN) {
|
||||
return -1.0F;
|
||||
} else {// NOLINT(readability-else-after-return)
|
||||
} else { // NOLINT(readability-else-after-return)
|
||||
const_cast<UrlAudioPlayer *>(this)->_duration = duration / 1000.0F;
|
||||
|
||||
if (_duration <= 0) {
|
||||
|
||||
@@ -22,10 +22,10 @@
|
||||
#include <strings.h>
|
||||
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
#include <sys/cdefs.h>
|
||||
#include <sys/cdefs.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
@@ -41,7 +41,7 @@ static inline int popcountll(unsigned long long x) {
|
||||
return __builtin_popcountll(x);
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
@@ -34,10 +34,10 @@
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
#include <android/log.h>
|
||||
#include <android/log.h>
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
#include <hilog/log.h>
|
||||
#define LOG_VERBOSE LOG_INFO
|
||||
#include <hilog/log.h>
|
||||
#define LOG_VERBOSE LOG_INFO
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
@@ -90,11 +90,11 @@ extern "C" {
|
||||
* Simplified macro to send a verbose log message using the current LOG_TAG.
|
||||
*/
|
||||
#ifndef ALOGV
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
#define __ALOGV(...) ((void)ALOG(LOG_VERBOSE, LOG_TAG, __VA_ARGS__))
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
#define __ALOGV(...) ((void)ALOG(LOG_INFO, LOG_TAG, __VA_ARGS__))
|
||||
#endif
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
#define __ALOGV(...) ((void)ALOG(LOG_VERBOSE, LOG_TAG, __VA_ARGS__))
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
#define __ALOGV(...) ((void)ALOG(LOG_INFO, LOG_TAG, __VA_ARGS__))
|
||||
#endif
|
||||
#if LOG_NDEBUG
|
||||
#define ALOGV(...) \
|
||||
do { \
|
||||
@@ -413,23 +413,23 @@ extern "C" {
|
||||
* is -inverted- from the normal assert() semantics.
|
||||
*/
|
||||
#ifndef LOG_ALWAYS_FATAL_IF
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
#define LOG_ALWAYS_FATAL_IF(cond, ...) \
|
||||
((__predict_false(cond)) \
|
||||
? ((void)android_printAssert(#cond, LOG_TAG, ##__VA_ARGS__)) \
|
||||
: (void)0)
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
#define LOG_ALWAYS_FATAL_IF(cond, ...) ((void)0 )
|
||||
#endif
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
#define LOG_ALWAYS_FATAL_IF(cond, ...) \
|
||||
((__predict_false(cond)) \
|
||||
? ((void)android_printAssert(#cond, LOG_TAG, ##__VA_ARGS__)) \
|
||||
: (void)0)
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
#define LOG_ALWAYS_FATAL_IF(cond, ...) ((void)0)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef LOG_ALWAYS_FATAL
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
#define LOG_ALWAYS_FATAL(...) \
|
||||
(((void)android_printAssert(NULL, LOG_TAG, ##__VA_ARGS__)))
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
#define LOG_ALWAYS_FATAL(...) ((void) OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_DOMAIN, "HMG_LOG", __VA_ARGS__))
|
||||
#endif
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
#define LOG_ALWAYS_FATAL(...) \
|
||||
(((void)android_printAssert(NULL, LOG_TAG, ##__VA_ARGS__)))
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
#define LOG_ALWAYS_FATAL(...) ((void)OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_DOMAIN, "HMG_LOG", __VA_ARGS__))
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/*
|
||||
@@ -476,26 +476,25 @@ extern "C" {
|
||||
* The second argument may be NULL or "" to indicate the "global" tag.
|
||||
*/
|
||||
#ifndef ALOG
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
#define ALOG(priority, tag, ...) \
|
||||
LOG_PRI(ANDROID_##priority, tag, __VA_ARGS__)
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
#define ALOG(priority, tag, ...) \
|
||||
LOG_PRI(priority, tag, __VA_ARGS__)
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
#define ALOG(priority, tag, ...) \
|
||||
LOG_PRI(ANDROID_##priority, tag, __VA_ARGS__)
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
#define ALOG(priority, tag, ...) \
|
||||
LOG_PRI(priority, tag, __VA_ARGS__)
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
* Log macro that allows you to specify a number for the priority.
|
||||
*/
|
||||
#ifndef LOG_PRI
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
#define LOG_PRI(priority, tag, ...) \
|
||||
android_printLog(priority, tag, __VA_ARGS__)
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
#define LOG_PRI(priority, tag, ...) ((void) OH_LOG_Print(LOG_APP, priority, LOG_DOMAIN, "HMG_LOG", __VA_ARGS__))
|
||||
#endif
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
#define LOG_PRI(priority, tag, ...) \
|
||||
android_printLog(priority, tag, __VA_ARGS__)
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
#define LOG_PRI(priority, tag, ...) ((void)OH_LOG_Print(LOG_APP, priority, LOG_DOMAIN, "HMG_LOG", __VA_ARGS__))
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/*
|
||||
|
||||
@@ -17,16 +17,15 @@
|
||||
#ifndef COCOS_LIB_UTILS_COMPAT_H
|
||||
#define COCOS_LIB_UTILS_COMPAT_H
|
||||
|
||||
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
#include <unistd.h>
|
||||
#include <SLES/OpenSLES.h>
|
||||
#include <SLES/OpenSLES_Android.h>
|
||||
#include <SLES/OpenSLES.h>
|
||||
#include <SLES/OpenSLES_Android.h>
|
||||
#include <unistd.h>
|
||||
#elif CC_PLATFORM == CC_PLATFORM_WINDOWS
|
||||
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
#include <SLES/OpenSLES_OpenHarmony.h>
|
||||
#include <SLES/OpenSLES_Platform.h>
|
||||
#include <SLES/OpenSLES_OpenHarmony.h>
|
||||
#include <SLES/OpenSLES_Platform.h>
|
||||
#endif
|
||||
|
||||
#if defined(__APPLE__)
|
||||
@@ -97,11 +96,11 @@ static inline ssize_t pwrite64(int fd, const void *buf, size_t nbytes, off64_t o
|
||||
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
typedef SLAndroidSimpleBufferQueueItf CCSLBufferQueueItf;
|
||||
#define CC_SL_IDD_BUFFER_QUEUE SL_IID_ANDROIDSIMPLEBUFFERQUEUE
|
||||
#define CC_SL_IDD_BUFFER_QUEUE SL_IID_ANDROIDSIMPLEBUFFERQUEUE
|
||||
#elif CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
typedef SLOHBufferQueueItf CCSLBufferQueueItf;
|
||||
#define CC_SL_IDD_BUFFER_QUEUE SL_IID_OH_BUFFERQUEUE
|
||||
#define __unused
|
||||
#define CC_SL_IDD_BUFFER_QUEUE SL_IID_OH_BUFFERQUEUE
|
||||
#define __unused
|
||||
#endif
|
||||
|
||||
#endif /* COCOS_LIB_UTILS_COMPAT_H */
|
||||
|
||||
@@ -17,8 +17,8 @@
|
||||
#ifndef COCOS_ERRORS_H
|
||||
#define COCOS_ERRORS_H
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <errno.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
namespace cc {
|
||||
|
||||
|
||||
@@ -27,8 +27,8 @@
|
||||
|
||||
#import <OpenAL/al.h>
|
||||
|
||||
#include <mutex>
|
||||
#include <functional>
|
||||
#include <mutex>
|
||||
#include "base/std/container/string.h"
|
||||
|
||||
#include "audio/apple/AudioMacros.h"
|
||||
|
||||
@@ -19,7 +19,7 @@
|
||||
|
||||
#include <stdint.h>
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
#include <sys/cdefs.h>
|
||||
#include <sys/cdefs.h>
|
||||
#endif
|
||||
|
||||
#include "audio/android/audio.h"
|
||||
|
||||
@@ -25,7 +25,7 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
#include <sys/cdefs.h>
|
||||
#include <sys/cdefs.h>
|
||||
#endif
|
||||
|
||||
/* The memcpy_* conversion routines are designed to work in-place on same dst as src
|
||||
|
||||
@@ -178,7 +178,7 @@ bool AudioEngineImpl::init() {
|
||||
|
||||
alcMakeContextCurrent(sALContext);
|
||||
|
||||
std::fill(std::begin(_alSources), std::end(_alSources), 0);
|
||||
std::fill(std::begin(_alSources), std::end(_alSources), 0);
|
||||
|
||||
alGenSources(MAX_AUDIOINSTANCES, _alSources);
|
||||
auto alError = alGetError();
|
||||
|
||||
@@ -26,9 +26,9 @@ THE SOFTWARE.
|
||||
#define LOG_TAG "PcmAudioService"
|
||||
|
||||
#include "audio/openharmony/PcmAudioService.h"
|
||||
#include <deviceinfo.h>
|
||||
#include "audio/android/AudioMixerController.h"
|
||||
#include "audio/android/cutils/log.h"
|
||||
#include <deviceinfo.h>
|
||||
|
||||
namespace cc {
|
||||
|
||||
@@ -106,10 +106,10 @@ bool PcmAudioService::init(AudioMixerController *controller, int numChannels, in
|
||||
|
||||
OH_AudioRenderer_Callbacks callbacks;
|
||||
static int sdkApi = OH_GetSdkApiVersion();
|
||||
if(sdkApi >= 21) {
|
||||
if (sdkApi >= 21) {
|
||||
callbacks.OH_AudioRenderer_OnWriteData = nullptr;
|
||||
} else {
|
||||
callbacks.OH_AudioRenderer_OnWriteData = reinterpret_cast<int32_t (*)(OH_AudioRenderer*,void* ,void* ,int32_t)>(AudioRendererOnWriteData);
|
||||
callbacks.OH_AudioRenderer_OnWriteData = reinterpret_cast<int32_t (*)(OH_AudioRenderer *, void *, void *, int32_t)>(AudioRendererOnWriteData);
|
||||
}
|
||||
callbacks.OH_AudioRenderer_OnInterruptEvent = AudioRendererOnInterrupt;
|
||||
callbacks.OH_AudioRenderer_OnError = nullptr;
|
||||
@@ -118,9 +118,9 @@ bool PcmAudioService::init(AudioMixerController *controller, int numChannels, in
|
||||
if (ret != AUDIOSTREAM_SUCCESS) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if(sdkApi >= 21) {
|
||||
ret = OH_AudioStreamBuilder_SetRendererWriteDataCallback(_builder, AudioRendererOnWriteData, this);
|
||||
|
||||
if (sdkApi >= 21) {
|
||||
ret = OH_AudioStreamBuilder_SetRendererWriteDataCallback(_builder, AudioRendererOnWriteData, this);
|
||||
if (ret != AUDIOSTREAM_SUCCESS) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -26,8 +26,8 @@ THE SOFTWARE.
|
||||
#define LOG_TAG "UrlAudioPlayer"
|
||||
|
||||
#include "audio/openharmony/UrlAudioPlayer.h"
|
||||
#include <map>
|
||||
#include <algorithm> // for std::find
|
||||
#include <map>
|
||||
#include "audio/android/ICallerThreadUtils.h"
|
||||
#include "audio/android/cutils/log.h"
|
||||
#include "cocos/application/ApplicationManager.h"
|
||||
|
||||
+12
-12
@@ -209,23 +209,23 @@ void Log::logMessage(LogType type, LogLevel level, const char *formats, ...) {
|
||||
::LogLevel ohosLoglevel = ::LogLevel::LOG_DEBUG;
|
||||
switch (level) {
|
||||
case LogLevel::LEVEL_DEBUG:
|
||||
ohosLoglevel = ::LogLevel::LOG_DEBUG;
|
||||
break;
|
||||
ohosLoglevel = ::LogLevel::LOG_DEBUG;
|
||||
break;
|
||||
case LogLevel::INFO:
|
||||
ohosLoglevel = ::LogLevel::LOG_INFO;
|
||||
break;
|
||||
ohosLoglevel = ::LogLevel::LOG_INFO;
|
||||
break;
|
||||
case LogLevel::WARN:
|
||||
ohosLoglevel = ::LogLevel::LOG_WARN;
|
||||
break;
|
||||
ohosLoglevel = ::LogLevel::LOG_WARN;
|
||||
break;
|
||||
case LogLevel::ERR:
|
||||
ohosLoglevel = ::LogLevel::LOG_ERROR;
|
||||
break;
|
||||
ohosLoglevel = ::LogLevel::LOG_ERROR;
|
||||
break;
|
||||
case LogLevel::FATAL:
|
||||
ohosLoglevel = ::LogLevel::LOG_FATAL;
|
||||
break;
|
||||
ohosLoglevel = ::LogLevel::LOG_FATAL;
|
||||
break;
|
||||
default:
|
||||
ohosLoglevel = ::LogLevel::LOG_INFO;
|
||||
break;
|
||||
ohosLoglevel = ::LogLevel::LOG_INFO;
|
||||
break;
|
||||
}
|
||||
OH_LOG_Print(LOG_APP, ohosLoglevel, LOG_DOMAIN, "HMG_LOG", "%{public}s", buff);
|
||||
#else
|
||||
|
||||
@@ -346,7 +346,7 @@ void Scheduler::runFunctionsToBePerformedInCocosThread() {
|
||||
// fixed #4123: Save the callback functions, they must be invoked after '_performMutex.unlock()', otherwise if new functions are added in callback, it will cause thread deadlock.
|
||||
auto temp = std::move(_functionsToPerform);
|
||||
_performMutex.unlock();
|
||||
|
||||
|
||||
auto iter = temp.begin();
|
||||
for (; iter != temp.end(); ++iter) {
|
||||
nowTime = std::chrono::steady_clock::now();
|
||||
@@ -355,10 +355,10 @@ void Scheduler::runFunctionsToBePerformedInCocosThread() {
|
||||
if (passedMS > 16) {
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
(*iter)();
|
||||
}
|
||||
|
||||
|
||||
std::lock_guard<std::mutex> lk(_performMutex);
|
||||
_functionsToPerform.insert(_functionsToPerform.begin(), std::make_move_iterator(iter), std::make_move_iterator(temp.end()));
|
||||
}
|
||||
|
||||
@@ -268,7 +268,7 @@ public:
|
||||
* @js NA
|
||||
*/
|
||||
void removeAllFunctionsToBePerformedInCocosThread();
|
||||
|
||||
|
||||
void runFunctionsToBePerformedInCocosThread();
|
||||
|
||||
bool isCurrentTargetSalvaged() const { return _currentTargetSalvaged; };
|
||||
|
||||
+25
-25
@@ -42,38 +42,38 @@ using index_t = int32_t;
|
||||
#define CC_ENUM_CONVERSION_OPERATOR(T) \
|
||||
inline std::underlying_type_t<T> toNumber(const T v) { return static_cast<std::underlying_type_t<T>>(v); }
|
||||
|
||||
#define CC_ENUM_BITWISE_OPERATORS(T) \
|
||||
constexpr bool operator!(const T v) { return !static_cast<std::underlying_type_t<T>>(v); } \
|
||||
constexpr T operator~(const T v) { return static_cast<T>(~static_cast<std::underlying_type_t<T>>(v)); } \
|
||||
#define CC_ENUM_BITWISE_OPERATORS(T) \
|
||||
constexpr bool operator!(const T v) { return !static_cast<std::underlying_type_t<T>>(v); } \
|
||||
constexpr T operator~(const T v) { return static_cast<T>(~static_cast<std::underlying_type_t<T>>(v)); } \
|
||||
constexpr bool operator||(const T lhs, const T rhs) { return (static_cast<std::underlying_type_t<T>>(lhs) || static_cast<std::underlying_type_t<T>>(rhs)); } \
|
||||
constexpr bool operator&&(const T lhs, const T rhs) { return (static_cast<std::underlying_type_t<T>>(lhs) && static_cast<std::underlying_type_t<T>>(rhs)); } \
|
||||
constexpr T operator|(const T lhs, const T rhs) { return static_cast<T>(static_cast<std::underlying_type_t<T>>(lhs) | static_cast<std::underlying_type_t<T>>(rhs)); } \
|
||||
constexpr T operator&(const T lhs, const T rhs) { return static_cast<T>(static_cast<std::underlying_type_t<T>>(lhs) & static_cast<std::underlying_type_t<T>>(rhs)); } \
|
||||
constexpr T operator^(const T lhs, const T rhs) { return static_cast<T>(static_cast<std::underlying_type_t<T>>(lhs) ^ static_cast<std::underlying_type_t<T>>(rhs)); } \
|
||||
constexpr T operator+(const T lhs, const T rhs) { return static_cast<T>(static_cast<std::underlying_type_t<T>>(lhs) + static_cast<std::underlying_type_t<T>>(rhs)); } \
|
||||
constexpr T operator+(const T lhs, bool rhs) { return static_cast<T>(static_cast<std::underlying_type_t<T>>(lhs) + rhs); } \
|
||||
constexpr T operator+(const T lhs, bool rhs) { return static_cast<T>(static_cast<std::underlying_type_t<T>>(lhs) + rhs); } \
|
||||
constexpr void operator|=(T &lhs, const T rhs) { lhs = static_cast<T>(static_cast<std::underlying_type_t<T>>(lhs) | static_cast<std::underlying_type_t<T>>(rhs)); } \
|
||||
constexpr void operator&=(T &lhs, const T rhs) { lhs = static_cast<T>(static_cast<std::underlying_type_t<T>>(lhs) & static_cast<std::underlying_type_t<T>>(rhs)); } \
|
||||
constexpr void operator^=(T &lhs, const T rhs) { lhs = static_cast<T>(static_cast<std::underlying_type_t<T>>(lhs) ^ static_cast<std::underlying_type_t<T>>(rhs)); } \
|
||||
constexpr bool hasFlag(const T flags, const T flagToTest) { \
|
||||
using ValueType = std::underlying_type_t<T>; \
|
||||
CC_ASSERT((static_cast<ValueType>(flagToTest) & (static_cast<ValueType>(flagToTest) - 1)) == 0); \
|
||||
return (static_cast<ValueType>(flags) & static_cast<ValueType>(flagToTest)) != 0; \
|
||||
} \
|
||||
constexpr bool hasAnyFlags(const T flags, const T flagsToTest) { \
|
||||
using ValueType = std::underlying_type_t<T>; \
|
||||
return (static_cast<ValueType>(flags) & static_cast<ValueType>(flagsToTest)) != 0; \
|
||||
} \
|
||||
constexpr bool hasAllFlags(const T flags, const T flagsToTest) { \
|
||||
using ValueType = std::underlying_type_t<T>; \
|
||||
return (static_cast<ValueType>(flags) & static_cast<ValueType>(flagsToTest)) == static_cast<ValueType>(flagsToTest); \
|
||||
} \
|
||||
constexpr T addFlags(T &flags, const T flagsToAdd) { \
|
||||
flags |= flagsToAdd; \
|
||||
return flags; \
|
||||
} \
|
||||
constexpr T removeFlags(T &flags, const T flagsToRemove) { \
|
||||
flags &= ~flagsToRemove; \
|
||||
return flags; \
|
||||
} \
|
||||
constexpr bool hasFlag(const T flags, const T flagToTest) { \
|
||||
using ValueType = std::underlying_type_t<T>; \
|
||||
CC_ASSERT((static_cast<ValueType>(flagToTest) & (static_cast<ValueType>(flagToTest) - 1)) == 0); \
|
||||
return (static_cast<ValueType>(flags) & static_cast<ValueType>(flagToTest)) != 0; \
|
||||
} \
|
||||
constexpr bool hasAnyFlags(const T flags, const T flagsToTest) { \
|
||||
using ValueType = std::underlying_type_t<T>; \
|
||||
return (static_cast<ValueType>(flags) & static_cast<ValueType>(flagsToTest)) != 0; \
|
||||
} \
|
||||
constexpr bool hasAllFlags(const T flags, const T flagsToTest) { \
|
||||
using ValueType = std::underlying_type_t<T>; \
|
||||
return (static_cast<ValueType>(flags) & static_cast<ValueType>(flagsToTest)) == static_cast<ValueType>(flagsToTest); \
|
||||
} \
|
||||
constexpr T addFlags(T &flags, const T flagsToAdd) { \
|
||||
flags |= flagsToAdd; \
|
||||
return flags; \
|
||||
} \
|
||||
constexpr T removeFlags(T &flags, const T flagsToRemove) { \
|
||||
flags &= ~flagsToRemove; \
|
||||
return flags; \
|
||||
} \
|
||||
CC_ENUM_CONVERSION_OPERATOR(T)
|
||||
|
||||
@@ -34,8 +34,8 @@
|
||||
#include "ConvertUTF/ConvertUTF.h"
|
||||
|
||||
#if CC_USE_SIMD_UTF
|
||||
#include "simdutf/simdutf.cpp" //NOLINT
|
||||
#include "simdutf/simdutf.h"
|
||||
#include "simdutf/simdutf.cpp" //NOLINT
|
||||
#include "simdutf/simdutf.h"
|
||||
#endif
|
||||
|
||||
#include "base/Log.h"
|
||||
|
||||
@@ -24,8 +24,8 @@
|
||||
|
||||
#include "MessageQueue.h"
|
||||
#include "AutoReleasePool.h"
|
||||
#include "base/Utils.h"
|
||||
#include "base/Log.h"
|
||||
#include "base/Utils.h"
|
||||
|
||||
#if CC_PLATFORM == CC_PLATFORM_ANDROID
|
||||
#include <unistd.h>
|
||||
|
||||
@@ -37,7 +37,7 @@ HandleObject::HandleObject(Object *obj)
|
||||
}
|
||||
}
|
||||
|
||||
HandleObject::HandleObject(HandleObject &&o) noexcept{
|
||||
HandleObject::HandleObject(HandleObject &&o) noexcept {
|
||||
_obj = o._obj;
|
||||
o._obj = nullptr;
|
||||
}
|
||||
@@ -49,7 +49,7 @@ HandleObject::~HandleObject() {
|
||||
}
|
||||
}
|
||||
|
||||
HandleObject& HandleObject::operator=(HandleObject &&o) noexcept {
|
||||
HandleObject &HandleObject::operator=(HandleObject &&o) noexcept {
|
||||
_obj = o._obj;
|
||||
o._obj = nullptr;
|
||||
return *this;
|
||||
|
||||
@@ -98,10 +98,10 @@ public:
|
||||
return (_obj == nullptr);
|
||||
}
|
||||
HandleObject(HandleObject &&) noexcept;
|
||||
HandleObject& operator=(HandleObject &&) noexcept;
|
||||
HandleObject &operator=(HandleObject &&) noexcept;
|
||||
|
||||
HandleObject(const HandleObject &) = delete;
|
||||
HandleObject& operator=(const HandleObject &) = delete;
|
||||
HandleObject &operator=(const HandleObject &) = delete;
|
||||
|
||||
void *operator new(size_t size) = delete;
|
||||
void operator delete(void *, size_t) = delete;
|
||||
|
||||
@@ -169,12 +169,12 @@ private:
|
||||
if (kls != nullptr && kls != itr->second->_getClass()) {
|
||||
continue;
|
||||
}
|
||||
// JS object may be null when it is obtained on zhe JSVM brach of the 5.1 ROMS
|
||||
#if SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_JSVM
|
||||
if(itr->second->_getJSObject() == nullptr) {
|
||||
continue;
|
||||
}
|
||||
#endif
|
||||
// JS object may be null when it is obtained on zhe JSVM brach of the 5.1 ROMS
|
||||
#if SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_JSVM
|
||||
if (itr->second->_getJSObject() == nullptr) {
|
||||
continue;
|
||||
}
|
||||
#endif
|
||||
eleCount++;
|
||||
CC_ASSERT_LT(eleCount, 2);
|
||||
eachCallback(itr->second);
|
||||
|
||||
@@ -43,12 +43,10 @@
|
||||
#include "chakracore/Object.h"
|
||||
#endif
|
||||
|
||||
|
||||
#if SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_NAPI
|
||||
#include "napi/Object.h"
|
||||
#endif
|
||||
|
||||
|
||||
#if SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_JSVM
|
||||
#include "jsvm/Object.h"
|
||||
#endif
|
||||
@@ -27,10 +27,10 @@
|
||||
#include <cmath>
|
||||
#include <memory>
|
||||
#include <type_traits>
|
||||
#include "base/HasMemberFunction.h"
|
||||
#include "base/Ptr.h"
|
||||
#include "base/RefCounted.h"
|
||||
#include "base/memory/Memory.h"
|
||||
#include "base/HasMemberFunction.h"
|
||||
|
||||
namespace se {
|
||||
|
||||
@@ -116,7 +116,7 @@ public:
|
||||
explicit CCIntrusivePtrPrivateObject(const cc::IntrusivePtr<T> &p) : _ptr(p) {}
|
||||
explicit CCIntrusivePtrPrivateObject(cc::IntrusivePtr<T> &&p) : _ptr(std::move(p)) {}
|
||||
~CCIntrusivePtrPrivateObject() override {
|
||||
if constexpr (cc::has_setScriptObject<T,void(se::Object *)>::value) {
|
||||
if constexpr (cc::has_setScriptObject<T, void(se::Object *)>::value) {
|
||||
_ptr->setScriptObject(nullptr);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -24,13 +24,13 @@
|
||||
****************************************************************************/
|
||||
|
||||
#include "Value.h"
|
||||
#include <cassert>
|
||||
#include <cctype>
|
||||
#include <cmath>
|
||||
#include <cstdint>
|
||||
#include <sstream>
|
||||
#include <type_traits>
|
||||
#include "Object.h"
|
||||
#include <cassert>
|
||||
|
||||
namespace se {
|
||||
|
||||
|
||||
@@ -36,11 +36,11 @@
|
||||
#define SCRIPT_ENGINE_JSVM 6
|
||||
|
||||
#ifndef SCRIPT_ENGINE_TYPE
|
||||
#if CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
#define SCRIPT_ENGINE_TYPE SCRIPT_ENGINE_NAPI
|
||||
#else
|
||||
#define SCRIPT_ENGINE_TYPE SCRIPT_ENGINE_V8
|
||||
#endif
|
||||
#if CC_PLATFORM == CC_PLATFORM_OPENHARMONY
|
||||
#define SCRIPT_ENGINE_TYPE SCRIPT_ENGINE_NAPI
|
||||
#else
|
||||
#define SCRIPT_ENGINE_TYPE SCRIPT_ENGINE_V8
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#define SE_LOG_TO_JS_ENV 0 // print log to JavaScript environment, for example DevTools
|
||||
@@ -65,9 +65,9 @@ CC_FORMAT_HINT(3, 4)
|
||||
void selogMessage(cc::LogLevel level, const char *tag, const char *format, ...);
|
||||
|
||||
#if CC_DEBUG
|
||||
#define SE_LOGD(...) selogMessage(cc::LogLevel::LEVEL_DEBUG, "D/", ##__VA_ARGS__)
|
||||
#define SE_LOGD(...) selogMessage(cc::LogLevel::LEVEL_DEBUG, "D/", ##__VA_ARGS__)
|
||||
#else
|
||||
#define SE_LOGD(...)
|
||||
#define SE_LOGD(...)
|
||||
#endif
|
||||
#define SE_LOGE(...) selogMessage(cc::LogLevel::ERR, "E/", ##__VA_ARGS__)
|
||||
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
|
||||
#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
|
||||
|
||||
#include "callback_queue.h"
|
||||
#include "callback_queue.h"
|
||||
|
||||
namespace node {
|
||||
|
||||
@@ -11,87 +11,87 @@ template <typename R, typename... Args>
|
||||
template <typename Fn>
|
||||
std::unique_ptr<typename CallbackQueue<R, Args...>::Callback>
|
||||
CallbackQueue<R, Args...>::CreateCallback(Fn&& fn, CallbackFlags::Flags flags) {
|
||||
return std::make_unique<CallbackImpl<Fn>>(std::move(fn), flags);
|
||||
return std::make_unique<CallbackImpl<Fn>>(std::move(fn), flags);
|
||||
}
|
||||
|
||||
template <typename R, typename... Args>
|
||||
std::unique_ptr<typename CallbackQueue<R, Args...>::Callback>
|
||||
CallbackQueue<R, Args...>::Shift() {
|
||||
std::unique_ptr<Callback> ret = std::move(head_);
|
||||
if (ret) {
|
||||
head_ = ret->get_next();
|
||||
if (!head_)
|
||||
tail_ = nullptr; // The queue is now empty.
|
||||
size_--;
|
||||
}
|
||||
return ret;
|
||||
std::unique_ptr<Callback> ret = std::move(head_);
|
||||
if (ret) {
|
||||
head_ = ret->get_next();
|
||||
if (!head_)
|
||||
tail_ = nullptr; // The queue is now empty.
|
||||
size_--;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
template <typename R, typename... Args>
|
||||
void CallbackQueue<R, Args...>::Push(std::unique_ptr<Callback> cb) {
|
||||
Callback* prev_tail = tail_;
|
||||
Callback* prev_tail = tail_;
|
||||
|
||||
size_++;
|
||||
tail_ = cb.get();
|
||||
if (prev_tail != nullptr)
|
||||
prev_tail->set_next(std::move(cb));
|
||||
else
|
||||
head_ = std::move(cb);
|
||||
size_++;
|
||||
tail_ = cb.get();
|
||||
if (prev_tail != nullptr)
|
||||
prev_tail->set_next(std::move(cb));
|
||||
else
|
||||
head_ = std::move(cb);
|
||||
}
|
||||
|
||||
template <typename R, typename... Args>
|
||||
void CallbackQueue<R, Args...>::ConcatMove(CallbackQueue<R, Args...>&& other) {
|
||||
size_ += other.size_;
|
||||
if (tail_ != nullptr)
|
||||
tail_->set_next(std::move(other.head_));
|
||||
else
|
||||
head_ = std::move(other.head_);
|
||||
tail_ = other.tail_;
|
||||
other.tail_ = nullptr;
|
||||
other.size_ = 0;
|
||||
size_ += other.size_;
|
||||
if (tail_ != nullptr)
|
||||
tail_->set_next(std::move(other.head_));
|
||||
else
|
||||
head_ = std::move(other.head_);
|
||||
tail_ = other.tail_;
|
||||
other.tail_ = nullptr;
|
||||
other.size_ = 0;
|
||||
}
|
||||
|
||||
template <typename R, typename... Args>
|
||||
size_t CallbackQueue<R, Args...>::size() const {
|
||||
return size_.load();
|
||||
return size_.load();
|
||||
}
|
||||
|
||||
template <typename R, typename... Args>
|
||||
CallbackQueue<R, Args...>::Callback::Callback(CallbackFlags::Flags flags)
|
||||
: flags_(flags) {}
|
||||
: flags_(flags) {}
|
||||
|
||||
template <typename R, typename... Args>
|
||||
CallbackFlags::Flags CallbackQueue<R, Args...>::Callback::flags() const {
|
||||
return flags_;
|
||||
return flags_;
|
||||
}
|
||||
|
||||
template <typename R, typename... Args>
|
||||
std::unique_ptr<typename CallbackQueue<R, Args...>::Callback>
|
||||
CallbackQueue<R, Args...>::Callback::get_next() {
|
||||
return std::move(next_);
|
||||
return std::move(next_);
|
||||
}
|
||||
|
||||
template <typename R, typename... Args>
|
||||
void CallbackQueue<R, Args...>::Callback::set_next(
|
||||
std::unique_ptr<Callback> next) {
|
||||
next_ = std::move(next);
|
||||
next_ = std::move(next);
|
||||
}
|
||||
|
||||
template <typename R, typename... Args>
|
||||
template <typename Fn>
|
||||
CallbackQueue<R, Args...>::CallbackImpl<Fn>::CallbackImpl(
|
||||
Fn&& callback, CallbackFlags::Flags flags)
|
||||
: Callback(flags),
|
||||
callback_(std::move(callback)) {}
|
||||
: Callback(flags),
|
||||
callback_(std::move(callback)) {}
|
||||
|
||||
template <typename R, typename... Args>
|
||||
template <typename Fn>
|
||||
R CallbackQueue<R, Args...>::CallbackImpl<Fn>::Call(Args... args) {
|
||||
return callback_(std::forward<Args>(args)...);
|
||||
return callback_(std::forward<Args>(args)...);
|
||||
}
|
||||
|
||||
} // namespace node
|
||||
} // namespace node
|
||||
|
||||
#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
|
||||
#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
|
||||
|
||||
#endif // SRC_CALLBACK_QUEUE_INL_H_
|
||||
#endif // SRC_CALLBACK_QUEUE_INL_H_
|
||||
|
||||
@@ -3,14 +3,14 @@
|
||||
|
||||
#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
|
||||
|
||||
#include <atomic>
|
||||
#include <atomic>
|
||||
|
||||
namespace node {
|
||||
|
||||
namespace CallbackFlags {
|
||||
enum Flags {
|
||||
kUnrefed = 0,
|
||||
kRefed = 1,
|
||||
kUnrefed = 0,
|
||||
kRefed = 1,
|
||||
};
|
||||
}
|
||||
|
||||
@@ -22,57 +22,57 @@ enum Flags {
|
||||
// should be run even if nothing else is keeping the event loop alive.
|
||||
template <typename R, typename... Args>
|
||||
class CallbackQueue {
|
||||
public:
|
||||
class Callback {
|
||||
public:
|
||||
explicit inline Callback(CallbackFlags::Flags flags);
|
||||
public:
|
||||
class Callback {
|
||||
public:
|
||||
explicit inline Callback(CallbackFlags::Flags flags);
|
||||
|
||||
virtual ~Callback() = default;
|
||||
virtual R Call(Args... args) = 0;
|
||||
virtual ~Callback() = default;
|
||||
virtual R Call(Args... args) = 0;
|
||||
|
||||
inline CallbackFlags::Flags flags() const;
|
||||
inline CallbackFlags::Flags flags() const;
|
||||
|
||||
private:
|
||||
inline std::unique_ptr<Callback> get_next();
|
||||
inline void set_next(std::unique_ptr<Callback> next);
|
||||
private:
|
||||
inline std::unique_ptr<Callback> get_next();
|
||||
inline void set_next(std::unique_ptr<Callback> next);
|
||||
|
||||
CallbackFlags::Flags flags_;
|
||||
std::unique_ptr<Callback> next_;
|
||||
CallbackFlags::Flags flags_;
|
||||
std::unique_ptr<Callback> next_;
|
||||
|
||||
friend class CallbackQueue;
|
||||
};
|
||||
friend class CallbackQueue;
|
||||
};
|
||||
|
||||
template <typename Fn>
|
||||
inline std::unique_ptr<Callback> CreateCallback(
|
||||
Fn&& fn, CallbackFlags::Flags);
|
||||
template <typename Fn>
|
||||
inline std::unique_ptr<Callback> CreateCallback(
|
||||
Fn&& fn, CallbackFlags::Flags);
|
||||
|
||||
inline std::unique_ptr<Callback> Shift();
|
||||
inline void Push(std::unique_ptr<Callback> cb);
|
||||
// ConcatMove adds elements from 'other' to the end of this list, and clears
|
||||
// 'other' afterwards.
|
||||
inline void ConcatMove(CallbackQueue&& other);
|
||||
inline std::unique_ptr<Callback> Shift();
|
||||
inline void Push(std::unique_ptr<Callback> cb);
|
||||
// ConcatMove adds elements from 'other' to the end of this list, and clears
|
||||
// 'other' afterwards.
|
||||
inline void ConcatMove(CallbackQueue&& other);
|
||||
|
||||
// size() is atomic and may be called from any thread.
|
||||
inline size_t size() const;
|
||||
// size() is atomic and may be called from any thread.
|
||||
inline size_t size() const;
|
||||
|
||||
private:
|
||||
template <typename Fn>
|
||||
class CallbackImpl final : public Callback {
|
||||
public:
|
||||
CallbackImpl(Fn&& callback, CallbackFlags::Flags flags);
|
||||
R Call(Args... args) override;
|
||||
private:
|
||||
template <typename Fn>
|
||||
class CallbackImpl final : public Callback {
|
||||
public:
|
||||
CallbackImpl(Fn&& callback, CallbackFlags::Flags flags);
|
||||
R Call(Args... args) override;
|
||||
|
||||
private:
|
||||
Fn callback_;
|
||||
};
|
||||
private:
|
||||
Fn callback_;
|
||||
};
|
||||
|
||||
std::atomic<size_t> size_ {0};
|
||||
std::unique_ptr<Callback> head_;
|
||||
Callback* tail_ = nullptr;
|
||||
std::atomic<size_t> size_{0};
|
||||
std::unique_ptr<Callback> head_;
|
||||
Callback* tail_ = nullptr;
|
||||
};
|
||||
|
||||
} // namespace node
|
||||
} // namespace node
|
||||
|
||||
#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
|
||||
#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
|
||||
|
||||
#endif // SRC_CALLBACK_QUEUE_H_
|
||||
#endif // SRC_CALLBACK_QUEUE_H_
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user