314 lines
8.3 KiB
C++
314 lines
8.3 KiB
C++
#include "SimpleMotionRenderer.h"
|
|
|
|
#include "GLExtensions.h"
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <cmath>
|
|
|
|
namespace
|
|
{
|
|
constexpr GLuint kInputTextureUnit = 0;
|
|
|
|
const char* kTextureVertexShader = R"GLSL(
|
|
#version 430 core
|
|
out vec2 vTexCoord;
|
|
void main()
|
|
{
|
|
vec2 positions[3] = vec2[3](
|
|
vec2(-1.0, -1.0),
|
|
vec2( 3.0, -1.0),
|
|
vec2(-1.0, 3.0));
|
|
vec2 texCoords[3] = vec2[3](
|
|
vec2(0.0, 0.0),
|
|
vec2(2.0, 0.0),
|
|
vec2(0.0, 2.0));
|
|
gl_Position = vec4(positions[gl_VertexID], 0.0, 1.0);
|
|
vTexCoord = texCoords[gl_VertexID];
|
|
}
|
|
)GLSL";
|
|
|
|
const char* kTextureFragmentShader = R"GLSL(
|
|
#version 430 core
|
|
layout(binding = 0) uniform sampler2D uInputTexture;
|
|
in vec2 vTexCoord;
|
|
out vec4 fragColor;
|
|
void main()
|
|
{
|
|
fragColor = texture(uInputTexture, clamp(vTexCoord, vec2(0.0), vec2(1.0)));
|
|
}
|
|
)GLSL";
|
|
|
|
const char* kPatternFragmentShader = R"GLSL(
|
|
#version 430 core
|
|
uniform vec2 uResolution;
|
|
uniform float uFrameIndex;
|
|
in vec2 vTexCoord;
|
|
out vec4 fragColor;
|
|
|
|
vec3 hexColor(float r, float g, float b)
|
|
{
|
|
return vec3(r, g, b) / 255.0;
|
|
}
|
|
|
|
vec3 smpteTop(float x)
|
|
{
|
|
if (x < 240.0) return hexColor(102.0, 102.0, 102.0);
|
|
if (x < 445.0) return hexColor(191.0, 191.0, 191.0);
|
|
if (x < 651.0) return hexColor(191.0, 191.0, 0.0);
|
|
if (x < 857.0) return hexColor(0.0, 191.0, 191.0);
|
|
if (x < 1063.0) return hexColor(0.0, 191.0, 0.0);
|
|
if (x < 1269.0) return hexColor(191.0, 0.0, 191.0);
|
|
if (x < 1475.0) return hexColor(191.0, 0.0, 0.0);
|
|
if (x < 1680.0) return hexColor(0.0, 0.0, 191.0);
|
|
return hexColor(102.0, 102.0, 102.0);
|
|
}
|
|
|
|
vec3 smpteMiddleA(float x)
|
|
{
|
|
if (x < 240.0) return hexColor(0.0, 255.0, 255.0);
|
|
if (x < 445.0) return hexColor(0.0, 63.0, 105.0);
|
|
if (x < 1680.0) return hexColor(191.0, 191.0, 191.0);
|
|
return hexColor(0.0, 0.0, 255.0);
|
|
}
|
|
|
|
vec3 smpteMiddleB(float x)
|
|
{
|
|
if (x < 240.0) return hexColor(255.0, 255.0, 0.0);
|
|
if (x < 445.0) return hexColor(65.0, 0.0, 119.0);
|
|
if (x < 1475.0)
|
|
{
|
|
float ramp = clamp((x - 445.0) / (1475.0 - 445.0), 0.0, 1.0);
|
|
return vec3(ramp);
|
|
}
|
|
if (x < 1680.0) return vec3(1.0);
|
|
return hexColor(255.0, 0.0, 0.0);
|
|
}
|
|
|
|
vec3 smpteBottom(float x)
|
|
{
|
|
if (x < 240.0) return hexColor(38.0, 38.0, 38.0);
|
|
if (x < 549.0) return vec3(0.0);
|
|
if (x < 960.0) return vec3(1.0);
|
|
if (x < 1268.0) return vec3(0.0);
|
|
if (x < 1337.0) return hexColor(5.0, 5.0, 5.0);
|
|
if (x < 1405.0) return vec3(0.0);
|
|
if (x < 1474.0) return hexColor(10.0, 10.0, 10.0);
|
|
if (x < 1680.0) return vec3(0.0);
|
|
return hexColor(38.0, 38.0, 38.0);
|
|
}
|
|
|
|
vec3 smpteColor(vec2 uv)
|
|
{
|
|
vec2 pixel = vec2(clamp(uv.x, 0.0, 1.0), 1.0 - clamp(uv.y, 0.0, 1.0)) * vec2(1920.0, 1080.0);
|
|
if (pixel.y < 630.0) return smpteTop(pixel.x);
|
|
if (pixel.y < 720.0) return smpteMiddleA(pixel.x);
|
|
if (pixel.y < 810.0) return smpteMiddleB(pixel.x);
|
|
return smpteBottom(pixel.x);
|
|
}
|
|
|
|
void main()
|
|
{
|
|
vec2 uv = clamp(vTexCoord, vec2(0.0), vec2(1.0));
|
|
vec3 color = smpteColor(uv);
|
|
|
|
float t = uFrameIndex / 60.0;
|
|
vec2 cubeSize = vec2(0.16, 0.20);
|
|
vec2 cubeMin = vec2(
|
|
(0.5 + 0.5 * sin(t * 1.7)) * (1.0 - cubeSize.x),
|
|
(0.5 + 0.5 * sin(t * 1.1 + 0.8)) * (1.0 - cubeSize.y));
|
|
vec2 cubeMax = cubeMin + cubeSize;
|
|
bool insideCube = uv.x >= cubeMin.x && uv.x <= cubeMax.x && uv.y >= cubeMin.y && uv.y <= cubeMax.y;
|
|
if (insideCube)
|
|
{
|
|
vec2 local = (uv - cubeMin) / cubeSize;
|
|
vec3 cubeColor = vec3(1.0, 0.74 + 0.18 * sin(t * 2.1), 0.08);
|
|
float edge = step(local.x, 0.04) + step(local.y, 0.04) + step(0.96, local.x) + step(0.96, local.y);
|
|
color = edge > 0.0 ? vec3(1.0) : cubeColor;
|
|
}
|
|
|
|
fragColor = vec4(color, 1.0);
|
|
}
|
|
)GLSL";
|
|
}
|
|
|
|
bool SimpleMotionRenderer::InitializeGl(unsigned width, unsigned height)
|
|
{
|
|
mWidth = width;
|
|
mHeight = height;
|
|
return mWidth > 0 && mHeight > 0;
|
|
}
|
|
|
|
void SimpleMotionRenderer::RenderFrame(uint64_t frameIndex)
|
|
{
|
|
if (!EnsurePatternProgram())
|
|
{
|
|
glViewport(0, 0, static_cast<GLsizei>(mWidth), static_cast<GLsizei>(mHeight));
|
|
glDisable(GL_SCISSOR_TEST);
|
|
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
return;
|
|
}
|
|
|
|
glViewport(0, 0, static_cast<GLsizei>(mWidth), static_cast<GLsizei>(mHeight));
|
|
glDisable(GL_SCISSOR_TEST);
|
|
glDisable(GL_DEPTH_TEST);
|
|
glDisable(GL_BLEND);
|
|
glUseProgram(mPatternProgram);
|
|
const GLint resolutionLocation = glGetUniformLocation(mPatternProgram, "uResolution");
|
|
if (resolutionLocation >= 0)
|
|
glUniform2f(resolutionLocation, static_cast<float>(mWidth), static_cast<float>(mHeight));
|
|
const GLint frameIndexLocation = glGetUniformLocation(mPatternProgram, "uFrameIndex");
|
|
if (frameIndexLocation >= 0)
|
|
glUniform1f(frameIndexLocation, static_cast<float>(frameIndex));
|
|
glBindVertexArray(mPatternVertexArray);
|
|
glDrawArrays(GL_TRIANGLES, 0, 3);
|
|
glBindVertexArray(0);
|
|
glUseProgram(0);
|
|
}
|
|
|
|
void SimpleMotionRenderer::RenderTexture(GLuint texture)
|
|
{
|
|
if (texture == 0 || !EnsureTextureProgram())
|
|
{
|
|
RenderFrame(0);
|
|
return;
|
|
}
|
|
|
|
glViewport(0, 0, static_cast<GLsizei>(mWidth), static_cast<GLsizei>(mHeight));
|
|
glDisable(GL_SCISSOR_TEST);
|
|
glDisable(GL_DEPTH_TEST);
|
|
glDisable(GL_BLEND);
|
|
glActiveTexture(GL_TEXTURE0 + kInputTextureUnit);
|
|
glBindTexture(GL_TEXTURE_2D, texture);
|
|
glUseProgram(mTextureProgram);
|
|
glBindVertexArray(mTextureVertexArray);
|
|
glDrawArrays(GL_TRIANGLES, 0, 3);
|
|
glBindVertexArray(0);
|
|
glUseProgram(0);
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
glActiveTexture(GL_TEXTURE0);
|
|
}
|
|
|
|
void SimpleMotionRenderer::ShutdownGl()
|
|
{
|
|
DestroyPatternProgram();
|
|
DestroyTextureProgram();
|
|
mWidth = 0;
|
|
mHeight = 0;
|
|
}
|
|
|
|
bool SimpleMotionRenderer::EnsurePatternProgram()
|
|
{
|
|
if (mPatternProgram != 0)
|
|
return true;
|
|
|
|
if (!CompileShader(GL_VERTEX_SHADER, kTextureVertexShader, mPatternVertexShader))
|
|
return false;
|
|
if (!CompileShader(GL_FRAGMENT_SHADER, kPatternFragmentShader, mPatternFragmentShader))
|
|
{
|
|
DestroyPatternProgram();
|
|
return false;
|
|
}
|
|
|
|
mPatternProgram = glCreateProgram();
|
|
glAttachShader(mPatternProgram, mPatternVertexShader);
|
|
glAttachShader(mPatternProgram, mPatternFragmentShader);
|
|
glLinkProgram(mPatternProgram);
|
|
|
|
GLint linkResult = GL_FALSE;
|
|
glGetProgramiv(mPatternProgram, GL_LINK_STATUS, &linkResult);
|
|
if (linkResult == GL_FALSE)
|
|
{
|
|
DestroyPatternProgram();
|
|
return false;
|
|
}
|
|
|
|
glGenVertexArrays(1, &mPatternVertexArray);
|
|
return mPatternVertexArray != 0;
|
|
}
|
|
|
|
bool SimpleMotionRenderer::EnsureTextureProgram()
|
|
{
|
|
if (mTextureProgram != 0)
|
|
return true;
|
|
|
|
if (!CompileShader(GL_VERTEX_SHADER, kTextureVertexShader, mTextureVertexShader))
|
|
return false;
|
|
if (!CompileShader(GL_FRAGMENT_SHADER, kTextureFragmentShader, mTextureFragmentShader))
|
|
{
|
|
DestroyTextureProgram();
|
|
return false;
|
|
}
|
|
|
|
mTextureProgram = glCreateProgram();
|
|
glAttachShader(mTextureProgram, mTextureVertexShader);
|
|
glAttachShader(mTextureProgram, mTextureFragmentShader);
|
|
glLinkProgram(mTextureProgram);
|
|
|
|
GLint linkResult = GL_FALSE;
|
|
glGetProgramiv(mTextureProgram, GL_LINK_STATUS, &linkResult);
|
|
if (linkResult == GL_FALSE)
|
|
{
|
|
DestroyTextureProgram();
|
|
return false;
|
|
}
|
|
|
|
glUseProgram(mTextureProgram);
|
|
const GLint inputLocation = glGetUniformLocation(mTextureProgram, "uInputTexture");
|
|
if (inputLocation >= 0)
|
|
glUniform1i(inputLocation, static_cast<GLint>(kInputTextureUnit));
|
|
glUseProgram(0);
|
|
|
|
glGenVertexArrays(1, &mTextureVertexArray);
|
|
return mTextureVertexArray != 0;
|
|
}
|
|
|
|
void SimpleMotionRenderer::DestroyTextureProgram()
|
|
{
|
|
if (mTextureProgram != 0)
|
|
glDeleteProgram(mTextureProgram);
|
|
if (mTextureVertexShader != 0)
|
|
glDeleteShader(mTextureVertexShader);
|
|
if (mTextureFragmentShader != 0)
|
|
glDeleteShader(mTextureFragmentShader);
|
|
if (mTextureVertexArray != 0)
|
|
glDeleteVertexArrays(1, &mTextureVertexArray);
|
|
mTextureProgram = 0;
|
|
mTextureVertexShader = 0;
|
|
mTextureFragmentShader = 0;
|
|
mTextureVertexArray = 0;
|
|
}
|
|
|
|
void SimpleMotionRenderer::DestroyPatternProgram()
|
|
{
|
|
if (mPatternProgram != 0)
|
|
glDeleteProgram(mPatternProgram);
|
|
if (mPatternVertexShader != 0)
|
|
glDeleteShader(mPatternVertexShader);
|
|
if (mPatternFragmentShader != 0)
|
|
glDeleteShader(mPatternFragmentShader);
|
|
if (mPatternVertexArray != 0)
|
|
glDeleteVertexArrays(1, &mPatternVertexArray);
|
|
mPatternProgram = 0;
|
|
mPatternVertexShader = 0;
|
|
mPatternFragmentShader = 0;
|
|
mPatternVertexArray = 0;
|
|
}
|
|
|
|
bool SimpleMotionRenderer::CompileShader(GLenum shaderType, const char* source, GLuint& shader)
|
|
{
|
|
shader = glCreateShader(shaderType);
|
|
glShaderSource(shader, 1, &source, nullptr);
|
|
glCompileShader(shader);
|
|
|
|
GLint compileResult = GL_FALSE;
|
|
glGetShaderiv(shader, GL_COMPILE_STATUS, &compileResult);
|
|
if (compileResult != GL_FALSE)
|
|
return true;
|
|
|
|
glDeleteShader(shader);
|
|
shader = 0;
|
|
return false;
|
|
}
|