renderer/library/src/opengl/opengl_render_path.cpp

#include "opengl/opengl_render_path.hpp"
#include "opengl/opengl_renderer.hpp"
#include "opengl/opengl.h"

using namespace rive;

OpenGLRenderPath::OpenGLRenderPath() { glGenBuffers(1, &m_ContourBuffer); }

OpenGLRenderPath::~OpenGLRenderPath() { glDeleteBuffers(1, &m_ContourBuffer); }
void OpenGLRenderPath::fillRule(FillRule value) { m_FillRule = value; }

void OpenGLRenderPath::stencil(OpenGLRenderer* renderer, const Mat2D& transform)
{
	if (isContainer())
	{
		for (auto& subPath : m_SubPaths)
		{
			Mat2D subPathTransform;
			Mat2D::multiply(subPathTransform, transform, subPath.transform());
			reinterpret_cast<OpenGLRenderPath*>(subPath.path())
			    ->stencil(renderer, subPathTransform);
		}
		return;
	}

	glUseProgram(renderer->program());
	std::size_t vertexCount;

	if (isDirty())
	{
		computeContour();
		vertexCount = m_ContourVertices.size();
		renderer->updateIndexBuffer(vertexCount);

		glBindBuffer(GL_ARRAY_BUFFER, m_ContourBuffer);
		glBufferData(GL_ARRAY_BUFFER,
		             vertexCount * 2 * sizeof(float),
		             &m_ContourVertices[0][0],
		             GL_DYNAMIC_DRAW);
	}
	else
	{
		glBindBuffer(GL_ARRAY_BUFFER, m_ContourBuffer);
		vertexCount = m_ContourVertices.size();
	}

	if (vertexCount < 2)
	{
		return;
	}

	auto triangleCount = vertexCount - 2;
	// printf("VCOUNT: %i E: %i\n", vertexCount, triangleCount);
	// printf("X: %f %f\n", transform[0], transform[1]);
	// printf("Y: %f %f\n", transform[2], transform[3]);
	// printf("T: %f %f\n", transform[4], transform[5]);

	float m4[16] = {transform[0],
	                transform[1],
	                0.0,
	                0.0,
	                transform[2],
	                transform[3],
	                0.0,
	                0.0,
	                0.0,
	                0.0,
	                1.0,
	                0.0,
	                transform[4],
	                transform[5],
	                0.0,
	                1.0};

	glUniformMatrix4fv(renderer->transformUniformIndex(), 1, GL_FALSE, m4);

	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * 4, (void*)0);

	glDisable(GL_CULL_FACE);
	glDisable(GL_DEPTH_TEST);
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, renderer->indexBuffer());
	glDrawElements(
	    GL_TRIANGLES, triangleCount * 3, GL_UNSIGNED_SHORT, (void*)(0));
	GLenum err;
	while ((err = glGetError()) != GL_NO_ERROR)
	{
		// Process/log the error.
		fprintf(stderr, "ERRR:: %i\n", err);
	}
	// glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
	// static unsigned short indices[3] = {0, 2, 2};
	// glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_SHORT, &indices[0]);
}