Табличка всех вариантов пикселей и аттрибутов

[newart]

Пытаюсь составить табличку всех вариантов пикселей и аттрибутов.
Получается же 65536 комбинаций? По 4 байта на пиксель. Итого 256 кб табличка.
Но что то не ладится.

  For pixels.a = 0 To 255
    For attr.a = 0 To 255
      
      Paper = (attr >> 3) & $0F 
      ink   = (attr & 7)  | ((attr & 64) >> 3)
      
      bit = 128
      For z = 0 To 7
        
        If pixels & bit
          
          color.l = color( ink )
          
        Else  
          
          color = color( paper )
          
        EndIf
        
        color.l = $FF000000 | Red(color) << 16 | Green(color) << 8 | Blue(color)
        PokeL(attributes_table + (((pixels << 8) | attr )<<2), color )
                        
        bit >> 1
      Next z 
            
    Next attr
    
  Next pixels 

color(0)  =   0 |   0 << 8 | 0   << 16 
color(1)  =   0 |   0 << 8 | 180 << 16 
color(2)  = 180 |   0 << 8 | 0   << 16
color(3)  = 180 |   0 << 8 | 180 << 16 
color(4)  =   0 | 178 << 8 | 0   << 16 
color(5)  =   0 | 178 << 8 | 180 << 16
color(6)  = 180 | 178 << 8 | 0   << 16 
color(7)  = 180 | 178 << 8 | 180 << 16 

color(8)  =   0 |   0 << 8 | 0   << 16 
color(9)  =   0 |   0 << 8 | 252 << 16 
color(10) = 252 |   0 << 8 | 0   << 16 
color(11) = 252 |   0 << 8 | 252 << 16 
color(12) =   0 | 254 << 8 | 0   << 16 
color(13) =   0 | 254 << 8 | 252 << 16 
color(14) = 252 | 254 << 8 | 0   << 16 
color(15) = 252 | 254 << 8 | 252 << 16 

Для начала не могу уловить есть ли разница в какой байт класть пикселы, а в какой атрибуты.

[Advertiser]

[Titus]

Боюсь, что плохо сформулировано, что ты хочешь, зачем и почему.
А так же, что у тебя не так получается относительно того, чего бы ты хотел)

[newart]

Интересный вриант - http://www.yoyogames.com/blog/89
память спектрума грузится в текстуру и из нее уже рисуется на экран.
Но пока хотелось бы вариант попроще.

- - - Добавлено - - -

Еще немного ускорил:

  For adr.l = 0 To 6143*4 Step 4
    
    chr_pixels.l   =  PeekA(*mem + PeekL(pixels_adress_table + adr) )
    chr_attr.l     =  PeekA(*mem + PeekL(attributes_adress_table + adr)  ) 
    
    CopyMemory( attributes_table + ((((chr_pixels&128) << 8) | (chr_attr))<<2), texture, 4 ):texture + 4
    CopyMemory( attributes_table + ((((chr_pixels&64 ) << 8) | (chr_attr))<<2), texture, 4 ):texture + 4
    CopyMemory( attributes_table + ((((chr_pixels&32 ) << 8) | (chr_attr))<<2), texture, 4 ):texture + 4
    CopyMemory( attributes_table + ((((chr_pixels&16 ) << 8) | (chr_attr))<<2), texture, 4 ):texture + 4
    CopyMemory( attributes_table + ((((chr_pixels&8  ) << 8) | (chr_attr))<<2), texture, 4 ):texture + 4
    CopyMemory( attributes_table + ((((chr_pixels&4  ) << 8) | (chr_attr))<<2), texture, 4 ):texture + 4
    CopyMemory( attributes_table + ((((chr_pixels&2  ) << 8) | (chr_attr))<<2), texture, 4 ):texture + 4
    CopyMemory( attributes_table + ((((chr_pixels&1  ) << 8) | (chr_attr))<<2), texture, 4 ):texture + 4
    
  Next adr 

[Reobne]

Получается же 65536 комбинаций? По 4 байта на пиксель. Итого 256 кб табличка.

65536 комбинаций. По 8 пикселей в комбинации. По 4 байта на пиксель. Итого 2Мб табличка.

[blackmirror]

Зачем только сразу делать по 32 бита на точку? Чем плохо 16 цветов с палитрой? Можно сразу вычислять по 8 точек пользуясь 1(только для pixels) или 3(еще для paper и delta) таблицами на 256 элементов и это будет быстрее чем копировать по 32 байта. В таблице mask каждый бит индекса просто дублируется по 4 раза, то есть если на входе 011000100b, в ячейке должна лежать маска 0FF000F00h.

uint32 Paper = ((attr >> 3) & $0F )*$11111111
uint32 delta  = ((attr&7) ^ (attr >> 3) & $0F )*$11111111
result=paper^(delta&mask[pixels]) 

[newart]

Зачем только сразу делать по 32 бита на точку?

Потому что такой формат текстуры выбран в OpenGL. (по привычке)
Сейчас погуглил, для спектрума можно наверное и GL_R3_G3_B2 обойтись.

Можно сразу вычислять по 8 точек пользуясь 1(только для pixels) или 3(еще для paper и delta) таблицами на 256 элементов и это будет быстрее чем копировать по 32 байта. В таблице mask каждый бит индекса просто дублируется по 4 раза, то есть если на входе 011000100b, в ячейке должна лежать маска 0FF000F00h.

Ничего не понял )

[blackmirror]

newart, чтобы выполнить преобразование нужно из атрибутов вычислить какого цвета должен быть paper, вычислить какого цвета ink, сделать xor между paper и ink чтобы получить delta. Далее все 8 точек красим в цвет paper (delta тоже копируется в 8 точек, или можно и то и другое сразу вытащить из таблицы), из таблицы на 256 элементов вытаскиваем маску для точек которые нужно перекрасить в цвет ink, делаем побитовое and с delta и затем хоr c paper, в итоге точки которые должны быть цвета ink будут перекрашены. Если использовать GL_R3_G3_B2, значит в каждом элементе таблицы будет по 8 байт, причём в таблице масок байты будут только 00 и FF, а для других таблиц байты в пределах 1 элемента будут одинаковые.

[AzAtom]

У меня получается 128 (вариантов атрибутов) * 256 значений (байт сразу) * 2 байта на пиксель (16 битный цвет) = 65536 байт.
FLASH я делаю отдельно, инвертирую байт пикселей.

[newart]

На соседнем форуме один фанат ретрокомпо накатал версию под SSE2. Получилось весьма шустро. Дает на 5-10 fps больше чем мой вариан

Вдруг кому пригодится:

; ZXScreen module by Wilbert

; *SCR has to be 6912 bytes of ZX Spectrum screen
; *Target has to be a buffer for 32 bit color data
; When FlashState is set to 1, pen and ink will be
; switched for blocks that have the flash bit set.

DeclareModule ZXScreen
  
  Declare RenderSCR(*SCR, *Target, FlashState = 0)
  
EndDeclareModule

Module ZXScreen
  
  #FlipY = #True
  #SwapRB = #True
  
  EnableExplicit
  DisableDebugger           ; disabling debugger is required !!
  EnableASM
  
  ;- Data section
  
  DataSection
    ColorLUT:
    Data.l $ff000000,$ffc03020,$ff1040c0,$ffc040c0,$ff10b040,$ffb0c050,$ff10c0e0,$ffc0c0c0
    Data.l $ff000000,$ffff4030,$ff3040ff,$fff070ff,$ff10e050,$ffffe050,$ff50e8ff,$ffffffff
  EndDataSection
    
  ;- Structures
  
  Structure RenderLUT
    bit_expand.l[256 * 8]   ; offset 0
    color.l[256 * 2]        ; offset 8192
    offset.u[768]           ; offset 10240
  EndStructure  
  
  ;- Global variables
  
  Global *Mem, *RenderLUT.RenderLUT
  
  ;- Init lookup table
  
  Procedure SwapRB(color.l)
    !mov eax, [p.v_color]
    !bswap eax
    !ror eax, 8
    ProcedureReturn
  EndProcedure
    
  Procedure InitTable()
    Protected.i bit, col, i, ink, paper, row
    If Not *RenderLUT
      *Mem = AllocateMemory(SizeOf(RenderLUT) + 32)
      *RenderLUT.RenderLUT = (*Mem + 31) & -32
      For i = 0 To 255
        If i & $80
          ink = (i >> 3 & 15) : paper = (i >> 3 & 8) | (i & 7)  ; flash
        Else
          paper = (i >> 3 & 15) : ink = (i >> 3 & 8) | (i & 7)  ; normal
        EndIf
        CompilerIf #SwapRB
          *RenderLUT\color[i << 1    ] = SwapRB(PeekL(?ColorLUT + paper << 2))
          *RenderLUT\color[i << 1 + 1] = SwapRB(PeekL(?ColorLUT + ink   << 2))
        CompilerElse
          *RenderLUT\color[i << 1    ] = PeekL(?ColorLUT + paper << 2)  ; paper
          *RenderLUT\color[i << 1 + 1] = PeekL(?ColorLUT + ink   << 2)  ; ink
        CompilerEndIf
      Next  
      For row = 0 To 7
        For col = 0 To 31
          *RenderLUT\offset[row << 5 | col] = row << 5 | col
          *RenderLUT\offset[row << 5 | col | 256] = row << 5 | col | 2048
          *RenderLUT\offset[row << 5 | col | 512] = row << 5 | col | 4096
        Next
      Next
      For i = 0 To 255
        For bit = 0 To 7
          If i & ($80 >> bit)
            *RenderLUT\bit_expand[i << 3 | bit] = -1
          EndIf
        Next
      Next
    EndIf
  EndProcedure
  
  InitTable()
  
  ;- Main code
  
  CompilerIf #PB_Compiler_Processor = #PB_Processor_x86
    Macro rax : eax : EndMacro
    Macro rbx : ebx : EndMacro
    Macro rcx : ecx : EndMacro
    Macro rdx : edx : EndMacro
    Macro rsi : esi : EndMacro
    Macro rdi : edi : EndMacro
    Macro rsp : esp : EndMacro
  CompilerEndIf
  
  Macro M_8x1(line)
    !movzx eax, byte [rsi + rbx + line*256] ; get bits
    !shl eax, 5
    !movdqa xmm0, [rdx    + rax]            ; expand every bit to 32 bits 
    !movdqa xmm1, [rdx+16 + rax]            ; expand every bit to 32 bits 
    !pand xmm0, xmm3
    !pand xmm1, xmm3
    !pxor xmm0, xmm2
    !pxor xmm1, xmm2
    CompilerIf #FlipY
      !movdqu [rdi    + (7-line)*1024], xmm0
      !movdqu [rdi+16 + (7-line)*1024], xmm1
    CompilerElse
      !movdqu [rdi    + line*1024], xmm0
      !movdqu [rdi+16 + line*1024], xmm1     
    CompilerEndIf
  EndMacro
  
  Procedure RenderSCR(*SCR, *Target, FlashState = 0)
    FlashState = (FlashState << 7) ! $7f
    ; backup registers without push
    ; so references to local variables stay valid
    mov [rsp -  8], rbx
    mov [rsp - 16], rsi
    mov [rsp - 24], rdi
    ; load registers
    mov rdx, *RenderLUT
    mov rsi, *SCR
    mov rdi, *Target
    CompilerIf #FlipY
      add rdi, 188416
    CompilerEndIf    
    ; block loop
    !xor ecx, ecx                           ; ecx = counter (0 - 767)
    !.block_loop:
    movzx eax, byte [rsi+6144 + rcx]        ; get attributes of block
    !and eax, [p.v_FlashState]
    movq xmm0, [rdx+8192 + rax*8]
    !pshufd xmm2, xmm0, 00000000b           ; paper
    !pshufd xmm3, xmm0, 01010101b           ; ink
    !pxor xmm3, xmm2
    movzx ebx, word [rdx+10240 + rcx*2]     ; get block offset
    M_8x1(0)                                ; block line 0
    M_8x1(1)                                ; block line 1
    M_8x1(2)                                ; block line 2
    M_8x1(3)                                ; block line 3
    M_8x1(4)                                ; block line 4
    M_8x1(5)                                ; block line 5
    M_8x1(6)                                ; block line 6
    M_8x1(7)                                ; block line 7
    add rdi, 32
    !inc ecx
    !test ecx, 31                           ; new row check
    !jnz .block_loop
    CompilerIf #FlipY
      sub rdi, 9216
    CompilerElse
      add rdi, 7168
    CompilerEndIf
    !cmp ecx, 768
    !jne .block_loop
    ; restore registers
    mov rdi, [rsp - 24]
    mov rsi, [rsp - 16]
    mov rbx, [rsp -  8]
  EndProcedure
  
EndModule 

[blackmirror]

На соседнем форуме один фанат ретрокомпо накатал версию под SSE2. Получилось весьма шустро. Дает на 5-10 fps больше чем мой вариан

Только у него 2Мб таблиц нету, ему хватает таблиц по 256 элементов - отдельно для точек и отдельно для атрибутов.