Remove Mesh Game Object and add Layer3D

Author: photonstorm

src/gameobjects/index.js

@@ -122,17 +122,18 @@ var GameObjects = {
 if (typeof WEBGL_RENDERER)
 {
     //  WebGL only Game Objects
-    GameObjects.Mesh = require('./mesh/Mesh');
-    GameObjects.MeshCamera = require('./mesh/MeshCamera');
+    GameObjects.Layer3D = require('./layer3d/Layer3D');
+    GameObjects.Layer3DCamera = require('./layer3d/Layer3DCamera');
+    GameObjects.Layer3DLight = require('./layer3d/Layer3DLight');
 
     GameObjects.Quad = require('./quad/Quad');
     GameObjects.Shader = require('./shader/Shader');
 
-    GameObjects.Factories.Mesh = require('./mesh/MeshFactory');
+    GameObjects.Factories.Layer3D = require('./layer3d/Layer3DFactory');
     GameObjects.Factories.Quad = require('./quad/QuadFactory');
     GameObjects.Factories.Shader = require('./shader/ShaderFactory');
 
-    GameObjects.Creators.Mesh = require('./mesh/MeshCreator');
+    GameObjects.Creators.Layer3D = require('./layer3d/Layer3DCreator');
     GameObjects.Creators.Quad = require('./quad/QuadCreator');
     GameObjects.Creators.Shader = require('./shader/ShaderCreator');
 

src/gameobjects/mesh/Mesh.js src/gameobjects/layer3d/Layer3D.jssrc/gameobjects/mesh/Mesh.js renamed to src/gameobjects/layer3d/Layer3D.js

@@ -12,18 +12,18 @@ var Vector4 = require('../../math/Vector4');
 
 /**
  * @classdesc
- * The Mesh Camera.
+ * The Layer3D Camera.
  *
- * @class MeshCamera
+ * @class Layer3DCamera
  * @memberof Phaser.GameObjects
  * @constructor
  * @since 3.50.0
  */
-var MeshCamera = new Class({
+var Layer3DCamera = new Class({
 
     initialize:
 
-    function MeshCamera (fov, x, y, z, near, far)
+    function Layer3DCamera (fov, x, y, z, near, far)
     {
         this.dirty = true;
         this.aspectRatio = 1;
@@ -44,7 +44,7 @@ var MeshCamera = new Class({
         this.projectionMatrix = new Matrix4(); // perspective projection matrix
         this.viewProjectionMatrix = new Matrix4(); // perspective projection matrix multiplied by the view matrix
 
-        this.mode = MeshCamera.MODE_ORBIT;
+        this.mode = Layer3DCamera.MODE_ORBIT;
     },
 
     panX: function (v)
@@ -60,7 +60,7 @@ var MeshCamera = new Class({
 
         this.position.y += this.up.y * v;
 
-        if (this.mode === MeshCamera.MODE_ORBIT)
+        if (this.mode === Layer3DCamera.MODE_ORBIT)
         {
             //  Can only move up and down the y axix in orbit mode
             return;
@@ -74,7 +74,7 @@ var MeshCamera = new Class({
     {
         this.updateViewMatrix();
 
-        if (this.mode === MeshCamera.MODE_ORBIT)
+        if (this.mode === Layer3DCamera.MODE_ORBIT)
         {
             //  orbit mode does translate after rotate, so only need to set Z, the rotate will handle the rest.
             this.position.z += v;
@@ -91,7 +91,7 @@ var MeshCamera = new Class({
     {
         var matView = this.matrix;
 
-        if (this.mode === MeshCamera.MODE_FREE)
+        if (this.mode === Layer3DCamera.MODE_FREE)
         {
             matView.fromRotationXYTranslation(this.rotation, this.position, true);
         }
@@ -126,6 +126,7 @@ var MeshCamera = new Class({
         this.up.set(0, 1, 0, 0).transformMat4(matView);
         this.right.set(1, 0, 0, 0).transformMat4(matView);
     },
+
     fov: {
 
         get: function ()
@@ -278,9 +279,9 @@ var MeshCamera = new Class({
 });
 
 // Allows free movement of position and rotation
-MeshCamera.MODE_FREE = 0;
+Layer3DCamera.MODE_FREE = 0;
 
 // Movement is locked to rotate around the origin
-MeshCamera.MODE_ORBIT = 1;
+Layer3DCamera.MODE_ORBIT = 1;
 
-module.exports = MeshCamera;
+module.exports = Layer3DCamera;

src/gameobjects/mesh/MeshCamera.js src/gameobjects/layer3d/Layer3DCamera.jssrc/gameobjects/mesh/MeshCamera.js renamed to src/gameobjects/layer3d/Layer3DCamera.js

@@ -5,18 +5,18 @@
  */
 
 /**
- * This is a stub function for Mesh.Render. There is no Canvas renderer for Mesh objects.
+ * This is a stub function for Layer3D.Render. There is no Canvas renderer for Layer3D objects.
  *
- * @method Phaser.GameObjects.Mesh#renderCanvas
- * @since 3.0.0
+ * @method Phaser.GameObjects.Layer3D#renderCanvas
+ * @since 3.50.0
  * @private
  *
  * @param {Phaser.Renderer.Canvas.CanvasRenderer} renderer - A reference to the current active Canvas renderer.
- * @param {Phaser.GameObjects.Mesh} src - The Game Object being rendered in this call.
+ * @param {Phaser.GameObjects.Layer3D} src - The Game Object being rendered in this call.
  * @param {Phaser.Cameras.Scene2D.Camera} camera - The Camera that is rendering the Game Object.
  */
-var MeshCanvasRenderer = function ()
+var Layer3DCanvasRenderer = function ()
 {
 };
 
-module.exports = MeshCanvasRenderer;
+module.exports = Layer3DCanvasRenderer;

…c/gameobjects/mesh/MeshCanvasRenderer.js …objects/layer3d/Layer3DCanvasRenderer.jssrc/gameobjects/mesh/MeshCanvasRenderer.js renamed to src/gameobjects/layer3d/Layer3DCanvasRenderer.js src/gameobjects/mesh/MeshCanvasRenderer.js renamed to src/gameobjects/layer3d/Layer3DCanvasRenderer.js

@@ -0,0 +1,40 @@
+/**
+ * @author       Richard Davey <rich@photonstorm.com>
+ * @copyright    2020 Photon Storm Ltd.
+ * @license      {@link https://opensource.org/licenses/MIT|MIT License}
+ */
+
+var BuildGameObject = require('../BuildGameObject');
+var GameObjectCreator = require('../GameObjectCreator');
+var Layer3D = require('./Layer3D');
+
+/**
+ * Creates a new Layer3D Game Object and returns it.
+ *
+ * Note: This method will only be available if the Layer3D Game Object and WebGL support have been built into Phaser.
+ *
+ * @method Phaser.GameObjects.GameObjectCreator#layer3d
+ * @since 3.50.0
+ *
+ * @param {object} config - The configuration object this Game Object will use to create itself.
+ * @param {boolean} [addToScene] - Add this Game Object to the Scene after creating it? If set this argument overrides the `add` property in the config object.
+ *
+ * @return {Phaser.GameObjects.Layer3D} The Game Object that was created.
+ */
+GameObjectCreator.register('layer3d', function (config, addToScene)
+{
+    if (config === undefined) { config = {}; }
+
+    var layer = new Layer3D(this.scene, 0, 0);
+
+    if (addToScene !== undefined)
+    {
+        config.add = addToScene;
+    }
+
+    BuildGameObject(this.scene, layer, config);
+
+    return layer;
+});
+
+//  When registering a factory function 'this' refers to the GameObjectCreator context.

src/gameobjects/layer3d/Layer3DCreator.js

@@ -0,0 +1,38 @@
+/**
+ * @author       Richard Davey <rich@photonstorm.com>
+ * @copyright    2020 Photon Storm Ltd.
+ * @license      {@link https://opensource.org/licenses/MIT|MIT License}
+ */
+
+var Layer3D = require('./Layer3D');
+var GameObjectFactory = require('../GameObjectFactory');
+
+/**
+ * Creates a new Layer3D Game Object and adds it to the Scene.
+ *
+ * Note: This method will only be available if the Layer3D Game Object and WebGL support have been built into Phaser.
+ *
+ * @method Phaser.GameObjects.GameObjectFactory#layer3d
+ * @webglOnly
+ * @since 3.50.0
+ *
+ * @param {number} [x] - The horizontal position of this Game Object in the world.
+ * @param {number} [y] - The vertical position of this Game Object in the world.
+ *
+ * @return {Phaser.GameObjects.Layer3D} The Game Object that was created.
+ */
+if (typeof WEBGL_RENDERER)
+{
+    GameObjectFactory.register('layer3d', function (x, y)
+    {
+        return this.displayList.add(new Layer3D(this.scene, x, y));
+    });
+}
+
+//  When registering a factory function 'this' refers to the GameObjectFactory context.
+//
+//  There are several properties available to use:
+//
+//  this.scene - a reference to the Scene that owns the GameObjectFactory
+//  this.displayList - a reference to the Display List the Scene owns
+//  this.updateList - a reference to the Update List the Scene owns

src/gameobjects/layer3d/Layer3DFactory.js

@@ -10,18 +10,18 @@ var Vector3 = require('../../math/Vector3');
 
 /**
  * @classdesc
- * The Mesh Light.
+ * A Layer3D Ambient Light.
  *
- * @class MeshLight
+ * @class Layer3DLight
  * @memberof Phaser.GameObjects
  * @constructor
  * @since 3.50.0
  */
-var MeshLight = new Class({
+var Layer3DLight = new Class({
 
     initialize:
 
-    function MeshLight (x, y, z)
+    function Layer3DLight (x, y, z)
     {
         this.position = new Vector3(x, y, z);
         this.ambient = new RGB(1, 1, 1);
@@ -124,4 +124,4 @@ var MeshLight = new Class({
 
 });
 
-module.exports = MeshLight;
+module.exports = Layer3DLight;

src/gameobjects/mesh/MeshLight.js src/gameobjects/layer3d/Layer3DLight.jssrc/gameobjects/mesh/MeshLight.js renamed to src/gameobjects/layer3d/Layer3DLight.js

@@ -9,12 +9,12 @@ var renderCanvas = require('../../utils/NOOP');
 
 if (typeof WEBGL_RENDERER)
 {
-    renderWebGL = require('./MeshWebGLRenderer');
+    renderWebGL = require('./Layer3DWebGLRenderer');
 }
 
 if (typeof CANVAS_RENDERER)
 {
-    renderCanvas = require('./MeshCanvasRenderer');
+    renderCanvas = require('./Layer3DCanvasRenderer');
 }
 
 module.exports = {

src/gameobjects/mesh/MeshRender.js src/gameobjects/layer3d/Layer3DRender.jssrc/gameobjects/mesh/MeshRender.js renamed to src/gameobjects/layer3d/Layer3DRender.js

@@ -9,16 +9,16 @@
  * The object will not render if any of its renderFlags are set or it is being actively filtered out by the Camera.
  * This method should not be called directly. It is a utility function of the Render module.
  *
- * @method Phaser.GameObjects.Mesh#renderWebGL
- * @since 3.0.0
+ * @method Phaser.GameObjects.Layer3D#renderWebGL
+ * @since 3.50.0
  * @private
  *
  * @param {Phaser.Renderer.WebGL.WebGLRenderer} renderer - A reference to the current active WebGL renderer.
- * @param {Phaser.GameObjects.Mesh} src - The Game Object being rendered in this call.
+ * @param {Phaser.GameObjects.Layer3D} src - The Game Object being rendered in this call.
  * @param {Phaser.Cameras.Scene2D.Camera} camera - The Camera that is rendering the Game Object.
  * @param {Phaser.GameObjects.Components.TransformMatrix} parentMatrix - This transform matrix is defined if the game object is nested
  */
-var MeshWebGLRenderer = function (renderer, src)
+var Layer3DWebGLRenderer = function (renderer, src)
 {
     var models = src.models;
     var totalModels = models.length;
@@ -36,12 +36,15 @@ var MeshWebGLRenderer = function (renderer, src)
     {
         var model = models[m];
 
-        pipeline.drawModel(src, model);
+        if (model.visible && model.vertexCount > 0)
+        {
+            pipeline.drawModel(src, model);
+        }
     }
 
     src.resetDirtyFlags();
 
     renderer.pipelines.rebind();
 };
 
-module.exports = MeshWebGLRenderer;
+module.exports = Layer3DWebGLRenderer;