opt: renderpass

src/foundation/components/MeshRenderer/MeshRendererComponent.ts

@@ -140,15 +140,7 @@ export class MeshRendererComponent extends Component {
     }
   }
 
-  // $prerender() {
-  // }
-
   static sort_$render(renderPass: RenderPass): ComponentSID[] {
-    const primitiveUids = MeshRendererComponent.sort_$render_inner(renderPass);
-    return primitiveUids;
-  }
-
-  private static sort_$render_inner(renderPass: RenderPass) {
     if (
       TransformComponent.updateCount === renderPass._lastTransformComponentsUpdateCount &&
       CameraControllerComponent.updateCount ===

src/foundation/renderer/RenderPass.ts

@@ -62,9 +62,7 @@ export class RenderPass extends RnObject {
   public toRenderTransparentPrimitives = true;
 
   public toRenderEffekseerEffects = false;
-  public drawCount = 1;
   public __renderTargetColorAttachments?: RenderBufferTargetEnum[];
-  private __preEachDrawFunc?: (drawCount: number) => void;
   private __postEachRenderFunc?: () => void;
   private static __tmp_Vector4_0 = MutableVector4.zero();
 
@@ -101,27 +99,12 @@ export class RenderPass extends RnObject {
     renderPass.isOutputForVr = this.isOutputForVr;
     renderPass.toRenderOpaquePrimitives = this.toRenderOpaquePrimitives;
     renderPass.toRenderTransparentPrimitives = this.toRenderTransparentPrimitives;
-    renderPass.__preEachDrawFunc = this.__preEachDrawFunc;
     renderPass.__postEachRenderFunc = this.__postEachRenderFunc;
     renderPass.__renderTargetColorAttachments = this.__renderTargetColorAttachments?.concat();
 
     return renderPass;
   }
 
-  setPreDrawFunction(func: (drawCount: number) => void) {
-    this.__preEachDrawFunc = func;
-  }
-
-  unsetPreDrawFunction() {
-    this.__preEachDrawFunc = void 0;
-  }
-
-  doPreEachDraw(drawCount: number) {
-    if (this.__preEachDrawFunc != null) {
-      this.__preEachDrawFunc(drawCount);
-    }
-  }
-
   setPostRenderFunction(func: () => void) {
     this.__postEachRenderFunc = func;
   }

src/foundation/system/System.ts

@@ -254,7 +254,7 @@ export class System {
                 this.__cgApiResourceRepository.clearFrameBuffer(renderPass);
               }
 
-              let skipNormalRender = false;
+              let skipNormalRender = renderPass.entities.length === 0 ? true : false;
               if (this.processApproach === ProcessApproach.WebGPU) {
                 const webGpuStrategyBasic = WebGpuStrategyBasic.getInstance();
                 skipNormalRender = webGpuStrategyBasic.renderWithRenderBundle(renderPass);

src/webgl/WebGLStrategyDataTexture.ts

@@ -725,34 +725,26 @@ ${returnType} get_${methodName}(highp float _instanceId, const int idxOfArray) {
         isVRMainPass
       );
 
-      for (let j = 0; j < renderPass.drawCount; j++) {
-        renderPass.doPreEachDraw(j);
-
-        // For opaque primitives
-        if (renderPass.toRenderOpaquePrimitives) {
-          for (let i = 0; i <= renderPass._lastOpaqueIndex; i++) {
-            const primitiveUid = primitiveUids[i];
-            this.renderInner(primitiveUid, glw, renderPass, isVRMainPass, displayIdx);
-          }
+      // For opaque primitives
+      if (renderPass.toRenderOpaquePrimitives) {
+        for (let i = 0; i <= renderPass._lastOpaqueIndex; i++) {
+          const primitiveUid = primitiveUids[i];
+          this.renderInner(primitiveUid, glw, renderPass, isVRMainPass, displayIdx);
         }
+      }
 
-        // For translucent primitives
-        if (renderPass.toRenderTransparentPrimitives) {
-          if (!MeshRendererComponent.isDepthMaskTrueForTransparencies) {
-            // disable depth write for transparent primitives
-            gl.depthMask(false);
-          }
+      // For translucent primitives
+      if (renderPass.toRenderTransparentPrimitives) {
+        if (!MeshRendererComponent.isDepthMaskTrueForTransparencies) {
+          // disable depth write for transparent primitives
+          gl.depthMask(false);
+        }
 
-          for (
-            let i = renderPass._lastOpaqueIndex + 1;
-            i <= renderPass._lastTransparentIndex;
-            i++
-          ) {
-            const primitiveUid = primitiveUids[i];
-            this.renderInner(primitiveUid, glw, renderPass, isVRMainPass, displayIdx);
-          }
-          gl.depthMask(true);
+        for (let i = renderPass._lastOpaqueIndex + 1; i <= renderPass._lastTransparentIndex; i++) {
+          const primitiveUid = primitiveUids[i];
+          this.renderInner(primitiveUid, glw, renderPass, isVRMainPass, displayIdx);
         }
+        gl.depthMask(true);
       }
     }
 

src/webgl/WebGLStrategyUniform.ts

@@ -366,48 +366,40 @@ bool get_isBillboard(float instanceId) {
         WebGLStrategyCommonMethod.setVRViewport(renderPass, displayIdx);
       }
 
-      for (let j = 0; j < renderPass.drawCount; j++) {
-        renderPass.doPreEachDraw(j);
-
-        // For opaque primitives
-        if (renderPass.toRenderOpaquePrimitives) {
-          for (let i = 0; i <= renderPass._lastOpaqueIndex; i++) {
-            const primitiveUid = primitiveUids[i];
-            this.renderInner(
-              primitiveUid,
-              glw,
-              renderPass,
-              renderPassTickCount,
-              isVrMainPass,
-              displayIdx
-            );
-          }
+      // For opaque primitives
+      if (renderPass.toRenderOpaquePrimitives) {
+        for (let i = 0; i <= renderPass._lastOpaqueIndex; i++) {
+          const primitiveUid = primitiveUids[i];
+          this.renderInner(
+            primitiveUid,
+            glw,
+            renderPass,
+            renderPassTickCount,
+            isVrMainPass,
+            displayIdx
+          );
+        }
+      }
+
+      // For translucent primitives
+      if (renderPass.toRenderTransparentPrimitives) {
+        if (!MeshRendererComponent.isDepthMaskTrueForTransparencies) {
+          // disable depth write for transparent primitives
+          gl.depthMask(false);
         }
 
-        // For translucent primitives
-        if (renderPass.toRenderTransparentPrimitives) {
-          if (!MeshRendererComponent.isDepthMaskTrueForTransparencies) {
-            // disable depth write for transparent primitives
-            gl.depthMask(false);
-          }
-
-          for (
-            let i = renderPass._lastOpaqueIndex + 1;
-            i <= renderPass._lastTransparentIndex;
-            i++
-          ) {
-            const primitiveUid = primitiveUids[i];
-            this.renderInner(
-              primitiveUid,
-              glw,
-              renderPass,
-              renderPassTickCount,
-              isVrMainPass,
-              displayIdx
-            );
-          }
-          gl.depthMask(true);
+        for (let i = renderPass._lastOpaqueIndex + 1; i <= renderPass._lastTransparentIndex; i++) {
+          const primitiveUid = primitiveUids[i];
+          this.renderInner(
+            primitiveUid,
+            glw,
+            renderPass,
+            renderPassTickCount,
+            isVrMainPass,
+            displayIdx
+          );
         }
+        gl.depthMask(true);
       }
     }
 

src/webgpu/WebGpuResourceRepository.ts

@@ -48,7 +48,7 @@ import { GlobalDataRepository } from '../foundation/core/GlobalDataRepository';
 import { RenderBuffer } from '../foundation/textures/RenderBuffer';
 import { Vector2 } from '../foundation/math/Vector2';
 import { CameraComponent } from '../foundation/components/Camera/CameraComponent';
-import { EntityRepository } from '../foundation';
+import { EntityRepository } from '../foundation/core/EntityRepository';
 
 const HDRImage = require('../../vendor/hdrpng.min.js');
 

src/webgpu/WebGpuStrategyBasic.ts

@@ -29,10 +29,8 @@ import { CompositionType } from '../foundation/definitions/CompositionType';
 import { ComponentType } from '../foundation/definitions/ComponentType';
 import { ShaderSemantics, getShaderPropertyFunc } from '../foundation/definitions/ShaderSemantics';
 import { ModuleManager } from '../foundation/system/ModuleManager';
-import { WellKnownComponentTIDs } from '../foundation/components/WellKnownComponentTIDs';
 import { ComponentRepository } from '../foundation/core/ComponentRepository';
 import { CameraComponent } from '../foundation/components/Camera/CameraComponent';
-import { VectorN } from '../foundation/math/VectorN';
 import { RnXR } from '../xr/main';
 import { Config } from '../foundation/core/Config';
 import { VertexAttribute } from '../foundation/definitions/VertexAttribute';
@@ -298,7 +296,9 @@ ${indexStr}
       );
     }
 
-    if (BlendShapeComponent.updateCount !== this.__lastBlendShapeComponentsUpdateCountForBlendData) {
+    if (
+      BlendShapeComponent.updateCount !== this.__lastBlendShapeComponentsUpdateCountForBlendData
+    ) {
       this.__createOrUpdateStorageBlendShapeBuffer();
       this.__lastBlendShapeComponentsUpdateCountForBlendData = BlendShapeComponent.updateCount;
     }
@@ -388,30 +388,26 @@ ${indexStr}
     renderPass: RenderPass,
     renderPassTickCount: number
   ): boolean {
-    for (let j = 0; j < renderPass.drawCount; j++) {
-      renderPass.doPreEachDraw(j);
-
-      // For opaque primitives
-      if (renderPass.toRenderOpaquePrimitives) {
-        for (let i = 0; i <= renderPass._lastOpaqueIndex; i++) {
-          const primitiveUid = primitiveUids[i];
-          this.renderInner(primitiveUid, renderPass, renderPassTickCount);
-        }
+    // For opaque primitives
+    if (renderPass.toRenderOpaquePrimitives) {
+      for (let i = 0; i <= renderPass._lastOpaqueIndex; i++) {
+        const primitiveUid = primitiveUids[i];
+        this.renderInner(primitiveUid, renderPass, renderPassTickCount);
       }
+    }
 
-      // For translucent primitives
-      if (renderPass.toRenderTransparentPrimitives) {
-        if (!MeshRendererComponent.isDepthMaskTrueForTransparencies) {
-          // disable depth write for transparent primitives
-          // gl.depthMask(false);
-        }
+    // For translucent primitives
+    if (renderPass.toRenderTransparentPrimitives) {
+      if (!MeshRendererComponent.isDepthMaskTrueForTransparencies) {
+        // disable depth write for transparent primitives
+        // gl.depthMask(false);
+      }
 
-        for (let i = renderPass._lastOpaqueIndex + 1; i <= renderPass._lastTransparentIndex; i++) {
-          const primitiveUid = primitiveUids[i];
-          this.renderInner(primitiveUid, renderPass, renderPassTickCount);
-        }
-        // gl.depthMask(true);
+      for (let i = renderPass._lastOpaqueIndex + 1; i <= renderPass._lastTransparentIndex; i++) {
+        const primitiveUid = primitiveUids[i];
+        this.renderInner(primitiveUid, renderPass, renderPassTickCount);
       }
+      // gl.depthMask(true);
     }
 
     return true;