(libretro ffmpeg FFT) Start using libretro-common gfx/matrix

functions instead of GLM; GLM only used now still for
packHalf2x16
This commit is contained in:
twinaphex 2017-04-22 12:08:10 +02:00
parent a65675d24f
commit 25f31883d5

View File

@ -14,7 +14,6 @@
#define GLM_SWIZZLE
#define GLM_FORCE_RADIANS
#include <glm/packing.hpp>
#include <glm/gtc/matrix_transform.hpp>
#if GL_DEBUG
#define GL_CHECK_ERROR() do { \
@ -149,88 +148,10 @@ static GLuint fft_compile_program(glfft_t *fft,
return prog;
}
#define USE_GLM
//#define GLM_USE_DEBUG
typedef float stub_matrix4x4[4][4];
static void fft_render(glfft_t *fft, GLuint backbuffer, unsigned width, unsigned height)
{
#ifdef USE_GLM
glm::vec3 eye = glm::vec3(0, 80, -60);
glm::vec3 center = eye + glm::vec3(0.0f, 0.0f, 1.0f);
#ifdef GLM_USE_DEBUG
printf("center : %.2f, %.2f, %.2f\n", center.x, center.y, center.z);
#endif
glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f);
glm::mat4 mvp_persp = glm::perspective((float)M_HALF_PI, (float)width / height,
1.0f, 500.0f);
#ifdef GLM_USE_DEBUG
printf("mvp_persp: \n %.2f, %.2f, %.2f, %.2f \n %.2f, %.2f, %.2f, %.2f \n %.2f, %.2f, %.2f, %.2f \n %.2f, %.2f, %.2f, %.2f \n\n",
mvp_persp[0][0],
mvp_persp[0][1],
mvp_persp[0][2],
mvp_persp[0][3],
mvp_persp[1][0],
mvp_persp[1][1],
mvp_persp[1][2],
mvp_persp[1][3],
mvp_persp[2][0],
mvp_persp[2][1],
mvp_persp[2][2],
mvp_persp[2][3],
mvp_persp[3][0],
mvp_persp[3][1],
mvp_persp[3][2],
mvp_persp[3][3]
);
#endif
glm::mat4 mvp_lookat = glm::lookAt(eye, center, up);
#ifdef GLM_USE_DEBUG
printf("eye %.2f %.2f %.2f\n", eye.x, eye.y, eye.z);
printf("center %.2f %.2f %.2f\n", center.x, center.y, center.z);
printf("up %.2f %.2f %.2f\n", up.x, up.y, up.z);
printf("mvp_lookat: \n %.2f, %.2f, %.2f, %.2f \n %.2f, %.2f, %.2f, %.2f \n %.2f, %.2f, %.2f, %.2f \n %.2f, %.2f, %.2f, %.2f \n\n",
mvp_lookat[0][0],
mvp_lookat[0][1],
mvp_lookat[0][2],
mvp_lookat[0][3],
mvp_lookat[1][0],
mvp_lookat[1][1],
mvp_lookat[1][2],
mvp_lookat[1][3],
mvp_lookat[2][0],
mvp_lookat[2][1],
mvp_lookat[2][2],
mvp_lookat[2][3],
mvp_lookat[3][0],
mvp_lookat[3][1],
mvp_lookat[3][2],
mvp_lookat[3][3]
);
#endif
glm::mat4 mvp = mvp_persp * mvp_lookat;
#ifdef GLM_USE_DEBUG
printf("mvp: \n %.2f, %.2f, %.2f, %.2f \n %.2f, %.2f, %.2f, %.2f \n %.2f, %.2f, %.2f, %.2f \n %.2f, %.2f, %.2f, %.2f \n\n",
mvp[0][0],
mvp[0][1],
mvp[0][2],
mvp[0][3],
mvp[1][0],
mvp[1][1],
mvp[1][2],
mvp[1][3],
mvp[2][0],
mvp[2][1],
mvp[2][2],
mvp[2][3],
mvp[3][0],
mvp[3][1],
mvp[3][2],
mvp[3][3]
);
#endif
#else
vec3_t eye, center, up;
math_matrix_4x4 mvp_lookat, mvp, mvp_persp;
@ -248,77 +169,9 @@ static void fft_render(glfft_t *fft, GLuint backbuffer, unsigned width, unsigned
vec3_add(center, eye);
#ifdef GLM_USE_DEBUG
printf("center : %.2f, %.2f, %.2f\n", center[0], center[1], center[2]);
#endif
matrix_4x4_projection(mvp_persp, (float)M_HALF_PI, (float)width / height, 1.0f, 500.0f);
#ifdef GLM_USE_DEBUG
printf("mvp_persp: \n %.2f, %.2f, %.2f, %.2f \n %.2f, %.2f, %.2f, %.2f \n %.2f, %.2f, %.2f, %.2f \n %.2f, %.2f, %.2f, %.2f \n\n",
MAT_ELEM_4X4(mvp_persp, 0, 0),
MAT_ELEM_4X4(mvp_persp, 0, 1),
MAT_ELEM_4X4(mvp_persp, 0, 2),
MAT_ELEM_4X4(mvp_persp, 0, 3),
MAT_ELEM_4X4(mvp_persp, 1, 0),
MAT_ELEM_4X4(mvp_persp, 1, 1),
MAT_ELEM_4X4(mvp_persp, 1, 2),
MAT_ELEM_4X4(mvp_persp, 1, 3),
MAT_ELEM_4X4(mvp_persp, 2, 0),
MAT_ELEM_4X4(mvp_persp, 2, 1),
MAT_ELEM_4X4(mvp_persp, 2, 2),
MAT_ELEM_4X4(mvp_persp, 2, 3),
MAT_ELEM_4X4(mvp_persp, 3, 0),
MAT_ELEM_4X4(mvp_persp, 3, 1),
MAT_ELEM_4X4(mvp_persp, 3, 2),
MAT_ELEM_4X4(mvp_persp, 3, 3)
);
printf("eye %.2f %.2f %.2f\n", eye[0], eye[1], eye[2]);
printf("center %.2f %.2f %.2f\n", center[0], center[1], center[2]);
printf("up %.2f %.2f %.2f\n", up[0], up[1], up[2]);
#endif
matrix_4x4_lookat(mvp_lookat, eye, center, up);
#ifdef GLM_USE_DEBUG
printf("mvp_lookat: \n %.2f, %.2f, %.2f, %.2f \n %.2f, %.2f, %.2f, %.2f \n %.2f, %.2f, %.2f, %.2f \n %.2f, %.2f, %.2f, %.2f \n\n",
MAT_ELEM_4X4(mvp_lookat, 0, 0),
MAT_ELEM_4X4(mvp_lookat, 0, 1),
MAT_ELEM_4X4(mvp_lookat, 0, 2),
MAT_ELEM_4X4(mvp_lookat, 0, 3),
MAT_ELEM_4X4(mvp_lookat, 1, 0),
MAT_ELEM_4X4(mvp_lookat, 1, 1),
MAT_ELEM_4X4(mvp_lookat, 1, 2),
MAT_ELEM_4X4(mvp_lookat, 1, 3),
MAT_ELEM_4X4(mvp_lookat, 2, 0),
MAT_ELEM_4X4(mvp_lookat, 2, 1),
MAT_ELEM_4X4(mvp_lookat, 2, 2),
MAT_ELEM_4X4(mvp_lookat, 2, 3),
MAT_ELEM_4X4(mvp_lookat, 3, 0),
MAT_ELEM_4X4(mvp_lookat, 3, 1),
MAT_ELEM_4X4(mvp_lookat, 3, 2),
MAT_ELEM_4X4(mvp_lookat, 3, 3)
);
#endif
matrix_4x4_multiply(mvp, mvp_lookat, mvp_persp);
#ifdef GLM_USE_DEBUG
printf("mvp: \n %.2f, %.2f, %.2f, %.2f \n %.2f, %.2f, %.2f, %.2f \n %.2f, %.2f, %.2f, %.2f \n %.2f, %.2f, %.2f, %.2f \n\n",
MAT_ELEM_4X4(mvp, 0, 0),
MAT_ELEM_4X4(mvp, 0, 1),
MAT_ELEM_4X4(mvp, 0, 2),
MAT_ELEM_4X4(mvp, 0, 3),
MAT_ELEM_4X4(mvp, 1, 0),
MAT_ELEM_4X4(mvp, 1, 1),
MAT_ELEM_4X4(mvp, 1, 2),
MAT_ELEM_4X4(mvp, 1, 3),
MAT_ELEM_4X4(mvp, 2, 0),
MAT_ELEM_4X4(mvp, 2, 1),
MAT_ELEM_4X4(mvp, 2, 2),
MAT_ELEM_4X4(mvp, 2, 3),
MAT_ELEM_4X4(mvp, 3, 0),
MAT_ELEM_4X4(mvp, 3, 1),
MAT_ELEM_4X4(mvp, 3, 2),
MAT_ELEM_4X4(mvp, 3, 3)
);
#endif
#endif
/* Render scene. */
glBindFramebuffer(GL_FRAMEBUFFER, fft->ms_fbo ? fft->ms_fbo : backbuffer);
@ -327,13 +180,27 @@ static void fft_render(glfft_t *fft, GLuint backbuffer, unsigned width, unsigned
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
glUseProgram(fft->block.prog);
#ifdef USE_GLM
stub_matrix4x4 mvp_real;
mvp_real[0][0] = MAT_ELEM_4X4(mvp, 0, 0);
mvp_real[0][1] = MAT_ELEM_4X4(mvp, 0, 1);
mvp_real[0][2] = MAT_ELEM_4X4(mvp, 0, 2);
mvp_real[0][3] = MAT_ELEM_4X4(mvp, 0, 3);
mvp_real[1][0] = MAT_ELEM_4X4(mvp, 1, 0);
mvp_real[1][1] = MAT_ELEM_4X4(mvp, 1, 1);
mvp_real[1][2] = MAT_ELEM_4X4(mvp, 1, 2);
mvp_real[1][3] = MAT_ELEM_4X4(mvp, 1, 3);
mvp_real[2][0] = MAT_ELEM_4X4(mvp, 2, 0);
mvp_real[2][1] = MAT_ELEM_4X4(mvp, 2, 1);
mvp_real[2][2] = MAT_ELEM_4X4(mvp, 2, 2);
mvp_real[2][3] = MAT_ELEM_4X4(mvp, 2, 3);
mvp_real[3][0] = MAT_ELEM_4X4(mvp, 3, 0);
mvp_real[3][1] = MAT_ELEM_4X4(mvp, 3, 1);
mvp_real[3][2] = MAT_ELEM_4X4(mvp, 3, 2);
mvp_real[3][3] = MAT_ELEM_4X4(mvp, 3, 3);
glUniformMatrix4fv(glGetUniformLocation(fft->block.prog, "uMVP"),
1, GL_FALSE, (&mvp[0].x));
#else
glUniformMatrix4fv(glGetUniformLocation(fft->block.prog, "uMVP"),
1, GL_FALSE, (&(MAT_ELEM_4X4(mvp, 0, 0))));
#endif
1, GL_FALSE, (&mvp_real[0][0]));
glUniform2i(glGetUniformLocation(fft->block.prog, "uOffset"),
(-int(fft->block_size) + 1) / 2, fft->output_ptr);
glUniform4f(glGetUniformLocation(fft->block.prog, "uHeightmapParams"),