~ubuntu-branches/ubuntu/saucy/lazarus/saucy

« back to all changes in this revision

Viewing changes to components/aggpas/src/agg_alpha_mask_u8.pas

  • Committer: Package Import Robot
  • Author(s): Paul Gevers, Abou Al Montacir, Bart Martens, Paul Gevers
  • Date: 2013-06-08 14:12:17 UTC
  • mfrom: (1.1.9)
  • Revision ID: package-import@ubuntu.com-20130608141217-7k0cy9id8ifcnutc
Tags: 1.0.8+dfsg-1
[ Abou Al Montacir ]
* New upstream major release and multiple maintenace release offering many
  fixes and new features marking a new milestone for the Lazarus development
  and its stability level.
  - The detailed list of changes can be found here:
    http://wiki.lazarus.freepascal.org/Lazarus_1.0_release_notes
    http://wiki.lazarus.freepascal.org/Lazarus_1.0_fixes_branch
* LCL changes:
  - LCL is now a normal package.
      + Platform independent parts of the LCL are now in the package LCLBase
      + LCL is automatically recompiled when switching the target platform,
        unless pre-compiled binaries for this target are already installed.
      + No impact on existing projects.
      + Linker options needed by LCL are no more added to projects that do
        not use the LCL package.
  - Minor changes in LCL basic classes behaviour
      + TCustomForm.Create raises an exception if a form resource is not
        found.
      + TNotebook and TPage: a new implementation of these classes was added.
      + TDBNavigator: It is now possible to have focusable buttons by setting
        Options = [navFocusableButtons] and TabStop = True, useful for
        accessibility and for devices with neither mouse nor touch screen.
      + Names of TControlBorderSpacing.GetSideSpace and GetSpace were swapped
        and are now consistent. GetSideSpace = Around + GetSpace.
      + TForm.WindowState=wsFullscreen was added
      + TCanvas.TextFitInfo was added to calculate how many characters will
        fit into a specified Width. Useful for word-wrapping calculations.
      + TControl.GetColorResolvingParent and
        TControl.GetRGBColorResolvingParent were added, simplifying the work
        to obtain the final color of the control while resolving clDefault
        and the ParentColor.
      + LCLIntf.GetTextExtentExPoint now has a good default implementation
        which works in any platform not providing a specific implementation.
        However, Widgetset specific implementation is better, when available.
      + TTabControl was reorganized. Now it has the correct class hierarchy
        and inherits from TCustomTabControl as it should.
  - New unit in the LCL:
      + lazdialogs.pas: adds non-native versions of various native dialogs,
        for example TLazOpenDialog, TLazSaveDialog, TLazSelectDirectoryDialog.
        It is used by widgetsets which either do not have a native dialog, or
        do not wish to use it because it is limited. These dialogs can also be
        used by user applications directly.
      + lazdeviceapis.pas: offers an interface to more hardware devices such
        as the accelerometer, GPS, etc. See LazDeviceAPIs
      + lazcanvas.pas: provides a TFPImageCanvas descendent implementing
        drawing in a LCL-compatible way, but 100% in Pascal.
      + lazregions.pas. LazRegions is a wholly Pascal implementation of
        regions for canvas clipping, event clipping, finding in which control
        of a region tree one an event should reach, for drawing polygons, etc.
      + customdrawncontrols.pas, customdrawndrawers.pas,
        customdrawn_common.pas, customdrawn_android.pas and
        customdrawn_winxp.pas: are the Lazarus Custom Drawn Controls -controls
        which imitate the standard LCL ones, but with the difference that they
        are non-native and support skinning.
  - New APIs added to the LCL to improve support of accessibility software
    such as screen readers.
* IDE changes:
  - Many improvments.
  - The detailed list of changes can be found here:
    http://wiki.lazarus.freepascal.org/New_IDE_features_since#v1.0_.282012-08-29.29
    http://wiki.lazarus.freepascal.org/Lazarus_1.0_release_notes#IDE_Changes
* Debugger / Editor changes:
  - Added pascal sources and breakpoints to the disassembler
  - Added threads dialog.
* Components changes:
  - TAChart: many fixes and new features
  - CodeTool: support Delphi style generics and new syntax extensions.
  - AggPas: removed to honor free licencing. (Closes: Bug#708695)
[Bart Martens]
* New debian/watch file fixing issues with upstream RC release.
[Abou Al Montacir]
* Avoid changing files in .pc hidden directory, these are used by quilt for
  internal purpose and could lead to surprises during build.
[Paul Gevers]
* Updated get-orig-source target and it compinion script orig-tar.sh so that they
  repack the source file, allowing bug 708695 to be fixed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
//----------------------------------------------------------------------------
2
 
// Anti-Grain Geometry - Version 2.4 (Public License)
3
 
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
4
 
//
5
 
// Anti-Grain Geometry - Version 2.4 Release Milano 3 (AggPas 2.4 RM3)
6
 
// Pascal Port By: Milan Marusinec alias Milano
7
 
//                 milan@marusinec.sk
8
 
//                 http://www.aggpas.org
9
 
// Copyright (c) 2005-2006
10
 
//
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.
15
 
//
16
 
//----------------------------------------------------------------------------
17
 
// Contact: mcseem@antigrain.com
18
 
//          mcseemagg@yahoo.com
19
 
//          http://www.antigrain.com
20
 
//
21
 
// [Pascal Port History] -----------------------------------------------------
22
 
//
23
 
// 23.06.2006-Milano: ptrcomp adjustments
24
 
// 10.02.2006-Milano: amask_no_clip_u8
25
 
// 09.02.2006-Milano: Unit port establishment
26
 
//
27
 
{ agg_alpha_mask_u8.pas }
28
 
unit
29
 
 agg_alpha_mask_u8 ;
30
 
 
31
 
INTERFACE
32
 
 
33
 
{$I agg_mode.inc }
34
 
 
35
 
uses
36
 
 agg_basics ,
37
 
 agg_rendering_buffer ;
38
 
 
39
 
{ TYPES DEFINITION }
40
 
const
41
 
 cover_shift = 8;
42
 
 cover_none  = 0;
43
 
 cover_full  = 255;
44
 
 
45
 
type
46
 
 func_mask_calculate = function(p : int8u_ptr ) : unsigned;
47
 
 
48
 
//==========================================================alpha_mask_u8
49
 
 alpha_mask_ptr = ^alpha_mask;
50
 
 alpha_mask = object
51
 
   procedure attach(rbuf : rendering_buffer_ptr ); virtual; abstract;
52
 
 
53
 
   function  mask_function : func_mask_calculate; virtual; abstract;
54
 
 
55
 
   function  pixel        (x ,y : int ) : int8u; virtual; abstract;
56
 
   function  combine_pixel(x ,y : int; val : int8u ) : int8u; virtual; abstract;
57
 
 
58
 
   procedure fill_hspan   (x ,y : int; dst : int8u_ptr; num_pix : int ); virtual; abstract;
59
 
   procedure combine_hspan(x ,y : int; dst : int8u_ptr; num_pix : int ); virtual; abstract;
60
 
   procedure fill_vspan   (x ,y : int; dst : int8u_ptr; num_pix : int ); virtual; abstract;
61
 
   procedure combine_vspan(x ,y : int; dst : int8u_ptr; num_pix : int ); virtual; abstract;
62
 
 
63
 
  end;
64
 
 
65
 
 alpha_mask_u8 = object(alpha_mask )
66
 
   Step   ,
67
 
   Offset : unsigned;
68
 
 
69
 
   m_rbuf          : rendering_buffer_ptr;
70
 
   m_mask_function : func_mask_calculate;
71
 
 
72
 
   constructor Construct(MaskF : func_mask_calculate; Step_ : unsigned = 1; Offset_ : unsigned = 0 ); overload;
73
 
   constructor Construct(rbuf : rendering_buffer_ptr; MaskF : func_mask_calculate; Step_ : unsigned = 1; Offset_ : unsigned = 0 ); overload;
74
 
 
75
 
   procedure attach(rbuf : rendering_buffer_ptr ); virtual;
76
 
 
77
 
   function  mask_function : func_mask_calculate; virtual;
78
 
 
79
 
   function  pixel        (x ,y : int ) : int8u; virtual;
80
 
   function  combine_pixel(x ,y : int; val : int8u ) : int8u; virtual;
81
 
 
82
 
   procedure fill_hspan   (x ,y : int; dst : int8u_ptr; num_pix : int ); virtual;
83
 
   procedure combine_hspan(x ,y : int; dst : int8u_ptr; num_pix : int ); virtual;
84
 
   procedure fill_vspan   (x ,y : int; dst : int8u_ptr; num_pix : int ); virtual;
85
 
   procedure combine_vspan(x ,y : int; dst : int8u_ptr; num_pix : int ); virtual;
86
 
 
87
 
  end;
88
 
 
89
 
 alpha_mask_gray8 = object(alpha_mask_u8 )
90
 
   constructor Construct(rbuf : rendering_buffer_ptr );
91
 
 
92
 
  end;
93
 
 
94
 
 alpha_mask_rgb24r = object(alpha_mask_u8 )
95
 
   constructor Construct(rbuf : rendering_buffer_ptr );
96
 
 
97
 
  end;
98
 
 
99
 
 alpha_mask_rgb24g = object(alpha_mask_u8 )
100
 
   constructor Construct(rbuf : rendering_buffer_ptr );
101
 
 
102
 
  end;
103
 
 
104
 
 alpha_mask_rgb24b = object(alpha_mask_u8 )
105
 
   constructor Construct(rbuf : rendering_buffer_ptr );
106
 
 
107
 
  end;
108
 
 
109
 
 alpha_mask_bgr24r = object(alpha_mask_u8 )
110
 
   constructor Construct(rbuf : rendering_buffer_ptr );
111
 
 
112
 
  end;
113
 
 
114
 
 alpha_mask_bgr24g = object(alpha_mask_u8 )
115
 
   constructor Construct(rbuf : rendering_buffer_ptr );
116
 
 
117
 
  end;
118
 
 
119
 
 alpha_mask_bgr24b = object(alpha_mask_u8 )
120
 
   constructor Construct(rbuf : rendering_buffer_ptr );
121
 
 
122
 
  end;
123
 
 
124
 
 alpha_mask_rgba32r = object(alpha_mask_u8 )
125
 
   constructor Construct(rbuf : rendering_buffer_ptr );
126
 
 
127
 
  end;
128
 
 
129
 
 alpha_mask_rgba32g = object(alpha_mask_u8 )
130
 
   constructor Construct(rbuf : rendering_buffer_ptr );
131
 
 
132
 
  end;
133
 
 
134
 
 alpha_mask_rgba32b = object(alpha_mask_u8 )
135
 
   constructor Construct(rbuf : rendering_buffer_ptr );
136
 
 
137
 
  end;
138
 
 
139
 
 alpha_mask_rgba32a = object(alpha_mask_u8 )
140
 
   constructor Construct(rbuf : rendering_buffer_ptr );
141
 
 
142
 
  end;
143
 
 
144
 
 alpha_mask_argb32r = object(alpha_mask_u8 )
145
 
   constructor Construct(rbuf : rendering_buffer_ptr );
146
 
 
147
 
  end;
148
 
 
149
 
 alpha_mask_argb32g = object(alpha_mask_u8 )
150
 
   constructor Construct(rbuf : rendering_buffer_ptr );
151
 
 
152
 
  end;
153
 
 
154
 
 alpha_mask_argb32b = object(alpha_mask_u8 )
155
 
   constructor Construct(rbuf : rendering_buffer_ptr );
156
 
 
157
 
  end;
158
 
 
159
 
 alpha_mask_argb32a = object(alpha_mask_u8 )
160
 
   constructor Construct(rbuf : rendering_buffer_ptr );
161
 
 
162
 
  end;
163
 
 
164
 
 alpha_mask_bgra32r = object(alpha_mask_u8 )
165
 
   constructor Construct(rbuf : rendering_buffer_ptr );
166
 
 
167
 
  end;
168
 
 
169
 
 alpha_mask_bgra32g = object(alpha_mask_u8 )
170
 
   constructor Construct(rbuf : rendering_buffer_ptr );
171
 
 
172
 
  end;
173
 
 
174
 
 alpha_mask_bgra32b = object(alpha_mask_u8 )
175
 
   constructor Construct(rbuf : rendering_buffer_ptr );
176
 
 
177
 
  end;
178
 
 
179
 
 alpha_mask_bgra32a = object(alpha_mask_u8 )
180
 
   constructor Construct(rbuf : rendering_buffer_ptr );
181
 
 
182
 
  end;
183
 
 
184
 
 alpha_mask_abgr32r = object(alpha_mask_u8 )
185
 
   constructor Construct(rbuf : rendering_buffer_ptr );
186
 
 
187
 
  end;
188
 
 
189
 
 alpha_mask_abgr32g = object(alpha_mask_u8 )
190
 
   constructor Construct(rbuf : rendering_buffer_ptr );
191
 
 
192
 
  end;
193
 
 
194
 
 alpha_mask_abgr32b = object(alpha_mask_u8 )
195
 
   constructor Construct(rbuf : rendering_buffer_ptr );
196
 
 
197
 
  end;
198
 
 
199
 
 alpha_mask_abgr32a = object(alpha_mask_u8 )
200
 
   constructor Construct(rbuf : rendering_buffer_ptr );
201
 
 
202
 
  end;
203
 
 
204
 
 alpha_mask_rgb24gray = object(alpha_mask_u8 )
205
 
   constructor Construct(rbuf : rendering_buffer_ptr );
206
 
 
207
 
  end;
208
 
 
209
 
 alpha_mask_bgr24gray = object(alpha_mask_u8 )
210
 
   constructor Construct(rbuf : rendering_buffer_ptr );
211
 
 
212
 
  end;
213
 
 
214
 
 alpha_mask_rgba32gray = object(alpha_mask_u8 )
215
 
   constructor Construct(rbuf : rendering_buffer_ptr );
216
 
 
217
 
  end;
218
 
 
219
 
 alpha_mask_argb32gray = object(alpha_mask_u8 )
220
 
   constructor Construct(rbuf : rendering_buffer_ptr );
221
 
 
222
 
  end;
223
 
 
224
 
 alpha_mask_bgra32gray = object(alpha_mask_u8 )
225
 
   constructor Construct(rbuf : rendering_buffer_ptr );
226
 
 
227
 
  end;
228
 
 
229
 
 alpha_mask_abgr32gray = object(alpha_mask_u8 )
230
 
   constructor Construct(rbuf : rendering_buffer_ptr );
231
 
 
232
 
  end;
233
 
 
234
 
//==========================================================amask_no_clip_u8
235
 
 amask_no_clip_u8 = object(alpha_mask )
236
 
   Step   ,
237
 
   Offset : unsigned;
238
 
 
239
 
   m_rbuf          : rendering_buffer_ptr;
240
 
   m_mask_function : func_mask_calculate;
241
 
 
242
 
   constructor Construct(MaskF : func_mask_calculate; Step_ : unsigned = 1; Offset_ : unsigned = 0 ); overload;
243
 
   constructor Construct(rbuf : rendering_buffer_ptr; MaskF : func_mask_calculate; Step_ : unsigned = 1; Offset_ : unsigned = 0 ); overload;
244
 
 
245
 
   procedure attach(rbuf : rendering_buffer_ptr ); virtual;
246
 
 
247
 
   function  mask_function : func_mask_calculate; virtual;
248
 
 
249
 
   function  pixel        (x ,y : int ) : int8u; virtual;
250
 
   function  combine_pixel(x ,y : int; val : int8u ) : int8u; virtual;
251
 
 
252
 
   procedure fill_hspan   (x ,y : int; dst : int8u_ptr; num_pix : int ); virtual;
253
 
   procedure combine_hspan(x ,y : int; dst : int8u_ptr; num_pix : int ); virtual;
254
 
   procedure fill_vspan   (x ,y : int; dst : int8u_ptr; num_pix : int ); virtual;
255
 
   procedure combine_vspan(x ,y : int; dst : int8u_ptr; num_pix : int ); virtual;
256
 
 
257
 
  end;
258
 
 
259
 
 amask_no_clip_gray8 = object(amask_no_clip_u8 )
260
 
   constructor Construct(rbuf : rendering_buffer_ptr );
261
 
 
262
 
  end;
263
 
 
264
 
 amask_no_clip_rgb24r = object(amask_no_clip_u8 )
265
 
   constructor Construct(rbuf : rendering_buffer_ptr );
266
 
 
267
 
  end;
268
 
 
269
 
 amask_no_clip_rgb24g = object(amask_no_clip_u8 )
270
 
   constructor Construct(rbuf : rendering_buffer_ptr );
271
 
 
272
 
  end;
273
 
 
274
 
 amask_no_clip_rgb24b = object(amask_no_clip_u8 )
275
 
   constructor Construct(rbuf : rendering_buffer_ptr );
276
 
 
277
 
  end;
278
 
 
279
 
 amask_no_clip_bgr24r = object(amask_no_clip_u8 )
280
 
   constructor Construct(rbuf : rendering_buffer_ptr );
281
 
 
282
 
  end;
283
 
 
284
 
 amask_no_clip_bgr24g = object(amask_no_clip_u8 )
285
 
   constructor Construct(rbuf : rendering_buffer_ptr );
286
 
 
287
 
  end;
288
 
 
289
 
 amask_no_clip_bgr24b = object(amask_no_clip_u8 )
290
 
   constructor Construct(rbuf : rendering_buffer_ptr );
291
 
 
292
 
  end;
293
 
 
294
 
 amask_no_clip_rgba32r = object(amask_no_clip_u8 )
295
 
   constructor Construct(rbuf : rendering_buffer_ptr );
296
 
 
297
 
  end;
298
 
 
299
 
 amask_no_clip_rgba32g = object(amask_no_clip_u8 )
300
 
   constructor Construct(rbuf : rendering_buffer_ptr );
301
 
 
302
 
  end;
303
 
 
304
 
 amask_no_clip_rgba32b = object(amask_no_clip_u8 )
305
 
   constructor Construct(rbuf : rendering_buffer_ptr );
306
 
 
307
 
  end;
308
 
 
309
 
 amask_no_clip_rgba32a = object(amask_no_clip_u8 )
310
 
   constructor Construct(rbuf : rendering_buffer_ptr );
311
 
 
312
 
  end;
313
 
 
314
 
 amask_no_clip_argb32r = object(amask_no_clip_u8 )
315
 
   constructor Construct(rbuf : rendering_buffer_ptr );
316
 
 
317
 
  end;
318
 
 
319
 
 amask_no_clip_argb32g = object(amask_no_clip_u8 )
320
 
   constructor Construct(rbuf : rendering_buffer_ptr );
321
 
 
322
 
  end;
323
 
 
324
 
 amask_no_clip_argb32b = object(amask_no_clip_u8 )
325
 
   constructor Construct(rbuf : rendering_buffer_ptr );
326
 
 
327
 
  end;
328
 
 
329
 
 amask_no_clip_argb32a = object(amask_no_clip_u8 )
330
 
   constructor Construct(rbuf : rendering_buffer_ptr );
331
 
 
332
 
  end;
333
 
 
334
 
 amask_no_clip_bgra32r = object(amask_no_clip_u8 )
335
 
   constructor Construct(rbuf : rendering_buffer_ptr );
336
 
 
337
 
  end;
338
 
 
339
 
 amask_no_clip_bgra32g = object(amask_no_clip_u8 )
340
 
   constructor Construct(rbuf : rendering_buffer_ptr );
341
 
 
342
 
  end;
343
 
 
344
 
 amask_no_clip_bgra32b = object(amask_no_clip_u8 )
345
 
   constructor Construct(rbuf : rendering_buffer_ptr );
346
 
 
347
 
  end;
348
 
 
349
 
 amask_no_clip_bgra32a = object(amask_no_clip_u8 )
350
 
   constructor Construct(rbuf : rendering_buffer_ptr );
351
 
 
352
 
  end;
353
 
 
354
 
 amask_no_clip_abgr32r = object(amask_no_clip_u8 )
355
 
   constructor Construct(rbuf : rendering_buffer_ptr );
356
 
 
357
 
  end;
358
 
 
359
 
 amask_no_clip_abgr32g = object(amask_no_clip_u8 )
360
 
   constructor Construct(rbuf : rendering_buffer_ptr );
361
 
 
362
 
  end;
363
 
 
364
 
 amask_no_clip_abgr32b = object(amask_no_clip_u8 )
365
 
   constructor Construct(rbuf : rendering_buffer_ptr );
366
 
 
367
 
  end;
368
 
 
369
 
 amask_no_clip_abgr32a = object(amask_no_clip_u8 )
370
 
   constructor Construct(rbuf : rendering_buffer_ptr );
371
 
 
372
 
  end;
373
 
 
374
 
 amask_no_clip_rgb24gray = object(amask_no_clip_u8 )
375
 
   constructor Construct(rbuf : rendering_buffer_ptr );
376
 
 
377
 
  end;
378
 
 
379
 
 amask_no_clip_bgr24gray = object(amask_no_clip_u8 )
380
 
   constructor Construct(rbuf : rendering_buffer_ptr );
381
 
 
382
 
  end;
383
 
 
384
 
 amask_no_clip_rgba32gray = object(amask_no_clip_u8 )
385
 
   constructor Construct(rbuf : rendering_buffer_ptr );
386
 
 
387
 
  end;
388
 
 
389
 
 amask_no_clip_argb32gray = object(amask_no_clip_u8 )
390
 
   constructor Construct(rbuf : rendering_buffer_ptr );
391
 
 
392
 
  end;
393
 
 
394
 
 amask_no_clip_bgra32gray = object(amask_no_clip_u8 )
395
 
   constructor Construct(rbuf : rendering_buffer_ptr );
396
 
 
397
 
  end;
398
 
 
399
 
 amask_no_clip_abgr32gray = object(amask_no_clip_u8 )
400
 
   constructor Construct(rbuf : rendering_buffer_ptr );
401
 
 
402
 
  end;
403
 
 
404
 
{ GLOBAL PROCEDURES }
405
 
 function one_component_mask_u8  (p : int8u_ptr ) : unsigned;
406
 
 function rgb_to_gray_mask_u8_012(p : int8u_ptr ) : unsigned;
407
 
 function rgb_to_gray_mask_u8_210(p : int8u_ptr ) : unsigned;
408
 
 
409
 
 
410
 
IMPLEMENTATION
411
 
{ LOCAL VARIABLES & CONSTANTS }
412
 
{ UNIT IMPLEMENTATION }
413
 
{ ONE_COMPONENT_MASK_U8 }
414
 
function one_component_mask_u8;
415
 
begin
416
 
 result:=p^;
417
 
 
418
 
end;
419
 
 
420
 
{ RGB_TO_GRAY_MASK_U8_012 }
421
 
function rgb_to_gray_mask_u8_012;
422
 
begin
423
 
 result:=
424
 
  int8u((
425
 
   int8u_ptr(ptrcomp(p ) + 0 * sizeof(int8u ) )^ * 77 +
426
 
   int8u_ptr(ptrcomp(p ) + 1 * sizeof(int8u ) )^ * 150 +
427
 
   int8u_ptr(ptrcomp(p ) + 2 * sizeof(int8u ) )^ * 29  shr 8 ) );
428
 
 
429
 
end;
430
 
 
431
 
{ RGB_TO_GRAY_MASK_U8_210 }
432
 
function rgb_to_gray_mask_u8_210;
433
 
begin
434
 
 result:=
435
 
  int8u((
436
 
   int8u_ptr(ptrcomp(p ) + 2 * sizeof(int8u ) )^ * 77 +
437
 
   int8u_ptr(ptrcomp(p ) + 1 * sizeof(int8u ) )^ * 150 +
438
 
   int8u_ptr(ptrcomp(p ) + 0 * sizeof(int8u ) )^ * 29 shr 8 ) );
439
 
 
440
 
end;
441
 
 
442
 
{ CONSTRUCT }
443
 
constructor alpha_mask_u8.Construct(MaskF : func_mask_calculate; Step_ : unsigned = 1; Offset_ : unsigned = 0 );
444
 
begin
445
 
 Step  :=Step_;
446
 
 Offset:=Offset_;
447
 
 
448
 
 m_rbuf         :=NIL;
449
 
 m_mask_function:=MaskF;
450
 
 
451
 
end;
452
 
 
453
 
{ CONSTRUCT }
454
 
constructor alpha_mask_u8.Construct(rbuf : rendering_buffer_ptr; MaskF : func_mask_calculate; Step_ : unsigned = 1; Offset_ : unsigned = 0 );
455
 
begin
456
 
 Step  :=Step_;
457
 
 Offset:=Offset_;
458
 
 
459
 
 m_rbuf         :=rbuf;
460
 
 m_mask_function:=MaskF;
461
 
 
462
 
end;
463
 
 
464
 
{ ATTACH }
465
 
procedure alpha_mask_u8.attach;
466
 
begin
467
 
 m_rbuf:=rbuf;
468
 
 
469
 
end;
470
 
 
471
 
{ MASK_FUNCTION }
472
 
function alpha_mask_u8.mask_function;
473
 
begin
474
 
 result:=@m_mask_function;
475
 
 
476
 
end;
477
 
 
478
 
{ PIXEL }
479
 
function alpha_mask_u8.pixel;
480
 
begin
481
 
 if(x >= 0 ) and
482
 
   (y >= 0 ) and
483
 
   (x < m_rbuf._width ) and
484
 
   (y < m_rbuf._height ) then
485
 
  result:=
486
 
   int8u(m_mask_function(
487
 
    int8u_ptr(ptrcomp(m_rbuf.row(y ) ) + (x * Step + Offset ) * sizeof(int8u ) ) ) )
488
 
 else
489
 
  result:=0;
490
 
 
491
 
end;
492
 
 
493
 
{ COMBINE_PIXEL }
494
 
function alpha_mask_u8.combine_pixel;
495
 
begin
496
 
 if(x >= 0 ) and
497
 
   (y >= 0 ) and
498
 
   (x < m_rbuf._width ) and
499
 
   (y < m_rbuf._height ) then
500
 
  result:=int8u(
501
 
   (cover_full + val *
502
 
     m_mask_function(
503
 
      int8u_ptr(ptrcomp(m_rbuf.row(y ) ) + (x * Step + Offset ) * sizeof(int8u ) ) )
504
 
   ) shr cover_shift )
505
 
 else
506
 
  result:=0;
507
 
 
508
 
end;
509
 
 
510
 
{ FILL_HSPAN }
511
 
procedure alpha_mask_u8.fill_hspan;
512
 
var
513
 
 xmax ,ymax ,count ,rest : int;
514
 
 
515
 
 covers ,mask : int8u_ptr;
516
 
 
517
 
begin
518
 
 xmax:=m_rbuf._width - 1;
519
 
 ymax:=m_rbuf._height - 1;
520
 
 
521
 
 count :=num_pix;
522
 
 covers:=dst;
523
 
 
524
 
 if (y < 0 ) or
525
 
    (y > ymax ) then
526
 
  begin
527
 
   fillchar(dst^ ,num_pix * sizeof(int8u ) ,0 );
528
 
 
529
 
   exit;
530
 
 
531
 
  end;
532
 
 
533
 
 if x < 0 then
534
 
  begin
535
 
   inc(count ,x );
536
 
 
537
 
   if count <= 0 then
538
 
    begin
539
 
     fillchar(dst^ ,num_pix * sizeof(int8u ) ,0 );
540
 
 
541
 
     exit;
542
 
 
543
 
    end;
544
 
 
545
 
   fillchar(covers^ ,-x * sizeof(int8u ) ,0 );
546
 
 
547
 
   dec(covers ,x );
548
 
 
549
 
   x:=0;
550
 
 
551
 
  end;
552
 
 
553
 
 if x + count > xmax then
554
 
  begin
555
 
   rest:=x + count - xmax - 1;
556
 
 
557
 
   dec(count ,rest );
558
 
 
559
 
   if count <= 0 then
560
 
    begin
561
 
     fillchar(dst^ ,num_pix * sizeof(int8u ) ,0 );
562
 
 
563
 
     exit;
564
 
 
565
 
    end;
566
 
 
567
 
   fillchar(int8u_ptr(ptrcomp(covers ) + count * sizeof(int8u ) )^ ,rest * sizeof(int8u ) ,0 );
568
 
 
569
 
  end;
570
 
 
571
 
 mask:=int8u_ptr(ptrcomp(m_rbuf.row(y ) ) + (x * Step + Offset ) * sizeof(int8u ) );
572
 
 
573
 
 repeat
574
 
  covers^:=int8u(m_mask_function(mask ) );
575
 
 
576
 
  inc(ptrcomp(covers ) ,sizeof(int8u ) );
577
 
  inc(ptrcomp(mask ) ,Step * sizeof(int8u ) );
578
 
  dec(count );
579
 
 
580
 
 until count = 0;
581
 
 
582
 
end;
583
 
 
584
 
{ COMBINE_HSPAN }
585
 
procedure alpha_mask_u8.combine_hspan;
586
 
var
587
 
 xmax ,ymax ,count ,rest : int;
588
 
 
589
 
 covers ,mask : int8u_ptr;
590
 
 
591
 
begin
592
 
 xmax:=m_rbuf._width - 1;
593
 
 ymax:=m_rbuf._height - 1;
594
 
 
595
 
 count :=num_pix;
596
 
 covers:=dst;
597
 
 
598
 
 if (y < 0 ) or
599
 
    (y > ymax ) then
600
 
  begin
601
 
   fillchar(dst^ ,num_pix * sizeof(int8u ) ,0 );
602
 
 
603
 
   exit;
604
 
 
605
 
  end;
606
 
 
607
 
 if x < 0 then
608
 
  begin
609
 
   inc(count ,x );
610
 
 
611
 
   if count <= 0 then
612
 
    begin
613
 
     fillchar(dst^ ,num_pix * sizeof(int8u ) ,0 );
614
 
 
615
 
     exit;
616
 
 
617
 
    end;
618
 
 
619
 
   fillchar(covers^ ,-x * sizeof(int8u ) ,0 );
620
 
 
621
 
   dec(ptrcomp(covers ) ,x * sizeof(int8u ) );
622
 
 
623
 
   x:=0;
624
 
 
625
 
  end;
626
 
 
627
 
 if x + count > xmax then
628
 
  begin
629
 
   rest:=x + count - xmax - 1;
630
 
 
631
 
   dec(count ,rest );
632
 
 
633
 
   if count <= 0 then
634
 
    begin
635
 
     fillchar(dst^ ,num_pix * sizeof(int8u ) ,0 );
636
 
 
637
 
     exit;
638
 
 
639
 
    end;
640
 
 
641
 
   fillchar(int8u_ptr(ptrcomp(covers ) + count * sizeof(int8u ) )^ ,rest * sizeof(int8u ) ,0 );
642
 
 
643
 
  end;
644
 
 
645
 
 mask:=int8u_ptr(ptrcomp(m_rbuf.row(y ) ) + (x * Step + Offset ) * sizeof(int8u ) );
646
 
 
647
 
 repeat
648
 
  covers^:=
649
 
   int8u(
650
 
    (cover_full + covers^ *
651
 
     m_mask_function(mask ) ) shr cover_shift );
652
 
 
653
 
  inc(ptrcomp(covers ) ,sizeof(int8u ) );
654
 
  inc(mask ,Step * sizeof(int8u ) );
655
 
  dec(count );
656
 
 
657
 
 until count = 0;
658
 
 
659
 
 
660
 
end;
661
 
 
662
 
{ FILL_VSPAN }
663
 
procedure alpha_mask_u8.fill_vspan;
664
 
var
665
 
 xmax ,ymax ,count ,rest : int;
666
 
 
667
 
 covers ,mask : int8u_ptr;
668
 
 
669
 
begin
670
 
 xmax:=m_rbuf._width - 1;
671
 
 ymax:=m_rbuf._height - 1;
672
 
 
673
 
 count :=num_pix;
674
 
 covers:=dst;
675
 
 
676
 
 if (x < 0 ) or
677
 
    (x > xmax ) then
678
 
  begin
679
 
   fillchar(dst^ ,num_pix * sizeof(int8u ) ,0 );
680
 
 
681
 
   exit;
682
 
 
683
 
  end;
684
 
 
685
 
 if y < 0 then
686
 
  begin
687
 
   inc(count ,y );
688
 
 
689
 
   if count <= 0 then
690
 
    begin
691
 
     fillchar(dst^ ,num_pix * sizeof(int8u ) ,0 );
692
 
 
693
 
     exit;
694
 
 
695
 
    end;
696
 
 
697
 
   fillchar(covers^ ,-y * sizeof(int8u ) ,0 );
698
 
 
699
 
   dec(ptrcomp(covers ) ,y * sizeof(int8u ) );
700
 
 
701
 
   y:=0;
702
 
 
703
 
  end;
704
 
 
705
 
 if y + count > ymax then
706
 
  begin
707
 
   rest:=y + count - ymax - 1;
708
 
 
709
 
   dec(count ,rest );
710
 
 
711
 
   if count <= 0 then
712
 
    begin
713
 
     fillchar(dst^ ,num_pix * sizeof(int8u ) ,0 );
714
 
 
715
 
     exit;
716
 
 
717
 
    end;
718
 
 
719
 
   fillchar(int8u_ptr(ptrcomp(covers ) + count * sizeof(int8u ) )^ ,rest * sizeof(int8u ) ,0 );
720
 
 
721
 
  end;
722
 
 
723
 
 repeat
724
 
  covers^:=int8u(m_mask_function(mask ) );
725
 
 
726
 
  inc(ptrcomp(covers ) ,sizeof(int8u ) );
727
 
  inc(ptrcomp(mask ) ,m_rbuf._stride );
728
 
  dec(count );
729
 
 
730
 
 until count = 0;
731
 
 
732
 
end;
733
 
 
734
 
{ COMBINE_VSPAN }
735
 
procedure alpha_mask_u8.combine_vspan;
736
 
var
737
 
 xmax ,ymax ,count ,rest : int;
738
 
 
739
 
 covers ,mask : int8u_ptr;
740
 
 
741
 
begin
742
 
 xmax:=m_rbuf._width - 1;
743
 
 ymax:=m_rbuf._height - 1;
744
 
 
745
 
 count :=num_pix;
746
 
 covers:=dst;
747
 
 
748
 
 if (x < 0 ) or
749
 
    (x > xmax ) then
750
 
  begin
751
 
   fillchar(dst^ ,num_pix * sizeof(int8u ) ,0 );
752
 
 
753
 
   exit;
754
 
 
755
 
  end;
756
 
 
757
 
 if y < 0 then
758
 
  begin
759
 
   inc(count ,y );
760
 
 
761
 
   if count <= 0 then
762
 
    begin
763
 
     fillchar(dst^ ,num_pix * sizeof(int8u ) ,0 );
764
 
 
765
 
     exit;
766
 
 
767
 
    end;
768
 
 
769
 
   fillchar(covers^ ,-y * sizeof(int8u ) ,0 );
770
 
 
771
 
   dec(ptrcomp(covers ) ,y * sizeof(int8u ) );
772
 
 
773
 
   y:=0;
774
 
 
775
 
  end;
776
 
 
777
 
 if y + count > ymax then
778
 
  begin
779
 
   rest:=y + count - ymax - 1;
780
 
 
781
 
   dec(count ,rest );
782
 
 
783
 
   if count <= 0 then
784
 
    begin
785
 
     fillchar(dst^ ,num_pix * sizeof(int8u ) ,0 );
786
 
 
787
 
     exit;
788
 
 
789
 
    end;
790
 
 
791
 
   fillchar(int8u_ptr(ptrcomp(covers ) + count * sizeof(int8u ) )^ ,rest * sizeof(int8u ) ,0 );
792
 
 
793
 
  end;
794
 
 
795
 
 mask:=int8u_ptr(ptrcomp(m_rbuf.row(y ) ) + (x * Step + Offset ) * sizeof(int8u ) );
796
 
 
797
 
 repeat
798
 
  covers^:=
799
 
   int8u(
800
 
    (cover_full + covers^ *
801
 
     m_mask_function(mask ) ) shr cover_shift );
802
 
 
803
 
  inc(ptrcomp(covers ) ,sizeof(int8u ) );
804
 
  inc(ptrcomp(mask ) ,m_rbuf._stride );
805
 
  dec(count );
806
 
 
807
 
 until count = 0;
808
 
 
809
 
end;
810
 
 
811
 
{ CONSTRUCT }
812
 
constructor alpha_mask_gray8.Construct;
813
 
begin
814
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,1 ,0 );
815
 
 
816
 
end;
817
 
 
818
 
{ CONSTRUCT }
819
 
constructor alpha_mask_rgb24r.Construct;
820
 
begin
821
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,3 ,0 );
822
 
 
823
 
end;
824
 
 
825
 
{ CONSTRUCT }
826
 
constructor alpha_mask_rgb24g.Construct;
827
 
begin
828
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,3 ,1 );
829
 
 
830
 
end;
831
 
 
832
 
{ CONSTRUCT }
833
 
constructor alpha_mask_rgb24b.Construct;
834
 
begin
835
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,3 ,2 );
836
 
 
837
 
end;
838
 
 
839
 
{ CONSTRUCT }
840
 
constructor alpha_mask_bgr24r.Construct;
841
 
begin
842
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,3 ,2 );
843
 
 
844
 
end;
845
 
 
846
 
{ CONSTRUCT }
847
 
constructor alpha_mask_bgr24g.Construct;
848
 
begin
849
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,3 ,1 );
850
 
 
851
 
end;
852
 
 
853
 
{ CONSTRUCT }
854
 
constructor alpha_mask_bgr24b.Construct;
855
 
begin
856
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,3 ,0 );
857
 
 
858
 
end;
859
 
 
860
 
{ CONSTRUCT }
861
 
constructor alpha_mask_rgba32r.Construct;
862
 
begin
863
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,0 );
864
 
 
865
 
end;
866
 
 
867
 
{ CONSTRUCT }
868
 
constructor alpha_mask_rgba32g.Construct;
869
 
begin
870
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,1 );
871
 
 
872
 
end;
873
 
 
874
 
{ CONSTRUCT }
875
 
constructor alpha_mask_rgba32b.Construct;
876
 
begin
877
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,2 );
878
 
 
879
 
end;
880
 
 
881
 
{ CONSTRUCT }
882
 
constructor alpha_mask_rgba32a.Construct;
883
 
begin
884
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,3 );
885
 
 
886
 
end;
887
 
 
888
 
{ CONSTRUCT }
889
 
constructor alpha_mask_argb32r.Construct;
890
 
begin
891
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,1 );
892
 
 
893
 
end;
894
 
 
895
 
{ CONSTRUCT }
896
 
constructor alpha_mask_argb32g.Construct;
897
 
begin
898
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,2 );
899
 
 
900
 
end;
901
 
 
902
 
{ CONSTRUCT }
903
 
constructor alpha_mask_argb32b.Construct;
904
 
begin
905
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,3 );
906
 
 
907
 
end;
908
 
 
909
 
{ CONSTRUCT }
910
 
constructor alpha_mask_argb32a.Construct;
911
 
begin
912
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,0 );
913
 
 
914
 
end;
915
 
 
916
 
{ CONSTRUCT }
917
 
constructor alpha_mask_bgra32r.Construct;
918
 
begin
919
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,2 );
920
 
 
921
 
end;
922
 
 
923
 
{ CONSTRUCT }
924
 
constructor alpha_mask_bgra32g.Construct;
925
 
begin
926
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,1 );
927
 
 
928
 
end;
929
 
 
930
 
{ CONSTRUCT }
931
 
constructor alpha_mask_bgra32b.Construct;
932
 
begin
933
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,0 );
934
 
 
935
 
end;
936
 
 
937
 
{ CONSTRUCT }
938
 
constructor alpha_mask_bgra32a.Construct;
939
 
begin
940
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,3 );
941
 
 
942
 
end;
943
 
 
944
 
{ CONSTRUCT }
945
 
constructor alpha_mask_abgr32r.Construct;
946
 
begin
947
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,3 );
948
 
 
949
 
end;
950
 
 
951
 
{ CONSTRUCT }
952
 
constructor alpha_mask_abgr32g.Construct;
953
 
begin
954
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,2 );
955
 
 
956
 
end;
957
 
 
958
 
{ CONSTRUCT }
959
 
constructor alpha_mask_abgr32b.Construct;
960
 
begin
961
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,1 );
962
 
 
963
 
end;
964
 
 
965
 
{ CONSTRUCT }
966
 
constructor alpha_mask_abgr32a.Construct;
967
 
begin
968
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,0 );
969
 
 
970
 
end;
971
 
 
972
 
{ CONSTRUCT }
973
 
constructor alpha_mask_rgb24gray.Construct;
974
 
begin
975
 
 inherited Construct(rbuf ,@rgb_to_gray_mask_u8_012 ,3 ,0 );
976
 
 
977
 
end;
978
 
 
979
 
{ CONSTRUCT }
980
 
constructor alpha_mask_bgr24gray.Construct;
981
 
begin
982
 
 inherited Construct(rbuf ,@rgb_to_gray_mask_u8_210 ,3 ,0 );
983
 
 
984
 
end;
985
 
 
986
 
{ CONSTRUCT }
987
 
constructor alpha_mask_rgba32gray.Construct;
988
 
begin
989
 
 inherited Construct(rbuf ,@rgb_to_gray_mask_u8_012 ,4 ,0 );
990
 
 
991
 
end;
992
 
 
993
 
{ CONSTRUCT }
994
 
constructor alpha_mask_argb32gray.Construct;
995
 
begin
996
 
 inherited Construct(rbuf ,@rgb_to_gray_mask_u8_012 ,4 ,1 );
997
 
 
998
 
end;
999
 
 
1000
 
{ CONSTRUCT }
1001
 
constructor alpha_mask_bgra32gray.Construct;
1002
 
begin
1003
 
 inherited Construct(rbuf ,@rgb_to_gray_mask_u8_210 ,4 ,0 );
1004
 
 
1005
 
end;
1006
 
 
1007
 
{ CONSTRUCT }
1008
 
constructor alpha_mask_abgr32gray.Construct;
1009
 
begin
1010
 
 inherited Construct(rbuf ,@rgb_to_gray_mask_u8_210 ,4 ,1 );
1011
 
 
1012
 
end;
1013
 
 
1014
 
{ CONSTRUCT }
1015
 
constructor amask_no_clip_u8.Construct(MaskF : func_mask_calculate; Step_ : unsigned = 1; Offset_ : unsigned = 0 );
1016
 
begin
1017
 
 Step  :=Step_;
1018
 
 Offset:=Offset_;
1019
 
 
1020
 
 m_rbuf         :=NIL;
1021
 
 m_mask_function:=MaskF;
1022
 
 
1023
 
end;
1024
 
 
1025
 
{ CONSTRUCT }
1026
 
constructor amask_no_clip_u8.Construct(rbuf : rendering_buffer_ptr; MaskF : func_mask_calculate; Step_ : unsigned = 1; Offset_ : unsigned = 0 );
1027
 
begin
1028
 
 Step  :=Step_;
1029
 
 Offset:=Offset_;
1030
 
 
1031
 
 m_rbuf         :=rbuf;
1032
 
 m_mask_function:=MaskF;
1033
 
 
1034
 
end;
1035
 
 
1036
 
{ ATTACH }
1037
 
procedure amask_no_clip_u8.attach;
1038
 
begin
1039
 
 m_rbuf:=rbuf;
1040
 
 
1041
 
end;
1042
 
 
1043
 
{ MASK_FUNCTION }
1044
 
function amask_no_clip_u8.mask_function;
1045
 
begin
1046
 
 result:=@m_mask_function;
1047
 
 
1048
 
end;
1049
 
 
1050
 
{ PIXEL }
1051
 
function amask_no_clip_u8.pixel;
1052
 
begin
1053
 
 result:=
1054
 
  int8u(m_mask_function(
1055
 
   int8u_ptr(ptrcomp(m_rbuf.row(y ) ) + (x * Step + Offset ) * sizeof(int8u ) ) ) );
1056
 
 
1057
 
end;
1058
 
 
1059
 
{ COMBINE_PIXEL }
1060
 
function amask_no_clip_u8.combine_pixel;
1061
 
begin
1062
 
 result:=int8u(
1063
 
  (cover_full + val *
1064
 
    m_mask_function(
1065
 
     int8u_ptr(ptrcomp(m_rbuf.row(y ) ) + (x * Step + Offset ) * sizeof(int8u ) ) )
1066
 
  ) shr cover_shift );
1067
 
 
1068
 
end;
1069
 
 
1070
 
{ FILL_HSPAN }
1071
 
procedure amask_no_clip_u8.fill_hspan;
1072
 
var
1073
 
 mask : int8u_ptr;
1074
 
 
1075
 
begin
1076
 
 mask:=int8u_ptr(ptrcomp(m_rbuf.row(y ) ) + (x * Step + Offset ) * sizeof(int8u ) );
1077
 
 
1078
 
 repeat
1079
 
  dst^:=int8u(m_mask_function(mask ) );
1080
 
 
1081
 
  inc(ptrcomp(dst ) ,sizeof(int8u ) );
1082
 
  inc(ptrcomp(mask ) ,Step * sizeof(int8u ) );
1083
 
  dec(num_pix );
1084
 
 
1085
 
 until num_pix = 0;
1086
 
 
1087
 
end;
1088
 
 
1089
 
{ COMBINE_HSPAN }
1090
 
procedure amask_no_clip_u8.combine_hspan;
1091
 
var
1092
 
 mask : int8u_ptr;
1093
 
 
1094
 
begin
1095
 
 mask:=int8u_ptr(ptrcomp(m_rbuf.row(y ) ) + (x * Step + Offset ) * sizeof(int8u ) );
1096
 
 
1097
 
 repeat
1098
 
  dst^:=int8u((cover_full + dst^ * m_mask_function(mask ) ) shr cover_shift );
1099
 
 
1100
 
  inc(ptrcomp(dst ) ,sizeof(int8u ) );
1101
 
  inc(ptrcomp(mask ) ,Step * sizeof(int8u ) );
1102
 
  dec(num_pix );
1103
 
 
1104
 
 until num_pix = 0;
1105
 
 
1106
 
end;
1107
 
 
1108
 
{ FILL_VSPAN }
1109
 
procedure amask_no_clip_u8.fill_vspan;
1110
 
var
1111
 
 mask : int8u_ptr;
1112
 
 
1113
 
begin
1114
 
 mask:=int8u_ptr(ptrcomp(m_rbuf.row(y ) ) + (x * Step + Offset ) * sizeof(int8u ) );
1115
 
 
1116
 
 repeat
1117
 
  dst^:=int8u(m_mask_function(mask ) );
1118
 
 
1119
 
  inc(ptrcomp(dst ) ,sizeof(int8u ) );
1120
 
  inc(ptrcomp(mask ) ,m_rbuf._stride );
1121
 
  dec(num_pix );
1122
 
 
1123
 
 until num_pix = 0;
1124
 
 
1125
 
end;
1126
 
 
1127
 
{ COMBINE_VSPAN }
1128
 
procedure amask_no_clip_u8.combine_vspan;
1129
 
var
1130
 
 mask : int8u_ptr;
1131
 
 
1132
 
begin
1133
 
 mask:=int8u_ptr(ptrcomp(m_rbuf.row(y ) ) + (x * Step + Offset ) * sizeof(int8u ) );
1134
 
 
1135
 
 repeat
1136
 
  dst^:=int8u((cover_full + dst^ * m_mask_function(mask ) ) shr cover_shift );
1137
 
 
1138
 
  inc(ptrcomp(dst ) ,sizeof(int8u ) );
1139
 
  inc(ptrcomp(mask ) ,m_rbuf._stride );
1140
 
  dec(num_pix );
1141
 
 
1142
 
 until num_pix = 0;
1143
 
 
1144
 
end;
1145
 
 
1146
 
{ CONSTRUCT }
1147
 
constructor amask_no_clip_gray8.Construct;
1148
 
begin
1149
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,1 ,0 );
1150
 
 
1151
 
end;
1152
 
 
1153
 
{ CONSTRUCT }
1154
 
constructor amask_no_clip_rgb24r.Construct;
1155
 
begin
1156
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,3 ,0 );
1157
 
 
1158
 
end;
1159
 
 
1160
 
{ CONSTRUCT }
1161
 
constructor amask_no_clip_rgb24g.Construct;
1162
 
begin
1163
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,3 ,1 );
1164
 
 
1165
 
end;
1166
 
 
1167
 
{ CONSTRUCT }
1168
 
constructor amask_no_clip_rgb24b.Construct;
1169
 
begin
1170
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,3 ,2 );
1171
 
 
1172
 
end;
1173
 
 
1174
 
{ CONSTRUCT }
1175
 
constructor amask_no_clip_bgr24r.Construct;
1176
 
begin
1177
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,3 ,2 );
1178
 
 
1179
 
end;
1180
 
 
1181
 
{ CONSTRUCT }
1182
 
constructor amask_no_clip_bgr24g.Construct;
1183
 
begin
1184
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,3 ,1 );
1185
 
 
1186
 
end;
1187
 
 
1188
 
{ CONSTRUCT }
1189
 
constructor amask_no_clip_bgr24b.Construct;
1190
 
begin
1191
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,3 ,0 );
1192
 
 
1193
 
end;
1194
 
 
1195
 
{ CONSTRUCT }
1196
 
constructor amask_no_clip_rgba32r.Construct;
1197
 
begin
1198
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,0 );
1199
 
 
1200
 
end;
1201
 
 
1202
 
{ CONSTRUCT }
1203
 
constructor amask_no_clip_rgba32g.Construct;
1204
 
begin
1205
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,1 );
1206
 
 
1207
 
end;
1208
 
 
1209
 
{ CONSTRUCT }
1210
 
constructor amask_no_clip_rgba32b.Construct;
1211
 
begin
1212
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,2 );
1213
 
 
1214
 
end;
1215
 
 
1216
 
{ CONSTRUCT }
1217
 
constructor amask_no_clip_rgba32a.Construct;
1218
 
begin
1219
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,3 );
1220
 
 
1221
 
end;
1222
 
 
1223
 
{ CONSTRUCT }
1224
 
constructor amask_no_clip_argb32r.Construct;
1225
 
begin
1226
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,1 );
1227
 
 
1228
 
end;
1229
 
 
1230
 
{ CONSTRUCT }
1231
 
constructor amask_no_clip_argb32g.Construct;
1232
 
begin
1233
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,2 );
1234
 
 
1235
 
end;
1236
 
 
1237
 
{ CONSTRUCT }
1238
 
constructor amask_no_clip_argb32b.Construct;
1239
 
begin
1240
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,3 );
1241
 
 
1242
 
end;
1243
 
 
1244
 
{ CONSTRUCT }
1245
 
constructor amask_no_clip_argb32a.Construct;
1246
 
begin
1247
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,0 );
1248
 
 
1249
 
end;
1250
 
 
1251
 
{ CONSTRUCT }
1252
 
constructor amask_no_clip_bgra32r.Construct;
1253
 
begin
1254
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,2 );
1255
 
 
1256
 
end;
1257
 
 
1258
 
{ CONSTRUCT }
1259
 
constructor amask_no_clip_bgra32g.Construct;
1260
 
begin
1261
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,1 );
1262
 
 
1263
 
end;
1264
 
 
1265
 
{ CONSTRUCT }
1266
 
constructor amask_no_clip_bgra32b.Construct;
1267
 
begin
1268
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,0 );
1269
 
 
1270
 
end;
1271
 
 
1272
 
{ CONSTRUCT }
1273
 
constructor amask_no_clip_bgra32a.Construct;
1274
 
begin
1275
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,3 );
1276
 
 
1277
 
end;
1278
 
 
1279
 
{ CONSTRUCT }
1280
 
constructor amask_no_clip_abgr32r.Construct;
1281
 
begin
1282
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,3 );
1283
 
 
1284
 
end;
1285
 
 
1286
 
{ CONSTRUCT }
1287
 
constructor amask_no_clip_abgr32g.Construct;
1288
 
begin
1289
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,2 );
1290
 
 
1291
 
end;
1292
 
 
1293
 
{ CONSTRUCT }
1294
 
constructor amask_no_clip_abgr32b.Construct;
1295
 
begin
1296
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,1 );
1297
 
 
1298
 
end;
1299
 
 
1300
 
{ CONSTRUCT }
1301
 
constructor amask_no_clip_abgr32a.Construct;
1302
 
begin
1303
 
 inherited Construct(rbuf ,@one_component_mask_u8 ,4 ,0 );
1304
 
 
1305
 
end;
1306
 
 
1307
 
{ CONSTRUCT }
1308
 
constructor amask_no_clip_rgb24gray.Construct;
1309
 
begin
1310
 
 inherited Construct(rbuf ,@rgb_to_gray_mask_u8_012 ,3 ,0 );
1311
 
 
1312
 
end;
1313
 
 
1314
 
{ CONSTRUCT }
1315
 
constructor amask_no_clip_bgr24gray.Construct;
1316
 
begin
1317
 
 inherited Construct(rbuf ,@rgb_to_gray_mask_u8_210 ,3 ,0 );
1318
 
 
1319
 
end;
1320
 
 
1321
 
{ CONSTRUCT }
1322
 
constructor amask_no_clip_rgba32gray.Construct;
1323
 
begin
1324
 
 inherited Construct(rbuf ,@rgb_to_gray_mask_u8_012 ,4 ,0 );
1325
 
 
1326
 
end;
1327
 
 
1328
 
{ CONSTRUCT }
1329
 
constructor amask_no_clip_argb32gray.Construct;
1330
 
begin
1331
 
 inherited Construct(rbuf ,@rgb_to_gray_mask_u8_012 ,4 ,1 );
1332
 
 
1333
 
end;
1334
 
 
1335
 
{ CONSTRUCT }
1336
 
constructor amask_no_clip_bgra32gray.Construct;
1337
 
begin
1338
 
 inherited Construct(rbuf ,@rgb_to_gray_mask_u8_210 ,4 ,0 );
1339
 
 
1340
 
end;
1341
 
 
1342
 
{ CONSTRUCT }
1343
 
constructor amask_no_clip_abgr32gray.Construct;
1344
 
begin
1345
 
 inherited Construct(rbuf ,@rgb_to_gray_mask_u8_210 ,4 ,1 );
1346
 
 
1347
 
end;
1348
 
 
1349
 
END.
1350