Copy as Markdown
Other Tools
struct cs_border_solid_common {
struct Samplers {
bool set_slot(int index, int value) {
switch (index) {
}
return false;
}
} samplers;
struct AttribLocations {
int aPosition = NULL_ATTRIB;
int aTaskOrigin = NULL_ATTRIB;
int aRect = NULL_ATTRIB;
int aColor0 = NULL_ATTRIB;
int aColor1 = NULL_ATTRIB;
int aFlags = NULL_ATTRIB;
int aWidths = NULL_ATTRIB;
int aRadii = NULL_ATTRIB;
int aClipParams1 = NULL_ATTRIB;
int aClipParams2 = NULL_ATTRIB;
void bind_loc(const char* name, int index) {
if (strcmp("aPosition", name) == 0) { aPosition = index; return; }
if (strcmp("aTaskOrigin", name) == 0) { aTaskOrigin = index; return; }
if (strcmp("aRect", name) == 0) { aRect = index; return; }
if (strcmp("aColor0", name) == 0) { aColor0 = index; return; }
if (strcmp("aColor1", name) == 0) { aColor1 = index; return; }
if (strcmp("aFlags", name) == 0) { aFlags = index; return; }
if (strcmp("aWidths", name) == 0) { aWidths = index; return; }
if (strcmp("aRadii", name) == 0) { aRadii = index; return; }
if (strcmp("aClipParams1", name) == 0) { aClipParams1 = index; return; }
if (strcmp("aClipParams2", name) == 0) { aClipParams2 = index; return; }
}
int get_loc(const char* name) const {
if (strcmp("aPosition", name) == 0) { return aPosition != NULL_ATTRIB ? aPosition : -1; }
if (strcmp("aTaskOrigin", name) == 0) { return aTaskOrigin != NULL_ATTRIB ? aTaskOrigin : -1; }
if (strcmp("aRect", name) == 0) { return aRect != NULL_ATTRIB ? aRect : -1; }
if (strcmp("aColor0", name) == 0) { return aColor0 != NULL_ATTRIB ? aColor0 : -1; }
if (strcmp("aColor1", name) == 0) { return aColor1 != NULL_ATTRIB ? aColor1 : -1; }
if (strcmp("aFlags", name) == 0) { return aFlags != NULL_ATTRIB ? aFlags : -1; }
if (strcmp("aWidths", name) == 0) { return aWidths != NULL_ATTRIB ? aWidths : -1; }
if (strcmp("aRadii", name) == 0) { return aRadii != NULL_ATTRIB ? aRadii : -1; }
if (strcmp("aClipParams1", name) == 0) { return aClipParams1 != NULL_ATTRIB ? aClipParams1 : -1; }
if (strcmp("aClipParams2", name) == 0) { return aClipParams2 != NULL_ATTRIB ? aClipParams2 : -1; }
return -1;
}
} attrib_locations;
vec4_scalar vColor0;
vec4_scalar vColor1;
vec4_scalar vColorLine;
ivec2_scalar vMixColors;
vec4_scalar vClipCenter_Sign;
vec4_scalar vClipRadii;
vec4_scalar vHorizontalClipCenter_Sign;
vec2_scalar vHorizontalClipRadii;
vec4_scalar vVerticalClipCenter_Sign;
vec2_scalar vVerticalClipRadii;
mat4_scalar uTransform;
void bind_textures() {
}
};
struct cs_border_solid_vert : VertexShaderImpl, cs_border_solid_common {
private:
typedef cs_border_solid_vert Self;
// mat4_scalar uTransform;
vec2 aPosition;
struct RectWithSize_scalar {
vec2_scalar p0;
vec2_scalar size;
RectWithSize_scalar() = default;
RectWithSize_scalar(vec2_scalar p0, vec2_scalar size) : p0(p0), size(size){}
};
struct RectWithSize {
vec2 p0;
vec2 size;
RectWithSize() = default;
RectWithSize(vec2 p0, vec2 size) : p0(p0), size(size){}
RectWithSize(vec2_scalar p0, vec2_scalar size):p0(p0),size(size){
}
IMPLICIT RectWithSize(RectWithSize_scalar s):p0(s.p0),size(s.size){
}
friend RectWithSize if_then_else(I32 c, RectWithSize t, RectWithSize e) { return RectWithSize(
if_then_else(c, t.p0, e.p0), if_then_else(c, t.size, e.size));
}};
struct RectWithEndpoint_scalar {
vec2_scalar p0;
vec2_scalar p1;
RectWithEndpoint_scalar() = default;
RectWithEndpoint_scalar(vec2_scalar p0, vec2_scalar p1) : p0(p0), p1(p1){}
};
struct RectWithEndpoint {
vec2 p0;
vec2 p1;
RectWithEndpoint() = default;
RectWithEndpoint(vec2 p0, vec2 p1) : p0(p0), p1(p1){}
RectWithEndpoint(vec2_scalar p0, vec2_scalar p1):p0(p0),p1(p1){
}
IMPLICIT RectWithEndpoint(RectWithEndpoint_scalar s):p0(s.p0),p1(s.p1){
}
friend RectWithEndpoint if_then_else(I32 c, RectWithEndpoint t, RectWithEndpoint e) { return RectWithEndpoint(
if_then_else(c, t.p0, e.p0), if_then_else(c, t.p1, e.p1));
}};
// vec4_scalar vColor0;
// vec4_scalar vColor1;
// vec4_scalar vColorLine;
// ivec2_scalar vMixColors;
// vec4_scalar vClipCenter_Sign;
// vec4_scalar vClipRadii;
// vec4_scalar vHorizontalClipCenter_Sign;
// vec2_scalar vHorizontalClipRadii;
// vec4_scalar vVerticalClipCenter_Sign;
// vec2_scalar vVerticalClipRadii;
vec2 vPos;
vec2_scalar aTaskOrigin;
vec4_scalar aRect;
vec4_scalar aColor0;
vec4_scalar aColor1;
int32_t aFlags;
vec2_scalar aWidths;
vec2_scalar aRadii;
vec4_scalar aClipParams1;
vec4_scalar aClipParams2;
vec2_scalar get_outer_corner_scale(int32_t segment) {
vec2_scalar p;
switch (segment) {
case 0:
p = make_vec2(0.f, 0.f);
break;
case 1:
p = make_vec2(1.f, 0.f);
break;
case 2:
p = make_vec2(1.f, 1.f);
break;
case 3:
p = make_vec2(0.f, 1.f);
break;
default:
p = make_vec2(0.f);
break;
}
return p;
}
ALWAYS_INLINE void main(void) {
int32_t segment = (aFlags)&(255);
bool do_aa = (((aFlags)>>(24))&(240))!=(0);
vec2_scalar outer_scale = get_outer_corner_scale(segment);
vec2_scalar size = ((aRect).sel(Z,W))-((aRect).sel(X,Y));
vec2_scalar outer = (outer_scale)*(size);
vec2_scalar clip_sign = (1.f)-((2.f)*(outer_scale));
int32_t mix_colors;
switch (segment) {
case 0:
case 1:
case 2:
case 3:
{
mix_colors = do_aa ? 1 : 2;
break;
}
default:
mix_colors = 0;
break;
}
(vMixColors).x = mix_colors;
vPos = (size)*((aPosition).sel(X,Y));
vColor0 = aColor0;
vColor1 = aColor1;
vClipCenter_Sign = make_vec4((outer)+((clip_sign)*(aRadii)), clip_sign);
vClipRadii = make_vec4(aRadii, max((aRadii)-(aWidths), 0.f));
vColorLine = make_vec4(outer, ((aWidths).y)*(-((clip_sign).y)), ((aWidths).x)*((clip_sign).x));
vec2_scalar horizontal_clip_sign = make_vec2(-((clip_sign).x), (clip_sign).y);
vHorizontalClipCenter_Sign = make_vec4(((aClipParams1).sel(X,Y))+((horizontal_clip_sign)*((aClipParams1).sel(Z,W))), horizontal_clip_sign);
vHorizontalClipRadii = (aClipParams1).sel(Z,W);
vec2_scalar vertical_clip_sign = make_vec2((clip_sign).x, -((clip_sign).y));
vVerticalClipCenter_Sign = make_vec4(((aClipParams2).sel(X,Y))+((vertical_clip_sign)*((aClipParams2).sel(Z,W))), vertical_clip_sign);
vVerticalClipRadii = (aClipParams2).sel(Z,W);
gl_Position = (uTransform)*(make_vec4(((aTaskOrigin)+((aRect).sel(X,Y)))+(vPos), 0.f, 1.f));
}
static void set_uniform_1i(VertexShaderImpl* impl, int index, int value) {
Self* self = (Self*)impl;
if (self->samplers.set_slot(index, value)) return;
switch (index) {
case 1:
assert(0); // uTransform
break;
}
}
static void set_uniform_4fv(VertexShaderImpl* impl, int index, const float *value) {
Self* self = (Self*)impl;
switch (index) {
case 1:
assert(0); // uTransform
break;
}
}
static void set_uniform_matrix4fv(VertexShaderImpl* impl, int index, const float *value) {
Self* self = (Self*)impl;
switch (index) {
case 1:
self->uTransform = mat4_scalar::load_from_ptr(value);
break;
}
}
static void load_attribs(VertexShaderImpl* impl, VertexAttrib *attribs, uint32_t start, int instance, int count) {Self* self = (Self*)impl;
load_attrib(self->aPosition, attribs[self->attrib_locations.aPosition], start, instance, count);
load_flat_attrib(self->aTaskOrigin, attribs[self->attrib_locations.aTaskOrigin], start, instance, count);
load_flat_attrib(self->aRect, attribs[self->attrib_locations.aRect], start, instance, count);
load_flat_attrib(self->aColor0, attribs[self->attrib_locations.aColor0], start, instance, count);
load_flat_attrib(self->aColor1, attribs[self->attrib_locations.aColor1], start, instance, count);
load_flat_attrib(self->aFlags, attribs[self->attrib_locations.aFlags], start, instance, count);
load_flat_attrib(self->aWidths, attribs[self->attrib_locations.aWidths], start, instance, count);
load_flat_attrib(self->aRadii, attribs[self->attrib_locations.aRadii], start, instance, count);
load_flat_attrib(self->aClipParams1, attribs[self->attrib_locations.aClipParams1], start, instance, count);
load_flat_attrib(self->aClipParams2, attribs[self->attrib_locations.aClipParams2], start, instance, count);
}
public:
struct InterpOutputs {
vec2_scalar vPos;
};
private:
ALWAYS_INLINE void store_interp_outputs(char* dest_ptr, size_t stride) {
for(int n = 0; n < 4; n++) {
auto* dest = reinterpret_cast<InterpOutputs*>(dest_ptr);
dest->vPos = get_nth(vPos, n);
dest_ptr += stride;
}
}
static void run(VertexShaderImpl* impl, char* interps, size_t interp_stride) {
Self* self = (Self*)impl;
self->main();
self->store_interp_outputs(interps, interp_stride);
}
static void init_batch(VertexShaderImpl* impl) {
Self* self = (Self*)impl; self->bind_textures(); }
public:
cs_border_solid_vert() {
set_uniform_1i_func = &set_uniform_1i;
set_uniform_4fv_func = &set_uniform_4fv;
set_uniform_matrix4fv_func = &set_uniform_matrix4fv;
init_batch_func = &init_batch;
load_attribs_func = &load_attribs;
run_primitive_func = &run;
}
};
struct cs_border_solid_frag : FragmentShaderImpl, cs_border_solid_vert {
private:
typedef cs_border_solid_frag Self;
#define oFragColor gl_FragColor
// vec4 oFragColor;
struct RectWithSize_scalar {
vec2_scalar p0;
vec2_scalar size;
RectWithSize_scalar() = default;
RectWithSize_scalar(vec2_scalar p0, vec2_scalar size) : p0(p0), size(size){}
};
struct RectWithSize {
vec2 p0;
vec2 size;
RectWithSize() = default;
RectWithSize(vec2 p0, vec2 size) : p0(p0), size(size){}
RectWithSize(vec2_scalar p0, vec2_scalar size):p0(p0),size(size){
}
IMPLICIT RectWithSize(RectWithSize_scalar s):p0(s.p0),size(s.size){
}
friend RectWithSize if_then_else(I32 c, RectWithSize t, RectWithSize e) { return RectWithSize(
if_then_else(c, t.p0, e.p0), if_then_else(c, t.size, e.size));
}};
struct RectWithEndpoint_scalar {
vec2_scalar p0;
vec2_scalar p1;
RectWithEndpoint_scalar() = default;
RectWithEndpoint_scalar(vec2_scalar p0, vec2_scalar p1) : p0(p0), p1(p1){}
};
struct RectWithEndpoint {
vec2 p0;
vec2 p1;
RectWithEndpoint() = default;
RectWithEndpoint(vec2 p0, vec2 p1) : p0(p0), p1(p1){}
RectWithEndpoint(vec2_scalar p0, vec2_scalar p1):p0(p0),p1(p1){
}
IMPLICIT RectWithEndpoint(RectWithEndpoint_scalar s):p0(s.p0),p1(s.p1){
}
friend RectWithEndpoint if_then_else(I32 c, RectWithEndpoint t, RectWithEndpoint e) { return RectWithEndpoint(
if_then_else(c, t.p0, e.p0), if_then_else(c, t.p1, e.p1));
}};
// vec4_scalar vColor0;
// vec4_scalar vColor1;
// vec4_scalar vColorLine;
// ivec2_scalar vMixColors;
// vec4_scalar vClipCenter_Sign;
// vec4_scalar vClipRadii;
// vec4_scalar vHorizontalClipCenter_Sign;
// vec2_scalar vHorizontalClipRadii;
// vec4_scalar vVerticalClipCenter_Sign;
// vec2_scalar vVerticalClipRadii;
vec2 vPos;
float compute_aa_range(vec2 position) {
return recip((fwidth(position)).x);
}
Float distance_to_line(vec2_scalar p0, vec2_scalar perp_dir, vec2 p) {
vec2 dir_to_p0 = (p0)-(p);
return dot(normalize(perp_dir), dir_to_p0);
}
Float distance_aa(float aa_range, Float signed_distance) {
Float dist = (signed_distance)*(aa_range);
return clamp((0.5f)-(dist), 0.f, 1.f);
}
Float distance_to_ellipse_approx(vec2 p, vec2_scalar inv_radii_sq, float scale) {
vec2 p_r = (p)*(inv_radii_sq);
Float g = (dot(p, p_r))-(scale);
vec2 dG = ((1.f)+(scale))*(p_r);
return (g)*(inversesqrt(dot(dG, dG)));
}
vec2_scalar inverse_radii_squared(vec2_scalar radii) {
return (1.f)/(max((radii)*(radii), 0.000001f));
}
Float distance_to_ellipse(vec2 p, vec2_scalar radii) {
return distance_to_ellipse_approx(p, inverse_radii_squared(radii), make_float((make_int(all(greaterThan(radii, make_vec2(0.f)))))&(1)));
}
ALWAYS_INLINE void main(void) {
float aa_range = compute_aa_range(vPos);
bool do_aa = ((vMixColors).x)!=(2);
Float mix_factor = 0.f;
if (((vMixColors).x)!=(0)) {
{
Float d_line = distance_to_line((vColorLine).sel(X,Y), (vColorLine).sel(Z,W), vPos);
if (do_aa) {
{
mix_factor = distance_aa(aa_range, -(d_line));
}
} else {
mix_factor = if_then_else(((d_line)+(0.0001f))>=(0.f), 1.f, 0.f);
}
}
}
vec2 clip_relative_pos = (vPos)-((vClipCenter_Sign).sel(X,Y));
Bool in_clip_region = all(lessThan(((vClipCenter_Sign).sel(Z,W))*(clip_relative_pos), make_vec2(0.f)));
Float d = -(1.f);
auto _c4_ = in_clip_region;
{
Float d_radii_a = distance_to_ellipse(clip_relative_pos, (vClipRadii).sel(X,Y));
Float d_radii_b = distance_to_ellipse(clip_relative_pos, (vClipRadii).sel(Z,W));
d = if_then_else(_c4_,max(d_radii_a, -(d_radii_b)),d);
}
clip_relative_pos = (vPos)-((vHorizontalClipCenter_Sign).sel(X,Y));
in_clip_region = all(lessThan(((vHorizontalClipCenter_Sign).sel(Z,W))*(clip_relative_pos), make_vec2(0.f)));
auto _c5_ = in_clip_region;
{
Float d_radii = distance_to_ellipse(clip_relative_pos, (vHorizontalClipRadii).sel(X,Y));
d = if_then_else(_c5_,max(d_radii, d),d);
}
clip_relative_pos = (vPos)-((vVerticalClipCenter_Sign).sel(X,Y));
in_clip_region = all(lessThan(((vVerticalClipCenter_Sign).sel(Z,W))*(clip_relative_pos), make_vec2(0.f)));
auto _c6_ = in_clip_region;
{
Float d_radii = distance_to_ellipse(clip_relative_pos, (vVerticalClipRadii).sel(X,Y));
d = if_then_else(_c6_,max(d_radii, d),d);
}
Float alpha = do_aa ? distance_aa(aa_range, d) : 1.f;
vec4 color = mix(vColor0, vColor1, mix_factor);
oFragColor = (color)*(alpha);
}
typedef cs_border_solid_vert::InterpOutputs InterpInputs;
InterpInputs interp_step;
struct InterpPerspective {
vec2 vPos;
};
InterpPerspective interp_perspective;
static void read_interp_inputs(FragmentShaderImpl* impl, const void* init_, const void* step_) {Self* self = (Self*)impl;const InterpInputs* init = (const InterpInputs*)init_;const InterpInputs* step = (const InterpInputs*)step_;
self->vPos = init_interp(init->vPos, step->vPos);
self->interp_step.vPos = step->vPos * 4.0f;
}
static void read_perspective_inputs(FragmentShaderImpl* impl, const void* init_, const void* step_) {Self* self = (Self*)impl;const InterpInputs* init = (const InterpInputs*)init_;const InterpInputs* step = (const InterpInputs*)step_;
Float w = 1.0f / self->gl_FragCoord.w;
self->interp_perspective.vPos = init_interp(init->vPos, step->vPos);
self->vPos = self->interp_perspective.vPos * w;
self->interp_step.vPos = step->vPos * 4.0f;
}
ALWAYS_INLINE void step_interp_inputs(int steps = 4) {
float chunks = steps * 0.25f;
vPos += interp_step.vPos * chunks;
}
ALWAYS_INLINE void step_perspective_inputs(int steps = 4) {
step_perspective(steps);
float chunks = steps * 0.25f;
Float w = 1.0f / gl_FragCoord.w;
interp_perspective.vPos += interp_step.vPos * chunks;
vPos = w * interp_perspective.vPos;
}
static void run(FragmentShaderImpl* impl) {
Self* self = (Self*)impl;
self->main();
self->step_interp_inputs();
}
static void skip(FragmentShaderImpl* impl, int steps) {
Self* self = (Self*)impl;
self->step_interp_inputs(steps);
}
static void run_perspective(FragmentShaderImpl* impl) {
Self* self = (Self*)impl;
self->main();
self->step_perspective_inputs();
}
static void skip_perspective(FragmentShaderImpl* impl, int steps) {
Self* self = (Self*)impl;
self->step_perspective_inputs(steps);
}
public:
cs_border_solid_frag() {
init_span_func = &read_interp_inputs;
run_func = &run;
skip_func = &skip;
enable_perspective();
init_span_w_func = &read_perspective_inputs;
run_w_func = &run_perspective;
skip_w_func = &skip_perspective;
}
};
struct cs_border_solid_program : ProgramImpl, cs_border_solid_frag {
int get_uniform(const char *name) const override {
if (strcmp("uTransform", name) == 0) { return 1; }
return -1;
}
void bind_attrib(const char* name, int index) override {
attrib_locations.bind_loc(name, index);
}
int get_attrib(const char* name) const override {
return attrib_locations.get_loc(name);
}
size_t interpolants_size() const override { return sizeof(InterpOutputs); }
VertexShaderImpl* get_vertex_shader() override {
return this;
}
FragmentShaderImpl* get_fragment_shader() override {
return this;
}
const char* get_name() const override { return "cs_border_solid"; }
static ProgramImpl* loader() { return new cs_border_solid_program; }
};