Colour Cube

From Burnout Wiki
ColourCube
aka RwColourCube

ColourCubes used in Burnout Paradise.
Resource names Unknown
Type ID 0x2B
Category Generic
Memory
distribution
Main Memory only
Imports Unknown
Imported by Environment Keyframe
Editor
available?
No

ColourCube resources are used by both the EnvironmentSettings and PostFX to change the colour and tone of the world.

A ColourCube is a set of textures forming a CLUT, which is usually colour corrected to give a different art style to the game at a given time (e.g., the red filter when wrecking a vehicle in versions 1.0-1.3 of Burnout Paradise).

Some time after the February 22, 2007 build of Paradise, ColourCubes were added to the EnvironmentSettings folder and were used specifically to give the game a unique art style.

In the 1.4 update to Burnout Paradise, the ColourCubes were changed to a standard CLUT, possibly due to the extended time cycle conflicting with the ColourCube's art style. In the 1.6 update, these were again updated to use a default RGB CLUT.

Structures

rw::graphics::postfx::ColourCube

32-bit

Offset Length Type Name Description Comments
0x0 0x4 uint32_t m_size The number of textures and their width/height. Used to calculate file size (m_size3 * 3 + 16)
0x4 0x4 uint8_t* m_pixels Pointer to the texture data.

64-bit

Offset Length Type Name Description Comments
0x0 0x4 uint32_t m_size The number of textures and their width/height. Used to calculate file size (m_size3 * 3 + 16)
0x4 0x4 Padding
0x8 0x8 uint8_t* m_pixels Pointer to the texture data.

Data

In Burnout Paradise: The Ultimate Box on PC and Burnout Paradise Remastered on PC and PS4, data is in a standard RGB24 format (that is, each pixel takes up 3 bytes, one for each color). Textures in the PS3, Xbox 360, and Switch versions of the game are also RGB24, but swizzled. There is a functional implementation of an Xbox 360 to PC texture converter on GitHub.

Xbox 360 Swizzle Algorithm

The following algorithm assumes that the data is stored as a cube of size m_size*m_size*m_size pixels, accessed according to a certain algorithm. The algorithm is different for Burnout Paradise 32*32*32 cubes and Need for Speed: Hot Pursuit 16*16*16 cubes.

To find the 3 bytes (R, G and B) of pixel data for position (x,y,z) in the PC m_pixels data, 3 bytes (R, G and B) can be read from the Xbox 360 m_pixels data at the offset calculated as follows where x, y and z are represented as a number of bits, x0 to x4, y0 to y4 and z0 to z4 (all values between 0 and m_size - 1).

x y z offset (m_size = 16)
xxxx
3210
yyyy
3210
zzzz
3210
o0=x0
o1=x1
o2=y0
o3=x2
o4=x3
o5=y1
o6=y2
o7=z0
o8=y3^z2
o9=z1
o10=z2
o11=z3
x y z offset (m_size = 32)
xxxxx
43210
yyyyy
43210
zzzzz
43210
o0=x0
o1=x1
o2=y0
o3=x2
o4=x3
o5=x4^y3^z2
o6=y1
o7=y2
o8=z0
o9=y3^z2
o10=z1
o11=y4
o12=z2
o13=z3
o14=z4

Example Ruby implementation:

class Fixnum
  # calculates the number of bytes
  def pixels
    self * 3
  end
end

# calculate offset, in pixels, of where to find the (x,y,z) pixel in the Xbox 360 data
# pixel offset in PC file is m_size * m_size * z + m_size * y + x
def calc_offset(m_size, x, y, z)
  case m_size
  when 16
    calc_offset16(x, y, z)
  when 32
    calc_offset32(x, y, z)
  else
    raise "Unsupported m_size: #{m_size}"
  end
end

def calc_offset16(x, y, z)
  x0 = (x >> 0) & 0b1
  x1 = (x >> 1) & 0b1
  x2 = (x >> 2) & 0b1
  x3 = (x >> 3) & 0b1
  y0 = (y >> 0) & 0b1
  y1 = (y >> 1) & 0b1
  y2 = (y >> 2) & 0b1
  y3 = (y >> 3) & 0b1
  z0 = (z >> 0) & 0b1
  z1 = (z >> 1) & 0b1
  z2 = (z >> 2) & 0b1
  z3 = (z >> 3) & 0b1

  o=(z3<<11)|
    (z2<<10)|
    (z1<<9)|
    ((y3<<8)^(z2<<8))|
    (z0<<7)|
    (y2<<6)|
    (y1<<5)|
    (x3<<4)|
    (x2<<3)|
    (y0<<2)|
    (x1<<1)|
    (x0<<0)
end

def calc_offset32(x, y, z)
  x0 = (x >> 0) & 0b1
  x1 = (x >> 1) & 0b1
  x2 = (x >> 2) & 0b1
  x3 = (x >> 3) & 0b1
  x4 = (x >> 4) & 0b1
  y0 = (y >> 0) & 0b1
  y1 = (y >> 1) & 0b1
  y2 = (y >> 2) & 0b1
  y3 = (y >> 3) & 0b1
  y4 = (y >> 4) & 0b1
  z0 = (z >> 0) & 0b1
  z1 = (z >> 1) & 0b1
  z2 = (z >> 2) & 0b1
  z3 = (z >> 3) & 0b1
  z4 = (z >> 4) & 0b1

  o=(z4<<14)|
    (z3<<13)|
    (z2<<12)|
    (y4<<11)|
    (z1<<10)|
    ((z2<<9)^(y3<<9))|
    (z0<<8)|
    (y2<<7)|
    (y1<<6)|
    ((z2<<5)^(y3<<5)^(x4<<5))|
    (x3<<4)|
    (x2<<3)|
    (y0<<2)|
    (x1<<1)|
    (x0<<0)
end

# read m_size and m_pixels data from Xbox 360 file
# ...

# now, convert the m_pixels data
data="".b
m_size.times do |z|
  m_size.times do |y|
    m_size.times do |x|
      offset = calc_offset(x, y, z)
      pixel_data = m_pixels[offset.pixels...(offset + 1).pixels]
      data << pixel_data
    end
  end
end

# write "converted to PC" data to file
# ...