omar/panopainter
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

implement instanced drawing

Browse Source
This commit is contained in:
omigamedev
2017-03-27 22:29:47 +01:00
parent b9277f94e8
commit e8cabebe66
8 changed files with 206 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

150
engine/brush.h
View File

@@ -1,5 +1,6 @@
#pragma once
#include "rtt.h"
#include "shader.h"
NS_START
@@ -20,16 +21,141 @@ public:
float m_jitter_flow;
};
struct StrokeSample
{
glm::vec2 pos;
float size;
float flow;
float angle;
};
class BrushMesh
{
public:
ui::Shader shader;
GLuint buffers[3]{ 0 };
struct vertex_t { glm::vec4 pos; glm::vec2 uvs; };
struct instance_t { glm::mat4 mvp; float flow; };
int loc_flow;
int loc_mvp;
bool create()
{
static GLushort idx[6] { 0, 1, 2, 0, 2, 3 };
static vertex_t vertices[4]{
{ { -.5f, -.5f, 0, 1 }, { 0, 0 } }, // A B----C
{ { -.5f, .5f, 0, 1 }, { 0, 1 } }, // B --\ | |
{ { .5f, .5f, 0, 1 }, { 1, 1 } }, // C --/ | |
{ { .5f, -.5f, 0, 1 }, { 1, 0 } }, // D A----D
};
glGenBuffers(3, buffers);
if (!buffers)
return false;
static instance_t inst{ glm::mat4(), .1f };
glBindBuffer(GL_ARRAY_BUFFER, buffers[2]);
glBufferData(GL_ARRAY_BUFFER, sizeof(instance_t), &inst, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[1]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(idx), idx, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, buffers[0]);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
// STROKE - INSTANCED
static const char* shader_stroke_inst_v =
SHADER_VERSION
"in vec4 pos;"
"in vec2 uvs;"
"in mat4 a_mvp;"
"in float a_flow;"
"out vec3 uv;"
"out float alpha;"
"void main(){"
" uv = vec3(uvs, pos.w);"
" alpha = a_flow;"
" gl_Position = a_mvp * vec4(pos.xyz, 1.0);"
"}";
static const char* shader_stroke_inst_f =
SHADER_VERSION
"uniform sampler2D tex;"
"uniform vec4 col;"
"in float alpha;"
"in vec3 uv;"
"out vec4 frag;"
"void main(){"
" float a = (1.0 - texture(tex, uv.xy).r) * alpha;"
" frag = vec4(col.rgb, a);"
"}";
if (!shader.create(shader_stroke_inst_v, shader_stroke_inst_f))
LOG("Failed to create shader Texture");
loc_flow = shader.GetAttribLocation("a_flow");
loc_mvp = shader.GetAttribLocation("a_mvp");
return true;
}
void draw(const std::vector<StrokeSample>& samples, const glm::mat4& proj)
{
std::vector<instance_t> attributes;
attributes.reserve(samples.size());
for (const auto& s : samples)
{
auto mvp = proj *
glm::translate(glm::vec3(s.pos, 0)) *
glm::scale(glm::vec3(s.size, s.size, 1)) *
glm::eulerAngleZ(s.angle);
attributes.emplace_back(instance_t{ mvp, s.flow });
}
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[1]);
glBindBuffer(GL_ARRAY_BUFFER, buffers[0]);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(vertex_t), (GLvoid*)offsetof(vertex_t, pos));
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(vertex_t), (GLvoid*)offsetof(vertex_t, uvs));
// Likewise, we can do the same with the model matrix. Note that a
// matrix input to the vertex shader consumes N consecutive input
// locations, where N is the number of columns in the matrix. So...
// we have four vertex attributes to set up.
glBindBuffer(GL_ARRAY_BUFFER, buffers[2]);
glBufferData(GL_ARRAY_BUFFER, (int)(sizeof(instance_t) * attributes.size()), attributes.data(), GL_STATIC_DRAW);
// Loop over each column of the matrix...
for (int i = 0; i < 4; i++)
{
// Set up the vertex attribute
glVertexAttribPointer(loc_mvp + i, 4, GL_FLOAT, GL_FALSE, sizeof(instance_t),
(GLvoid*)(offsetof(instance_t, mvp) + sizeof(glm::vec4) * i));
// Enable it
glEnableVertexAttribArray(loc_mvp + i);
// Make it instanced
glVertexAttribDivisor(loc_mvp + i, 1);
}
glEnableVertexAttribArray(loc_flow);
glVertexAttribPointer(loc_flow, 1, GL_FLOAT, GL_FALSE, sizeof(instance_t),
(GLvoid*)offsetof(instance_t, flow));
glVertexAttribDivisor(loc_flow, 1);
glDrawElementsInstanced(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0, (int)samples.size());
//glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
for (int i = 0; i < 4; i++)
glDisableVertexAttribArray(loc_mvp + i);
glDisableVertexAttribArray(loc_flow);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}
};
class Stroke
{
public:
struct Sample
{
glm::vec2 pos;
float size;
float flow;
float angle;
};
struct Keypoint
{
glm::vec2 pos;
@@ -41,7 +167,7 @@ public:
float m_step;
ui::Brush m_brush;
std::vector<Keypoint> m_keypoints;
std::vector<Sample> m_samples;
std::vector<StrokeSample> m_samples;
int m_last_kp;
std::minstd_rand prng;
void start(glm::vec2 pos, float pressure, const ui::Brush& brush)
@@ -66,10 +192,10 @@ public:
return m_keypoints.empty() ? false : // no keypoints
(m_keypoints.back().dist > (m_dist + m_step)); // check if next kp is closer than spacing
}
std::vector<Sample> compute_samples()
std::vector<StrokeSample> compute_samples()
{
int nsamples = (int)glm::floor((m_keypoints.back().dist - m_dist) / m_step);
std::vector<Sample> samples;
std::vector<StrokeSample> samples;
samples.reserve(nsamples); // preallocate the estimate number of samples
while (m_keypoints.back().dist > (m_dist + m_step))
{
@@ -86,14 +212,14 @@ public:
}
return std::move(samples);
}
Sample randomize_sample(const glm::vec2& pos, float pressure)
StrokeSample randomize_sample(const glm::vec2& pos, float pressure)
{
auto rnd_nor = [&] { return float((double)prng() / (double)prng.max()); }; // normalized [0, +1]
auto rnd_neg = [&] { return float((double)prng() / (double)prng.max() * 2.0 - 1.0); }; // normalized [-1, +1]
auto rnd_rad = [&] { return float((double)prng() / (double)prng.max() * M_PI * 2.0); }; // normalized [0, 2pi]
auto rnd_vec = [&] { float rad = rnd_rad(); return glm::vec2(cosf(rad), sinf(rad)); }; // normalized direction vector
Sample s;
StrokeSample s;
s.angle = (m_brush.m_tip_angle + rnd_nor() * m_brush.m_jitter_angle) * (float)(M_PI * 2.0);
s.pos = pos + (rnd_vec() * m_brush.m_jitter_spread * 100.f);
s.size = 100.f * m_brush.m_tip_size * (1.f - rnd_nor() * m_brush.m_jitter_scale);