#define RGB_ON   0xFFFFFFFFL
#define RGB_OFF 0x00000000L

    unsigned char *b = (unsigned char *)buffer8888; // buffer8888 = malloc(4 * 224*256);
    unsigned char *fb = [invaders framebuffer]; //  a pointer to malloc(16 * 0x1000) offset by 0x2400.
    for (i=0; i< 224; i++)
    {
        for (j = 0; j < 256; j+= 8)
        {
            int p;
            //Read the first 1-bit pixel
            // divide by 8 because there are 8 pixels
            // in a byte
            unsigned char pix = fb[(i*(256/8)) + j/8];
            
            //That makes 8 output vertical pixels
            // we need to do a vertical flip
            // so j needs to start at the last line
            // and advance backward through the buffer
            int offset = (255-j)*(224*4) + (i*4);
            unsigned int*p1 = (unsigned int*)(&b[offset]);  // This is where i'm suspicious
            for (p=0; p<8; p++)
            {
                if ( 0!= (pix & (1<<p)))
                    *p1 = RGB_ON;
                else
                    *p1 = RGB_OFF;
                p1-=224;  //next line
            }
        }
}

    // FB_SIZE is 0x4000 - 0x2400 = 7168 bytes
    fn update_buf(&mut self, fb: [u8; FB_SIZE]) {
        for i in 0..224 {
            let mut j = 0;
            while j < 256 {
                let pixel_offset = (i * (256 / 8)) + j / 8;
                let pixel = fb[pixel_offset];
                let mut offset = (255 - j) * (224 * 4) + (i * 4);

                for p in 0..8 {
                    // I do not understand what this is testing, but I think it's correct anyhow.
                    let p1 = if 0 != (pixel & (1 << p)) {
                        0xff
                    } else {
                        0x00
                    };

                    // self.buf is [u8;4 * 224 * 256]
                    self.buf[offset] = p1;
                    self.buf[offset + 1] = p1;
                    self.buf[offset + 2] = p1;
                    // ggez (game framework) works with rgba, but authors config ignores alpha channel.
                    // So, our last byte represents the alpha channel, which we always want turned up 2 max,
                    // even when the other bytes are 0x0.
                    self.buf[offset + 3] = 0xff;
                    offset -= 224;
                }
                j += 8;
            }
        }
    }

DONT THREAD ON ME fucked around with this message at 16:14 on Aug 22, 2018

if (input & 0b00000001) {
  output[0] = 0xffffffff;
} else {
  output[0] = 0x00000000;
}

if (input & 0b00000010) {
  output[1] = 0xffffffff;
} else {
  output[1] = 0x00000000;
}

if (input & 0b00000100) {
  output[2] = 0xffffffff;
} else {
  output[2] = 0x00000000;
}

// etc etc

CRIP EATIN BREAD fucked around with this message at 16:20 on Aug 22, 2018

Lime fucked around with this message at 20:55 on Aug 22, 2018

DONT THREAD ON ME fucked around with this message at 22:24 on Aug 22, 2018

DONT THREAD ON ME fucked around with this message at 22:42 on Aug 22, 2018

DONT THREAD ON ME fucked around with this message at 00:26 on Aug 23, 2018