SpriteKit物理体categoryBitMask的UInt32单位理解困惑咨询

Hey there! I totally get why those UInt32 notations like 0b01 << 1 or 0x01 feel confusing at first—binary shifts and hex values can look like gibberish if you're not used to them. Let's break this down step by step, using SpriteKit's collision logic as context.

First: What's the point of these values? #

SpriteKit's categoryBitMask, collisionBitMask, and contactTestBitMask all use 32-bit unsigned integers (UInt32) where each bit represents a unique "collision category". Think of each bit as a toggle switch: if the bit is set to 1, that category is active; 0 means it's not.

Since we're dealing with individual bits, developers use notations that make it easy to manipulate single bits without messing up others. Let's unpack each common notation:

1. Hexadecimal: 0x01, 0x02, 0x04, etc. #

• The 0x prefix tells Swift this is a hexadecimal number (base 16).
• Each hex value here corresponds to a single bit being set in binary:
  • 0x01 = decimal 1 = binary 00000000 00000000 00000000 00000001 (only the 0th bit is 1)
  • 0x02 = decimal 2 = binary 00000000 00000000 00000000 00000010 (only the 1st bit is 1)
  • 0x04 = decimal 4 = binary 00000000 00000000 00000000 00000100 (only the 2nd bit is 1)
• This pattern doubles each time (0x01, 0x02, 0x04, 0x08, 0x10, etc.), so each value maps to exactly one unique collision category.

2. Binary: 0b01, 0b10, 0b100, etc. #

• The 0b prefix means this is a binary number (base 2).
• This is the most direct way to visualize which bits are set:
  • 0b01 = decimal 1 (0th bit active)
  • 0b10 = decimal 2 (1st bit active)
  • 0b100 = decimal 4 (2nd bit active)
• It’s great for clarity when you want to see exactly which categories you’re working with at a glance.

3. Bit Shift: 1 << 0, 1 << 1, 1 << 2, etc. #

• The << operator shifts the bits of the number to the left by the specified number of positions.
• Let's break down 0b01 << 1 (or 1 << 1):
  • Start with 1 (binary 0b01).
  • Shift left by 1 position: the bit moves from the 0th spot to the 1st spot, resulting in 0b10 (decimal 2).
• This is super useful because you don’t have to memorize hex/decimal values. For example, to set the 5th category (counting from 0), you just write 1 << 4—no math required.

Putting it all together in SpriteKit #

Here’s how you might use these notations in practice:

// Define collision categories using bit shifts (clear and scalable)
let playerCategory: UInt32 = 1 << 0
let enemyCategory: UInt32 = 1 << 1
let bulletCategory: UInt32 = 1 << 2
let powerUpCategory: UInt32 = 1 << 3

// Set up player's collision rules
player.physicsBody?.categoryBitMask = playerCategory
// Player collides with enemies and power-ups
player.physicsBody?.collisionBitMask = enemyCategory | powerUpCategory
// Notify us when player touches bullets or power-ups
player.physicsBody?.contactTestBitMask = bulletCategory | powerUpCategory

The | operator here is a bitwise OR, which combines the bits of multiple categories into one value (so both bits are set to 1).

Once you get the hang of it, these notations will feel way more intuitive than typing raw decimal numbers—they make it immediately clear which collision categories you’re enabling or checking.

内容的提问来源于stack exchange，提问作者Jiri