use crate::Vertex;
use crate::geometry::pos2;
use std::time::Instant;
use super::coverage::{
ScanlineEdges, TriangleBoundaryIncludes, TriangleCoverage, TriangleRowStateSearch,
triangle_row_state_endpoints,
};
use super::math::{
PixelOffset, edge, edge_covers_pixel, edge_includes_boundary, edge_step_x, edge_step_y,
f32_to_u8_round_clamped, interpolate_channel_value, interpolate_color, modulate_color,
};
use super::sampling::sample_nearest;
use super::stats::RasterStats;
use super::triangle::{TRIANGLE_SCANLINE_NARROWING_MIN_AREA, TriangleVertices, triangle_positions};
use super::types::TriangleRasterBounds;
use super::{duration_as_us, usize_to_f32};
use crate::{surface::SoftwareSurface, texture::TextureImage};
const fn is_white_texel(texture_color: [u8; 4]) -> bool {
matches!(texture_color, [255, 255, 255, 255])
}
pub(super) fn rasterize_textured_triangle(
surface: &mut SoftwareSurface,
vertices: TriangleVertices<'_>,
texture: &TextureImage,
bounds: TriangleRasterBounds,
area: f32,
stats: Option<&mut RasterStats>,
) {
if let Some(stats) = stats {
stats.textured_triangle_calls += 1;
stats.textured_triangle_bbox_px += bounds.pixel_area();
stats.sampled_textured_triangle_calls += 1;
let raster_start = Instant::now();
rasterize_textured_triangle_with_stats(surface, vertices, texture, bounds, area, stats);
stats.sampled_textured_triangle_us += duration_as_us(raster_start.elapsed());
} else {
rasterize_textured_triangle_no_stats(surface, vertices, texture, bounds, area);
}
}
pub(super) fn rasterize_constant_texel_textured_triangle(
surface: &mut SoftwareSurface,
vertices: TriangleVertices<'_>,
bounds: TriangleRasterBounds,
area: f32,
texture_color: [u8; 4],
stats: Option<&mut RasterStats>,
) {
if let Some(stats) = stats {
let white_texel = is_white_texel(texture_color);
stats.textured_triangle_calls += 1;
stats.textured_triangle_bbox_px += bounds.pixel_area();
stats.constant_texel_textured_triangle_calls += 1;
if white_texel {
stats.constant_texel_textured_triangle_white_texel_calls += 1;
} else {
stats.constant_texel_textured_triangle_non_white_texel_calls += 1;
}
let raster_start = Instant::now();
rasterize_constant_texel_textured_triangle_with_stats(
surface,
vertices,
bounds,
area,
texture_color,
white_texel,
stats,
);
let elapsed_us = duration_as_us(raster_start.elapsed());
stats.constant_texel_textured_triangle_us += elapsed_us;
if white_texel {
stats.constant_texel_textured_triangle_white_texel_us += elapsed_us;
} else {
stats.constant_texel_textured_triangle_non_white_texel_us += elapsed_us;
}
} else {
rasterize_constant_texel_textured_triangle_no_stats(
surface,
vertices,
bounds,
area,
texture_color,
);
}
}
fn rasterize_constant_texel_textured_triangle_no_stats(
surface: &mut SoftwareSurface,
vertices: TriangleVertices<'_>,
bounds: TriangleRasterBounds,
area: f32,
texture_color: [u8; 4],
) {
if texture_color == [255, 255, 255, 255] {
rasterize_white_constant_texel_textured_triangle_no_stats(surface, vertices, bounds, area);
} else {
rasterize_constant_texel_textured_triangle_no_stats_with_color(
surface,
vertices,
bounds,
area,
|v0, v1, v2, w0, w1, w2| {
modulate_color(
interpolate_constant_texel_vertex_color(v0, v1, v2, w0, w1, w2),
texture_color,
)
},
);
}
}
fn rasterize_white_constant_texel_textured_triangle_no_stats(
surface: &mut SoftwareSurface,
vertices: TriangleVertices<'_>,
bounds: TriangleRasterBounds,
area: f32,
) {
if white_constant_texel_alpha_only_vertices(vertices) {
rasterize_white_constant_texel_alpha_only_textured_triangle_no_stats(
surface, vertices, bounds, area,
);
return;
}
let TriangleVertices { v0, v1, v2 } = vertices;
let raster = TriangleRasterState::new(v0, v1, v2, bounds, area);
let mut row_edge0 = raster.row_edge0;
let mut row_edge1 = raster.row_edge1;
let mut row_edge2 = raster.row_edge2;
let positions = triangle_positions(vertices);
let scanline_edges = ScanlineEdges::new(positions);
let narrow_scanlines = bounds.pixel_area() > TRIANGLE_SCANLINE_NARROWING_MIN_AREA;
let color_step = white_constant_texel_color_step(v0, v1, v2, &raster);
for y in bounds.min_y..bounds.max_y {
let (start_x, end_x) = if narrow_scanlines {
scanline_edges.x_range(bounds, usize_to_f32(y) + 0.5)
} else {
(bounds.min_x, bounds.max_x)
};
let row_start_edges = triangle_row_start_edges(
vertices,
(row_edge0, row_edge1, row_edge2),
y,
start_x,
narrow_scanlines,
);
let row_color = white_constant_texel_row_color(v0, v1, v2, &raster, row_start_edges);
let row_offset = surface.row_offset(y);
if let Some((span_start, span_end)) =
white_constant_texel_endpoint_span(&raster, row_start_edges, (start_x, end_x), false)
.span
{
emit_white_constant_texel_run_no_stats(
surface,
row_color,
color_step,
span_start - start_x,
span_end - span_start,
row_offset + span_start * 4,
);
}
advance_triangle_row_edges(&raster, &mut row_edge0, &mut row_edge1, &mut row_edge2);
}
}
fn rasterize_white_constant_texel_alpha_only_textured_triangle_no_stats(
surface: &mut SoftwareSurface,
vertices: TriangleVertices<'_>,
bounds: TriangleRasterBounds,
area: f32,
) {
let TriangleVertices { v0, v1, v2 } = vertices;
let raster = TriangleRasterState::new(v0, v1, v2, bounds, area);
let mut row_edge0 = raster.row_edge0;
let mut row_edge1 = raster.row_edge1;
let mut row_edge2 = raster.row_edge2;
let positions = triangle_positions(vertices);
let scanline_edges = ScanlineEdges::new(positions);
let narrow_scanlines = bounds.pixel_area() > TRIANGLE_SCANLINE_NARROWING_MIN_AREA;
let alpha_step = white_constant_texel_alpha_step(v0, v1, v2, &raster);
for y in bounds.min_y..bounds.max_y {
let (start_x, end_x) = if narrow_scanlines {
scanline_edges.x_range(bounds, usize_to_f32(y) + 0.5)
} else {
(bounds.min_x, bounds.max_x)
};
let row_start_edges = triangle_row_start_edges(
vertices,
(row_edge0, row_edge1, row_edge2),
y,
start_x,
narrow_scanlines,
);
let row_alpha = white_constant_texel_row_alpha(v0, v1, v2, &raster, row_start_edges);
if let Some((span_start, span_end)) =
white_constant_texel_endpoint_span(&raster, row_start_edges, (start_x, end_x), false)
.span
{
emit_white_constant_texel_alpha_only_run_no_stats(
surface,
row_alpha,
alpha_step,
AlphaOnlyRun {
alpha_offset: span_start - start_x,
len: span_end - span_start,
y,
x: span_start,
},
);
}
advance_triangle_row_edges(&raster, &mut row_edge0, &mut row_edge1, &mut row_edge2);
}
}
fn rasterize_constant_texel_textured_triangle_no_stats_with_color(
surface: &mut SoftwareSurface,
vertices: TriangleVertices<'_>,
bounds: TriangleRasterBounds,
area: f32,
pixel_color: impl Fn(&Vertex, &Vertex, &Vertex, f32, f32, f32) -> [u8; 4],
) {
let TriangleVertices { v0, v1, v2 } = vertices;
let raster = TriangleRasterState::new(v0, v1, v2, bounds, area);
let mut row_edge0 = raster.row_edge0;
let mut row_edge1 = raster.row_edge1;
let mut row_edge2 = raster.row_edge2;
let positions = triangle_positions(vertices);
let scanline_edges = ScanlineEdges::new(positions);
let narrow_scanlines = bounds.pixel_area() > TRIANGLE_SCANLINE_NARROWING_MIN_AREA;
for y in bounds.min_y..bounds.max_y {
let (start_x, end_x) = if narrow_scanlines {
scanline_edges.x_range(bounds, usize_to_f32(y) + 0.5)
} else {
(bounds.min_x, bounds.max_x)
};
let (mut pixel_edge0, mut pixel_edge1, mut pixel_edge2) = triangle_row_start_edges(
vertices,
(row_edge0, row_edge1, row_edge2),
y,
start_x,
narrow_scanlines,
);
for x in start_x..end_x {
let w0 = pixel_edge0 * raster.inv_area;
let w1 = pixel_edge1 * raster.inv_area;
let w2 = pixel_edge2 * raster.inv_area;
if edge_covers_pixel(w0, raster.edge0_includes_boundary)
&& edge_covers_pixel(w1, raster.edge1_includes_boundary)
&& edge_covers_pixel(w2, raster.edge2_includes_boundary)
{
let color = pixel_color(v0, v1, v2, w0, w1, w2);
surface.blend_pixel(x, y, color);
}
pixel_edge0 += raster.w0_step_x;
pixel_edge1 += raster.w1_step_x;
pixel_edge2 += raster.w2_step_x;
}
advance_triangle_row_edges(&raster, &mut row_edge0, &mut row_edge1, &mut row_edge2);
}
}
fn rasterize_constant_texel_textured_triangle_with_stats(
surface: &mut SoftwareSurface,
vertices: TriangleVertices<'_>,
bounds: TriangleRasterBounds,
area: f32,
texture_color: [u8; 4],
white_texel: bool,
stats: &mut RasterStats,
) {
if white_texel {
rasterize_white_constant_texel_textured_triangle_with_stats(
surface, vertices, bounds, area, stats,
);
} else {
rasterize_constant_texel_textured_triangle_with_stats_and_color(
surface,
vertices,
bounds,
area,
white_texel,
stats,
|v0, v1, v2, w0, w1, w2| {
modulate_color(
interpolate_constant_texel_vertex_color(v0, v1, v2, w0, w1, w2),
texture_color,
)
},
);
}
}
fn rasterize_white_constant_texel_textured_triangle_with_stats(
surface: &mut SoftwareSurface,
vertices: TriangleVertices<'_>,
bounds: TriangleRasterBounds,
area: f32,
stats: &mut RasterStats,
) {
let alpha_only = white_constant_texel_alpha_only_vertices(vertices);
if alpha_only {
stats.constant_texel_textured_triangle_white_alpha_only_eligible_calls += 1;
rasterize_white_constant_texel_alpha_only_textured_triangle_with_stats(
surface, vertices, bounds, area, stats,
);
return;
}
record_white_constant_texel_alpha_only_rejection(stats, vertices);
let TriangleVertices { v0, v1, v2 } = vertices;
let raster = TriangleRasterState::new(v0, v1, v2, bounds, area);
let mut row_edge0 = raster.row_edge0;
let mut row_edge1 = raster.row_edge1;
let mut row_edge2 = raster.row_edge2;
let positions = triangle_positions(vertices);
let scanline_edges = ScanlineEdges::new(positions);
let narrow_scanlines = bounds.pixel_area() > TRIANGLE_SCANLINE_NARROWING_MIN_AREA;
let color_step = white_constant_texel_color_step(v0, v1, v2, &raster);
for y in bounds.min_y..bounds.max_y {
let (start_x, end_x) = if narrow_scanlines {
scanline_edges.x_range(bounds, usize_to_f32(y) + 0.5)
} else {
(bounds.min_x, bounds.max_x)
};
let candidate_px = end_x - start_x;
record_constant_texel_textured_triangle_candidate_row(stats, bounds, candidate_px);
let (pixel_edge0, pixel_edge1, pixel_edge2) = triangle_row_start_edges(
vertices,
(row_edge0, row_edge1, row_edge2),
y,
start_x,
narrow_scanlines,
);
let row_start_edges = (pixel_edge0, pixel_edge1, pixel_edge2);
let row_color = white_constant_texel_row_color(
v0,
v1,
v2,
&raster,
(pixel_edge0, pixel_edge1, pixel_edge2),
);
let row_offset = surface.row_offset(y);
emit_white_constant_texel_endpoint_row_with_stats(
surface,
&raster,
WhiteEndpointRow {
y,
start_x,
end_x,
row_offset,
row_start_edges,
},
row_color,
color_step,
stats,
);
advance_triangle_row_edges(&raster, &mut row_edge0, &mut row_edge1, &mut row_edge2);
}
}
fn record_white_constant_texel_alpha_only_rejection(
stats: &mut RasterStats,
vertices: TriangleVertices<'_>,
) {
stats.constant_texel_textured_triangle_white_alpha_only_rejected_rgb_calls += 1;
if white_constant_texel_uniform_rgb_vertices(vertices) {
stats.constant_texel_textured_triangle_white_alpha_only_rejected_uniform_rgb_calls += 1;
} else {
stats.constant_texel_textured_triangle_white_alpha_only_rejected_varying_rgb_calls += 1;
}
}
fn record_constant_texel_textured_triangle_candidate_row(
stats: &mut RasterStats,
bounds: TriangleRasterBounds,
candidate_px: usize,
) {
stats.textured_triangle_candidate_px += candidate_px;
stats.constant_texel_textured_triangle_candidate_px += candidate_px;
if candidate_px < bounds.max_x - bounds.min_x {
stats.textured_triangle_narrowed_rows += 1;
} else {
stats.textured_triangle_full_scan_rows += 1;
}
}
#[cfg(test)]
fn record_white_constant_texel_scan_run(
start_x: usize,
end_x: usize,
scan_runs: &mut usize,
scan_span: &mut Option<(usize, usize)>,
) {
*scan_runs += 1;
if *scan_runs == 1 {
*scan_span = Some((start_x, end_x));
}
}
fn white_constant_texel_endpoint_span(
raster: &TriangleRasterState,
row_start_edges: (f32, f32, f32),
x_range: (usize, usize),
collect_stats: bool,
) -> super::coverage::TriangleRowEndpoints {
let (start_x, end_x) = x_range;
triangle_row_state_endpoints(TriangleRowStateSearch {
coverage: TriangleCoverage {
inv_area: raster.inv_area,
includes_boundary: TriangleBoundaryIncludes {
edge0: raster.edge0_includes_boundary,
edge1: raster.edge1_includes_boundary,
edge2: raster.edge2_includes_boundary,
},
},
row_start_edges,
x_steps: (raster.w0_step_x, raster.w1_step_x, raster.w2_step_x),
candidate_start_x: start_x,
candidate_end_x: end_x,
collect_stats,
})
}
#[derive(Clone, Copy)]
struct WhiteEndpointRow {
y: usize,
start_x: usize,
end_x: usize,
row_offset: usize,
row_start_edges: (f32, f32, f32),
}
fn emit_white_constant_texel_endpoint_row_with_stats(
surface: &mut SoftwareSurface,
raster: &TriangleRasterState,
row: WhiteEndpointRow,
row_color: [f32; 4],
color_step: [f32; 4],
stats: &mut RasterStats,
) {
let endpoints = white_constant_texel_endpoint_span(
raster,
row.row_start_edges,
(row.start_x, row.end_x),
false,
);
record_white_constant_texel_endpoint_render_row(stats, &endpoints);
if let Some((span_start, span_end)) = endpoints.span {
emit_white_constant_texel_run_with_stats(
surface,
row_color,
color_step,
span_start - row.start_x,
span_end - span_start,
row.row_offset + span_start * 4,
stats,
);
}
}
fn emit_white_constant_texel_alpha_only_endpoint_row_with_stats(
surface: &mut SoftwareSurface,
raster: &TriangleRasterState,
row: WhiteEndpointRow,
row_alpha: f32,
alpha_step: f32,
stats: &mut RasterStats,
) {
let endpoints = white_constant_texel_endpoint_span(
raster,
row.row_start_edges,
(row.start_x, row.end_x),
false,
);
record_white_constant_texel_endpoint_render_row(stats, &endpoints);
if let Some((span_start, span_end)) = endpoints.span {
emit_white_constant_texel_alpha_only_run_with_stats(
surface,
row_alpha,
alpha_step,
AlphaOnlyRun {
alpha_offset: span_start - row.start_x,
len: span_end - span_start,
y: row.y,
x: span_start,
},
stats,
);
}
}
fn record_white_constant_texel_endpoint_render_row(
stats: &mut RasterStats,
endpoints: &super::coverage::TriangleRowEndpoints,
) {
stats.constant_texel_textured_triangle_white_endpoint_render_rows += 1;
if let Some((endpoint_start, endpoint_end)) = endpoints.span {
stats.constant_texel_textured_triangle_white_endpoint_render_px +=
endpoint_end - endpoint_start;
}
}
fn rasterize_white_constant_texel_alpha_only_textured_triangle_with_stats(
surface: &mut SoftwareSurface,
vertices: TriangleVertices<'_>,
bounds: TriangleRasterBounds,
area: f32,
stats: &mut RasterStats,
) {
let TriangleVertices { v0, v1, v2 } = vertices;
let raster = TriangleRasterState::new(v0, v1, v2, bounds, area);
let mut row_edge0 = raster.row_edge0;
let mut row_edge1 = raster.row_edge1;
let mut row_edge2 = raster.row_edge2;
let positions = triangle_positions(vertices);
let scanline_edges = ScanlineEdges::new(positions);
let narrow_scanlines = bounds.pixel_area() > TRIANGLE_SCANLINE_NARROWING_MIN_AREA;
let alpha_step = white_constant_texel_alpha_step(v0, v1, v2, &raster);
for y in bounds.min_y..bounds.max_y {
let (start_x, end_x) = if narrow_scanlines {
scanline_edges.x_range(bounds, usize_to_f32(y) + 0.5)
} else {
(bounds.min_x, bounds.max_x)
};
let candidate_px = end_x - start_x;
record_constant_texel_textured_triangle_candidate_row(stats, bounds, candidate_px);
let row_start_edges = triangle_row_start_edges(
vertices,
(row_edge0, row_edge1, row_edge2),
y,
start_x,
narrow_scanlines,
);
let row_alpha = white_constant_texel_row_alpha(v0, v1, v2, &raster, row_start_edges);
emit_white_constant_texel_alpha_only_endpoint_row_with_stats(
surface,
&raster,
WhiteEndpointRow {
y,
start_x,
end_x,
row_offset: 0,
row_start_edges,
},
row_alpha,
alpha_step,
stats,
);
advance_triangle_row_edges(&raster, &mut row_edge0, &mut row_edge1, &mut row_edge2);
}
}
#[derive(Clone, Copy)]
struct AlphaOnlyRun {
alpha_offset: usize,
len: usize,
y: usize,
x: usize,
}
fn emit_white_constant_texel_alpha_only_run_no_stats(
surface: &mut SoftwareSurface,
row_alpha: f32,
alpha_step: f32,
run: AlphaOnlyRun,
) {
let mut pixel_offset = surface.row_offset(run.y) + run.x * 4;
for offset in 0..run.len {
let alpha = white_constant_texel_alpha_only_pixel_alpha(
row_alpha,
alpha_step,
run.alpha_offset + offset,
);
match alpha {
0 => {}
u8::MAX => surface.write_opaque_pixel_at_offset(pixel_offset, [255, 255, 255, alpha]),
_ => surface.blend_translucent_pixel_at_offset(pixel_offset, [255, 255, 255, alpha]),
}
pixel_offset += 4;
}
}
fn emit_white_constant_texel_alpha_only_run_with_stats(
surface: &mut SoftwareSurface,
row_alpha: f32,
alpha_step: f32,
run: AlphaOnlyRun,
stats: &mut RasterStats,
) {
stats.textured_triangle_covered_px += run.len;
stats.constant_texel_textured_triangle_covered_px += run.len;
stats.constant_texel_textured_triangle_white_texel_covered_px += run.len;
stats.record_constant_texel_textured_triangle_span_run(run.len);
if alpha_step == 0.0 {
stats.constant_texel_textured_triangle_white_alpha_only_constant_alpha_run_calls += 1;
stats.constant_texel_textured_triangle_white_alpha_only_constant_alpha_run_px += run.len;
stats.record_constant_texel_textured_triangle_repeated_color_opportunity(run.len);
} else {
stats.constant_texel_textured_triangle_white_alpha_only_variable_alpha_run_calls += 1;
stats.constant_texel_textured_triangle_white_alpha_only_variable_alpha_run_px += run.len;
}
let mut pixel_offset = surface.row_offset(run.y) + run.x * 4;
for offset in 0..run.len {
let alpha = white_constant_texel_alpha_only_pixel_alpha(
row_alpha,
alpha_step,
run.alpha_offset + offset,
);
match alpha {
0 => {
stats.transparent_px += 1;
stats.constant_texel_textured_triangle_transparent_px += 1;
}
u8::MAX => {
stats.opaque_px += 1;
stats.constant_texel_textured_triangle_opaque_px += 1;
surface.write_opaque_pixel_at_offset(pixel_offset, [255, 255, 255, alpha]);
}
_ => {
stats.translucent_px += 1;
stats.constant_texel_textured_triangle_translucent_px += 1;
surface.blend_translucent_pixel_at_offset(pixel_offset, [255, 255, 255, alpha]);
}
}
pixel_offset += 4;
}
}
fn emit_white_constant_texel_run_no_stats(
surface: &mut SoftwareSurface,
row_color: [f32; 4],
color_step: [f32; 4],
start_dx: usize,
len: usize,
pixel_offset: usize,
) {
if let Some(alpha) =
white_constant_texel_constant_run_alpha(row_color, color_step, start_dx, len)
{
emit_white_constant_texel_constant_alpha_run_no_stats(
surface,
row_color,
color_step,
WhiteConstantTexelRun {
start_dx,
len,
pixel_offset,
},
alpha,
);
return;
}
emit_white_constant_texel_variable_alpha_run_no_stats(
surface,
row_color,
color_step,
WhiteConstantTexelRun {
start_dx,
len,
pixel_offset,
},
);
}
#[derive(Clone, Copy)]
struct WhiteConstantTexelRun {
start_dx: usize,
len: usize,
pixel_offset: usize,
}
fn white_constant_texel_constant_run_alpha(
row_color: [f32; 4],
color_step: [f32; 4],
start_dx: usize,
len: usize,
) -> Option<u8> {
if len == 0 || !row_color[3].is_finite() || !color_step[3].is_finite() {
return None;
}
let last_dx = start_dx.checked_add(len - 1)?;
let first = white_constant_texel_pixel_alpha(row_color, color_step, start_dx);
if last_dx == start_dx {
return Some(first);
}
let last = white_constant_texel_pixel_alpha(row_color, color_step, last_dx);
(first == last).then_some(first)
}
fn emit_white_constant_texel_constant_alpha_run_no_stats(
surface: &mut SoftwareSurface,
row_color: [f32; 4],
color_step: [f32; 4],
run: WhiteConstantTexelRun,
alpha: u8,
) {
if let Some(color) = white_constant_texel_constant_run_color(row_color, color_step, run, alpha)
{
emit_white_constant_texel_constant_color_run_no_stats(surface, run, color);
return;
}
emit_white_constant_texel_variable_color_constant_alpha_run_no_stats(
surface, row_color, color_step, run, alpha,
);
}
fn white_constant_texel_constant_run_color(
row_color: [f32; 4],
color_step: [f32; 4],
run: WhiteConstantTexelRun,
alpha: u8,
) -> Option<[u8; 4]> {
if run.len == 0
|| row_color.iter().any(|value| !value.is_finite())
|| color_step.iter().any(|value| !value.is_finite())
{
return None;
}
let last_dx = run.start_dx.checked_add(run.len - 1)?;
let first =
white_constant_texel_pixel_color_with_alpha(row_color, color_step, run.start_dx, alpha);
if last_dx == run.start_dx {
return Some(first);
}
let last_offset = usize_to_f32(last_dx);
(0..3)
.all(|channel| {
f32_to_u8_round_clamped(color_step[channel].mul_add(last_offset, row_color[channel]))
== first[channel]
})
.then_some(first)
}
fn emit_white_constant_texel_constant_color_run_no_stats(
surface: &mut SoftwareSurface,
run: WhiteConstantTexelRun,
color: [u8; 4],
) {
surface.blend_constant_color_span_at_offset(run.pixel_offset, run.len, color);
}
fn emit_white_constant_texel_variable_color_constant_alpha_run_no_stats(
surface: &mut SoftwareSurface,
row_color: [f32; 4],
color_step: [f32; 4],
run: WhiteConstantTexelRun,
alpha: u8,
) {
if alpha != 0 {
emit_white_gradient_run(surface, row_color, color_step, run, Some(alpha));
}
}
fn emit_white_constant_texel_variable_alpha_run_no_stats(
surface: &mut SoftwareSurface,
row_color: [f32; 4],
color_step: [f32; 4],
run: WhiteConstantTexelRun,
) {
emit_white_gradient_run(surface, row_color, color_step, run, None);
}
fn emit_white_gradient_run(
surface: &mut SoftwareSurface,
row_color: [f32; 4],
color_step: [f32; 4],
run: WhiteConstantTexelRun,
constant_alpha: Option<u8>,
) {
let mut pixel_offset = run.pixel_offset;
let mut dx = PixelOffset::new(run.start_dx);
let mut remaining = run.len;
while remaining > 0 {
let block = u8::try_from(remaining.min(4)).unwrap_or(4);
if blend_white_gradient_rgba4_neon(
surface,
pixel_offset,
block,
WhiteGradient {
row_color,
color_step,
dx,
constant_alpha,
},
) {
pixel_offset += usize::from(block) * 4;
dx.advance_by(block);
remaining -= usize::from(block);
continue;
}
let mut color = white_constant_texel_pixel_rgba(row_color, color_step, dx.get());
if let Some(alpha) = constant_alpha {
color[3] = alpha;
}
match color[3] {
0 => {}
u8::MAX => surface.write_opaque_pixel_at_offset(pixel_offset, color),
_ => surface.blend_translucent_pixel_at_offset(pixel_offset, color),
}
pixel_offset += 4;
dx.advance();
remaining -= 1;
}
}
#[cfg_attr(
not(all(target_arch = "aarch64", target_endian = "little")),
allow(dead_code)
)]
#[derive(Clone, Copy)]
struct WhiteGradient {
row_color: [f32; 4],
color_step: [f32; 4],
dx: PixelOffset,
constant_alpha: Option<u8>,
}
#[cfg(not(all(target_arch = "aarch64", target_endian = "little")))]
const fn blend_white_gradient_rgba4_neon(
_surface: &mut SoftwareSurface,
_pixel_offset: usize,
_pixels: u8,
_gradient: WhiteGradient,
) -> bool {
false
}
#[cfg(all(target_arch = "aarch64", target_endian = "little"))]
fn blend_white_gradient_rgba4_neon(
surface: &mut SoftwareSurface,
pixel_offset: usize,
pixels: u8,
gradient: WhiteGradient,
) -> bool {
use core::arch::aarch64::{
uint8x8_t, uint16x8_t, vaddq_f32, vaddq_u16, vandq_u8, vbslq_u8, vceqq_u8, vcltq_u8,
vcombine_u8, vcombine_u16, vcvtq_u32_f32, vdup_n_u8, vdup_n_u16, vdupq_n_f32, vdupq_n_u8,
vdupq_n_u16, vfmaq_f32, vget_low_u8, vld1q_f32, vld1q_u8, vminq_f32, vmovn_u16,
vmull_high_u8, vmull_u8, vmvnq_u8, vorrq_u8, vqaddq_u8, vqmovn_u16, vqmovn_u32, vqtbl1q_u8,
vreinterpret_u8_u16, vreinterpret_u16_u8, vrndaq_f32, vshrq_n_u16, vst1q_u8, vzip1_u8,
vzip1_u16, vzip2_u16,
};
const LANE_OFFSETS: [f32; 4] = [0.0, 1.0, 2.0, 3.0];
const BYTE_INDEX: [u8; 16] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
const ALPHA_BROADCAST: [u8; 16] = [3, 3, 3, 3, 7, 7, 7, 7, 11, 11, 11, 11, 15, 15, 15, 15];
const ALPHA_BYTES: [u8; 16] = [0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 255];
unsafe fn divide_product(product: uint16x8_t) -> uint8x8_t {
let biased = unsafe { vaddq_u16(product, vdupq_n_u16(128)) };
let correction = unsafe { vshrq_n_u16(biased, 8) };
let quotient = unsafe { vshrq_n_u16(vaddq_u16(biased, correction), 8) };
unsafe { vmovn_u16(quotient) }
}
debug_assert!((1..=4).contains(&pixels));
let Some(destination_bytes) = surface.pixels.get_mut(pixel_offset..pixel_offset + 16) else {
return false;
};
let WhiteGradient {
row_color,
color_step,
dx,
constant_alpha,
} = gradient;
unsafe {
let offsets = vminq_f32(
vaddq_f32(vdupq_n_f32(dx.raw()), vld1q_f32(LANE_OFFSETS.as_ptr())),
vdupq_n_f32(f32::from(u16::MAX)),
);
let channel = |index: usize| -> uint8x8_t {
let value = vfmaq_f32(
vdupq_n_f32(row_color[index]),
vdupq_n_f32(color_step[index]),
offsets,
);
let words = vcvtq_u32_f32(vrndaq_f32(value));
vqmovn_u16(vcombine_u16(vqmovn_u32(words), vdup_n_u16(0)))
};
let (red, green, blue) = (channel(0), channel(1), channel(2));
let alpha = constant_alpha.map_or_else(|| channel(3), |alpha| vdup_n_u8(alpha));
let red_green = vreinterpret_u16_u8(vzip1_u8(red, green));
let blue_alpha = vreinterpret_u16_u8(vzip1_u8(blue, alpha));
let source = vcombine_u8(
vreinterpret_u8_u16(vzip1_u16(red_green, blue_alpha)),
vreinterpret_u8_u16(vzip2_u16(red_green, blue_alpha)),
);
let live = vcltq_u8(vld1q_u8(BYTE_INDEX.as_ptr()), vdupq_n_u8(pixels * 4));
let source = vandq_u8(source, live);
let source_alpha = vqtbl1q_u8(source, vld1q_u8(ALPHA_BROADCAST.as_ptr()));
let inverse_alpha = vmvnq_u8(source_alpha);
let destination = vld1q_u8(destination_bytes.as_ptr());
let blend = vcombine_u8(
divide_product(vmull_u8(
vget_low_u8(destination),
vget_low_u8(inverse_alpha),
)),
divide_product(vmull_high_u8(destination, inverse_alpha)),
);
let blended = vorrq_u8(vqaddq_u8(source, blend), vld1q_u8(ALPHA_BYTES.as_ptr()));
let transparent = vceqq_u8(source_alpha, vdupq_n_u8(0));
vst1q_u8(
destination_bytes.as_mut_ptr(),
vbslq_u8(transparent, destination, blended),
);
}
true
}
fn emit_white_constant_texel_run_with_stats(
surface: &mut SoftwareSurface,
row_color: [f32; 4],
color_step: [f32; 4],
start_dx: usize,
len: usize,
pixel_offset: usize,
stats: &mut RasterStats,
) {
stats.textured_triangle_covered_px += len;
stats.constant_texel_textured_triangle_covered_px += len;
stats.constant_texel_textured_triangle_white_texel_covered_px += len;
stats.record_constant_texel_textured_triangle_span_run(len);
let run = WhiteConstantTexelRun {
start_dx,
len,
pixel_offset,
};
if let Some(alpha) =
white_constant_texel_constant_run_alpha(row_color, color_step, start_dx, len)
{
stats.constant_texel_textured_triangle_white_constant_alpha_run_calls += 1;
stats.constant_texel_textured_triangle_white_constant_alpha_run_px += len;
stats.record_alpha_px(alpha, len);
stats.record_constant_texel_alpha_px(alpha, len);
if let Some(color) =
white_constant_texel_constant_run_color(row_color, color_step, run, alpha)
{
stats.constant_texel_textured_triangle_white_constant_color_run_calls += 1;
stats.constant_texel_textured_triangle_white_constant_color_run_px += len;
stats.record_constant_texel_textured_triangle_repeated_color_opportunity(len);
stats.record_constant_texel_textured_triangle_repeated_color_helper_use(len, alpha);
emit_white_constant_texel_constant_color_run_no_stats(surface, run, color);
} else {
stats.constant_texel_textured_triangle_white_variable_color_run_calls += 1;
stats.constant_texel_textured_triangle_white_variable_color_run_px += len;
emit_white_constant_texel_variable_color_constant_alpha_run_no_stats(
surface, row_color, color_step, run, alpha,
);
}
return;
}
stats.constant_texel_textured_triangle_white_variable_alpha_run_calls += 1;
stats.constant_texel_textured_triangle_white_variable_alpha_run_px += len;
emit_white_constant_texel_variable_alpha_run_with_stats(
surface, row_color, color_step, run, stats,
);
}
fn emit_white_constant_texel_variable_alpha_run_with_stats(
surface: &mut SoftwareSurface,
row_color: [f32; 4],
color_step: [f32; 4],
run: WhiteConstantTexelRun,
stats: &mut RasterStats,
) {
let mut pixel_offset = run.pixel_offset;
for run_dx in 0..run.len {
let dx = run.start_dx + run_dx;
let alpha = white_constant_texel_pixel_alpha(row_color, color_step, dx);
match alpha {
0 => {
stats.transparent_px += 1;
stats.constant_texel_textured_triangle_transparent_px += 1;
}
u8::MAX => {
stats.opaque_px += 1;
stats.constant_texel_textured_triangle_opaque_px += 1;
let color =
white_constant_texel_pixel_color_with_alpha(row_color, color_step, dx, alpha);
surface.write_opaque_pixel_at_offset(pixel_offset, color);
}
_ => {
stats.translucent_px += 1;
stats.constant_texel_textured_triangle_translucent_px += 1;
let color =
white_constant_texel_pixel_color_with_alpha(row_color, color_step, dx, alpha);
surface.blend_translucent_pixel_at_offset(pixel_offset, color);
}
}
pixel_offset += 4;
}
}
fn rasterize_constant_texel_textured_triangle_with_stats_and_color(
surface: &mut SoftwareSurface,
vertices: TriangleVertices<'_>,
bounds: TriangleRasterBounds,
area: f32,
white_texel: bool,
stats: &mut RasterStats,
pixel_color: impl Fn(&Vertex, &Vertex, &Vertex, f32, f32, f32) -> [u8; 4],
) {
let TriangleVertices { v0, v1, v2 } = vertices;
let raster = TriangleRasterState::new(v0, v1, v2, bounds, area);
let mut row_edge0 = raster.row_edge0;
let mut row_edge1 = raster.row_edge1;
let mut row_edge2 = raster.row_edge2;
let positions = triangle_positions(vertices);
let scanline_edges = ScanlineEdges::new(positions);
let narrow_scanlines = bounds.pixel_area() > TRIANGLE_SCANLINE_NARROWING_MIN_AREA;
for y in bounds.min_y..bounds.max_y {
let (start_x, end_x) = if narrow_scanlines {
scanline_edges.x_range(bounds, usize_to_f32(y) + 0.5)
} else {
(bounds.min_x, bounds.max_x)
};
let candidate_px = end_x - start_x;
stats.textured_triangle_candidate_px += candidate_px;
stats.constant_texel_textured_triangle_candidate_px += candidate_px;
if candidate_px < bounds.max_x - bounds.min_x {
stats.textured_triangle_narrowed_rows += 1;
} else {
stats.textured_triangle_full_scan_rows += 1;
}
let (mut pixel_edge0, mut pixel_edge1, mut pixel_edge2) = if narrow_scanlines {
let pixel_center = pos2(usize_to_f32(start_x) + 0.5, usize_to_f32(y) + 0.5);
(
edge(v1.pos2(), v2.pos2(), pixel_center),
edge(v2.pos2(), v0.pos2(), pixel_center),
edge(v0.pos2(), v1.pos2(), pixel_center),
)
} else {
(row_edge0, row_edge1, row_edge2)
};
let mut span_len = 0;
let mut repeated_color_len = 0;
let mut previous_color = [0; 4];
for x in start_x..end_x {
let w0 = pixel_edge0 * raster.inv_area;
let w1 = pixel_edge1 * raster.inv_area;
let w2 = pixel_edge2 * raster.inv_area;
if edge_covers_pixel(w0, raster.edge0_includes_boundary)
&& edge_covers_pixel(w1, raster.edge1_includes_boundary)
&& edge_covers_pixel(w2, raster.edge2_includes_boundary)
{
let color = pixel_color(v0, v1, v2, w0, w1, w2);
if span_len == 0 {
previous_color = color;
repeated_color_len = 1;
} else if color == previous_color {
repeated_color_len += 1;
} else {
stats.record_constant_texel_textured_triangle_repeated_color_opportunity(
repeated_color_len,
);
previous_color = color;
repeated_color_len = 1;
}
span_len += 1;
surface.blend_pixel(x, y, color);
stats.textured_triangle_covered_px += 1;
stats.constant_texel_textured_triangle_covered_px += 1;
if white_texel {
stats.constant_texel_textured_triangle_white_texel_covered_px += 1;
} else {
stats.constant_texel_textured_triangle_non_white_texel_covered_px += 1;
}
stats.record_alpha_px(color[3], 1);
stats.record_constant_texel_alpha_px(color[3], 1);
} else if span_len != 0 {
stats.record_constant_texel_textured_triangle_span_run(span_len);
stats.record_constant_texel_textured_triangle_repeated_color_opportunity(
repeated_color_len,
);
span_len = 0;
repeated_color_len = 0;
}
pixel_edge0 += raster.w0_step_x;
pixel_edge1 += raster.w1_step_x;
pixel_edge2 += raster.w2_step_x;
}
if span_len != 0 {
stats.record_constant_texel_textured_triangle_span_run(span_len);
stats.record_constant_texel_textured_triangle_repeated_color_opportunity(
repeated_color_len,
);
}
row_edge0 += raster.w0_step_y;
row_edge1 += raster.w1_step_y;
row_edge2 += raster.w2_step_y;
}
}
fn rasterize_textured_triangle_no_stats(
surface: &mut SoftwareSurface,
vertices: TriangleVertices<'_>,
texture: &TextureImage,
bounds: TriangleRasterBounds,
area: f32,
) {
let TriangleVertices { v0, v1, v2 } = vertices;
let raster = TriangleRasterState::new(v0, v1, v2, bounds, area);
let mut row_edge0 = raster.row_edge0;
let mut row_edge1 = raster.row_edge1;
let mut row_edge2 = raster.row_edge2;
let positions = triangle_positions(vertices);
let scanline_edges = ScanlineEdges::new(positions);
let narrow_scanlines = bounds.pixel_area() > TRIANGLE_SCANLINE_NARROWING_MIN_AREA;
for y in bounds.min_y..bounds.max_y {
let (start_x, end_x) = if narrow_scanlines {
scanline_edges.x_range(bounds, usize_to_f32(y) + 0.5)
} else {
(bounds.min_x, bounds.max_x)
};
let (mut pixel_edge0, mut pixel_edge1, mut pixel_edge2) = if narrow_scanlines {
let pixel_center = pos2(usize_to_f32(start_x) + 0.5, usize_to_f32(y) + 0.5);
(
edge(v1.pos2(), v2.pos2(), pixel_center),
edge(v2.pos2(), v0.pos2(), pixel_center),
edge(v0.pos2(), v1.pos2(), pixel_center),
)
} else {
(row_edge0, row_edge1, row_edge2)
};
for x in start_x..end_x {
let w0 = pixel_edge0 * raster.inv_area;
let w1 = pixel_edge1 * raster.inv_area;
let w2 = pixel_edge2 * raster.inv_area;
if edge_covers_pixel(w0, raster.edge0_includes_boundary)
&& edge_covers_pixel(w1, raster.edge1_includes_boundary)
&& edge_covers_pixel(w2, raster.edge2_includes_boundary)
{
let color = textured_triangle_pixel_color(v0, v1, v2, texture, w0, w1, w2);
surface.blend_pixel(x, y, color);
}
pixel_edge0 += raster.w0_step_x;
pixel_edge1 += raster.w1_step_x;
pixel_edge2 += raster.w2_step_x;
}
row_edge0 += raster.w0_step_y;
row_edge1 += raster.w1_step_y;
row_edge2 += raster.w2_step_y;
}
}
fn rasterize_textured_triangle_with_stats(
surface: &mut SoftwareSurface,
vertices: TriangleVertices<'_>,
texture: &TextureImage,
bounds: TriangleRasterBounds,
area: f32,
stats: &mut RasterStats,
) {
let TriangleVertices { v0, v1, v2 } = vertices;
let raster = TriangleRasterState::new(v0, v1, v2, bounds, area);
let mut row_edge0 = raster.row_edge0;
let mut row_edge1 = raster.row_edge1;
let mut row_edge2 = raster.row_edge2;
let positions = triangle_positions(vertices);
let scanline_edges = ScanlineEdges::new(positions);
let narrow_scanlines = bounds.pixel_area() > TRIANGLE_SCANLINE_NARROWING_MIN_AREA;
for y in bounds.min_y..bounds.max_y {
let (start_x, end_x) = if narrow_scanlines {
scanline_edges.x_range(bounds, usize_to_f32(y) + 0.5)
} else {
(bounds.min_x, bounds.max_x)
};
let candidate_px = end_x - start_x;
stats.textured_triangle_candidate_px += candidate_px;
stats.sampled_textured_triangle_candidate_px += candidate_px;
if candidate_px < bounds.max_x - bounds.min_x {
stats.textured_triangle_narrowed_rows += 1;
} else {
stats.textured_triangle_full_scan_rows += 1;
}
let (mut pixel_edge0, mut pixel_edge1, mut pixel_edge2) = if narrow_scanlines {
let pixel_center = pos2(usize_to_f32(start_x) + 0.5, usize_to_f32(y) + 0.5);
(
edge(v1.pos2(), v2.pos2(), pixel_center),
edge(v2.pos2(), v0.pos2(), pixel_center),
edge(v0.pos2(), v1.pos2(), pixel_center),
)
} else {
(row_edge0, row_edge1, row_edge2)
};
for x in start_x..end_x {
let w0 = pixel_edge0 * raster.inv_area;
let w1 = pixel_edge1 * raster.inv_area;
let w2 = pixel_edge2 * raster.inv_area;
if edge_covers_pixel(w0, raster.edge0_includes_boundary)
&& edge_covers_pixel(w1, raster.edge1_includes_boundary)
&& edge_covers_pixel(w2, raster.edge2_includes_boundary)
{
let color = textured_triangle_pixel_color(v0, v1, v2, texture, w0, w1, w2);
surface.blend_pixel(x, y, color);
stats.textured_triangle_covered_px += 1;
stats.sampled_textured_triangle_covered_px += 1;
stats.record_alpha_px(color[3], 1);
}
pixel_edge0 += raster.w0_step_x;
pixel_edge1 += raster.w1_step_x;
pixel_edge2 += raster.w2_step_x;
}
row_edge0 += raster.w0_step_y;
row_edge1 += raster.w1_step_y;
row_edge2 += raster.w2_step_y;
}
}
struct TriangleRasterState {
inv_area: f32,
w0_step_x: f32,
w1_step_x: f32,
w2_step_x: f32,
w0_step_y: f32,
w1_step_y: f32,
w2_step_y: f32,
row_edge0: f32,
row_edge1: f32,
row_edge2: f32,
edge0_includes_boundary: bool,
edge1_includes_boundary: bool,
edge2_includes_boundary: bool,
}
impl TriangleRasterState {
fn new(v0: &Vertex, v1: &Vertex, v2: &Vertex, bounds: TriangleRasterBounds, area: f32) -> Self {
let start = pos2(
usize_to_f32(bounds.min_x) + 0.5,
usize_to_f32(bounds.min_y) + 0.5,
);
Self {
inv_area: 1.0 / area,
w0_step_x: edge_step_x(v1.pos2(), v2.pos2()),
w1_step_x: edge_step_x(v2.pos2(), v0.pos2()),
w2_step_x: edge_step_x(v0.pos2(), v1.pos2()),
w0_step_y: edge_step_y(v1.pos2(), v2.pos2()),
w1_step_y: edge_step_y(v2.pos2(), v0.pos2()),
w2_step_y: edge_step_y(v0.pos2(), v1.pos2()),
row_edge0: edge(v1.pos2(), v2.pos2(), start),
row_edge1: edge(v2.pos2(), v0.pos2(), start),
row_edge2: edge(v0.pos2(), v1.pos2(), start),
edge0_includes_boundary: edge_includes_boundary(v1.pos2(), v2.pos2(), area),
edge1_includes_boundary: edge_includes_boundary(v2.pos2(), v0.pos2(), area),
edge2_includes_boundary: edge_includes_boundary(v0.pos2(), v1.pos2(), area),
}
}
}
#[cfg(test)]
fn triangle_raster_state_covers_pixel(
raster: &TriangleRasterState,
w0: f32,
w1: f32,
w2: f32,
) -> bool {
edge_covers_pixel(w0, raster.edge0_includes_boundary)
&& edge_covers_pixel(w1, raster.edge1_includes_boundary)
&& edge_covers_pixel(w2, raster.edge2_includes_boundary)
}
#[cfg(test)]
fn triangle_raster_state_covers_row_dx(
raster: &TriangleRasterState,
row_start_edges: (f32, f32, f32),
dx: usize,
) -> bool {
let (edge0, edge1, edge2) = triangle_raster_state_row_edges_at_dx(raster, row_start_edges, dx);
triangle_raster_state_covers_pixel(
raster,
edge0 * raster.inv_area,
edge1 * raster.inv_area,
edge2 * raster.inv_area,
)
}
#[cfg(test)]
fn triangle_raster_state_row_edges_at_dx(
raster: &TriangleRasterState,
row_start_edges: (f32, f32, f32),
dx: usize,
) -> (f32, f32, f32) {
let dx = usize_to_f32(dx);
(
row_start_edges.0 + raster.w0_step_x * dx,
row_start_edges.1 + raster.w1_step_x * dx,
row_start_edges.2 + raster.w2_step_x * dx,
)
}
fn advance_triangle_row_edges(
raster: &TriangleRasterState,
row_edge0: &mut f32,
row_edge1: &mut f32,
row_edge2: &mut f32,
) {
*row_edge0 += raster.w0_step_y;
*row_edge1 += raster.w1_step_y;
*row_edge2 += raster.w2_step_y;
}
fn triangle_row_start_edges(
vertices: TriangleVertices<'_>,
row_edges: (f32, f32, f32),
y: usize,
start_x: usize,
narrow_scanlines: bool,
) -> (f32, f32, f32) {
if narrow_scanlines {
let TriangleVertices { v0, v1, v2 } = vertices;
let pixel_center = pos2(usize_to_f32(start_x) + 0.5, usize_to_f32(y) + 0.5);
(
edge(v1.pos2(), v2.pos2(), pixel_center),
edge(v2.pos2(), v0.pos2(), pixel_center),
edge(v0.pos2(), v1.pos2(), pixel_center),
)
} else {
row_edges
}
}
#[cfg(test)]
fn white_constant_texel_pixel_color(
row_color: [f32; 4],
color_step: [f32; 4],
dx: usize,
) -> [u8; 4] {
let alpha = white_constant_texel_pixel_alpha(row_color, color_step, dx);
white_constant_texel_pixel_color_with_alpha(row_color, color_step, dx, alpha)
}
fn white_constant_texel_pixel_color_with_alpha(
row_color: [f32; 4],
color_step: [f32; 4],
dx: usize,
alpha: u8,
) -> [u8; 4] {
let dx = usize_to_f32(dx);
[
f32_to_u8_round_clamped(color_step[0].mul_add(dx, row_color[0])),
f32_to_u8_round_clamped(color_step[1].mul_add(dx, row_color[1])),
f32_to_u8_round_clamped(color_step[2].mul_add(dx, row_color[2])),
alpha,
]
}
fn white_constant_texel_pixel_rgba(row_color: [f32; 4], color_step: [f32; 4], dx: f32) -> [u8; 4] {
let mut rgba = [0; 4];
for ((channel, step), row) in rgba.iter_mut().zip(color_step).zip(row_color) {
*channel = f32_to_u8_round_clamped(step.mul_add(dx, row));
}
rgba
}
fn white_constant_texel_pixel_alpha(row_color: [f32; 4], color_step: [f32; 4], dx: usize) -> u8 {
f32_to_u8_round_clamped(color_step[3].mul_add(usize_to_f32(dx), row_color[3]))
}
fn white_constant_texel_alpha_only_pixel_alpha(row_alpha: f32, alpha_step: f32, dx: usize) -> u8 {
f32_to_u8_round_clamped(alpha_step.mul_add(usize_to_f32(dx), row_alpha))
}
pub(super) fn white_constant_texel_alpha_only_vertices(vertices: TriangleVertices<'_>) -> bool {
let TriangleVertices { v0, v1, v2 } = vertices;
[v0, v1, v2]
.iter()
.all(|vertex| vertex.color.r == 255 && vertex.color.g == 255 && vertex.color.b == 255)
}
fn white_constant_texel_uniform_rgb_vertices(vertices: TriangleVertices<'_>) -> bool {
let TriangleVertices { v0, v1, v2 } = vertices;
v0.color.r == v1.color.r
&& v0.color.r == v2.color.r
&& v0.color.g == v1.color.g
&& v0.color.g == v2.color.g
&& v0.color.b == v1.color.b
&& v0.color.b == v2.color.b
}
fn white_constant_texel_row_alpha(
v0: &Vertex,
v1: &Vertex,
v2: &Vertex,
raster: &TriangleRasterState,
row_edges: (f32, f32, f32),
) -> f32 {
let w0 = row_edges.0 * raster.inv_area;
let w1 = row_edges.1 * raster.inv_area;
let w2 = row_edges.2 * raster.inv_area;
interpolate_channel_value(v0.color.a, v1.color.a, v2.color.a, w0, w1, w2)
}
fn white_constant_texel_row_color(
v0: &Vertex,
v1: &Vertex,
v2: &Vertex,
raster: &TriangleRasterState,
row_edges: (f32, f32, f32),
) -> [f32; 4] {
let w0 = row_edges.0 * raster.inv_area;
let w1 = row_edges.1 * raster.inv_area;
let w2 = row_edges.2 * raster.inv_area;
[
interpolate_channel_value(v0.color.r, v1.color.r, v2.color.r, w0, w1, w2),
interpolate_channel_value(v0.color.g, v1.color.g, v2.color.g, w0, w1, w2),
interpolate_channel_value(v0.color.b, v1.color.b, v2.color.b, w0, w1, w2),
interpolate_channel_value(v0.color.a, v1.color.a, v2.color.a, w0, w1, w2),
]
}
fn white_constant_texel_color_step(
v0: &Vertex,
v1: &Vertex,
v2: &Vertex,
raster: &TriangleRasterState,
) -> [f32; 4] {
let w0_step = raster.w0_step_x * raster.inv_area;
let w1_step = raster.w1_step_x * raster.inv_area;
let w2_step = raster.w2_step_x * raster.inv_area;
[
interpolate_channel_value(
v0.color.r, v1.color.r, v2.color.r, w0_step, w1_step, w2_step,
),
interpolate_channel_value(
v0.color.g, v1.color.g, v2.color.g, w0_step, w1_step, w2_step,
),
interpolate_channel_value(
v0.color.b, v1.color.b, v2.color.b, w0_step, w1_step, w2_step,
),
interpolate_channel_value(
v0.color.a, v1.color.a, v2.color.a, w0_step, w1_step, w2_step,
),
]
}
fn white_constant_texel_alpha_step(
v0: &Vertex,
v1: &Vertex,
v2: &Vertex,
raster: &TriangleRasterState,
) -> f32 {
let w0_step = raster.w0_step_x * raster.inv_area;
let w1_step = raster.w1_step_x * raster.inv_area;
let w2_step = raster.w2_step_x * raster.inv_area;
interpolate_channel_value(
v0.color.a, v1.color.a, v2.color.a, w0_step, w1_step, w2_step,
)
}
pub(super) fn textured_triangle_pixel_color(
v0: &Vertex,
v1: &Vertex,
v2: &Vertex,
texture: &TextureImage,
w0: f32,
w1: f32,
w2: f32,
) -> [u8; 4] {
let uv = pos2(
v0.uv2()
.x
.mul_add(w0, v1.uv2().x.mul_add(w1, v2.uv2().x * w2)),
v0.uv2()
.y
.mul_add(w0, v1.uv2().y.mul_add(w1, v2.uv2().y * w2)),
);
let vertex_color = interpolate_color(v0.color, v1.color, v2.color, w0, w1, w2);
let texture_color = sample_nearest(texture, uv);
modulate_color(vertex_color, texture_color)
}
fn interpolate_constant_texel_vertex_color(
v0: &Vertex,
v1: &Vertex,
v2: &Vertex,
w0: f32,
w1: f32,
w2: f32,
) -> [u8; 4] {
interpolate_color(v0.color, v1.color, v2.color, w0, w1, w2)
}
#[cfg(test)]
mod tests {
use super::*;
#[cfg(all(target_arch = "aarch64", target_endian = "little"))]
#[test]
fn white_gradient_neon_blocks_match_scalar_pixels() {
let mut state = 0x2545_f491_u32;
let mut next = move || {
state ^= state << 13;
state ^= state >> 17;
state ^= state << 5;
state
};
let mut unit = move || f32::from(u16::try_from(next() >> 16).unwrap_or(0)) / 65_535.0;
for case in 0..20_000_u32 {
let pixels = u8::try_from(1 + case % 4).unwrap_or(1);
let row_color = [0; 4].map(|_: u8| unit() * 300.0 - 20.0);
let color_step = [0; 4].map(|_: u8| unit() * 40.0 - 20.0);
let start_dx = if case % 7 == 0 {
65_533 + (case as usize % 5)
} else {
case as usize % 400
};
let constant_alpha = match case % 5 {
0 => Some(255),
1 => Some(u8::try_from(1 + case % 254).unwrap_or(1)),
_ => None,
};
let destination: Vec<u8> = (0..16)
.map(|_| u8::try_from(next() >> 24).unwrap_or(0))
.collect();
let gradient = WhiteGradient {
row_color,
color_step,
dx: PixelOffset::new(start_dx),
constant_alpha,
};
let mut actual = SoftwareSurface {
width: 4,
height: 1,
pixels: destination.clone(),
};
assert!(blend_white_gradient_rgba4_neon(
&mut actual,
0,
pixels,
gradient
));
let mut expected = SoftwareSurface {
width: 4,
height: 1,
pixels: destination,
};
let mut dx = PixelOffset::new(start_dx);
for pixel in 0..usize::from(pixels) {
let mut color = white_constant_texel_pixel_rgba(row_color, color_step, dx.get());
if let Some(alpha) = constant_alpha {
color[3] = alpha;
}
match color[3] {
0 => {}
u8::MAX => expected.write_opaque_pixel_at_offset(pixel * 4, color),
_ => expected.blend_translucent_pixel_at_offset(pixel * 4, color),
}
dx.advance();
}
assert_eq!(
actual.pixels, expected.pixels,
"case={case} pixels={pixels} row={row_color:?} step={color_step:?} dx={start_dx}"
);
}
}
use crate::Color;
use crate::geometry::Pos2;
use crate::raster::math::{f32_to_usize_ceil_clamped, f32_to_usize_floor_clamped};
#[test]
fn constant_alpha_only_runs_match_reference_for_translucent_alpha() {
assert_constant_alpha_only_run_matches_reference(117.4, 0.0, 3, 8, 2, 5);
}
#[test]
fn constant_alpha_only_runs_match_reference_for_transparent_alpha() {
assert_constant_alpha_only_run_matches_reference(-12.0, 0.0, 4, 7, 1, 6);
}
#[test]
fn constant_alpha_only_runs_match_reference_for_opaque_alpha() {
assert_constant_alpha_only_run_matches_reference(300.0, 0.0, 2, 9, 3, 4);
}
#[test]
fn variable_alpha_only_runs_match_reference_and_classify_counters() {
let row_alpha = 63.25;
let alpha_step = 7.5;
let alpha_offset = 2;
let len = 11;
let y = 2;
let x = 3;
let run = AlphaOnlyRun {
alpha_offset,
len,
y,
x,
};
let mut actual = test_surface(18, 6);
let mut actual_no_stats = test_surface(18, 6);
let mut reference = test_surface(18, 6);
let mut stats = RasterStats::default();
emit_white_constant_texel_alpha_only_run_with_stats(
&mut actual,
row_alpha,
alpha_step,
run,
&mut stats,
);
emit_white_constant_texel_alpha_only_run_no_stats(
&mut actual_no_stats,
row_alpha,
alpha_step,
run,
);
emit_white_constant_texel_alpha_only_run_reference(
&mut reference,
row_alpha,
alpha_step,
run,
);
assert_eq!(actual.pixels, reference.pixels);
assert_eq!(actual_no_stats.pixels, reference.pixels);
assert_eq!(
stats.constant_texel_textured_triangle_white_alpha_only_constant_alpha_run_calls,
0
);
assert_eq!(
stats.constant_texel_textured_triangle_white_alpha_only_constant_alpha_run_px,
0
);
assert_eq!(
stats.constant_texel_textured_triangle_white_alpha_only_variable_alpha_run_calls,
1
);
assert_eq!(
stats.constant_texel_textured_triangle_white_alpha_only_variable_alpha_run_px,
len
);
assert_eq!(stats.textured_triangle_covered_px, len);
assert_alpha_stats_match_run(&stats, row_alpha, alpha_step, alpha_offset, len);
}
#[test]
fn white_constant_texel_runs_match_reference_for_transparent_alpha() {
assert_white_constant_texel_run_matches_reference(
[20.0, 40.0, 60.0, -8.0],
[0.0, 0.0, 0.0, 0.0],
2,
8,
(2, 4),
AlphaRunKind::Constant(0),
ColorRunKind::Constant([20, 40, 60, 0]),
);
}
#[test]
fn white_constant_texel_runs_match_reference_for_opaque_alpha() {
assert_white_constant_texel_run_matches_reference(
[20.0, 40.0, 60.0, 260.0],
[0.0, 0.0, 0.0, 0.0],
2,
8,
(2, 4),
AlphaRunKind::Constant(u8::MAX),
ColorRunKind::Constant([20, 40, 60, u8::MAX]),
);
}
#[test]
fn white_constant_texel_runs_match_reference_for_translucent_alpha() {
assert_white_constant_texel_run_matches_reference(
[20.0, 40.0, 60.0, 117.4],
[0.0, 0.0, 0.0, 0.0],
2,
8,
(2, 4),
AlphaRunKind::Constant(117),
ColorRunKind::Constant([20, 40, 60, 117]),
);
}
#[test]
fn white_constant_texel_variable_alpha_runs_match_reference_and_fallback() {
assert_white_constant_texel_run_matches_reference(
[12.0, 220.0, 40.0, 63.25],
[2.5, -3.0, 1.25, 7.5],
2,
11,
(2, 3),
AlphaRunKind::Variable,
ColorRunKind::Variable,
);
}
#[test]
fn white_constant_texel_negative_alpha_step_fixed_rounding_matches_reference() {
assert_white_constant_texel_run_matches_reference(
[12.0, 220.0, 40.0, 128.49],
[2.5, -3.0, 1.25, -0.03],
4,
5,
(2, 3),
AlphaRunKind::Constant(128),
ColorRunKind::Variable,
);
}
#[test]
fn white_constant_texel_nonzero_start_dx_matches_reference() {
assert_white_constant_texel_run_matches_reference(
[12.0, 220.0, 40.0, 73.2],
[2.5, -3.0, 1.25, 0.01],
7,
9,
(2, 3),
AlphaRunKind::Constant(73),
ColorRunKind::Variable,
);
}
#[test]
fn white_constant_texel_len_one_matches_reference() {
assert_white_constant_texel_run_matches_reference(
[12.0, 220.0, 40.0, 41.2],
[2.5, -3.0, 1.25, 12.0],
6,
1,
(2, 3),
AlphaRunKind::Constant(113),
ColorRunKind::Constant([27, 202, 48, 113]),
);
}
#[test]
fn constant_texel_span_buckets_and_alpha_counts_use_emitted_runs() {
let mut surface = test_surface(80, 5);
let mut stats = RasterStats::default();
let runs = [
(0, 3, [255.0, 255.0, 255.0, 0.0]),
(8, 4, [255.0, 255.0, 255.0, 255.0]),
(16, 8, [255.0, 255.0, 255.0, 128.0]),
(32, 16, [255.0, 255.0, 255.0, 128.0]),
(48, 32, [255.0, 255.0, 255.0, 128.0]),
];
for (x, len, row_color) in runs {
emit_white_constant_texel_run_with_stats(
&mut surface,
row_color,
[0.0; 4],
0,
len,
x * 4,
&mut stats,
);
}
assert_eq!(stats.constant_texel_textured_triangle_span_runs, 5);
assert_eq!(stats.constant_texel_textured_triangle_span_px_lt4, 3);
assert_eq!(stats.constant_texel_textured_triangle_span_px_4_7, 4);
assert_eq!(stats.constant_texel_textured_triangle_span_px_8_15, 8);
assert_eq!(stats.constant_texel_textured_triangle_span_px_16_31, 16);
assert_eq!(stats.constant_texel_textured_triangle_span_px_32_plus, 32);
assert_eq!(stats.constant_texel_textured_triangle_transparent_px, 3);
assert_eq!(stats.constant_texel_textured_triangle_opaque_px, 4);
assert_eq!(stats.constant_texel_textured_triangle_translucent_px, 56);
assert_eq!(stats.transparent_px, 3);
assert_eq!(stats.opaque_px, 4);
assert_eq!(stats.translucent_px, 56);
assert_eq!(
stats.constant_texel_textured_triangle_repeated_color_opportunity_blocks_16,
3
);
assert_eq!(
stats.constant_texel_textured_triangle_repeated_color_opportunity_px_16,
48
);
assert_eq!(
stats.constant_texel_textured_triangle_repeated_color_true_tail_px_16,
15
);
assert_eq!(
stats.constant_texel_textured_triangle_repeated_color_span_helper_calls,
5
);
assert_eq!(
stats.constant_texel_textured_triangle_repeated_color_span_helper_px,
63
);
assert_eq!(
stats.constant_texel_textured_triangle_repeated_color_opaque_write_helper_calls,
1
);
assert_eq!(
stats.constant_texel_textured_triangle_repeated_color_opaque_write_helper_px,
4
);
assert_eq!(
stats.constant_texel_textured_triangle_repeated_color_translucent_blend_helper_calls,
3
);
assert_eq!(
stats.constant_texel_textured_triangle_repeated_color_translucent_blend_helper_px,
56
);
}
#[test]
fn generic_constant_texel_repeated_color_spans_record_opportunities_without_helper_use() {
let vertices = [
test_vertex(pos2(2.0, 2.0), [255, 255, 255, 255]),
test_vertex(pos2(30.0, 3.0), [255, 255, 255, 255]),
test_vertex(pos2(4.0, 16.0), [255, 255, 255, 255]),
];
let [v0, v1, v2] = &vertices;
let mut surface = test_surface(40, 24);
let mut stats = RasterStats::default();
let bounds = test_triangle_bounds(&vertices);
let area = edge(v0.pos2(), v1.pos2(), v2.pos2());
rasterize_constant_texel_textured_triangle_with_stats_and_color(
&mut surface,
TriangleVertices { v0, v1, v2 },
bounds,
area,
false,
&mut stats,
|_, _, _, _, _, _| [24, 12, 6, 128],
);
assert!(stats.constant_texel_textured_triangle_span_runs > 0);
assert!(stats.constant_texel_textured_triangle_repeated_color_opportunity_blocks_16 > 0);
assert_eq!(
stats.constant_texel_textured_triangle_repeated_color_opportunity_px_16
+ stats.constant_texel_textured_triangle_repeated_color_true_tail_px_16,
stats.constant_texel_textured_triangle_covered_px
);
assert_eq!(
stats.constant_texel_textured_triangle_repeated_color_span_helper_calls,
0
);
assert_eq!(
stats.constant_texel_textured_triangle_repeated_color_span_helper_px,
0
);
assert_eq!(
stats.constant_texel_textured_triangle_repeated_color_opaque_write_helper_calls,
0
);
assert_eq!(
stats.constant_texel_textured_triangle_repeated_color_translucent_blend_helper_calls,
0
);
}
#[test]
fn generic_constant_texel_repeated_color_subruns_record_each_plateau() {
let vertices = [
test_vertex(pos2(0.0, 0.0), [255, 255, 255, 255]),
test_vertex(pos2(32.0, 0.0), [255, 255, 255, 255]),
test_vertex(pos2(0.0, 1000.0), [255, 255, 255, 255]),
];
let [v0, v1, v2] = &vertices;
let mut surface = test_surface(32, 1);
let mut stats = RasterStats::default();
let bounds = TriangleRasterBounds {
min_x: 0,
min_y: 0,
max_x: 32,
max_y: 1,
};
let area = edge(v0.pos2(), v1.pos2(), v2.pos2());
rasterize_constant_texel_textured_triangle_with_stats_and_color(
&mut surface,
TriangleVertices { v0, v1, v2 },
bounds,
area,
false,
&mut stats,
|_, _, _, _, w1, _| {
if w1 < 0.5 {
[24, 12, 6, 128]
} else {
[48, 24, 12, 128]
}
},
);
assert_eq!(stats.constant_texel_textured_triangle_span_runs, 1);
assert_eq!(stats.constant_texel_textured_triangle_covered_px, 32);
assert_eq!(
stats.constant_texel_textured_triangle_repeated_color_opportunity_blocks_16,
2
);
assert_eq!(
stats.constant_texel_textured_triangle_repeated_color_opportunity_px_16,
32
);
assert_eq!(
stats.constant_texel_textured_triangle_repeated_color_true_tail_px_16,
0
);
assert_eq!(
stats.constant_texel_textured_triangle_repeated_color_span_helper_px,
0
);
}
#[test]
fn white_constant_texel_threshold_and_clamp_edges_match_reference() {
assert_white_constant_texel_run_matches_reference(
[12.0, 220.0, 40.0, -3.0],
[2.5, -3.0, 1.25, 0.2],
0,
10,
(2, 3),
AlphaRunKind::Constant(0),
ColorRunKind::Variable,
);
assert_white_constant_texel_run_matches_reference(
[12.0, 220.0, 40.0, 255.6],
[2.5, -3.0, 1.25, 0.2],
0,
10,
(3, 3),
AlphaRunKind::Constant(u8::MAX),
ColorRunKind::Variable,
);
}
#[test]
fn white_constant_texel_constant_alpha_detection_rejects_invalid_endpoints() {
assert_eq!(
white_constant_texel_constant_run_alpha([0.0; 4], [0.0; 4], 0, 0),
None
);
assert_eq!(
white_constant_texel_constant_run_alpha([0.0, 0.0, 0.0, f32::INFINITY], [0.0; 4], 0, 1,),
None
);
assert_eq!(
white_constant_texel_constant_run_alpha([0.0; 4], [0.0, 0.0, 0.0, f32::NAN], 0, 1,),
None
);
assert_eq!(
white_constant_texel_constant_run_alpha([0.0; 4], [0.0; 4], usize::MAX - 1, 3),
None
);
assert_eq!(
white_constant_texel_constant_run_color(
[0.0; 4],
[0.0; 4],
WhiteConstantTexelRun {
start_dx: usize::MAX - 1,
len: 3,
pixel_offset: 0,
},
0,
),
None
);
}
#[test]
fn varying_rgb_white_texel_triangles_match_sampled_reference_and_classify_alpha_runs() {
let texture = TextureImage {
width: 1,
height: 1,
pixels: vec![255, 255, 255, 255],
};
let mut optimized = test_surface(32, 24);
let mut reference = test_surface(32, 24);
let mut stats = RasterStats::default();
let constant_alpha_vertices = [
test_vertex(pos2(2.0, 2.0), [40, 20, 10, 128]),
test_vertex(pos2(22.0, 3.0), [220, 80, 30, 128]),
test_vertex(pos2(5.0, 15.0), [80, 200, 160, 128]),
];
rasterize_white_triangle_pair(
&mut optimized,
&mut reference,
&texture,
&constant_alpha_vertices,
Some(&mut stats),
);
let variable_alpha_vertices = [
test_vertex(pos2(11.0, 7.0), [30, 210, 80, 16]),
test_vertex(pos2(29.0, 8.0), [180, 40, 220, 248]),
test_vertex(pos2(15.0, 22.0), [90, 160, 40, 96]),
];
rasterize_white_triangle_pair(
&mut optimized,
&mut reference,
&texture,
&variable_alpha_vertices,
Some(&mut stats),
);
assert_eq!(optimized.pixels, reference.pixels);
assert!(stats.constant_texel_textured_triangle_white_constant_alpha_run_calls > 0);
assert!(stats.constant_texel_textured_triangle_white_constant_alpha_run_px > 0);
assert!(stats.constant_texel_textured_triangle_white_variable_color_run_calls > 0);
assert!(stats.constant_texel_textured_triangle_white_variable_color_run_px > 0);
assert!(stats.constant_texel_textured_triangle_white_variable_alpha_run_calls > 0);
assert!(stats.constant_texel_textured_triangle_white_variable_alpha_run_px > 0);
}
#[test]
fn white_constant_texel_endpoint_spans_match_row_state_scan_on_boundary_rows() {
let triangles = [
[
test_vertex(pos2(2.0, 2.0), [255, 64, 32, 255]),
test_vertex(pos2(18.0, 2.0), [16, 255, 32, 255]),
test_vertex(pos2(2.0, 13.0), [16, 64, 255, 255]),
],
[
test_vertex(pos2(5.5, 1.0), [255, 255, 255, 32]),
test_vertex(pos2(21.0, 10.5), [255, 255, 255, 224]),
test_vertex(pos2(4.0, 18.0), [255, 255, 255, 128]),
],
[
test_vertex(pos2(0.25, 7.75), [80, 120, 200, 192]),
test_vertex(pos2(27.5, 8.0), [220, 10, 50, 192]),
test_vertex(pos2(11.0, 21.25), [40, 220, 90, 192]),
],
];
for vertices in triangles {
assert_endpoint_spans_match_row_state_scan(vertices);
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum AlphaRunKind {
Constant(u8),
Variable,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum ColorRunKind {
Constant([u8; 4]),
Variable,
}
fn assert_white_constant_texel_run_matches_reference(
row_color: [f32; 4],
color_step: [f32; 4],
start_dx: usize,
len: usize,
pos: (usize, usize),
expected_kind: AlphaRunKind,
expected_color_kind: ColorRunKind,
) {
let pixel_offset = test_surface(1, 1).row_offset(0);
let run = WhiteConstantTexelRun {
start_dx,
len,
pixel_offset: pixel_offset + (pos.0 * 20 + pos.1) * 4,
};
let mut actual = test_surface(20, 7);
let mut actual_no_stats = test_surface(20, 7);
let mut reference = test_surface(20, 7);
let mut stats = RasterStats::default();
let mut scalar_stats = RasterStats::default();
emit_white_constant_texel_run_with_stats(
&mut actual,
row_color,
color_step,
start_dx,
len,
run.pixel_offset,
&mut stats,
);
emit_white_constant_texel_run_no_stats(
&mut actual_no_stats,
row_color,
color_step,
start_dx,
len,
run.pixel_offset,
);
emit_white_constant_texel_run_reference(
&mut reference,
row_color,
color_step,
run,
Some(&mut scalar_stats),
);
assert_eq!(actual.pixels, reference.pixels);
assert_eq!(actual_no_stats.pixels, reference.pixels);
assert_eq!(
white_constant_texel_constant_run_alpha(row_color, color_step, start_dx, len),
expected_kind.alpha()
);
assert_eq!(
white_constant_texel_constant_run_color(
row_color,
color_step,
run,
expected_kind.alpha().unwrap_or(0)
),
expected_color_kind.color()
);
assert_white_constant_texel_classification_stats(
&stats,
expected_kind,
expected_color_kind,
len,
);
assert_white_constant_texel_alpha_stats_match(&stats, &scalar_stats);
}
impl AlphaRunKind {
const fn alpha(self) -> Option<u8> {
match self {
Self::Constant(alpha) => Some(alpha),
Self::Variable => None,
}
}
}
impl ColorRunKind {
const fn color(self) -> Option<[u8; 4]> {
match self {
Self::Constant(color) => Some(color),
Self::Variable => None,
}
}
}
fn assert_white_constant_texel_classification_stats(
stats: &RasterStats,
expected_kind: AlphaRunKind,
expected_color_kind: ColorRunKind,
len: usize,
) {
match expected_kind {
AlphaRunKind::Constant(_) => {
assert_eq!(
stats.constant_texel_textured_triangle_white_constant_alpha_run_calls,
1
);
assert_eq!(
stats.constant_texel_textured_triangle_white_constant_alpha_run_px,
len
);
assert_eq!(
stats.constant_texel_textured_triangle_white_variable_alpha_run_calls,
0
);
assert_eq!(
stats.constant_texel_textured_triangle_white_variable_alpha_run_px,
0
);
assert_white_constant_texel_color_classification_stats(
stats,
expected_color_kind,
len,
);
}
AlphaRunKind::Variable => {
assert_eq!(
stats.constant_texel_textured_triangle_white_constant_alpha_run_calls,
0
);
assert_eq!(
stats.constant_texel_textured_triangle_white_constant_alpha_run_px,
0
);
assert_eq!(
stats.constant_texel_textured_triangle_white_variable_alpha_run_calls,
1
);
assert_eq!(
stats.constant_texel_textured_triangle_white_variable_alpha_run_px,
len
);
assert_white_constant_texel_color_classification_stats(
stats,
ColorRunKind::Variable,
0,
);
}
}
}
fn assert_white_constant_texel_color_classification_stats(
stats: &RasterStats,
expected_kind: ColorRunKind,
len: usize,
) {
match expected_kind {
ColorRunKind::Constant(_) => {
assert_eq!(
stats.constant_texel_textured_triangle_white_constant_color_run_calls,
1
);
assert_eq!(
stats.constant_texel_textured_triangle_white_constant_color_run_px,
len
);
assert_eq!(
stats.constant_texel_textured_triangle_white_variable_color_run_calls,
0
);
assert_eq!(
stats.constant_texel_textured_triangle_white_variable_color_run_px,
0
);
}
ColorRunKind::Variable => {
assert_eq!(
stats.constant_texel_textured_triangle_white_constant_color_run_calls,
0
);
assert_eq!(
stats.constant_texel_textured_triangle_white_constant_color_run_px,
0
);
assert_eq!(
stats.constant_texel_textured_triangle_white_variable_color_run_calls,
usize::from(len > 0)
);
assert_eq!(
stats.constant_texel_textured_triangle_white_variable_color_run_px,
len
);
}
}
}
fn assert_white_constant_texel_alpha_stats_match(
stats: &RasterStats,
scalar_stats: &RasterStats,
) {
assert_eq!(
stats.textured_triangle_covered_px,
scalar_stats.textured_triangle_covered_px
);
assert_eq!(
stats.constant_texel_textured_triangle_covered_px,
scalar_stats.constant_texel_textured_triangle_covered_px,
);
assert_eq!(
stats.constant_texel_textured_triangle_white_texel_covered_px,
scalar_stats.constant_texel_textured_triangle_white_texel_covered_px,
);
assert_eq!(stats.opaque_px, scalar_stats.opaque_px);
assert_eq!(stats.translucent_px, scalar_stats.translucent_px);
assert_eq!(stats.transparent_px, scalar_stats.transparent_px);
assert_eq!(
stats.constant_texel_textured_triangle_opaque_px,
scalar_stats.constant_texel_textured_triangle_opaque_px,
);
assert_eq!(
stats.constant_texel_textured_triangle_translucent_px,
scalar_stats.constant_texel_textured_triangle_translucent_px,
);
assert_eq!(
stats.constant_texel_textured_triangle_transparent_px,
scalar_stats.constant_texel_textured_triangle_transparent_px,
);
}
fn emit_white_constant_texel_run_reference(
surface: &mut SoftwareSurface,
row_color: [f32; 4],
color_step: [f32; 4],
run: WhiteConstantTexelRun,
mut stats: Option<&mut RasterStats>,
) {
if let Some(stats) = stats.as_deref_mut() {
stats.textured_triangle_covered_px += run.len;
stats.constant_texel_textured_triangle_covered_px += run.len;
stats.constant_texel_textured_triangle_white_texel_covered_px += run.len;
}
let mut pixel_offset = run.pixel_offset;
for run_dx in 0..run.len {
let dx = run.start_dx + run_dx;
let color = white_constant_texel_pixel_color(row_color, color_step, dx);
if let Some(stats) = stats.as_deref_mut() {
stats.record_alpha_px(color[3], 1);
stats.record_constant_texel_alpha_px(color[3], 1);
}
match color[3] {
0 => {}
u8::MAX => surface.write_opaque_pixel_at_offset(pixel_offset, color),
_ => surface.blend_translucent_pixel_at_offset(pixel_offset, color),
}
pixel_offset += 4;
}
}
fn rasterize_white_triangle_pair(
optimized: &mut SoftwareSurface,
reference: &mut SoftwareSurface,
texture: &TextureImage,
vertices: &[Vertex; 3],
stats: Option<&mut RasterStats>,
) {
let [v0, v1, v2] = vertices;
let triangle = TriangleVertices { v0, v1, v2 };
let bounds = test_triangle_bounds(vertices);
let area = edge(v0.pos2(), v1.pos2(), v2.pos2());
rasterize_constant_texel_textured_triangle(
optimized,
triangle,
bounds,
area,
[255, 255, 255, 255],
stats,
);
rasterize_textured_triangle(reference, triangle, texture, bounds, area, None);
}
fn assert_endpoint_spans_match_row_state_scan(vertices: [Vertex; 3]) {
let [v0, v1, v2] = &vertices;
let triangle = TriangleVertices { v0, v1, v2 };
let bounds = test_triangle_bounds(&vertices);
let area = edge(v0.pos2(), v1.pos2(), v2.pos2());
let raster = TriangleRasterState::new(v0, v1, v2, bounds, area);
let positions = triangle_positions(triangle);
let scanline_edges = ScanlineEdges::new(positions);
let narrow_scanlines = bounds.pixel_area() > TRIANGLE_SCANLINE_NARROWING_MIN_AREA;
let mut row_edge0 = raster.row_edge0;
let mut row_edge1 = raster.row_edge1;
let mut row_edge2 = raster.row_edge2;
for y in bounds.min_y..bounds.max_y {
let (start_x, end_x) = if narrow_scanlines {
scanline_edges.x_range(bounds, usize_to_f32(y) + 0.5)
} else {
(bounds.min_x, bounds.max_x)
};
let row_start_edges = triangle_row_start_edges(
triangle,
(row_edge0, row_edge1, row_edge2),
y,
start_x,
narrow_scanlines,
);
let endpoints = white_constant_texel_endpoint_span(
&raster,
row_start_edges,
(start_x, end_x),
true,
);
let (scan_span, expected_endpoint_probe_px) =
row_state_scan_span_and_endpoint_probe_px(&raster, row_start_edges, start_x, end_x);
assert_eq!(endpoints.span, scan_span, "y={y} vertices={vertices:?}");
assert_eq!(
endpoints.endpoint_probe_px, expected_endpoint_probe_px,
"y={y} vertices={vertices:?}"
);
advance_triangle_row_edges(&raster, &mut row_edge0, &mut row_edge1, &mut row_edge2);
}
}
fn row_state_scan_span_and_endpoint_probe_px(
raster: &TriangleRasterState,
row_start_edges: (f32, f32, f32),
start_x: usize,
end_x: usize,
) -> (Option<(usize, usize)>, usize) {
let mut run_start = None;
let mut scan_span = None;
let mut scan_runs = 0;
for x in start_x..end_x {
if triangle_raster_state_covers_row_dx(raster, row_start_edges, x - start_x) {
run_start.get_or_insert(x);
} else if let Some(start) = run_start.take() {
record_white_constant_texel_scan_run(start, x, &mut scan_runs, &mut scan_span);
}
}
if let Some(start) = run_start {
record_white_constant_texel_scan_run(start, end_x, &mut scan_runs, &mut scan_span);
}
assert!(
scan_runs <= 1,
"test triangle unexpectedly produced {scan_runs} row runs"
);
let expected_endpoint_probe_px = scan_span
.map_or(end_x - start_x, |(span_start, span_end)| {
(span_start - start_x + 1) + (end_x - span_end + 1)
});
(scan_span, expected_endpoint_probe_px)
}
fn test_triangle_bounds(vertices: &[Vertex; 3]) -> TriangleRasterBounds {
let min_x = vertices
.iter()
.map(|vertex| f32_to_usize_floor_clamped(vertex.pos2().x, usize::MAX))
.min()
.expect("triangle has vertices");
let min_y = vertices
.iter()
.map(|vertex| f32_to_usize_floor_clamped(vertex.pos2().y, usize::MAX))
.min()
.expect("triangle has vertices");
let max_x = vertices
.iter()
.map(|vertex| f32_to_usize_ceil_clamped(vertex.pos2().x, usize::MAX))
.max()
.expect("triangle has vertices");
let max_y = vertices
.iter()
.map(|vertex| f32_to_usize_ceil_clamped(vertex.pos2().y, usize::MAX))
.max()
.expect("triangle has vertices");
TriangleRasterBounds {
min_x,
min_y,
max_x,
max_y,
}
}
fn test_vertex(pos: Pos2, color: [u8; 4]) -> Vertex {
Vertex {
pos: [pos.x, pos.y],
uv: [0.0, 0.0],
color: Color::from_rgba_premultiplied(color[0], color[1], color[2], color[3]),
}
}
fn assert_constant_alpha_only_run_matches_reference(
row_alpha: f32,
alpha_step: f32,
alpha_offset: usize,
len: usize,
y: usize,
x: usize,
) {
const REPEATED_COLOR_BLOCK_PX: usize = 16;
let run = AlphaOnlyRun {
alpha_offset,
len,
y,
x,
};
let mut actual = test_surface(20, 7);
let mut actual_no_stats = test_surface(20, 7);
let mut reference = test_surface(20, 7);
let mut stats = RasterStats::default();
emit_white_constant_texel_alpha_only_run_with_stats(
&mut actual,
row_alpha,
alpha_step,
run,
&mut stats,
);
emit_white_constant_texel_alpha_only_run_no_stats(
&mut actual_no_stats,
row_alpha,
alpha_step,
run,
);
emit_white_constant_texel_alpha_only_run_reference(
&mut reference,
row_alpha,
alpha_step,
run,
);
assert_eq!(actual.pixels, reference.pixels);
assert_eq!(actual_no_stats.pixels, reference.pixels);
assert_eq!(
stats.constant_texel_textured_triangle_white_alpha_only_constant_alpha_run_calls,
1
);
assert_eq!(
stats.constant_texel_textured_triangle_white_alpha_only_constant_alpha_run_px,
len
);
assert_eq!(
stats.constant_texel_textured_triangle_white_alpha_only_variable_alpha_run_calls,
0
);
assert_eq!(
stats.constant_texel_textured_triangle_white_alpha_only_variable_alpha_run_px,
0
);
assert_eq!(stats.textured_triangle_covered_px, len);
assert_eq!(
stats.constant_texel_textured_triangle_repeated_color_opportunity_blocks_16,
len / REPEATED_COLOR_BLOCK_PX
);
assert_eq!(
stats.constant_texel_textured_triangle_repeated_color_opportunity_px_16,
len / REPEATED_COLOR_BLOCK_PX * REPEATED_COLOR_BLOCK_PX
);
assert_eq!(
stats.constant_texel_textured_triangle_repeated_color_true_tail_px_16,
len % REPEATED_COLOR_BLOCK_PX
);
assert_eq!(
stats.constant_texel_textured_triangle_repeated_color_span_helper_px,
0
);
assert_alpha_stats_match_run(&stats, row_alpha, alpha_step, alpha_offset, len);
}
fn assert_alpha_stats_match_run(
stats: &RasterStats,
row_alpha: f32,
alpha_step: f32,
alpha_offset: usize,
len: usize,
) {
let (transparent, opaque, translucent) =
alpha_counts(row_alpha, alpha_step, alpha_offset, len);
assert_eq!(stats.opaque_px, opaque);
assert_eq!(stats.constant_texel_textured_triangle_opaque_px, opaque);
assert_eq!(stats.transparent_px, transparent);
assert_eq!(
stats.constant_texel_textured_triangle_transparent_px,
transparent
);
assert_eq!(stats.translucent_px, translucent);
assert_eq!(
stats.constant_texel_textured_triangle_translucent_px,
translucent
);
}
fn alpha_counts(
row_alpha: f32,
alpha_step: f32,
alpha_offset: usize,
len: usize,
) -> (usize, usize, usize) {
let mut transparent = 0;
let mut opaque = 0;
let mut translucent = 0;
for offset in 0..len {
match white_constant_texel_alpha_only_pixel_alpha(
row_alpha,
alpha_step,
alpha_offset + offset,
) {
0 => transparent += 1,
u8::MAX => opaque += 1,
_ => translucent += 1,
}
}
(transparent, opaque, translucent)
}
fn emit_white_constant_texel_alpha_only_run_reference(
surface: &mut SoftwareSurface,
row_alpha: f32,
alpha_step: f32,
run: AlphaOnlyRun,
) {
let mut pixel_offset = surface.row_offset(run.y) + run.x * 4;
for offset in 0..run.len {
let alpha = white_constant_texel_alpha_only_pixel_alpha(
row_alpha,
alpha_step,
run.alpha_offset + offset,
);
match alpha {
0 => {}
u8::MAX => {
surface.write_opaque_pixel_at_offset(pixel_offset, [255, 255, 255, alpha]);
}
_ => {
surface.blend_translucent_pixel_at_offset(pixel_offset, [255, 255, 255, alpha]);
}
}
pixel_offset += 4;
}
}
fn test_surface(width: usize, height: usize) -> SoftwareSurface {
let mut surface = SoftwareSurface::default();
surface.resize(width, height).expect("surface resize");
surface.clear([19, 47, 83, 255]);
surface
}
}