Fix Camera canvas resize and rename initXXX to configureXXX (#3249)

Author: halx99

axmol/2d/NodeGrid.cpp

@@ -84,12 +84,12 @@ Camera* NodeGrid::getGridCamera()
 {
     if (!_gridCamera)
     {
-        _gridCamera = Camera::createOrthographicView(_director->getCanvasSize(), -1024, 1024);
+        _gridCamera = Camera::create(CameraMode::Ortho);
         AX_SAFE_RETAIN(_gridCamera);
     }
     else
     {
-        _gridCamera->initOrthographicView(_director->getCanvasSize(), -1024, 1024);
+        _gridCamera->configureOrthographicView(_director->getCanvasSize(), -1024, 1024);
     }
 
     auto visitingCamera = Camera::getVisitingCamera();

axmol/2d/Transition.cpp

@@ -1126,7 +1126,7 @@ void TransitionCrossFade::onEnter()
     Vec2 size         = _director->getCanvasSize();
     LayerColor* layer = LayerColor::create(color);
 
-    auto camera = Camera::createOrthographicView(_director->getCanvasSize(), -1024, 1024);
+    auto camera = Camera::create(CameraMode::Ortho);
 
     // create the first render texture for inScene
     RenderTexture* inTexture =

axmol/2d/TransitionProgress.cpp

@@ -80,7 +80,7 @@ void TransitionProgress::onEnter()
     sprite->setAnchorPoint(Vec2(0.5f, 0.5f));
 
     // render outScene to its texturebuffer
-    auto camera = Camera::createOrthographicView(_director->getCanvasSize(), -1024, 1024);
+    auto camera = Camera::create(CameraMode::Ortho);
 
     {
         RefPtr<RenderTexturePass> pass(RenderTexturePass::obtain(texture), tlx::adopt_object);

axmol/base/Director.cpp

@@ -371,6 +371,12 @@ void Director::setCanvasSize(const Vec2& canvasSize)
 
     updateOverlayCamera();
     updateOffscreenCamera();
+
+    if (_runningScene)
+    {
+        if (auto* camera = _runningScene->getDefaultCamera())
+            camera->onCanvasSizeChanged(canvasSize);
+    }
 }
 
 TextureCache* Director::getTextureCache() const
@@ -404,7 +410,7 @@ Camera* Director::getOverlayCamera()
 {
     if (!_overlayCamera)
     {
-        _overlayCamera = Camera::createOrthographicView(_canvasSizeInPoints, -1024.0f, 1024.0f);
+        _overlayCamera = Camera::create(CameraMode::Ortho);
         _overlayCamera->retain();
         _overlayCamera->setCameraFlag(CameraFlag::DEFAULT);
         _overlayCamera->setDepth(127);
@@ -417,7 +423,7 @@ Camera* Director::getOffscreenCamera()
 {
     if (!_offscreenCamera)
     {
-        _offscreenCamera = Camera::createOrthographicView(_canvasSizeInPoints, -1024.0f, 1024.0f);
+        _offscreenCamera = Camera::create(CameraMode::Ortho);
         _offscreenCamera->retain();
         _offscreenCamera->setCameraFlag(CameraFlag::DEFAULT);
         _offscreenCamera->setDepth(0);
@@ -427,18 +433,18 @@ Camera* Director::getOffscreenCamera()
 
 void Director::updateOverlayCamera()
 {
-    if (_canvasSizeInPoints.width <= 0 || _canvasSizeInPoints.height <= 0 || !_offscreenCamera)
+    if (_canvasSizeInPoints.width <= 0 || _canvasSizeInPoints.height <= 0 || !_overlayCamera)
         return;
 
-    _overlayCamera->initOrthographicView(_canvasSizeInPoints, -1024.0f, 1024.0f);
+    _overlayCamera->configureOrthographicView(_canvasSizeInPoints, -1024.0f, 1024.0f);
 }
 
 void Director::updateOffscreenCamera()
 {
     if (_canvasSizeInPoints.width <= 0 || _canvasSizeInPoints.height <= 0 || !_offscreenCamera)
         return;
 
-    _offscreenCamera->initOrthographicView(_canvasSizeInPoints, -1024.0f, 1024.0f);
+    _offscreenCamera->configureOrthographicView(_canvasSizeInPoints, -1024.0f, 1024.0f);
 }
 
 void Director::setNextDeltaTimeZero(bool nextDeltaTimeZero)

axmol/base/Types.h

@@ -299,6 +299,7 @@ enum class RenderScaleMode
 
 enum class CameraMode
 {
+    None,
     Ortho,        ///< Pure orthographic projection, camera at (w/2, h/2, 0) looking -Z
     Perspective,  ///< Pure perspective projection, user positions camera; default at (0, 1.5, 5) looking at origin
     Classic,      ///< Calibrated perspective at (w/2, h/2, zEye) looking at center; z=0 has no distortion

axmol/base/Utils.cpp

@@ -159,7 +159,8 @@ void captureNode(Node* startNode, std::function<void(RefPtr<Image>)> imageCallba
 
         RefPtr<RenderTexturePass> rtxPass(RenderTexturePass::obtain(rtx), tlx::adopt_object);
 
-        Camera* camera = Camera::createOrthographicView(size, -1024.f, 1024.f);
+        auto camera = Camera::create();
+        camera->configureOrthographicView(size, -1024.f, 1024.f);
 
         rtxPass->begin(camera);
         rtxPass->clearAll();

axmol/scene/Camera.cpp

@@ -42,62 +42,44 @@ Viewport Camera::_defaultViewport;
 
 // start static methods
 
+Camera* Camera::create()
+{
+    auto ret = new Camera();
+    ret->autorelease();
+    return ret;
+}
+
 Camera* Camera::create(CameraMode mode)
 {
-    auto& size = Director::getInstance()->getCanvasSize();
+    auto& canvasSize = Director::getInstance()->getCanvasSize();
     switch (mode)
     {
     case CameraMode::Ortho:
     {
-        auto cam = Camera::createOrthographicView(size, -1024.0f, 1024.0f);
+        auto cam = Camera::create();
+        cam->configureOrthographicView(canvasSize, -1024.0f, 1024.0f);
         return cam;
     }
     case CameraMode::Perspective:
     {
-        auto cam = Camera::createPerspective(60.0f, size.width / size.height, 0.3f, 1000.0f);
+        auto cam = Camera::create();
+        cam->configurePerspective(60.0f, canvasSize.width / canvasSize.height, 0.3f, 1000.0f);
         cam->setPosition3D(Vec3(0.0f, 1.5f, 5.0f));
         cam->lookAt(Vec3(0, 0, 0));
         return cam;
     }
     case CameraMode::Classic:
     {
-        Camera* camera = new Camera();
-        camera->initClassic();
-        camera->autorelease();
-        return camera;
+        auto cam = Camera::create();
+        cam->configureClassicView(canvasSize);
+        cam->setDepth(0);
+        return cam;
     }
     }
     AXASSERT(false, "Invalid CameraMode");
     return nullptr;
 }
 
-Camera* Camera::createPerspective(float fieldOfView, float aspectRatio, float nearPlane, float farPlane)
-{
-    auto ret         = new Camera();
-    ret->_cameraMode = CameraMode::Perspective;
-    ret->initPerspective(fieldOfView, aspectRatio, nearPlane, farPlane);
-    ret->autorelease();
-    return ret;
-}
-
-Camera* Camera::createOrthographic(float zoomX, float zoomY, float nearPlane, float farPlane)
-{
-    auto ret         = new Camera();
-    ret->_cameraMode = CameraMode::Ortho;
-    ret->initOrthographic(zoomX, zoomY, nearPlane, farPlane);
-    ret->autorelease();
-    return ret;
-}
-
-Camera* Camera::createOrthographicView(const Vec2& size, float nearPlane, float farPlane)
-{
-    auto ret         = new Camera();
-    ret->_cameraMode = CameraMode::Ortho;
-    ret->initOrthographicView(size, nearPlane, farPlane);
-    ret->autorelease();
-    return ret;
-}
-
 Camera* Camera::getDefaultCamera()
 {
     // camera nullptr scene init fix #690
@@ -128,15 +110,7 @@ void Camera::setDefaultViewport(const Viewport& vp)
 // end static methods
 
 Camera::Camera()
-    : _eyeZdistance(1)
-    , _zoomFactor(1)
-    , _nearPlane(-1024)
-    , _farPlane(1024)
-    , _zoomFactorNearPlane(10)
-    , _zoomFactorFarPlane(1024)
-{
-    // minggo comment
-    // _frustum.setClipZ(true);
+{
     _renderView = _director->getRenderView();
 }
 
@@ -224,88 +198,107 @@ void Camera::setAdditionalProjection(const Mat4& mat)
     getViewProjectionMatrix();
 }
 
-void Camera::initClassic()
+void Camera::updateProjection()
+{
+    switch (_cameraMode)
+    {
+    case CameraMode::Ortho:
+        Mat4::createOrthographic(_zoom[0] * _zoomFactor, _zoom[1] * _zoomFactor, _nearPlane, _farPlane, &_projection);
+        break;
+
+    case CameraMode::Perspective:
+    case CameraMode::Classic:
+        Mat4::createPerspective(_fieldOfView, _aspectRatio, _nearPlane, _farPlane, &_projection);
+        break;
+    case CameraMode::None:
+        break;
+    }
+
+    _viewProjectionDirty = true;
+    _frustumDirty        = true;
+}
+
+void Camera::configureClassicView(const Vec2& canvasSize)
 {
-    // Classic mode only - calibrated perspective
-    auto& size   = _director->getCanvasSize();
-    float zeye   = _director->getZEye();
-    _fieldOfView = 60.0F;
-    _nearPlane   = 0.5F;
-    _farPlane    = zeye + size.height / 2.0f;
-    initPerspective(_fieldOfView, (float)size.width / size.height, _nearPlane, _farPlane);
-    Vec3 eye(size.width / 2.0f, size.height / 2.0f, zeye), center(size.width / 2.0f, size.height / 2.0f, 0.0f),
-        up(0.0f, 1.0f, 0.0f);
-    setPosition3D(eye);
-    lookAt(center, up);
-    _eyeZdistance = eye.z;
+    const float zeye     = _director->getZEye();
+    const float farPlane = zeye + canvasSize.height * 0.5f;
 
-    setDepth(0);
+    configureClassic(canvasSize.width / canvasSize.height, 0.5f, farPlane);
 
-    if (_zoomFactor != 1.0F)
+    setPosition3D(Vec3(canvasSize.width * 0.5f, canvasSize.height * 0.5f, zeye));
+    lookAt(Vec3(canvasSize.width * 0.5f, canvasSize.height * 0.5f, 0.0f), Vec3::yAxis);
+    _eyeZdistance = zeye;
+
+    if (_zoomFactor != 1.0f)
         applyZoom();
 }
 
-void Camera::updateTransform()
+void Camera::onCanvasSizeChanged(const Vec2& canvasSize)
 {
-    auto& size = _director->getCanvasSize();
+    if (canvasSize.width <= 0.0f || canvasSize.height <= 0.0f)
+        return;
+
     switch (_cameraMode)
     {
+    case CameraMode::Classic:
+        configureClassicView(canvasSize);
+        break;
+
     case CameraMode::Ortho:
-    {
-        initOrthographicView(size, _nearPlane, _farPlane);
+        configureOrthographicView(canvasSize, _nearPlane, _farPlane);
         break;
-    }
+
     case CameraMode::Perspective:
-    {
-        initPerspective(_fieldOfView, (float)size.width / size.height, _nearPlane, _farPlane);
+        _aspectRatio = canvasSize.width / canvasSize.height;
+        updateProjection();
         break;
-    }
-    case CameraMode::Classic:
-    {
-        float zeye = _director->getZEye();
-        initPerspective(_fieldOfView, (float)size.width / size.height, _nearPlane, _farPlane);
-        Vec3 eye(size.width / 2.0f, size.height / 2.0f, zeye), center(size.width / 2.0f, size.height / 2.0f, 0.0f),
-            up(0.0f, 1.0f, 0.0f);
-        _eyeZdistance = eye.z;
+    case CameraMode::None:
         break;
     }
-    }
 }
 
-bool Camera::initPerspective(float fieldOfView, float aspectRatio, float nearPlane, float farPlane)
+void Camera::configureClassic(float aspectRatio, float nearPlane, float farPlane)
 {
+    _cameraMode          = CameraMode::Classic;
+    _fieldOfView         = 60.0F;
+    _aspectRatio         = aspectRatio;
+    _nearPlane           = nearPlane;
+    _farPlane            = farPlane;
+    _zoomFactorNearPlane = _nearPlane;
+    _zoomFactorFarPlane  = _farPlane;
+    updateProjection();
+}
+
+bool Camera::configurePerspective(float fieldOfView, float aspectRatio, float nearPlane, float farPlane)
+{
+    _cameraMode  = CameraMode::Perspective;
     _fieldOfView = fieldOfView;
+    _aspectRatio = aspectRatio;
     _nearPlane   = nearPlane;
     _farPlane    = farPlane;
 
-    if (_zoomFactorFarPlane == 1024)
-        _zoomFactorFarPlane = farPlane;
-    if (_zoomFactorNearPlane == 10)
-        _zoomFactorNearPlane = nearPlane;
-
-    Mat4::createPerspective(_fieldOfView, aspectRatio, _nearPlane, _farPlane, &_projection);
-    _viewProjectionDirty = true;
-    _frustumDirty        = true;
+    _zoomFactorNearPlane = nearPlane;
+    _zoomFactorFarPlane  = farPlane;
 
+    updateProjection();
     return true;
 }
 
-bool Camera::initOrthographic(float zoomX, float zoomY, float nearPlane, float farPlane)
+bool Camera::configureOrthographic(float zoomX, float zoomY, float nearPlane, float farPlane)
 {
-    _zoom[0]   = zoomX;
-    _zoom[1]   = zoomY;
-    _nearPlane = nearPlane;
-    _farPlane  = farPlane;
-    Mat4::createOrthographic(_zoom[0] * _zoomFactor, _zoom[1] * _zoomFactor, _nearPlane, _farPlane, &_projection);
-    _viewProjectionDirty = true;
-    _frustumDirty        = true;
+    _cameraMode = CameraMode::Ortho;
+    _zoom[0]    = zoomX;
+    _zoom[1]    = zoomY;
+    _nearPlane  = nearPlane;
+    _farPlane   = farPlane;
 
+    updateProjection();
     return true;
 }
 
-bool Camera::initOrthographicView(const Vec2& size, float nearPlane, float farPlane)
+bool Camera::configureOrthographicView(const Vec2& size, float nearPlane, float farPlane)
 {
-    initOrthographic(size.width, size.height, nearPlane, farPlane);
+    configureOrthographic(size.width, size.height, nearPlane, farPlane);
     setPosition3D(Vec3(size.width / 2.0F, size.height / 2.0F, 0.0F));
     setRotation3D(Vec3(0.0F, 0.0F, 0.0F));
     return true;
@@ -450,14 +443,14 @@ void Camera::applyZoom()
         if (_zoomFactorFarPlane * _zoomFactor > _farPlane)
         {
             _farPlane = _zoomFactorFarPlane * _zoomFactor;
-            Camera::updateTransform();
+            updateProjection();
         }
 
         // Push the near plane closer the more we zoom in.
         if (_zoomFactorNearPlane * _zoomFactor < _nearPlane)
         {
             _nearPlane = _zoomFactorNearPlane * _zoomFactor;
-            Camera::updateTransform();
+            updateProjection();
         }
 
         this->setPositionZ(_eyeZdistance * _zoomFactor);
@@ -545,19 +538,19 @@ int Camera::getRenderOrder() const
 void Camera::setFOV(float fieldOfView)
 {
     _fieldOfView = fieldOfView;
-    Camera::updateTransform();
+    updateProjection();
 }
 
 void Camera::setFarPlane(float farPlane)
 {
     _farPlane = farPlane;
-    Camera::updateTransform();
+    updateProjection();
 }
 
 void Camera::setNearPlane(float nearPlane)
 {
     _nearPlane = nearPlane;
-    Camera::updateTransform();
+    updateProjection();
 }
 
 void Camera::visit(Renderer* renderer, const Mat4& parentTransform, uint32_t parentFlags)