mirror/projectm
3
0
Fork 0
mirror of https://github.com/projectM-visualizer/projectm.git synced 2026-02-06 07:05:55 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #70 from projectM-visualizer/gles3

Browse Source 
GLES3
This commit is contained in:
Mischa Spiegelmock
2018-06-10 16:32:01 +03:00
committed by GitHub
parent 46e92f41ed 6cdba2c68e
commit 1cacdd6799
24 changed files with 1187 additions and 734 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
.travis.yml
View File

@ -6,8 +6,8 @@ before_install:
# TODO: test different combinations of flags, --enable-sdl, --enable-qt, etc
script:
- ./configure --enable-sdl --enable-ftgl --prefix=$PWD/local && make -j8 && make install # build from checkout
- make dist && tar -zxf projectM-*.tar.gz && cd projectM-* && ./configure --enable-sdl --enable-ftgl --prefix=$PWD/dist_install && make -j8 && make install # build from dist
- ./configure --enable-sdl --prefix=$PWD/local && make -j8 && make install # build from checkout
- make dist && tar -zxf projectM-*.tar.gz && cd projectM-* && ./configure --enable-sdl --prefix=$PWD/dist_install && make -j8 && make install # build from dist
- echo "PWD $PWD"
- ls .
- test -e src/projectM-sdl/projectMSDL
@ -36,6 +36,7 @@ matrix:
- libftgl-dev
- libsdl2-dev
- libdevil-dev
- libglm-dev
env:
- MATRIX_EVAL="CC=clang-5.0 && CXX=clang++-5.0"
# linux/gcc
@ -51,6 +52,7 @@ matrix:
- libftgl-dev
- libsdl2-dev
- libdevil-dev
- libglm-dev
env:
- MATRIX_EVAL="CC=gcc-7 && CXX=g++-7"
@ -58,7 +60,7 @@ matrix:
- os: osx
osx_image: xcode8
env:
- MATRIX_EVAL="brew update && brew install sdl2 && brew install ftgl"
- MATRIX_EVAL="brew update && brew install sdl2 ftgl glm"
notifications:
email:

6
README.md
View File

@ -61,13 +61,13 @@ Silverjuke (FOSS Jukebox)
```
## Linux (debian/ubuntu)
* `sudo apt-get install autoconf libtool libsdl2-dev libglew-dev libftgl-dev libsdl2-dev libdevil-dev`
* `sudo apt-get install autoconf libtool libsdl2-dev libglew-dev libftgl-dev libsdl2-dev libdevil-dev libglm-dev`
## FreeBSD
* `pkg install gcc autoconf automake libtool mesa-libs libGLU sdl2`
* `pkg install gcc autoconf automake libtool mesa-libs libGLU sdl2 glm`
## Mac OS X
* Install the [SDL2 Framework](https://www.libsdl.org/download-2.0.php)
* `brew install glm sdl2`
* `./configure --enable-sdl`

43
configure.ac
View File

@ -5,6 +5,7 @@ m4_ifdef([AM_PROG_AR], [AM_PROG_AR])
LT_INIT
AC_PROG_CXX
AC_LANG(C++)
AC_CONFIG_MACRO_DIRS([m4 m4/autoconf-archive])
AX_CHECK_GL
@ -56,28 +57,37 @@ AS_IF([test "x$enable_threading" = "xyes"], [
])
])
dnl FTGL
AC_ARG_ENABLE([ftgl],
AS_HELP_STRING([--enable-ftgl], [FTGL support to display text such as preset title, stats, fps, ...]),
[], [enable_ftgl=no])
AS_IF([test "x$enable_ftgl" = "xyes"], [
PKG_CHECK_MODULES(FTGL, [ftgl], [], [AC_MSG_ERROR([libftgl is required.])])
AC_DEFINE([USE_FTGL], [1], [Define USE_FTGL])
#dnl FTGL
#AC_ARG_ENABLE([ftgl],
# AS_HELP_STRING([--enable-ftgl], [FTGL support to display text such as preset title, stats, fps, ...]),
# [], [enable_ftgl=no])
#AS_IF([test "x$enable_ftgl" = "xyes"], [
# PKG_CHECK_MODULES(FTGL, [ftgl], [], [AC_MSG_ERROR([libftgl is required.])])
# AC_DEFINE([USE_FTGL], [1], [Define USE_FTGL])
#])
AC_CHECK_HEADER([glm/glm.hpp],, AC_MSG_ERROR(libglm is required.))
AC_ARG_ENABLE([gles],
AS_HELP_STRING([--enable-gles], [OpenGL ES support]),
[], [enable_gles=no])
AS_IF([test "x$enable_gles" = "xyes"], [
AC_DEFINE([USE_GLES], [1], [Define USE_GLES])
])
dnl Cg framework OSX -- replace with GLSL someday!
CG_CFLAGS=
CG_LDFLAGS=
FRAMEWORK_SEARCH_PATHS="-F/Library/Frameworks -F$HOME/Library/Frameworks"
AC_ARG_ENABLE([cg],
AS_HELP_STRING([--enable-cg], [Cg framework for shaders]),
[], [enable_cg=no])
AS_IF([test "x$enable_cg" = "xyes"], [
dnl AC_CHECK_HEADERS([Cg/cg.h], [], [AC_MSG_ERROR([Cg framework not found.])])
AC_DEFINE([USE_CG], [1], [Define USE_CG])
CG_LDFLAGS+="$FRAMEWORK_SEARCH_PATHS -framework Cg"
CG_CFLAGS+="$FRAMEWORK_SEARCH_PATHS"
])
#AC_ARG_ENABLE([cg],
#AS_HELP_STRING([--enable-cg], [Cg framework for shaders]),
#[], [enable_cg=no])
#AS_IF([test "x$enable_cg" = "xyes"], [
#dnl AC_CHECK_HEADERS([Cg/cg.h], [], [AC_MSG_ERROR([Cg framework not found.])])
#AC_DEFINE([USE_CG], [1], [Define USE_CG])
#CG_LDFLAGS+="$FRAMEWORK_SEARCH_PATHS -framework Cg"
#CG_CFLAGS+="$FRAMEWORK_SEARCH_PATHS"
#])
AC_SUBST([CG_CFLAGS])
AC_SUBST([CG_LDFLAGS])
@ -167,4 +177,5 @@ SDL: ${enable_sdl}
Qt & Pulseaudio: ${enable_qt}
FTGL: ${enable_ftgl}
Cg: ${enable_cg}
OpenGL ES: ${enable_gles}
])

172
src/libprojectM/Renderer/FBO.cpp
View File

@ -38,13 +38,13 @@ RenderTarget::~RenderTarget() {
if (useFBO)
{
glDeleteTextures( 1, &this->textureID[1] );
glDeleteRenderbuffersEXT(1, &this->depthb[0]);
glDeleteFramebuffersEXT(1, &this->fbuffer[0]);
glDeleteRenderbuffers(1, &this->depthb[0]);
glDeleteFramebuffers(1, &this->fbuffer[0]);
if(renderToTexture)
{
glDeleteTextures( 1, &this->textureID[2] );
glDeleteRenderbuffersEXT(1, &this->depthb[1]);
glDeleteFramebuffersEXT(1, &this->fbuffer[1]);
glDeleteRenderbuffers(1, &this->depthb[1]);
glDeleteFramebuffers(1, &this->fbuffer[1]);
}
}
#endif
@ -57,16 +57,15 @@ GLuint RenderTarget::initRenderToTexture()
if (this->useFBO==1)
{
if (this->renderToTexture == 1) {
return this->textureID[2];
}
this->renderToTexture=1;
GLuint fb2, depth_rb2;
glGenFramebuffersEXT(1, &fb2);
glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, fb2 );
glGenRenderbuffersEXT(1, &depth_rb2);
glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, depth_rb2 );
glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, this->texsize,this->texsize );
glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_rb2 );
glGenFramebuffers(1, &fb2);
glBindFramebuffer( GL_FRAMEBUFFER, fb2 );
this->fbuffer[1] = fb2;
this->depthb[1]= depth_rb2;
glGenTextures(1, &this->textureID[2]);
@ -74,10 +73,17 @@ GLuint RenderTarget::initRenderToTexture()
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, texsize, texsize, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL );
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, this->textureID[2], 0 );
return this->textureID[2];
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, this->textureID[2], 0 );
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (status == GL_FRAMEBUFFER_COMPLETE) {
return this->textureID[2];
}
std::cerr << "[projecM] warning: initRenderToTexture failed." << std::endl;
}
#endif
return -1;
@ -94,58 +100,48 @@ RenderTarget::RenderTarget(int texsize, int width, int height) : useFBO(false) {
this->texsize = texsize;
#ifdef USE_FBO
glewInit();
// Forceably disable FBO if user requested it but the video card / driver lacks
// the appropraite frame buffer extension.
if (useFBO = glewIsSupported("GL_EXT_framebuffer_object"))
{
GLuint fb, depth_rb, rgba_tex, other_tex;
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, fb );
glGenRenderbuffersEXT(1, &depth_rb);
glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, depth_rb );
glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, this->texsize,this->texsize );
glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_rb );
this->fbuffer[0] = fb;
this->depthb[0]= depth_rb;
glGenTextures(1, &other_tex);
glBindTexture(GL_TEXTURE_2D,other_tex);
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, texsize, texsize, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL );
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
//glGenerateMipmapEXT(GL_TEXTURE_2D);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glGenTextures(1, &rgba_tex);
glBindTexture(GL_TEXTURE_2D, rgba_tex);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, texsize, texsize, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL );
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
//glGenerateMipmapEXT(GL_TEXTURE_2D);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, rgba_tex, 0 );
this->textureID[0] = rgba_tex;
this->textureID[1] = other_tex;
GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
useFBO = true;
glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, 0);
GLuint fb, depth_rb, rgba_tex, other_tex;
glGenFramebuffers(1, &fb);
glBindFramebuffer( GL_FRAMEBUFFER, fb );
if (status == GL_FRAMEBUFFER_COMPLETE_EXT) {
return;
}
std::cerr << "[projecM] warning: FBO support not detected. Using fallback." << std::endl;
}
this->fbuffer[0] = fb;
this->depthb[0]= depth_rb;
glGenTextures(1, &other_tex);
glBindTexture(GL_TEXTURE_2D,other_tex);
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, texsize, texsize, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL );
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
//glGenerateMipmapEXT(GL_TEXTURE_2D);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glGenTextures(1, &rgba_tex);
glBindTexture(GL_TEXTURE_2D, rgba_tex);
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, texsize, texsize, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL );
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
//glGenerateMipmapEXT(GL_TEXTURE_2D);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, rgba_tex, 0 );
this->textureID[0] = rgba_tex;
this->textureID[1] = other_tex;
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
glBindFramebuffer (GL_FRAMEBUFFER, 0);
if (status == GL_FRAMEBUFFER_COMPLETE) {
return;
}
std::cerr << "[projecM] warning: FBO support not detected. Using fallback." << std::endl;
#endif
@ -171,10 +167,10 @@ RenderTarget::RenderTarget(int texsize, int width, int height) : useFBO(false) {
glTexImage2D(GL_TEXTURE_2D,
0,
GL_RGB,
GL_RGB,
this->texsize, this->texsize,
0,
GL_RGBA,
GL_RGB,
GL_UNSIGNED_BYTE,
NULL);
@ -183,46 +179,6 @@ RenderTarget::RenderTarget(int texsize, int width, int height) : useFBO(false) {
return;
}
void RenderTarget::fallbackRescale(int width, int height)
{
int mindim = width < height ? width : height;
int origtexsize = this->texsize;
this->texsize = nearestPower2( mindim, SCALE_MINIFY );
if (origtexsize == texsize)
return;
/* Create the texture that will be bound to the render this */
/*
if ( this->texsize != origtexsize ) {
glDeleteTextures( 1, &this->textureID[0] );
}
*/
glGenTextures(1, &this->textureID[0] );
glBindTexture(GL_TEXTURE_2D, this->textureID[0] );
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D,
0,
GL_RGB,
this->texsize, this->texsize,
0,
GL_RGBA,
GL_UNSIGNED_BYTE,
NULL);
}
/** Destroys the pbuffer */
/** Locks the pbuffer */
void RenderTarget::lock() {
@ -230,7 +186,7 @@ void RenderTarget::lock() {
#ifdef USE_FBO
if(this->useFBO)
{
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, this->fbuffer[0]);
glBindFramebuffer(GL_FRAMEBUFFER, this->fbuffer[0]);
}
#endif
}
@ -245,7 +201,7 @@ void RenderTarget::unlock() {
glCopyTexSubImage2D( GL_TEXTURE_2D,
0, 0, 0, 0, 0,
this->texsize, this->texsize );
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
return;
}
#endif

1
src/libprojectM/Renderer/FBO.hpp
View File

@ -49,7 +49,6 @@ public:
void unlock();
GLuint initRenderToTexture();
int nearestPower2( int value, TextureScale scaleRule );
void fallbackRescale(int width, int height);
/** Opaque pbuffer context and pbuffer */
/*

131
src/libprojectM/Renderer/Filters.cpp
View File

@ -8,18 +8,31 @@
#include "Common.hpp"
#include "projectM-opengl.h"
#include "Filters.hpp"
#include "ShaderEngine.hpp"
#include <glm/gtc/type_ptr.hpp>
void Brighten::InitVertexAttrib() {
float points[4][2] = {{-0.5, -0.5},
{-0.5, 0.5},
{ 0.5, 0.5},
{ 0.5, -0.5}};
glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
glDisableVertexAttribArray(1);
}
void Brighten::Draw(RenderContext &context)
{
float points[4][2] = {{-0.5, -0.5},
{-0.5, 0.5},
{ 0.5, 0.5},
{ 0.5, -0.5}};
glUseProgram(context.programID_v2f_c4f);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(2,GL_FLOAT,0,points);
glUniformMatrix4fv(ShaderEngine::Uniform_V2F_C4F_VertexTranformation(), 1, GL_FALSE, glm::value_ptr(context.mat_ortho));
glColor4f(1.0, 1.0, 1.0, 1.0);
glBindVertexArray(m_vaoID);
glVertexAttrib4f(1, 1.0, 1.0, 1.0, 1.0);
glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ZERO);
glDrawArrays(GL_TRIANGLE_FAN,0,4);
glBlendFunc(GL_ZERO, GL_DST_COLOR);
@ -28,58 +41,98 @@ void Brighten::Draw(RenderContext &context)
glDrawArrays(GL_TRIANGLE_FAN,0,4);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisableClientState(GL_VERTEX_ARRAY);
glBindVertexArray(0);
}
void Darken::InitVertexAttrib() {
float points[4][2] = {{-0.5, -0.5},
{-0.5, 0.5},
{ 0.5, 0.5},
{ 0.5, -0.5}};
glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
glDisableVertexAttribArray(1);
}
void Darken::Draw(RenderContext &context)
{
float points[4][2] = {{-0.5, -0.5},
{-0.5, 0.5},
{ 0.5, 0.5},
{ 0.5, -0.5}};
glUseProgram(context.programID_v2f_c4f);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(2,GL_FLOAT,0,points);
glColor4f(1.0, 1.0, 1.0, 1.0);
glBlendFunc(GL_ZERO, GL_DST_COLOR);
glDrawArrays(GL_TRIANGLE_FAN,0,4);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisableClientState(GL_VERTEX_ARRAY);
glUniformMatrix4fv(ShaderEngine::Uniform_V2F_C4F_VertexTranformation(), 1, GL_FALSE, glm::value_ptr(context.mat_ortho));
glVertexAttrib4f(1, 1.0, 1.0, 1.0, 1.0);
glBlendFunc(GL_ZERO, GL_DST_COLOR);
glBindVertexArray(m_vaoID);
glDrawArrays(GL_TRIANGLE_FAN,0,4);
glBindVertexArray(0);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
void Invert::InitVertexAttrib() {
float points[4][2] = {{-0.5, -0.5},
{-0.5, 0.5},
{ 0.5, 0.5},
{ 0.5, -0.5}};
glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
glDisableVertexAttribArray(1);
}
void Invert::Draw(RenderContext &context)
{
float points[4][2] = {{-0.5, -0.5},
{-0.5, 0.5},
{ 0.5, 0.5},
{ 0.5, -0.5}};
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(2,GL_FLOAT,0,points);
glColor4f(1.0, 1.0, 1.0, 1.0);
glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ZERO);
glDrawArrays(GL_TRIANGLE_FAN,0,4);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glUseProgram(context.programID_v2f_c4f);
glDisableClientState(GL_VERTEX_ARRAY);
glUniformMatrix4fv(ShaderEngine::Uniform_V2F_C4F_VertexTranformation(), 1, GL_FALSE, glm::value_ptr(context.mat_ortho));
glVertexAttrib4f(1, 1.0, 1.0, 1.0, 1.0);
glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ZERO);
glBindVertexArray(m_vaoID);
glDrawArrays(GL_TRIANGLE_FAN,0,4);
glBindVertexArray(0);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
void Solarize::InitVertexAttrib() {
float points[4][2] = {{-0.5, -0.5},
{-0.5, 0.5},
{ 0.5, 0.5},
{ 0.5, -0.5}};
glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
glDisableVertexAttribArray(1);
}
void Solarize::Draw(RenderContext &context)
{
float points[4][2] = {{-0.5, -0.5},
{-0.5, 0.5},
{ 0.5, 0.5},
{ 0.5, -0.5}};
glUseProgram(context.programID_v2f_c4f);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(2,GL_FLOAT,0,points);
glUniformMatrix4fv(ShaderEngine::Uniform_V2F_C4F_VertexTranformation(), 1, GL_FALSE, glm::value_ptr(context.mat_ortho));
glVertexAttrib4f(1, 1.0, 1.0, 1.0, 1.0);
glColor4f(1.0, 1.0, 1.0, 1.0);
glBlendFunc(GL_ZERO, GL_ONE_MINUS_DST_COLOR);
glBindVertexArray(m_vaoID);
glDrawArrays(GL_TRIANGLE_FAN,0,4);
glBlendFunc(GL_DST_COLOR, GL_ONE);
glDrawArrays(GL_TRIANGLE_FAN,0,4);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBindVertexArray(0);
glDisableClientState(GL_VERTEX_ARRAY);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}

12
src/libprojectM/Renderer/Filters.hpp
View File

@ -13,28 +13,32 @@
class Brighten : public RenderItem
{
public:
Brighten(){}
Brighten(){ Init(); }
void InitVertexAttrib();
void Draw(RenderContext &context);
};
class Darken : public RenderItem
{
public:
Darken(){}
Darken(){ Init(); }
void InitVertexAttrib();
void Draw(RenderContext &context);
};
class Invert : public RenderItem
{
public:
Invert(){}
Invert(){ Init(); }
void InitVertexAttrib();
void Draw(RenderContext &context);
};
class Solarize : public RenderItem
{
public:
Solarize(){}
Solarize(){ Init(); }
void InitVertexAttrib();
void Draw(RenderContext &context);
};

1
src/libprojectM/Renderer/Makefile.am
View File

@ -40,6 +40,7 @@ libRenderer_la_SOURCES = \
SOIL2/stb_image_write.h SOIL2/stbi_pvr_c.h
libRenderer_la_CPPFLAGS = ${my_CFLAGS} \
-include $(top_builddir)/config.h \
-I$(top_srcdir)/src/libprojectM \
${FTGL_CFLAGS} ${CG_CFLAGS}

133
src/libprojectM/Renderer/MilkdropWaveform.cpp
View File

@ -10,70 +10,109 @@
#include "MilkdropWaveform.hpp"
#include "math.h"
#include "BeatDetect.hpp"
#include "ShaderEngine.hpp"
#include <glm/gtc/type_ptr.hpp>
MilkdropWaveform::MilkdropWaveform(): RenderItem(),
x(0.5), y(0.5), r(1), g(0), b(0), a(1), mystery(0), mode(Line), scale(10), smoothing(0), rot(0), samples(0),modOpacityStart(0),modOpacityEnd(1),
modulateAlphaByVolume(false), maximizeColors(false), additive(false), dots(false), thick(false), loop(false) {}
modulateAlphaByVolume(false), maximizeColors(false), additive(false), dots(false), thick(false), loop(false) {
Init();
}
MilkdropWaveform::~MilkdropWaveform() {
}
void MilkdropWaveform::InitVertexAttrib() {
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
glDisableVertexAttribArray(1);
}
void MilkdropWaveform::Draw(RenderContext &context)
{
WaveformMath(context);
#ifndef EMSCRIPTEN
glMatrixMode( GL_MODELVIEW );
#endif
glPushMatrix();
glLoadIdentity();
glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
if(modulateAlphaByVolume) ModulateOpacityByVolume(context);
else temp_a = a;
MaximizeColors(context);
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * samples * 2, NULL, GL_DYNAMIC_DRAW);
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * samples * 2, wavearray, GL_DYNAMIC_DRAW);
#ifndef USE_GLES1
if(dots==1) glEnable(GL_LINE_STIPPLE);
#endif
if (two_waves) {
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * samples * 2, NULL, GL_DYNAMIC_DRAW);
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * samples * 2, wavearray2, GL_DYNAMIC_DRAW);
}
//Thick wave drawing
if (thick==1) glLineWidth( (context.texsize < 512 ) ? 2 : 2*context.texsize/512);
else glLineWidth( (context.texsize < 512 ) ? 1 : context.texsize/512);
glBindBuffer(GL_ARRAY_BUFFER, 0);
//Additive wave drawing (vice overwrite)
if (additive==1)glBlendFunc(GL_SRC_ALPHA, GL_ONE);
else glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glUseProgram(context.programID_v2f_c4f);
glm::mat4 mat_first_translation = glm::mat4(1.0);
mat_first_translation[3][0] = -0.5;
mat_first_translation[3][1] = -0.5;
glm::mat4 mat_scale = glm::mat4(1.0);
mat_scale[0][0] = aspectScale;
float s = glm::sin(glm::radians(-rot));
float c = glm::cos(glm::radians(-rot));
glm::mat4 mat_rotation = glm::mat4( c,-s, 0, 0,
s, c, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1);
glm::mat4 mat_second_translation = glm::mat4(1.0);
mat_second_translation[3][0] = 0.5;
mat_second_translation[3][1] = 0.5;
glm::mat4 mat_vertex = context.mat_ortho;
mat_vertex = mat_first_translation * mat_vertex;
mat_vertex = mat_scale * mat_vertex;
mat_vertex = mat_rotation * mat_vertex;
mat_vertex = mat_second_translation * mat_vertex;
glUniformMatrix4fv(ShaderEngine::Uniform_V2F_C4F_VertexTranformation(), 1, GL_FALSE, glm::value_ptr(mat_vertex));
if(modulateAlphaByVolume) ModulateOpacityByVolume(context);
else temp_a = a;
MaximizeColors(context);
#ifndef GL_TRANSITION
if(dots==1) glEnable(GL_LINE_STIPPLE);
#endif
//Thick wave drawing
if (thick==1) glLineWidth( (context.texsize < 512 ) ? 2 : 2*context.texsize/512);
else glLineWidth( (context.texsize < 512 ) ? 1 : context.texsize/512);
//Additive wave drawing (vice overwrite)
if (additive==1)glBlendFunc(GL_SRC_ALPHA, GL_ONE);
else glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBindVertexArray(m_vaoID);
if (loop)
glDrawArrays(GL_LINE_LOOP,0,samples);
else
glDrawArrays(GL_LINE_STRIP,0,samples);
glTranslatef(.5, .5, 0);
glRotatef(rot, 0, 0, 1);
glScalef(aspectScale, 1.0, 1.0);
glTranslatef(-.5, -.5, 0);
if (two_waves)
{
if (loop)
glDrawArrays(GL_LINE_LOOP,0,samples);
else
glDrawArrays(GL_LINE_STRIP,0,samples);
}
glBindVertexArray(0);
glEnableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glVertexPointer(2,GL_FLOAT,0,wavearray);
if (loop)
glDrawArrays(GL_LINE_LOOP,0,samples);
else
glDrawArrays(GL_LINE_STRIP,0,samples);
if (two_waves)
{
glVertexPointer(2,GL_FLOAT,0,wavearray2);
if (loop)
glDrawArrays(GL_LINE_LOOP,0,samples);
else
glDrawArrays(GL_LINE_STRIP,0,samples);
}
#ifndef USE_GLES1
#ifndef GL_TRANSITION
if(dots==1) glDisable(GL_LINE_STIPPLE);
#endif
glPopMatrix();
}
void MilkdropWaveform::ModulateOpacityByVolume(RenderContext &context)
@ -144,11 +183,11 @@ void MilkdropWaveform::MaximizeColors(RenderContext &context)
}
glColor4f(wave_r_switch, wave_g_switch, wave_b_switch, temp_a * masterAlpha);
glVertexAttrib4f(1, wave_r_switch, wave_g_switch, wave_b_switch, temp_a * masterAlpha);
}
else
{
glColor4f(r, g, b, temp_a * masterAlpha);
glVertexAttrib4f(1, r, g, b, temp_a * masterAlpha);
}
}

2
src/libprojectM/Renderer/MilkdropWaveform.hpp
View File

@ -42,7 +42,9 @@ public:
float smoothing;
MilkdropWaveform();
~MilkdropWaveform();
void Draw(RenderContext &context);
void InitVertexAttrib();
float modOpacityStart;
float modOpacityEnd;

526
src/libprojectM/Renderer/Renderable.cpp
View File

@ -2,6 +2,8 @@
#include "Common.hpp"
#include "Renderable.hpp"
#include <math.h>
#include "ShaderEngine.hpp"
#include <glm/gtc/type_ptr.hpp>
typedef float floatPair[2];
typedef float floatTriple[3];
@ -12,40 +14,71 @@ RenderContext::RenderContext()
RenderItem::RenderItem():masterAlpha(1){}
DarkenCenter::DarkenCenter():RenderItem(){}
MotionVectors::MotionVectors():RenderItem(){}
Border::Border():RenderItem(){}
void RenderItem::Init() {
glGenVertexArrays(1, &m_vaoID);
glGenBuffers(1, &m_vboID);
glBindVertexArray(m_vaoID);
glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
InitVertexAttrib();
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
RenderItem::~RenderItem() {
glDeleteBuffers(1, &m_vboID);
glDeleteVertexArrays(1, &m_vaoID);
}
DarkenCenter::DarkenCenter():RenderItem(){
Init();
}
MotionVectors::MotionVectors():RenderItem() {
Init();
}
Border::Border():RenderItem() {
Init();
}
void DarkenCenter::InitVertexAttrib() {
float points_colors[6][6] = {
{ 0.5, 0.5, 0, 0, 0, (3.0f/32.0f) * masterAlpha},
{ 0.45, 0.5, 0, 0, 0, 0},
{ 0.5, 0.45, 0, 0, 0, 0},
{ 0.55, 0.5, 0, 0, 0, 0},
{ 0.5, 0.55, 0, 0, 0, 0},
{ 0.45, 0.5, 0, 0, 0, 0}};
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float)*6, (void*)0); // points
glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(float)*6, (void*)(sizeof(float)*2)); // colors
glBufferData(GL_ARRAY_BUFFER, sizeof(points_colors), points_colors, GL_STATIC_DRAW);
}
void DarkenCenter::Draw(RenderContext &context)
{
//float unit=0.05f;
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glUseProgram(context.programID_v2f_c4f);
float colors[6][4] = {{0, 0, 0, (3.0f/32.0f) * masterAlpha},
{0, 0, 0, 0},
{0, 0, 0, 0},
{0, 0, 0, 0},
{0, 0, 0, 0},
{0, 0, 0, 0}};
glUniformMatrix4fv(ShaderEngine::Uniform_V2F_C4F_VertexTranformation(), 1, GL_FALSE, glm::value_ptr(context.mat_ortho));
float points[6][2] = {{ 0.5, 0.5},
{ 0.45, 0.5},
{ 0.5, 0.45},
{ 0.55, 0.5},
{ 0.5, 0.55},
{ 0.45, 0.5}};
glBindVertexArray(m_vaoID);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDrawArrays(GL_TRIANGLE_FAN,0,6);
glVertexPointer(2,GL_FLOAT,0,points);
glColorPointer(4,GL_FLOAT,0,colors);
glDrawArrays(GL_TRIANGLE_FAN,0,6);
}
glBindVertexArray(0);
}
Shape::Shape():RenderItem()
{
@ -80,269 +113,316 @@ Shape::Shape():RenderItem()
border_a = 0.0; /* alpha color value */
glGenVertexArrays(1, &m_vaoID_texture);
glGenBuffers(1, &m_vboID_texture);
glGenVertexArrays(1, &m_vaoID_not_texture);
glGenBuffers(1, &m_vboID_not_texture);
glBindVertexArray(m_vaoID_texture);
glBindBuffer(GL_ARRAY_BUFFER, m_vboID_texture);
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(struct_data), (void*)0); // Positions
glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(struct_data), (void*)(sizeof(float)*2)); // Colors
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(struct_data), (void*)(sizeof(float)*6)); // Textures
glBindVertexArray(m_vaoID_not_texture);
glBindBuffer(GL_ARRAY_BUFFER, m_vboID_not_texture);
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(struct_data), (void*)0); // points
glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(struct_data), (void*)(sizeof(float)*2)); // Colors
Init();
}
Shape::~Shape() {
glDeleteBuffers(1, &m_vboID_texture);
glDeleteVertexArrays(1, &m_vaoID_texture);
glDeleteBuffers(1, &m_vboID_not_texture);
glDeleteVertexArrays(1, &m_vaoID_not_texture);
}
void Shape::InitVertexAttrib() {
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, (void*)0); // points
glDisableVertexAttribArray(1);
}
void Shape::Draw(RenderContext &context)
{
float xval, yval;
float t;
// printf("drawing shape %f\n", ang);
float temp_radius= radius*(.707*.707*.707*1.04);
float temp_radius= radius*(.707*.707*.707*1.04);
//Additive Drawing or Overwrite
if ( additive==0) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
else glBlendFunc(GL_SRC_ALPHA, GL_ONE);
//Additive Drawing or Overwrite
if ( additive==0) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
else glBlendFunc(GL_SRC_ALPHA, GL_ONE);
xval= x;
yval= -(y-1);
xval= x;
yval= -(y-1);
if ( textured)
struct_data *buffer_data = new struct_data[sides+2];
if ( textured)
{
if (imageUrl !="")
{
GLuint tex= context.textureManager->getTexture(imageUrl);
if (tex != 0)
{
if (imageUrl !="")
{
GLuint tex= context.textureManager->getTexture(imageUrl);
if (tex != 0)
{
glBindTexture(GL_TEXTURE_2D, tex);
context.aspectRatio=1.0;
}
}
glMatrixMode(GL_TEXTURE);
glPushMatrix();
glLoadIdentity();
glEnable(GL_TEXTURE_2D);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
floatQuad *colors = new float[sides+2][4];
floatPair *tex = new float[sides+2][2];
floatPair *points = new float[sides+2][2];
//Define the center point of the shape
colors[0][0] = r;
colors[0][1] = g;
colors[0][2] = b;
colors[0][3] = a * masterAlpha;
tex[0][0] = 0.5;
tex[0][1] = 0.5;
points[0][0] = xval;
points[0][1] = yval;
for ( int i=1;i< sides+2;i++)
{
colors[i][0]= r2;
colors[i][1]=g2;
colors[i][2]=b2;
colors[i][3]=a2 * masterAlpha;
t = (i-1)/(float) sides;
tex[i][0] =0.5f + 0.5f*cosf(t*3.1415927f*2 + tex_ang + 3.1415927f*0.25f)*(context.aspectCorrect ? context.aspectRatio : 1.0)/ tex_zoom;
tex[i][1] = 0.5f + 0.5f*sinf(t*3.1415927f*2 + tex_ang + 3.1415927f*0.25f)/ tex_zoom;
points[i][0]=temp_radius*cosf(t*3.1415927f*2 + ang + 3.1415927f*0.25f)*(context.aspectCorrect ? context.aspectRatio : 1.0)+xval;
points[i][1]=temp_radius*sinf(t*3.1415927f*2 + ang + 3.1415927f*0.25f)+yval;
}
glVertexPointer(2,GL_FLOAT,0,points);
glColorPointer(4,GL_FLOAT,0,colors);
glTexCoordPointer(2,GL_FLOAT,0,tex);
glDrawArrays(GL_TRIANGLE_FAN,0,sides+2);
glDisable(GL_TEXTURE_2D);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
//Reset Texture state since we might have changed it
/*
if(this->renderTarget->useFBO)
{
glBindTexture( GL_TEXTURE_2D, renderTarget->textureID[1] );
}
else
{
glBindTexture( GL_TEXTURE_2D, renderTarget->textureID[0] );
}
*/
delete[] colors;
delete[] tex;
delete[] points;
glBindTexture(GL_TEXTURE_2D, tex);
context.aspectRatio=1.0;
}
else
{//Untextured (use color values)
}
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
//Define the center point of the shape
buffer_data[0].color_r = r;
buffer_data[0].color_g = g;
buffer_data[0].color_b = b;
buffer_data[0].color_a = a * masterAlpha;
buffer_data[0].tex_x = 0.5;
buffer_data[0].tex_y = 0.5;
buffer_data[0].point_x = xval;
buffer_data[0].point_y = yval;
floatQuad *colors = new float[sides+2][4];
floatPair *points = new float[sides+2][2];
for ( int i=1;i< sides+2;i++)
{
buffer_data[i].color_r=r2;
buffer_data[i].color_g=g2;
buffer_data[i].color_b=b2;
buffer_data[i].color_a=a2 * masterAlpha;
//Define the center point of the shape
colors[0][0]=r;
colors[0][1]=g;
colors[0][2]=b;
colors[0][3]=a * masterAlpha;
points[0][0]=xval;
points[0][1]=yval;
t = (i-1)/(float) sides;
buffer_data[i].tex_x =0.5f + 0.5f*cosf(t*3.1415927f*2 + tex_ang + 3.1415927f*0.25f)*(context.aspectCorrect ? context.aspectRatio : 1.0)/ tex_zoom;
buffer_data[i].tex_y = 0.5f + 0.5f*sinf(t*3.1415927f*2 + tex_ang + 3.1415927f*0.25f)/ tex_zoom;
buffer_data[i].point_x=temp_radius*cosf(t*3.1415927f*2 + ang + 3.1415927f*0.25f)*(context.aspectCorrect ? context.aspectRatio : 1.0)+xval;
buffer_data[i].point_y=temp_radius*sinf(t*3.1415927f*2 + ang + 3.1415927f*0.25f)+yval;
}
glBindBuffer(GL_ARRAY_BUFFER, m_vboID_texture);
glBufferData(GL_ARRAY_BUFFER, sizeof(struct_data)*(sides+2), NULL, GL_DYNAMIC_DRAW);
glBufferData(GL_ARRAY_BUFFER, sizeof(struct_data)*(sides+2), buffer_data, GL_DYNAMIC_DRAW);
glUseProgram(context.programID_v2f_c4f_t2f);
glActiveTexture(GL_TEXTURE0);
glUniformMatrix4fv(ShaderEngine::Uniform_V2F_C4F_T2F_VertexTranformation(), 1, GL_FALSE, glm::value_ptr(context.mat_ortho));
glUniform1i(ShaderEngine::Uniform_V2F_C4F_T2F_FragTextureSampler(), 0);
glBindVertexArray(m_vaoID_texture);
glDrawArrays(GL_TRIANGLE_FAN, 0, sides+2);
glBindVertexArray(0);
}
else
{//Untextured (use color values)
//Define the center point of the shape
buffer_data[0].color_r=r;
buffer_data[0].color_g=g;
buffer_data[0].color_b=b;
buffer_data[0].color_a=a * masterAlpha;
buffer_data[0].point_x=xval;
buffer_data[0].point_y=yval;
for ( int i=1;i< sides+2;i++)
{
buffer_data[i].color_r=r2;
buffer_data[i].color_g=g2;
buffer_data[i].color_b=b2;
buffer_data[i].color_a=a2 * masterAlpha;
t = (i-1)/(float) sides;
buffer_data[i].point_x=temp_radius*cosf(t*3.1415927f*2 + ang + 3.1415927f*0.25f)*(context.aspectCorrect ? context.aspectRatio : 1.0)+xval;
buffer_data[i].point_y=temp_radius*sinf(t*3.1415927f*2 + ang + 3.1415927f*0.25f)+yval;
}
for ( int i=1;i< sides+2;i++)
{
colors[i][0]=r2;
colors[i][1]=g2;
colors[i][2]=b2;
colors[i][3]=a2 * masterAlpha;
t = (i-1)/(float) sides;
points[i][0]=temp_radius*cosf(t*3.1415927f*2 + ang + 3.1415927f*0.25f)*(context.aspectCorrect ? context.aspectRatio : 1.0)+xval;
points[i][1]=temp_radius*sinf(t*3.1415927f*2 + ang + 3.1415927f*0.25f)+yval;
glBindBuffer(GL_ARRAY_BUFFER, m_vboID_not_texture);
}
glBufferData(GL_ARRAY_BUFFER, sizeof(struct_data)*(sides+2), NULL, GL_DYNAMIC_DRAW);
glBufferData(GL_ARRAY_BUFFER, sizeof(struct_data)*(sides+2), buffer_data, GL_DYNAMIC_DRAW);
glVertexPointer(2,GL_FLOAT,0,points);
glColorPointer(4,GL_FLOAT,0,colors);
glUseProgram(context.programID_v2f_c4f);
glUniformMatrix4fv(ShaderEngine::Uniform_V2F_C4F_VertexTranformation(), 1, GL_FALSE, glm::value_ptr(context.mat_ortho));
glBindVertexArray(m_vaoID_not_texture);
glDrawArrays(GL_TRIANGLE_FAN,0,sides+2);
glBindVertexArray(0);
}
glDrawArrays(GL_TRIANGLE_FAN,0,sides+2);
//draw first n-1 triangular pieces
floatPair *points = new float[sides+1][2];
delete[] colors;
delete[] points;
}
if (thickOutline==1) glLineWidth(context.texsize < 512 ? 1 : 2*context.texsize/512);
for ( int i=0;i< sides;i++)
{
t = (i-1)/(float) sides;
points[i][0]= temp_radius*cosf(t*3.1415927f*2 + ang + 3.1415927f*0.25f)*(context.aspectCorrect ? context.aspectRatio : 1.0)+xval;
points[i][1]= temp_radius*sinf(t*3.1415927f*2 + ang + 3.1415927f*0.25f)+yval;
}
glEnableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
floatPair *points = new float[sides+1][2];
glBufferData(GL_ARRAY_BUFFER, sizeof(floatPair)*(sides), NULL, GL_DYNAMIC_DRAW);
glBufferData(GL_ARRAY_BUFFER, sizeof(floatPair)*(sides), points, GL_DYNAMIC_DRAW);
glColor4f( border_r, border_g, border_b, border_a * masterAlpha);
glBindBuffer(GL_ARRAY_BUFFER, 0);
for ( int i=0;i< sides;i++)
{
t = (i-1)/(float) sides;
points[i][0]= temp_radius*cosf(t*3.1415927f*2 + ang + 3.1415927f*0.25f)*(context.aspectCorrect ? context.aspectRatio : 1.0)+xval;
points[i][1]= temp_radius*sinf(t*3.1415927f*2 + ang + 3.1415927f*0.25f)+yval;
glUseProgram(context.programID_v2f_c4f);
}
glUniformMatrix4fv(ShaderEngine::Uniform_V2F_C4F_VertexTranformation(), 1, GL_FALSE, glm::value_ptr(context.mat_ortho));
glVertexPointer(2,GL_FLOAT,0,points);
glDrawArrays(GL_LINE_LOOP,0,sides);
glVertexAttrib4f(1, border_r, border_g, border_b, border_a * masterAlpha);
if (thickOutline==1) glLineWidth(context.texsize < 512 ? 1 : context.texsize/512);
if (thickOutline==1) glLineWidth(context.texsize < 512 ? 1 : 2*context.texsize/512);
delete[] points;
glBindVertexArray(m_vaoID);
glDrawArrays(GL_LINE_LOOP,0,sides);
glBindVertexArray(0);
if (thickOutline==1) glLineWidth(context.texsize < 512 ? 1 : context.texsize/512);
delete[] buffer_data;
delete[] points;
}
void MotionVectors::InitVertexAttrib() {
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
glDisableVertexAttribArray(1);
}
void MotionVectors::Draw(RenderContext &context)
{
glEnableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
float intervalx=1.0/x_num;
float intervaly=1.0/y_num;
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
#ifndef EMSCRIPTEN
glPointSize(length);
#endif
glColor4f(r, g, b, a * masterAlpha);
if (x_num + y_num < 600)
{
int size = x_num * y_num ;
floatPair *points = new float[size][2];
for (int x=0;x<(int)x_num;x++)
{
for(int y=0;y<(int)y_num;y++)
int size = x_num * y_num ;
floatPair *points = new float[size][2];
for (int x=0;x<(int)x_num;x++)
{
float lx, ly, lz;
lx = x_offset+x*intervalx;
ly = y_offset+y*intervaly;
for(int y=0;y<(int)y_num;y++)
{
float lx, ly, lz;
lx = x_offset+x*intervalx;
ly = y_offset+y*intervaly;
points[(x * (int)y_num) + y][0] = lx;
points[(x * (int)y_num) + y][1] = ly;
points[(x * (int)y_num) + y][0] = lx;
points[(x * (int)y_num) + y][1] = ly;
}
}
}
glVertexPointer(2,GL_FLOAT,0,points);
glDrawArrays(GL_POINTS,0,size);
glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
delete[] points;
glBufferData(GL_ARRAY_BUFFER, sizeof(floatPair) * size, NULL, GL_DYNAMIC_DRAW);
glBufferData(GL_ARRAY_BUFFER, sizeof(floatPair) * size, points, GL_DYNAMIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
delete[] points;
glUseProgram(context.programID_v2f_c4f);
glUniformMatrix4fv(ShaderEngine::Uniform_V2F_C4F_VertexTranformation(), 1, GL_FALSE, glm::value_ptr(context.mat_ortho));
#ifndef GL_TRANSITION
if (length <= 0.0) {
glPointSize(1.0);
} else {
glPointSize(length);
}
#endif
glUniform1f(ShaderEngine::Uniform_V2F_C4F_VertexPointSize(), length);
glVertexAttrib4f(1, r, g, b, a * masterAlpha);
glBindVertexArray(m_vaoID);
glDrawArrays(GL_POINTS,0,size);
glBindVertexArray(0);
}
}
void Border::InitVertexAttrib() {
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
glDisableVertexAttribArray(1);
}
void Border::Draw(RenderContext &context)
{
glEnableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
//Draw Borders
float of=outer_size*.5;
float iff=inner_size*.5;
float texof=1.0-of;
//Draw Borders
float of=outer_size*.5;
float iff=inner_size*.5;
float texof=1.0-of;
//no additive drawing for borders
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f(outer_r, outer_g, outer_b, outer_a * masterAlpha);
float points[40] = {
// Outer
0,0, of,0,
0,1, of,texof,
1,1, texof,texof,
1,0, texof,of,
of,0, of,of,
float pointsA[4][2] = {{0,0},{0,1},{of,0},{of,1}};
glVertexPointer(2,GL_FLOAT,0,pointsA);
glDrawArrays(GL_TRIANGLE_STRIP,0,4);
// Inner
of,of, of+iff,of,
of,texof, of+iff,texof-iff,
texof,texof, texof-iff,texof-iff,
texof,of, texof-iff,of+iff,
of+iff,of, of+iff,of+iff,
};
float pointsB[4][2] = {{of,0},{of,of},{texof,0},{texof,of}};
glVertexPointer(2,GL_FLOAT,0,pointsB);
glDrawArrays(GL_TRIANGLE_STRIP,0,4);
glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
float pointsC[4][2] = {{texof,0},{texof,1},{1,0},{1,1}};
glVertexPointer(2,GL_FLOAT,0,pointsC);
glDrawArrays(GL_TRIANGLE_STRIP,0,4);
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 40, NULL, GL_DYNAMIC_DRAW);
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 40, points, GL_DYNAMIC_DRAW);
float pointsD[4][2] = {{of,1},{of,texof},{texof,1},{texof,texof}};
glVertexPointer(2,GL_FLOAT,0,pointsD);
glDrawArrays(GL_TRIANGLE_STRIP,0,4);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glColor4f(inner_r, inner_g, inner_b, inner_a * masterAlpha);
glUseProgram(context.programID_v2f_c4f);
// glRect doesn't exist in GLES I think
// TODO: replace glRect
#ifndef USE_GLES1
glRectd(of, of, of+iff, texof);
glRectd(of+iff, of, texof-iff, of+iff);
glRectd(texof-iff, of, texof, texof);
glRectd(of+iff, texof, texof-iff, texof-iff);
#endif
glUniformMatrix4fv(ShaderEngine::Uniform_V2F_C4F_VertexTranformation(), 1, GL_FALSE, glm::value_ptr(context.mat_ortho));
float pointsE[4][2] = {{of,of},{of,texof},{of+iff,of},{of+iff,texof}};
glVertexPointer(2,GL_FLOAT,0,pointsE);
glDrawArrays(GL_TRIANGLE_STRIP,0,4);
glVertexAttrib4f(1, outer_r, outer_g, outer_b, outer_a * masterAlpha);
float pointsF[4][2] = {{of+iff,of},{of+iff,of+iff},{texof-iff,of},{texof-iff,of+iff}};
glVertexPointer(2,GL_FLOAT,0,pointsF);
glDrawArrays(GL_TRIANGLE_STRIP,0,4);
//no additive drawing for borders
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
float pointsG[4][2] = {{texof-iff,of},{texof-iff,texof},{texof,of},{texof,texof}};
glVertexPointer(2,GL_FLOAT,0,pointsG);
glDrawArrays(GL_TRIANGLE_STRIP,0,4);
glBindVertexArray(m_vaoID);
float pointsH[4][2] = {{of+iff,texof},{of+iff,texof-iff},{texof-iff,texof},{texof-iff,texof-iff}};
glVertexPointer(2,GL_FLOAT,0,pointsH);
glDrawArrays(GL_TRIANGLE_STRIP,0,4);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 10);
glVertexAttrib4f(1, inner_r, inner_g, inner_b, inner_a * masterAlpha);
// 1st pass for inner
glDrawArrays(GL_TRIANGLE_STRIP, 10, 10);
// 2nd pass for inner
glDrawArrays(GL_TRIANGLE_STRIP, 10, 10);
glBindVertexArray(0);
}

39
src/libprojectM/Renderer/Renderable.hpp
View File

@ -4,6 +4,7 @@
#include <typeinfo>
#include "TextureManager.hpp"
#include "projectM-opengl.h"
#include <glm/mat4x4.hpp>
class BeatDetect;
@ -17,6 +18,9 @@ public:
bool aspectCorrect;
BeatDetect *beatDetect;
TextureManager *textureManager;
GLuint programID_v2f_c4f;
GLuint programID_v2f_c4f_t2f;
glm::mat4 mat_ortho;
RenderContext();
};
@ -24,9 +28,18 @@ public:
class RenderItem
{
public:
RenderItem();
~RenderItem();
float masterAlpha;
virtual void InitVertexAttrib() = 0;
virtual void Draw(RenderContext &context) = 0;
RenderItem();
protected:
virtual void Init();
GLuint m_vboID;
GLuint m_vaoID;
};
typedef std::vector<RenderItem*> RenderItemList;
@ -35,6 +48,7 @@ class DarkenCenter : public RenderItem
{
public:
DarkenCenter();
void InitVertexAttrib();
void Draw(RenderContext &context);
};
@ -73,7 +87,28 @@ public:
Shape();
~Shape();
void InitVertexAttrib();
virtual void Draw(RenderContext &context);
private:
struct struct_data {
float point_x;
float point_y;
float color_r;
float color_g;
float color_b;
float color_a;
float tex_x;
float tex_y;
};
GLuint m_vboID_texture;
GLuint m_vaoID_texture;
GLuint m_vboID_not_texture;
GLuint m_vaoID_not_texture;
};
class Text : RenderItem
@ -93,6 +128,7 @@ public:
float x_offset;
float y_offset;
void InitVertexAttrib();
void Draw(RenderContext &context);
MotionVectors();
};
@ -112,6 +148,7 @@ public:
float inner_b;
float inner_a;
void InitVertexAttrib();
void Draw(RenderContext &context);
Border();
};

291
src/libprojectM/Renderer/Renderer.cpp
View File

@ -11,6 +11,8 @@
#include "omptl/omptl"
#include "omptl/omptl_algorithm"
#include "UserTexture.hpp"
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
class Preset;
@ -81,13 +83,13 @@ Renderer::Renderer(int width, int height, int gx, int gy, int texsize, BeatDetec
#endif /** USE_FTGL */
int size = (mesh.height - 1) *mesh.width * 5 * 2;
int size = (mesh.height - 1) *mesh.width * 4 * 2;
p = ( float * ) wipemalloc ( size * sizeof ( float ) );
for (int j = 0; j < mesh.height - 1; j++)
{
int base = j * mesh.width * 2 * 5;
int base = j * mesh.width * 4 * 2;
for (int i = 0; i < mesh.width; i++)
@ -95,22 +97,72 @@ Renderer::Renderer(int width, int height, int gx, int gy, int texsize, BeatDetec
int index = j * mesh.width + i;
int index2 = (j + 1) * mesh.width + i;
int strip = base + i * 10;
p[strip + 2] = mesh.identity[index].x;
p[strip + 3] = mesh.identity[index].y;
p[strip + 4] = 0;
int strip = base + i * 8;
p[strip + 0] = mesh.identity[index].x;
p[strip + 1] = mesh.identity[index].y;
p[strip + 7] = mesh.identity[index2].x;
p[strip + 8] = mesh.identity[index2].y;
p[strip + 9] = 0;
p[strip + 4] = mesh.identity[index2].x;
p[strip + 5] = mesh.identity[index2].y;
}
}
renderContext.programID_v2f_c4f = shaderEngine.programID_v2f_c4f;
renderContext.programID_v2f_c4f_t2f = shaderEngine.programID_v2f_c4f_t2f;
#ifdef USE_CG
shaderEngine.setParams(renderTarget->texsize, renderTarget->textureID[1], aspect, beatDetect, textureManager);
#endif
// Interpolation VAO/VBO's
glGenBuffers(1, &m_vbo_Interpolation);
glGenVertexArrays(1, &m_vao_Interpolation);
glBindVertexArray(m_vao_Interpolation);
glBindBuffer(GL_ARRAY_BUFFER, m_vbo_Interpolation);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float)*4, (void*)0); // Positions
glDisableVertexAttribArray(1);
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(float)*4, (void*)(sizeof(float)*2)); // Textures
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
// CompositeOutput VAO/VBO's
glGenBuffers(1, &m_vbo_CompositeOutput);
glGenVertexArrays(1, &m_vao_CompositeOutput);
float composite_buffer_data[8][2] =
{
{ -0.5, -0.5 },
{ 0, 1 },
{ -0.5, 0.5 },
{ 0, 0 },
{ 0.5, 0.5 },
{ 1, 0 },
{ 0.5, -0.5 },
{ 1, 1 } };
glBindVertexArray(m_vao_CompositeOutput);
glBindBuffer(GL_ARRAY_BUFFER, m_vbo_CompositeOutput);
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 8 * 2, composite_buffer_data, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float)*4, (void*)0); // Positions
glDisableVertexAttribArray(1);
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(float)*4, (void*)(sizeof(float)*2)); // Textures
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
void Renderer::SetPipeline(Pipeline &pipeline)
@ -136,31 +188,11 @@ void Renderer::ResetTextures()
void Renderer::SetupPass1(const Pipeline &pipeline, const PipelineContext &pipelineContext)
{
//glMatrixMode(GL_PROJECTION);
//glPushMatrix();
//glMatrixMode(GL_MODELVIEW);
//glPushMatrix();
totalframes++;
renderTarget->lock();
glViewport(0, 0, renderTarget->texsize, renderTarget->texsize);
glEnable(GL_TEXTURE_2D);
//If using FBO, switch to FBO texture
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0, 1, 0.0, 1, -40, 40);
#ifndef EMSCRIPTEN
glMatrixMode(GL_MODELVIEW);
#endif
glLoadIdentity();
renderContext.mat_ortho = glm::ortho(0.0f, 1.0f, 0.0f, 1.0f, -40.0f, 40.0f);
#ifdef USE_CG
shaderEngine.RenderBlurTextures(pipeline, pipelineContext, renderTarget->texsize);
@ -188,13 +220,6 @@ void Renderer::RenderItems(const Pipeline &pipeline, const PipelineContext &pipe
void Renderer::FinishPass1()
{
draw_title_to_texture();
/** Restore original view state */
//glMatrixMode(GL_MODELVIEW);
//glPopMatrix();
//glMatrixMode(GL_PROJECTION);
//glPopMatrix();
renderTarget->unlock();
}
@ -211,7 +236,7 @@ void Renderer::Pass2(const Pipeline &pipeline, const PipelineContext &pipelineCo
#ifdef USE_FBO
if (renderTarget->renderToTexture)
{
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, this->renderTarget->fbuffer[1]);
glBindFramebuffer(GL_FRAMEBUFFER, this->renderTarget->fbuffer[1]);
glViewport(0, 0, this->renderTarget->texsize, this->renderTarget->texsize);
}
else
@ -220,17 +245,15 @@ void Renderer::Pass2(const Pipeline &pipeline, const PipelineContext &pipelineCo
glBindTexture(GL_TEXTURE_2D, this->renderTarget->textureID[0]);
#ifndef EMSCRIPTEN
glMatrixMode(GL_PROJECTION);
#endif
glLoadIdentity();
glOrtho(-0.5, 0.5, -0.5, 0.5, -40, 40);
renderContext.mat_ortho = glm::ortho(-0.5f, 0.5f, -0.5f, 0.5f, -40.0f, 40.0f);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glLineWidth(this->renderTarget->texsize < 512 ? 1 : this->renderTarget->texsize / 512.0);
CompositeOutput(pipeline, pipelineContext);
/* FTGL does not support OpenGL ES
#ifndef EMSCRIPTEN
glMatrixMode(GL_MODELVIEW);
#endif
@ -251,10 +274,11 @@ void Renderer::Pass2(const Pipeline &pipeline, const PipelineContext &pipelineCo
if (this->showstats % 2)
draw_stats();
glTranslatef(0.5, 0.5, 0);
*/
#ifdef USE_FBO
if (renderTarget->renderToTexture)
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
#endif
}
@ -268,7 +292,7 @@ void Renderer::RenderFrame(const Pipeline &pipeline, const PipelineContext &pipe
if (!renderTarget->renderToTexture)
{
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &externalFBO);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
#endif
@ -290,7 +314,7 @@ void Renderer::RenderFrame(const Pipeline &pipeline, const PipelineContext &pipe
// if it exists (0 means no external FBO)
// then rebind it just before calling the final pass: Pass2
if (!renderTarget->renderToTexture && externalFBO != 0)
glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, externalFBO);
glBindFramebuffer(GL_FRAMEBUFFER, externalFBO);
#endif
Pass2(pipeline, pipelineContext);
@ -306,12 +330,12 @@ void Renderer::Interpolation(const Pipeline &pipeline)
//Texture wrapping( clamp vs. wrap)
if (pipeline.textureWrap == 0)
{
#ifdef USE_GLES1
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
#ifdef GL_TRANSITION
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
#else
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
#endif
}
else
@ -320,41 +344,24 @@ void Renderer::Interpolation(const Pipeline &pipeline)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
}
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glActiveTexture(GL_TEXTURE0);
glBlendFunc(GL_SRC_ALPHA, GL_ZERO);
glColor4f(1.0, 1.0, 1.0, pipeline.screenDecay);
glEnable(GL_TEXTURE_2D);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
//glVertexPointer(2, GL_FLOAT, 0, p);
//glTexCoordPointer(2, GL_FLOAT, 0, t);
#ifndef EMSCRIPTEN
glInterleavedArrays(GL_T2F_V3F,0,p);
#endif
int size = (mesh.height - 1) * mesh.width * 4 * 2;
if (pipeline.staticPerPixel)
{
for (int j = 0; j < mesh.height - 1; j++)
{
int base = j * mesh.width * 2 * 5;
int base = j * mesh.width * 2 * 4;
for (int i = 0; i < mesh.width; i++)
{
int strip = base + i * 10;
p[strip] = pipeline.x_mesh[i][j];
p[strip + 1] = pipeline.y_mesh[i][j];
int strip = base + i * 8;
p[strip + 2] = pipeline.x_mesh[i][j];
p[strip + 3] = pipeline.y_mesh[i][j];
p[strip + 5] = pipeline.x_mesh[i][j+1];
p[strip + 6] = pipeline.y_mesh[i][j+1];
p[strip + 6] = pipeline.x_mesh[i][j+1];
p[strip + 7] = pipeline.y_mesh[i][j+1];
}
}
@ -366,31 +373,47 @@ void Renderer::Interpolation(const Pipeline &pipeline)
for (int j = 0; j < mesh.height - 1; j++)
{
int base = j * mesh.width * 2 * 5;
int base = j * mesh.width * 2 * 4;
for (int i = 0; i < mesh.width; i++)
{
int strip = base + i * 10;
int index = j * mesh.width + i;
int index2 = (j + 1) * mesh.width + i;
for (int i = 0; i < mesh.width; i++)
{
int strip = base + i * 8;
int index = j * mesh.width + i;
int index2 = (j + 1) * mesh.width + i;
p[strip] = mesh.p[index].x;
p[strip + 1] = mesh.p[index].y;
p[strip + 2] = mesh.p[index].x;
p[strip + 3] = mesh.p[index].y;
p[strip + 5] = mesh.p[index2].x;
p[strip + 6] = mesh.p[index2].y;
p[strip + 6] = mesh.p[index2].x;
p[strip + 7] = mesh.p[index2].y;
}
}
}
}
glBindBuffer(GL_ARRAY_BUFFER, m_vbo_Interpolation);
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * size, NULL, GL_DYNAMIC_DRAW);
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * size, p, GL_DYNAMIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glUseProgram(renderContext.programID_v2f_c4f_t2f);
glUniformMatrix4fv(ShaderEngine::Uniform_V2F_C4F_T2F_VertexTranformation(), 1, GL_FALSE, glm::value_ptr(renderContext.mat_ortho));
glUniform1i(ShaderEngine::Uniform_V2F_C4F_T2F_FragTextureSampler(), 0);
glVertexAttrib4f(1, 1.0, 1.0, 1.0, pipeline.screenDecay);
glBlendFunc(GL_SRC_ALPHA, GL_ZERO);
glBindVertexArray(m_vao_Interpolation);
for (int j = 0; j < mesh.height - 1; j++)
glDrawArrays(GL_TRIANGLE_STRIP,j* mesh.width* 2,mesh.width*2);
glDisable(GL_TEXTURE_2D);
glBindVertexArray(0);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
@ -422,6 +445,12 @@ Renderer::~Renderer()
// std::cerr << "freeing title fonts finished" << std::endl;
#endif
// std::cerr << "exiting destructor" << std::endl;
glDeleteBuffers(1, &m_vbo_Interpolation);
glDeleteVertexArrays(1, &m_vao_Interpolation);
glDeleteBuffers(1, &m_vbo_CompositeOutput);
glDeleteVertexArrays(1, &m_vao_CompositeOutput);
}
void Renderer::reset(int w, int h)
@ -434,56 +463,38 @@ void Renderer::reset(int w, int h)
shaderEngine.setAspect(aspect);
#endif
#ifndef EMSCRIPTEN
glShadeModel(GL_SMOOTH);
#endif
glCullFace(GL_BACK);
//glFrontFace( GL_CCW );
#ifndef GL_TRANSITION
glEnable(GL_LINE_SMOOTH);
#endif
glClearColor(0, 0, 0, 0);
glViewport(0, 0, w, h);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glEnable(GL_BLEND);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
#ifndef USE_GLES1
glDrawBuffer(GL_BACK);
glReadBuffer(GL_BACK);
#endif
glEnable(GL_BLEND);
glActiveTexture(GL_TEXTURE0);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_LINE_SMOOTH);
glEnable(GL_POINT_SMOOTH);
glClear(GL_COLOR_BUFFER_BIT);
#ifndef USE_GLES1
glLineStipple(2, 0xAAAA);
#endif
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
// TODO: how to port this to modern openGL ?
// glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
//glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
//glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
//glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
if (!this->renderTarget->useFBO)
{
this->renderTarget->fallbackRescale(w, h);
}
// if (!this->renderTarget->useFBO)
// {
// this->renderTarget->fallbackRescale(w, h);
// }
}
GLuint Renderer::initRenderToTexture()
@ -511,10 +522,6 @@ void Renderer::draw_title_to_screen(bool flip)
if (this->drawtitle > 0)
{
//setUpLighting();
//glEnable(GL_POLYGON_SMOOTH);
//glEnable( GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glClear(GL_DEPTH_BUFFER_BIT);
@ -756,51 +763,29 @@ void Renderer::draw_fps(float realfps)
void Renderer::CompositeOutput(const Pipeline &pipeline, const PipelineContext &pipelineContext)
{
glUseProgram(renderContext.programID_v2f_c4f_t2f);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glUniformMatrix4fv(ShaderEngine::Uniform_V2F_C4F_T2F_VertexTranformation(), 1, GL_FALSE, glm::value_ptr(renderContext.mat_ortho));
glUniform1i(ShaderEngine::Uniform_V2F_C4F_T2F_FragTextureSampler(), 0);
//Overwrite anything on the screen
glBlendFunc(GL_ONE, GL_ZERO);
glColor4f(1.0, 1.0, 1.0, 1.0f);
glVertexAttrib4f(1, 1.0, 1.0, 1.0, 1.0);
glEnable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE0);
#ifdef USE_CG
shaderEngine.enableShader(currentPipe->compositeShader, pipeline, pipelineContext);
#endif
float tex[4][2] =
{
{ 0, 1 },
{ 0, 0 },
{ 1, 0 },
{ 1, 1 } };
glBindVertexArray(m_vao_CompositeOutput);
float points[4][2] =
{
{ -0.5, -0.5 },
{ -0.5, 0.5 },
{ 0.5, 0.5 },
{ 0.5, -0.5 } };
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glEnableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glBindVertexArray(0);
glVertexPointer(2, GL_FLOAT, 0, points);
glTexCoordPointer(2, GL_FLOAT, 0, tex);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glDisable(GL_TEXTURE_2D);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
#ifdef USE_CG
shaderEngine.disableShader();
#endif

8
src/libprojectM/Renderer/Renderer.hpp
View File

@ -81,9 +81,7 @@ private:
static Pipeline* currentPipe;
RenderContext renderContext;
//per pixel equation variables
#ifdef USE_CG
ShaderEngine shaderEngine;
#endif
std::string m_presetName;
float* p;
@ -98,6 +96,12 @@ private:
std::string menu_fontURL;
std::string presetURL;
GLuint m_vbo_Interpolation;
GLuint m_vao_Interpolation;
GLuint m_vbo_CompositeOutput;
GLuint m_vao_CompositeOutput;
#ifdef USE_FTGL
FTGLPixmapFont *title_font;
FTGLPixmapFont *other_font;

170
src/libprojectM/Renderer/ShaderEngine.cpp
View File

@ -9,11 +9,102 @@
#include "ShaderEngine.hpp"
#include "BeatDetect.hpp"
#define GLSL_VERSION "410"
std::string v2f_c4f_vert(
"#version "
GLSL_VERSION
"\n"
""
"layout(location = 0) in vec2 vertex_position;\n"
"layout(location = 1) in vec4 vertex_color;\n"
""
"uniform mat4 vertex_transformation;\n"
"uniform float vertex_point_size;\n"
""
"out vec4 fragment_color;\n"
""
"void main(){\n"
" gl_Position = vertex_transformation * vec4(vertex_position, 0.0, 1.0);\n"
" gl_PointSize = vertex_point_size;\n"
" fragment_color = vertex_color;\n"
"}\n");
std::string v2f_c4f_frag(
"#version "
GLSL_VERSION
"\n"
"precision mediump float;\n"
""
"in vec4 fragment_color;\n"
"out vec4 color;\n"
""
"void main(){\n"
" color = fragment_color;\n"
"}\n");
std::string v2f_c4f_t2f_vert(
"#version "
GLSL_VERSION
"\n"
"layout(location = 0) in vec2 vertex_position;\n"
"layout(location = 1) in vec4 vertex_color;\n"
"layout(location = 2) in vec2 vertex_texture;\n"
""
"uniform mat4 vertex_transformation;\n"
""
"out vec4 fragment_color;\n"
"out vec2 fragment_texture;\n"
""
"void main(){\n"
" gl_Position = vertex_transformation * vec4(vertex_position, 0.0, 1.0);\n"
" fragment_color = vertex_color;\n"
" fragment_texture = vertex_texture;\n"
"}\n");
std::string v2f_c4f_t2f_frag(
"#version "
GLSL_VERSION
"\n"
"precision mediump float;\n"
""
"in vec4 fragment_color;\n"
"in vec2 fragment_texture;\n"
""
"uniform sampler2D texture_sampler;\n"
""
"out vec4 color;\n"
""
"void main(){\n"
" color = fragment_color * texture(texture_sampler, fragment_texture.st);\n"
"}\n");
GLint ShaderEngine::UNIFORM_V2F_C4F_VERTEX_TRANFORMATION = 0;
GLint ShaderEngine::UNIFORM_V2F_C4F_VERTEX_POINT_SIZE = 0;
GLint ShaderEngine::UNIFORM_V2F_C4F_T2F_VERTEX_TRANFORMATION = 0;
GLint ShaderEngine::UNIFORM_V2F_C4F_T2F_FRAG_TEXTURE_SAMPLER = 0;
ShaderEngine::ShaderEngine()
{
#ifdef USE_CG
SetupCg();
#endif
GLuint m_temp_vao;
glGenVertexArrays(1, &m_temp_vao);
glBindVertexArray(m_temp_vao);
programID_v2f_c4f = CompileShaderProgram(v2f_c4f_vert, v2f_c4f_frag);
programID_v2f_c4f_t2f = CompileShaderProgram(v2f_c4f_t2f_vert, v2f_c4f_t2f_frag);
UNIFORM_V2F_C4F_VERTEX_TRANFORMATION = glGetUniformLocation(programID_v2f_c4f, "vertex_transformation");
UNIFORM_V2F_C4F_VERTEX_POINT_SIZE = glGetUniformLocation(programID_v2f_c4f, "vertex_point_size");
UNIFORM_V2F_C4F_T2F_VERTEX_TRANFORMATION = glGetUniformLocation(programID_v2f_c4f_t2f, "vertex_transformation");
UNIFORM_V2F_C4F_T2F_FRAG_TEXTURE_SAMPLER = glGetUniformLocation(programID_v2f_c4f_t2f, "texture_sampler");
}
ShaderEngine::~ShaderEngine()
@ -696,3 +787,82 @@ void ShaderEngine::reset()
}
#endif
GLuint ShaderEngine::CompileShaderProgram(const std::string & VertexShaderCode, const std::string & FragmentShaderCode){
// Create the shaders
GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
GLint Result = GL_FALSE;
int InfoLogLength;
// Compile Vertex Shader
char const * VertexSourcePointer = VertexShaderCode.c_str();
glShaderSource(VertexShaderID, 1, &VertexSourcePointer , NULL);
glCompileShader(VertexShaderID);
// Check Vertex Shader
glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &Result);
glGetShaderiv(VertexShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
if ( InfoLogLength > 0 ){
std::vector<char> VertexShaderErrorMessage(InfoLogLength+1);
glGetShaderInfoLog(VertexShaderID, InfoLogLength, NULL, &VertexShaderErrorMessage[0]);
fprintf(stderr, "Error compiling base vertex shader: %s\n", &VertexShaderErrorMessage[0]);
}
// Compile Fragment Shader
char const * FragmentSourcePointer = FragmentShaderCode.c_str();
glShaderSource(FragmentShaderID, 1, &FragmentSourcePointer , NULL);
glCompileShader(FragmentShaderID);
// Check Fragment Shader
glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result);
glGetShaderiv(FragmentShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
if ( InfoLogLength > 0 ){
std::vector<char> FragmentShaderErrorMessage(InfoLogLength+1);
glGetShaderInfoLog(FragmentShaderID, InfoLogLength, NULL, &FragmentShaderErrorMessage[0]);
fprintf(stderr, "Error compiling base fragment shader: %s\n", &FragmentShaderErrorMessage[0]);
}
// Link the program
GLuint programID = glCreateProgram();
glAttachShader(programID, VertexShaderID);
glAttachShader(programID, FragmentShaderID);
glLinkProgram(programID);
// Check the program
glGetProgramiv(programID, GL_LINK_STATUS, &Result);
glGetProgramiv(programID, GL_INFO_LOG_LENGTH, &InfoLogLength);
if ( InfoLogLength > 0 ){
std::vector<char> ProgramErrorMessage(InfoLogLength+1);
glGetProgramInfoLog(programID, InfoLogLength, NULL, &ProgramErrorMessage[0]);
fprintf(stderr, "%s\n", &ProgramErrorMessage[0]);
}
glValidateProgram(programID);
// Check the program
glGetProgramiv(programID, GL_VALIDATE_STATUS, &Result);
glGetProgramiv(programID, GL_INFO_LOG_LENGTH, &InfoLogLength);
if ( InfoLogLength > 0 ){
std::vector<char> ProgramErrorMessage(InfoLogLength+1);
glGetProgramInfoLog(programID, InfoLogLength, NULL, &ProgramErrorMessage[0]);
fprintf(stderr, "%s\n", &ProgramErrorMessage[0]);
}
glDetachShader(programID, VertexShaderID);
glDetachShader(programID, FragmentShaderID);
glDeleteShader(VertexShaderID);
glDeleteShader(FragmentShaderID);
return programID;
}

16
src/libprojectM/Renderer/ShaderEngine.hpp
View File

@ -95,6 +95,22 @@ public:
std::string profileName;
#endif
GLuint programID_v2f_c4f;
GLuint programID_v2f_c4f_t2f;
GLuint CompileShaderProgram(const std::string & VertexShaderCode, const std::string & FragmentShaderCode);
static GLint Uniform_V2F_C4F_VertexTranformation() { return UNIFORM_V2F_C4F_VERTEX_TRANFORMATION; }
static GLint Uniform_V2F_C4F_VertexPointSize() { return UNIFORM_V2F_C4F_VERTEX_POINT_SIZE; }
static GLint Uniform_V2F_C4F_T2F_VertexTranformation() { return UNIFORM_V2F_C4F_T2F_VERTEX_TRANFORMATION; }
static GLint Uniform_V2F_C4F_T2F_FragTextureSampler() { return UNIFORM_V2F_C4F_T2F_FRAG_TEXTURE_SAMPLER; }
static GLint UNIFORM_V2F_C4F_VERTEX_TRANFORMATION;
static GLint UNIFORM_V2F_C4F_VERTEX_POINT_SIZE;
static GLint UNIFORM_V2F_C4F_T2F_VERTEX_TRANFORMATION;
static GLint UNIFORM_V2F_C4F_T2F_FRAG_TEXTURE_SAMPLER;
};
#endif /* SHADERENGINE_HPP_ */

120
src/libprojectM/Renderer/VideoEcho.cpp
View File

@ -6,53 +6,30 @@
*/
#include "VideoEcho.hpp"
#include "ShaderEngine.hpp"
#include <glm/gtc/type_ptr.hpp>
VideoEcho::VideoEcho(): a(0), zoom(1), orientation(Normal)
{
// TODO Auto-generated constructor stub
Init();
}
VideoEcho::~VideoEcho()
{
// TODO Auto-generated destructor stub
}
void VideoEcho::InitVertexAttrib() {
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float)*4, (void*)0); // Positions
glDisableVertexAttribArray(1);
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(float)*4, (void*)(sizeof(float)*2)); // Textures
}
void VideoEcho::Draw(RenderContext &context)
{
glEnable(GL_TEXTURE_2D);
float tex[4][2] = {{0, 1},
{0, 0},
{1, 0},
{1, 1}};
float points[4][2] = {{-0.5, -0.5},
{-0.5, 0.5},
{ 0.5, 0.5},
{ 0.5, -0.5}};
glEnableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glVertexPointer(2,GL_FLOAT,0,points);
glTexCoordPointer(2,GL_FLOAT,0,tex);
//Now Blend the Video Echo
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glMatrixMode(GL_TEXTURE);
//draw video echo
glColor4f(1.0, 1.0, 1.0, a * masterAlpha);
glTranslatef(.5, .5, 0);
glScalef(1.0/zoom, 1.0/zoom, 1);
glTranslatef(-.5, -.5, 0);
int flipx=1, flipy=1;
switch (orientation)
{
@ -63,17 +40,70 @@ void VideoEcho::Draw(RenderContext &context)
default: flipx=1;flipy=1; break;
}
double pointsFlip[4][2] = {{-0.5*flipx, -0.5*flipy},
{-0.5*flipx, 0.5*flipy},
{ 0.5*flipx, 0.5*flipy},
{ 0.5*flipx, -0.5*flipy}};
float buffer_data[8][2] = {
{-0.5f*flipx, -0.5f*flipy},
{0.0, 1.0},
glVertexPointer(2,GL_FLOAT,0,pointsFlip);
glDrawArrays(GL_TRIANGLE_FAN,0,4);
{-0.5f*flipx, 0.5f*flipy},
{0.0, 0.0},
glDisable(GL_TEXTURE_2D);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
{ 0.5f*flipx, 0.5f*flipy},
{1.0, 0.0},
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
{ 0.5f*flipx, -0.5f*flipy},
{1.0, 1.0}
};
glm::mat4 mat_first_translation = glm::mat4(1.0);
mat_first_translation[3][0] = -0.5;
mat_first_translation[3][1] = -0.5;
glm::mat4 mat_scale = glm::mat4(1.0);
mat_scale[0][0] = 1.0/zoom;
mat_scale[1][1] = 1.0/zoom;
glm::mat4 mat_second_translation = glm::mat4(1.0);
mat_second_translation[3][0] = 0.5;
mat_second_translation[3][1] = 0.5;
for (int i = 1; i < 8; i+=2) {
glm::vec4 texture = glm::vec4(buffer_data[i][0], buffer_data[i][1], 0, 1);
texture = mat_first_translation * texture;
texture = mat_scale * texture;
texture = mat_second_translation * texture;
buffer_data[i][0] = texture[0];
buffer_data[i][1] = texture[1];
}
glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 16, NULL, GL_DYNAMIC_DRAW);
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 16, buffer_data, GL_DYNAMIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glActiveTexture(GL_TEXTURE0);
glUseProgram(context.programID_v2f_c4f_t2f);
glUniformMatrix4fv(ShaderEngine::Uniform_V2F_C4F_T2F_VertexTranformation(), 1, GL_FALSE, glm::value_ptr(context.mat_ortho));
glUniform1i(ShaderEngine::Uniform_V2F_C4F_T2F_FragTextureSampler(), 0);
//Now Blend the Video Echo
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glVertexAttrib4f(1, 1.0, 1.0, 1.0, a * masterAlpha);
glBindVertexArray(m_vaoID);
//draw video echo
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glBindVertexArray(0);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}

1
src/libprojectM/Renderer/VideoEcho.hpp
View File

@ -27,6 +27,7 @@ public:
float zoom;
Orientation orientation;
void InitVertexAttrib();
void Draw(RenderContext &context);
};

150
src/libprojectM/Renderer/Waveform.cpp
View File

@ -9,6 +9,8 @@
#include "Waveform.hpp"
#include <algorithm>
#include "BeatDetect.hpp"
#include "ShaderEngine.hpp"
#include <glm/gtc/type_ptr.hpp>
typedef float floatPair[2];
typedef float floatTriple[3];
@ -27,88 +29,90 @@ Waveform::Waveform(int samples)
smoothing = 0; /* smooth factor of waveform */
sep = 0;
Init();
}
void Waveform::InitVertexAttrib() {
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(ColoredPoint), (void*)0); // points
glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(ColoredPoint), (void*)(sizeof(float)*2)); // colors
}
void Waveform::Draw(RenderContext &context)
{
{
float *value1 = new float[samples];
float *value2 = new float[samples];
context.beatDetect->pcm->getPCM( value1, samples, 0, spectrum, smoothing, 0);
context.beatDetect->pcm->getPCM( value2, samples, 1, spectrum, smoothing, 0);
//if (samples > 2048) samples = 2048;
float mult= scaling*( spectrum ? 0.015f :1.0f);
std::transform(&value1[0],&value1[samples],&value1[0],std::bind2nd(std::multiplies<float>(),mult));
std::transform(&value2[0],&value2[samples],&value2[0],std::bind2nd(std::multiplies<float>(),mult));
if (additive) glBlendFunc(GL_SRC_ALPHA, GL_ONE);
else glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
WaveformContext waveContext(samples, context.beatDetect);
// webGL doesn't do glPointSize
#ifndef EMSCRIPTEN
if (thick)
{
glLineWidth(context.texsize <= 512 ? 2 : 2*context.texsize/512);
glPointSize(context.texsize <= 512 ? 2 : 2*context.texsize/512);
for(int x=0;x< samples;x++)
{
waveContext.sample = x/(float)(samples - 1);
waveContext.sample_int = x;
waveContext.left = value1[x];
waveContext.right = value2[x];
}
else glPointSize(context.texsize <= 512 ? 1 : context.texsize/512);
points[x] = PerPoint(points[x],waveContext);
}
std::vector<ColoredPoint> points_transf = points;
for (std::vector<ColoredPoint>::iterator iter = points_transf.begin(); iter != points_transf.end(); ++iter) {
(*iter).y = -( (*iter).y-1);
(*iter).a *= masterAlpha;
}
glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
glBufferData(GL_ARRAY_BUFFER, sizeof(ColoredPoint) * samples, NULL, GL_DYNAMIC_DRAW);
glBufferData(GL_ARRAY_BUFFER, sizeof(ColoredPoint) * samples, &points_transf[0], GL_DYNAMIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glUseProgram(context.programID_v2f_c4f);
glUniformMatrix4fv(ShaderEngine::Uniform_V2F_C4F_VertexTranformation(), 1, GL_FALSE, glm::value_ptr(context.mat_ortho));
if (additive) glBlendFunc(GL_SRC_ALPHA, GL_ONE);
else glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
if (thick)
{
glLineWidth(context.texsize <= 512 ? 2 : 2*context.texsize/512);
#ifndef GL_TRANSITION
glPointSize(context.texsize <= 512 ? 2 : 2*context.texsize/512);
#endif
float *value1 = new float[samples];
float *value2 = new float[samples];
context.beatDetect->pcm->getPCM( value1, samples, 0, spectrum, smoothing, 0);
context.beatDetect->pcm->getPCM( value2, samples, 1, spectrum, smoothing, 0);
// printf("%f\n",pcmL[0]);
float mult= scaling*( spectrum ? 0.015f :1.0f);
std::transform(&value1[0],&value1[samples],&value1[0],std::bind2nd(std::multiplies<float>(),mult));
std::transform(&value2[0],&value2[samples],&value2[0],std::bind2nd(std::multiplies<float>(),mult));
WaveformContext waveContext(samples, context.beatDetect);
for(int x=0;x< samples;x++)
{
waveContext.sample = x/(float)(samples - 1);
waveContext.sample_int = x;
waveContext.left = value1[x];
waveContext.right = value2[x];
points[x] = PerPoint(points[x],waveContext);
}
floatQuad *colors = new float[samples][4];
floatPair *p = new float[samples][2];
for(int x=0;x< samples;x++)
{
colors[x][0] = points[x].r;
colors[x][1] = points[x].g;
colors[x][2] = points[x].b;
colors[x][3] = points[x].a * masterAlpha;
p[x][0] = points[x].x;
p[x][1] = -(points[x].y-1);
}
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glVertexPointer(2,GL_FLOAT,0,p);
glColorPointer(4,GL_FLOAT,0,colors);
if (dots) glDrawArrays(GL_POINTS,0,samples);
else glDrawArrays(GL_LINE_STRIP,0,samples);
glPointSize(context.texsize < 512 ? 1 : context.texsize/512);
glLineWidth(context.texsize < 512 ? 1 : context.texsize/512);
#ifndef USE_GLES1
glDisable(GL_LINE_STIPPLE);
glUniform1f(ShaderEngine::Uniform_V2F_C4F_VertexPointSize(), context.texsize <= 512 ? 2 : 2*context.texsize/512);
}
else
{
#ifndef GL_TRANSITION
glPointSize(context.texsize <= 512 ? 1 : context.texsize/512);
#endif
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// glPopMatrix();
glUniform1f(ShaderEngine::Uniform_V2F_C4F_VertexPointSize(), context.texsize <= 512 ? 1 : context.texsize/512);
}
delete[] colors;
delete[] p;
delete[] value1;
delete[] value2;
glBindVertexArray(m_vaoID);
if (dots) glDrawArrays(GL_POINTS,0,samples);
else glDrawArrays(GL_LINE_STRIP,0,samples);
glBindVertexArray(0);
glLineWidth(context.texsize < 512 ? 1 : context.texsize/512);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
delete[] value1;
delete[] value2;
}

1
src/libprojectM/Renderer/Waveform.hpp
View File

@ -53,6 +53,7 @@ public:
int sep; /* no idea what this is yet... */
Waveform(int samples);
void InitVertexAttrib();
void Draw(RenderContext &context);
private:

14
src/libprojectM/projectM-opengl.h
View File

@ -5,15 +5,23 @@
#ifndef __PROJECTM_OPENGL_H__
#define __PROJECTM_OPENGL_H__
// stuff that needs to be ported to newer GL calls
#define GL_TRANSITION
#ifdef __APPLE__
# include <OpenGL/gl.h>
# include <OpenGL/gl3.h>
# include <OpenGL/gl3ext.h>
#elif defined(_WIN32)
# include <windows.h>
#else /* linux/unix/other */
# ifdef USE_GLES1
# include <GLES/gl.h>
# ifdef USE_GLES
# include <GLES3/gl3.h>
# else
# if !defined(GL_GLEXT_PROTOTYPES)
# define GL_GLEXT_PROTOTYPES
# endif
# include <GL/gl.h>
# include <GL/glext.h>
# endif
#endif

8
src/projectM-sdl/pmSDL.cpp
View File

@ -211,9 +211,7 @@ void projectMSDL::renderFrame() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
projectM::renderFrame();
glFlush();
SDL_RenderPresent(rend);
SDL_GL_SwapWindow(win);
}
projectMSDL::projectMSDL(Settings settings, int flags) : projectM(settings, flags) {
@ -230,9 +228,9 @@ projectMSDL::projectMSDL(std::string config_file, int flags) : projectM(config_f
isFullScreen = false;
}
void projectMSDL::init(SDL_Window *window, SDL_Renderer *renderer) {
void projectMSDL::init(SDL_Window *window, SDL_GLContext *_glCtx) {
win = window;
rend = renderer;
glCtx = _glCtx;
selectRandom(true);
projectM_resetGL(width, height);
}

4
src/projectM-sdl/pmSDL.hpp
View File

@ -35,7 +35,7 @@ public:
projectMSDL(Settings settings, int flags);
projectMSDL(std::string config_file, int flags);
void init(SDL_Window *window, SDL_Renderer *renderer);
void init(SDL_Window *window, SDL_GLContext *glCtx);
int openAudioInput();
void beginAudioCapture();
void endAudioCapture();
@ -48,7 +48,7 @@ public:
private:
SDL_Window *win;
SDL_Renderer *rend;
SDL_GLContext *glCtx;
bool isFullScreen;
projectM::Settings settings;
SDL_AudioDeviceID audioInputDevice;

64
src/projectM-sdl/projectM_SDL_main.cpp
View File

@ -8,6 +8,29 @@
#include "pmSDL.hpp"
#define OGL_DEBUG 0
#if OGL_DEBUG
#include <GLES3/gl32.h>
void DebugLog(GLenum source,
GLenum type,
GLuint id,
GLenum severity,
GLsizei length,
const GLchar* message,
const void* userParam) {
/*if (type != GL_DEBUG_TYPE_OTHER)*/
{
std::cerr << " -- \n" << "Type: " <<
type << "; Source: " <<
source <<"; ID: " << id << "; Severity: " <<
severity << "\n" << message << "\n";
}
}
#endif
// return path to config file to use
std::string getConfigFilePath() {
const char *path = DATADIR_PATH;
@ -49,13 +72,35 @@ int main(int argc, char *argv[]) {
#endif
int width = initialWindowBounds.w;
int height = initialWindowBounds.h;
int renderIndex = 0;
SDL_Window *win = SDL_CreateWindow("projectM", 0, 0, width, height, SDL_WINDOW_RESIZABLE);
SDL_Renderer *rend = SDL_CreateRenderer(win, 0, SDL_RENDERER_ACCELERATED);
if (! rend) {
fprintf(stderr, "Failed to create renderer: %s\n", SDL_GetError());
SDL_Quit();
#ifdef USE_GLES
for(int i = 0; i < SDL_GetNumRenderDrivers(); i++) {
SDL_RendererInfo info;
if (SDL_GetRenderDriverInfo(i, &info) == 0) {
if (std::string(info.name) == "opengles2") {
renderIndex = i;
break;
}
}
}
#else
// Disabling compatibility profile
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
#endif
SDL_Window *win = SDL_CreateWindow("projectM", 0, 0, width, height, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
SDL_GLContext glCtx = SDL_GL_CreateContext(win);
SDL_Log("GL_VERSION: %s", glGetString(GL_VERSION));
SDL_Log("GL_SHADING_LANGUAGE_VERSION: %s", glGetString(GL_SHADING_LANGUAGE_VERSION));
SDL_Log("GL_VENDOR: %s", glGetString(GL_VENDOR));
SDL_SetWindowTitle(win, "projectM Visualizer");
projectMSDL *app;
@ -89,7 +134,13 @@ int main(int argc, char *argv[]) {
// init with settings
app = new projectMSDL(settings, 0);
}
app->init(win, rend);
app->init(win, &glCtx);
#if OGL_DEBUG
glEnable(GL_DEBUG_OUTPUT);
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageCallback(DebugLog, NULL);
#endif
// get an audio input device
app->openAudioInput();
@ -107,6 +158,7 @@ int main(int argc, char *argv[]) {
last_time = SDL_GetTicks();
}
SDL_GL_DeleteContext(glCtx);
app->endAudioCapture();
delete app;