Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-07-22 23:03:42 +01:00
Code Issues Projects Releases Packages Wiki Activity

Auto merge of #13146 - glennw:update-wr-soa, r=nox

Browse source 
Update WR + shaders (switch to untyped UBO for CI).

This makes WR startup time significantly faster on Linux, by working around a slow path in the shader compiler.

<!-- Reviewable:start -->
---
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/13146)
<!-- Reviewable:end -->
This commit is contained in:
bors-servo 2016-09-01 04:28:46 -05:00 • committed by GitHub
commit c3ef836c09
18 changed files with 375 additions and 197 deletions
Download patch file Download diff file Expand all files Collapse all files

4
components/servo/Cargo.lock generated
View file

@ -2585,7 +2585,7 @@ dependencies = [
[[package]]
name = "webrender"
version = "0.5.1"
source = "git+https://github.com/servo/webrender#b3611d501b13281299a073540058547feeb7e4e3"
source = "git+https://github.com/servo/webrender#a235d5bd9d3d5174e5b71542277358a9534e7f44"
dependencies = [
"app_units 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
"bincode 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
@ -2610,7 +2610,7 @@ dependencies = [
[[package]]
name = "webrender_traits"
version = "0.5.1"
source = "git+https://github.com/servo/webrender#b3611d501b13281299a073540058547feeb7e4e3"
source = "git+https://github.com/servo/webrender#a235d5bd9d3d5174e5b71542277358a9534e7f44"
dependencies = [
"app_units 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
"byteorder 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)",

4
ports/cef/Cargo.lock generated
View file

@ -2445,7 +2445,7 @@ dependencies = [
[[package]]
name = "webrender"
version = "0.5.1"
source = "git+https://github.com/servo/webrender#b3611d501b13281299a073540058547feeb7e4e3"
source = "git+https://github.com/servo/webrender#a235d5bd9d3d5174e5b71542277358a9534e7f44"
dependencies = [
"app_units 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
"bincode 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
@ -2470,7 +2470,7 @@ dependencies = [
[[package]]
name = "webrender_traits"
version = "0.5.1"
source = "git+https://github.com/servo/webrender#b3611d501b13281299a073540058547feeb7e4e3"
source = "git+https://github.com/servo/webrender#a235d5bd9d3d5174e5b71542277358a9534e7f44"
dependencies = [
"app_units 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
"byteorder 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)",

349
resources/shaders/prim_shared.glsl
View file

@ -27,6 +27,8 @@
#define BORDER_STYLE_INSET uint(8)
#define BORDER_STYLE_OUTSET uint(9)
#define MAX_STOPS_PER_ANGLE_GRADIENT 8
#ifdef WR_VERTEX_SHADER
struct Layer {
mat4 transform;
@ -35,30 +37,89 @@ struct Layer {
vec4 screen_vertices[4];
};
layout(std140) uniform Layers {
Layer layers[WR_MAX_PRIM_LAYERS];
layout(std140) uniform Data {
vec4 data[WR_MAX_UBO_VECTORS];
};
layout(std140) uniform Tiles {
vec4 tiles[WR_MAX_UBO_VECTORS];
};
layout(std140) uniform Layers {
vec4 layers[WR_MAX_UBO_VECTORS];
};
Layer fetch_layer(int index) {
Layer layer;
int offset = index * 13;
layer.transform[0] = layers[offset + 0];
layer.transform[1] = layers[offset + 1];
layer.transform[2] = layers[offset + 2];
layer.transform[3] = layers[offset + 3];
layer.inv_transform[0] = layers[offset + 4];
layer.inv_transform[1] = layers[offset + 5];
layer.inv_transform[2] = layers[offset + 6];
layer.inv_transform[3] = layers[offset + 7];
layer.local_clip_rect = layers[offset + 8];
layer.screen_vertices[0] = layers[offset + 9];
layer.screen_vertices[1] = layers[offset + 10];
layer.screen_vertices[2] = layers[offset + 11];
layer.screen_vertices[3] = layers[offset + 12];
return layer;
}
struct Tile {
vec4 actual_rect;
vec4 target_rect;
};
layout(std140) uniform Tiles {
Tile tiles[WR_MAX_PRIM_TILES];
};
Tile fetch_tile(int index) {
Tile tile;
int offset = index * 2;
tile.actual_rect = tiles[offset + 0];
tile.target_rect = tiles[offset + 1];
return tile;
}
struct PrimitiveInfo {
uvec4 layer_tile;
vec4 layer_tile;
vec4 local_clip_rect;
vec4 local_rect;
};
PrimitiveInfo unpack_prim_info(int offset) {
PrimitiveInfo info;
info.layer_tile = data[offset + 0];
info.local_clip_rect = data[offset + 1];
info.local_rect = data[offset + 2];
return info;
}
struct ClipCorner {
vec4 rect;
vec4 outer_inner_radius;
};
ClipCorner unpack_clip_corner(int offset) {
ClipCorner corner;
corner.rect = data[offset + 0];
corner.outer_inner_radius = data[offset + 1];
return corner;
}
struct Clip {
vec4 rect;
ClipCorner top_left;
@ -67,6 +128,18 @@ struct Clip {
ClipCorner bottom_right;
};
Clip unpack_clip(int offset) {
Clip clip;
clip.rect = data[offset + 0];
clip.top_left = unpack_clip_corner(offset + 1);
clip.top_right = unpack_clip_corner(offset + 3);
clip.bottom_left = unpack_clip_corner(offset + 5);
clip.bottom_right = unpack_clip_corner(offset + 7);
return clip;
}
bool ray_plane(vec3 normal, vec3 point, vec3 ray_origin, vec3 ray_dir, out float t)
{
float denom = dot(normal, ray_dir);
@ -91,8 +164,7 @@ vec4 untransform(vec2 ref, vec3 n, vec3 a, mat4 inv_transform) {
return r;
}
vec3 get_layer_pos(vec2 pos, uint layer_index) {
Layer layer = layers[layer_index];
vec3 get_layer_pos(vec2 pos, Layer layer) {
vec3 a = layer.screen_vertices[0].xyz / layer.screen_vertices[0].w;
vec3 b = layer.screen_vertices[3].xyz / layer.screen_vertices[3].w;
vec3 c = layer.screen_vertices[2].xyz / layer.screen_vertices[2].w;
@ -113,8 +185,8 @@ struct VertexInfo {
};
VertexInfo write_vertex(PrimitiveInfo info) {
Layer layer = layers[info.layer_tile.x];
Tile tile = tiles[info.layer_tile.y];
Layer layer = fetch_layer(int(info.layer_tile.x));
Tile tile = fetch_tile(int(info.layer_tile.y));
vec2 p0 = floor(0.5 + info.local_rect.xy * uDevicePixelRatio) / uDevicePixelRatio;
vec2 p1 = floor(0.5 + (info.local_rect.xy + info.local_rect.zw) * uDevicePixelRatio) / uDevicePixelRatio;
@ -155,8 +227,8 @@ struct TransformVertexInfo {
};
TransformVertexInfo write_transform_vertex(PrimitiveInfo info) {
Layer layer = layers[info.layer_tile.x];
Tile tile = tiles[info.layer_tile.y];
Layer layer = fetch_layer(int(info.layer_tile.x));
Tile tile = fetch_tile(int(info.layer_tile.y));
vec2 lp0 = info.local_rect.xy;
vec2 lp1 = info.local_rect.xy + info.local_rect.zw;
@ -200,7 +272,7 @@ TransformVertexInfo write_transform_vertex(PrimitiveInfo info) {
max_pos_clamped,
aPosition.xy);
vec3 layer_pos = get_layer_pos(clamped_pos / uDevicePixelRatio, info.layer_tile.x);
vec3 layer_pos = get_layer_pos(clamped_pos / uDevicePixelRatio, layer);
vec2 final_pos = clamped_pos + vec2(tile.target_rect.xy) - vec2(tile.actual_rect.xy);
@ -208,6 +280,257 @@ TransformVertexInfo write_transform_vertex(PrimitiveInfo info) {
return TransformVertexInfo(layer_pos, clipped_local_rect);
}
struct Rectangle {
PrimitiveInfo info;
vec4 color;
};
Rectangle fetch_rectangle(int index) {
Rectangle rect;
int offset = index * 4;
rect.info = unpack_prim_info(offset);
rect.color = data[offset + 3];
return rect;
}
struct RectangleClip {
PrimitiveInfo info;
vec4 color;
Clip clip;
};
RectangleClip fetch_rectangle_clip(int index) {
RectangleClip rect;
int offset = index * 13;
rect.info = unpack_prim_info(offset);
rect.color = data[offset + 3];
rect.clip = unpack_clip(offset + 4);
return rect;
}
struct Glyph {
PrimitiveInfo info;
vec4 color;
vec4 uv_rect;
};
Glyph fetch_glyph(int index) {
Glyph glyph;
int offset = index * 5;
glyph.info = unpack_prim_info(offset);
glyph.color = data[offset + 3];
glyph.uv_rect = data[offset + 4];
return glyph;
}
struct TextRunGlyph {
vec4 local_rect;
vec4 uv_rect;
};
struct TextRun {
PrimitiveInfo info;
vec4 color;
TextRunGlyph glyphs[WR_GLYPHS_PER_TEXT_RUN];
};
PrimitiveInfo fetch_text_run_glyph(int index, out vec4 color, out vec4 uv_rect) {
int offset = 20 * (index / WR_GLYPHS_PER_TEXT_RUN);
int glyph_index = index % WR_GLYPHS_PER_TEXT_RUN;
int glyph_offset = offset + 4 + 2 * glyph_index;
PrimitiveInfo info;
info.layer_tile = data[offset + 0];
info.local_clip_rect = data[offset + 1];
info.local_rect = data[glyph_offset + 0];
color = data[offset + 3];
uv_rect = data[glyph_offset + 1];
return info;
}
struct Image {
PrimitiveInfo info;
vec4 st_rect; // Location of the image texture in the texture atlas.
vec4 stretch_size_uvkind; // Size of the actual image.
};
Image fetch_image(int index) {
Image image;
int offset = index * 5;
image.info = unpack_prim_info(offset);
image.st_rect = data[offset + 3];
image.stretch_size_uvkind = data[offset + 4];
return image;
}
struct ImageClip {
PrimitiveInfo info;
vec4 st_rect; // Location of the image texture in the texture atlas.
vec4 stretch_size_uvkind; // Size of the actual image.
Clip clip;
};
ImageClip fetch_image_clip(int index) {
ImageClip image;
int offset = index * 14;
image.info = unpack_prim_info(offset);
image.st_rect = data[offset + 3];
image.stretch_size_uvkind = data[offset + 4];
image.clip = unpack_clip(offset + 5);
return image;
}
struct Border {
PrimitiveInfo info;
vec4 verticalColor;
vec4 horizontalColor;
vec4 radii;
vec4 border_style_trbl;
vec4 part;
};
Border fetch_border(int index) {
Border border;
int offset = index * 8;
border.info = unpack_prim_info(offset);
border.verticalColor = data[offset + 3];
border.horizontalColor = data[offset + 4];
border.radii = data[offset + 5];
border.border_style_trbl = data[offset + 6];
border.part = data[offset + 7];
return border;
}
struct BoxShadow {
PrimitiveInfo info;
vec4 color;
vec4 border_radii_blur_radius_inverted;
vec4 bs_rect;
vec4 src_rect;
};
BoxShadow fetch_boxshadow(int index) {
BoxShadow bs;
int offset = index * 7;
bs.info = unpack_prim_info(offset);
bs.color = data[offset + 3];
bs.border_radii_blur_radius_inverted = data[offset + 4];
bs.bs_rect = data[offset + 5];
bs.src_rect = data[offset + 6];
return bs;
}
struct AlignedGradient {
PrimitiveInfo info;
vec4 color0;
vec4 color1;
vec4 dir;
Clip clip;
};
AlignedGradient fetch_aligned_gradient(int index) {
AlignedGradient gradient;
int offset = index * 15;
gradient.info = unpack_prim_info(offset);
gradient.color0 = data[offset + 3];
gradient.color1 = data[offset + 4];
gradient.dir = data[offset + 5];
gradient.clip = unpack_clip(offset + 6);
return gradient;
}
struct AngleGradient {
PrimitiveInfo info;
vec4 start_end_point;
vec4 stop_count;
vec4 colors[MAX_STOPS_PER_ANGLE_GRADIENT];
vec4 offsets[MAX_STOPS_PER_ANGLE_GRADIENT/4];
};
AngleGradient fetch_angle_gradient(int index) {
AngleGradient gradient;
int offset = index * 15;
gradient.info = unpack_prim_info(offset);
gradient.start_end_point = data[offset + 3];
gradient.stop_count = data[offset + 4];
for (int i=0 ; i < MAX_STOPS_PER_ANGLE_GRADIENT ; ++i) {
gradient.colors[i] = data[offset + 5 + i];
}
for (int i=0 ; i < MAX_STOPS_PER_ANGLE_GRADIENT/4 ; ++i) {
gradient.offsets[i] = data[offset + 5 + MAX_STOPS_PER_ANGLE_GRADIENT + i];
}
return gradient;
}
struct Blend {
vec4 target_rect;
vec4 src_rect;
vec4 opacity;
};
Blend fetch_blend(int index) {
Blend blend;
int offset = index * 3;
blend.target_rect = data[offset + 0];
blend.src_rect = data[offset + 1];
blend.opacity = data[offset + 2];
return blend;
}
struct Composite {
vec4 src0;
vec4 src1;
vec4 target_rect;
vec4 info_amount;
};
Composite fetch_composite(int index) {
Composite composite;
int offset = index * 4;
composite.src0 = data[offset + 0];
composite.src1 = data[offset + 1];
composite.target_rect = data[offset + 2];
composite.info_amount = data[offset + 3];
return composite;
}
#endif
#ifdef WR_FRAGMENT_SHADER

2
resources/shaders/ps_angle_gradient.glsl
View file

@ -2,8 +2,6 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#define MAX_STOPS_PER_ANGLE_GRADIENT 8
flat varying int vStopCount;
flat varying float vAngle;
flat varying vec2 vStartPoint;

14
resources/shaders/ps_angle_gradient.vs.glsl
View file

@ -3,20 +3,8 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
struct AngleGradient {
PrimitiveInfo info;
vec4 start_end_point;
vec4 stop_count;
vec4 colors[MAX_STOPS_PER_ANGLE_GRADIENT];
vec4 offsets[MAX_STOPS_PER_ANGLE_GRADIENT/4];
};
layout(std140) uniform Items {
AngleGradient gradients[WR_MAX_PRIM_ITEMS];
};
void main(void) {
AngleGradient gradient = gradients[gl_InstanceID];
AngleGradient gradient = fetch_angle_gradient(gl_InstanceID);
VertexInfo vi = write_vertex(gradient.info);
vStopCount = int(gradient.stop_count.x);

12
resources/shaders/ps_blend.vs.glsl
View file

@ -3,18 +3,8 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
struct Blend {
vec4 target_rect;
vec4 src_rect;
vec4 opacity;
};
layout(std140) uniform Items {
Blend blends[WR_MAX_PRIM_ITEMS];
};
void main(void) {
Blend blend = blends[gl_InstanceID];
Blend blend = fetch_blend(gl_InstanceID);
vec2 local_pos = mix(vec2(blend.target_rect.xy),
vec2(blend.target_rect.xy + blend.target_rect.zw),

29
resources/shaders/ps_border.fs.glsl
View file

@ -62,15 +62,6 @@ vec4 drawCircle(vec2 aPixel, vec2 aDesiredPos, float aRadius, vec3 aColor) {
return vec4(aColor, pixelInCircle);
}
// Draw a rectangle at aRect fill it with aColor. Only works on non-rotated
// rects.
vec4 drawRect(vec2 aPixel, vec4 aRect, vec3 aColor) {
// GLSL origin is bottom left, positive Y is up
bool inRect = (aRect.x <= aPixel.x) && (aPixel.x <= aRect.x + aRect.z) &&
(aPixel.y >= aRect.y) && (aPixel.y <= aRect.y + aRect.w);
return vec4(aColor, float(inRect));
}
vec4 draw_dotted_edge() {
// Everything here should be in device pixels.
// We want the dot to be roughly the size of the whole border spacing
@ -134,11 +125,21 @@ void draw_dotted_border(void) {
#endif
vec4 draw_dashed_edge(float position, float border_width) {
vec4 draw_dashed_edge(float position, float border_width, float pixels_per_fragment) {
// TODO: Investigate exactly what FF does.
float size = border_width * 3;
float segment = floor(position / size) + 2;
return mix(vec4(0, 0, 0, 0), vHorizontalColor, mod(segment, 2));
float segment = floor(position / size);
float alpha = alpha_for_solid_border(position,
segment * size,
(segment + 1) * size,
pixels_per_fragment);
if (mod(segment + 2, 2) == 0) {
return vHorizontalColor * vec4(1, 1, 1, 1 - alpha);
} else {
return vHorizontalColor * vec4(1, 1, 1, alpha);
}
}
void draw_dashed_border(vec2 local_pos, float distance_from_mix_line) {
@ -165,13 +166,13 @@ void draw_dashed_border(vec2 local_pos, float distance_from_mix_line) {
case PST_BOTTOM:
case PST_TOP:
{
oFragColor = draw_dashed_edge(vLocalPos.x - vPieceRect.x, vPieceRect.w);
oFragColor = draw_dashed_edge(vLocalPos.x - vPieceRect.x, vPieceRect.w, pixels_per_fragment);
break;
}
case PST_LEFT:
case PST_RIGHT:
{
oFragColor = draw_dashed_edge(vLocalPos.y - vPieceRect.y, vPieceRect.z);
oFragColor = draw_dashed_edge(vLocalPos.y - vPieceRect.y, vPieceRect.z, pixels_per_fragment);
break;
}
}

15
resources/shaders/ps_border.vs.glsl
View file

@ -3,19 +3,6 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
struct Border {
PrimitiveInfo info;
vec4 verticalColor;
vec4 horizontalColor;
vec4 radii;
vec4 border_style_trbl;
vec4 part;
};
layout(std140) uniform Items {
Border borders[WR_MAX_PRIM_ITEMS];
};
float get_border_style(Border a_border, uint a_edge) {
switch (a_edge) {
case PST_TOP:
@ -34,7 +21,7 @@ float get_border_style(Border a_border, uint a_edge) {
}
void main(void) {
Border border = borders[gl_InstanceID];
Border border = fetch_border(gl_InstanceID);
#ifdef WR_FEATURE_TRANSFORM
TransformVertexInfo vi = write_transform_vertex(border.info);
vLocalPos = vi.local_pos;

14
resources/shaders/ps_box_shadow.vs.glsl
View file

@ -3,20 +3,8 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
struct BoxShadow {
PrimitiveInfo info;
vec4 color;
vec4 border_radii_blur_radius_inverted;
vec4 bs_rect;
vec4 src_rect;
};
layout(std140) uniform Items {
BoxShadow boxshadows[WR_MAX_PRIM_ITEMS];
};
void main(void) {
BoxShadow bs = boxshadows[gl_InstanceID];
BoxShadow bs = fetch_boxshadow(gl_InstanceID);
VertexInfo vi = write_vertex(bs.info);
vPos = vi.local_clamped_pos;

13
resources/shaders/ps_clear.vs.glsl
View file

@ -4,19 +4,12 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
struct ClearTile {
uvec4 rect;
layout(std140) uniform Data {
uvec4 data[WR_MAX_UBO_VECTORS];
};
layout(std140) uniform Tiles {
ClearTile tiles[WR_MAX_CLEAR_TILES];
};
void main() {
ClearTile tile = tiles[gl_InstanceID];
vec4 rect = vec4(tile.rect);
vec4 rect = vec4(data[gl_InstanceID]);
vec4 pos = vec4(mix(rect.xy, rect.xy + rect.zw, aPosition.xy), 0, 1);
gl_Position = uTransform * pos;

13
resources/shaders/ps_composite.vs.glsl
View file

@ -3,19 +3,8 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
struct Composite {
vec4 src0;
vec4 src1;
vec4 target_rect;
vec4 info_amount;
};
layout(std140) uniform Items {
Composite composites[WR_MAX_PRIM_ITEMS];
};
void main(void) {
Composite composite = composites[gl_InstanceID];
Composite composite = fetch_composite(gl_InstanceID);
vec2 local_pos = mix(vec2(composite.target_rect.xy),
vec2(composite.target_rect.xy + composite.target_rect.zw),

14
resources/shaders/ps_gradient.vs.glsl
View file

@ -6,20 +6,8 @@
#define DIR_HORIZONTAL uint(0)
#define DIR_VERTICAL uint(1)
struct Gradient {
PrimitiveInfo info;
vec4 color0;
vec4 color1;
vec4 dir;
Clip clip;
};
layout(std140) uniform Items {
Gradient gradients[WR_MAX_PRIM_ITEMS];
};
void main(void) {
Gradient gradient = gradients[gl_InstanceID];
AlignedGradient gradient = fetch_aligned_gradient(gl_InstanceID);
#ifdef WR_FEATURE_TRANSFORM
TransformVertexInfo vi = write_transform_vertex(gradient.info);

12
resources/shaders/ps_image.vs.glsl
View file

@ -3,18 +3,8 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
struct Image {
PrimitiveInfo info;
vec4 st_rect; // Location of the image texture in the texture atlas.
vec4 stretch_size_uvkind; // Size of the actual image.
};
layout(std140) uniform Items {
Image images[WR_MAX_PRIM_ITEMS];
};
void main(void) {
Image image = images[gl_InstanceID];
Image image = fetch_image(gl_InstanceID);
#ifdef WR_FEATURE_TRANSFORM
TransformVertexInfo vi = write_transform_vertex(image.info);

13
resources/shaders/ps_image_clip.vs.glsl
View file

@ -3,19 +3,8 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
struct Image {
PrimitiveInfo info;
vec4 st_rect; // Location of the image texture in the texture atlas.
vec4 stretch_size_uvkind; // Size of the actual image.
Clip clip;
};
layout(std140) uniform Items {
Image images[WR_MAX_PRIM_ITEMS];
};
void main(void) {
Image image = images[gl_InstanceID];
ImageClip image = fetch_image_clip(gl_InstanceID);
VertexInfo vi = write_vertex(image.info);
vClipRect = vec4(image.clip.rect.xy, image.clip.rect.xy + image.clip.rect.zw);

11
resources/shaders/ps_rectangle.vs.glsl
View file

@ -3,17 +3,8 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
struct Rectangle {
PrimitiveInfo info;
vec4 color;
};
layout(std140) uniform Items {
Rectangle rects[WR_MAX_PRIM_ITEMS];
};
void main(void) {
Rectangle rect = rects[gl_InstanceID];
Rectangle rect = fetch_rectangle(gl_InstanceID);
vColor = rect.color;
#ifdef WR_FEATURE_TRANSFORM
TransformVertexInfo vi = write_transform_vertex(rect.info);

12
resources/shaders/ps_rectangle_clip.vs.glsl
View file

@ -3,18 +3,8 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
struct Rectangle {
PrimitiveInfo info;
vec4 color;
Clip clip;
};
layout(std140) uniform Items {
Rectangle rects[WR_MAX_PRIM_ITEMS];
};
void main(void) {
Rectangle rect = rects[gl_InstanceID];
RectangleClip rect = fetch_rectangle_clip(gl_InstanceID);
VertexInfo vi = write_vertex(rect.info);
vClipRect = vec4(rect.clip.rect.xy, rect.clip.rect.xy + rect.clip.rect.zw);

12
resources/shaders/ps_text.vs.glsl
View file

@ -3,18 +3,8 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
struct Glyph {
PrimitiveInfo info;
vec4 color;
vec4 uv_rect;
};
layout(std140) uniform Items {
Glyph glyphs[WR_MAX_PRIM_ITEMS];
};
void main(void) {
Glyph glyph = glyphs[gl_InstanceID];
Glyph glyph = fetch_glyph(gl_InstanceID);
#ifdef WR_FEATURE_TRANSFORM
TransformVertexInfo vi = write_transform_vertex(glyph.info);

29
resources/shaders/ps_text_run.vs.glsl
View file

@ -3,34 +3,17 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
struct TextRunGlyph {
vec4 local_rect;
vec4 uv_rect;
};
struct TextRun {
PrimitiveInfo info;
TextRunGlyph glyphs[WR_GLYPHS_PER_TEXT_RUN];
vec4 color;
};
layout(std140) uniform Items {
TextRun text_runs[WR_MAX_PRIM_ITEMS];
};
void main(void) {
TextRun text_run = text_runs[gl_InstanceID / WR_GLYPHS_PER_TEXT_RUN];
TextRunGlyph glyph = text_run.glyphs[gl_InstanceID % WR_GLYPHS_PER_TEXT_RUN];
text_run.info.local_rect = glyph.local_rect;
vec4 uv_rect = glyph.uv_rect;
vec4 color, uv_rect;
PrimitiveInfo info = fetch_text_run_glyph(gl_InstanceID, color, uv_rect);
#ifdef WR_FEATURE_TRANSFORM
TransformVertexInfo vi = write_transform_vertex(text_run.info);
TransformVertexInfo vi = write_transform_vertex(info);
vLocalRect = vi.clipped_local_rect;
vLocalPos = vi.local_pos;
vec2 f = (vi.local_pos.xy - text_run.info.local_rect.xy) / text_run.info.local_rect.zw;
vec2 f = (vi.local_pos.xy - info.local_rect.xy) / info.local_rect.zw;
#else
VertexInfo vi = write_vertex(text_run.info);
VertexInfo vi = write_vertex(info);
vec2 f = (vi.local_clamped_pos - vi.local_rect.p0) / (vi.local_rect.p1 - vi.local_rect.p0);
#endif
@ -38,6 +21,6 @@ void main(void) {
vec2 st0 = uv_rect.xy / texture_size;
vec2 st1 = uv_rect.zw / texture_size;
vColor = text_run.color;
vColor = color;
vUv = mix(st0, st1, f);
}