source/src/qt/common/qt_glutil.cpp

   1 /*
   2  * Qt: OpenGL Utils
   3  * (C) 2011 K.Ohta <whatisthis.sowhat@gmail.com>
   4  */
   5
   6 #undef _USE_OPENCL
   7 #ifdef _USE_OPENCL
   8 //#include "agar_glcl.h"
   9 #endif
  10 #include "agar_logger.h"
  11 #include "qt_gldraw.h"
  12 #include "emu.h"
  13 #ifdef USE_OPENMP
  14 #include <omp.h>
  15 #endif //_OPENMP
  16 #include <QGLContext>
  17
  18 //extern const char *cl_render;
  19
  20 #ifdef _USE_OPENCL
  21 //class GLCLDraw *cldraw = NULL;
  22 #endif
  23 void GLDrawClass::update_screen(QImage *p)
  24 {
  25         //if(tick < (1000 / 75)) tick = 1000 / 75;
  26         imgptr = p;
  27         crt_flag = true;
  28         this->update();
  29 }
  30
  31
  32
  33 void GLDrawClass::InitContextCL(void)
  34 {
  35 }
  36
  37
  38
  39 void GLDrawClass::initializeGL(void)
  40 {
  41         int i;
  42         GLfloat xf, yf, delta;
  43 #ifdef _USE_OPENCL
  44         cldraw = NULL;
  45 #endif
  46         /*
  47          * GL 拡張の取得 20110907-
  48          */
  49         InitFBO(); // 拡張の有無を調べてからFBOを初期化する。
  50         InitGLExtensionVars();
  51         glHorizGrids = (GLfloat *)malloc(sizeof(float) * (SCREEN_HEIGHT + 2) * 6);
  52         if(glHorizGrids != NULL) {
  53                 yf = -1.0f;
  54                 delta = 2.0f / (float)SCREEN_HEIGHT;
  55                 yf = yf - delta * 0.75f;
  56                 for(i = 0; i < (SCREEN_HEIGHT + 1) ; i++) {
  57                         glHorizGrids[i * 6]     = -1.0f; // XBegin
  58                         glHorizGrids[i * 6 + 3] = +1.0f; // XEnd
  59                         glHorizGrids[i * 6 + 1] = yf; // YBegin
  60                         glHorizGrids[i * 6 + 4] = yf; // YEnd
  61                         glHorizGrids[i * 6 + 2] = 0.1f; // ZBegin
  62                         glHorizGrids[i * 6 + 5] = 0.1f; // ZEnd
  63                         yf = yf + delta;
  64                 }
  65         }
  66         glVertGrids  = (GLfloat *)malloc(sizeof(float) * (SCREEN_WIDTH + 2) * 6);
  67         if(glVertGrids != NULL) {
  68                 xf = -1.0f;
  69                 delta = 2.0f / (float)SCREEN_WIDTH;
  70                 xf = xf - delta * 0.75f;
  71                 for(i = 0; i < (SCREEN_WIDTH + 1) ; i++) {
  72                         glVertGrids[i * 6]     = xf; // XBegin
  73                         glVertGrids[i * 6 + 3] = xf; // XEnd
  74                         glVertGrids[i * 6 + 1] = -1.0f; // YBegin
  75                         glVertGrids[i * 6 + 4] =  1.0f; // YEnd
  76                         glVertGrids[i * 6 + 2] = 0.1f; // ZBegin
  77                         glVertGrids[i * 6 + 5] = 0.1f; // ZEnd
  78                         xf = xf + delta;
  79                 }
  80         }
  81
  82         // Init view
  83         extfunc->glClearColor(0.0, 0.0, 0.0, 1.0);
  84
  85 }
  86
  87 void GLDrawClass::setChangeBrightness(bool flag)
  88 {
  89         set_brightness = flag;
  90 }
  91
  92 void GLDrawClass::setBrightness(GLfloat r, GLfloat g, GLfloat b)
  93 {
  94         fBrightR = r;
  95         fBrightG = g;
  96         fBrightB = b;
  97 }
  98
  99 void GLDrawClass::setSmoosing(bool flag)
 100 {
 101         smoosing = flag;
 102         crt_flag = true;
 103 }
 104
 105 void GLDrawClass::setDrawGLGridVert(bool flag)
 106 {
 107         gl_grid_vert = flag;
 108         crt_flag = true;
 109 }
 110
 111 void GLDrawClass::setDrawGLGridHoriz(bool flag)
 112 {
 113         gl_grid_vert = flag;
 114         crt_flag = true;
 115 }
 116
 117 void GLDrawClass::setVirtualVramSize(int width, int height)
 118 {
 119         vert_lines = height;
 120         horiz_pixels = width;
 121         crt_flag = true;
 122 }
 123
 124 // OpenGL状態変数
 125 bool GLDrawClass::QueryGLExtensions(const char *str)
 126 {
 127         char *ext;
 128         char *p;
 129         int i;
 130         int j;
 131         int k;
 132         int l;
 133         int ll;
 134         return false;
 135 }
 136
 137 void GLDrawClass::InitGLExtensionVars(void)
 138 {
 139         //    bGL_PIXEL_UNPACK_BUFFER_BINDING = QueryGLExtensions("GL_pixel_unpack_buffer_binding");
 140         bGL_PIXEL_UNPACK_BUFFER_BINDING = true;
 141         bCLEnabled = false;
 142         bCLGLInterop = false;
 143 }
 144
 145
 146 void GLDrawClass::InitFBO(void)
 147 {
 148         bGL_EXT_VERTEX_ARRAY = false;
 149 #if defined(_USE_GLAPI_QT5_4) || defined(_USE_GLAPI_QT5_1)
 150         extfunc = new QOpenGLFunctions;
 151         extfunc->initializeOpenGLFunctions();
 152 #elif defined(_USE_GLAPI_QT4_8) || defined(_USE_GLAPI_QT5_0)
 153         extfunc = new QGLFunctions;
 154         //if(extfunc->initializeOpenGLFunctions()) bGL_EXT_VERTEX_ARRAY = true;
 155 #endif
 156         main_shader = new QOpenGLShaderProgram(this);
 157         if(main_shader != NULL) {
 158                 main_shader->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/vertex_shader.glsl");
 159                 main_shader->addShaderFromSourceFile(QOpenGLShader::Fragment, ":/fragment_shader.glsl");
 160                 main_shader->link();
 161         }
 162         grids_shader = new QOpenGLShaderProgram(this);
 163         if(grids_shader != NULL) {
 164                 grids_shader->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/grids_vertex_shader.glsl");
 165                 grids_shader->addShaderFromSourceFile(QOpenGLShader::Fragment, ":/grids_fragment_shader.glsl");
 166                 grids_shader->link();
 167         }
 168
 169 # if defined(USE_BITMAP)
 170         bitmap_shader = new QOpenGLShaderProgram(this);
 171         if(bitmap_shader != NULL) {
 172                 bitmap_shader->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/vertex_shader.glsl");
 173                 bitmap_shader->addShaderFromSourceFile(QOpenGLShader::Fragment, ":/fragment_shader.glsl");
 174                 bitmap_shader->link();
 175         }
 176 # endif
 177 # if defined(USE_BUTTON)
 178         button_shader = new QOpenGLShaderProgram(this);
 179         if(button_shader != NULL) {
 180                 button_shader->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/vertex_shader.glsl");
 181                 button_shader->addShaderFromSourceFile(QOpenGLShader::Fragment, ":/fragment_shader.glsl");
 182                 button_shader->link();
 183         }
 184 # endif
 185         if(extfunc) {
 186                 buffer_grid_horizonal = new QOpenGLBuffer(QOpenGLBuffer::VertexBuffer);
 187                 vertex_grid_horizonal = new QOpenGLVertexArrayObject;
 188                 QVector3D hg;
 189                 if(vertex_grid_horizonal != NULL) {
 190                         if(vertex_grid_horizonal->create()) {
 191                                 vertex_grid_horizonal->bind();
 192                                 buffer_grid_horizonal->allocate(SCREEN_HEIGHT * 6 * sizeof(GLfloat));
 193                                 vertex_grid_horizonal->release();
 194                         }
 195                 }
 196
 197                 buffer_grid_vertical = new QOpenGLBuffer(QOpenGLBuffer::VertexBuffer);
 198                 vertex_grid_vertical = new QOpenGLVertexArrayObject;
 199                 if(vertex_grid_vertical != NULL) {
 200                         if(vertex_grid_vertical->create()) {
 201                                 vertex_grid_vertical->bind();
 202                                 buffer_grid_horizonal->allocate(SCREEN_WIDTH * 6 * sizeof(GLfloat));
 203                                 vertex_grid_vertical->release();
 204                         }
 205                 }
 206 # if defined(USE_BUTTON)
 207                 {
 208                         int i;
 209                         GLfloat Vertexs[4][3];
 210                         for(i = 0; i < MAX_BUTTONS; i++) {
 211                                 buffer_button_vertex[i] = new QOpenGLBuffer(QOpenGLBuffer::VertexBuffer);
 212                                 fButtonX[i] = -1.0 + (float)(buttons[i].x * 2) / (float)SCREEN_WIDTH;
 213                                 fButtonY[i] = 1.0 - (float)(buttons[i].y * 2) / (float)SCREEN_HEIGHT;
 214                                 fButtonWidth[i] = (float)(buttons[i].width * 2) / (float)SCREEN_WIDTH;
 215                                 fButtonHeight[i] = (float)(buttons[i].height * 2) / (float)SCREEN_HEIGHT;
 216
 217                                 vertex_button[i] = new QOpenGLVertexArrayObject;
 218                                 if(vertex_button[i] != NULL) {
 219                                         if(vertex_button[i]->create()) {
 220                                         VertexTexCoord_t vt;
 221                                            vt[0].x =  fButtonX[i];
 222                                            vt[0].y =  fButtonY[i];
 223                                            vt[0].z =  -0.2f;
 224                                            vt[0].s = 0.0f;
 225                                            vt[0].t = 1.0f;
 226
 227                                            vt[1].x =  fButtonX[i] + fButtonWidth[i];
 228                                            vt[1].y =  fButtonY[i];
 229                                            vt[1].z =  -0.2f;
 230                                            vt[1].s = 1.0f;
 231                                            vt[1].t = 1.0f;
 232
 233                                            vt[2].x =  fButtonX[i] + fButtonWidth[i];
 234                                            vt[2].y =  fButtonY[i] - fButtonHeight[i];
 235                                            vt[2].z =  -0.2f;
 236                                            vt[2].s = 1.0f;
 237                                            vt[2].t = 0.0f;
 238
 239                                            vt[3].x =  fButtonX[i];
 240                                            vt[3].y =  fButtonY[i] - fButtonHeight[i];
 241                                            vt[3].z =  -0.2f;
 242                                            vt[3].s = 0.0f;
 243                                            vt[3].t = 0.0f;
 244
 245                                            buffer_button_vertex->write(0, vt, 4 * sizeof(VertexTexCoord_t));
 246                                            buffer_button_vertex[i]->create();
 247                                            buffer_button_vertex[i]->setUsagePattern(QOpenGLBuffer::DynamicDraw);
 248                                            int vertex_loc = main_shader->attributeLocation("vertex");
 249                                            int texcoord_loc = main_shader->attributeLocation("texcoord");
 250
 251                                            vertex_button[i]->bind();
 252                                            buffer_button_vertex[i]->bind();
 253                                            buffer_button_vertex[i]->allocate(sizeof(vt));
 254
 255                                            buffer_button_vertex[i]->write(0, vertexFormat, sizeof(vertexFormat));
 256                                            button_shader->setAttributeBuffer(vertex_loc, GL_FLOAT, 0, 3, 5 * sizeof(GLfloat));
 257                                            button_shader->setAttributeBuffer(texcoord_loc, GL_FLOAT, 3 * sizeof(GLfloat), 2, 5 * sizeof(GLfloat));
 258                                            buffer_button_vertex[i]->release();
 259                                            vertex_button[i]->release();
 260                                            button_shader->setUniformValue("a_texture", 0);
 261
 262                                            extfunc->glVertexAttribPointer(vertex_loc, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), 0);
 263                                            extfunc->glVertexAttribPointer(texcoord_loc, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat),
 264                                                                           (char *)NULL + 3 * sizeof(GLfloat));
 265                                            button_shader->enableAttributeArray(vertex_loc);
 266                                            button_shader->enableAttributeArray(texcoord_loc);
 267                                            vertex_button[i]->release();
 268                                         }
 269                                 }
 270                         }
 271                 }
 272 #endif
 273 #if defined(USE_BITMAP)
 274            buffer_bitmap_vertex = new QOpenGLBuffer(QOpenGLBuffer::VertexBuffer);
 275            vertex_bitmap = new QOpenGLVertexArrayObject;
 276            if(vertex_bitmap != NULL) {
 277                    if(vertex_bitmap->create()) {
 278                            vertexBitmap[0].x = -1.0f;
 279                            vertexBitmap[0].y = -1.0f;
 280                            vertexBitmap[0].z = -0.9f;
 281                            vertexBitmap[0].s = 0.0f;
 282                            vertexBitmap[0].t = 1.0f;
 283
 284                            vertexBitmap[1].x = +1.0f;
 285                            vertexBitmap[1].y = -1.0f;
 286                            vertexBitmap[1].z = -0.9f;
 287                            vertexBitmap[1].s = 1.0f;
 288                            vertexBitmap[1].t = 1.0f;
 289
 290                            vertexBitmap[2].x = +1.0f;
 291                            vertexBitmap[2].y = +1.0f;
 292                            vertexBitmap[2].z = -0.9f;
 293                            vertexBitmap[2].s = 1.0f;
 294                            vertexBitmap[2].t = 0.0f;
 295
 296                            vertexBitmap[3].x = -1.0f;
 297                            vertexBitmap[3].y = +1.0f;
 298                            vertexBitmap[3].z = -0.9f;
 299                            vertexBitmap[3].s = 0.0f;
 300                            vertexBitmap[3].t = 0.0f;
 301
 302                            buffer_bitmap_vertex->create();
 303                            buffer_bitmap_vertex->setUsagePattern(QOpenGLBuffer::DynamicDraw);
 304                            int vertex_loc = main_shader->attributeLocation("vertex");
 305                            int texcoord_loc = main_shader->attributeLocation("texcoord");
 306
 307                            vertex_bitmap->bind();
 308                            buffer_bitmap_vertex->bind();
 309                            buffer_bitmap_vertex->allocate(sizeof(vertexBitmap));
 310
 311                            buffer_bitmap_vertex->write(0, vertexFormat, sizeof(vertexFormat));
 312                            bitmap_shader->setAttributeBuffer(vertex_loc, GL_FLOAT, 0, 3, 5 * sizeof(GLfloat));
 313                            bitmap_shader->setAttributeBuffer(texcoord_loc, GL_FLOAT, 3 * sizeof(GLfloat), 2, 5 * sizeof(GLfloat));
 314                            buffer_bitmap_vertex->release();
 315                            vertex_bitmap->release();
 316                            bitmap_shader->setUniformValue("a_texture", 0);
 317
 318                            extfunc->glVertexAttribPointer(vertex_loc, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), 0);
 319                            extfunc->glVertexAttribPointer(texcoord_loc, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat),
 320                                                                                           (char *)NULL + 3 * sizeof(GLfloat));
 321                            bitmap_shader->enableAttributeArray(vertex_loc);
 322                            bitmap_shader->enableAttributeArray(texcoord_loc);
 323                            vertex_bitmap->release();
 324                    }
 325                 }
 326 #endif
 327            buffer_screen_vertex = new QOpenGLBuffer(QOpenGLBuffer::VertexBuffer);
 328            vertex_screen = new QOpenGLVertexArrayObject;
 329            if(vertex_screen != NULL) {
 330                    if(vertex_screen->create()) {
 331                            vertexFormat[0].x = -0.5f;
 332                            vertexFormat[0].y = -0.5f;
 333                            vertexFormat[0].z = 0.0f;
 334                            vertexFormat[0].s = 0.0f;
 335                            vertexFormat[0].t = 1.0f;
 336
 337                            vertexFormat[1].x = +0.5f;
 338                            vertexFormat[1].y = -0.5f;
 339                            vertexFormat[1].z = 0.0f;
 340                            vertexFormat[1].s = 1.0f;
 341                            vertexFormat[1].t = 1.0f;
 342
 343                            vertexFormat[2].x = +0.5f;
 344                            vertexFormat[2].y = +0.5f;
 345                            vertexFormat[2].z = 0.0f;
 346                            vertexFormat[2].s = 1.0f;
 347                            vertexFormat[2].t = 0.0f;
 348
 349                            vertexFormat[3].x = -0.5f;
 350                            vertexFormat[3].y = +0.5f;
 351                            vertexFormat[3].z = 0.0f;
 352                            vertexFormat[3].s = 0.0f;
 353                            vertexFormat[3].t = 0.0f;
 354
 355
 356                            buffer_screen_vertex->create();
 357                            buffer_screen_vertex->setUsagePattern(QOpenGLBuffer::DynamicDraw);
 358                            int vertex_loc = main_shader->attributeLocation("vertex");
 359                            int texcoord_loc = main_shader->attributeLocation("texcoord");
 360
 361                            vertex_screen->bind();
 362                            buffer_screen_vertex->bind();
 363                            buffer_screen_vertex->allocate(sizeof(vertexFormat));
 364
 365                            buffer_screen_vertex->write(0, vertexFormat, sizeof(vertexFormat));
 366                            main_shader->setAttributeBuffer(vertex_loc, GL_FLOAT, 0, 3, 5 * sizeof(GLfloat));
 367                            main_shader->setAttributeBuffer(texcoord_loc, GL_FLOAT, 3 * sizeof(GLfloat), 2, 5 * sizeof(GLfloat));
 368                            buffer_screen_vertex->release();
 369                            vertex_screen->release();
 370                            main_shader->setUniformValue("a_texture", 0);
 371
 372                            extfunc->glVertexAttribPointer(vertex_loc, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), 0);
 373                            extfunc->glVertexAttribPointer(texcoord_loc, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat),
 374                                                                (char *)NULL + 3 * sizeof(GLfloat));
 375                            main_shader->enableAttributeArray(vertex_loc);
 376                            main_shader->enableAttributeArray(texcoord_loc);
 377                            QMatrix4x4 mat;
 378                            mat.ortho(-1.0, 1.0, -1.0, +1.0, -1.0, 1.0);
 379                            mat.translate(0, 0, 0);
 380                    }
 381            }
 382         }
 383         bGL_PIXEL_UNPACK_BUFFER_BINDING = false;
 384 }