Cocos2d-x happy to make people happy game 2: large collection of Coordinate Systems

Cocos2d involves four coordinate systems:

• GL Coordinate SystemCocos2D uses OpenglES as the graphics library, so it uses the OpenglES coordinate system. The GL coordinate system origin is in the lower left corner of the screen,X axis to the right, Y axis to the up.
  
  • Screen Coordinate SystemApple's Quarze2D uses different coordinate systems, with the origin in the upper left corner of the screen,X axis to the right, Y axis down.
    This coordinate system is used for the position information transmitted by the ios screen touch event CCTouch. Therefore, before responding to a touch event in cocos2d, you must first convert the touch point to the GL coordinate system. You can use convertToGL of CCDirector to complete this conversion.
    
    
    • World coordinate systemIt is also called the absolute coordinate system. The world coordinate system is consistent with the GL coordinate system,The origin is in the lower left corner of the screen..
      Elements in cocos2d are hierarchical structures with parent-child relationships. We set the position of an element through CCNode to use the local coordinate system relative to its parent node rather than the world coordinate system. Finally, cocos2d maps the local coordinates of these elements to the coordinates of the world coordinate system.
      
      • Local Coordinate SystemCoordinates relative to the parent object.
        

        [Obj. parent convertToWorldSpace: [obj position]; // obtain the obj world coordinate [obj. parent convertToNodeSpace: [obj position]; // obtain the local coordinates of obj [[CCDirector sharedDirector] convertToGL: ***** ()]; // obtain the GL coordinates [[CCDirector shareddire] convertToUI: ***** ()]; // obtain the screen coordinates

        
        

        Whether it is 2d or 3d development, the most important thing to understand is the coordinate system. If this is a mess, there will be no rush. So when we play cocos2d, we first need to figure out all the things related to coordinates.
        Two basic coordinate systems: the screen coordinate system and the GL coordinate system.
        The X axis of the screen coordinate system is right-facing, and the Y axis is down. The default origin is in the upper left corner.
        The X axis of the GL coordinate system is right-facing, and the Y axis is facing up. The default origin is in the lower left corner.
        Before calling any function that requires location setting or obtaining location information from the function, you must specify the coordinate system used by the function. For example, to call the setPosition function of the CCNode class, it uses the GL coordinate system. For example, when processing a touch event, the coordinates in the CCTouch object are the screen coordinate system.
        The most commonly used coordinate systems are Node-related local coordinate systems. This structure is the same as that of the scenario tree used in 3D. Therefore, the location obtained from the Node is the local coordinate of the Node. You must use a specific function to convert the local coordinate to the world coordinate. In addition, the coordinates here use the GL coordinate system. There are several convenient functions in the CCNode object for coordinate transformation. The convertToWorldSpace method can convert coordinates in the local coordinate system based on the current node to the world coordinate system. The convertToNodeSpace method can convert the world coordinates to the local coordinate system of the current node.
        In addition, by the way, the click hit problem will involve the mutual conversion of some coordinate systems. At the same time, we have to mention the size of various objects in cocos2d. In cocos2d, The CCNode object has the scaling methods setScaleX and setScaleY. Therefore, when obtaining the object size, you must specify the original size of the object as needed, or the scaled size. Of course, cocos2d provides corresponding functions to complete these operations.
        The getContentSize function is used to obtain the original node size.
        The boundingBox function is used to obtain the size of the box after resizing and rotation.
        A simple example:
        Bool ret = CCRect: CCRectContainsPoint (
        This-> boundingBox (), this-> getParent ()-> convertTouchToNodeSpace (pTouch ));
        The function of this example is to determine whether the current touch operation occurs on your node object. PTouch is the pointer to the CCTouch object, which contains the coordinates of the occurrence points of the current touch event.
        The CCRectContainsPoint function is used to determine whether a vertex is within a rectangle. We want to use this function to determine whether the point of the current touch operation is within the range of the current node.
        This-> boundingBox () method obtains the local coordinate size after the current node object is scaled under the parent node object and is expressed in the GL coordinate system.
        The coordinates in the pTouch object are the screen coordinate system, so they must be converted to the GL coordinate system and then to the local coordinates of the parent node. Fortunately, the convertTouchToNodeSpace function completes the two conversions at a time. You can refer to the source code of the database, which has a specific computing process.
        After all the data is converted to the same coordinate system, you can use the CCRectContainsPoint function to complete the final judgment operation.
        The last point is to use relative coordinates as much as possible. In other words, when setting the size and position of all objects in the program, the size and position of the parent object should be taken as the basis. In this way, you only need to adjust the size of the root object when the program is published at different resolutions.

        
        

        By the way, cocos2dx can be used to determine click hits:

        [Cpp]View plaincopy
        1. // Reload
        2. Virtual bool ccTouchBegan (CCTouch * touch, CCEvent * pEvent );
        3. Virtual void ccTouchMoved (CCTouch * touch, CCEvent * pEvent );
        4. Virtual void ccTouchEnded (CCTouch * touch, CCEvent * pEvent );
        5. Virtual void onEnter ();
        6. Virtual void onExit ();
        8. // Add support for touch events
        9. Void CTestLayer: onEnter ()
        10. {
        11. CCLayer: onEnter ();
        12. This-> setTouchEnabled (true );
        13. CCDirector: sharedDirector ()-> getTouchDispatcher ()-> addTargetedDelegate (this, 0, true );
        14. }
        16. Void CTestLayer: onExit ()
        17. {
        18. CCLayer: onExit ();
        19. CCDirector: sharedDirector ()-> getTouchDispatcher ()-> removeDelegate (this );
        20. }
        21. //////////////////////////////////////// //////////////////////////////////////// ////////////////
        22. // Use your own coordinate system to determine relative to the origin
        23. Bool checkTouchInSelf (CCTouch * touch );
        24. // Use your coordinate system to judge relative to the anchor.
        25. Bool checkTouchInSelf_AR (CCTouch * touch );
        26. // Use the coordinate system of the parent element and its position in the parent coordinate to determine
        27. Bool checkTouchInSelf_Parent (CCTouch * touch );
        29. //______________________________________________________________________________________________
        30. // Use your own coordinate system to determine relative to the origin
        31. Bool CTestLayer: checkTouchInSelf (CCTouch * touch)
        32. {
        33. // Solution 1
        34. // Convert the click point to the coordinates in the coordinate system.
        35. CCPoint pt = convertTouchToNodeSpace (touch );
        36. Printf ("pt. x = %. 1f pt. y = %. 1f \ n", pt. x, pt. y );
        37. Int nw = getContentSize (). width;
        38. Int nh = getContentSize (). height;
        39. CCRect rc (0, 0, nw, nh );
        40. If (rc. containsPoint (pt ))
        41. {
        42. // Obtain the world coordinate value of the clicked OpenGL
        43. CCPoint touchPoint = touch-> getLocation ();
        44. Printf ("ccTouchBegan x = %. 1f y = %. 1f \ n", touchPoint. x, touchPoint. y );
        45. Return true;
        46. }
        47. Return false;
        48. }
        49. //______________________________________________________________________________________________
        50. // Use your coordinate system to judge relative to the anchor.
        51. Bool CTestLayer: checkTouchInSelf_AR (CCTouch * touch)
        52. {
        53. // Solution 2
        54. // Convert the click point to the coordinates in the coordinate system, relative to the anchor.
        55. CCPoint ptAR = convertTouchToNodeSpaceAR (touch );
        56. Printf ("ptAR. x = %. 1f ptAR. y = %. 1f \ n", ptAR. x, ptAR. y );
        57. CCPoint pp = this-> getAnchorPoint ();
        58. Int nw = getContentSize (). width;
        59. Int nh = getContentSize (). height;
        60. Int nx =-(nw * pp. x );
        61. Int ny =-(nh * pp. y );
        62. CCRect rcar (nx, ny, nw, nh );
        63. If (rcar. containsPoint (ptAR ))
        64. {
        65. // Obtain the world coordinate value of the clicked OpenGL
        66. CCPoint touchPoint = touch-> getLocation ();
        67. Printf ("ccTouchBegan x = %. 1f y = %. 1f \ n", touchPoint. x, touchPoint. y );
        68. Return true;
        69. }
        70. Return false;
        71. }
        72. //______________________________________________________________________________________________
        73. // Use the coordinate system of the parent element and its position in the parent coordinate to determine
        74. Bool CTestLayer: checkTouchInSelf_Parent (CCTouch * touch)
        75. {
        76. // Solution 3
        77. // Obtain the world coordinate value of the clicked OpenGL
        78. CCPoint touchPoint = touch-> getLocation ();
        79. // Convert the clicked position to the relative coordinates in the coordinate system of the parent Element
        80. CCPoint pt = getParent ()-> convertToNodeSpace (touchPoint );
        81. Printf ("pt. x = %. 1f, pt. y = %. 1f \ n", pt. x, pt. y );
        82. // Obtain the range of position in the coordinate system of the parent element.
        83. CCRect rect = boundingBox ();
        84. Printf ("rect. l = %. 1f, rect. B = %. 1f, rect. r = %. 1f, rect. t = %. 1f \ n ",\
        85. Rect. getMinX (), rect. getMinY (), rect. getMaxX (), rect. getMaxY ());
        86. // Determine whether the cursor is in its own range. All the above judgments are calculated in the parent element coordinate system.
        87. If (rect. containsPoint (pt ))
        88. {
        89. Printf ("ccTouchBegan x = %. 1f y = %. 1f \ n", touchPoint. x, touchPoint. y );
        90. Return true;
        91. }
        92. Return false;
        93. }