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

fix brush projection to eliminate seams, still problems with big brushes and need to implement erase

Browse Source
This commit is contained in:
omigamedev
2017-08-13 16:59:58 +01:00
parent 060e08a891
commit 90ee185dcd
7 changed files with 123 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
engine/app_shaders.cpp
View File

@@ -205,9 +205,11 @@ void App::initShaders()
"in vec4 pos;\n"
"in vec2 uvs;\n"
"out vec2 uv;\n"
"out float q;\n"
"void main(){\n"
" uv = uvs;\n"
" gl_Position = mvp * vec4(pos.xyz, 1.0);\n"
" q = pos.z;\n"
" gl_Position = mvp * vec4(pos.xy, 0.0, 1.0);\n"
"}\n";
static const char* shader_stroke_f =
SHADER_VERSION
@@ -220,6 +222,7 @@ void App::initShaders()
"uniform mediump vec2 resolution;\n"
"uniform mediump float alpha;\n"
"in mediump vec2 uv;\n"
"in mediump float q;\n"
#ifdef __IOS__
"inout mediump vec4 frag;\n"
#else
@@ -227,7 +230,7 @@ void App::initShaders()
#endif
"void main(){\n"
" mediump vec2 uv2 = gl_FragCoord.st / resolution;\n"
" mediump float brush_alpha = ( 1.0 - texture(tex, uv).r ) * alpha;\n"
" mediump float brush_alpha = ( 1.0 - texture(tex, uv/q).r ) * alpha;\n"
" mediump vec4 fg = vec4(col.rgb, brush_alpha);\n"
#ifdef __IOS__
" mediump vec4 bg = frag;\n"

105
engine/canvas.cpp
View File

@@ -213,9 +213,17 @@ void ui::Canvas::stroke_draw()
m_sampler.bind(0);
m_sampler_bg.bind(1);
m_sampler_mask.bind(2);
for (int i = 0; i < 6; i++)
{
// check if plane is even visible
glm::vec4 forward = m_mv * glm::vec4(0, 0, 1, 1);
float dot = glm::dot(forward.xyz(), m_plane_normal[i]);
// TODO: use better threshold than 0.3
// some trigonometric shit, tangent and stuff
// if (dot < -0.3f)
// continue;
m_tmp[i].bindFramebuffer();
glActiveTexture(GL_TEXTURE1);
@@ -232,82 +240,59 @@ void ui::Canvas::stroke_draw()
else
{
glDisable(GL_BLEND);
// if (0 && m_state == kCanvasMode::Erase)
// {
// ShaderManager::use(ui::kShader::StrokeErase);
// //ShaderManager::u_vec4(kShaderUniform::Col, m_brush.m_tip_color);
// }
// else if(m_layers[m_current_layer_idx].m_alpha_locked)
// {
// ShaderManager::use(kShader::StrokeLock);
// ShaderManager::u_vec4(kShaderUniform::Col, m_brush.m_tip_color);
// ShaderManager::u_int(kShaderUniform::TexMask, 2); // alpha mask
// glActiveTexture(GL_TEXTURE2);
// m_layers[m_current_layer_idx].m_rtt[i].bindTexture();
// glActiveTexture(GL_TEXTURE1);
// }
// else
{
ShaderManager::use(ui::kShader::Stroke);
ShaderManager::u_vec4(kShaderUniform::Col, m_brush.m_tip_color);
}
ShaderManager::use(ui::kShader::Stroke);
ShaderManager::u_int(kShaderUniform::Tex, 0); // brush
ShaderManager::u_int(kShaderUniform::TexBG, 1); // bg
ShaderManager::u_vec4(kShaderUniform::Col, m_brush.m_tip_color);
ShaderManager::u_vec2(kShaderUniform::Resolution, { m_width, m_height });
for (const auto& s : samples)
{
glm::vec3 ray_origin, ray_dir;
point_unproject(s.pos, { 0, 0, m_box.zw }, m_mv, m_proj, ray_origin, ray_dir);
glm::vec3 hit;
glm::vec2 fb_pos;
if (ray_intersect(ray_origin, ray_dir, m_plane_origin[i], m_plane_normal[i], m_plane_tangent[i], hit))
glm::vec2 dx(s.size, 0), dy(0, s.size);
glm::vec2 off[4] = {
- dx - dy, // A - bottom-left
- dx + dy, // B - top-left
+ dx + dy, // C - top-right
+ dx - dy, // D - bottom-right
};
static glm::vec4 P[4];
int intersected = 0;
int inside = 0;
for (int j = 0; j < 4; j++)
{
glm::mat4 plane_camera = glm::lookAt(m_plane_origin[i], m_plane_normal[i], m_plane_tangent[i]);
glm::vec4 plane_local = plane_camera * glm::vec4(hit, 1);
if (glm::abs(plane_local.x) < 1.5f && glm::abs(plane_local.y) < 1.5f)
glm::vec3 ray_origin, ray_dir;
point_unproject(s.pos + off[j], { 0, 0, m_box.zw }, m_mv, m_proj, ray_origin, ray_dir);
glm::vec3 hit;
if (ray_intersect(ray_origin, ray_dir, m_plane_origin[i], m_plane_normal[i], m_plane_tangent[i], hit))
{
fb_pos.x = -(plane_local.x * 0.5f - 0.5f) * m_width;
fb_pos.y = (plane_local.y * 0.5f + 0.5f) * m_height;
//LOG("draw %f %f", fb_pos.x, fb_pos.y);
glm::mat4 plane_camera = glm::lookAt(m_plane_origin[i], m_plane_normal[i], m_plane_tangent[i]);
glm::vec4 plane_local = plane_camera * glm::vec4(hit, 1);
if (glm::abs(plane_local.x) < 1.5f && glm::abs(plane_local.y) < 1.5f)
{
inside++;
}
P[j].x = -(plane_local.x * 0.5f - 0.5f) * m_width;
P[j].y = (plane_local.y * 0.5f + 0.5f) * m_height;
intersected++;
}
else
{
continue;
// if (i==0)
// LOG("no intersection with plane %d", i);
break;
}
}
else
{
if (intersected < 4 || inside == 0)
continue;
}
m_dirty_face[i] = true;
auto mvp = ortho_proj *
glm::translate(glm::vec3(fb_pos, 0)) *
glm::scale(glm::vec3(s.size, s.size, 1)) *
glm::eulerAngleZ(s.angle);
glm::vec4 P[4] {
mvp * glm::vec4(glm::vec2(-.5f, -.5f), 0, 1.f), // A - bottom-left
mvp * glm::vec4(glm::vec2(-.5f, +.5f), 0, 1.f), // B - top-left
mvp * glm::vec4(glm::vec2(+.5f, +.5f), 0, 1.f), // C - top-right
mvp * glm::vec4(glm::vec2(+.5f, -.5f), 0, 1.f), // D - bottom-right
};
auto mvp_inv = glm::inverse(ortho_proj);
glm::vec4 P2[4]{
mvp_inv * P[0],
mvp_inv * P[1],
mvp_inv * P[2],
mvp_inv * P[3],
};
glm::vec2 bb_min(m_width, m_height);
glm::vec2 bb_max(0, 0);
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++)
{
bb_min = glm::max({ 0, 0 }, glm::min(bb_min, P2[i].xy()));
bb_max = glm::min({ m_width, m_height }, glm::max(bb_max, P2[i].xy()));
bb_min = glm::max({ 0, 0 }, glm::min(bb_min, P[j].xy()));
bb_max = glm::min({ m_width, m_height }, glm::max(bb_max, P[j].xy()));
}
auto bb_sz = bb_max - bb_min;
@@ -324,9 +309,9 @@ void ui::Canvas::stroke_draw()
m_dirty_box[i].xy = glm::min(m_dirty_box[i].xy(), (glm::vec2)tex_pos);
m_dirty_box[i].zw = glm::max(m_dirty_box[i].zw(), (glm::vec2)(tex_pos + tex_sz));
ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
ShaderManager::u_mat4(kShaderUniform::MVP, ortho_proj);
ShaderManager::u_float(kShaderUniform::Alpha, s.flow);
//m_plane_brush.update_vertices(P);
m_plane_brush.update_vertices(P);
m_plane_brush.draw_fill();
}
}

24
engine/node.cpp
View File

@@ -478,30 +478,6 @@ glm::vec2 Node::GetSize()
return{ GetWidth(), GetHeight() };
}
glm::vec4 Node::rect_intersection(glm::vec4 a, glm::vec4 b) const
{
// convert from [x,y,w,h] to [x1,y1,x2,y1]
a = glm::vec4(a.xy(), a.xy() + a.zw());
b = glm::vec4(b.xy(), b.xy() + b.zw());
// compute intersection
auto o = glm::vec4(glm::max(a.xy(), b.xy()), glm::min(a.zw(), b.zw()));
// back to rect form
o = glm::vec4(o.xy(), glm::max({ 0, 0 }, o.zw() - o.xy()));
return o;
}
glm::vec4 Node::rect_union(glm::vec4 a, glm::vec4 b) const
{
// convert from rect [x,y,w,h] to bb [x1,y1,x2,y1]
a = glm::vec4(a.xy(), a.xy() + a.zw());
b = glm::vec4(b.xy(), b.xy() + b.zw());
// compute union
glm::vec4 o = { glm::min(a.xy(), b.xy()), glm::max(a.zw(), b.zw()) };
// back to rect form
o = glm::vec4(o.xy(), glm::max({ 0, 0 }, o.zw() - o.xy()));
return o;
}
void Node::restore_context()
{
for (auto& c : m_children)

3
engine/node.h
View File

@@ -138,9 +138,6 @@ public:
float GetHeight();
glm::vec2 GetSize();
glm::vec4 rect_intersection(glm::vec4 a, glm::vec4 b) const;
glm::vec4 rect_union(glm::vec4 a, glm::vec4 b) const;
virtual void restore_context();;
virtual void clear_context();
void update(float width, float height, float zoom);

17
engine/shape.cpp
View File

@@ -212,10 +212,25 @@ void Plane::create_impl(float w, float h, int div, GLushort *idx, Shape::vertex_
void ui::Plane::update_vertices(const glm::vec4* data)
{
static vertex_t vertices[4];
glm::vec2 mid;
segments_intersect(data[0].xy, data[2].xy, data[1].xy, data[3].xy, mid);
static float d[4];
for (int i = 0; i < 4; i++)
d[i] = glm::distance(data[i].xy(), mid);
vertices[0] = { data[0],{ 0, 0 } }; // A
vertices[1] = { data[1],{ 0, 1 } }; // B
vertices[2] = { data[2],{ 1, 1 } }; // C
vertices[3] = { data[3],{ 1, 0 } }; // D
for (int i = 0; i < 4; i++)
{
float q = (d[i] + d[(i + 2) % 4]) / d[(i + 2) % 4];
vertices[i].uvs *= q;
vertices[i].pos.z = q;
}
glBindBuffer(GL_ARRAY_BUFFER, buffers[0]);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
static GLushort idx[6 + 8]{
@@ -457,4 +472,4 @@ void ui::DynamicShape::update_vertices(vertex_t* vertices, int vcount)
glBindBuffer(GL_ARRAY_BUFFER, buffers[0]);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_t) * vcount, vertices, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
}

53
engine/util.cpp
View File

@@ -7,6 +7,59 @@ bool point_in_rect(const glm::vec2& p, const glm::vec4& r)
return p.x > r.x && p.x < r.x+r.z && p.y > r.y && p.y < r.y+r.w;
}
// params and returns {origin, size} form
glm::vec4 rect_intersection(glm::vec4 a, glm::vec4 b)
{
// convert from [x,y,w,h] to [x1,y1,x2,y1]
a = glm::vec4(a.xy(), a.xy() + a.zw());
b = glm::vec4(b.xy(), b.xy() + b.zw());
// compute intersection
auto o = glm::vec4(glm::max(a.xy(), b.xy()), glm::min(a.zw(), b.zw()));
// back to rect form
o = glm::vec4(o.xy(), glm::max({ 0, 0 }, o.zw() - o.xy()));
return o;
}
// params and returns {origin, size} form
glm::vec4 rect_union(glm::vec4 a, glm::vec4 b)
{
// convert from rect [x,y,w,h] to bb [x1,y1,x2,y1]
a = glm::vec4(a.xy(), a.xy() + a.zw());
b = glm::vec4(b.xy(), b.xy() + b.zw());
// compute union
glm::vec4 o = { glm::min(a.xy(), b.xy()), glm::max(a.zw(), b.zw()) };
// back to rect form
o = glm::vec4(o.xy(), glm::max({ 0, 0 }, o.zw() - o.xy()));
return o;
}
// see: https://stackoverflow.com/questions/563198/how-do-you-detect-where-two-line-segments-intersect
bool segments_intersect(const glm::vec2& p0a, const glm::vec2& p0b,
const glm::vec2& p1a, const glm::vec2& p1b, glm::vec2& out_pt)
{
auto cross2d = [](const glm::vec2& v, const glm::vec2& w)
{ return (v.x * w.y) - (v.y * w.x); };
auto p = p0a;
auto r = p0b - p0a;
auto q = p1a;
auto s = p1b - p1a;
float den = cross2d(r, s);
if (den == 0.f)
{
glm::vec4 is = rect_intersection({p, r}, {q, s});
out_pt = is.xy + is.zw * 0.5f;
return glm::all(glm::greaterThan(is.zw(), glm::vec2(0, 0)));
}
float t = cross2d(q - p, s) / den;
float u = cross2d(q - p, r) / den;
if (t >= 0 && t <= 1 && u >= 0 && u <= 1)
{
out_pt = p + t * r;
return true;
}
return false;
}
glm::vec4 rand_color()
{
float r = (rand() % 256) / 256.f;

4
engine/util.h
View File

@@ -8,6 +8,10 @@ uint16_t constexpr const_hash(const char* input)
}
bool point_in_rect(const glm::vec2& point, const glm::vec4& rect);
glm::vec4 rect_intersection(glm::vec4 a, glm::vec4 b);
glm::vec4 rect_union(glm::vec4 a, glm::vec4 b);
bool segments_intersect(const glm::vec2& p0a, const glm::vec2& p0b,
const glm::vec2& p1a, const glm::vec2& p1b, glm::vec2& out_pt);
glm::vec4 rand_color();
glm::vec3 convert_hsv2rgb(const glm::vec3 c);
glm::vec3 convert_rgb2hsv(const glm::vec3 c);