The Allegro Wiki is migrating to github at https://github.com/liballeg/allegro_wiki/wiki

Difference between revisions of "Vector graphic objects"

From Allegro Wiki
Jump to: navigation, search
m (type definition of AREA struct)
m
Line 73: Line 73:
 
====filltype====
 
====filltype====
  
   
+
= Rendering =
 +
 
 +
There are two main methods. Your choice depends on what the output is good at, triangles and lines; or hlines.
 +
 
 +
== Primitive rendering ==
 +
This is the normal method when using OpenGL
 +
The AREAs in a SHAPE are first decomposed into triangles and drawn, then the LINEs are drawn on at the right thickness, after being decomposed into straight line segments.
 +
 
 +
== Scanline rendering ==
 +
This is the normal method when drawing in software to a bitmap in memory.  It is more complicated, but performs better and gives almost free anti-aliasing on the left and right edges of everything.
 +
The algorithm depends on building for each scanline an ordered-from-left-to-right list of transitions from one area (or line, or the background). The final pass of rendering the SHAPE can then draw all the scanlines using optimal hline() style functions. 
  
 
[[Category:Vector graphics]]
 
[[Category:Vector graphics]]

Revision as of 01:51, May 22, 2009

Vector Graphic Objects

A VectorGraphics Subject These are the datatypes used in the prototype Vector Render API.

fig 1

Vector shapes are represented in memory by a series of vertices, connected by lines. LINE fragments are joined into PATHs. Where lines intersect, a new PATH is started. Filled AREAs are defined by a list of PATHs. They are defined in order (clockwise).

A small example of a 2d vector object engine in C

type definition of SHAPE struct

<highlightSyntax language="cpp">typedef struct SHAPE {

  V2D_f * verts;    /* list of vertices, including invisible control points */
  LINE * lines;     /* each line segment has 4 control points, 2 are unused for
                       straight segments */
  PATH * paths;     /* each path is a list of line segments */
  AREA * areas;     /* areas are bounded by list of paths (indexed from paths list) */   

} SHAPE;

</highlightSyntax>


type definition of LINE struct

<highlightSyntax language="cpp">typedef struct LINE {

  int p1,p2;            /* start and end points (index to vertex list) */
  int p3,p4;            /* bezier control points */
  float thickness;      
  int color;

} LINE;

</highlightSyntax>


type definition of PATH struct

<highlightSyntax language="cpp">typedef struct PATH {

  int p1,p2;            /* start and end verts */
  int n_seg;            /* number of segments in line */
  int segs[];           /* list of indices to shape->lines */ 

} PATH;

</highlightSyntax>


type definition of AREA struct

<highlightSyntax language="cpp">typedef struct AREA {

  int n_paths;           /* number of segments in line */
  int paths[];           /* list of indices to shape->paths, with direction bit */ 


  FILLTYPE_ENUM filltype;   /* enum FILLTYPE_NONE, FILLTYPE_SOLID, FILLTYPE_LINEARGRADIENT,
                               FILLTYPE_RADIALGRADIENT, FILLTYPE_TEXTURED */ 
  GRADIENT * gradient;   /* specifies gradient table when FILLTYPE_LINEARGRADIENT or FILLTYPE_RADIALGRADIENT
                            are used */
  AL_BITMAP * bmp;       /* specifies bitmap to use as texture when FILLTYPE_TEXTURED is used*/
  // int gl_tex;         /* only used in A4 as above*/   
  float fill_ox,fill_oy;  /* origin of fill co-ords */     
  float fill_ux,fill_uy;  /* u axis, relative to ox,oy */   
  float fill_vx,fill_vy;  /* v axis */  

} AREA;

</highlightSyntax>

filltype

Rendering

There are two main methods. Your choice depends on what the output is good at, triangles and lines; or hlines.

Primitive rendering

This is the normal method when using OpenGL The AREAs in a SHAPE are first decomposed into triangles and drawn, then the LINEs are drawn on at the right thickness, after being decomposed into straight line segments.

Scanline rendering

This is the normal method when drawing in software to a bitmap in memory. It is more complicated, but performs better and gives almost free anti-aliasing on the left and right edges of everything. The algorithm depends on building for each scanline an ordered-from-left-to-right list of transitions from one area (or line, or the background). The final pass of rendering the SHAPE can then draw all the scanlines using optimal hline() style functions.