mirror/yacreader
1
0
Fork 0
mirror of https://github.com/YACReader/yacreader synced 2025-05-28 03:10:27 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #53 from selmf/light_gl_flow_refactoring

Browse Source 
Light gl flow refactoring
This commit is contained in:
Luis Ángel San Martín 2019-05-30 18:21:05 +02:00 committed by GitHub
commit 7b712e144a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 129 additions and 2155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
INSTALL.md
View File

@ -28,7 +28,6 @@ folder. To build it, enter the folder and run the commands described above.
- network - network
- A pdf rendering backend (optional, see below) - A pdf rendering backend (optional, see below)
- qrencode (optional) - qrencode (optional)
- glu
- (lib)unarr (see below) - (lib)unarr (see below)
Not all dependencies are needed at build time. For example the qml components in Not all dependencies are needed at build time. For example the qml components in

8
YACReader/YACReader.pro
View File

@ -53,13 +53,13 @@ INCLUDEPATH += ../common \
win32 { win32 {
CONFIG(force_angle) { CONFIG(force_angle) {
message("using ANGLE") message("using ANGLE")
LIBS += -loleaut32 -lole32 -lshell32 -lopengl32 -lglu32 -luser32 LIBS += -loleaut32 -lole32 -lshell32 -lopengl32 -luser32
#linking extra libs are necesary for a successful compilation, a better approach should be #linking extra libs are necesary for a successful compilation, a better approach should be
#to remove any OpenGL (desktop) dependencies #to remove any OpenGL (desktop) dependencies
#the OpenGL stuff should be migrated to OpenGL ES #the OpenGL stuff should be migrated to OpenGL ES
DEFINES += FORCE_ANGLE DEFINES += FORCE_ANGLE
} else { } else {
LIBS += -loleaut32 -lole32 -lshell32 -lopengl32 -lglu32 -luser32 LIBS += -loleaut32 -lole32 -lshell32 -lopengl32 -luser32
} }
QMAKE_CXXFLAGS_RELEASE += /MP /Ob2 /Oi /Ot /GT /GL QMAKE_CXXFLAGS_RELEASE += /MP /Ob2 /Oi /Ot /GT /GL
@ -67,10 +67,6 @@ win32 {
CONFIG -= embed_manifest_exe CONFIG -= embed_manifest_exe
} }
unix:!macx:!CONFIG(no_opengl) {
LIBS += -lGLU
}
macx { macx {
QT += macextras gui-private QT += macextras gui-private
CONFIG += objective_c CONFIG += objective_c

8
YACReaderLibrary/YACReaderLibrary.pro
View File

@ -30,13 +30,13 @@ INCLUDEPATH += ../common/gl
win32 { win32 {
CONFIG(force_angle) { CONFIG(force_angle) {
message("using ANGLE") message("using ANGLE")
LIBS += -loleaut32 -lole32 -lshell32 -lopengl32 -lglu32 -luser32 LIBS += -loleaut32 -lole32 -lshell32 -lopengl32 -luser32
# linking extra libs are necesary for a successful compilation, a better approach should be # linking extra libs are necesary for a successful compilation, a better approach should be
# to remove any OpenGL (desktop) dependencies # to remove any OpenGL (desktop) dependencies
# the OpenGL stuff should be migrated to OpenGL ES # the OpenGL stuff should be migrated to OpenGL ES
DEFINES += FORCE_ANGLE DEFINES += FORCE_ANGLE
} else { } else {
LIBS += -loleaut32 -lole32 -lshell32 -lopengl32 -lglu32 -luser32 LIBS += -loleaut32 -lole32 -lshell32 -lopengl32 -luser32
} }
QMAKE_CXXFLAGS_RELEASE += /MP /Ob2 /Oi /Ot /GT /GL QMAKE_CXXFLAGS_RELEASE += /MP /Ob2 /Oi /Ot /GT /GL
@ -62,10 +62,6 @@ CONFIG(force_angle) {
} }
} }
unix:!macx:!CONFIG(no_opengl) {
LIBS += -lGLU
}
macx { macx {
LIBS += -framework Foundation -framework ApplicationServices -framework AppKit LIBS += -framework Foundation -framework ApplicationServices -framework AppKit
CONFIG += objective_c CONFIG += objective_c

109
common/gl/yacreader_flow_gl.cpp
View File

@ -2,18 +2,9 @@
#include <QtGui> #include <QtGui>
#include <QtOpenGL> #include <QtOpenGL>
//#include <math.h> #include <QMatrix4x4>
#ifdef Q_OS_MAC
#include <OpenGL/glu.h>
#else
#include <GL/glu.h>
#endif
#include <QGLContext>
#include <QGLPixelBuffer>
#include <cmath> #include <cmath>
#include <iostream>
/*** Animation Settings ***/ /*** Animation Settings ***/
/*** Position Configuration ***/ /*** Position Configuration ***/
@ -374,10 +365,10 @@ void YACReaderFlowGL::udpatePerspective(int width, int height)
glViewport(0, 0, width*pixelRatio, height*pixelRatio); glViewport(0, 0, width*pixelRatio, height*pixelRatio);
glMatrixMode(GL_PROJECTION); glMatrixMode(GL_PROJECTION);
glLoadIdentity(); QMatrix4x4 perspectiveMatrix;
perspectiveMatrix.setToIdentity();
gluPerspective(20.0, GLdouble(width) / (float)height, 1.0, 200.0); perspectiveMatrix.perspective(20.0, GLdouble(width) / (float)height, 1.0, 200.0);
glLoadMatrixf(perspectiveMatrix.constData());
glMatrixMode(GL_MODELVIEW); glMatrixMode(GL_MODELVIEW);
} }
@ -869,12 +860,10 @@ void YACReaderFlowGL::setZoom(int zoom)
glViewport(0, 0, width, height); glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION); glMatrixMode(GL_PROJECTION);
glLoadIdentity(); QMatrix4x4 zoomMatrix;
//float sideX = ((float(width)/height)/2)*1.5; zoomMatrix.setToIdentity();
//float sideY = 0.5*1.5; zoomMatrix.perspective(zoom, (float)width / (float)height, 1.0, 200.0);
gluPerspective(zoom, (float)width / (float)height, 1.0, 200.0); glLoadMatrixf(zoomMatrix.constData());
//glOrtho(-sideX, sideX, -sideY+0.2, +sideY+0.2, 4, 11.0);
glMatrixMode(GL_MODELVIEW); glMatrixMode(GL_MODELVIEW);
} }
@ -1116,38 +1105,34 @@ void YACReaderFlowGL::mousePressEvent(QMouseEvent *event)
if(event->button() == Qt::LeftButton) if(event->button() == Qt::LeftButton)
{ {
float x,y; float x,y;
float pixelRatio = devicePixelRatio(); x = event->x()*devicePixelRatio();
x = event->x()*pixelRatio; y = event->y()*devicePixelRatio();
y = event->y()*pixelRatio;
GLint viewport[4]; GLint viewport[4];
GLdouble modelview[16]; QMatrix4x4 modelview;
GLdouble projection[16]; QMatrix4x4 projection;
GLfloat winX, winY, winZ; GLfloat winZ;
GLdouble posX, posY, posZ;
glGetDoublev( GL_MODELVIEW_MATRIX, modelview ); glGetFloatv(GL_MODELVIEW_MATRIX, modelview.data());
glGetDoublev( GL_PROJECTION_MATRIX, projection ); glGetFloatv(GL_PROJECTION_MATRIX, projection.data());
glGetIntegerv( GL_VIEWPORT, viewport ); glGetIntegerv(GL_VIEWPORT, viewport);
glReadPixels(x, int((float)viewport[3] - (float)y), 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &winZ );
winX = (float)x; auto clickVector = QVector3D(x, (float)viewport[3] - (float)y, winZ);
winY = (float)viewport[3] - (float)y; clickVector = clickVector.unproject(modelview, projection, QRect(viewport[0], viewport[1], viewport[2],viewport[3]));
glReadPixels(winX, int(winY), 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &winZ ); if((clickVector.x() >= 0.5 && !flowRightToLeft) || (clickVector.x() <=-0.5 && flowRightToLeft))
{
gluUnProject(winX, winY, winZ, modelview, projection, viewport, &posX, &posY, &posZ); showNext();
}
if((posX >= 0.5 && !flowRightToLeft) || (posX <=-0.5 && flowRightToLeft)) else if((clickVector.x() <=-0.5 && !flowRightToLeft) || (clickVector.x() >= 0.5 && flowRightToLeft) )
{ {
//int index = currentSelected+1; showPrevious();
//while((cfImages[index].current.x-cfImages[index].width/(2.0*config.rotation)) < posX) }
// index++; }
//setCurrentIndex(index-1); else
showNext(); {
}
else if((posX <=-0.5 && !flowRightToLeft) || (posX >= 0.5 && flowRightToLeft) )
showPrevious();
} else
QOpenGLWidget::mousePressEvent(event); QOpenGLWidget::mousePressEvent(event);
}
doneCurrent(); doneCurrent();
} }
@ -1155,26 +1140,22 @@ void YACReaderFlowGL::mouseDoubleClickEvent(QMouseEvent* event)
{ {
makeCurrent(); makeCurrent();
float x,y; float x,y;
float pixelRatio = devicePixelRatio(); x = event->x()*devicePixelRatio();
x = event->x()*pixelRatio; y = event->y()*devicePixelRatio();
y = event->y()*pixelRatio;
GLint viewport[4]; GLint viewport[4];
GLdouble modelview[16]; QMatrix4x4 modelview;
GLdouble projection[16]; QMatrix4x4 projection;
GLfloat winX, winY, winZ; GLfloat winZ;
GLdouble posX, posY, posZ;
glGetDoublev( GL_MODELVIEW_MATRIX, modelview ); glGetFloatv(GL_MODELVIEW_MATRIX, modelview.data());
glGetDoublev( GL_PROJECTION_MATRIX, projection ); glGetFloatv(GL_PROJECTION_MATRIX, projection.data());
glGetIntegerv( GL_VIEWPORT, viewport ); glGetIntegerv(GL_VIEWPORT, viewport);
glReadPixels(x, int((float)viewport[3] - (float)y), 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &winZ );
winX = (float)x; auto clickVector = QVector3D(x, (float)viewport[3] - (float)y, winZ);
winY = (float)viewport[3] - (float)y; clickVector = clickVector.unproject(modelview, projection, QRect(viewport[0], viewport[1], viewport[2],viewport[3]));
glReadPixels( x, int(winY), 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &winZ );
gluUnProject( winX, winY, winZ, modelview, projection, viewport, &posX, &posY, &posZ); if(clickVector.x() <= 0.5 && clickVector.x() >= -0.5)
if(posX <= 0.5 && posX >= -0.5)
{ {
emit selected(centerIndex()); emit selected(centerIndex());
event->accept(); event->accept();

8
common/gl/yacreader_flow_gl.h
View File

@ -2,11 +2,6 @@
#ifndef __YACREADER_FLOW_GL_H #ifndef __YACREADER_FLOW_GL_H
#define __YACREADER_FLOW_GL_H #define __YACREADER_FLOW_GL_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <QOpenGLWidget> #include <QOpenGLWidget>
#include <QOpenGLFunctions> #include <QOpenGLFunctions>
#include <QOpenGLTexture> #include <QOpenGLTexture>
@ -16,8 +11,6 @@
#include "scroll_management.h" #include "scroll_management.h"
class ImageLoaderGL; class ImageLoaderGL;
class QGLContext;
class WidgetLoader;
class ImageLoaderByteArrayGL; class ImageLoaderByteArrayGL;
enum Performance enum Performance
@ -125,7 +118,6 @@ protected:
void udpatePerspective(int width, int height); void udpatePerspective(int width, int height);
int updateCount; int updateCount;
WidgetLoader * loader;
int fontSize; int fontSize;
QOpenGLTexture * defaultTexture; QOpenGLTexture * defaultTexture;

1605
common/gl_legacy/yacreader_flow_gl.cpp
View File

File diff suppressed because it is too large Load Diff

385
common/gl_legacy/yacreader_flow_gl.h
View File

@ -1,385 +0,0 @@
//OpenGL Coverflow API by J.Roth
#ifndef __YACREADER_FLOW_GL_H
#define __YACREADER_FLOW_GL_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <QtOpenGL>
#include <QGLWidget>
#include <QtWidgets>
#include "pictureflow.h" //TODO mover los tipos de flow de sitio
#include "scroll_management.h"
class ImageLoaderGL;
class QGLContext;
class WidgetLoader;
class ImageLoaderByteArrayGL;
enum Performance
{
low=0,
medium,
high,
ultraHigh
};
//Cover Vector
struct YACReader3DVector{
float x;
float y;
float z;
float rot;
};
//the image/texture info struct
struct YACReader3DImage{
GLuint texture;
//char name[256];
float width;
float height;
int index;
YACReader3DVector current;
YACReader3DVector animEnd;
};
struct Preset{
/*** Animation Settings ***/
//sets the speed of the animation
float animationStep;
//sets the acceleration of the animation
float animationSpeedUp;
//sets the maximum speed of the animation
float animationStepMax;
//sets the distance of view
float animationFadeOutDist;
//sets the rotation increasion
float preRotation;
//sets the light strenght on rotation
float viewRotateLightStrenght;
//sets the speed of the rotation
float viewRotateAdd;
//sets the speed of reversing the rotation
float viewRotateSub;
//sets the maximum view angle
float viewAngle;
/*** Position Configuration ***/
//the X Position of the Coverflow
float cfX;
//the Y Position of the Coverflow
float cfY;
//the Z Position of the Coverflow
float cfZ;
//the X Rotation of the Coverflow
float cfRX;
//the Y Rotation of the Coverflow
float cfRY;
//the Z Rotation of the Coverflow
float cfRZ;
//sets the rotation of each cover
float rotation;
//sets the distance between the covers
float xDistance;
//sets the distance between the centered and the non centered covers
float centerDistance;
//sets the pushback amount
float zDistance;
//sets the elevation amount
float yDistance;
float zoom;
};
extern struct Preset defaultYACReaderFlowConfig;
extern struct Preset presetYACReaderFlowClassicConfig;
extern struct Preset presetYACReaderFlowStripeConfig;
extern struct Preset presetYACReaderFlowOverlappedStripeConfig;
extern struct Preset pressetYACReaderFlowUpConfig;
extern struct Preset pressetYACReaderFlowDownConfig;
class YACReaderFlowGL : public QGLWidget, public ScrollManagement
{
Q_OBJECT
protected:
int timerId;
/*** System variables ***/
YACReader3DImage dummy;
int viewRotateActive;
float stepBackup;
/*functions*/
void calcPos(YACReader3DImage & image, int pos);
void calcVector(YACReader3DVector & vector, int pos);
//returns true if the animation is finished for Current
bool animate(YACReader3DVector &currentVector, YACReader3DVector &toVector);
void drawCover(const YACReader3DImage & image);
void udpatePerspective(int width, int height);
int updateCount;
WidgetLoader * loader;
int fontSize;
GLuint defaultTexture;
GLuint markTexture;
GLuint readingTexture;
void initializeGL();
void paintGL();
void timerEvent(QTimerEvent *);
//number of Covers
int numObjects;
int lazyPopulateObjects;
bool showMarks;
QVector<bool> loaded;
QVector<YACReaderComicReadStatus> marks;
QVector<YACReader3DImage> images;
bool hasBeenInitialized;
// sets flow direction right-to-left (manga mode)
bool flowRightToLeft;
Performance performance;
bool bUseVSync;
/*** Animation Settings ***/
Preset config;
//sets/returns the curent selected cover
int currentSelected;
//defines the position of the centered cover
YACReader3DVector centerPos;
/*** Style ***/
//sets the amount of shading of the covers in the back (0-1)
float shadingTop;
float shadingBottom;
//sets the reflection strenght (0-1)
float reflectionUp;
float reflectionBottom;
/*** System info ***/
float viewRotate;
//sets the updateInterval in ms
static int updateInterval;
void startAnimationTimer();
void stopAnimationTimer();
public:
/*Constructor*/
YACReaderFlowGL(QWidget *parent = 0,struct Preset p = pressetYACReaderFlowDownConfig);
virtual ~YACReaderFlowGL();
//size;
QSize minimumSizeHint() const;
//QSize sizeHint() const;
/*functions*/
//if called it moves the coverflow to the left
void showPrevious();
//if called it moves the coverflow to the right
void showNext();
//go to
void setCurrentIndex(int pos);
//must be called whenever the coverflow animation is stopped
void cleanupAnimation();
//Draws the coverflow
void draw();
//updates the coverflow
void updatePositions();
//inserts a new item to the coverflow
//if item is set to a value > -1 it updates a already set value
//otherwise a new entry is set
void insert(const char *name, GLuint Tex, float x, float y,int item = -1);
//removes a item
virtual void remove(int item);
//replaces the texture of the item 'item' with Tex
void replace(const char *name, GLuint Tex, float x, float y,int item);
//create n covers with the default nu
void populate(int n);
/*Info*/
//retuns the YACReader3DImage Struct of the current selected item
//to read title or textures
YACReader3DImage getCurrentSelected();
public slots:
void setCF_RX(int value);
//the Y Rotation of the Coverflow
void setCF_RY(int value);
//the Z Rotation of the Coverflow
void setCF_RZ(int value);
//perspective
void setZoom(int zoom);
void setRotation(int angle);
//sets the distance between the covers
void setX_Distance(int distance);
//sets the distance between the centered and the non centered covers
void setCenter_Distance(int distance);
//sets the pushback amount
void setZ_Distance(int distance);
void setCF_Y(int value);
void setCF_Z(int value);
void setY_Distance(int value);
void setFadeOutDist(int value);
void setLightStrenght(int value);
void setMaxAngle(int value);
void setPreset(const Preset & p);
void setPerformance(Performance performance);
void useVSync(bool b);
void setFlowRightToLeft(bool b);
virtual void updateImageData() = 0;
void reset();
void reload();
//interface with yacreaderlibrary, compatibility
void setShowMarks(bool value);
void setMarks(QVector<YACReaderComicReadStatus> marks);
void setMarkImage(QImage & image);
void markSlide(int index, YACReaderComicReadStatus status);
void unmarkSlide(int index);
void setSlideSize(QSize size);
void clear();
void setCenterIndex(unsigned int index);
void showSlide(int index);
int centerIndex();
void updateMarks();
//void setFlowType(PictureFlow::FlowType flowType);
void render();
//void paintEvent(QPaintEvent *event);
void mouseDoubleClickEvent(QMouseEvent* event);
void mousePressEvent(QMouseEvent *event);
void wheelEvent(QWheelEvent * event);
void keyPressEvent(QKeyEvent *event);
void resizeGL(int width, int height);
friend class ImageLoaderGL;
friend class ImageLoaderByteArrayGL;
signals:
void centerIndexChanged(int);
void selected(unsigned int);
};
class YACReaderComicFlowGL : public YACReaderFlowGL
{
public:
YACReaderComicFlowGL(QWidget *parent = 0,struct Preset p = defaultYACReaderFlowConfig);
void setImagePaths(QStringList paths);
void updateImageData();
void remove(int item);
void resortCovers(QList<int> newOrder);
friend class ImageLoaderGL;
private:
ImageLoaderGL * worker;
protected:
QList<QString> paths;
};
class YACReaderPageFlowGL : public YACReaderFlowGL
{
public:
YACReaderPageFlowGL(QWidget *parent = 0,struct Preset p = defaultYACReaderFlowConfig);
~YACReaderPageFlowGL();
void updateImageData();
void populate(int n);
QVector<bool> imagesReady;
QVector<QByteArray> rawImages;
QVector<bool> imagesSetted;
friend class ImageLoaderByteArrayGL;
private:
ImageLoaderByteArrayGL * worker;
};
class ImageLoaderGL : public QThread
{
public:
ImageLoaderGL(YACReaderFlowGL * flow);
~ImageLoaderGL();
// returns FALSE if worker is still busy and can't take the task
bool busy() const;
void generate(int index, const QString& fileName);
void reset(){idx = -1;fileName="";}
int index() const { return idx; }
void lock();
void unlock();
QImage result();
YACReaderFlowGL * flow;
GLuint resultTexture;
QImage loadImage(const QString& fileName);
protected:
void run();
private:
QMutex mutex;
QWaitCondition condition;
bool restart;
bool working;
int idx;
QString fileName;
QSize size;
QImage img;
};
class ImageLoaderByteArrayGL : public QThread
{
public:
ImageLoaderByteArrayGL(YACReaderFlowGL * flow);
~ImageLoaderByteArrayGL();
// returns FALSE if worker is still busy and can't take the task
bool busy() const;
void generate(int index, const QByteArray& raw);
void reset(){idx = -1; rawData.clear();}
int index() const { return idx; }
QImage result();
YACReaderFlowGL * flow;
GLuint resultTexture;
QImage loadImage(const QByteArray& rawData);
protected:
void run();
private:
QMutex mutex;
QWaitCondition condition;
bool restart;
bool working;
int idx;
QByteArray rawData;
QSize size;
QImage img;
};
#endif