Legacy:CompactIndex - Unreal Wiki

# Legacy:CompactIndex

### From Unreal Wiki, The Unreal Engine Documentation Site

CompactIndex is a special integer data type used very often in the Unreal Engine. It is used to reduce the size of a integer. However in the worst case scenario it takes up one extra byte (5bytes instead of 4), but this isn't often the case. CompactIndex is for example used to store the length of a string.

A CompactIndex tries to use as less bytes as possible to store the integer's (32bit) value.

## The bytes

### 1st Byte

The `MSB` (Most Significant Bit) flags if the string is in UTF-16 encoding instead of normal ASCII. Thus the MSB only has a meaning when used for string length.

`MSB-1` defines if there's another byte following this byte that should be included with the CompactIndex.

The other 6 bits are used for the value. Therefor the maximum value in the first byte is `(2^6)-1 = 63`

### 2nd to 4th Byte

The `MSB` defines if there's another byte following this byte that should be included with the CompactIndex.

The rest is used for the value. `(2^7)-1 = 127`

### 5th Byte

The whole byte is used for the value. However, because the first 4 bytes already consume 27 of the 32 bits only 5 bits are used in this byte.

## Integer to CompactIndex

B1 = 1st byte of the CompactIndex; B2 = 2nd byte of the CompactIndex; etc.

    //TODO

    final function IntToIndex( int Integer, out byte data[255], out byte ptr )
    {
            local int val;

            val = abs(Integer);
            if( val != Integer )
                    data[ptr] = 0x80; // B1 sign bit

            data[ptr] += val & 0x3f; // B1 data, 6 bits
            val = val >> 6;
            if( val != 0 )
            {
                    data[ptr] += 0x40; // B1 continue bit
                    data[++ptr] = val & 0x7f; // B2 data, 7 bits
                    val = val >> 7;
                    if( val != 0 )
                    {
                            data[ptr] += 0x80; // B2 continue bit
                            data[++ptr] = val & 0x7f; // B3 data, 7 bits
                            val = val >> 7;
                            if( val != 0 )
                            {
                                    data[ptr] += 0x80; // B3 continue bit
                                    data[++ptr] = val & 0x7f; // B4 data, 7 bits
                                    val = val >> 7;
                                    if( val != 0 )
                                    {
                                            data[ptr] += 0x80; // B4 continue bit
                                            data[++ptr] = val & 0x1f; // B5 data, 5 bits
                                    }
                            }
                    }
            }
    }

## CompactIndex to Integer

B1 = 1st byte of the CompactIndex; B2 = 2nd byte of the CompactIndex; etc.

    Integer = B1 & 0x3F;
    if (B1 & 0x40) // got a 2nd byte
    {
      Integer += (B2 & 0x3F) << 6;
      if (B2 & 0x80) // got a 3rd byte
      {
        Integer += (B3 & 0x3F) << 13;
        if (B3 & 0x80) // got a 4th byte
        {
          Integer += (B4 & 0x3F) << 20;
          if (B4 & 0x80) // got a 5th byte
          {
            Integer += (B5 & 0x3F) << 27;
          }
        }
      }
    }

Example:

    final function int IndexToInt( byte data[255], optional byte ptr )
    {
            local byte B1,B2,B3,B4,B5;
            local int Integer;

            B1 = data[ptr++];
            Integer = B1 & 0x3f;
            if((B1 & 0x40)!=0)
            {
                    B2 = data[ptr++];
                    Integer += (B2 & 0x7f) << 6;
                    if((B2 & 0x80)!=0)
                    {
                            B3 = data[ptr++];
                            Integer += (B3 & 0x7f) << 13;
                            if((B3 & 0x80)!=0)
                            {
                                    B4 = data[ptr++];
                                    Integer += (B4 & 0x7f) << 20;
                                    if((B4 & 0x80)!=0)
                                    {
                                            B5 = data[ptr++];
                                            Integer += B5 << 27;
                                    }
                            }
                    }
            }

            if((B1 & 0x80)!=0)
                    Integer = -Integer;

            return Integer;
    }

El Muerte: need this description when I'm going to port by UE2 query specification to the wiki

##### Views

- Legacy
- Discussion
- Current revision

##### Search