Camera::unprojectGL always seems to return the camera position?

[aceinetx]

So I am making a level editor for my game (with zoom & stuff) and i am stuck with converting the touch position to the world position. I tried using Camera::unprojectGL since I saw other people use it and it always seems to return the camera position itself (in other words, it returns visibleSize / 2).
The code:

EditorLayer.cpp

#include "EditorScene.h"
#include "GameObject.h"
#include "EditorUI.h"

using namespace ax;
using namespace ax::extension;

bool EditorScene::init()
{
  if (!Scene::init())
    return false;

  auto winSize = Director::getInstance()->getVisibleSize();

  m_background = Sprite::createWithSpriteFrameName("SN_Background1.png");
  m_background->setPosition(winSize / 2);
  m_background->setScale(2);
  addChild(m_background);

  m_gridNode = DrawNode::create();
  for (int j = -40; j < winSize.y / 40 + 40; j++)
  {
    for (int i = -40; i < winSize.x / 40 + 40; i++)
    {
      Vec2 origin      = Vec2(i * 40, winSize.y - (j * 40));
      Vec2 destination = Vec2(i * 40 + 40, winSize.y - (j * 40) - 40);
      m_gridNode->drawRect(origin, destination, Color4B(127, 127, 127, 255));
    }
  }
  m_gridNode->drawRect({0, 0}, sn::res, Color4B(35, 255, 0, 255), 4.0f);
  addChild(m_gridNode);

  m_batchNode = SpriteBatchNode::create("SN_BlockSheet.png");
  addChild(m_batchNode);

  m_editorUi = EditorUI::create(this);
  addChild(m_editorUi, 9999);

  auto touchListener          = EventListenerTouchOneByOne::create();
  touchListener->onTouchBegan = AX_CALLBACK_2(EditorScene::onTouchBegan, this);
  touchListener->onTouchMoved = AX_CALLBACK_2(EditorScene::onTouchMoved, this);
  touchListener->onTouchEnded = AX_CALLBACK_2(EditorScene::onTouchEnded, this);
  _eventDispatcher->addEventListenerWithSceneGraphPriority(touchListener, this);

  auto keyboardListener          = EventListenerKeyboard::create();
  keyboardListener->onKeyPressed = AX_CALLBACK_2(EditorScene::onKeyPressed, this);
  _eventDispatcher->addEventListenerWithSceneGraphPriority(keyboardListener, this);

  return true;
}

void EditorScene::onEnter()
{
  Scene::onEnter();

  scheduleOnce([this](float) { Inspector::getInstance()->openForCurrentScene(); }, 1.f, "inspectorSchedule");
}

static Vec2 s_initialTouchPos;
static bool s_didSwipe;
bool EditorScene::onTouchBegan(Touch* touch, Event* event)
{
  s_initialTouchPos = touch->getLocation();
  s_didSwipe        = false;

  return true;
}

void EditorScene::onTouchEnded(Touch* touch, Event* event)
{
  Vec2 currentTouchPos = touch->getLocation();
  Vec2 delta           = currentTouchPos - s_initialTouchPos;
  auto winSize         = Director::getInstance()->getVisibleSize();
  auto camera          = Director::getInstance()->getRunningScene()->getDefaultCamera();

  if (!s_didSwipe)
  {
    Vec3 pos3 = camera->unprojectGL(Vec3(currentTouchPos.x, currentTouchPos.y, 0));
    Vec2 pos  = Vec2(pos3.x, pos3.y);

    SNLOG("touch: {} {}", currentTouchPos.x, currentTouchPos.y);
    SNLOG("pos3: {} {} {}", pos3.x, pos3.y, pos3.z);
    SNLOG("pos: {} {}", pos.x, pos.y);
  }
}

void EditorScene::onTouchMoved(Touch* touch, Event* event)
{
  Vec2 currentTouchPos = touch->getLocation();
  Vec2 delta           = currentTouchPos - s_initialTouchPos;
  auto winSize         = Director::getInstance()->getVisibleSize();
  auto camera          = Director::getInstance()->getRunningScene()->getDefaultCamera();

  if ((delta.length() > 15.0f || s_didSwipe))
  {
    s_didSwipe = true;
    camera->setPosition(camera->getPosition() - delta * camera->getZoom());
    updateUI();

    s_initialTouchPos = currentTouchPos;
  }
}

void EditorScene::onKeyPressed(ax::EventKeyboard::KeyCode keyCode, ax::Event* event)
{
  switch (keyCode)
  {
  case EventKeyboard::KeyCode::KEY_O:
    zoomIn();
    break;
  case EventKeyboard::KeyCode::KEY_P:
    zoomOut();
    break;
  default:
    break;
  }
}

void EditorScene::updateUI()
{
  auto camera  = Director::getInstance()->getRunningScene()->getDefaultCamera();
  auto winSize = Director::getInstance()->getVisibleSize();

  m_editorUi->setPosition(camera->getPosition() - winSize / 2 * camera->getZoom());
  m_editorUi->setScale(camera->getZoom());
}

void EditorScene::zoom(float zoomDiff)
{
  auto winSize = Director::getInstance()->getVisibleSize();
  auto camera  = Director::getInstance()->getRunningScene()->getDefaultCamera();
  float zoom   = camera->getZoom();
  if (zoom < 0.5f && zoomDiff < 0)  // zoom too big
    return;
  if (zoom > 1.5f && zoomDiff > 0)  // zoom too small
    return;

  camera->setZoom(zoom + zoomDiff);
  SNLOG("zoom: {}", camera->getZoom());
  updateUI();
}

void EditorScene::zoomIn()
{
  zoom(-0.05f);
}

void EditorScene::zoomOut()
{
  zoom(0.05f);
}

EditorScene.h

#pragma once
#include "SceneFunc.h"
#include "axmol.h"
class EditorUI;

class EditorScene : public ax::Scene
{
  public:
  ax::Sprite* m_background;
  ax::SpriteBatchNode* m_batchNode;
  ax::DrawNode* m_gridNode;
  EditorUI* m_editorUi;

  public:
  bool init() override;

  void onEnter() override;

  bool onTouchBegan(ax::Touch* touch, ax::Event* event);
  void onTouchMoved(ax::Touch* touch, ax::Event* event);
  void onTouchEnded(ax::Touch* touch, ax::Event* event);

  void onKeyPressed(ax::EventKeyboard::KeyCode keyCode, ax::Event* event);

  void updateUI();

  void zoom(float s_zoomDiff);
  void zoomIn();
  void zoomOut();

  CREATE_FUNC(EditorScene);
};

Here's the output:

EditorLayer.cpp[void EditorLayer::onTouchEnded(ax::Touch*, ax::Event*)]:90 - touch: 552.0001 405.9998
EditorLayer.cpp[void EditorLayer::onTouchEnded(ax::Touch*, ax::Event*)]:91 - pos3: 640.0001 359.99997 623.539
EditorLayer.cpp[void EditorLayer::onTouchEnded(ax::Touch*, ax::Event*)]:92 - pos: 640.0001 359.99997
EditorLayer.cpp[void EditorLayer::onTouchEnded(ax::Touch*, ax::Event*)]:90 - touch: 12.000743 499.9997
EditorLayer.cpp[void EditorLayer::onTouchEnded(ax::Touch*, ax::Event*)]:91 - pos3: 640.00085 359.99985 623.539
EditorLayer.cpp[void EditorLayer::onTouchEnded(ax::Touch*, ax::Event*)]:92 - pos: 640.00085 359.99985

[rh101]

Can you please show the expected values versus the actual values?

So, for the output you're displaying in your post above, what values did you actually expect to see, and what is the size of the view?

Also, there are a few methods in the Node class that may help with conversions, such as:

Vec2 convertToNodeSpace(const Vec2& worldPoint) const;
Vec2 convertToWorldSpace(const Vec2& nodePoint) const;
Vec2 convertToNodeSpaceAR(const Vec2& worldPoint) const;
Vec2 convertToWorldSpaceAR(const Vec2& nodePoint) const;
Vec2 convertTouchToNodeSpace(Touch* touch) const;
Vec2 convertTouchToNodeSpaceAR(Touch* touch) const;

[rh101]

Sorry, it's a little hard to work exactly what is going on. Are you able to show screenshots of where you're clicking/touching the screen, and the corresponding expected and actual coordinate values, both at zoom = 1 and zoom != 1 (for example, at 2 or 0.5)?

Also, please explain why you are expecting the values to be as they are. For example, why are you expecting the pos to be 320,180 for a touch position of 320,180? There is no context to the values, so it's a little difficult to understand what it is you're trying to achieve.

[aceinetx]

Sorry, it's a little hard to work exactly what is going on. Are you able to show screenshots of where you're clicking/touching the screen, and the corresponding expected and actual coordinate values, both at zoom = 1 and zoom != 1 (for example, at 2 or 0.5)?

If the touch position is 40, 0, zoom is 1.0, and the camera is at it's initial position, I expect unprojectGL to return these coords:
Vec2(40, 0)
If the touch position is 40, 0, zoom is 0.5, and the camera is at it's initial position, I expect unprojectGL to return these coords:
Vec2(20, 0)
If the touch position is 40, 0, zoom is 2.0, and the camera is at it's initial position, I expect unprojectGL to return these coords:
Vec2(80, 0)

Basically I expect unprojectGL to convert the touch position to the corresponding world space position (accounting for the camera position and zoom of course), but it returns the camera position regardless of zoom

Like here, another person's code that works just fine:

Vec2 EditorScene::getTouchPos(Vec2 point, Camera* camera) {
    Vec3 touchPos3D = camera->unprojectGL(Vec3(point.x, point.y, 0));
    return Vec2(touchPos3D.x, touchPos3D.y);
}
auto touchPos = getTouchPos(touch->getLocation(), getDefaultCamera());

(Sorry if that doesn't explain what I want, i'm just desperate for any answers i've been figuring it out for the past 3 days)

[rh101]

Can you link the original project source code that you're using as a reference (where you saw the use of unprojectGL)?

Just to be frank, copying code from another project, without fully understanding what is going on with it, just ends up wasting time. It seems like something is missing or not correctly set up. For example, is the camera in the reference project orthographic or perspective?

[aceinetx]

Can you link the original project source code that you're using as a reference (where you saw the use of unprojectGL)?

Just to be frank, copying code from another project, without fully understanding what is going on with it, just ends up wasting time. It seems like something is missing or not correctly set up. For example, is the camera in the reference project orthographic or perspective?

Unfortunately the reference project is closed source, i've contacted the developer of it and got the snippet of code from their level editor privately. What I know for sure is that the camera is orthographic

Just so I know, is unprojectGL() working as intended for me? For example, should unprojectGL(Vec3(0, 0, 0)) return values close to visibleSize / 2 with the camera being at it's initial position in the scene?

[rh101]

Unfortunately the reference project is closed source, i've contacted the developer of it and got the snippet of code from their level editor privately.

That's unfortunate, because there may be more code that affects how unprojectGL() is being used.

From what I can see in the engine, unprojectGL() does appear to be working correctly, and other areas of the engine that rely on that method do not seem to have any issues.

If I have some time I'll look into it some more, but perhaps someone else with more understanding of the camera and unprojectGL() may be able to help.

[rh101]

Try the following to see if it will help.

Add this method to your class:

Vec3 EditorScene::unprojectGL(Camera* camera, Point p, float z)
{
    auto pointNear = Vec3(p.x, p.y, 0);
    auto pointFar  = Vec3(p.x, p.y, 1);

    pointNear = camera->unprojectGL(pointNear);
    pointFar  = camera->unprojectGL(pointFar);

    auto x0 = pointNear.x;
    auto y0 = pointNear.y;
    auto z0 = pointNear.z;

    auto x1  = pointFar.x;
    auto y1  = pointFar.y;
    auto z1  = pointFar.z;

    auto x = (((z - z0) / (z1 - z0)) * (x1 - x0)) + x0;
    auto y  = (((z - z0) / (z1 - z0)) * (y1 - y0)) + y0;

    return {x, y, z};
}

Change this line:
Vec3 pos3 = camera->unprojectGL(Vec3(currentTouchPos.x, currentTouchPos.y, 0));

To:
Vec3 pos3 = unprojectGL(camera, currentTouchPos, 0);

That should give you the results you are after, even with camera zooming and moving the camera around. In your original post you mention that you want the world coordinates, yet your use of Camera::unprojectGL indicates that you want the 3D coordinate for that point. If you want to convert the 2D point to 3D, then sure, Camera::unprojectGL can be used, but you need to project a line out from the camera going through both the near and far planes, and pick a specific Z value on that project line. In the example above, a Z value of 0 is used.

Original code is from here.

[aceinetx]

Try the following to see if it will help.

Add this method to your class:

Vec3 EditorScene::unprojectGL(Camera* camera, Point p, float z)
{
    auto pointNear = Vec3(p.x, p.y, 0);
    auto pointFar  = Vec3(p.x, p.y, 1);

    pointNear = camera->unprojectGL(pointNear);
    pointFar  = camera->unprojectGL(pointFar);

    auto x0 = pointNear.x;
    auto y0 = pointNear.y;
    auto z0 = pointNear.z;

    auto x1  = pointFar.x;
    auto y1  = pointFar.y;
    auto z1  = pointFar.z;

    auto x = (((z - z0) / (z1 - z0)) * (x1 - x0)) + x0;
    auto y  = (((z - z0) / (z1 - z0)) * (y1 - y0)) + y0;

    return {x, y, z};
}

Change this line: Vec3 pos3 = camera->unprojectGL(Vec3(currentTouchPos.x, currentTouchPos.y, 0));

To: Vec3 pos3 = unprojectGL(camera, currentTouchPos, 0);

That should give you the results you are after, even with camera zooming and moving the camera around. In your original post you mention that you want the world coordinates, yet your use of Camera::unprojectGL indicates that you want the 3D coordinate for that point. If you want to convert the 2D point to 3D, then sure, Camera::unprojectGL can be used, but you need to project a line out from the camera going through both the near and far planes, and pick a specific Z value on that project line. In the example above, a Z value of 0 is used.

Original code is from here.

Thank youuu it works! I have also found a different solution while researching:

ax::Vec2 convertFromScreenToSpace(ax::Vec2 pos, ax::Camera* camera, bool reverseY)
{
  auto director   = Director::getInstance();
  auto winSize    = director->getVisibleSize();
  auto loc        = director->convertToGL(Vec2(pos.x, (!reverseY ? winSize.y - pos.y : pos.y)));
  auto screenSize = Director::getInstance()->getWinSizeInPixels();
  return Vec2((((loc.x - winSize.x / 2) * camera->getZoom()) + camera->getPositionX()),
              (((loc.y - winSize.y / 2) * camera->getZoom()) + camera->getPositionY()));
}

From here