This is an automated email from the git hooks/post-receive script.
git pushed a commit to reference refs/pull/114/head
in repository efl.
View the commit online.
commit 74514e38769a110a3e259e582edd2f9664b4420b
Author: [email protected] <[email protected]>
AuthorDate: Sun Sep 13 18:39:21 2026 -0600
evas_ector_gl: use only ASCII in the code this branch adds
Raster's review flagged a Unicode multiplication sign in
Evas_Engine_GL_Generic.h ("1024×64"). EFL sources are plain ASCII, and
the branch had 165 such characters in 18 files, all in comments.
Replace them with ASCII: an em dash becomes "-", an arrow "->", a
multiplication sign "x" and "almost equal" "~".
Only lines added by this branch are touched: none of the changed lines
exists on master. No replacement falls inside a string literal, so the
generated GLSL and log messages are unchanged. No branch-added line
contains non-ASCII any more. The build is clean, and ector_suite and
evas_suite pass.
Co-Authored-By: Claude Opus 5 (1M context) <[email protected]>
---
.../ector/software/ector_renderer_software_shape.c | 2 +-
src/lib/ector/software/ector_software_private.h | 4 +-
src/lib/ector/software/ector_software_rasterizer.c | 2 +-
src/lib/evas/canvas/efl_canvas_vg_container.c | 4 +-
src/lib/evas/canvas/efl_canvas_vg_object.c | 4 +-
.../engines/gl_common/evas_ector_gl_span_types.h | 14 ++--
.../evas/engines/gl_common/evas_gl_common.h | 2 +-
.../evas/engines/gl_common/evas_gl_context.c | 2 +-
.../engines/gl_generic/Evas_Engine_GL_Generic.h | 4 +-
.../engines/gl_generic/evas_ector_gl_grad_atlas.c | 14 ++--
.../engines/gl_generic/evas_ector_gl_grad_atlas.h | 8 +--
.../evas/engines/gl_generic/evas_ector_gl_span.c | 78 +++++++++++-----------
.../evas/engines/gl_generic/evas_ector_gl_span.h | 40 +++++------
.../engines/gl_generic/evas_ector_gl_span_shader.c | 48 ++++++-------
src/modules/evas/engines/gl_generic/evas_engine.c | 44 ++++++------
src/tests/ector/suite/ector_test_grad_atlas.c | 10 +--
src/tests/ector/suite/ector_test_span_collector.c | 38 +++++------
src/tests/ector/suite/meson.build | 6 +-
18 files changed, 162 insertions(+), 162 deletions(-)
diff --git a/src/lib/ector/software/ector_renderer_software_shape.c b/src/lib/ector/software/ector_renderer_software_shape.c
index ed35605827..c6aa715f52 100644
--- a/src/lib/ector/software/ector_renderer_software_shape.c
+++ b/src/lib/ector/software/ector_renderer_software_shape.c
@@ -660,7 +660,7 @@ _ector_renderer_software_shape_ector_renderer_draw(Eo *obj EINA_UNUSED,
ector_software_rasterizer_clip_rect_set(pd->surface->rasterizer, clips);
ector_software_rasterizer_transform_set(pd->surface->rasterizer, pd->base->m);
- // fill the span_data structure — mark fill vs stroke pass for the
+ // fill the span_data structure - mark fill vs stroke pass for the
// span collector so it routes spans to the correct texture buffer.
pd->surface->rasterizer->fill_data.span_is_stroke = EINA_FALSE;
if (pd->shape->fill)
diff --git a/src/lib/ector/software/ector_software_private.h b/src/lib/ector/software/ector_software_private.h
index 2ddf089382..9bf5e3cae9 100644
--- a/src/lib/ector/software/ector_software_private.h
+++ b/src/lib/ector/software/ector_software_private.h
@@ -56,7 +56,7 @@ typedef struct _Ector_Renderer_Software_Gradient_Data
// (status cycles through CTABLE_NOT_READY before becoming READY again).
//
// Lives here rather than on Span_Collector so the cache survives the
- // collector pool's high-water-mark slot reuse — collectors are
+ // collector pool's high-water-mark slot reuse - collectors are
// recycled across shapes between frames, but gradient_data is stable
// per-gradient-renderer-object.
//
@@ -151,7 +151,7 @@ struct _Ector_Software_Surface_Data
int y;
// Per-shape span collector arrays. Each entry is a Span_Collector*.
// Owned by the engine (eng_ector_destroy frees them). Arrays grow
- // with high-water mark allocation — never shrunk, reallocated on
+ // with high-water mark allocation - never shrunk, reallocated on
// demand when more shapes are drawn in a single VG object.
void **span_collectors_fill;
int span_collectors_fill_count;
diff --git a/src/lib/ector/software/ector_software_rasterizer.c b/src/lib/ector/software/ector_software_rasterizer.c
index a175fe3d2e..22d6781975 100644
--- a/src/lib/ector/software/ector_software_rasterizer.c
+++ b/src/lib/ector/software/ector_software_rasterizer.c
@@ -945,7 +945,7 @@ ector_software_rasterizer_draw_rle_data(Software_Rasterizer *rasterizer,
// Per-shape collector allocation. When span_collector_alloc is set,
// allocate (or reuse) a fresh Span_Collector for this shape and select
- // the appropriate collector callback. No CPU pixel blending occurs —
+ // the appropriate collector callback. No CPU pixel blending occurs -
// spans are packed into the collector's GPU-uploadable buffer; the
// fragment shader renders them into the FBO in eng_ector_end().
//
diff --git a/src/lib/evas/canvas/efl_canvas_vg_container.c b/src/lib/evas/canvas/efl_canvas_vg_container.c
index 50d4ecc3a9..e0bff55fdf 100644
--- a/src/lib/evas/canvas/efl_canvas_vg_container.c
+++ b/src/lib/evas/canvas/efl_canvas_vg_container.c
@@ -96,7 +96,7 @@ _prepare_comp(Evas_Object_Protected_Data *obj, //vector object
// and reused when the size matches. eng_ector_end() of the main VG object
// reads espd->gl_comp_surface (set by render_pre after we return) to fill
// the mask texture params on each shape's Span_Pipe_Params.
- if (ENFN->gl_surface_read_pixels) // GL engine only — SW engine sets this to NULL
+ if (ENFN->gl_surface_read_pixels) // GL engine only - SW engine sets this to NULL
{
int err = 0;
void *mask_surface = pd->comp.gl_surface;
@@ -277,7 +277,7 @@ _efl_canvas_vg_container_render_pre(Evas_Object_Protected_Data *vg_pd,
// Even when the container's flags are NONE (nothing changed), we must
// still propagate the GL composite mask reference to the ector surface
- // every frame — eng_ector_end clears it after use.
+ // every frame - eng_ector_end clears it after use.
if (pd->comp_target && _comp_method_needs_mask(pd->comp.method))
{
Efl_Canvas_Vg_Container_Data *cpd =
diff --git a/src/lib/evas/canvas/efl_canvas_vg_object.c b/src/lib/evas/canvas/efl_canvas_vg_object.c
index 6338cb02bf..6061547db0 100644
--- a/src/lib/evas/canvas/efl_canvas_vg_object.c
+++ b/src/lib/evas/canvas/efl_canvas_vg_object.c
@@ -574,7 +574,7 @@ _evas_vg_render(Evas_Object_Protected_Data *obj, Efl_Canvas_Vg_Object_Data *pd,
EINA_LIST_FOREACH(cd->children, l, child)
{
- // Skip composite target containers — their shapes were
+ // Skip composite target containers - their shapes were
// already rendered to the mask FBO during render_pre.
// Drawing them again would overwrite the masked result.
if (efl_isa(child, EFL_CANVAS_VG_CONTAINER_CLASS))
@@ -583,7 +583,7 @@ _evas_vg_render(Evas_Object_Protected_Data *obj, Efl_Canvas_Vg_Object_Data *pd,
efl_data_scope_get(child, EFL_CANVAS_VG_CONTAINER_CLASS);
if (child_cd && child_cd->comp.src) continue;
}
- // Skip gradient objects in composite containers — they are
+ // Skip gradient objects in composite containers - they are
// fill properties of shapes, not standalone renderable
// nodes. Only skip when comp_target is set to avoid
// affecting non-composite containers.
diff --git a/src/modules/evas/engines/gl_common/evas_ector_gl_span_types.h b/src/modules/evas/engines/gl_common/evas_ector_gl_span_types.h
index 70d9f86601..78ae9d6083 100644
--- a/src/modules/evas/engines/gl_common/evas_ector_gl_span_types.h
+++ b/src/modules/evas/engines/gl_common/evas_ector_gl_span_types.h
@@ -51,12 +51,12 @@ typedef struct _Span_Page Span_Page;
#define SPAN_FILL_TYPE_GRADIENT_MIN SPAN_FILL_TYPE_LINEAR_GRADIENT
// ---------------------------------------------------------------------------
-// Span_Variant — selects the interleaved vertex layout for a given draw call.
+// Span_Variant - selects the interleaved vertex layout for a given draw call.
//
-// SOLID — no gradient, no mask
-// SOLID_MASK — no gradient, composite mask present
-// GRADIENT — gradient fill or stroke, no mask
-// GRADIENT_MASK — gradient fill or stroke, composite mask present
+// SOLID - no gradient, no mask
+// SOLID_MASK - no gradient, composite mask present
+// GRADIENT - gradient fill or stroke, no mask
+// GRADIENT_MASK - gradient fill or stroke, composite mask present
// ---------------------------------------------------------------------------
typedef enum
{
@@ -76,8 +76,8 @@ typedef enum
// docs/superpowers/specs/2026-05-05-span-gl-attribute-batching-design.md
//
// mask_comp_inv[2]:
-// [0] — raw comp_method (Efl_Gfx_Vg_Composite_Method enum value, cast to GLfloat)
-// [1] — mask_inv flag (1.0 if the mask alpha should be inverted, 0.0 otherwise)
+// [0] - raw comp_method (Efl_Gfx_Vg_Composite_Method enum value, cast to GLfloat)
+// [1] - mask_inv flag (1.0 if the mask alpha should be inverted, 0.0 otherwise)
// ---------------------------------------------------------------------------
// Common fields shared by all four variants. 16f = 64 B
diff --git a/src/modules/evas/engines/gl_common/evas_gl_common.h b/src/modules/evas/engines/gl_common/evas_gl_common.h
index cd2f930400..0a827703c6 100644
--- a/src/modules/evas/engines/gl_common/evas_gl_common.h
+++ b/src/modules/evas/engines/gl_common/evas_gl_common.h
@@ -48,7 +48,7 @@
// Per-variant span-buffer interleaved vertex types, shared macros, and
// the SPAN_FILL_TYPE_* fill type constants.
-// Single source of truth — no duplication with evas_ector_gl_span.h.
+// Single source of truth - no duplication with evas_ector_gl_span.h.
#include "evas_ector_gl_span_types.h"
#define EVAS_GL_TILE_SIZE 16
diff --git a/src/modules/evas/engines/gl_common/evas_gl_context.c b/src/modules/evas/engines/gl_common/evas_gl_context.c
index a28030f1fa..8f9afc3f71 100644
--- a/src/modules/evas/engines/gl_common/evas_gl_context.c
+++ b/src/modules/evas/engines/gl_common/evas_gl_context.c
@@ -2120,7 +2120,7 @@ evas_gl_common_span_fill_vertices(void *out_buf, Span_Variant variant,
(p->stroke.tex ? 2 : 0));
common.x_min[0] = (GLfloat)p->fill.x_min;
common.x_min[1] = (GLfloat)p->stroke.x_min;
- // mul_col: premultiplied ARGB 0xAARRGGBB — decode as R,G,B,A for the shader
+ // mul_col: premultiplied ARGB 0xAARRGGBB - decode as R,G,B,A for the shader
common.mul_col[0] = (float)((p->mul_col >> 16) & 0xFF) / 255.0f; // R
common.mul_col[1] = (float)((p->mul_col >> 8) & 0xFF) / 255.0f; // G
common.mul_col[2] = (float)( p->mul_col & 0xFF) / 255.0f; // B
diff --git a/src/modules/evas/engines/gl_generic/Evas_Engine_GL_Generic.h b/src/modules/evas/engines/gl_generic/Evas_Engine_GL_Generic.h
index b749f0c717..83a7df8e7e 100644
--- a/src/modules/evas/engines/gl_generic/Evas_Engine_GL_Generic.h
+++ b/src/modules/evas/engines/gl_generic/Evas_Engine_GL_Generic.h
@@ -33,8 +33,8 @@ struct _Render_Engine_GL_Generic
Render_Output_GL_Generic *current;
- // Gradient ramp atlas: one 1024×64 RGBA8 texture pool per engine lifetime.
- // NULL if span_grad_atlas_new() failed — gradient shapes are skipped per
+ // Gradient ramp atlas: one 1024x64 RGBA8 texture pool per engine lifetime.
+ // NULL if span_grad_atlas_new() failed - gradient shapes are skipped per
// the spec error table (one-shot ERR logged at allocation time).
Span_Grad_Atlas *grad_atlas;
diff --git a/src/modules/evas/engines/gl_generic/evas_ector_gl_grad_atlas.c b/src/modules/evas/engines/gl_generic/evas_ector_gl_grad_atlas.c
index b7342e62c8..ba280e4d62 100644
--- a/src/modules/evas/engines/gl_generic/evas_ector_gl_grad_atlas.c
+++ b/src/modules/evas/engines/gl_generic/evas_ector_gl_grad_atlas.c
@@ -19,7 +19,7 @@
// when SPAN_GRAD_ATLAS_TEST_BUILD is defined.
# include <Eina.h>
# include <eina_crc.h>
-// Stub out all GL functions used by the implementation — in test mode
+// Stub out all GL functions used by the implementation - in test mode
// _ensure_gl short-circuits before any GL call, and _upload_row skips
// the GL path, so these are never reached.
# define glGenTextures(n, ids) ((void)0)
@@ -42,7 +42,7 @@
#include "evas_ector_gl_grad_atlas.h"
// CRC32 over 4096 bytes using eina_crc() (SSE4.2-accelerated when
-// available — measured ~2.6x faster than FNV-1a on 4 KB ramps).
+// available - measured ~2.6x faster than FNV-1a on 4 KB ramps).
// Cache lookup uses byte-compare on hit to defend against collisions.
uint32_t
span_grad_atlas_hash(const uint8_t *bytes)
@@ -121,7 +121,7 @@ span_grad_atlas_flush_cb_set(Span_Grad_Atlas *a,
a->flush_data = data;
}
-// Find row by (grad_id, version) — O(64). Returns row idx or -1.
+// Find row by (grad_id, version) - O(64). Returns row idx or -1.
static int
_find_identity(Span_Grad_Atlas *a, void *grad_id, uint32_t version)
{
@@ -215,9 +215,9 @@ _alloc_row(Span_Grad_Atlas *a)
// Upload bytes to row idx via glTexSubImage2D and copy to mirror.
//
// @p bytes points at native uint32 ARGB content (same layout as
-// gd->color_table). The ARGB→RGBA byte-swap for the GL upload is
+// gd->color_table). The ARGB->RGBA byte-swap for the GL upload is
// done here on a stack staging buffer so that callers never need a
-// separate rearrangement pass — the cpu_mirror stores the native
+// separate rearrangement pass - the cpu_mirror stores the native
// layout too, keeping hash/memcmp consistent.
static void
_upload_row(Span_Grad_Atlas *a, int row, const uint8_t *bytes)
@@ -227,7 +227,7 @@ _upload_row(Span_Grad_Atlas *a, int row, const uint8_t *bytes)
#endif
if (a->tex)
{
- // Rearrange ARGB native→RGBA for GL only at upload time.
+ // Rearrange ARGB native->RGBA for GL only at upload time.
uint32_t staging[SPAN_GRAD_ATLAS_W];
const uint32_t *src = "" uint32_t *)bytes;
for (int j = 0; j < SPAN_GRAD_ATLAS_W; j++)
@@ -279,7 +279,7 @@ span_grad_atlas_lookup(Span_Grad_Atlas *a, void *grad_id,
return row;
}
- // Miss — allocate or evict, upload.
+ // Miss - allocate or evict, upload.
if (!_ensure_gl(a)) return -1;
row = _alloc_row(a);
_upload_row(a, row, bytes);
diff --git a/src/modules/evas/engines/gl_generic/evas_ector_gl_grad_atlas.h b/src/modules/evas/engines/gl_generic/evas_ector_gl_grad_atlas.h
index a5d6311361..c5b7167ac9 100644
--- a/src/modules/evas/engines/gl_generic/evas_ector_gl_grad_atlas.h
+++ b/src/modules/evas/engines/gl_generic/evas_ector_gl_grad_atlas.h
@@ -14,14 +14,14 @@ typedef unsigned int GLuint;
# endif
#endif
-// Gradient ramp atlas — fixed 1024×64 RGBA8 texture pool.
+// Gradient ramp atlas - fixed 1024x64 RGBA8 texture pool.
//
// Each row holds one resolved 1024-texel ramp. Lookup is by
-// (Efl_Vg_Gradient*, version) — fast identity match
+// (Efl_Vg_Gradient*, version) - fast identity match
// or by content hash with byte-compare fallback for collisions.
//
// The CPU-side mirror (256 KB) lives only for hash-collision
-// verification — it is never read back from the GPU.
+// verification - it is never read back from the GPU.
//
// Single-threaded; no locking.
@@ -60,7 +60,7 @@ Span_Grad_Atlas *span_grad_atlas_new(void);
// Free GL resources and CPU mirror.
void span_grad_atlas_free(Span_Grad_Atlas *a);
-// Begin a new render pass — bumps the LRU frame counter.
+// Begin a new render pass - bumps the LRU frame counter.
void span_grad_atlas_frame_begin(Span_Grad_Atlas *a);
// Register a callback that drains any draw calls referencing atlas rows.
diff --git a/src/modules/evas/engines/gl_generic/evas_ector_gl_span.c b/src/modules/evas/engines/gl_generic/evas_ector_gl_span.c
index e7f48cb67d..cd294219db 100644
--- a/src/modules/evas/engines/gl_generic/evas_ector_gl_span.c
+++ b/src/modules/evas/engines/gl_generic/evas_ector_gl_span.c
@@ -48,7 +48,7 @@
// sc->textures array, avoiding a separate heap allocation and copy.
//
// @param tex Pointer to the Span_Texture slot to initialise.
-// @param h Canvas height — determines buffer row count.
+// @param h Canvas height - determines buffer row count.
// @param stride Bytes per row ((max_spans + 1) * 4).
// @param x_min Inclusive left edge of the x-range this texture covers.
// @param x_max Inclusive right edge of the x-range this texture covers.
@@ -110,7 +110,7 @@ span_collector_new(int h, int max_spans, Span_Data_Type type)
return NULL;
}
- // Initialise the primary texture slot in place — no alloc+copy+free.
+ // Initialise the primary texture slot in place - no alloc+copy+free.
if (!_span_texture_init(&sc->textures[0], h, sc->stride, 0, SPAN_TEXTURE_X_MAX_INITIAL))
{
free(sc->textures);
@@ -132,7 +132,7 @@ span_collector_new(int h, int max_spans, Span_Data_Type type)
// Follows the Evas high-water mark pattern (like pipe buffers and RLE
// spans): buffers grow via realloc when h > alloc_h, but never
// shrink. When h <= alloc_h, only the active height is updated
-// and the existing buffers are reused — no allocation at all.
+// and the existing buffers are reused - no allocation at all.
void
span_collector_resize(Span_Collector *sc, int h)
{
@@ -145,14 +145,14 @@ span_collector_resize(Span_Collector *sc, int h)
sc->h = h;
// When active height changes, the GPU texture dimensions no longer
- // match — mark dirty so the upload path recreates or resizes it.
+ // match - mark dirty so the upload path recreates or resizes it.
{
int ti;
for (ti = 0; ti < sc->texture_count; ti++)
sc->textures[ti].dirty = EINA_TRUE;
}
- // Common case: h fits within existing allocation — no realloc needed.
+ // Common case: h fits within existing allocation - no realloc needed.
if (h <= sc->alloc_h)
return;
@@ -257,7 +257,7 @@ span_collector_clear(Span_Collector *sc)
// that may be freed between frames via the Eina free queue. If not
// NULLed here, a reused collector from the high-water mark pool
// would retain a dangling pointer from the previous frame.
- // type must also be reset — a collector previously used for gradient fills
+ // type must also be reset - a collector previously used for gradient fills
// retains LinearGradient/RadialGradient, causing eng_ector_end to select
// the gradient shader with a NULL gradient_data when reused for solid fills.
sc->type = Solid;
@@ -351,7 +351,7 @@ _find_split_x(Span_Texture *tex, int y, int stride, int bytes_per_span)
// @param row_buf Pointer to the start of the row (buffer + y * stride).
// @param idx Entry index to start writing at.
// @param max_spans Maximum spans allowed in this row.
-// @param stride Bytes per row (unused here — caller passes row_buf already
+// @param stride Bytes per row (unused here - caller passes row_buf already
// offset to the correct row; kept for API symmetry).
// @param gap_ptr Remaining gap; reduced by 256 per extender written.
// @return Number of extender entries written.
@@ -377,7 +377,7 @@ _emit_gap_extenders(uint8_t *row_buf, int idx, int max_spans,
// existing rows are redistributed: spans fully on the right migrate to the
// new texture; straddling spans are split at split_x; left-only spans stay.
//
-// Gap extender entries (cov==0, len==1) in the source are skipped — they are
+// Gap extender entries (cov==0, len==1) in the source are skipped - they are
// not redistributed. New gap extenders are emitted in each destination where
// the recomputed relative gap exceeds 255.
//
@@ -455,11 +455,11 @@ _do_spatial_split(Span_Collector *sc, int overflow_y)
// Gap-encoded format: byte[0]=cov, byte[1]=len, byte[2]=gap, byte[3]=0
// Absolute position reconstructed as:
// abs_x starts at old_tex->x_min (first gap is relative to x_min)
- // abs_x += gap → start of span
- // abs_x += len → end of span / start of next gap region
+ // abs_x += gap -> start of span
+ // abs_x += len -> end of span / start of next gap region
//
// Gap extender entries (cov==0 && len==1) bridge gaps > 255 in the
- // source — skip them during redistribution (they are regenerated below
+ // source - skip them during redistribution (they are regenerated below
// wherever the recomputed destination gap still exceeds 255).
//
// left_last tracks the end of the last span written to the left texture;
@@ -489,7 +489,7 @@ _do_spatial_split(Span_Collector *sc, int overflow_y)
abs_x += gap; // start of this span in absolute coords
- // Skip source gap extender entries — just advance position.
+ // Skip source gap extender entries - just advance position.
if ((cov == 0) && (len == 1))
{
abs_x += len;
@@ -501,7 +501,7 @@ _do_spatial_split(Span_Collector *sc, int overflow_y)
if (span_end <= split_x)
{
- // Entirely in the left half — compact in place.
+ // Entirely in the left half - compact in place.
int new_gap = abs_x - left_last;
left_idx += _emit_gap_extenders(left_row, left_idx,
sc->max_spans,
@@ -516,7 +516,7 @@ _do_spatial_split(Span_Collector *sc, int overflow_y)
}
else if (abs_x >= split_x)
{
- // Entirely in the right half — move to new texture.
+ // Entirely in the right half - move to new texture.
int new_gap = abs_x - right_last;
right_idx += _emit_gap_extenders(right_row, right_idx,
sc->max_spans,
@@ -531,7 +531,7 @@ _do_spatial_split(Span_Collector *sc, int overflow_y)
}
else
{
- // Straddles the split point — divide at split_x.
+ // Straddles the split point - divide at split_x.
int left_len = split_x - abs_x;
int right_len = span_end - split_x;
@@ -550,7 +550,7 @@ _do_spatial_split(Span_Collector *sc, int overflow_y)
}
}
- // Right fragment starts exactly at split_x → gap = 0.
+ // Right fragment starts exactly at split_x -> gap = 0.
if (right_idx < sc->max_spans)
{
_write_span_entry(right_row + ((size_t)right_idx * 4),
@@ -569,7 +569,7 @@ _do_spatial_split(Span_Collector *sc, int overflow_y)
new_tex->span_counts[y] = right_idx;
new_tex->last_x_end[y] = right_last;
- // Clear tails of redistributed rows — stale entries beyond the
+ // Clear tails of redistributed rows - stale entries beyond the
// new span_counts have non-zero len bytes from the pre-split data.
// The collection callback's row-change memset won't cover these
// since the split happens mid-collection.
@@ -627,7 +627,7 @@ _find_texture_for_x(Span_Collector *sc, int x)
// prior frames beyond the current frame's last span.
//
// The memset covers exactly (max_spans + 1 - idx) entries starting at
-// index idx — only the unused tail, not the full row. When idx == 0 the
+// index idx - only the unused tail, not the full row. When idx == 0 the
// entire row is zeroed; when idx == max_spans nothing is done (row full,
// sentinel already provided by the spatial split path).
//
@@ -657,9 +657,9 @@ _flush_row_tail(Span_Collector *sc, int ti, int y)
// SW_FT_SpanFunc callback for Solid fills.
//
// Packs each span as 1 RGBA8 texel (4 bytes) into the Span_Texture row:
-// byte 0: gap — distance from end of previous span on this row
-// byte 1: len — span length (max 255; longer spans are split)
-// byte 2: coverage — AA coverage 0-255
+// byte 0: gap - distance from end of previous span on this row
+// byte 1: len - span length (max 255; longer spans are split)
+// byte 2: coverage - AA coverage 0-255
// byte 3: reserved (zero)
//
// The base color is passed to the shader as a uniform, not per-span.
@@ -688,7 +688,7 @@ _collect_spans_solid(int count, const SW_FT_Span *spans, void *user_data)
if (!sc) return;
// sd->color and sd->mul_col are constant across all spans in one
- // callback invocation — compute the composited base color once.
+ // callback invocation - compute the composited base color once.
// DRAW_MUL4_SYM is defined either via draw.h (engine build) or via
// evas_ector_gl_span.h (SPAN_COLLECTOR_TEST_BUILD).
sc->color = DRAW_MUL4_SYM(sd->color, sd->mul_col);
@@ -719,7 +719,7 @@ _collect_spans_solid(int count, const SW_FT_Span *spans, void *user_data)
// The buffer is hot in L1-D from the span writes above, so the
// memset is nearly free.
//
- // Only fires when y actually changes — not once per span.
+ // Only fires when y actually changes - not once per span.
if ((y != sc->flush_prev_y) && (sc->flush_prev_y >= 0) && (sc->flush_prev_ti >= 0))
_flush_row_tail(sc, sc->flush_prev_ti, sc->flush_prev_y);
@@ -729,7 +729,7 @@ _collect_spans_solid(int count, const SW_FT_Span *spans, void *user_data)
// When the row is full, attempt a spatial split so that the
// overflow span can still be routed to a new right-half texture.
- // On split success, retry the current span without advancing — the
+ // On split success, retry the current span without advancing - the
// textures array has been reorganised and _find_texture_for_x will
// now return a different (less-full) slot.
// On split failure (quota exhausted or degenerate geometry), drop
@@ -750,7 +750,7 @@ _collect_spans_solid(int count, const SW_FT_Span *spans, void *user_data)
//
// Memory layout: [cov, len, gap, reserved]
// GL_BGRA interprets: B=cov, G=len, R=gap, A=reserved
- // Shader reads: .r=gap, .g=len, .b=cov — correct.
+ // Shader reads: .r=gap, .g=len, .b=cov - correct.
//
// gap = distance from end of previous span on this row.
// Spans longer than 255 are split into multiple entries.
@@ -777,9 +777,9 @@ _collect_spans_solid(int count, const SW_FT_Span *spans, void *user_data)
while ((gap > 255) && (idx < sc->max_spans))
{
entry = tex->buffer + ((size_t)y * sc->stride) + ((size_t)idx * 4);
- entry[0] = 0; // cov = 0 → invisible
- entry[1] = 1; // len = 1 → advances x by 1
- entry[2] = 255; // gap = 255 → advances x by 255
+ entry[0] = 0; // cov = 0 -> invisible
+ entry[1] = 1; // len = 1 -> advances x by 1
+ entry[2] = 255; // gap = 255 -> advances x by 255
entry[3] = 0;
tex->rolling_hash = (tex->rolling_hash * 31) + *((const uint32_t *)entry);
gap -= 256; // 255 gap + 1 len = 256 pixels
@@ -801,10 +801,10 @@ _collect_spans_solid(int count, const SW_FT_Span *spans, void *user_data)
| ((uint32_t)g << 16);
entry = tex->buffer + ((size_t)y * sc->stride) + ((size_t)idx * 4);
- entry[0] = (uint8_t)cov; // byte0 → B in BGRA
- entry[1] = (uint8_t)chunk; // byte1 → G in BGRA
- entry[2] = (uint8_t)g; // byte2 → R in BGRA
- entry[3] = 0; // byte3 → A in BGRA
+ entry[0] = (uint8_t)cov; // byte0 -> B in BGRA
+ entry[1] = (uint8_t)chunk; // byte1 -> G in BGRA
+ entry[2] = (uint8_t)g; // byte2 -> R in BGRA
+ entry[3] = 0; // byte3 -> A in BGRA
tex->rolling_hash = (tex->rolling_hash * 31) + v;
}
@@ -845,7 +845,7 @@ _collect_spans_solid(int count, const SW_FT_Span *spans, void *user_data)
// identical (1 texel per span: gap, len, coverage, reserved). Gradient
// colors are NOT stored per-span; instead the fragment shader computes
// them per-pixel using:
-// - a 1024×1 RGBA8 gradient ramp texture (uploaded by eng_ector_end)
+// - a 1024x1 RGBA8 gradient ramp texture (uploaded by eng_ector_end)
// - three float coefficients (a, b, c) where t = a*px + b*py + c
// with px/py being FBO-space gl_FragCoord values.
//
@@ -884,10 +884,10 @@ _collect_spans_gradient(int count, const SW_FT_Span *spans, void *user_data)
// natively via the fragment shader.
//
// Supported methods (shader handles the blend via branchless mix()):
-// MATTE_ALPHA — result *= mask_a (u_mask_inv = 0.0)
-// MATTE_ALPHA_INVERSE — result *= (1 - mask_a) (u_mask_inv = 1.0)
-// MASK_INTERSECT — result *= mask_a (u_mask_inv = 0.0)
-// MASK_SUBSTRACT — result *= (1 - mask_a) (u_mask_inv = 1.0)
+// MATTE_ALPHA - result *= mask_a (u_mask_inv = 0.0)
+// MATTE_ALPHA_INVERSE - result *= (1 - mask_a) (u_mask_inv = 1.0)
+// MASK_INTERSECT - result *= mask_a (u_mask_inv = 0.0)
+// MASK_SUBSTRACT - result *= (1 - mask_a) (u_mask_inv = 1.0)
//
// INTERSECT uses the same shader math as MATTE_ALPHA; SUBSTRACT uses
// the same as MATTE_ALPHA_INVERSE. The semantic difference (how
@@ -895,8 +895,8 @@ _collect_spans_gradient(int count, const SW_FT_Span *spans, void *user_data)
// FBO rendering phase, not the source shape shader.
//
// Additive / difference modes (u_mask_op selects the math):
-// MASK_ADD — result.a = min(result.a + mask_a, 1.0) (u_mask_op = 1)
-// MASK_DIFFERENCE — result *= abs(result.a - mask_a) (u_mask_op = 2)
+// MASK_ADD - result.a = min(result.a + mask_a, 1.0) (u_mask_op = 1)
+// MASK_DIFFERENCE - result *= abs(result.a - mask_a) (u_mask_op = 2)
//
// All 6 composite methods are GPU-accelerated. NONE falls through.
//
diff --git a/src/modules/evas/engines/gl_generic/evas_ector_gl_span.h b/src/modules/evas/engines/gl_generic/evas_ector_gl_span.h
index 14d123a08a..4c5e6125ab 100644
--- a/src/modules/evas/engines/gl_generic/evas_ector_gl_span.h
+++ b/src/modules/evas/engines/gl_generic/evas_ector_gl_span.h
@@ -55,11 +55,11 @@ typedef enum _Span_Data_Type
// Span_Data struct: full definition when building in test mode so test code
// can declare stack instances and drive _collect_spans_solid directly.
// Must mirror the fields that _collect_spans_solid actually reads:
-// offx, offy — ector surface offset (zero in unit tests)
-// mul_col — multiplicative tint; set to 0xFFFFFFFF for identity
-// color (union) — premultiplied ARGB base color for Solid fills
-// type — fill type (Solid / LinearGradient / RadialGradient)
-// span_collector — pointer to the active Span_Collector
+// offx, offy - ector surface offset (zero in unit tests)
+// mul_col - multiplicative tint; set to 0xFFFFFFFF for identity
+// color (union) - premultiplied ARGB base color for Solid fills
+// type - fill type (Solid / LinearGradient / RadialGradient)
+// span_collector - pointer to the active Span_Collector
// In normal engine builds the full definition comes from ector_software_private.h.
# ifdef SPAN_COLLECTOR_TEST_BUILD
struct _Span_Data
@@ -67,18 +67,18 @@ struct _Span_Data
void *raster_buffer; // unused in tests; keeps struct layout sane
void *blend; // unused in tests
void *unclipped_blend; // unused in tests
- int offx, offy; // ector surface offset — set to 0 in tests
+ int offx, offy; // ector surface offset - set to 0 in tests
void *clip; // unused in tests
- int type; // Span_Data_Type cast — Solid=1, etc.
+ int type; // Span_Data_Type cast - Solid=1, etc.
uint32_t mul_col; // multiplicative tint; 0xFFFFFFFF = identity
- int op; // render op — unused in tests
+ int op; // render op - unused in tests
union {
uint32_t color; // premultiplied ARGB for Solid fills
- void *gradient; // gradient pointer — unused in span tests
+ void *gradient; // gradient pointer - unused in span tests
void *buffer; // unused in tests
};
void *span_collector; // active Span_Collector *
- Eina_Matrix3 inv; // inverse transform matrix — identity in tests
+ Eina_Matrix3 inv; // inverse transform matrix - identity in tests
};
// DRAW_MUL4_SYM: symmetric 8-bit channel multiply used to composite mul_col
@@ -132,17 +132,17 @@ typedef struct _Span_Collector Span_Collector;
//
// Each entry is 1 texel (4 bytes) for all fill types (Solid, LinearGradient,
// RadialGradient):
-// byte 0 (BGRA B): coverage — AA coverage 0-255
-// byte 1 (BGRA G): len — span length (max 255; longer spans are split)
-// byte 2 (BGRA R): gap — distance from end of previous span on this row
-// byte 3 (BGRA A): reserved — zero
+// byte 0 (BGRA B): coverage - AA coverage 0-255
+// byte 1 (BGRA G): len - span length (max 255; longer spans are split)
+// byte 2 (BGRA R): gap - distance from end of previous span on this row
+// byte 3 (BGRA A): reserved - zero
//
// The buffer is stored in BGRA-swapped byte order for direct upload.
// The shader reads: .r=gap, .g=len, .b=coverage.
//
// For Solid fills: the base color is passed as a shader uniform.
// For LinearGradient / RadialGradient fills: the gradient ramp texture
-// (1024×1 RGBA8) and per-pixel t-computation coefficients are passed as
+// (1024x1 RGBA8) and per-pixel t-computation coefficients are passed as
// shader uniforms. No per-span color data is stored in the span buffer.
//
// The rows do not get a GPU texture of their own. Every Span_Texture of
@@ -194,7 +194,7 @@ struct _Span_Collector
// The +1 reserves a dedicated sentinel slot.
int actual_max_spans; // max span_counts[y] seen during collection this frame
- // Row-tail flush state — tracked across multiple _collect_spans_solid
+ // Row-tail flush state - tracked across multiple _collect_spans_solid
// invocations (e.g., when _span_fill_clipRect calls the callback in
// chunks). Reset in span_collector_clear.
int flush_prev_y; // last row flushed (-1 = none)
@@ -212,7 +212,7 @@ struct _Span_Collector
// Ector surface offset captured during _collect_spans_gradient().
// These are the x/y values passed to ector_surface_reference_point_set().
- // Needed to fold the local→canvas translation into the t-coefficients.
+ // Needed to fold the local->canvas translation into the t-coefficients.
int grad_offx;
int grad_offy;
@@ -260,7 +260,7 @@ void span_collector_clear(Span_Collector *sc);
//
// Follows the Evas high-water mark pattern: buffers grow via realloc when
// @p h exceeds alloc_h, but never shrink. When @p h is within
-// alloc_h, only the active height is updated — no allocation.
+// alloc_h, only the active height is updated - no allocation.
void span_collector_resize(Span_Collector *sc, int h);
// ------------------------------------------------------------------
@@ -278,8 +278,8 @@ void _collect_spans_solid(int count, const SW_FT_Span *spans, void *user_data);
//
// Thin wrapper around _collect_spans_solid(): packs spans in the same
// 1-texel format (gap, len, coverage, reserved). The gradient shader
-// computes per-pixel colors from a 1024×1 ramp texture and per-frame
-// t-computation coefficients passed as uniforms — no per-span color data
+// computes per-pixel colors from a 1024x1 ramp texture and per-frame
+// t-computation coefficients passed as uniforms - no per-span color data
// is written into the span buffer.
//
// Sets sc->type = sd->type and captures sc->gradient_data and
diff --git a/src/modules/evas/engines/gl_generic/evas_ector_gl_span_shader.c b/src/modules/evas/engines/gl_generic/evas_ector_gl_span_shader.c
index a573b34406..6635d36f38 100644
--- a/src/modules/evas/engines/gl_generic/evas_ector_gl_span_shader.c
+++ b/src/modules/evas/engines/gl_generic/evas_ector_gl_span_shader.c
@@ -149,7 +149,7 @@ static const char _glsl_varyings_mask[] =
"varying mediump vec2 v_mask_comp_inv;\n";
// ------------------------------------------------------------------
-// Attribute declaration blocks (per-vertex data → VS input)
+// Attribute declaration blocks (per-vertex data -> VS input)
// ------------------------------------------------------------------
static const char _glsl_attributes_common[] =
@@ -176,7 +176,7 @@ static const char _glsl_attributes_mask[] =
"attribute mediump vec2 a_mask_comp_inv;\n";
// ------------------------------------------------------------------
-// Vertex shader main bodies — one per variant family
+// Vertex shader main bodies - one per variant family
// ------------------------------------------------------------------
// Solid, no mask.
@@ -196,7 +196,7 @@ static const char _glsl_vs_main_solid[] =
"}\n";
// Solid with composite mask.
-// Decodes comp_method (slot 0) → mask_op (0=multiply,1=add,2=difference)
+// Decodes comp_method (slot 0) -> mask_op (0=multiply,1=add,2=difference)
// so the FS can keep its existing mop < 0.5 / mop < 1.5 logic.
// Slot 1 (mask_inv) is already pre-decoded by _span_fill_vertices.
static const char _glsl_vs_main_solid_mask[] =
@@ -353,7 +353,7 @@ _span_tier_get(void)
{
// Both queries came back 0: this means glGetIntegerv failed (e.g. no
// current GL context yet), not that the device genuinely reports 0
- // attributes/varyings. Do not memoize — leave _span_tier_resolved
+ // attributes/varyings. Do not memoize - leave _span_tier_resolved
// unresolved so the next call (once a context is current) retries.
INF("span tier query returned 0/0; assuming no current GL context, "
"will retry on next call");
@@ -408,7 +408,7 @@ static const char _glsl_uniforms_shared[] =
//
// Per-shape data (offsets, x_min, has_fill/has_stroke) moved to varyings.
// Samplers still declared as uniforms; the has_fill/has_stroke values are
-// decoded from v_has_flags in main() — no per-binding defines needed.
+// decoded from v_has_flags in main() - no per-binding defines needed.
static const char _glsl_uniforms_bind_fs[] =
"uniform sampler2D u_fill_spans;\n"
"uniform sampler2D u_stroke_spans;\n";
@@ -437,13 +437,13 @@ static const char _glsl_uniforms_bind_s[] =
static const char _glsl_uniforms_mask[] =
"uniform sampler2D u_mask_tex;\n";
-// scan_spans() — shared by solid and solid_mask shaders.
+// scan_spans() - shared by solid and solid_mask shaders.
//
// Each span entry is 1 texel (4 bytes) in the span texture:
-// byte0 (B): coverage — AA coverage 0-255
-// byte1 (G): len — span length (max 255; longer spans are split)
-// byte2 (R): gap — distance from end of previous span on this row
-// byte3 (A): reserved — zero
+// byte0 (B): coverage - AA coverage 0-255
+// byte1 (G): len - span length (max 255; longer spans are split)
+// byte2 (R): gap - distance from end of previous span on this row
+// byte3 (A): reserved - zero
static const char _glsl_scan_spans[] =
"\n"
"/* Scan one span texture row, accumulating coverage-weighted base_col\n"
@@ -470,7 +470,7 @@ static const char _glsl_scan_spans[] =
" return res;\n"
"}\n";
-// grad_spread() — shared by gradient and gradient_mask shaders.
+// grad_spread() - shared by gradient and gradient_mask shaders.
//
// Spread modes:
// spread == 0 (PAD): t = clamp(t, 0.0, 1.0)
@@ -496,7 +496,7 @@ static const char _glsl_grad_spread[] =
" return t;\n"
"}\n";
-// scan_gradient_spans() — shared by gradient and gradient_mask shaders.
+// scan_gradient_spans() - shared by gradient and gradient_mask shaders.
//
// Span buffer format identical to the solid shader (gap, len, coverage).
// On hit, computes gradient parameter t per-pixel (linear or radial) and
@@ -639,7 +639,7 @@ static const char _glsl_main_end[] =
// Mask epilogue: sample the composite mask texture and apply it.
// v_mask_comp_inv.x: decoded mask_op (0=multiply, 1=add, 2=difference)
-// — decoded in the VS from raw comp_method to save per-fragment work.
+// - decoded in the VS from raw comp_method to save per-fragment work.
// v_mask_comp_inv.y: mask_inv (0=normal, 1=invert, multiply path only).
static const char _glsl_mask_epilogue[] =
"\n"
@@ -783,22 +783,22 @@ _span_vs_parts_build(int kind, int mask, int *out_count)
typedef struct
{
unsigned int program;
- // Uniform locations — samplers and pool reciprocals only.
+ // Uniform locations - samplers and pool reciprocals only.
// Per-shape data travels in vertex attributes, whose locations are the
// fixed SPAN_ATTR_* constants bound before linking.
int loc_fill_spans;
int loc_stroke_spans;
int loc_inv_tw;
int loc_inv_th;
- // Gradient atlas sampler — valid only in gradient variants (-1 otherwise).
+ // Gradient atlas sampler - valid only in gradient variants (-1 otherwise).
int loc_grad_ramp_atlas;
- // Mask sampler — valid only in mask variants (-1 otherwise).
+ // Mask sampler - valid only in mask variants (-1 otherwise).
int loc_mask_tex;
// Sampler uniforms are program state; assign the texture units once.
Eina_Bool samplers_bound;
} Span_Shader;
-// [kind][bind][mask] — kind 0=solid 1=gradient, bind in Span_Bind_Set, mask 0/1.
+// [kind][bind][mask] - kind 0=solid 1=gradient, bind in Span_Bind_Set, mask 0/1.
// 12 variants total: eliminates unused sampler declarations per binding set.
static Span_Shader _span_shaders[2][SPAN_BIND_COUNT][2];
@@ -820,7 +820,7 @@ typedef enum {
static Span_Shader_State _span_shader_state = SPAN_SHADER_UNTRIED;
-// 1x1 white texture — kept for potential fallback use; not bound during
+// 1x1 white texture - kept for potential fallback use; not bound during
// normal rendering (non-mask shaders have no mask sampler at all).
static GLuint _white_mask_tex = 0;
@@ -1050,7 +1050,7 @@ _link_program(Span_Shader *ss,
// Bind attribute locations explicitly, before linking, so that every
// variant places a given semantic at the same index. Without this the
// linker is free to assign per-program locations, and a vertex array
- // object — whose state is keyed by location, not by program — could not
+ // object - whose state is keyed by location, not by program - could not
// be shared between the programs that use the same vertex layout.
//
// Solid and gradient variants deliberately overlap on 5/6: a VAO is
@@ -1090,14 +1090,14 @@ _link_program(Span_Shader *ss,
return EINA_FALSE;
}
- // Uniform locations — only samplers and pool reciprocals remain.
+ // Uniform locations - only samplers and pool reciprocals remain.
ss->loc_fill_spans = glGetUniformLocation(ss->program, "u_fill_spans");
ss->loc_stroke_spans = glGetUniformLocation(ss->program, "u_stroke_spans");
ss->loc_inv_tw = glGetUniformLocation(ss->program, "u_inv_tw");
ss->loc_inv_th = glGetUniformLocation(ss->program, "u_inv_th");
- // Gradient atlas — location -1 in solid shaders (safe no-op).
+ // Gradient atlas - location -1 in solid shaders (safe no-op).
ss->loc_grad_ramp_atlas = glGetUniformLocation(ss->program, "u_grad_ramp_atlas");
- // Mask sampler — location -1 in non-mask shaders (safe no-op).
+ // Mask sampler - location -1 in non-mask shaders (safe no-op).
ss->loc_mask_tex = glGetUniformLocation(ss->program, "u_mask_tex");
// Attribute locations are the constants bound above, not queried: an
@@ -1203,7 +1203,7 @@ span_shader_init(void)
}
}
- // Create 1x1 white texture — kept as a potential no-mask fallback.
+ // Create 1x1 white texture - kept as a potential no-mask fallback.
if (!_white_mask_tex)
{
uint8_t white[4] = { 255, 255, 255, 255 };
@@ -1676,7 +1676,7 @@ _span_draw_batch(Evas_Engine_GL_Context *gc, Span_Variant variant,
if (!vao)
{
// No vertex array objects: respecify the layout for every draw.
- // Locations left enabled afterwards are benign — image/font shaders
+ // Locations left enabled afterwards are benign - image/font shaders
// bind their own slots explicitly and never fetch from ours.
Span_Attr_Desc desc[16];
int n = _span_attr_layout(variant, desc);
diff --git a/src/modules/evas/engines/gl_generic/evas_engine.c b/src/modules/evas/engines/gl_generic/evas_engine.c
index c1d8695263..eb211d2b92 100644
--- a/src/modules/evas/engines/gl_generic/evas_engine.c
+++ b/src/modules/evas/engines/gl_generic/evas_engine.c
@@ -181,7 +181,7 @@ eng_engine_new(void)
generic_cache_size_func_set(engine->software.surface_cache,
_ector_surface_cache_size);
- // Gradient ramp atlas: NULL return means atlas unavailable — gradient
+ // Gradient ramp atlas: NULL return means atlas unavailable - gradient
// shapes will be skipped per the spec error table (no-op, non-fatal).
engine->span_page = span_page_new();
engine->grad_atlas = span_grad_atlas_new();
@@ -2674,7 +2674,7 @@ eng_ector_mask_surface_create(void *engine, int width, int height, int *error)
if (span_path_usable())
{
- // Mask FBO must use a dedicated texture — not shared with the atlas.
+ // Mask FBO must use a dedicated texture - not shared with the atlas.
// The main VG FBO and the mask FBO would otherwise map to the same GL
// texture object, creating a read/write feedback loop when the span
// shader samples the mask while rendering into the main FBO.
@@ -2687,7 +2687,7 @@ eng_ector_mask_surface_create(void *engine, int width, int height, int *error)
else
{
// Span path unusable: this GL-mask branch has no CPU-backed
- // counterpart that eng_ector_end() knows how to consume — the mask
+ // counterpart that eng_ector_end() knows how to consume - the mask
// it produces is only ever read from espd->gl_comp_surface inside
// the span draw loop. Fail here so efl_canvas_vg_container.c's
// caller takes its "gl_mask_fallback" path instead, which uses the
@@ -2887,7 +2887,7 @@ eng_ector_begin(void *engine, void *surface,
// the underlying Span_Collector* slots are reused/cleared on demand.
//
// Skip-collection is not yet implemented for the multi-collector
- // model — it would require per-collector hash storage.
+ // model - it would require per-collector hash storage.
{
Ector_Software_Surface_Data *pd =
efl_data_scope_get(ector, ECTOR_SOFTWARE_SURFACE_CLASS);
@@ -2910,7 +2910,7 @@ eng_ector_begin(void *engine, void *surface,
if (fgc) evas_gl_common_context_flush(fgc);
}
- // Reset counts — existing collectors are reused by the alloc cb.
+ // Reset counts - existing collectors are reused by the alloc cb.
pd->span_collectors_fill_count = 0;
pd->span_collectors_stroke_count = 0;
@@ -2921,7 +2921,7 @@ eng_ector_begin(void *engine, void *surface,
sd->span_is_stroke = EINA_FALSE;
// Reaching here means span_path_usable() already returned
- // EINA_TRUE (checked at function entry above) — the
+ // EINA_TRUE (checked at function entry above) - the
// !span_path_usable() case returns early with the CPU
// fallback and never installs collectors, so ector does not
// emit spans that nothing consumes.
@@ -2978,7 +2978,7 @@ _span_gradient_linear_coeffs(Ector_Renderer_Software_Gradient_Data *gd,
// (ector_software_rasterizer.c) and never reaches the gradient
// parameter. The shader instead evaluates at px/py in surface space,
// which does include that origin, so the translation has to be undone
- // here — otherwise the gradient slides across the shape by
+ // here - otherwise the gradient slides across the shape by
// (a*offx + b*offy) in ramp units.
//
// The shader receives px = gl_FragCoord.x - fbo_offset which already
@@ -3039,7 +3039,7 @@ _span_gradient_radial_coeffs(Ector_Renderer_Software_Gradient_Data *gd,
*out_f = (float)(inv->yz - gd->radial.fy
- (inv->yx * (double)offx) - (inv->yy * (double)offy));
- // Quadratic parameters — pass inv2a instead of a to avoid
+ // Quadratic parameters - pass inv2a instead of a to avoid
// per-fragment division in the shader.
*out_ra = (float)(0.5 / gd->radial.a);
*out_rdx = (float)gd->radial.dx;
@@ -3051,16 +3051,16 @@ _span_gradient_radial_coeffs(Ector_Renderer_Software_Gradient_Data *gd,
// Inspects sc->type and sc->gradient_data. When sc is non-NULL and holds
// gradient data this function fills all out parameters and may downgrade
// *inout_shader_type from LinearGradient/RadialGradient to Solid when the
-// radial geometry degenerates (fradius != 0 or a ≈ 0). When sc is NULL
+// radial geometry degenerates (fradius != 0 or a ~ 0). When sc is NULL
// or has no gradient data all out values are left at their zero defaults.
//
// @param sc Span collector for this channel (fill or stroke).
-// @param atlas Gradient ramp atlas (may be NULL → gradient skipped).
+// @param atlas Gradient ramp atlas (may be NULL -> gradient skipped).
// @param inout_shader_type On entry: LinearGradient or RadialGradient.
// On exit: may be downgraded to Solid.
-// @param inout_col Solid color — updated when downgraded to Solid.
+// @param inout_col Solid color - updated when downgraded to Solid.
// @param out_ga..out_grdy Output gradient coefficients.
-// @param out_gs Gradient spread mode (EFL enum → int).
+// @param out_gs Gradient spread mode (EFL enum -> int).
// @param out_gramp_y Atlas V coordinate for this gradient's ramp row.
// @param out_atlas_skip Set to EINA_TRUE if atlas lookup failed (skip shape).
static void
@@ -3083,7 +3083,7 @@ _compute_gradient_coeffs(Span_Collector *sc,
// Upload ramp into atlas and get V coordinate.
// version is the CRC32 of gd->color_table's native uint32 content (4096 B).
// The identity fast path in span_grad_atlas_lookup is keyed on (grad_id,
- // content_crc) — animated stop changes force a re-lookup automatically.
+ // content_crc) - animated stop changes force a re-lookup automatically.
// Fallback: if atlas is unavailable, mark the shape as atlas-skip.
//
// Tier-3 cache: skip the 4 KB CRC recompute on frames where the
@@ -3092,7 +3092,7 @@ _compute_gradient_coeffs(Span_Collector *sc,
// regen in flight, or pointer realloc).
if (!(atlas && gd->color_table && (gd->ctable_status == CTABLE_READY_DONE)))
{
- // Ramp not ready or atlas unavailable — invalidate gd-side cache so
+ // Ramp not ready or atlas unavailable - invalidate gd-side cache so
// that when status returns to READY we recompute the CRC against
// potentially new content.
gd->cached_ctable_crc_valid = EINA_FALSE;
@@ -3100,8 +3100,8 @@ _compute_gradient_coeffs(Span_Collector *sc,
return;
}
- // Pass gd->color_table directly — no staging rearrangement needed.
- // _upload_row in the atlas does the ARGB→RGBA swap at GL upload time.
+ // Pass gd->color_table directly - no staging rearrangement needed.
+ // _upload_row in the atlas does the ARGB->RGBA swap at GL upload time.
//
// Tier-3 cache: skip the 4 KB CRC recompute on frames where color_table
// content has not changed. Staleness signal: the framework cycles
@@ -3128,7 +3128,7 @@ _compute_gradient_coeffs(Span_Collector *sc,
version, ramp_bytes);
if (row < 0)
{
- // Atlas disabled or full — skip this shape.
+ // Atlas disabled or full - skip this shape.
*out_atlas_skip = EINA_TRUE;
return;
}
@@ -3145,7 +3145,7 @@ _compute_gradient_coeffs(Span_Collector *sc,
{
if ((gd->radial.fradius >= 0.00001f) || (fabsf(gd->radial.a) <= 0.00001f))
{
- // Degenerate radial — fall back to solid using first stop color.
+ // Degenerate radial - fall back to solid using first stop color.
*inout_shader_type = (int)Solid;
if (gd->color_table)
*inout_col = gd->color_table[0];
@@ -3203,7 +3203,7 @@ eng_ector_end(void *engine,
Evas_GL_Image *glim = surface;
// _span_collector_alloc updates espd-> arrays directly (it receives
- // espd as its data pointer). No sync-back from Span_Data needed —
+ // espd as its data pointer). No sync-back from Span_Data needed -
// the counts and pointers on espd are already authoritative.
{
@@ -3262,7 +3262,7 @@ eng_ector_end(void *engine,
// Clear FBO sub-region to transparent via glClear + scissor.
//
// On tile-based GPUs (Broadcom V3D / ARM Mali) glClear is
- // a tile-buffer flag — no main-memory traffic — whereas the
+ // a tile-buffer flag - no main-memory traffic - whereas the
// previous SHD_RECT + immediate flush forced a tile store
// and reload before the span draws. The clear happens
// outside the pipe system, so no pipe-reorder races; we
@@ -3486,7 +3486,7 @@ eng_ector_end(void *engine,
//
// NDC must be divided by the TARGET SURFACE
// dimensions, not gc->w/gc->h. When VG content
- // is drawn into an FBO (the common case — VG
+ // is drawn into an FBO (the common case - VG
// renders to an atlas-pool sub-rect via glim),
// gc->w/h still hold the main window dimensions
// because _evas_gl_common_viewport_set never
@@ -3547,7 +3547,7 @@ eng_ector_end(void *engine,
}
span_done:
- // Do NOT reset ector surface dimensions to 0 here — the pixel
+ // Do NOT reset ector surface dimensions to 0 here - the pixel
// buffer is managed by the high-water mark path in eng_ector_begin
// and must persist across begin/end cycles within the same frame
// (VG objects may be rendered multiple times per frame).
diff --git a/src/tests/ector/suite/ector_test_grad_atlas.c b/src/tests/ector/suite/ector_test_grad_atlas.c
index 79c8254066..75c509cc27 100644
--- a/src/tests/ector/suite/ector_test_grad_atlas.c
+++ b/src/tests/ector/suite/ector_test_grad_atlas.c
@@ -114,7 +114,7 @@ EFL_START_TEST(grad_atlas_lru_eviction)
1, ramp);
ck_assert_int_ge(first_rows[i], 0);
}
- // The oldest row was filled at frame 1 — that's first_rows[0].
+ // The oldest row was filled at frame 1 - that's first_rows[0].
int oldest_row = first_rows[0];
// Insert a 65th distinct ramp. Must evict oldest_row.
@@ -137,7 +137,7 @@ EFL_START_TEST(grad_atlas_content_dedup_across_distinct_grad_ids)
uint8_t ramp[SPAN_GRAD_ATLAS_ROW_BYTES];
_fill_ramp(ramp, 42);
- // Two different grad_ids with identical content — second should hit
+ // Two different grad_ids with identical content - second should hit
// the hash+memcmp path and return the same row.
int r1 = span_grad_atlas_lookup(a, (void *)0x1000, 1, ramp);
ck_assert_int_ge(r1, 0);
@@ -152,7 +152,7 @@ EFL_END_TEST
EFL_START_TEST(grad_atlas_hash_collision_distinguished_by_memcmp)
{
- // Two distinct ramp contents — even if they hashed to the same value
+ // Two distinct ramp contents - even if they hashed to the same value
// (rare in practice for FNV-1a over 4 KB), memcmp must detect they
// differ and allocate a second row. We can't easily synthesize a
// real collision, but we CAN simulate the logic by inserting two
@@ -169,7 +169,7 @@ EFL_START_TEST(grad_atlas_hash_collision_distinguished_by_memcmp)
uint8_t ramp_b[SPAN_GRAD_ATLAS_ROW_BYTES];
_fill_ramp(ramp_a, 1001);
_fill_ramp(ramp_b, 1002);
- // Confirm they differ — fail loud if our pattern collides accidentally.
+ // Confirm they differ - fail loud if our pattern collides accidentally.
ck_assert_int_ne(memcmp(ramp_a, ramp_b, SPAN_GRAD_ATLAS_ROW_BYTES), 0);
int ra = span_grad_atlas_lookup(a, (void *)0x1000, 1, ramp_a);
@@ -198,7 +198,7 @@ EFL_START_TEST(grad_atlas_version_change_evicts_or_refreshes)
int r1 = span_grad_atlas_lookup(a, grad, 1, ramp_v1);
ck_assert_int_ge(r1, 0);
- // Version bumps + content changes — must NOT return r1 via identity
+ // Version bumps + content changes - must NOT return r1 via identity
// (version differs); content also differs so hash path won't dedup.
// Result: a fresh row is allocated.
int r2 = span_grad_atlas_lookup(a, grad, 2, ramp_v2);
diff --git a/src/tests/ector/suite/ector_test_span_collector.c b/src/tests/ector/suite/ector_test_span_collector.c
index 3140c0749a..bd5a12cd46 100644
--- a/src/tests/ector/suite/ector_test_span_collector.c
+++ b/src/tests/ector/suite/ector_test_span_collector.c
@@ -18,26 +18,26 @@
// Unit tests for the span-buffer collector (1-texel gap-encoded format).
//
// The current format stores each span as one RGBA8 texel (4 bytes):
-// byte[0] (B): coverage — AA coverage 0-255
-// byte[1] (G): len — span length (0-255; 0 == sentinel)
-// byte[2] (R): gap — distance from end of previous span on this row
+// byte[0] (B): coverage - AA coverage 0-255
+// byte[1] (G): len - span length (0-255; 0 == sentinel)
+// byte[2] (R): gap - distance from end of previous span on this row
// (first span's gap is relative to x_min of the texture)
-// byte[3] (A): reserved — always 0
+// byte[3] (A): reserved - always 0
//
// stride = (max_spans + 1) * 4 bytes per row. The extra +1 slot holds the
// zero-length sentinel (byte[1] == 0) that terminates the shader scan loop.
//
-// sc->color is a premultiplied ARGB uniform — it is NOT written into the
+// sc->color is a premultiplied ARGB uniform - it is NOT written into the
// span buffer. The callback sets sc->color = DRAW_MUL4_SYM(sd->color,
// sd->mul_col) before packing spans.
//
// To drive _collect_spans_solid in the test binary we set:
-// sd.mul_col = 0xFFFFFFFF — identity, so sc->color == sd.color
+// sd.mul_col = 0xFFFFFFFF - identity, so sc->color == sd.color
// sd.color = desired_color
-// sd.offx = sd.offy = 0 — no ector surface offset
+// sd.offx = sd.offy = 0 - no ector surface offset
//
// Tests exercise span_collector_new/free and _collect_spans_solid in
-// isolation — no GL context is required because upload/draw stubs are
+// isolation - no GL context is required because upload/draw stubs are
// compiled as no-ops when SPAN_COLLECTOR_TEST_BUILD is defined.
#ifdef HAVE_CONFIG_H
@@ -70,7 +70,7 @@ _sd_init_solid(Span_Data *sd, Span_Collector *sc, uint32_t color)
sd->color = color;
sd->mul_col = 0xFFFFFFFF; // identity: DRAW_MUL4_SYM(c, 0xFFFFFFFF) == c
sd->type = Solid;
- // offx, offy default to 0 — no ector surface translation
+ // offx, offy default to 0 - no ector surface translation
}
// Walk one texture row and reconstruct (absolute_x, len) pairs for every
@@ -106,7 +106,7 @@ _reconstruct_spans(Span_Texture *tex, int y, int stride, int max_ent,
abs_x += gap;
- // Gap extender: cov==0, len==1 — advances position, not a real span.
+ // Gap extender: cov==0, len==1 - advances position, not a real span.
if (cov == 0 && len == 1)
{
abs_x += len;
@@ -136,7 +136,7 @@ _reconstruct_spans(Span_Texture *tex, int y, int stride, int max_ent,
// entry byte[2] == 50 (gap from x_min=0, so gap == x)
// entry byte[3] == 0 (reserved)
//
-// sc->color is set via DRAW_MUL4_SYM(sd.color, sd.mul_col) — not written
+// sc->color is set via DRAW_MUL4_SYM(sd.color, sd.mul_col) - not written
// to the buffer, so we do NOT assert buffer bytes against color values.
EFL_START_TEST(span_collector_solid_single)
{
@@ -199,14 +199,14 @@ EFL_START_TEST(span_collector_solid_sentinel)
// Sentinel is at entry index 1 (one past the span we wrote).
sentinel = sc->textures[0].buffer + (5 * sc->stride) + (1 * 4);
- ck_assert_int_eq(sentinel[1], 0); // len == 0 → sentinel
+ ck_assert_int_eq(sentinel[1], 0); // len == 0 -> sentinel
span_collector_free(sc);
}
EFL_END_TEST
// ------------------------------------------------------------------
-// Test 3: multiple spans on the same row — gap encoding
+// Test 3: multiple spans on the same row - gap encoding
// ------------------------------------------------------------------
// Write 3 spans on row 20:
@@ -353,7 +353,7 @@ EFL_START_TEST(span_collector_gap_extender)
ck_assert_int_eq(e2[1], 1);
ck_assert_int_eq(e2[2], 255);
- // Entry 3: span B — remainder gap = 585 - 2*256 = 73
+ // Entry 3: span B - remainder gap = 585 - 2*256 = 73
ck_assert_int_eq(e3[0], 100); // coverage
ck_assert_int_eq(e3[1], 5); // len
ck_assert_int_eq(e3[2], 73); // gap = 585 - 512
@@ -610,12 +610,12 @@ EFL_START_TEST(span_collector_post_split_routing)
EFL_END_TEST
// ------------------------------------------------------------------
-// Test 9: gradient format invariants — stride == (max_spans+1)*4
+// Test 9: gradient format invariants - stride == (max_spans+1)*4
// ------------------------------------------------------------------
// Verifies that span_collector_new() sets stride correctly for gradient
// fill types. Stride must be (max_spans + 1) * 4 bytes for all types
-// (Solid, LinearGradient, RadialGradient) — the +1 is the sentinel slot.
+// (Solid, LinearGradient, RadialGradient) - the +1 is the sentinel slot.
//
// Actual gradient color sampling (which requires a gradient ramp texture
// and t-coefficient uniforms) is tested in the integration suite. Here
@@ -642,7 +642,7 @@ EFL_START_TEST(span_collector_gradient_basic)
EFL_END_TEST
// ------------------------------------------------------------------
-// Test 10: overflow drop test (legacy) — preserved for regression
+// Test 10: overflow drop test (legacy) - preserved for regression
// ------------------------------------------------------------------
// Original regression test: with max_spans=4, write exactly 4 spans
@@ -752,7 +752,7 @@ EFL_END_TEST
// Call span_collector_clear (simulating a frame boundary).
// Frame 2: write NO span on row 3.
//
-// Verify that byte[1] of entry 0 on row 3 is 0 after clear — the shader
+// Verify that byte[1] of entry 0 on row 3 is 0 after clear - the shader
// must see len=0 at the very first entry on a row that received no spans.
EFL_START_TEST(span_collector_clear_stale_sentinel)
{
@@ -782,7 +782,7 @@ EFL_START_TEST(span_collector_clear_stale_sentinel)
// Frame 2: no spans written on row 3. span_counts[3] == 0.
ck_assert_int_eq(sc->textures[0].span_counts[3], 0);
- // byte[1] of entry 0 must be 0 — the sentinel the shader relies on.
+ // byte[1] of entry 0 must be 0 - the sentinel the shader relies on.
entry0 = sc->textures[0].buffer + (3 * sc->stride);
ck_assert_int_eq(entry0[1], 0);
diff --git a/src/tests/ector/suite/meson.build b/src/tests/ector/suite/meson.build
index 338a652bc4..f4788bf371 100644
--- a/src/tests/ector/suite/meson.build
+++ b/src/tests/ector/suite/meson.build
@@ -7,10 +7,10 @@ ector_suite_src = [
]
# Include directories for the test suite:
-# '..' — resolves ../efl_check.h via the -I../src/tests/ector
+# '..' - resolves ../efl_check.h via the -I../src/tests/ector
# search path that meson adds automatically
-# gl_generic — provides evas_ector_gl_span.h
-# freetype — provides sw_ft_raster.h (needed by evas_ector_gl_span.h)
+# gl_generic - provides evas_ector_gl_span.h
+# freetype - provides sw_ft_raster.h (needed by evas_ector_gl_span.h)
ector_suite_inc = [
include_directories('..'),
include_directories(
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
