[Draw][Qt] Prepare to immutable texture buffer.
message("* qt/osd")
-SET(THIS_LIB_VERSION 2.16.0)
+SET(THIS_LIB_VERSION 2.17.0)
set(s_qt_osd_headers
osd_base.h
#include "csp_logger.h"
#include "menu_flags.h"
#include "../osd.h"
+#include "mainwidget_base.h"
// buttons
#ifdef MAX_BUTTONS
extern EMU *emu;
extern CSP_Logger *csp_logger;
-EmuThreadClass::EmuThreadClass(META_MainWindow *rootWindow, USING_FLAGS *p, QObject *parent)
+EmuThreadClass::EmuThreadClass(Ui_MainWindowBase *rootWindow, USING_FLAGS *p, QObject *parent)
: EmuThreadClassBase(rootWindow, p, parent)
{
emu = new EMU(rMainWindow, rMainWindow->getGraphicsView(), using_flags);
bool get_power_state(void);
public:
- EmuThreadClass(META_MainWindow *rootWindow, USING_FLAGS *p, QObject *parent = 0);
+ EmuThreadClass(Ui_MainWindowBase *rootWindow, USING_FLAGS *p, QObject *parent = 0);
~EmuThreadClass();
void run() { doWork("");}
bool now_debugging();
<file alias="gles2/ntsc_pass1.glsl">../../gui/gles2/ntsc_pass1.glsl</file>
<file alias="gles2/ntsc_pass2.glsl">../../gui/gles2/ntsc_pass2.glsl</file>
- <file alias="gl4_3/chromakey_fragment_shader.glsl">../../gui/gl4_3/chromakey_fragment_shader.glsl</file>
- <file alias="gl4_3/chromakey_fragment_shader2.glsl">../../gui/gl4_3/chromakey_fragment_shader2.glsl</file>
- <file alias="gl4_3/fragment_shader.glsl">../../gui/gl4_3/fragment_shader.glsl</file>
- <file alias="gl4_3/icon_fragment_shader.glsl">../../gui/gl4_3/icon_fragment_shader.glsl</file>
- <file alias="gl4_3/normal_fragment_shader.glsl">../../gui/gl4_3/normal_fragment_shader.glsl</file>
+ <file alias="gl4_5/chromakey_fragment_shader.glsl">../../gui/gl4_5/chromakey_fragment_shader.glsl</file>
+ <file alias="gl4_5/chromakey_fragment_shader2.glsl">../../gui/gl4_5/chromakey_fragment_shader2.glsl</file>
+ <file alias="gl4_5/fragment_shader.glsl">../../gui/gl4_5/fragment_shader.glsl</file>
+ <file alias="gl4_5/icon_fragment_shader.glsl">../../gui/gl4_5/icon_fragment_shader.glsl</file>
+ <file alias="gl4_5/normal_fragment_shader.glsl">../../gui/gl4_5/normal_fragment_shader.glsl</file>
- <file alias="gl4_3/vertex_shader.glsl">../../gui/gl4_3/vertex_shader.glsl</file>
- <file alias="gl4_3/tmp_vertex_shader.glsl">../../gui/gl4_3/tmp_vertex_shader.glsl</file>
+ <file alias="gl4_5/vertex_shader.glsl">../../gui/gl4_5/vertex_shader.glsl</file>
+ <file alias="gl4_5/tmp_vertex_shader.glsl">../../gui/gl4_5/tmp_vertex_shader.glsl</file>
- <file alias="gl4_3/led_fragment_shader.glsl">../../gui/gl4_3/led_fragment_shader.glsl</file>
- <file alias="gl4_3/led_vertex_shader.glsl">../../gui/gl4_3/led_vertex_shader.glsl</file>
+ <file alias="gl4_5/led_fragment_shader.glsl">../../gui/gl4_5/led_fragment_shader.glsl</file>
+ <file alias="gl4_5/led_vertex_shader.glsl">../../gui/gl4_5/led_vertex_shader.glsl</file>
- <file alias="gl4_3/grids_fragment_shader.glsl">../../gui/gl4_3/grids_fragment_shader.glsl</file>
- <file alias="gl4_3/grids_vertex_shader.glsl">../../gui/gl4_3/grids_vertex_shader.glsl</file>
- <file alias="gl4_3/grids_vertex_shader_fixed.glsl">../../gui/gl4_3/grids_vertex_shader_fixed.glsl</file>
- <file alias="gl4_3/ntsc_pass1.glsl">../../gui/gl4_3/ntsc_pass1.glsl</file>
- <file alias="gl4_3/ntsc_pass2.glsl">../../gui/gl4_3/ntsc_pass2.glsl</file>
+ <file alias="gl4_5/grids_fragment_shader.glsl">../../gui/gl4_5/grids_fragment_shader.glsl</file>
+ <file alias="gl4_5/grids_vertex_shader.glsl">../../gui/gl4_5/grids_vertex_shader.glsl</file>
+ <file alias="gl4_5/grids_vertex_shader_fixed.glsl">../../gui/gl4_5/grids_vertex_shader_fixed.glsl</file>
+ <file alias="gl4_5/ntsc_pass1.glsl">../../gui/gl4_5/ntsc_pass1.glsl</file>
+ <file alias="gl4_5/ntsc_pass2.glsl">../../gui/gl4_5/ntsc_pass2.glsl</file>
</qresource>
</RCC>
message("* qt/gui")
-set(THIS_LIB_VERSION 2.17.1)
+set(THIS_LIB_VERSION 2.18.0)
#include(cotire)
#include(PrecompiledHeader)
gl/qt_glutil_gl_tmpl.h
gl2/qt_glutil_gl2_0.h
gl3/qt_glutil_gl3_0.h
- gl4_3/qt_glutil_gl4_3.h
+ gl4_5/qt_glutil_gl4_5.h
gles2/qt_glutil_gles_2.h
commonclasses.h
qt_glpack.cpp
gl2/qt_glutil_gl2_0.cpp
gl3/qt_glutil_gl3_0.cpp
- gl4_3/qt_glutil_gl4_3.cpp
+ gl4_5/qt_glutil_gl4_5.cpp
gles2/qt_glutil_gles_2.cpp
qt_glevents.cpp
qt_dialogs.cpp
using_flags = NULL;
if(p_osd != NULL) using_flags = p_osd->get_config_flags();
screen = QGuiApplication::primaryScreen();
-
+
+
+ is_shared_glcontext = false;
+ glContext = NULL;
draw_screen_buffer = NULL;
-
+ if(p_osd != NULL) {
+ p_osd->set_glview(glv);
+ //printf("OSD/Context sharing succeeded.ADDR=%08x GLES=%s\n", glContext, (glContext->isOpenGLES()) ? "YES" : "NO");
+ }
do_change_refresh_rate(screen->refreshRate());
connect(screen, SIGNAL(refreshRateChanged(qreal)), this, SLOT(do_change_refresh_rate(qreal)));
- connect(this, SIGNAL(sig_update_screen(bitmap_t *)), glv, SLOT(update_screen(bitmap_t *)), Qt::QueuedConnection);
+ connect(this, SIGNAL(sig_update_screen(void *, bool)), glv, SLOT(update_screen(void *, bool)), Qt::QueuedConnection);
connect(this, SIGNAL(sig_update_osd()), glv, SLOT(update_osd()), Qt::QueuedConnection);
connect(this, SIGNAL(sig_push_frames_to_avio(int, int, int)), glv->extfunc, SLOT(paintGL_OffScreen(int, int, int)));
- connect(this, SIGNAL(sig_map_texture()), glv, SLOT(do_map_vram_texture()));
- connect(this, SIGNAL(sig_unmap_texture()), glv, SLOT(do_unmap_vram_texture()));
- connect(glv, SIGNAL(sig_map_texture_reply(bool, void *, int, int)), this, SLOT(do_recv_texture_map_status(bool, void *, int, int)));
- connect(glv, SIGNAL(sig_unmap_texture_reply()), this, SLOT(do_recv_texture_unmap_status()));
//connect(this, SIGNAL(sig_call_draw_screen()), p_osd, SLOT(draw_screen()));
//connect(this, SIGNAL(sig_call_no_draw_screen()), p_osd, SLOT(no_draw_screen()));
void DrawThreadClass::do_draw_one_turn(bool _req_draw)
{
- if((mapped_drawn) && (_req_draw)) {
- emit sig_update_screen(NULL);
- } else if((_req_draw) && (draw_screen_buffer != NULL)) {
- emit sig_update_screen(draw_screen_buffer);
+ if((_req_draw) && (draw_screen_buffer != NULL)) {
+ emit sig_update_screen((void *)draw_screen_buffer, mapped_drawn);
} else {
if(ncount == 0) emit sig_update_osd();
}
wait_count += (wait_refresh * 1.0);
}
-void DrawThreadClass::do_update_screen(bitmap_t *p)
+void DrawThreadClass::do_update_screen(void *p, bool is_mapped)
{
- draw_screen_buffer = p;
+ draw_screen_buffer = (bitmap_t*)p;
bDrawReq = true;
+ mapped_drawn = is_mapped;
}
void DrawThreadClass::do_req_encueue_video(int count, int width, int height)
mapping_width = 0;
mapping_height = 0;
if(glv->is_ready_to_map_vram_texture()) {
- emit sig_map_texture();
textureMappingSemaphore->acquire();
//mapping_pointer = (scrntype_t *)(glv->do_map_vram_texture(&mapping_width, &mapping_height));
//if(mapping_pointer == NULL) {
class CSP_Logger;
class QSemaphore;
class QScreen;
+class QOpenGLContext;
class USING_FLAGS;
QT_BEGIN_NAMESPACE
+#include "../osd_types.h"
class DLL_PREFIX DrawThreadClass : public QThread {
Q_OBJECT
OSD *p_osd;
Ui_MainWindowBase *MainWindow;
GLDrawClass *glv;
-
+
+ QOpenGLContext *glContext;
+ bool is_shared_glcontext;
+
qreal refresh_rate;
qreal wait_refresh;
qreal wait_count;
void doExit(void);
void doDraw(bool flag);
void do_change_refresh_rate(qreal rate);
- void do_update_screen(bitmap_t *p);
+ void do_update_screen(void *p, bool is_mapped);
void do_req_encueue_video(int count, int width, int height);
void do_draw_one_turn(bool _req_draw);
void do_set_frames_per_second(double fps);
void req_map_screen_texture();
void req_unmap_screen_texture();
+
+ bool is_glcontext_shared(void)
+ {
+ return is_shared_glcontext;
+ }
+
+ QOpenGLContext *get_gl_context(void)
+ {
+ return glContext;
+ }
signals:
int sig_draw_frames(int);
int message_changed(QString);
- int sig_update_screen(bitmap_t *);
+ int sig_update_screen(void *, bool);
int sig_update_osd(void);
int sig_draw_timing(bool);
int sig_push_frames_to_avio(int, int, int);
#include <QTextCodec>
#include <QWaitCondition>
#include <QWidget>
+#include <QOpenGLContext>
#include <SDL.h>
#include "emu_thread_tmpl.h"
-
+#include "mainwidget_base.h"
#include "qt_gldraw.h"
#include "common.h"
//#include "csp_logger.h"
#include "menu_flags.h"
-EmuThreadClassBase::EmuThreadClassBase(META_MainWindow *rootWindow, USING_FLAGS *p, QObject *parent) : QThread(parent) {
+EmuThreadClassBase::EmuThreadClassBase(Ui_MainWindowBase *rootWindow, USING_FLAGS *p, QObject *parent) : QThread(parent) {
MainWindow = rootWindow;
using_flags = p;
p_config = p->get_config_ptr();
+
+
+ is_shared_glcontext = false;
+ glContext = NULL;
+ glContext = new QOpenGLContext(this);
+
+ if(glContext != NULL) {
+ glContext->setShareContext(rootWindow->getGraphicsView()->context());
+ glContext->create();
+ }
+ if(glContext->isValid()) {
+ is_shared_glcontext = true;
+ printf("Context sharing succeeded.ADDR=%08x GLES=%s\n", glContext, (glContext->isOpenGLES()) ? "YES" : "NO");
+ }
bRunThread = true;
prev_skip = false;
};
EmuThreadClassBase::~EmuThreadClassBase() {
+
delete drawCond;
key_fifo->release();
#include "commonclasses.h"
#include "config.h"
-class META_MainWindow;
class EMU;
class QWaitCondition;
+class QOpenGLContext;
class USING_FLAGS;
+class Ui_MainWindowBase;
+//class META_MainWindow;
QT_BEGIN_NAMESPACE
enum {
int mouse_y;
FIFO *key_fifo;
+ QOpenGLContext *glContext;
+ bool is_shared_glcontext;
uint32_t key_mod;
QWaitCondition *drawCond;
QMutex *keyMutex;
- class META_MainWindow *MainWindow;
+ //class META_MainWindow *MainWindow;
+ Ui_MainWindowBase *MainWindow;
QElapsedTimer tick_timer;
bool bRunThread;
};
public:
- EmuThreadClassBase(META_MainWindow *rootWindow, USING_FLAGS *p, QObject *parent = 0);
+ EmuThreadClassBase(Ui_MainWindowBase *rootWindow, USING_FLAGS *p, QObject *parent = 0);
~EmuThreadClassBase();
virtual void run() {};
void set_tape_play(bool);
virtual void initLocalGLObjects(void) {}
virtual void initOsdObjects(void) {}
- virtual void uploadMainTexture(QImage *p, bool chromakey) {}
+ virtual void uploadMainTexture(QImage *p, bool chromakey, bool was_mapped) {}
virtual void drawScreenTexture(void) {}
virtual void drawGrids(void) { }
virtual void do_set_display_osd(bool onoff) { }
virtual void do_display_osd_leds(int lednum, bool onoff) { }
virtual void do_set_led_width(int bitwidth) { }
-
+ virtual bool is_mapped_buffer(void) { return false; }
+ virtual GLuint get_mapped_buffer_num(int region) { return (GLuint)0; }
signals:
int sig_push_image_to_movie(int, int, int, QImage *);
};
#include <QRect>
#include <QOpenGLFunctions_2_0>
+#include "osd_types.h"
#include "qt_gldraw.h"
#include "qt_glutil_gl2_0.h"
#include "menu_flags.h"
uploadBitmapTexture(p);
}
-void GLDraw_2_0::uploadMainTexture(QImage *p, bool use_chromakey)
+void GLDraw_2_0::uploadMainTexture(QImage *p, bool use_chromakey, bool was_mapped)
{
// set vertex
redraw_required = true;
virtual void initLocalGLObjects(void);
virtual void initOsdObjects(void);
- virtual void uploadMainTexture(QImage *p, bool chromakey);
+ virtual void uploadMainTexture(QImage *p, bool chromakey, bool was_mapped);
virtual void drawScreenTexture(void);
void drawGrids(void);
* Jan 22, 2016 : Initial.
*/
+#include "osd_types.h"
#include "qt_gldraw.h"
#include "qt_glpack.h"
#include "qt_glutil_gl3_0.h"
}
-void GLDraw_3_0::uploadMainTexture(QImage *p, bool use_chromakey)
+void GLDraw_3_0::uploadMainTexture(QImage *p, bool use_chromakey, bool was_mapped)
{
// set vertex
redraw_required = true;
if(uVramTextureID == NULL) {
uVramTextureID = new QOpenGLTexture(*imgptr);
}
- if(using_flags->is_use_one_board_computer() || (using_flags->get_max_button() > 0)) {
- uploadMainTexture(imgptr, true);
- } else {
- uploadMainTexture(imgptr, false);
- }
+ //if(using_flags->is_use_one_board_computer() || (using_flags->get_max_button() > 0)) {
+ // uploadMainTexture(imgptr, true);
+ //} else {
+ // uploadMainTexture(imgptr, false);
+ //}
crt_flag = true;
p_wid->doneCurrent();
}
virtual void initFBO(void);
//virtual void initBitmapVertex(void);
- virtual void uploadMainTexture(QImage *p, bool chromakey);
+ virtual void uploadMainTexture(QImage *p, bool chromakey, bool was_mapped);
virtual void drawScreenTexture(void);
virtual void do_set_screen_multiply(float mul);
virtual void doSetGridsHorizonal(int lines, bool force);
* Jan 22, 2016 : Initial.
*/
+#include "osd_types.h"
#include "qt_gldraw.h"
#include "qt_glpack.h"
-#include "qt_glutil_gl4_3.h"
+#include "qt_glutil_gl4_5.h"
#include "csp_logger.h"
#include "menu_flags.h"
#include <QVector3D>
#include <QVector4D>
-#include <QOpenGLFunctions_4_3_Core>
+#include <QOpenGLFunctions_4_5_Core>
//extern USING_FLAGS *using_flags;
-GLDraw_4_3::GLDraw_4_3(GLDrawClass *parent, USING_FLAGS *p, CSP_Logger *logger, EMU *emu) : GLDraw_Tmpl(parent, p, logger, emu)
+GLDraw_4_5::GLDraw_4_5(GLDrawClass *parent, USING_FLAGS *p, CSP_Logger *logger, EMU *emu) : GLDraw_Tmpl(parent, p, logger, emu)
{
uTmpTextureID = 0;
map_base_address = NULL;
}
-GLDraw_4_3::~GLDraw_4_3()
+GLDraw_4_5::~GLDraw_4_5()
{
if(main_pass != NULL) delete main_pass;
}
}
-QOpenGLTexture *GLDraw_4_3::createMainTexture(QImage *img)
+QOpenGLTexture *GLDraw_4_5::createMainTexture(QImage *img)
{
QOpenGLTexture *tx;
QImage *ip = NULL;
//tx->setFormat(QOpenGLTexture::RGBA8_UNorm);
if(main_texture_buffer != 0) {
+ this->unmap_vram_texture();
+ map_base_address = NULL;
extfunc->glDeleteBuffers(1, &main_texture_buffer);
+ main_texture_buffer = 0;
}
{
extfunc->glGenBuffers(1, &main_texture_buffer);
extfunc->glBindBuffer(GL_PIXEL_UNPACK_BUFFER, main_texture_buffer);
- extfunc->glBufferData(GL_PIXEL_UNPACK_BUFFER, w * h * sizeof(uint32_t), ip->constBits(), GL_DYNAMIC_COPY);
+ //extfunc->glBufferData(GL_PIXEL_UNPACK_BUFFER, w * h * sizeof(uint32_t), ip->constBits(), GL_DYNAMIC_COPY);
+ extfunc->glBufferStorage(GL_PIXEL_UNPACK_BUFFER, w * h * sizeof(uint32_t), ip->constBits(), GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT | GL_MAP_READ_BIT);
tx = new QOpenGLTexture(QOpenGLTexture::Target2D);
tx->setFormat(QOpenGLTexture::RGBA8_UNorm);
tx->setMinMagFilters(QOpenGLTexture::Linear, QOpenGLTexture::Nearest);
tx->bind();
tx->release();
extfunc->glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+ map_vram_texture();
+ pixel_width = w;
+ pixel_height = h;
+
}
- pixel_width = w;
- pixel_height = h;
return tx;
}
-void GLDraw_4_3::initBitmapVertex(void)
+void GLDraw_4_5::initBitmapVertex(void)
{
if(using_flags->is_use_one_board_computer()) {
vertexBitmap[0].x = -1.0f;
}
}
-void GLDraw_4_3::initFBO(void)
+void GLDraw_4_5::initFBO(void)
{
glHorizGrids = (GLfloat *)malloc(sizeof(float) * (using_flags->get_real_screen_height() + 2) * 6);
}
// Init view
extfunc->glClearColor(0.0, 0.0, 0.0, 1.0);
+
+ sync_fence = extfunc->glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
}
-void GLDraw_4_3::setNormalVAO(QOpenGLShaderProgram *prg,
+void GLDraw_4_5::setNormalVAO(QOpenGLShaderProgram *prg,
QOpenGLVertexArrayObject *vp,
QOpenGLBuffer *bp,
VertexTexCoord_t *tp,
prg->enableAttributeArray(texcoord_loc);
}
-void GLDraw_4_3::initGLObjects()
+void GLDraw_4_5::initGLObjects()
{
- extfunc = new QOpenGLFunctions_4_3_Core();
+ extfunc = new QOpenGLFunctions_4_5_Core();
extfunc->initializeOpenGLFunctions();
extfunc->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &texture_max_size);
}
-void GLDraw_4_3::initPackedGLObject(GLScreenPack **p,
+void GLDraw_4_5::initPackedGLObject(GLScreenPack **p,
int _width, int _height,
const QString vertex_shader, const QString fragment_shader,
const QString _name)
-bool GLDraw_4_3::initGridShaders(const QString vertex_fixed, const QString vertex_rotate, const QString fragment)
+bool GLDraw_4_5::initGridShaders(const QString vertex_fixed, const QString vertex_rotate, const QString fragment)
{
QOpenGLContext *context = QOpenGLContext::currentContext();
QPair<int, int> _version = QOpenGLVersionProfile(context->format()).version();
return f;
}
-bool GLDraw_4_3::initGridVertexObject(QOpenGLBuffer **vbo, QOpenGLVertexArrayObject **vao, int alloc_size)
+bool GLDraw_4_5::initGridVertexObject(QOpenGLBuffer **vbo, QOpenGLVertexArrayObject **vao, int alloc_size)
{
QOpenGLBuffer *bp = NULL;
QOpenGLVertexArrayObject *ap = NULL;
}
-void GLDraw_4_3::initLocalGLObjects(void)
+void GLDraw_4_5::initLocalGLObjects(void)
{
int _width = using_flags->get_screen_width();
if(using_flags->is_use_one_board_computer() || (using_flags->get_max_button() > 0)) {
initPackedGLObject(&main_pass,
using_flags->get_screen_width() * 2, using_flags->get_screen_height() * 2,
- ":/gl4_3/vertex_shader.glsl" , ":/gl4_3/chromakey_fragment_shader2.glsl",
+ ":/gl4_5/vertex_shader.glsl" , ":/gl4_5/chromakey_fragment_shader2.glsl",
"Main Shader");
} else {
initPackedGLObject(&main_pass,
using_flags->get_screen_width() * 2, using_flags->get_screen_height() * 2,
- ":/gl4_3/vertex_shader.glsl" , ":/gl4_3/fragment_shader.glsl",
+ ":/gl4_5/vertex_shader.glsl" , ":/gl4_5/fragment_shader.glsl",
"Main Shader");
}
if(main_pass != NULL) {
#if 0
initPackedGLObject(&std_pass,
using_flags->get_screen_width(), using_flags->get_screen_height(),
- ":/gl4_3/vertex_shader.glsl" , ":/gl4_3/chromakey_fragment_shader.glsl",
+ ":/gl4_5/vertex_shader.glsl" , ":/gl4_5/chromakey_fragment_shader.glsl",
"Standard Shader");
#endif
initPackedGLObject(&led_pass,
10, 10,
- ":/gl4_3/led_vertex_shader.glsl" , ":/gl4_3/led_fragment_shader.glsl",
+ ":/gl4_5/led_vertex_shader.glsl" , ":/gl4_5/led_fragment_shader.glsl",
"LED Shader");
for(int i = 0; i < 32; i++) {
led_pass_vao[i] = new QOpenGLVertexArrayObject;
}
initPackedGLObject(&osd_pass,
48.0, 48.0,
- ":/gl4_3/vertex_shader.glsl" , ":/gl4_3/icon_fragment_shader.glsl",
+ ":/gl4_5/vertex_shader.glsl" , ":/gl4_5/icon_fragment_shader.glsl",
"OSD Shader");
for(int i = 0; i < 32; i++) {
osd_pass_vao[i] = new QOpenGLVertexArrayObject;
initPackedGLObject(&ntsc_pass1,
_width, _height,
- ":/gl4_3/vertex_shader.glsl" , ":/gl4_3/ntsc_pass1.glsl",
+ ":/gl4_5/vertex_shader.glsl" , ":/gl4_5/ntsc_pass1.glsl",
"NTSC Shader Pass1");
initPackedGLObject(&ntsc_pass2,
_width / 2, _height,
- ":/gl4_3/vertex_shader.glsl" , ":/gl4_3/ntsc_pass2.glsl",
+ ":/gl4_5/vertex_shader.glsl" , ":/gl4_5/ntsc_pass2.glsl",
"NTSC Shader Pass2");
if(!(((gl_major_version >= 3) && (gl_minor_version >= 1)) || (gl_major_version >= 4))){
int ii;
initBitmapVertex();
initPackedGLObject(&bitmap_block,
_width * 2, _height * 2,
- ":/gl4_3/vertex_shader.glsl", ":/gl4_3/normal_fragment_shader.glsl",
+ ":/gl4_5/vertex_shader.glsl", ":/gl4_5/normal_fragment_shader.glsl",
"Background Bitmap Shader");
if(bitmap_block != NULL) {
setNormalVAO(bitmap_block->getShader(), bitmap_block->getVAO(),
}
}
- initGridShaders(":/gl4_3/grids_vertex_shader_fixed.glsl", ":/gl4_3/grids_vertex_shader.glsl", ":/gl4_3/grids_fragment_shader.glsl");
+ initGridShaders(":/gl4_5/grids_vertex_shader_fixed.glsl", ":/gl4_5/grids_vertex_shader.glsl", ":/gl4_5/grids_fragment_shader.glsl");
initGridVertexObject(&grids_horizonal_buffer, &grids_horizonal_vertex, using_flags->get_real_screen_height() + 3);
doSetGridsHorizonal(using_flags->get_real_screen_height(), true);
p_wid->doneCurrent();
}
-void GLDraw_4_3::updateGridsVAO(QOpenGLBuffer *bp,
+void GLDraw_4_5::updateGridsVAO(QOpenGLBuffer *bp,
QOpenGLVertexArrayObject *vp,
GLfloat *tp,
int number)
}
}
-void GLDraw_4_3::drawGrids(void)
+void GLDraw_4_5::drawGrids(void)
{
gl_grid_horiz = p_config->opengl_scanline_horiz;
gl_grid_vert = p_config->opengl_scanline_vert;
}
}
-void GLDraw_4_3::drawGridsMain(QOpenGLShaderProgram *prg,
+void GLDraw_4_5::drawGridsMain(QOpenGLShaderProgram *prg,
QOpenGLBuffer *bp,
QOpenGLVertexArrayObject *vp,
int number,
}
}
-void GLDraw_4_3::doSetGridsVertical(int pixels, bool force)
+void GLDraw_4_5::doSetGridsVertical(int pixels, bool force)
{
GLDraw_Tmpl::doSetGridsVertical(pixels, force);
updateGridsVAO(grids_vertical_buffer,
pixels);
}
-void GLDraw_4_3::doSetGridsHorizonal(int lines, bool force)
+void GLDraw_4_5::doSetGridsHorizonal(int lines, bool force)
{
if((lines == vert_lines) && !force) return;
GLDraw_Tmpl::doSetGridsHorizonal(lines, force);
lines);
}
-void GLDraw_4_3::drawGridsHorizonal(void)
+void GLDraw_4_5::drawGridsHorizonal(void)
{
QVector4D c= QVector4D(0.0f, 0.0f, 0.0f, 1.0f);
drawGridsMain(grids_shader,
c);
}
-void GLDraw_4_3::drawGridsVertical(void)
+void GLDraw_4_5::drawGridsVertical(void)
{
QVector4D c= QVector4D(0.0f, 0.0f, 0.0f, 1.0f);
drawGridsMain(grids_shader,
c);
}
-void GLDraw_4_3::renderToTmpFrameBuffer_nPass(GLuint src_texture,
+void GLDraw_4_5::renderToTmpFrameBuffer_nPass(GLuint src_texture,
GLuint src_w,
GLuint src_h,
GLScreenPack *renderObject,
}
}
-
-void GLDraw_4_3::uploadMainTexture(QImage *p, bool use_chromakey)
+void GLDraw_4_5::uploadMainTexture(QImage *p, bool use_chromakey, bool was_mapped)
{
// set vertex
redraw_required = true;
// Upload to main texture
if(p != NULL) {
#if 1
- extfunc->glBindBuffer(GL_PIXEL_PACK_BUFFER, main_texture_buffer);
- uint32_t *pp = (uint32_t *)(extfunc->glMapBuffer(GL_PIXEL_PACK_BUFFER, GL_WRITE_ONLY));
- if(pp != NULL) {
- int hh = (pixel_height < p->height()) ? pixel_height : p->height();
- for(int y = 0; y < hh; y++) {
- memcpy(&(pp[y * pixel_width]), p->scanLine(y), p->width() * sizeof(uint32_t));
+ if(map_base_address == NULL) {
+ extfunc->glBindBuffer(GL_PIXEL_UNPACK_BUFFER, main_texture_buffer);
+ uint32_t *pp = (uint32_t *)(extfunc->glMapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_WRITE_ONLY));
+ if(pp != NULL) {
+ int hh = (pixel_height < p->height()) ? pixel_height : p->height();
+ for(int y = 0; y < hh; y++) {
+ memcpy(&(pp[y * pixel_width]), p->scanLine(y), p->width() * sizeof(uint32_t));
+ }
}
- }
- extfunc->glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
- extfunc->glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
+ extfunc->glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
+ extfunc->glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+
+ extfunc->glBindBuffer(GL_PIXEL_UNPACK_BUFFER, main_texture_buffer);
+ extfunc->glBindTexture(GL_TEXTURE_2D, uVramTextureID->textureId());
+ //extfunc->glActiveTexture(GL_TEXTURE0);
+ extfunc->glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, p->width(), p->height(), GL_RGBA, GL_UNSIGNED_BYTE, 0);
+ extfunc->glBindTexture(GL_TEXTURE_2D, 0);
+ extfunc->glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
- extfunc->glBindBuffer(GL_PIXEL_UNPACK_BUFFER, main_texture_buffer);
- extfunc->glBindTexture(GL_TEXTURE_2D, uVramTextureID->textureId());
- //extfunc->glActiveTexture(GL_TEXTURE0);
- extfunc->glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, p->width(), p->height(), GL_RGBA, GL_UNSIGNED_BYTE, 0);
- extfunc->glBindTexture(GL_TEXTURE_2D, 0);
- extfunc->glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+ } else {
+ printf("*\n");
+ extfunc->glBindBuffer(GL_PIXEL_UNPACK_BUFFER, main_texture_buffer);
+ //extfunc->glFlushMappedBufferRange(GL_PIXEL_UNPACK_BUFFER, 0, pixel_width *pixel_height * sizeof(scrntype_t));
+ //extfunc->glClientWaitSync(sync_fence, GL_SYNC_FLUSH_COMMANDS_BIT, 0);
+
+ extfunc->glBindTexture(GL_TEXTURE_2D, uVramTextureID->textureId());
+ //extfunc->glActiveTexture(GL_TEXTURE0);
+ extfunc->glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, pixel_width, pixel_height, GL_RGBA, GL_UNSIGNED_BYTE, 0);
+ extfunc->glBindTexture(GL_TEXTURE_2D, 0);
+ extfunc->glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+ }
#else
uVramTextureID->setData(*p, QOpenGLTexture::DontGenerateMipMaps);
#endif
crt_flag = true;
}
-void GLDraw_4_3::drawScreenTexture(void)
+void GLDraw_4_5::drawScreenTexture(void)
{
if(using_flags->is_use_one_board_computer()) {
extfunc->glEnable(GL_BLEND);
}
}
-void GLDraw_4_3::drawMain(QOpenGLShaderProgram *prg,
+void GLDraw_4_5::drawMain(QOpenGLShaderProgram *prg,
QOpenGLVertexArrayObject *vp,
QOpenGLBuffer *bp,
GLuint texid,
}
}
-void GLDraw_4_3::drawMain(GLScreenPack *obj,
+void GLDraw_4_5::drawMain(GLScreenPack *obj,
GLuint texid,
QVector4D color,
bool f_smoosing,
drawMain(prg, vp, bp, texid, color, f_smoosing, do_chromakey, chromakey);
}
-void GLDraw_4_3::drawButtonsMain(int num, bool f_smoosing)
+void GLDraw_4_5::drawButtonsMain(int num, bool f_smoosing)
{
GLuint texid = uButtonTextureID[num]->textureId();
QOpenGLBuffer *bp = buffer_button_vertex[num];
}
-void GLDraw_4_3::drawButtons(void)
+void GLDraw_4_5::drawButtons(void)
{
for(int i = 0; i < using_flags->get_max_button(); i++) {
drawButtonsMain(i, false);
}
}
-void GLDraw_4_3::drawBitmapTexture(void)
+void GLDraw_4_5::drawBitmapTexture(void)
{
QVector4D color = QVector4D(1.0f, 1.0f, 1.0f, 1.0f);
smoosing = p_config->use_opengl_filters;
}
}
-void GLDraw_4_3::drawLedMain(GLScreenPack *obj, int num, QVector4D color)
+void GLDraw_4_5::drawLedMain(GLScreenPack *obj, int num, QVector4D color)
{
QOpenGLShaderProgram *prg = obj->getShader();
QOpenGLVertexArrayObject *vp = led_pass_vao[num];
}
-void GLDraw_4_3::drawOsdLeds()
+void GLDraw_4_5::drawOsdLeds()
{
QVector4D color_on;
QVector4D color_off;
}
}
-void GLDraw_4_3::drawOsdIcons()
+void GLDraw_4_5::drawOsdIcons()
{
QVector4D color_on;
QVector4D color_off;
}
}
-void GLDraw_4_3::paintGL(void)
+void GLDraw_4_5::paintGL(void)
{
//p_wid->makeCurrent();
extfunc->glFlush();
}
-void GLDraw_4_3::setBrightness(GLfloat r, GLfloat g, GLfloat b)
+void GLDraw_4_5::setBrightness(GLfloat r, GLfloat g, GLfloat b)
{
fBrightR = r;
fBrightG = g;
if(uVramTextureID == NULL) {
uVramTextureID = createMainTexture(imgptr);
}
- if(using_flags->is_use_one_board_computer() || (using_flags->get_max_button() > 0)) {
- uploadMainTexture(imgptr, true);
- } else {
- uploadMainTexture(imgptr, false);
- }
+// if(using_flags->is_use_one_board_computer() || (using_flags->get_max_button() > 0)) {
+// uploadMainTexture(imgptr, true);
+// } else {
+// uploadMainTexture(imgptr, false);
+// }
p_wid->doneCurrent();
}
crt_flag = true;
}
-void GLDraw_4_3::set_texture_vertex(float wmul, float hmul)
+void GLDraw_4_5::set_texture_vertex(float wmul, float hmul)
{
float wfactor = 1.0f;
float hfactor = 1.0f;
}
-void GLDraw_4_3::set_osd_vertex(int xbit)
+void GLDraw_4_5::set_osd_vertex(int xbit)
{
float xbase, ybase, zbase;
VertexTexCoord_t vertex[4];
vertex, 4);
}
-void GLDraw_4_3::set_led_vertex(int xbit)
+void GLDraw_4_5::set_led_vertex(int xbit)
{
float xbase, ybase, zbase;
VertexTexCoord_t vertex[4];
vertex, 4);
}
-void GLDraw_4_3::do_set_screen_multiply(float mul)
+void GLDraw_4_5::do_set_screen_multiply(float mul)
{
screen_multiply = mul;
do_set_texture_size(imgptr, screen_texture_width, screen_texture_height);
}
-void GLDraw_4_3::do_set_texture_size(QImage *p, int w, int h)
+void GLDraw_4_5::do_set_texture_size(QImage *p, int w, int h)
{
if(w <= 0) w = using_flags->get_real_screen_width();
if(h <= 0) h = using_flags->get_real_screen_height();
p_wid->doneCurrent();
}
}
-void GLDraw_4_3::do_set_horiz_lines(int lines)
+void GLDraw_4_5::do_set_horiz_lines(int lines)
{
if(lines > using_flags->get_real_screen_height()) {
lines = using_flags->get_real_screen_height();
this->doSetGridsHorizonal(lines, false);
}
-void GLDraw_4_3::resizeGL_Screen(void)
+void GLDraw_4_5::resizeGL_Screen(void)
{
if(main_pass != NULL) {
setNormalVAO(main_pass->getShader(), main_pass->getVAO(),
}
}
-void GLDraw_4_3::resizeGL(int width, int height)
+void GLDraw_4_5::resizeGL(int width, int height)
{
//int side = qMin(width, height);
p_wid->makeCurrent();
p_wid->doneCurrent();
}
-void GLDraw_4_3::initButtons(void)
+void GLDraw_4_5::initButtons(void)
{
button_desc_t *vm_buttons_d = using_flags->get_vm_buttons();
QOpenGLContext *context = QOpenGLContext::currentContext();
button_shader = new QOpenGLShaderProgram(p_wid);
if(button_shader != NULL) {
bool f = false;
- QFile vertex_src(QString::fromUtf8(":/gl4_3/vertex_shader.glsl"));
+ QFile vertex_src(QString::fromUtf8(":/gl4_5/vertex_shader.glsl"));
if (vertex_src.open(QIODevice::ReadOnly | QIODevice::Text)) {
QString srcs = versionext;
srcs = srcs + QString::fromUtf8(vertex_src.readAll());
} else {
return;
}
- QFile fragment_src(QString::fromUtf8(":/gl4_3/normal_fragment_shader.glsl"));
+ QFile fragment_src(QString::fromUtf8(":/gl4_5/normal_fragment_shader.glsl"));
if (fragment_src.open(QIODevice::ReadOnly | QIODevice::Text)) {
QString srcs = versionext;
srcs = srcs + QString::fromUtf8(fragment_src.readAll());
}
}
-void GLDraw_4_3::do_set_display_osd(bool onoff)
+void GLDraw_4_5::do_set_display_osd(bool onoff)
{
osd_onoff = onoff;
}
-void GLDraw_4_3::do_display_osd_leds(int lednum, bool onoff)
+void GLDraw_4_5::do_display_osd_leds(int lednum, bool onoff)
{
if(lednum == -1) {
osd_led_status = (onoff) ? 0xffffffff : 0x00000000;
}
}
-void GLDraw_4_3::uploadIconTexture(QPixmap *p, int icon_type, int localnum)
+void GLDraw_4_5::uploadIconTexture(QPixmap *p, int icon_type, int localnum)
{
if((icon_type > 7) || (icon_type < 0)) return;
if((localnum >= 9) || (localnum < 0)) return;
}
-void GLDraw_4_3::updateBitmap(QImage *p)
+void GLDraw_4_5::updateBitmap(QImage *p)
{
if(!using_flags->is_use_one_board_computer()) return;
redraw_required = true;
uploadBitmapTexture(p);
}
-void GLDraw_4_3::uploadBitmapTexture(QImage *p)
+void GLDraw_4_5::uploadBitmapTexture(QImage *p)
{
if(!using_flags->is_use_one_board_computer()) return;
if(p == NULL) return;
}
}
-void GLDraw_4_3::updateButtonTexture(void)
+void GLDraw_4_5::updateButtonTexture(void)
{
int i;
button_desc_t *vm_buttons_d = using_flags->get_vm_buttons();
button_updated = true;
}
-void GLDraw_4_3::get_screen_geometry(int *w, int *h)
+void GLDraw_4_5::get_screen_geometry(int *w, int *h)
{
if(w != NULL) *w = pixel_width;
if(h != NULL) *h = pixel_height;
}
-scrntype_t *GLDraw_4_3::get_screen_buffer(int y)
+scrntype_t *GLDraw_4_5::get_screen_buffer(int y)
{
if((y < 0) || (y >= pixel_height)) return NULL;
if(map_base_address == NULL) {
}
// Note: Mapping vram from draw_thread does'nt work well.
// This feature might be disable. 20180728 K.Ohta.
-bool GLDraw_4_3::is_ready_to_map_vram_texture(void)
+bool GLDraw_4_5::is_ready_to_map_vram_texture(void)
{
- return false;
+ if(main_texture_buffer == 0) {
+ return false;
+ }
+ if(gl_major_version < 4) {
+ return false;
+ }
+ if(gl_minor_version < 4) {
+ return false;
+ }
+ return true;
}
-bool GLDraw_4_3::map_vram_texture(void)
+bool GLDraw_4_5::map_vram_texture(void)
{
if(main_texture_buffer == 0) {
return false;
}
- extfunc->glBindBuffer(GL_PIXEL_PACK_BUFFER, main_texture_buffer);
- map_base_address = (scrntype_t *)(extfunc->glMapBuffer(GL_PIXEL_PACK_BUFFER, GL_READ_WRITE));
+ if(gl_major_version < 4) {
+ return false;
+ }
+ if(gl_minor_version < 4) {
+ return false;
+ }
+#if 1
+ return false;
+#else
+ extfunc->glBindBuffer(GL_PIXEL_UNPACK_BUFFER, main_texture_buffer);
+ map_base_address = (scrntype_t *)(extfunc->glMapBufferRange(GL_PIXEL_UNPACK_BUFFER, 0, pixel_width * pixel_height * sizeof(scrntype_t), GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT));
+ printf("%08x\n", map_base_address);
+ extfunc->glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
if(map_base_address == NULL) return false;
return true;
+#endif
}
-bool GLDraw_4_3::unmap_vram_texture(void)
+bool GLDraw_4_5::unmap_vram_texture(void)
{
if((map_base_address == NULL) || (main_texture_buffer == 0)) return false;
- extfunc->glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
- extfunc->glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
-
extfunc->glBindBuffer(GL_PIXEL_UNPACK_BUFFER, main_texture_buffer);
- extfunc->glBindTexture(GL_TEXTURE_2D, uVramTextureID->textureId());
- //extfunc->glActiveTexture(GL_TEXTURE0);
- extfunc->glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, pixel_width, pixel_height, GL_RGBA, GL_UNSIGNED_BYTE, 0);
- extfunc->glBindTexture(GL_TEXTURE_2D, 0);
+ extfunc->glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
extfunc->glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+
return true;
}
/*
- * qt_glutil_gl3_0.cpp
+ * qt_glutil_gl4_5.cpp
* (c) 2016 K.Ohta <whatisthis.sowhat@gmail.com>
* License: GPLv2.
- * Renderer with OpenGL v3.0 (extend from renderer with OpenGL v2.0).
+ * Renderer with OpenGL v4.5 (extend from renderer with OpenGL v2.0).
* History:
* Jan 22, 2016 : Initial.
*/
-#ifndef _QT_COMMON_GLUTIL_4_3_H
-#define _QT_COMMON_GLUTIL_4_3_H
+#ifndef _QT_COMMON_GLUTIL_4_5_H
+#define _QT_COMMON_GLUTIL_4_5_H
#include <QString>
#include "../gl/qt_glutil_gl_tmpl.h"
QT_BEGIN_NAMESPACE
class GLScreenPack;
class CSP_Logger;
-class QOpenGLFunctions_4_3_Core;
+class QOpenGLFunctions_4_5_Core;
class QOpenGLBuffer;
class QOpenGLVertexArrayObject;
class QOpenGLShaderProgram;
class QOpenGLPixelTransferOptions;
-class DLL_PREFIX GLDraw_4_3 : public GLDraw_Tmpl
+class DLL_PREFIX GLDraw_4_5 : public GLDraw_Tmpl
{
Q_OBJECT
private:
- QOpenGLFunctions_4_3_Core *extfunc;
+ QOpenGLFunctions_4_5_Core *extfunc;
float ringing_phase;
protected:
const float luma_filter[24 + 1] = {
int pixel_width;
int pixel_height;
GLuint main_texture_buffer;
+ GLsync sync_fence;
scrntype_t *map_base_address;
GLScreenPack *main_pass;
void updateButtonTexture(void);
public:
- GLDraw_4_3(GLDrawClass *parent, USING_FLAGS *p, CSP_Logger *logger, EMU *emu = 0);
- ~GLDraw_4_3();
+ GLDraw_4_5(GLDrawClass *parent, USING_FLAGS *p, CSP_Logger *logger, EMU *emu = 0);
+ ~GLDraw_4_5();
void drawButtons(void);
virtual void initGLObjects();
virtual void initLocalGLObjects(void);
void initButtons(void);
//virtual void initBitmapVertex(void);
- virtual void uploadMainTexture(QImage *p, bool chromakey);
+ virtual void uploadMainTexture(QImage *p, bool chromakey, bool was_mapped);
virtual void drawScreenTexture(void);
virtual void do_set_screen_multiply(float mul);
virtual void doSetGridsHorizonal(int lines, bool force);
bool is_ready_to_map_vram_texture(void);
bool map_vram_texture(void);
bool unmap_vram_texture(void);
+ virtual bool is_mapped_buffer(void) {
+ if(main_texture_buffer == 0) {
+ return false;
+ }
+ return true;
+ }
+ // ToDo: Double buffer
+ virtual GLuint get_mapped_buffer_num(int region) {
+ return (GLuint)main_texture_buffer;
+ }
public slots:
void updateBitmap(QImage *);
* May 05, 2018 : Copy from GL v3.0.
*/
+#include "osd_types.h"
#include "qt_gldraw.h"
#include "qt_glpack.h"
#include "qt_glutil_gles_2.h"
}
-void GLDraw_ES_2::uploadMainTexture(QImage *p, bool use_chromakey)
+void GLDraw_ES_2::uploadMainTexture(QImage *p, bool use_chromakey, bool was_mapped)
{
// set vertex
redraw_required = true;
if(uVramTextureID == NULL) {
uVramTextureID = createMainTexture(imgptr);
}
- if(using_flags->is_use_one_board_computer() || (using_flags->get_max_button() > 0)) {
- uploadMainTexture(imgptr, true);
- } else {
- uploadMainTexture(imgptr, false);
- }
+ //if(using_flags->is_use_one_board_computer() || (using_flags->get_max_button() > 0)) {
+ // uploadMainTexture(imgptr, true);
+ //} else {
+ // uploadMainTexture(imgptr, false);
+ //}
crt_flag = true;
p_wid->doneCurrent();
}
void initButtons(void);
//virtual void initBitmapVertex(void);
- virtual void uploadMainTexture(QImage *p, bool chromakey);
+ virtual void uploadMainTexture(QImage *p, bool chromakey, bool was_mapped);
virtual void drawScreenTexture(void);
virtual void do_set_screen_multiply(float mul);
virtual void doSetGridsHorizonal(int lines, bool force);
case RENDER_PLATFORMS_OPENGL_CORE:
_type = CONFIG_RENDER_PLATFORM_OPENGL_CORE;
_major = 4;
- _minor = 3;
+ _minor = 5;
break;
default:
break;
#ifdef USE_OPENMP
#include <omp.h>
#endif //_OPENMP
+#include "../osd.h"
#include "qt_gldraw.h"
#include "gl2/qt_glutil_gl2_0.h"
#include "csp_logger.h"
-#include "../osd.h"
#include "./qt_drawitem.h"
//extern USING_FLAGS *using_flags;
if(extfunc != NULL) extfunc->drawGrids();
}
-void GLDrawClass::drawUpdateTexture(bitmap_t *p)
+void GLDrawClass::drawUpdateTexture(void *p, bool was_mapped)
{
+ bitmap_t* pp = (bitmap_t*)p;
if(using_flags->get_osd() == NULL) return;
QMutexLocker Locker_S(using_flags->get_osd()->screen_mutex);
- if((p != NULL)) {
+ if((pp != NULL)) {
if(extfunc != NULL) {
// Will fix at implemenitin PX7.
if(using_flags->is_use_one_board_computer() || (using_flags->get_max_button() > 0)) {
- extfunc->uploadMainTexture(&(p->pImage), true);
+ extfunc->uploadMainTexture(&(pp->pImage), true, was_mapped);
} else {
- extfunc->uploadMainTexture(&(p->pImage), false);
+ extfunc->uploadMainTexture(&(pp->pImage), false, was_mapped);
}
}
}
emit sig_draw_timing();
}
+scrntype_t* GLDrawClass::get_screen_buffer(int y)
+{
+ if(extfunc == NULL) return NULL;
+ return extfunc->get_screen_buffer(y);
+}
+
void GLDrawClass::do_set_display_osd(bool onoff)
{
emit sig_set_display_osd(onoff);
// Note: Mapping vram from draw_thread does'nt work well.
// This feature might be disable. 20180728 K.Ohta.
-void GLDrawClass::do_map_vram_texture(void)
+scrntype_t *GLDrawClass::do_map_vram_texture(int *r_width, int *r_height)
{
bool stat = false;
int w = 0;
void *p = NULL;
if(extfunc != NULL) {
if(extfunc->is_ready_to_map_vram_texture()) {
- this->makeCurrent();
stat = extfunc->map_vram_texture();
if(stat) {
extfunc->get_screen_geometry(&w, &h);
w = 0;
h = 0;
}
- emit sig_map_texture_reply(stat, p, w, h);
- return;
+ if(r_width != NULL) *r_width = w;
+ if(r_height != NULL) *r_height = h;
+ return (scrntype_t*)p;
}
}
- emit sig_map_texture_reply(false, NULL, 0, 0);
+ if(r_width != NULL) *r_width = 0;
+ if(r_height != NULL) *r_height = 0;
+ return NULL;
}
void GLDrawClass::do_unmap_vram_texture()
if(extfunc != NULL) {
if(extfunc->is_ready_to_map_vram_texture()) {
extfunc->unmap_vram_texture();
- this->doneCurrent();
- emit sig_unmap_texture_reply();
return;
}
}
- emit sig_unmap_texture_reply();
}
const bool GLDrawClass::is_ready_to_map_vram_texture(void)
#define _CSP_QT_GLDRAW_H
//#include "emu.h"
-#include "../osd_types.h"
+//#include "../osd_types.h"
#include "dropdown_keyset.h"
#include "config.h"
#include "menu_flags.h"
void InitFBO(void);
void closeEvent(QCloseEvent *event);
- void drawUpdateTexture(bitmap_t *p);
+ void drawUpdateTexture(void *p, bool was_mapped);
QString logGLString(bool getExtensions = false);
bool emu_launched;
quint32 modifier;
const bool is_ready_to_map_vram_texture(void);
-
+ scrntype_t *do_map_vram_texture(int *r_width, int *r_height);
+ void do_unmap_vram_texture();
+ bool is_mapped_buffer(void);
+ GLuint get_mapped_buffer_num(int region);
+
+ scrntype_t* get_screen_buffer(int y);
public slots:
void initKeyCode(void);
void releaseKeyCode(void);
- void update_screen(bitmap_t *);
+ void update_screen(void *p, bool was_mapped);
void update_osd(void);
void resizeGL(int width, int height);
void mouseMoveEvent(QMouseEvent *event);
void do_update_icon(int icon_type, int localnum, QPixmap *p);
void do_update_icon(int icon_type, int localnum, QString message, QColor bg, QColor fg, QColor fg2, QColor fg3, QColor lg, QColor tg, float pt);
- void do_map_vram_texture(void);
- void do_unmap_vram_texture();
signals:
void update_screenChanged(int tick);
void do_notify_move_mouse(int x, int y);
#include "gl/qt_glutil_gl_tmpl.h"
#include "gl2/qt_glutil_gl2_0.h"
#include "gl3/qt_glutil_gl3_0.h"
-#include "gl4_3/qt_glutil_gl4_3.h"
+#include "gl4_5/qt_glutil_gl4_5.h"
#include "gles2/qt_glutil_gles_2.h"
-#include <QOpenGLFunctions_4_3_Core>
+#include <QOpenGLFunctions_4_5_Core>
#include <QApplication>
#include "./qt_drawitem.h"
//extern const char *cl_render;
-void GLDrawClass::update_screen(bitmap_t *p)
+void GLDrawClass::update_screen(void *p, bool was_mapped)
{
//if(tick < (1000 / 75)) tick = 1000 / 75;
if((p != NULL) && (run_vm)) {
this->makeCurrent();
//imgptr = &(p->pImage);
- drawUpdateTexture(p);
+ drawUpdateTexture(p, was_mapped);
this->doneCurrent();
this->update();
}
}
+bool GLDrawClass::is_mapped_buffer(void)
+{
+ if(extfunc != NULL) {
+ return extfunc->is_mapped_buffer();
+ }
+ return false;
+}
+
+GLuint GLDrawClass::get_mapped_buffer_num(int region)
+{
+ if(extfunc != NULL) {
+ return extfunc->get_mapped_buffer_num(region);
+ }
+ return (GLuint)0;
+}
+
+
void GLDrawClass::do_update_icon(int icon_type, int localnum, QPixmap *p)
{
if(extfunc != NULL) {
}
if(_fmt.profile() == QSurfaceFormat::CoreProfile) {
QPair<int, int> _glversion = _fmt.version();
- if((((_glversion.first == 4) && (_glversion.second >= 3)) || (_glversion.first >= 5)) &&
+ if(((_glversion.first >= 5) || ((_glversion.first == 4) && (_glversion.second >= 5))) &&
(extfunc == NULL) &&
- (((_major_version == 4) && (_minor_version >= 3)) || (_major_version >= 5))){
- extfunc = new GLDraw_4_3(this, using_flags, csp_logger); // ToDo
+ ((_major_version >= 5) || ((_major_version == 4) && (_minor_version >= 5)))){
+ extfunc = new GLDraw_4_5(this, using_flags, csp_logger); // ToDo
if(extfunc != NULL) {
- csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_GENERAL, "Use OpenGL v4.3(CORE) Renderer");
+ csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_GENERAL, "Use OpenGL v4.5(CORE) Renderer");
goto _nr_end;
}
}
#include <QObject>
#include <QThread>
#include <QMutex>
+#include <QOpenGLContext>
#include "simd_types.h"
mapped_screen_height = 0;
mapped_screen_status = false;
SupportedFeatures.clear();
+
+ is_glcontext_shared = false;
+ glContext = NULL;
+ p_glv = NULL;
}
OSD_BASE::~OSD_BASE()
extern std::string cpp_homedir;
extern std::string my_procname;
+
+bool OSD_BASE::set_glview(GLDrawClass *glv)
+{
+ if(glv == NULL) return false;
+ if(glContext != NULL) {
+ if(glContext->isValid()) return true;
+ return false;
+ }
+ p_glv = glv;
+
+ glContext = new QOpenGLContext();
+ if(glContext != NULL) {
+ glContext->setShareContext(glv->context());
+ glContext->create();
+ }
+ if(glContext->isValid()) {
+ is_glcontext_shared = true;
+ return true;
+ }
+ return false;
+}
+
+QOpenGLContext *OSD_BASE::get_gl_context()
+{
+ if(glContext == NULL) return NULL;
+ if(!(glContext->isValid())) return NULL;
+ return glContext;
+}
+
EmuThreadClass *OSD_BASE::get_parent_handler()
{
return parent_thread;
//#include "qt_main.h"
-class GLDrawClass;
class EmuThreadClass;
class DrawThreadClass;
class Ui_MainWindow;
class CSP_KeyTables;
class USING_FLAGS;
class CSP_logger;
+class GLDrawClass;
+
class QMutex;
+class QOpenGLContext;
QT_BEGIN_NAMESPACE
USING_FLAGS *using_flags;
config_t *p_config;
CSP_Logger *p_logger;
+ GLDrawClass *p_glv;
+
+ QOpenGLContext *glContext;
+ bool is_glcontext_shared;
QList<supportedlist_t> SupportedFeatures;
// Special
CSP_Logger *get_logger(void) { return p_logger; }
+ bool set_glview(GLDrawClass *glv);
+ QOpenGLContext *get_gl_context();
+ GLDrawClass *get_gl_view();
+
public slots:
void do_write_inputdata(QString s);
void do_set_screen_map_texture_address(scrntype_t *p, int width, int height);
signals:
- int sig_update_screen(bitmap_t *);
+ int sig_update_screen(void *, bool);
int sig_save_screen(const char *);
int sig_draw_frames(int);
int sig_close_window(void);
#include <QDateTime>
#include <QImageReader>
#include <QMutexLocker>
+#include <QOpenGLContext>
#include "qt_gldraw.h"
#include "osd_base.h"
{
// draw screen
QMutexLocker Locker_S(screen_mutex);
+ bool mapped = false;
//QMutexLocker Locker_VM(vm_mutex);
if(vm_screen_buffer.width != vm_screen_width || vm_screen_buffer.height != vm_screen_height) {
//emit sig_movie_set_width(vm_screen_width);
//emit sig_movie_set_height(vm_screen_height);
initialize_screen_buffer(&vm_screen_buffer, vm_screen_width, vm_screen_height, 0);
}
+ #if 1
+ if(p_glv->is_ready_to_map_vram_texture()) {
+ vm_screen_buffer.is_mapped = true;
+ mapped = true;
+ } else {
+ vm_screen_buffer.is_mapped = false;
+ }
+ #else
+ vm_screen_buffer.is_mapped = false;
+ #endif
this->vm_draw_screen();
// screen size was changed in vm->draw_screen()
if(vm_screen_buffer.width != vm_screen_width || vm_screen_buffer.height != vm_screen_height) {
// calculate screen size
// invalidate window
- emit sig_update_screen(draw_screen_buffer);
+ emit sig_update_screen((void *)draw_screen_buffer, mapped);
first_draw_screen = self_invalidate = true;
QColor fillcolor;
fillcolor.setRgb(0, 0, 0, 255);
buffer->pImage.fill(fillcolor);
+ buffer->glv = p_glv;
+ buffer->is_mapped = false;
//emit sig_movie_set_width(width);
//emit sig_movie_set_height(height);
emit sig_resize_vm_screen(&(buffer->pImage), width, height);
}
buffer->width = 0;
buffer->height = 0;
+ buffer->is_mapped = false;
+ buffer->glv = NULL;
//memset(buffer, 0, sizeof(bitmap_t));
}
#include "../fileio.h"
#include "../fifo.h"
+class GLDrawClass;
+#include "gui/qt_gldraw.h"
+
#if !defined(Q_OS_WIN32)
#include "qt_input.h"
#endif
typedef struct bitmap_s {
int width, height;
QImage pImage;
+ GLDrawClass *glv;
+ bool is_mapped;
scrntype_t *get_buffer(int y) {
+ if((is_mapped) && (glv != NULL)) {
+ scrntype_t *p = NULL;
+ p = glv->get_screen_buffer(y);
+ if(p != NULL) return p;
+ }
return (scrntype_t *)pImage.scanLine(y);
};
scrntype_t* lpBuf;
void OSD::set_draw_thread(DrawThreadClass *handler)
{
//this->moveToThread(handler);
- connect(this, SIGNAL(sig_update_screen(bitmap_t *)), handler, SLOT(do_update_screen(bitmap_t *)));
+ connect(this, SIGNAL(sig_update_screen(void *, bool)), handler, SLOT(do_update_screen(void *, bool)));
connect(this, SIGNAL(sig_save_screen(const char *)), glv, SLOT(do_save_frame_screen(const char *)));
connect(this, SIGNAL(sig_resize_vm_screen(QImage *, int, int)), glv, SLOT(do_set_texture_size(QImage *, int, int)));
connect(this, SIGNAL(sig_resize_vm_lines(int)), glv, SLOT(do_set_horiz_lines(int)));
OSDN Git Service
