1
//----------------------------------------------------------------------------
2
// Anti-Grain Geometry - Version 2.4 (Public License)
3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
5
// Anti-Grain Geometry - Version 2.4 Release Milano 3 (AggPas 2.4 RM3)
6
// Pascal Port By: Milan Marusinec alias Milano
8
// http://www.aggpas.org
9
// Copyright (c) 2005-2006
11
// Permission to copy, use, modify, sell and distribute this software
12
// is granted provided this copyright notice appears in all copies.
13
// This software is provided "as is" without express or implied
14
// warranty, and with no claim as to its suitability for any purpose.
16
//----------------------------------------------------------------------------
17
// Contact: mcseem@antigrain.com
18
// mcseemagg@yahoo.com
19
// http://www.antigrain.com
21
// [Pascal Port History] -----------------------------------------------------
23
// 23.06.2006-Milano: ptrcomp adjustments
24
// 15.02.2006-Milano: Unit port establishment
26
{ agg_scanline_storage_aa.pas }
28
agg_scanline_storage_aa ;
39
agg_renderer_scanline ,
40
agg_render_scanlines ,
41
agg_rasterizer_scanline_aa ;
45
//----------------------------------------------scanline_cell_storage
46
extra_span_ptr = ^extra_span;
53
scanline_cell_storage_ptr = ^scanline_cell_storage;
54
scanline_cell_storage = object
56
m_extra_storage : pod_deque;
58
constructor Construct(entry_sz : unsigned ); overload;
59
constructor Construct(v : scanline_cell_storage_ptr ); overload;
63
function add_cells(cells : pointer; num_cells : unsigned ) : int;
65
function assign_operator(v : scanline_cell_storage_ptr ) : scanline_cell_storage_ptr;
66
function array_operator (idx : int ) : pointer;
68
procedure copy_extra_storage(v : scanline_cell_storage_ptr );
72
//-----------------------------------------------scanline_storage_aa
73
span_data_ss_ptr = ^span_data_ss;
76
len : int32; // If negative, it's a solid span, covers is valid
77
covers_id : int; // The index of the cells in the scanline_cell_storage
81
scanline_data_ss_ptr = ^scanline_data_ss;
82
scanline_data_ss = record
85
start_span : unsigned;
89
span_ss_ptr = ^span_ss;
92
len : int32; // If negative, it's a solid span, covers is valid
98
scanline_storage_aa_ptr = ^scanline_storage_aa;
100
embedded_scanline_ss_ptr = ^embedded_scanline_ss;
102
const_iterator_ss = object(span_obj )
103
m_storage : scanline_storage_aa_ptr;
104
m_span_idx : unsigned;
107
constructor Construct(sl : embedded_scanline_ss_ptr );
109
function x : int; virtual;
110
function len : int; virtual;
111
function covers : int8u_ptr; virtual;
113
procedure inc_operator; virtual;
118
embedded_scanline_ss = object(scanline )
119
m_storage : scanline_storage_aa_ptr;
120
m_scanline : scanline_data_ss;
121
m_scanline_idx : unsigned;
123
m_result : const_iterator_ss;
125
constructor Construct(storage : scanline_storage_aa_ptr );
127
procedure reset(min_x ,max_x : int ); virtual;
129
function y : int; virtual;
130
function num_spans : unsigned; virtual;
131
function begin_ : pointer; virtual;
133
function sz_of_span : unsigned; virtual;
134
function is_plain_span : boolean; virtual;
135
function is_embedded : boolean; virtual;
137
procedure setup(scanline_idx : unsigned ); virtual;
141
scanline_storage_aa = object(renderer_scanline )
142
m_covers : scanline_cell_storage;
144
m_scanlines : pod_deque;
146
m_fake_span : span_data_ss;
147
m_fake_scanline : scanline_data_ss;
154
m_cur_scanline : unsigned;
156
constructor Construct;
159
// Renderer Interface
160
procedure prepare(u : unsigned ); virtual;
161
procedure render (sl : scanline_ptr ); virtual;
163
// Iterate scanlines interface
164
function _min_x : int; virtual;
165
function _min_y : int; virtual;
166
function _max_x : int; virtual;
167
function _max_y : int; virtual;
169
function rewind_scanlines : boolean; virtual;
170
function sweep_scanline(sl : scanline_ptr ) : boolean; virtual;
172
// Specialization for embedded_scanline
173
function sweep_scanline_em(sl : scanline_ptr ) : boolean; virtual;
175
function byte_size : unsigned; virtual;
176
procedure write_int32(dst : int8u_ptr; val : int32 );
177
procedure serialize (data : int8u_ptr ); virtual;
179
function scanline_by_index(i : unsigned ) : scanline_data_ss_ptr;
180
function span_by_index (i : unsigned ) : span_data_ss_ptr;
181
function covers_by_index (i : int ) : pointer;
185
scanline_storage_aa8 = object(scanline_storage_aa )
188
scanline_storage_aa16 = object(scanline_storage_aa )
189
constructor Construct;
191
function sweep_scanline(sl : scanline_ptr ) : boolean; virtual;
193
function byte_size : unsigned; virtual;
194
procedure serialize(data : int8u_ptr ); virtual;
198
scanline_storage_aa32 = object(scanline_storage_aa )
199
constructor Construct;
201
function sweep_scanline(sl : scanline_ptr ) : boolean; virtual;
203
function byte_size : unsigned; virtual;
204
procedure serialize(data : int8u_ptr ); virtual;
208
//------------------------------------------serialized_scanlines_adaptor_aa
209
embedded_scanline_sa_ptr = ^embedded_scanline_sa;
211
const_iterator_sa = object(span_obj )
218
constructor Construct(sl : embedded_scanline_sa_ptr; sz : unsigned );
220
function x : int; virtual;
221
function len : int; virtual;
222
function covers : int8u_ptr; virtual;
224
procedure inc_operator; virtual;
227
function read_int32 : int;
231
embedded_scanline_sa = object(scanline )
235
m_num_spans : unsigned;
240
m_result : const_iterator_sa;
242
constructor Construct(sz : unsigned );
244
procedure reset(min_x ,max_x : int ); virtual;
246
function y : int; virtual;
247
function num_spans : unsigned; virtual;
248
function begin_ : pointer; virtual;
250
function sz_of_span : unsigned; virtual;
251
function is_plain_span : boolean; virtual;
252
function is_embedded : boolean; virtual;
254
procedure init(ptr : int8u_ptr; dx ,dy : int ); virtual;
256
function read_int32 : int;
260
serialized_scanlines_adaptor_aa = object(rasterizer_scanline )
275
constructor Construct(sz : unsigned ); overload;
276
constructor Construct(sz : unsigned; data : int8u_ptr; size : unsigned; dx ,dy : double ); overload;
278
procedure init(data : int8u_ptr; size : unsigned; dx ,dy : double );
280
function read_int32 : int;
281
function read_int32u : unsigned;
283
// Iterate scanlines interface
284
function rewind_scanlines : boolean; virtual;
286
function _min_x : int; virtual;
287
function _min_y : int; virtual;
288
function _max_x : int; virtual;
289
function _max_y : int; virtual;
291
function sweep_scanline(sl : scanline_ptr ) : boolean; virtual;
293
// Specialization for embedded_scanline
294
function sweep_scanline_em(sl : scanline_ptr ) : boolean; virtual;
298
serialized_scanlines_adaptor_aa8 = object(serialized_scanlines_adaptor_aa )
299
constructor Construct; overload;
300
constructor Construct(data : int8u_ptr; size : unsigned; dx ,dy : double ); overload;
304
serialized_scanlines_adaptor_aa16 = object(serialized_scanlines_adaptor_aa )
305
constructor Construct; overload;
306
constructor Construct(data : int8u_ptr; size : unsigned; dx ,dy : double ); overload;
310
serialized_scanlines_adaptor_aa32 = object(serialized_scanlines_adaptor_aa )
311
constructor Construct; overload;
312
constructor Construct(data : int8u_ptr; size : unsigned; dx ,dy : double ); overload;
316
{ GLOBAL PROCEDURES }
320
{ LOCAL VARIABLES & CONSTANTS }
321
{ UNIT IMPLEMENTATION }
323
constructor scanline_cell_storage.Construct(entry_sz : unsigned );
325
m_cells.Construct (128 - 2 ,entry_sz ,12 );
326
m_extra_storage.Construct(sizeof(extra_span ) ,6 );
331
constructor scanline_cell_storage.Construct(v : scanline_cell_storage_ptr );
333
m_cells.Construct (v.m_cells.m_entry_sz );
334
m_extra_storage.Construct(sizeof(extra_span ) ,6 );
336
assign_operator (v );
337
copy_extra_storage(v );
342
destructor scanline_cell_storage.Destruct;
347
m_extra_storage.Destruct;
352
procedure scanline_cell_storage.remove_all;
358
i:=m_extra_storage.size; dec(i );
362
s:=m_extra_storage.array_operator(i );
364
agg_freemem(s.ptr ,s.len * m_cells.m_entry_sz );
370
m_extra_storage.remove_all;
376
function scanline_cell_storage.add_cells;
384
idx:=m_cells.allocate_continuous_block(num_cells );
388
ptr:=m_cells.array_operator(idx );
390
move(cells^ ,ptr^ ,m_cells.m_entry_sz * num_cells );
400
agg_getmem(s.ptr ,s.len * m_cells.m_entry_sz );
402
move(cells^ ,s.ptr^ ,s.len * m_cells.m_entry_sz );
404
m_extra_storage.add(@s );
406
result:=-int(m_extra_storage.size );
411
function scanline_cell_storage.assign_operator;
415
m_cells.assign_operator(@v.m_cells );
416
copy_extra_storage (v );
423
function scanline_cell_storage.array_operator;
430
if idx >= m_cells.size then
438
result:=m_cells.array_operator(idx );
444
i:=unsigned(-idx - 1 );
446
if i >= m_extra_storage.size then
454
result:=extra_span_ptr(m_extra_storage.array_operator(i ) ).ptr;
458
{ COPY_EXTRA_STORAGE }
459
procedure scanline_cell_storage.copy_extra_storage;
463
src : extra_span_ptr;
469
while i < v.m_extra_storage.size do
471
src:=v.m_extra_storage.array_operator(i );
475
agg_getmem(dst.ptr ,dst.len * v.m_cells.m_entry_sz );
477
move(src.ptr^ ,dst.ptr^ ,dst.len * v.m_cells.m_entry_sz );
479
m_extra_storage.add(@dst );
488
constructor const_iterator_ss.Construct;
490
m_storage :=sl.m_storage;
491
m_span_idx:=sl.m_scanline.start_span;
498
function const_iterator_ss.x;
505
function const_iterator_ss.len;
512
function const_iterator_ss.covers;
514
result:=m_span.covers;
519
procedure const_iterator_ss.inc_operator;
528
procedure const_iterator_ss.init_span;
530
s : span_data_ss_ptr;
533
s:=m_storage.span_by_index(m_span_idx );
537
m_span.covers:=m_storage.covers_by_index(s.covers_id );
542
constructor embedded_scanline_ss.Construct;
551
procedure embedded_scanline_ss.reset;
556
function embedded_scanline_ss.y;
558
result:=m_scanline.y;
563
function embedded_scanline_ss.num_spans;
565
result:=m_scanline.num_spans;
570
function embedded_scanline_ss.begin_;
572
m_result.Construct(@self );
579
function embedded_scanline_ss.sz_of_span;
581
result:=sizeof(span_ss );
586
function embedded_scanline_ss.is_plain_span;
593
function embedded_scanline_ss.is_embedded;
600
procedure embedded_scanline_ss.setup;
602
m_scanline_idx:=scanline_idx;
603
m_scanline :=m_storage.scanline_by_index(m_scanline_idx )^;
608
constructor scanline_storage_aa.Construct;
610
m_covers.Construct (sizeof(int8u ) );
611
m_spans.Construct (256 - 2 ,sizeof(span_data_ss ) ,10 ); // Block increment size
612
m_scanlines.Construct(sizeof(scanline_data_ss ) ,8 );
621
m_fake_scanline.y :=0;
622
m_fake_scanline.num_spans :=0;
623
m_fake_scanline.start_span:=0;
627
m_fake_span.covers_id:=0;
632
destructor scanline_storage_aa.Destruct;
636
m_scanlines.Destruct;
641
procedure scanline_storage_aa.prepare;
644
m_scanlines.remove_all;
657
procedure scanline_storage_aa.render;
659
sl_this : scanline_data_ss;
661
y ,x1 ,x2 ,len : int;
663
num_spans ,ss : unsigned;
666
span_obj : span_obj_ptr;
680
sl_this.num_spans :=sl.num_spans;
681
sl_this.start_span:=m_spans.size;
683
num_spans:=sl_this.num_spans;
688
if sl.is_plain_span then
699
if span_pl <> NIL then
708
sp.len:=span_obj.len;
714
if span_pl <> NIL then
715
sp.covers_id:=m_covers.add_cells(span_pl.covers ,unsigned(len ) )
717
sp.covers_id:=m_covers.add_cells(span_obj.covers ,unsigned(len ) );
732
if num_spans = 0 then
735
if span_pl <> NIL then
736
inc(ptrcomp(span_pl ) ,ss )
738
span_obj.inc_operator;
742
m_scanlines.add(@sl_this );
747
function scanline_storage_aa._min_x;
754
function scanline_storage_aa._min_y;
761
function scanline_storage_aa._max_x;
768
function scanline_storage_aa._max_y;
775
function scanline_storage_aa.rewind_scanlines;
779
result:=m_scanlines.size > 0;
784
function scanline_storage_aa.sweep_scanline;
786
sl_this : scanline_data_ss_ptr;
788
num_spans ,span_idx : unsigned;
790
sp : span_data_ss_ptr;
798
if m_cur_scanline >= m_scanlines.size then
806
sl_this:=m_scanlines.array_operator(m_cur_scanline );
808
num_spans:=sl_this.num_spans;
809
span_idx :=sl_this.start_span;
812
sp:=m_spans.array_operator(span_idx );
816
covers:=covers_by_index(sp.covers_id );
819
sl.add_span(sp.x ,unsigned(-sp.len ) ,covers^ )
821
sl.add_cells(sp.x ,sp.len ,covers );
827
inc(m_cur_scanline );
829
if sl.num_spans <> 0 then
831
sl.finalize(sl_this.y );
844
function scanline_storage_aa.sweep_scanline_em;
847
if m_cur_scanline >= m_scanlines.size then
855
sl.setup(m_cur_scanline );
857
inc(m_cur_scanline );
859
until sl.num_spans <> 0;
866
function scanline_storage_aa.byte_size;
868
i ,size ,num_spans ,span_idx : unsigned;
870
sl_this : scanline_data_ss_ptr;
872
sp : span_data_ss_ptr;
875
size:=sizeof(int32 ) * 4; // min_x, min_y, max_x, max_y
879
while i < m_scanlines.size do
881
inc(size ,sizeof(int32 ) * 3 ); // scanline size in bytes, Y, num_spans
883
sl_this:=m_scanlines.array_operator(i );
885
num_spans:=sl_this.num_spans;
886
span_idx :=sl_this.start_span;
889
sp:=m_spans.array_operator(span_idx );
892
inc(size ,sizeof(int32 ) * 2 ); // X, span_len
895
inc(size ,sizeof(int8u ) ) // cover
897
inc(size ,sizeof(int8u ) * unsigned(sp.len ) ); // covers
912
procedure scanline_storage_aa.write_int32;
914
int8u_ptr(ptrcomp(dst ) + 0 * sizeof(int8u ) )^:=int32_int8u(val )._0;
915
int8u_ptr(ptrcomp(dst ) + 1 * sizeof(int8u ) )^:=int32_int8u(val )._1;
916
int8u_ptr(ptrcomp(dst ) + 2 * sizeof(int8u ) )^:=int32_int8u(val )._2;
917
int8u_ptr(ptrcomp(dst ) + 3 * sizeof(int8u ) )^:=int32_int8u(val )._3;
922
procedure scanline_storage_aa.serialize;
924
i ,num_spans ,span_idx : unsigned;
926
sl_this : scanline_data_ss_ptr;
928
sp : span_data_ss_ptr;
932
size_ptr : int8u_ptr;
935
write_int32(data ,_min_x ); // min_x
936
inc(ptrcomp(data ) ,sizeof(int32 ) );
938
write_int32(data ,_min_y ); // min_y
939
inc(ptrcomp(data ) ,sizeof(int32 ) );
941
write_int32(data ,_max_x ); // max_x
942
inc(ptrcomp(data ) ,sizeof(int32 ) );
944
write_int32(data ,_max_y ); // max_y
945
inc(ptrcomp(data ) ,sizeof(int32 ) );
949
while i < m_scanlines.size do
951
sl_this :=m_scanlines.array_operator(i );
954
inc(ptrcomp(data ) ,sizeof(int32 ) ); // Reserve space for scanline size in bytes
956
write_int32(data ,sl_this.y ); // Y
957
inc(ptrcomp(data ) ,sizeof(int32 ) );
959
write_int32(data ,sl_this.num_spans ); // num_spans
960
inc(ptrcomp(data ) ,sizeof(int32 ) );
962
num_spans:=sl_this.num_spans;
963
span_idx :=sl_this.start_span;
966
sp:=m_spans.array_operator(span_idx );
970
covers:=covers_by_index(sp.covers_id );
972
write_int32(data ,sp.x ); // X
973
inc(ptrcomp(data ) ,sizeof(int32 ) );
975
write_int32(data ,sp.len ); // span_len
976
inc(ptrcomp(data ) ,sizeof(int32 ) );
980
move(covers^ ,data^ ,sizeof(int8u ) );
981
inc (ptrcomp(data ) ,sizeof(int8u ) );
986
move(covers^ ,data^ ,unsigned(sp.len ) * sizeof(int8u ) );
987
inc (ptrcomp(data ) ,sizeof(int8u ) * unsigned(sp.len ) );
995
write_int32(size_ptr ,ptrcomp(data ) - ptrcomp(size_ptr ) );
1003
{ SCANLINE_BY_INDEX }
1004
function scanline_storage_aa.scanline_by_index;
1006
if i < m_scanlines.size then
1007
result:=m_scanlines.array_operator(i )
1009
result:=@m_fake_scanline;
1014
function scanline_storage_aa.span_by_index;
1016
if i < m_spans.size then
1017
result:=m_spans.array_operator(i )
1019
result:=@m_fake_span;
1024
function scanline_storage_aa.covers_by_index;
1026
result:=m_covers.array_operator(i );
1031
constructor scanline_storage_aa16.Construct;
1033
m_covers.Construct (sizeof(int16u ) );
1034
m_spans.Construct (256 - 2 ,sizeof(span_data_ss ) ,10 ); // Block increment size
1035
m_scanlines.Construct(sizeof(scanline_data_ss ) ,8 );
1039
m_max_x:=-$7FFFFFFF;
1040
m_max_y:=-$7FFFFFFF;
1044
m_fake_scanline.y :=0;
1045
m_fake_scanline.num_spans :=0;
1046
m_fake_scanline.start_span:=0;
1049
m_fake_span.len :=0;
1050
m_fake_span.covers_id:=0;
1055
function scanline_storage_aa16.sweep_scanline;
1057
sl_this : scanline_data_ss_ptr;
1059
num_spans ,span_idx : unsigned;
1061
sp : span_data_ss_ptr;
1063
covers : int16u_ptr;
1069
if m_cur_scanline >= m_scanlines.size then
1077
sl_this:=m_scanlines.array_operator(m_cur_scanline );
1079
num_spans:=sl_this.num_spans;
1080
span_idx :=sl_this.start_span;
1083
sp:=m_spans.array_operator(span_idx );
1087
covers:=covers_by_index(sp.covers_id );
1090
sl.add_span(sp.x ,unsigned(-sp.len ) ,covers^ )
1092
sl.add_cells(sp.x ,sp.len ,int8u_ptr(covers ) );
1096
until num_spans = 0;
1098
inc(m_cur_scanline );
1100
if sl.num_spans <> 0 then
1102
sl.finalize(sl_this.y );
1115
function scanline_storage_aa16.byte_size;
1117
i ,size ,num_spans ,span_idx : unsigned;
1119
sl_this : scanline_data_ss_ptr;
1121
sp : span_data_ss_ptr;
1124
size:=sizeof(int32 ) * 4; // min_x, min_y, max_x, max_y
1128
while i < m_scanlines.size do
1130
inc(size ,sizeof(int32 ) * 3 ); // scanline size in bytes, Y, num_spans
1132
sl_this:=m_scanlines.array_operator(i );
1134
num_spans:=sl_this.num_spans;
1135
span_idx :=sl_this.start_span;
1138
sp:=m_spans.array_operator(span_idx );
1141
inc(size ,sizeof(int32 ) * 2 ); // X, span_len
1144
inc(size ,sizeof(int16u ) ) // cover
1146
inc(size ,sizeof(int16u ) * unsigned(sp.len ) ); // covers
1150
until num_spans = 0;
1161
procedure scanline_storage_aa16.serialize;
1163
i ,num_spans ,span_idx : unsigned;
1165
sl_this : scanline_data_ss_ptr;
1167
sp : span_data_ss_ptr;
1169
covers : int16u_ptr;
1171
size_ptr : int8u_ptr;
1174
write_int32(data ,_min_x ); // min_x
1175
inc(ptrcomp(data ) ,sizeof(int32 ) );
1177
write_int32(data ,_min_y ); // min_y
1178
inc(ptrcomp(data ) ,sizeof(int32 ) );
1180
write_int32(data ,_max_x ); // max_x
1181
inc(ptrcomp(data ) ,sizeof(int32 ) );
1183
write_int32(data ,_max_y ); // max_y
1184
inc(ptrcomp(data ) ,sizeof(int32 ) );
1188
while i < m_scanlines.size do
1190
sl_this :=m_scanlines.array_operator(i );
1193
inc(ptrcomp(data ) ,sizeof(int32 ) ); // Reserve space for scanline size in bytes
1195
write_int32(data ,sl_this.y ); // Y
1196
inc(ptrcomp(data ) ,sizeof(int32 ) );
1198
write_int32(data ,sl_this.num_spans ); // num_spans
1199
inc(ptrcomp(data ) ,sizeof(int32 ) );
1201
num_spans:=sl_this.num_spans;
1202
span_idx :=sl_this.start_span;
1205
sp:=m_spans.array_operator(span_idx );
1209
covers:=covers_by_index(sp.covers_id );
1211
write_int32(data ,sp.x ); // X
1212
inc(ptrcomp(data ) ,sizeof(int32 ) );
1214
write_int32(data ,sp.len ); // span_len
1215
inc(ptrcomp(data ) ,sizeof(int32 ) );
1219
move(covers^ ,data^ ,sizeof(int16u ) );
1220
inc (ptrcomp(data ) ,sizeof(int16u ) );
1225
move(covers^ ,data^ ,unsigned(sp.len ) * sizeof(int16u ) );
1226
inc (ptrcomp(data ) ,sizeof(int16u ) * unsigned(sp.len ) );
1232
until num_spans = 0;
1234
write_int32(size_ptr ,ptrcomp(data ) - ptrcomp(size_ptr ) );
1243
constructor scanline_storage_aa32.Construct;
1245
m_covers.Construct (sizeof(int32u ) );
1246
m_spans.Construct (256 - 2 ,sizeof(span_data_ss ) ,10 ); // Block increment size
1247
m_scanlines.Construct(sizeof(scanline_data_ss ) ,8 );
1251
m_max_x:=-$7FFFFFFF;
1252
m_max_y:=-$7FFFFFFF;
1256
m_fake_scanline.y :=0;
1257
m_fake_scanline.num_spans :=0;
1258
m_fake_scanline.start_span:=0;
1261
m_fake_span.len :=0;
1262
m_fake_span.covers_id:=0;
1267
function scanline_storage_aa32.sweep_scanline;
1269
sl_this : scanline_data_ss_ptr;
1271
num_spans ,span_idx : unsigned;
1273
sp : span_data_ss_ptr;
1275
covers : int32u_ptr;
1281
if m_cur_scanline >= m_scanlines.size then
1289
sl_this:=m_scanlines.array_operator(m_cur_scanline );
1291
num_spans:=sl_this.num_spans;
1292
span_idx :=sl_this.start_span;
1295
sp:=m_spans.array_operator(span_idx );
1299
covers:=covers_by_index(sp.covers_id );
1302
sl.add_span(sp.x ,unsigned(-sp.len ) ,covers^ )
1304
sl.add_cells(sp.x ,sp.len ,int8u_ptr(covers ) );
1308
until num_spans = 0;
1310
inc(m_cur_scanline );
1312
if sl.num_spans <> 0 then
1314
sl.finalize(sl_this.y );
1327
function scanline_storage_aa32.byte_size;
1329
i ,size ,num_spans ,span_idx : unsigned;
1331
sl_this : scanline_data_ss_ptr;
1333
sp : span_data_ss_ptr;
1336
size:=sizeof(int32 ) * 4; // min_x, min_y, max_x, max_y
1340
while i < m_scanlines.size do
1342
inc(size ,sizeof(int32 ) * 3 ); // scanline size in bytes, Y, num_spans
1344
sl_this:=m_scanlines.array_operator(i );
1346
num_spans:=sl_this.num_spans;
1347
span_idx :=sl_this.start_span;
1350
sp:=m_spans.array_operator(span_idx );
1353
inc(size ,sizeof(int32 ) * 2 ); // X, span_len
1356
inc(size ,sizeof(int32u ) ) // cover
1358
inc(size ,sizeof(int32u ) * unsigned(sp.len ) ); // covers
1362
until num_spans = 0;
1373
procedure scanline_storage_aa32.serialize;
1375
i ,num_spans ,span_idx : unsigned;
1377
sl_this : scanline_data_ss_ptr;
1379
sp : span_data_ss_ptr;
1381
covers : int32u_ptr;
1383
size_ptr : int8u_ptr;
1386
write_int32(data ,_min_x ); // min_x
1387
inc(ptrcomp(data ) ,sizeof(int32 ) );
1389
write_int32(data ,_min_y ); // min_y
1390
inc(ptrcomp(data ) ,sizeof(int32 ) );
1392
write_int32(data ,_max_x ); // max_x
1393
inc(ptrcomp(data ) ,sizeof(int32 ) );
1395
write_int32(data ,_max_y ); // max_y
1396
inc(ptrcomp(data ) ,sizeof(int32 ) );
1400
while i < m_scanlines.size do
1402
sl_this :=m_scanlines.array_operator(i );
1405
inc(ptrcomp(data ) ,sizeof(int32 ) ); // Reserve space for scanline size in bytes
1407
write_int32(data ,sl_this.y ); // Y
1408
inc(ptrcomp(data ) ,sizeof(int32 ) );
1410
write_int32(data ,sl_this.num_spans ); // num_spans
1411
inc(ptrcomp(data ) ,sizeof(int32 ) );
1413
num_spans:=sl_this.num_spans;
1414
span_idx :=sl_this.start_span;
1417
sp:=m_spans.array_operator(span_idx );
1421
covers:=covers_by_index(sp.covers_id );
1423
write_int32(data ,sp.x ); // X
1424
inc(ptrcomp(data ) ,sizeof(int32 ) );
1426
write_int32(data ,sp.len ); // span_len
1427
inc(ptrcomp(data ) ,sizeof(int32 ) );
1431
move(covers^ ,data^ ,sizeof(int32u ) );
1432
inc (ptrcomp(data ) ,sizeof(int32u ) );
1437
move(covers^ ,data^ ,unsigned(sp.len ) * sizeof(int32u ) );
1438
inc (ptrcomp(data ) ,sizeof(int32u ) * unsigned(sp.len ) );
1444
until num_spans = 0;
1446
write_int32(size_ptr ,ptrcomp(data ) - ptrcomp(size_ptr ) );
1455
constructor const_iterator_sa.Construct;
1466
function const_iterator_sa.x;
1473
function const_iterator_sa.len;
1480
function const_iterator_sa.covers;
1482
result:=m_span.covers;
1487
procedure const_iterator_sa.inc_operator;
1489
if m_span.len < 0 then
1490
inc(ptrcomp(m_ptr ) ,m_sz )
1492
inc(ptrcomp(m_ptr ) ,m_span.len * m_sz );
1499
procedure const_iterator_sa.init_span;
1501
m_span.x :=read_int32 + m_dx;
1502
m_span.len :=read_int32;
1503
m_span.covers:=m_ptr;
1508
function const_iterator_sa.read_int32;
1510
int32_int8u(result )._0:=m_ptr^; inc(ptrcomp(m_ptr ) ,sizeof(int8u ) );
1511
int32_int8u(result )._1:=m_ptr^; inc(ptrcomp(m_ptr ) ,sizeof(int8u ) );
1512
int32_int8u(result )._2:=m_ptr^; inc(ptrcomp(m_ptr ) ,sizeof(int8u ) );
1513
int32_int8u(result )._3:=m_ptr^; inc(ptrcomp(m_ptr ) ,sizeof(int8u ) );
1518
constructor embedded_scanline_sa.Construct;
1529
procedure embedded_scanline_sa.reset;
1534
function embedded_scanline_sa.y;
1541
function embedded_scanline_sa.num_spans;
1543
result:=m_num_spans;
1548
function embedded_scanline_sa.begin_;
1550
m_result.Construct(@self ,m_sz );
1557
function embedded_scanline_sa.sz_of_span;
1559
result:=sizeof(span_ss );
1564
function embedded_scanline_sa.is_plain_span;
1571
function embedded_scanline_sa.is_embedded;
1578
procedure embedded_scanline_sa.init;
1581
m_y :=read_int32 + dy;
1582
m_num_spans:=unsigned(read_int32 );
1588
function embedded_scanline_sa.read_int32;
1590
int32_int8u(result )._0:=m_ptr^; inc(ptrcomp(m_ptr ) ,sizeof(int8u ) );
1591
int32_int8u(result )._1:=m_ptr^; inc(ptrcomp(m_ptr ) ,sizeof(int8u ) );
1592
int32_int8u(result )._2:=m_ptr^; inc(ptrcomp(m_ptr ) ,sizeof(int8u ) );
1593
int32_int8u(result )._3:=m_ptr^; inc(ptrcomp(m_ptr ) ,sizeof(int8u ) );
1598
constructor serialized_scanlines_adaptor_aa.Construct(sz : unsigned );
1609
m_max_x:=-$7FFFFFFF;
1610
m_max_y:=-$7FFFFFFF;
1617
constructor serialized_scanlines_adaptor_aa.Construct(sz : unsigned; data : int8u_ptr; size : unsigned; dx ,dy : double );
1620
m_end :=int8u_ptr(ptrcomp(data ) + size );
1623
m_dx:=trunc(dx + 0.5 );
1624
m_dy:=trunc(dy + 0.5 );
1628
m_max_x:=-$7FFFFFFF;
1629
m_max_y:=-$7FFFFFFF;
1636
procedure serialized_scanlines_adaptor_aa.init;
1639
m_end :=int8u_ptr(ptrcomp(data ) + size );
1642
m_dx:=trunc(dx + 0.5 );
1643
m_dy:=trunc(dy + 0.5 );
1647
m_max_x:=-$7FFFFFFF;
1648
m_max_y:=-$7FFFFFFF;
1653
function serialized_scanlines_adaptor_aa.read_int32;
1655
int32_int8u(result )._0:=m_ptr^; inc(ptrcomp(m_ptr ) ,sizeof(int8u ) );
1656
int32_int8u(result )._1:=m_ptr^; inc(ptrcomp(m_ptr ) ,sizeof(int8u ) );
1657
int32_int8u(result )._2:=m_ptr^; inc(ptrcomp(m_ptr ) ,sizeof(int8u ) );
1658
int32_int8u(result )._3:=m_ptr^; inc(ptrcomp(m_ptr ) ,sizeof(int8u ) );
1663
function serialized_scanlines_adaptor_aa.read_int32u;
1665
int32_int8u(result )._0:=m_ptr^; inc(ptrcomp(m_ptr ) ,sizeof(int8u ) );
1666
int32_int8u(result )._1:=m_ptr^; inc(ptrcomp(m_ptr ) ,sizeof(int8u ) );
1667
int32_int8u(result )._2:=m_ptr^; inc(ptrcomp(m_ptr ) ,sizeof(int8u ) );
1668
int32_int8u(result )._3:=m_ptr^; inc(ptrcomp(m_ptr ) ,sizeof(int8u ) );
1672
{ REWIND_SCANLINES }
1673
function serialized_scanlines_adaptor_aa.rewind_scanlines;
1680
if ptrcomp(m_ptr ) < ptrcomp(m_end ) then
1682
m_min_x:=read_int32 + m_dx;
1683
m_min_y:=read_int32 + m_dy;
1684
m_max_x:=read_int32 + m_dx;
1685
m_max_y:=read_int32 + m_dy;
1698
function serialized_scanlines_adaptor_aa._min_x;
1705
function serialized_scanlines_adaptor_aa._min_y;
1712
function serialized_scanlines_adaptor_aa._max_x;
1719
function serialized_scanlines_adaptor_aa._max_y;
1726
function serialized_scanlines_adaptor_aa.sweep_scanline;
1730
num_spans : unsigned;
1736
if ptrcomp(m_ptr ) >= ptrcomp(m_end ) then
1744
read_int32; // Skip scanline size in bytes
1746
y :=read_int32 + m_dy;
1747
num_spans:=read_int32;
1750
x :=read_int32 + m_dx;
1755
sl.add_span(x ,unsigned(-len ) ,m_ptr^ );
1757
inc(ptrcomp(m_ptr ) ,m_sz );
1762
sl.add_cells(x ,len ,m_ptr );
1764
inc(ptrcomp(m_ptr ) ,len * m_sz );
1770
until num_spans = 0;
1772
if sl.num_spans <> 0 then
1787
function serialized_scanlines_adaptor_aa.sweep_scanline_em;
1789
byte_size : unsigned;
1793
if ptrcomp(m_ptr ) >= ptrcomp(m_end ) then
1801
byte_size:=read_int32u;
1803
sl.init(m_ptr ,m_dx ,m_dy );
1805
inc(ptrcomp(m_ptr ) ,byte_size - sizeof(int32 ) );
1807
until sl.num_spans <> 0;
1814
constructor serialized_scanlines_adaptor_aa8.Construct;
1816
inherited Construct(sizeof(int8u ) );
1821
constructor serialized_scanlines_adaptor_aa8.Construct(data : int8u_ptr; size : unsigned; dx ,dy : double );
1823
inherited Construct(sizeof(int8u ) ,data ,size ,dx ,dy );
1828
constructor serialized_scanlines_adaptor_aa16.Construct;
1830
inherited Construct(sizeof(int16u ) );
1835
constructor serialized_scanlines_adaptor_aa16.Construct(data : int8u_ptr; size : unsigned; dx ,dy : double );
1837
inherited Construct(sizeof(int8u ) ,data ,size ,dx ,dy );
1842
constructor serialized_scanlines_adaptor_aa32.Construct;
1844
inherited Construct(sizeof(int32u ) );
1849
constructor serialized_scanlines_adaptor_aa32.Construct(data : int8u_ptr; size : unsigned; dx ,dy : double );
1851
inherited Construct(sizeof(int8u ) ,data ,size ,dx ,dy );