@forgeax/engine-render 0.1.33 → 0.1.35

package/src/__tests__/gpu-driven-production.integration.test.ts

@@ -3,15 +3,27 @@ import { World } from '@forgeax/engine-ecs';
 import { deriveVertexLayoutProjection } from '@forgeax/engine-geometry';
 import { vec3 } from '@forgeax/engine-math';
 import { RenderGraphBuilder } from '@forgeax/engine-render-graph';
-import { type BindGroup, RhiError, type RhiRenderPassEncoder } from '@forgeax/engine-rhi';
-import { type RhiNullDevice, rhi } from '@forgeax/engine-rhi-null';
+import {
+  type BindGroup,
+  type Buffer,
+  type Result,
+  RhiError,
+  type RhiRenderPassEncoder,
+} from '@forgeax/engine-rhi';
+import {
+  RhiNullCommandEncoder,
+  RhiNullDevice,
+  type RhiNullDevice as RhiNullDeviceType,
+  RhiNullQueue,
+  rhi,
+} from '@forgeax/engine-rhi-null';
 import { propagateTransforms, Transform } from '@forgeax/engine-scene';
 import {
   createStandardPbrArtifactReceipt,
   DEFAULT_STANDARD_PBR_PARAM_SCHEMA,
   DEFAULT_UNLIT_PARAM_SCHEMA,
 } from '@forgeax/engine-shader';
-import { ok } from '@forgeax/engine-types';
+import { deriveMaterialDynamicInputLayout, ok } from '@forgeax/engine-types';
 import { describe, expect, it, vi } from 'vitest';
 import { createRenderer as constructRenderer } from '../assembly/factory';
 import { Camera, MeshFilter, MeshRenderer, PointLight } from '../components';
@@ -23,6 +35,7 @@ import {
   adaptStandardPbrFrameResources,
   GpuDrivenProduction,
   projectStandardPbrScene,
+  resolveGpuDrivenMeshGroup,
 } from '../gpu-driven/production-raster';
 import { GPU_DRIVEN_VIEW_WGSL } from '../gpu-driven/view-gpu';
 import { GpuBuffer } from '../gpu-resource';
@@ -30,11 +43,13 @@ import { GpuScene } from '../gpu-scene';
 import {
   GPU_BUFFER_USAGE_COPY_DST,
   GPU_BUFFER_USAGE_INDEX,
+  GPU_BUFFER_USAGE_STORAGE,
   GPU_BUFFER_USAGE_UNIFORM,
   GPU_BUFFER_USAGE_VERTEX,
 } from '../gpu-usage';
 import { buildDispatchPlan } from '../record/frame';
 import { makeZeroCameraFallbackSnapshot, worldEntityKey } from '../record/frame-snapshot';
+import { emitGpuDrivenDrawReceipts } from '../record/gpu-draw-receipts';
 import {
   encodeDirectionalShadowPass,
   encodePointShadowPass,
@@ -51,6 +66,7 @@ import type {
 } from '../render-system-extract';
 import { shadowCasterCpuReason } from '../render-system-extract';
 import { PersistentRenderScene, RenderScene } from '../scene/render-scene';
+import { ReadonlyDynamicInputPage } from '../surface/dynamic-input';
 import {
   preparedPbrSnapshot as preparedPbrFixture,
   standardPbrInputs,
@@ -58,6 +74,105 @@ import {
 
 const STANDARD_PBR_RECEIPT = createStandardPbrArtifactReceipt();
 
+describe('GPU-driven scene-index mesh address selection', () => {
+  it('keeps direct batches on their local group and rebuilds clustered group(2) around the same projection buffer', () => {
+    const directGroup = {} as BindGroup;
+    const clusteredGroup = {} as BindGroup;
+    const legacyClusterGroup = {} as BindGroup;
+    const projectionBuffer = {} as Buffer;
+    const clusterBindGroupForMesh = vi.fn(() => clusteredGroup);
+    const frameResources = { clusterBindGroup: legacyClusterGroup, clusterBindGroupForMesh };
+
+    expect(
+      resolveGpuDrivenMeshGroup({
+        clustered: false,
+        deformation: 'rigid',
+        meshBindGroup: directGroup,
+        meshProjectionBuffer: projectionBuffer,
+        meshProjectionBytes: 256,
+        frameResources,
+      }),
+    ).toBe(directGroup);
+    expect(clusterBindGroupForMesh).not.toHaveBeenCalled();
+
+    expect(
+      resolveGpuDrivenMeshGroup({
+        clustered: true,
+        deformation: 'rigid',
+        meshBindGroup: directGroup,
+        meshProjectionBuffer: projectionBuffer,
+        meshProjectionBytes: 512,
+        frameResources,
+      }),
+    ).toBe(clusteredGroup);
+    expect(clusterBindGroupForMesh).toHaveBeenCalledExactlyOnceWith(projectionBuffer, 512);
+  });
+
+  it('rebuilds clustered skin group(2) from the matching scene-index mesh and palette pages', () => {
+    const directSkinGroup = {} as BindGroup;
+    const clusteredSkinGroup = {} as BindGroup;
+    const projectionBuffer = {} as Buffer;
+    const paletteBuffer = {} as Buffer;
+    const clusterBindGroupForSkin = vi.fn(() => clusteredSkinGroup);
+
+    expect(
+      resolveGpuDrivenMeshGroup({
+        clustered: true,
+        deformation: 'skin',
+        meshBindGroup: directSkinGroup,
+        meshProjectionBuffer: projectionBuffer,
+        meshProjectionBytes: 768,
+        skinPaletteBinding: { buffer: paletteBuffer, bindingWindowBytes: 16_320 },
+        frameResources: { clusterBindGroupForSkin },
+      }),
+    ).toBe(clusteredSkinGroup);
+    expect(clusterBindGroupForSkin).toHaveBeenCalledExactlyOnceWith(
+      projectionBuffer,
+      768,
+      paletteBuffer,
+      16_320,
+    );
+  });
+});
+
+interface BufferWrite {
+  readonly buffer: Buffer;
+  readonly offset: number;
+  readonly bytes: Uint8Array;
+}
+
+class RecordingQueue extends RhiNullQueue {
+  readonly writes: BufferWrite[] = [];
+
+  override writeBuffer(
+    buffer: Buffer,
+    bufferOffset: number,
+    data: ArrayBufferView | ArrayBuffer,
+    dataOffset?: number,
+    size?: number,
+  ): Result<void, RhiError> {
+    const source =
+      data instanceof ArrayBuffer
+        ? new Uint8Array(data)
+        : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    const start = dataOffset ?? 0;
+    const length = size ?? source.byteLength - start;
+    this.writes.push({
+      buffer,
+      offset: bufferOffset,
+      bytes: source.slice(start, start + length),
+    });
+    return super.writeBuffer(buffer, bufferOffset, data, dataOffset, size);
+  }
+}
+
+function recordingDevice(queue: RecordingQueue): RhiNullDeviceType {
+  return new RhiNullDevice(
+    queue,
+    (bookkeeper, device) => new RhiNullCommandEncoder(bookkeeper, device),
+  );
+}
+
 const EMPTY_RESOURCE_CLASS = JSON.stringify({ textures: [], samplers: [], video: [] });
 const OUTPUT_TRANSFORM_WGSL =
   '@vertex fn vs_main(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> { ' +
@@ -453,6 +568,314 @@ describe('GPU-driven production projection', () => {
     availability.scene.dispose();
   });
 
+  it('validates and consumes a published Surface dynamic page through production prepare', async () => {
+    const queue = new RecordingQueue();
+    const device = recordingDevice(queue);
+    const shader = (await rhi.createShaderModule(device, { code: 'synthetic' })).unwrap();
+    const viewLayout = device
+      .createBindGroupLayout({
+        entries: [{ binding: 0, visibility: 0x1, buffer: { type: 'uniform' } }],
+      })
+      .unwrap();
+    const pbrInputs = standardPbrInputs(device, shader, viewLayout);
+    const baseArtifact = pbrInputs.standardPbrArtifact;
+    expect(baseArtifact).toBeDefined();
+    if (baseArtifact === undefined) return;
+    const dynamicSchema = {
+      name: 'surfaceEvents',
+      fields: [
+        { name: 'position', type: 'vec3<f32>' as const },
+        { name: 'strength', type: 'f32' as const },
+      ],
+      maxRecords: 4,
+      maxDomains: 2,
+      maxPageBytes: 64,
+      maxBindings: 1,
+      maxEventsPerSample: 2,
+    };
+    const layout = deriveMaterialDynamicInputLayout(dynamicSchema).unwrap();
+    const surfaceReceipt = {
+      ...STANDARD_PBR_RECEIPT,
+      surface: {
+        model: 'single-layer-medium' as const,
+        module: 'forgeax::single-layer-medium',
+        inputAbi: 'SingleLayerMediumSurfaceInput',
+        outputAbi: 'SingleLayerMediumSurfaceData',
+        passes: ['nearest-layer', 'color'] as const,
+        dynamicInput: {
+          layout,
+          group: 3,
+          binding: 3,
+          readOnly: true as const,
+          accessor: `read_${layout.name}`,
+        },
+      },
+    };
+    const artifact = {
+      ...baseArtifact,
+      receipt: surfaceReceipt,
+    };
+    const projection = new RenderScene();
+    const source = preparedPbrFixture(snapshot(1, 3));
+    const identity = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+    const twoInstanceSurface = {
+      ...source,
+      instances: {
+        transforms: new Float32Array([...identity, ...identity]),
+        instanceCount: 2,
+        cacheKey: 1,
+        archVersion: 1,
+        revision: 1,
+      },
+    } satisfies RenderableSnapshot;
+    const delta = projection.apply([updateSnapshot(twoInstanceSurface)]);
+    const availability = GpuScene.create(device, 1).unwrap();
+    expect(availability.status).toBe('available');
+    if (availability.status !== 'available') return;
+    availability.scene.sync(delta).unwrap();
+    const topology = new BatchTopology();
+    topology.rebuild(projection.slotsSnapshot());
+    const page = ReadonlyDynamicInputPage.create({
+      sourceId: 'surface-producer',
+      pageId: 1,
+      schema: dynamicSchema,
+    }).unwrap();
+    page.writeRecord(0, { position: [1, 2, 3], strength: 0.75 }).unwrap();
+    page.writeRecord(1, { position: [4, 5, 6], strength: 0.25 }).unwrap();
+    const firstRange = page
+      .reserveRange({
+        domain: 'surface-a',
+        recordStart: 0,
+        recordCount: 1,
+        instanceIndex: 3,
+        member: {
+          worldIdentity: 'world-a',
+          entityKey: 1,
+          drawItemIndex: 0,
+          instanceOrdinal: 0,
+        },
+      })
+      .unwrap();
+    const secondRange = page
+      .reserveRange({
+        domain: 'surface-b',
+        recordStart: 1,
+        recordCount: 1,
+        instanceIndex: 7,
+        member: {
+          worldIdentity: 'world-a',
+          entityKey: 1,
+          drawItemIndex: 0,
+          instanceOrdinal: 1,
+        },
+      })
+      .unwrap();
+    const stableRanges = Object.freeze([firstRange, secondRange]);
+    const production = new GpuDrivenProduction(device, {
+      createShaderModule: () => ok(shader),
+    });
+    const probeBlendRecordBuffer = device
+      .createBuffer({ size: 4096, usage: GPU_BUFFER_USAGE_STORAGE })
+      .unwrap();
+    const prepared = production
+      .prepare({
+        ...pbrInputs,
+        standardPbrArtifact: artifact,
+        scene: {
+          scene: availability.scene,
+          plan: topology.plan(),
+          slots: projection.slotsSnapshot(),
+          worldIdentities: ['world-a'],
+        },
+        camera: makeZeroCameraFallbackSnapshot(),
+        meshBySlot: new Map([[0, mesh(device)]]),
+        viewBindGroupLayout: viewLayout,
+        meshResidencyEpoch: 1,
+        probeBlendRecordBuffer,
+        hdrp: false,
+        surfaceDynamicInput: {
+          page,
+          ranges: [secondRange, firstRange],
+          projectionRevision: 1,
+          frameTime: 1,
+        },
+        deviceGeneration: 1,
+      })
+      .unwrap();
+    expect(prepared?.surfaceSubmission).toMatchObject({
+      model: 'single-layer-medium',
+      lane: 'gpu-driven',
+      passes: [{ pass: 'nearest-layer' }, { pass: 'color' }],
+    });
+    expect(page.uploadedRevision).toBe(page.contentRevision);
+    const consumeSpy = vi.spyOn(page, 'consume');
+    expect(prepared?._consumeSurfaceDynamicInput?.(31)).toMatchObject({
+      ok: true,
+    });
+    expect(consumeSpy).toHaveBeenCalledTimes(2);
+    const frameBuffer = prepared?.standardPbrFrameResources.surfaceDynamicInput?.frame;
+    expect(frameBuffer).toBeDefined();
+    if (frameBuffer === undefined) return;
+    const frameWrites = queue.writes.filter(
+      (write) => write.buffer === frameBuffer && write.bytes.byteLength === 48,
+    );
+    const mappedFrameWrite = frameWrites.find((write) => {
+      if (write.buffer !== frameBuffer || write.bytes.byteLength !== 48) return false;
+      return (
+        new DataView(write.bytes.buffer, write.bytes.byteOffset, write.bytes.byteLength).getUint32(
+          12,
+          true,
+        ) === 3
+      );
+    });
+    expect(mappedFrameWrite?.offset).toBe(0);
+    expect(
+      mappedFrameWrite === undefined
+        ? undefined
+        : new DataView(
+            mappedFrameWrite.bytes.buffer,
+            mappedFrameWrite.bytes.byteOffset,
+            mappedFrameWrite.bytes.byteLength,
+          ).getUint32(44, true),
+    ).toBe(1);
+    const secondMappedFrameWrite = frameWrites.find((write) => {
+      if (write.buffer !== frameBuffer || write.bytes.byteLength !== 48) return false;
+      return (
+        new DataView(write.bytes.buffer, write.bytes.byteOffset, write.bytes.byteLength).getUint32(
+          12,
+          true,
+        ) === 7
+      );
+    });
+    expect(secondMappedFrameWrite?.offset).toBe(48);
+    const frameWriteCount = frameWrites.length;
+    expect(production.inspect()).toMatchObject({
+      surfaceFrameRangeBuilds: 1,
+      surfaceFrameMemberScans: 4,
+      surfaceFrameRowAllocations: 2,
+      surfaceFrameTimeWrites: 1,
+    });
+    const repeated = production
+      .prepare({
+        ...pbrInputs,
+        standardPbrArtifact: artifact,
+        scene: {
+          scene: availability.scene,
+          plan: topology.plan(),
+          slots: projection.slotsSnapshot(),
+          worldIdentities: ['world-a'],
+        },
+        camera: makeZeroCameraFallbackSnapshot(),
+        meshBySlot: new Map([[0, mesh(device)]]),
+        viewBindGroupLayout: viewLayout,
+        meshResidencyEpoch: 1,
+        probeBlendRecordBuffer,
+        hdrp: false,
+        surfaceDynamicInput: { page, ranges: stableRanges, projectionRevision: 1, frameTime: 1 },
+        deviceGeneration: 1,
+      })
+      .unwrap();
+    expect(repeated).toBeDefined();
+    expect(repeated?._consumeSurfaceDynamicInput?.(32)).toMatchObject({ ok: true });
+    expect(consumeSpy).toHaveBeenCalledTimes(2);
+    expect(
+      queue.writes.filter((write) => write.buffer === frameBuffer && write.bytes.byteLength === 48),
+    ).toHaveLength(frameWriteCount);
+    const stableInspection = production.inspect();
+    expect(stableInspection).toMatchObject({
+      surfaceFrameRangeBuilds: 1,
+      surfaceFrameMemberScans: 4,
+      surfaceFrameRowAllocations: 2,
+      surfaceFrameTimeWrites: 1,
+    });
+
+    const writesBeforeTimeAdvance = queue.writes.length;
+    production
+      .prepare({
+        ...pbrInputs,
+        standardPbrArtifact: artifact,
+        scene: {
+          scene: availability.scene,
+          plan: topology.plan(),
+          slots: projection.slotsSnapshot(),
+          worldIdentities: ['world-a'],
+        },
+        camera: makeZeroCameraFallbackSnapshot(),
+        meshBySlot: new Map([[0, mesh(device)]]),
+        viewBindGroupLayout: viewLayout,
+        meshResidencyEpoch: 1,
+        probeBlendRecordBuffer,
+        hdrp: false,
+        surfaceDynamicInput: { page, ranges: stableRanges, projectionRevision: 1, frameTime: 2 },
+        deviceGeneration: 1,
+      })
+      .unwrap();
+    const timeAdvanceWrites = queue.writes.slice(writesBeforeTimeAdvance);
+    const sharedFrameBuffer = prepared?.standardPbrFrameResources.surfaceDynamicInput?.sharedFrame;
+    expect(sharedFrameBuffer).toBeDefined();
+    expect(timeAdvanceWrites.filter((write) => write.buffer === sharedFrameBuffer)).toMatchObject([
+      { offset: 0, bytes: { byteLength: 16 } },
+    ]);
+    expect(timeAdvanceWrites.some((write) => write.buffer === frameBuffer)).toBe(false);
+    expect(production.inspect()).toMatchObject({
+      surfaceFrameRangeBuilds: stableInspection.surfaceFrameRangeBuilds,
+      surfaceFrameMemberScans: stableInspection.surfaceFrameMemberScans,
+      surfaceFrameRowAllocations: stableInspection.surfaceFrameRowAllocations,
+      surfaceFrameTimeWrites: stableInspection.surfaceFrameTimeWrites + 1,
+    });
+
+    const invalid = production.prepare({
+      ...pbrInputs,
+      standardPbrArtifact: artifact,
+      scene: {
+        scene: availability.scene,
+        plan: topology.plan(),
+        slots: projection.slotsSnapshot(),
+        worldIdentities: ['world-a'],
+      },
+      camera: makeZeroCameraFallbackSnapshot(),
+      meshBySlot: new Map([[0, mesh(device)]]),
+      viewBindGroupLayout: viewLayout,
+      meshResidencyEpoch: 1,
+      probeBlendRecordBuffer,
+      hdrp: false,
+      surfaceDynamicInput: {
+        page,
+        ranges: [{ ...firstRange, byteOffset: firstRange.byteOffset + 4 }, secondRange],
+        projectionRevision: 2,
+        frameTime: 1,
+      },
+      deviceGeneration: 1,
+    });
+    expect(invalid).toMatchObject({ ok: false, error: { code: 'rhi-descriptor-invalid' } });
+    const retried = production.prepare({
+      ...pbrInputs,
+      standardPbrArtifact: artifact,
+      scene: {
+        scene: availability.scene,
+        plan: topology.plan(),
+        slots: projection.slotsSnapshot(),
+        worldIdentities: ['world-a'],
+      },
+      camera: makeZeroCameraFallbackSnapshot(),
+      meshBySlot: new Map([[0, mesh(device)]]),
+      viewBindGroupLayout: viewLayout,
+      meshResidencyEpoch: 1,
+      probeBlendRecordBuffer,
+      hdrp: false,
+      surfaceDynamicInput: {
+        page,
+        ranges: stableRanges,
+        projectionRevision: 2,
+        frameTime: 2,
+      },
+      deviceGeneration: 1,
+    });
+    expect(retried.ok).toBe(true);
+    production.dispose();
+    availability.scene.dispose();
+  });
+
   it('keeps GPU batches World-homogeneous for same-submit counter attribution', async () => {
     const adapter = (await rhi.requestAdapter()).unwrap();
     const device = (await adapter.requestDevice()).unwrap() as RhiNullDevice;
@@ -531,6 +954,62 @@ describe('GPU-driven production projection', () => {
       cpuFallbackDrawItems: 0,
       validatedGpuOwnedRows: 0,
     });
+
+    // Composition-local world indices do not necessarily equal the retained
+    // stable world identity used by the GPU draw-key producer.
+    const worldKeys = [101, 202] as const;
+    const stableGpuOwned = new Set([
+      gpuDrivenDrawKey(
+        worldEntityKey(worldKeys[gpuLodRow.worldId] ?? -1, gpuLodRow.entityKey),
+        -1,
+        0,
+      ),
+    ]);
+    production.recordCpuValidation(
+      [{ source: gpuLodRow }],
+      stableGpuOwned,
+      'stable-world',
+      worldKeys,
+    );
+    expect(production.inspect()).toMatchObject({
+      cpuFallbackDrawItems: 0,
+      validatedGpuOwnedRows: 0,
+    });
+    production.dispose();
+  });
+
+  it('keeps unclaimed mixed draws on the CPU lane while GPU receipts stay concrete', async () => {
+    const adapter = (await rhi.requestAdapter()).unwrap();
+    const device = (await adapter.requestDevice()).unwrap() as RhiNullDevice;
+    const shader = (await rhi.createShaderModule(device, { code: 'synthetic' })).unwrap();
+    const production = new GpuDrivenProduction(device, {
+      createShaderModule: () => ok(shader),
+    });
+    const base = snapshot(8, 3);
+    const firstDraw = base.gpuDrivenDraws?.[0];
+    if (firstDraw === undefined) throw new Error('mixed ownership fixture has no first draw');
+    const mixed = {
+      ...base,
+      gpuDrivenDraws: [
+        firstDraw,
+        { ...firstDraw, drawItemIndex: 1, first: firstDraw.first + firstDraw.count },
+      ],
+    };
+    const claimed = new Set([
+      gpuDrivenDrawKey(worldEntityKey(mixed.worldId, mixed.entityKey), -1, 0),
+    ]);
+    const gpuReceipts: { readonly submeshIndex: number; readonly lane: string }[] = [];
+    emitGpuDrivenDrawReceipts({ source: mixed }, claimed, (_entry, submeshIndex, receipt) =>
+      gpuReceipts.push({ submeshIndex, lane: receipt.lane }),
+    );
+    expect(gpuReceipts).toEqual([{ submeshIndex: 0, lane: 'gpu' }]);
+    expect(gpuReceipts.some((receipt) => receipt.submeshIndex === 1)).toBe(false);
+
+    production.recordCpuValidation([{ source: mixed }], claimed);
+    expect(production.inspect()).toMatchObject({
+      cpuFallbackDrawItems: 1,
+      validatedGpuOwnedRows: 1,
+    });
     production.dispose();
   });
 

package/src/__tests__/gpu-driven-shadow-views.dawn.test.ts

@@ -196,7 +196,7 @@ describe('GPU-driven shadow views Dawn structural evidence', () => {
         visibleReadback: device
           .createBuffer({
             label: `shadow-view-${index}-visible-readback`,
-            size: 520,
+            size: 1040,
             usage: GPU_BUFFER_USAGE_MAP_READ | GPU_BUFFER_USAGE_COPY_DST,
           })
           .unwrap(),
@@ -219,7 +219,7 @@ describe('GPU-driven shadow views Dawn structural evidence', () => {
     const encoder = device.createCommandEncoder({ label: 'gpu-driven-shadow-views-dawn' }).unwrap();
     compiled.execute({ encoder }).unwrap();
     for (const readback of readbacks) {
-      encoder.copyBufferToBuffer(readback.visible, 0, readback.visibleReadback, 0, 520);
+      encoder.copyBufferToBuffer(readback.visible, 0, readback.visibleReadback, 0, 1040);
       encoder.copyBufferToBuffer(readback.indirect, 0, readback.indirectReadback, 0, 40);
       encoder.copyBufferToBuffer(
         readback.overflow,
@@ -243,10 +243,11 @@ describe('GPU-driven shadow views Dawn structural evidence', () => {
       const overflowMap = (await readback.overflowReadback.mapAsync(GPU_MAP_MODE_READ)).unwrap();
       const overflow = new Uint32Array(overflowMap.getMappedRange().unwrap().slice(0));
       overflowMap.unmap();
-      expect(Array.from(visible.slice(0, 2))).toEqual([0, 0]);
+      expect(Array.from(visible.slice(0, 4))).toEqual([0, 0, 1, 0]);
       // Each indirect batch binds its own projected Mesh table, so the
-      // compact visible row is batch-local rather than a global primitive id.
-      expect(Array.from(visible.slice(128, 130))).toEqual([0, 1]);
+      // compact visible row is batch-local. The retained RenderScene slot and
+      // generation remain global addresses for scene-index side tables.
+      expect(Array.from(visible.slice(256, 260))).toEqual([0, 1, 2, 0]);
       expect(Array.from(indirect)).toEqual([36, 1, 0, 0, 0, 36, 1, 0, 0, 0]);
       expect(Array.from(overflow)).toEqual([0]);
       device.destroyBuffer(readback.visibleReadback);