mirror of
https://gitlab.com/freepascal.org/lazarus/lazarus.git
synced 2025-07-24 12:36:26 +02:00
213 lines
4.6 KiB
ObjectPascal
213 lines
4.6 KiB
ObjectPascal
//----------------------------------------------------------------------------
|
|
// Anti-Grain Geometry - Version 2.4 (Public License)
|
|
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
|
|
//
|
|
// Anti-Grain Geometry - Version 2.4 Release Milano 3 (AggPas 2.4 RM3)
|
|
// Pascal Port By: Milan Marusinec alias Milano
|
|
// milan@marusinec.sk
|
|
// http://www.aggpas.org
|
|
// Copyright (c) 2005-2007
|
|
//
|
|
// Permission to copy, use, modify, sell and distribute this software
|
|
// is granted provided this copyright notice appears in all copies.
|
|
// This software is provided "as is" without express or implied
|
|
// warranty, and with no claim as to its suitability for any purpose.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
// Contact: mcseem@antigrain.com
|
|
// mcseemagg@yahoo.com
|
|
// http://www.antigrain.com
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// class rendering_buffer_dynarow
|
|
//
|
|
// [Pascal Port History] -----------------------------------------------------
|
|
//
|
|
// 06.10.2007-Milano: Unit port establishment
|
|
//
|
|
{ agg_rendering_buffer_dynarow.pas }
|
|
unit
|
|
agg_rendering_buffer_dynarow ;
|
|
|
|
INTERFACE
|
|
|
|
{$I agg_mode.inc }
|
|
|
|
uses
|
|
agg_basics ,
|
|
agg_rendering_buffer ;
|
|
|
|
{ TYPES DEFINITION }
|
|
type
|
|
//===============================================rendering_buffer_dynarow
|
|
// Rendering buffer class with dynamic allocation of the rows.
|
|
// The rows are allocated as needed when requesting for span_ptr().
|
|
// The class automatically calculates min_x and max_x for each row.
|
|
// Generally it's more efficient to use this class as a temporary buffer
|
|
// for rendering a few lines and then to blend it with another buffer.
|
|
rendering_buffer_dynarow_ptr = ^rendering_buffer_dynarow;
|
|
rendering_buffer_dynarow = object(rendering_buffer )
|
|
private
|
|
m_buff : row_data_type_ptr; // Pointers to each row of the buffer
|
|
m_alloc ,
|
|
|
|
m_byte_width : unsigned; // Width in bytes
|
|
|
|
public
|
|
constructor Construct(width ,height ,byte_width : unsigned );
|
|
destructor Destruct; virtual;
|
|
|
|
procedure init(width ,height ,byte_width : unsigned );
|
|
|
|
function _width : unsigned;
|
|
function _height : unsigned;
|
|
function _byte_width : unsigned;
|
|
|
|
function row_xy(x ,y : int; len : unsigned ) : int8u_ptr; virtual;
|
|
function row (y : unsigned ) : int8u_ptr; virtual;
|
|
|
|
end;
|
|
|
|
{ GLOBAL VARIABLES & CONSTANTS }
|
|
{ GLOBAL PROCEDURES }
|
|
|
|
|
|
IMPLEMENTATION
|
|
{ LOCAL VARIABLES & CONSTANTS }
|
|
{ UNIT IMPLEMENTATION }
|
|
{ CONSTRUCT }
|
|
// Allocate and clear the buffer
|
|
constructor rendering_buffer_dynarow.Construct(width ,height ,byte_width : unsigned );
|
|
begin
|
|
m_alloc:=sizeof(row_data_type ) * height;
|
|
|
|
agg_getmem(pointer(m_buff ) ,m_alloc );
|
|
|
|
m_width :=width;
|
|
m_height:=height;
|
|
|
|
m_byte_width:=byte_width;
|
|
|
|
FillChar(m_buff^ ,m_alloc ,0 );
|
|
|
|
end;
|
|
|
|
{ DESTRUCT }
|
|
destructor rendering_buffer_dynarow.Destruct;
|
|
begin
|
|
init(0 ,0 ,0 );
|
|
|
|
end;
|
|
|
|
{ INIT }
|
|
// Allocate and clear the buffer
|
|
procedure rendering_buffer_dynarow.init(width ,height ,byte_width : unsigned );
|
|
var
|
|
i : unsigned;
|
|
|
|
begin
|
|
i:=0;
|
|
|
|
while i < m_height do
|
|
begin
|
|
agg_freemem(
|
|
pointer(
|
|
row_data_type_ptr(ptrcomp(m_buff ) + i * sizeof(row_data_type ) ).ptr ) ,
|
|
m_byte_width );
|
|
|
|
inc(i );
|
|
|
|
end;
|
|
|
|
agg_freemem(pointer(m_buff ) ,m_alloc );
|
|
|
|
m_buff:=NIL;
|
|
|
|
if (width <> 0 ) and
|
|
(height <> 0 ) then
|
|
begin
|
|
m_width :=width;
|
|
m_height:=height;
|
|
|
|
m_byte_width:=byte_width;
|
|
|
|
m_alloc:=sizeof(row_data_type ) * height;
|
|
|
|
agg_getmem(pointer(m_buff ) ,m_alloc );
|
|
FillChar (m_buff^ ,m_alloc ,0 );
|
|
|
|
end;
|
|
|
|
end;
|
|
|
|
{ _WIDTH }
|
|
function rendering_buffer_dynarow._width : unsigned;
|
|
begin
|
|
result:=m_width;
|
|
|
|
end;
|
|
|
|
{ _HEIGHT }
|
|
function rendering_buffer_dynarow._height : unsigned;
|
|
begin
|
|
result:=m_height;
|
|
|
|
end;
|
|
|
|
{ _BYTE_WIDTH }
|
|
function rendering_buffer_dynarow._byte_width : unsigned;
|
|
begin
|
|
result:=m_byte_width;
|
|
|
|
end;
|
|
|
|
{ ROW_XY }
|
|
// The main function used for rendering. Returns pointer to the
|
|
// pre-allocated span. Memory for the row is allocated as needed.
|
|
function rendering_buffer_dynarow.row_xy(x ,y : int; len : unsigned ) : int8u_ptr;
|
|
var
|
|
r : row_data_type_ptr;
|
|
p : int8u_ptr;
|
|
|
|
x2 : int;
|
|
|
|
begin
|
|
r :=row_data_type_ptr(ptrcomp(m_buff ) + y * sizeof(row_data_type ) );
|
|
x2:=x + len - 1;
|
|
|
|
if r.ptr <> NIL then
|
|
begin
|
|
if x < r.x1 then
|
|
r.x1:=x;
|
|
|
|
if x2 > r.x2 then
|
|
r.x2:=x2;
|
|
|
|
end
|
|
else
|
|
begin
|
|
agg_getmem(pointer(p ) ,m_byte_width );
|
|
|
|
r.ptr:=p;
|
|
r.x1 :=x;
|
|
r.x2 :=x2;
|
|
|
|
FillChar(p^ ,m_byte_width ,0 );
|
|
|
|
end;
|
|
|
|
result:=r.ptr;
|
|
|
|
end;
|
|
|
|
{ ROW }
|
|
function rendering_buffer_dynarow.row(y : unsigned ) : int8u_ptr;
|
|
begin
|
|
result:=row_xy(0 ,y ,m_width );
|
|
|
|
end;
|
|
|
|
END.
|
|
|