* Jan 22, 2016 : Initial.
*/
+#include "osd_types.h"
#include "qt_gldraw.h"
#include "qt_glpack.h"
#include "qt_glutil_gl3_0.h"
#include "csp_logger.h"
-#include "menu_flags.h"
#include <QOpenGLTexture>
#include <QOpenGLFunctions_3_0>
+#include <QColor>
+#include <QImageReader>
+#include <QRect>
+#include <QOpenGLTexture>
+
//extern USING_FLAGS *using_flags;
#if 0
// OLD_THREE_PHASE
void GLDraw_3_0::initPackedGLObject(GLScreenPack **p,
int _width, int _height,
const QString vertex_shader, const QString fragment_shader,
- const QString _name)
+ const QString _name, bool req_float, bool req_highp)
{
QString s;
GLScreenPack *pp;
if(p != NULL) {
- pp = new GLScreenPack(_width, _height, p_wid);
+ pp = new GLScreenPack(_width, _height, _name, p_wid, req_float, req_highp);
*p = pp;
if(pp != NULL) {
pp->initialize(_width, _height, vertex_shader, fragment_shader);
csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GL_SHADER, "Fragment: %s ", fragment_shader.toLocal8Bit().constData());
csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GL_SHADER, "%s", s.toLocal8Bit().constData());
}
+ s = pp->getGLLog();
+ if(s.size() > 0) {
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GL_SHADER, "%s", s.toLocal8Bit().constData());
+ pp->clearGLLog();
+ }
}
}
}
bool f = false;
grids_shader = new QOpenGLShaderProgram(p_wid);
if(grids_shader != NULL) {
- if(using_flags->is_use_screen_rotate()) {
- f = grids_shader->addShaderFromSourceFile(QOpenGLShader::Vertex, vertex_rotate);
- } else {
- f = grids_shader->addShaderFromSourceFile(QOpenGLShader::Vertex, vertex_fixed);
- }
+ f = grids_shader->addShaderFromSourceFile(QOpenGLShader::Vertex, vertex_rotate);
f &= grids_shader->addShaderFromSourceFile(QOpenGLShader::Fragment, fragment);
f &= grids_shader->link();
}
initPackedGLObject(&main_pass,
using_flags->get_screen_width() * 2, using_flags->get_screen_height() * 2,
":/gl3/vertex_shader.glsl" , ":/gl3/chromakey_fragment_shader2.glsl",
- "Main Shader");
+ "Main Shader", false, false);
} else {
initPackedGLObject(&main_pass,
using_flags->get_screen_width() * 2, using_flags->get_screen_height() * 2,
":/gl3/vertex_shader.glsl" , ":/gl3/fragment_shader.glsl",
- "Main Shader");
+ "Main Shader", false, false);
}
if(main_pass != NULL) {
setNormalVAO(main_pass->getShader(), main_pass->getVAO(),
initPackedGLObject(&std_pass,
using_flags->get_screen_width(), using_flags->get_screen_height(),
":/gl3/vertex_shader.glsl" , ":/gl3/chromakey_fragment_shader.glsl",
- "Standard Shader");
+ "Standard Shader", false, false);
initPackedGLObject(&led_pass,
10, 10,
":/gl3/led_vertex_shader.glsl" , ":/gl3/led_fragment_shader.glsl",
- "LED Shader");
+ "LED Shader", false, false);
for(int i = 0; i < 32; i++) {
led_pass_vao[i] = new QOpenGLVertexArrayObject;
led_pass_vbuffer[i] = new QOpenGLBuffer(QOpenGLBuffer::VertexBuffer);
initPackedGLObject(&osd_pass,
48.0, 48.0,
":/gl3/vertex_shader.glsl" , ":/gl3/icon_fragment_shader.glsl",
- "OSD Shader");
+ "OSD Shader", false, false);
for(int i = 0; i < 32; i++) {
osd_pass_vao[i] = new QOpenGLVertexArrayObject;
osd_pass_vbuffer[i] = new QOpenGLBuffer(QOpenGLBuffer::VertexBuffer);
initPackedGLObject(&ntsc_pass1,
_width, _height,
":/gl3/vertex_shader.glsl" , ":/gl3/ntsc_pass1.glsl",
- "NTSC Shader Pass1");
+ "NTSC Shader Pass1", true, true);
initPackedGLObject(&ntsc_pass2,
_width / 2, _height,
":/gl3/vertex_shader.glsl" , ":/gl3/ntsc_pass2.glsl",
- "NTSC Shader Pass2");
+ "NTSC Shader Pass2", true, true);
{
int ii;
QOpenGLShaderProgram *shader = ntsc_pass2->getShader();
initPackedGLObject(&bitmap_block,
_width * 2, _height * 2,
":/gl3/vertex_shader.glsl", ":/gl3/normal_fragment_shader.glsl",
- "Background Bitmap Shader");
+ "Background Bitmap Shader", false, false);
if(bitmap_block != NULL) {
setNormalVAO(bitmap_block->getShader(), bitmap_block->getVAO(),
bitmap_block->getVertexBuffer(),
bp->bind();
vp->bind();
prg->bind();
- //GLfloat ff[2];
- //bp->read(8, &ff, sizeof(GLfloat) * 2);
- //printf("%d %f %f\n", number, ff[0], ff[1]);
+ QMatrix2x2 rot;
+ switch(p_config->rotate_type) {
+ case 0:
+ rot = QMatrix2x2(rot0);
+ break;
+ case 1:
+ rot = QMatrix2x2(rot90);
+ break;
+ case 2:
+ rot = QMatrix2x2(rot180);
+ break;
+ case 3:
+ rot = QMatrix2x2(rot270);
+ break;
+ default:
+ rot = QMatrix2x2(rot0);
+ break;
+ }
+ prg->setUniformValue("rotate_mat", rot);
prg->setUniformValue("color", color);
prg->enableAttributeArray("vertex");
int vertex_loc = prg->attributeLocation("vertex");
extfunc->glViewport(0, 0, p_wid->width(), p_wid->height());
extfunc->glOrtho(-1.0f, 1.0f, -1.0f, 1.0f, -1.0, 1.0);
- //extfunc->glEnable(GL_BLEND);
- //extfunc->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
- //extfunc->glBlendFunc(GL_SRC_ALPHA, GL_ONE);
extfunc->glVertexAttribPointer(vertex_loc, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 3, 0);
extfunc->glEnableVertexAttribArray(vertex_loc);
extfunc->glVertexPointer(3, GL_FLOAT, 0, 0);
extfunc->glDrawArrays(GL_LINES, 0, (number + 1) * 2);
extfunc->glDisableClientState(GL_VERTEX_ARRAY);
- //extfunc->glDisable(GL_BLEND);
+
prg->release();
vp->release();
bp->release();
void GLDraw_3_0::doSetGridsVertical(int pixels, bool force)
{
- GLDraw_2_0::doSetGridsVertical(pixels, force);
+ GLDraw_Tmpl::doSetGridsVertical(pixels, force);
updateGridsVAO(grids_vertical_buffer,
grids_vertical_vertex,
glVertGrids,
void GLDraw_3_0::doSetGridsHorizonal(int lines, bool force)
{
if((lines == vert_lines) && !force) return;
- GLDraw_2_0::doSetGridsHorizonal(lines, force);
+ GLDraw_Tmpl::doSetGridsHorizonal(lines, force);
updateGridsVAO(grids_horizonal_buffer,
grids_horizonal_vertex,
glHorizGrids,
if(ringing_phase > 1.0) ringing_phase = ringing_phase - 1.0;
shader->setUniformValue(ii, ringing_phase);
}
- //ii = shader->uniformLocation("luma_filter");
- //if(ii >= 0) {
- // shader->setUniformValueArray(ii, luma_filter, 24 + 1, 1);
- //}
- //ii = shader->uniformLocation("chroma_filter");
- //if(ii >= 0) {
- // shader->setUniformValueArray(ii, chroma_filter, 24 + 1, 1);
- //}
+ shader->setUniformValue("rotate_mat", QMatrix2x2(rot0));
+
}
{
QVector4D c(fBrightR, fBrightG, fBrightB, 1.0);
}
-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;
//screen_texture_width * 2,
//screen_texture_height * 2,
p->width(), p->height(),
- GL_BGRA, GL_UNSIGNED_BYTE, p->constBits());
+ GL_RGBA, GL_UNSIGNED_BYTE, p->constBits());
extfunc->glBindTexture(GL_TEXTURE_2D, 0);
}
- if(using_flags->is_support_tv_render() && (using_flags->get_config_ptr()->rendering_type == CONFIG_RENDER_TYPE_TV)) {
+ if(using_flags->is_support_tv_render() && (p_config->rendering_type == CONFIG_RENDER_TYPE_TV)) {
renderToTmpFrameBuffer_nPass(uVramTextureID->textureId(),
screen_texture_width,
screen_texture_height,
ntsc_pass2->getViewportHeight());
uTmpTextureID = ntsc_pass2->getTexture();
} else {
- renderToTmpFrameBuffer_nPass(uVramTextureID->textureId(),
- screen_texture_width,
- screen_texture_height,
- std_pass,
- std_pass->getViewportWidth(),
- std_pass->getViewportHeight(),
- use_chromakey);
+// renderToTmpFrameBuffer_nPass(uVramTextureID->textureId(),
+// screen_texture_width,
+// screen_texture_height,
+// std_pass,
+// std_pass->getViewportWidth(),
+// std_pass->getViewportHeight(),
+// use_chromakey);
//std_pass->bind();
- uTmpTextureID = std_pass->getTexture();
- //std_pass->release();
+ //uTmpTextureID = std_pass->getTexture();
+ uTmpTextureID = uVramTextureID->textureId(); //std_pass->release();
}
crt_flag = true;
}
}
QVector4D color;
- smoosing = using_flags->get_config_ptr()->use_opengl_filters;
+ smoosing = p_config->use_opengl_filters;
if(set_brightness) {
color = QVector4D(fBrightR, fBrightG, fBrightB, 1.0);
} else {
if(ii >= 0) {
prg->setUniformValue(ii, (float)screen_texture_height);
}
- if(using_flags->is_use_screen_rotate()) {
- if(using_flags->get_config_ptr()->rotate_type) {
- prg->setUniformValue("rotate", GL_TRUE);
- } else {
- prg->setUniformValue("rotate", GL_FALSE);
- }
- } else {
- prg->setUniformValue("rotate", GL_FALSE);
+
+ QMatrix2x2 rot;
+ switch(p_config->rotate_type) {
+ case 0:
+ rot = QMatrix2x2(rot0);
+ break;
+ case 1:
+ rot = QMatrix2x2(rot90);
+ break;
+ case 2:
+ rot = QMatrix2x2(rot180);
+ break;
+ case 3:
+ rot = QMatrix2x2(rot270);
+ break;
+ default:
+ rot = QMatrix2x2(rot0);
+ break;
}
+ prg->setUniformValue("rotate_mat", rot);
if(do_chromakey) {
ii = prg->uniformLocation("chromakey");
if(ii >= 0) {
prg->setUniformValue(ii, color);
}
- if(using_flags->is_use_screen_rotate()) {
- if(using_flags->get_config_ptr()->rotate_type) {
- prg->setUniformValue("rotate", GL_TRUE);
- } else {
- prg->setUniformValue("rotate", GL_FALSE);
- }
- } else {
- prg->setUniformValue("rotate", GL_FALSE);
+ QMatrix2x2 rot;
+ switch(p_config->rotate_type) {
+ case 0:
+ rot = QMatrix2x2(rot0);
+ break;
+ case 1:
+ rot = QMatrix2x2(rot90);
+ break;
+ case 2:
+ rot = QMatrix2x2(rot180);
+ break;
+ case 3:
+ rot = QMatrix2x2(rot270);
+ break;
+ default:
+ rot = QMatrix2x2(rot0);
+ break;
}
+ prg->setUniformValue("rotate_mat", rot);
if(do_chromakey) {
ii = prg->uniformLocation("chromakey");
if(ii >= 0) {
prg->setUniformValue(ii, GL_FALSE);
}
- if(using_flags->is_use_screen_rotate()) {
- if(using_flags->get_config_ptr()->rotate_type) {
- prg->setUniformValue("rotate", GL_TRUE);
- } else {
- prg->setUniformValue("rotate", GL_FALSE);
- }
- } else {
- prg->setUniformValue("rotate", GL_FALSE);
+ QMatrix2x2 rot;
+ switch(p_config->rotate_type) {
+ case 0:
+ rot = QMatrix2x2(rot0);
+ break;
+ case 1:
+ rot = QMatrix2x2(rot90);
+ break;
+ case 2:
+ rot = QMatrix2x2(rot180);
+ break;
+ case 3:
+ rot = QMatrix2x2(rot270);
+ break;
+ default:
+ rot = QMatrix2x2(rot0);
+ break;
}
+ prg->setUniformValue("rotate_mat", rot);
int vertex_loc = prg->attributeLocation("vertex");
int texcoord_loc = prg->attributeLocation("texcoord");
prg->setAttributeBuffer(vertex_loc, GL_FLOAT, 0, 3, sizeof(VertexTexCoord_t));
void GLDraw_3_0::drawBitmapTexture(void)
{
QVector4D color = QVector4D(1.0f, 1.0f, 1.0f, 1.0f);
- smoosing = using_flags->get_config_ptr()->use_opengl_filters;
+ smoosing = p_config->use_opengl_filters;
if(uBitmapTextureID == NULL) return;
if(using_flags->is_use_one_board_computer()) {
extfunc->glDisable(GL_BLEND);
major = 0;
minor = 0;
}
+ // ToDo: CD(6),LD(7) and HDD(8).
if((major != 0) && (icon_texid[major][minor] != NULL)) {
drawMain(osd_pass->getShader(), osd_pass_vao[i], osd_pass_vbuffer[i],
icon_texid[major][minor]->textureId(),
extfunc->glOrtho(-1.0f, 1.0f, -1.0f, 1.0f, -1.0, 1.0);
extfunc->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
- extfunc->glEnable(GL_DEPTH_TEST);
+ //extfunc->glEnable(GL_DEPTH_TEST);
+ extfunc->glDisable(GL_DEPTH_TEST);
extfunc->glDisable(GL_BLEND);
if(using_flags->is_use_one_board_computer() || using_flags->is_use_bitmap()) {
extfunc->glEnable(GL_BLEND);
extfunc->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
extfunc->glDisable(GL_DEPTH_TEST);
//drawOsdLeds();
- if(using_flags->get_config_ptr()->use_osd_virtual_media) drawOsdIcons();
+ if(p_config->use_osd_virtual_media) drawOsdIcons();
extfunc->glDisable(GL_BLEND);
if(!using_flags->is_use_one_board_computer() && (using_flags->get_max_button() <= 0)) {
drawGrids();
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();
}
main_pass->getVertexBuffer(),
vertexFormat, 4);
+ if(w > using_flags->get_real_screen_width()) {
+ w = using_flags->get_real_screen_width();
+ }
+ if(h > using_flags->get_real_screen_height()) {
+ h = using_flags->get_real_screen_height();
+ }
this->doSetGridsHorizonal(h, false);
this->doSetGridsVertical(w, false);
p_wid->doneCurrent();
}
void GLDraw_3_0::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_3_0::resizeGL(int width, int height)
{
//int side = qMin(width, height);
- p_wid->makeCurrent();
extfunc->glViewport(0, 0, width, height);
extfunc->glOrtho(-1.0f, 1.0f, -1.0f, 1.0f, -1.0, 1.0);
crt_flag = true;
if(using_flags->get_max_button() > 0) {
updateButtonTexture();
}
- p_wid->doneCurrent();
}
OSDN Git Service
