[VM][FMTOWNS] Some devices are enabled to compile.

[csp-qt/common_source_project-fm7.git] / source / src / vm / fmtowns / towns_vram.h

diff --git a/source/src/vm/fmtowns/towns_vram.h b/source/src/vm/fmtowns/towns_vram.h
index 66c124f..00ebe01 100644 (file)
--- a/source/src/vm/fmtowns/towns_vram.h
+++ b/source/src/vm/fmtowns/towns_vram.h
@@ -14,6 +14,11 @@
 #include "../vm.h"
 #include "../emu.h"
 #include "device.h"
+#include "../../common.h"
+
+#if defined(_USE_QT)
+#include <QMutex>
+#endif
 
 // Older Towns.
 #define TOWNS_VRAM_ADDR_MASK 0x7ffff
@@ -42,14 +47,25 @@ protected:
        scrntype_t *framebuffer0[2]; // Frame Buffer Layer 0. Not saved.
        scrntype_t *framebuffer1[2]; // Frame Buffer Layer 1. Not saved.
 
-       int framebuffer_width[2];
-       int framebuffer_height[2];
+       int framebuffer_width[2][2]; // [Bank][Layer]
+       int framebuffer_height[2][2];
+       int framebuffer_stride[2][2];
+       int framebuffer_size[2][2];
 
        uint16_t *vram_ptr[2];   // Layer [01] address.
        uint32_t vram_size[2];   // Layer [01] size [bytes].
        uint32_t vram_offset[2]; // Layer [01] address offset.
-
-       scrntype_t table_32768c[65536];
+#if defined(_USE_QT)
+       // If you use other framework, place mutex lock.
+       QMutex vram_lock[2][2]; // [bank][layer];
+#endif
+       
+       __DECL_ALIGNED(sizeof(scrntype_t) * 4) scrntype_t table_32768c[65536];
+       __DECL_ALIGNED(sizeof(scrntype_t) * 4) scrntype_t alpha_32768c[65536];
+       __DECL_ALIGNED(sizeof(uint16_t) * 8)   uint16_t   mask_32768c[65536];
+       
+       __DECL_ALIGNED(sizeof(scrntype_t) * 4) scrntype_t alpha_16c[8 * 8 * 2];
+       __DECL_ALIGNED(sizeof(uint16_t) * 8)   uint16_t   mask_16c[8 * 8];
        
        uint32_t layer_virtual_width[2];
        uint32_t layer_virtual_height[2];
@@ -63,17 +79,14 @@ protected:
 
        bool dirty_flag[0x80000 >> 3]; // Per 8bytes : 16pixels(16colors) / 8pixels(256) / 4pixels(32768)
 
-#if 0
-       // WIP: Still not use mask rendering.
-       uint16_t mask_32768_word[0x80000 >> 1];
-       uint16_t alpha_32768_word[0x80000 >> 1];
-       uint8_t  alpha_32768_byte[0x80000 >> 1];
-
-       uint16_t mask_16_word[0x80000 << 1];
-       uint16_t alpha_16_word[0x80000 << 1];
-       uint8_t  alpha_16_byte[0x80000 << 1];
+       scrntype_t alpha_buffer_32768[0x80000 >> 1];
+       scrntype_t alpha_buffer_16[0x80000 << 1];
 
-#endif 
+       uint16_t mask_buffer_32768[0x80000 >> 1];
+       uint16_t mask_buffer_32768_neg[0x80000 >> 1];
+       uint8_t  mask_buffer_16[0x80000];
+       uint8_t  mask_buffer_16_neg[0x80000];
+       
        
        uint16_t vram[0x80000 / 2]; // Related by machine.
        
@@ -122,11 +135,38 @@ protected:
        bool has_hardware_rendering;
        bool has_hardware_blending;
        // End.
+
+       void lock_framebuffer(int layer, int bank)
+       {
+#if defined(_USE_QT)
+               vram_lock[bank][layer].lock();
+#endif
+       }
+       void unlock_framebuffer(int layer, int bank)
+       {
+#if defined(_USE_QT)
+               vram_lock[bank][layer].unlock();
+#endif
+       }
+
+       
 public:
        TOWNS_VRAM(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
        {
                memset(vram, 0x00, sizeof(vram));
-               render_buffer = NULL;
+               for(int bank = 0; bank < 2; bank++) {
+                       for(int layer = 0; layer < 2; layer++) {
+                               framebuffer_width[bank][layer] = 640;
+                               framebuffer_height[bank][layer] = 480;
+                               framebuffer_stride[bank][layer] = 640 * sizeof(scrntype_t);
+                               framebuffer_size[bank][layer] = 640 * 480 * sizeof(scrntype_t);
+                               if(layer == 0) {
+                                       framebuffer0[bank] = NULL;
+                               } else {
+                                       framebuffer1[bank] = NULL;
+                               }
+                       }
+               }
                page_modes[0] = page_modes[1] = page_modes[2] = page_modes[3] = 0;
                packed_access_mask_hi = packed_access_mask_lo = 0xff;
                write_plane_mask = 0xffffffff;
@@ -165,8 +205,21 @@ public:
        void set_render_features(bool blending_from_buffer, bool rendering_framebuffer);
        // End.
        
-       void set_context_renderbuffer(scrntype_t *p, uint32_t size){
-               render_buffer = p;
+       void set_context_renderbuffer(scrntype_t *p, int layer, int bank, uint32_t width, uint32_t height, uint32_t stride){
+               if((layer > 1) || (layer < 0)) return;
+               if((bank > 1) || (bank < 0)) return;
+               lock_framebuffer(layer, bank);
+               framebuffer_width[bank][layer] = width;
+               framebuffer_height[bank][layer] = height;
+               framebuffer_stride[bank][layer] = stride * sizeof(scrntype_t);
+               framebuffer_size[bank][layer] = stride * height * sizeof(scrntype_t);
+               if(layer == 0) {
+                       framebuffer0[bank] = p;
+               } else {
+                       framebuffer1[bank] = p;
+               }
+               unlock_framebuffer(layer, bank);
+       
        };
 };