nuttx/nuttx-mirror
1
2
Fork 0
mirror of https://github.com/apache/nuttx.git synced 2025-01-13 08:38:38 +08:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add support for trapezoidal fills

Browse source 
git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@1323 42af7a65-404d-4744-a932-0658087f49c3
This commit is contained in:
patacongo 2008-11-28 13:20:36 +00:00
parent 7ae6a40baa
commit 5638ac274f
10 changed files with 464 additions and 62 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
graphics/nxbe/Make.defs
View file

@ -37,5 +37,5 @@ NXBE_ASRCS =
NXBE_CSRCS = nxbe_fbconfigure.c nxbe_colormap.c nxbe_clipper.c \
nxbe_closewindow.c \
nxbe_setposition.c nxbe_setsize.c nxbe_raise.c nxbe_lower.c \
nxbe_fill.c nxbe_move.c nxbe_bitmap.c \
nxbe_fill.c nxbe_filltrapezoid.c nxbe_move.c nxbe_bitmap.c \
nxbe_redraw.c nxbe_redrawbelow.c

11
graphics/nxbe/nxbe.h
View file

@ -55,13 +55,6 @@
# define CONFIG_NX_NPLANES 1 /* Max number of color planes supported */
#endif
/* Mnemonics for indices */
#define NX_TOP_NDX (0)
#define NX_LEFT_NDX (1)
#define NX_RIGHT_NDX (2)
#define NX_BOTTOM_NDX (3)
/* These are the values for the clipping order provided to nx_clipper */
#define NX_CLIPORDER_TLRB (0) /* Top-left-right-bottom */
@ -87,6 +80,10 @@ struct nxbe_plane_s
void (*fillrectangle)(FAR struct fb_planeinfo_s *pinfo,
FAR const struct nxgl_rect_s *rect,
nxgl_mxpixel_t color);
void (*filltrapezoid)(FAR struct fb_planeinfo_s *pinfo,
FAR const struct nxgl_trapezoid_s *trap,
FAR const struct nxgl_rect_s *bounds,
nxgl_mxpixel_t color);
void (*moverectangle)(FAR struct fb_planeinfo_s *pinfo,
FAR const struct nxgl_rect_s *rect,
FAR struct nxgl_point_s *offset);

7
graphics/nxbe/nxbe_fbconfigure.c
View file

@ -128,6 +128,7 @@ int nxbe_fbconfigure(FAR struct fb_vtable_s *fb, FAR struct nxbe_state_s *be)
if (be->plane[i].pinfo.bpp == 1)
{
be->plane[i].fillrectangle = nxgl_fillrectangle_1bpp;
be->plane[i].filltrapezoid = nxgl_filltrapezoid_1bpp;
be->plane[i].moverectangle = nxgl_moverectangle_1bpp;
be->plane[i].copyrectangle = nxgl_copyrectangle_1bpp;
}
@ -137,6 +138,7 @@ int nxbe_fbconfigure(FAR struct fb_vtable_s *fb, FAR struct nxbe_state_s *be)
if (be->plane[i].pinfo.bpp == 2)
{
be->plane[i].fillrectangle = nxgl_fillrectangle_2bpp;
be->plane[i].filltrapezoid = nxgl_filltrapezoid_2bpp;
be->plane[i].moverectangle = nxgl_moverectangle_2bpp;
be->plane[i].copyrectangle = nxgl_copyrectangle_2bpp;
}
@ -146,6 +148,7 @@ int nxbe_fbconfigure(FAR struct fb_vtable_s *fb, FAR struct nxbe_state_s *be)
if (be->plane[i].pinfo.bpp == 4)
{
be->plane[i].fillrectangle = nxgl_fillrectangle_4bpp;
be->plane[i].filltrapezoid = nxgl_filltrapezoid_4bpp;
be->plane[i].moverectangle = nxgl_moverectangle_4bpp;
be->plane[i].copyrectangle = nxgl_copyrectangle_4bpp;
}
@ -155,6 +158,7 @@ int nxbe_fbconfigure(FAR struct fb_vtable_s *fb, FAR struct nxbe_state_s *be)
if (be->plane[i].pinfo.bpp == 8)
{
be->plane[i].fillrectangle = nxgl_fillrectangle_8bpp;
be->plane[i].filltrapezoid = nxgl_filltrapezoid_8bpp;
be->plane[i].moverectangle = nxgl_moverectangle_8bpp;
be->plane[i].copyrectangle = nxgl_copyrectangle_8bpp;
}
@ -164,6 +168,7 @@ int nxbe_fbconfigure(FAR struct fb_vtable_s *fb, FAR struct nxbe_state_s *be)
if (be->plane[i].pinfo.bpp == 16)
{
be->plane[i].fillrectangle = nxgl_fillrectangle_16bpp;
be->plane[i].filltrapezoid = nxgl_filltrapezoid_16bpp;
be->plane[i].moverectangle = nxgl_moverectangle_16bpp;
be->plane[i].copyrectangle = nxgl_copyrectangle_16bpp;
}
@ -173,6 +178,7 @@ int nxbe_fbconfigure(FAR struct fb_vtable_s *fb, FAR struct nxbe_state_s *be)
if (be->plane[i].pinfo.bpp == 24)
{
be->plane[i].fillrectangle = nxgl_fillrectangle_24bpp;
be->plane[i].filltrapezoid = nxgl_filltrapezoid_24bpp;
be->plane[i].moverectangle = nxgl_moverectangle_24bpp;
be->plane[i].copyrectangle = nxgl_copyrectangle_24bpp;
}
@ -182,6 +188,7 @@ int nxbe_fbconfigure(FAR struct fb_vtable_s *fb, FAR struct nxbe_state_s *be)
if (be->plane[i].pinfo.bpp == 32)
{
be->plane[i].fillrectangle = nxgl_fillrectangle_32bpp;
be->plane[i].filltrapezoid = nxgl_filltrapezoid_32bpp;
be->plane[i].moverectangle = nxgl_moverectangle_32bpp;
be->plane[i].copyrectangle = nxgl_copyrectangle_32bpp;
}

14
graphics/nxbe/nxbe_fill.c
View file

@ -121,15 +121,23 @@ void nxbe_fill(FAR struct nxbe_window_s *wnd,
}
#endif
/* Offset the rectangle by the window origin to convert it into a bounding box */
/* Offset the rectangle by the window origin to convert it into a
* bounding box
*/
nxgl_rectoffset(&remaining, rect, wnd->origin.x, wnd->origin.y);
/* Clip to the limits of the window and of the background screen */
/* Clip to the bounding box to the limits of the window and of the
* background screen
*/
nxgl_rectintersect(&remaining, &remaining, &wnd->bounds);
nxgl_rectintersect(&remaining, &remaining, &wnd->be->bkgd.bounds);
/* Then clip the bounding box due to other windows above this one.
* Render the portions of the trapezoid exposed in visible regions.
*/
if (!nxgl_nullrect(&remaining))
{
#if CONFIG_NX_NPLANES > 1
@ -143,7 +151,7 @@ void nxbe_fill(FAR struct nxbe_window_s *wnd,
info.color = color[i];
nxbe_clipper(wnd->above, &remaining, NX_CLIPORDER_DEFAULT,
&info.cops, &wnd->be->plane[0]);
&info.cops, &wnd->be->plane[i]);
}
}
}

162
graphics/nxbe/nxbe_filltrapezoid.c Normal file
View file

@ -0,0 +1,162 @@
/****************************************************************************
* graphics/nxbe/nxbe_filltrapezoid.c
*
* Copyright (C) 2008 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <sys/types.h>
#include <fixedmath.h>
#include <nuttx/nxglib.h>
#include "nxbe.h"
/****************************************************************************
* Pre-Processor Definitions
****************************************************************************/
/****************************************************************************
* Private Types
****************************************************************************/
struct nxbe_filltrap_s
{
struct nxbe_clipops_s cops;
struct nxgl_trapezoid_s trap;
nxgl_mxpixel_t color;
};
/****************************************************************************
* Private Data
****************************************************************************/
/****************************************************************************
* Public Data
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: nxbe_clipfilltrapezoid
*
* Description:
* Called from nxbe_clipper() to performed the fill operation on visible portions
* of the rectangle.
*
****************************************************************************/
static void nxbe_clipfilltrapezoid(FAR struct nxbe_clipops_s *cops,
FAR struct nxbe_plane_s *plane,
FAR const struct nxgl_rect_s *rect)
{
struct nxbe_filltrap_s *fillinfo = (struct nxbe_filltrap_s *)cops;
plane->filltrapezoid(&plane->pinfo, &fillinfo->trap, rect, fillinfo->color);
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: nxbe_filltrapezoid
*
* Description:
* Fill the specified rectangle in the window with the specified color
*
* Input Parameters:
* wnd - The window structure reference
* rect - The location to be filled
* col - The color to use in the fill
*
* Return:
* None
*
****************************************************************************/
void nxbe_filltrapezoid(FAR struct nxbe_window_s *wnd,
FAR const struct nxgl_trapezoid_s *trap,
nxgl_mxpixel_t color[CONFIG_NX_NPLANES])
{
struct nxbe_filltrap_s info;
struct nxgl_rect_s bounds;
struct nxgl_rect_s remaining;
int i;
#ifdef CONFIG_DEBUG
if (!wnd || !trap)
{
return;
}
#endif
/* Offset the trapezoid by the window origin to position it within
* the framebuffer region
*/
nxgl_trapoffset(&info.trap, trap, wnd->origin.x, wnd->origin.y);
/* Now create a bounding box that contains the trapezoid */
bounds.pt1.x = b16toi(ngl_min(info.trap.top.x1, info.trap.bot.x1));
bounds.pt1.y = b16toi(info.trap.top.y);
bounds.pt2.x = b16toi(ngl_max(info.trap.top.x2, info.trap.bot.x2));
bounds.pt2.y = b16toi(info.trap.bot.y);
/* Clip to the limits of the window and of the background screen */
nxgl_rectintersect(&remaining, &bounds, &wnd->bounds);
nxgl_rectintersect(&remaining, &remaining, &wnd->be->bkgd.bounds);
if (!nxgl_nullrect(&remaining))
{
#if CONFIG_NX_NPLANES > 1
for (i = 0; i < wnd->be->vinfo.nplanes; i++)
#else
i = 0;
#endif
{
info.cops.visible = nxbe_clipfilltrapezoid;
info.cops.obscured = nxbe_clipnull;
info.color = color[i];
nxbe_clipper(wnd->above, &remaining, NX_CLIPORDER_DEFAULT,
&info.cops, &wnd->be->plane[i]);
}
}
}

6
graphics/nxglib/Make.defs
View file

@ -51,10 +51,12 @@ RMOVE2_CSRCS = nxglib_moverectangle_8bpp.c nxglib_moverectangle_16bpp.c \
# nxglib_copyrectangle_4bpp.c
RCOPY2_CSRCS = nxglib_copyrectangle_8bpp.c nxglib_copyrectangle_16bpp.c \
nxglib_copyrectangle_24bpp.c nxglib_copyrectangle_32bpp.c
RECT_CRCS = nxglib_rectcopy.c nxglib_rectoffset.c nxglib_vectoradd.c \
RECT_CSRCS = nxglib_rectcopy.c nxglib_rectoffset.c nxglib_vectoradd.c \
nxglib_rectintersect.c nxglib_nonintersecting.c \
nxglib_rectoverlap.c nxglib_nullrect.c
TRAP_CSRCS = nxglib_runoffset.c nxglib_trapoffset.c
NXGLIB_CSRCS = nxglib_rgb2yuv.c nxglib_yuv2rgb.c \
$(RFILL1_CSRCS) $(RFILL2_CSRCS) $(TFILL1_CSRCS) $(TFILL2_CSRCS) \
$(RMOVE1_CSRCS) $(RMOVE2_CSRCS) $(RCOPY1_CSRCS) $(RCOPY2_CSRCS)
$(RMOVE1_CSRCS) $(RMOVE2_CSRCS) $(RCOPY1_CSRCS) $(RCOPY2_CSRCS) \
$(RECT_CSRCS) $(TRAP_CSRCS)

62
graphics/nxglib/nxglib_filltrapezoid.c
View file

@ -79,20 +79,24 @@
*
* Descripton:
* Fill a trapezoidal region in the framebuffer memory with a fixed color.
* This is useful for drawing complex shape -- (most) complex shapes can be
* broken into a set of trapezoids.
* Clip the trapezoid to lie within a boundng box. This is useful for
* drawing complex shapes that can be broken into a set of trapezoids.
*
****************************************************************************/
void NXGL_FUNCNAME(nxglib_filltrapezoid,NXGLIB_SUFFIX)
(FAR struct fb_videoinfo_s *vinfo, FAR struct fb_planeinfo_s *pinfo,
FAR const struct nxgl_trapezoid_s *trap, nxgl_mxpixel_t color)
void NXGL_FUNCNAME(nxgl_filltrapezoid,NXGLIB_SUFFIX)(
FAR struct fb_planeinfo_s *pinfo,
FAR const struct nxgl_trapezoid_s *trap,
FAR const struct nxgl_rect_s *bounds,
nxgl_mxpixel_t color)
{
unsigned int stride;
ubyte *line;
int nrows;
b16_t x1;
b16_t x2;
nxgl_coord_t y1;
nxgl_coord_t y2;
b16_t dx1dy;
b16_t dx2dy;
@ -102,18 +106,38 @@ void NXGL_FUNCNAME(nxglib_filltrapezoid,NXGLIB_SUFFIX)
/* Get the top run position and the number of rows to draw */
x1 = trap->top.x1;
x2 = trap->top.x2;
nrows = trap->bot.y - trap->top.y + 1;
/* Get the address of the first byte on the first line */
line = pinfo->fbmem + trap->top.y * stride ;
x1 = trap->top.x1;
x2 = trap->top.x2;
/* Calculate the slope of the left and right side of the trapezoid */
dx1dy = b16divi((trap->bot.x1 - x1), nrows);
dx2dy = b16divi((trap->bot.x2 - x2), nrows);
dx1dy = b16divi((trap->bot.x1 - x1), nrows);
dx2dy = b16divi((trap->bot.x2 - x2), nrows);
/* Perform vertical clipping */
y1 = trap->top.y;
if (y1 < bounds->pt1.y)
{
int dy = bounds->pt1.y - y1;
x1 += dy * dx1dy;
x2 += dy * dx2dy;
y1 = bounds->pt1.y;
}
y2 = trap->bot.y;
if (y2 > bounds->pt2.y)
{
y2 = bounds->pt2.y;
}
/* Then calculate the number of rows to render */
nrows = y2 - y1 + 1;
/* Get the address of the first byte on the first line */
line = pinfo->fbmem + y1 * stride ;
/* Then fill the trapezoid line-by-line */
@ -140,17 +164,17 @@ void NXGL_FUNCNAME(nxglib_filltrapezoid,NXGLIB_SUFFIX)
* always draw at least one pixel.
*/
if (x1 > x2 || ix2 < 0 || ix1 > vinfo->yres)
if (x1 > x2 || ix2 < bounds->pt1.x || ix1 > bounds->pt2.x)
{
/* Get a clipped copies of the startingand ending X positions. This
/* Get a clipped copies of the starting and ending X positions. This
* clipped truncates "down" and gives the quantized pixel holding the
* fractional X position
*/
ix1 = ngl_clipl(ix1, 0);
ix2 = ngl_clipr(ix2, vinfo->yres);
ix1 = ngl_clipl(ix1, bounds->pt1.x);
ix2 = ngl_clipr(ix2, bounds->pt2.x);
/* Then draw the run from (line + clipx1) to (line + clipx2) */
/* Then draw the run from (line + ix1) to (line + ix2) */
NXGL_MEMSET(line + NXGL_SCALEX(ix1), (NXGL_PIXEL_T)color, ix2 - ix1 + 1);
}

86
graphics/nxglib/nxglib_runoffset.c Normal file
View file

@ -0,0 +1,86 @@
/****************************************************************************
* graphics/nxglib/nxsglib_runoffset.c
*
* Copyright (C) 2008 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <sys/types.h>
#include <fixedmath.h>
#include <nuttx/nxglib.h>
/****************************************************************************
* Pre-Processor Definitions
****************************************************************************/
/****************************************************************************
* Private Types
****************************************************************************/
/****************************************************************************
* Private Data
****************************************************************************/
/****************************************************************************
* Public Data
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: nxgl_runoffset
*
* Description:
* Offset the run position by the specified dx, dy values.
*
****************************************************************************/
void nxgl_runoffset(FAR struct nxgl_run_s *dest,
FAR const struct nxgl_run_s *src,
nxgl_coord_t dx, nxgl_coord_t dy)
{
b16_t b16dx = itob16(dx);
dest->x1 += b16dx;
dest->x2 += b16dx;
dest->y += dy;
}

83
graphics/nxglib/nxglib_trapoffset.c Normal file
View file

@ -0,0 +1,83 @@
/****************************************************************************
* graphics/nxglib/nxsglib_trapoffset.c
*
* Copyright (C) 2008 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <sys/types.h>
#include <nuttx/nxglib.h>
/****************************************************************************
* Pre-Processor Definitions
****************************************************************************/
/****************************************************************************
* Private Types
****************************************************************************/
/****************************************************************************
* Private Data
****************************************************************************/
/****************************************************************************
* Public Data
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: nxgl_trapoffset
*
* Description:
* Offset the trapezoid position by the specified dx, dy values.
*
****************************************************************************/
void nxgl_trapoffset(FAR struct nxgl_trapezoid_s *dest,
FAR const struct nxgl_trapezoid_s *src,
nxgl_coord_t dx, nxgl_coord_t dy)
{
nxgl_runoffset(&dest->top, &src->top, dx, dy);
nxgl_runoffset(&dest->bot, &src->bot, dx, dy);
}

93
include/nuttx/nxglib.h
View file

@ -48,6 +48,15 @@
* Pre-processor definitions
****************************************************************************/
/* Mnemonics for indices */
#define NX_TOP_NDX (0)
#define NX_LEFT_NDX (1)
#define NX_RIGHT_NDX (2)
#define NX_BOTTOM_NDX (3)
/* Handy macros */
#define ngl_min(a,b) ((a) < (b) ? (a) : (b))
#define ngl_max(a,b) ((a) > (b) ? (a) : (b))
#define ngl_swap(a,b,t) do { t = a; a = b; b = t; } while (0);
@ -196,39 +205,39 @@ EXTERN void nxgl_fillrectangle_32bpp(FAR struct fb_planeinfo_s *pinfo,
*
* Descripton:
* Fill a trapezoidal region in the framebuffer memory with a fixed color.
* This is useful for drawing complex shape -- (most) complex shapes can be
* broken into a set of trapezoids.
* Clip the trapezoid to lie within a boundng box. This is useful for
* drawing complex shapes that can be broken into a set of trapezoids.
*
****************************************************************************/
EXTERN void nxglib_filltrapezoid_1bpp(FAR struct fb_videoinfo_s *vinfo,
FAR struct fb_planeinfo_s *pinfo,
FAR const struct nxgl_trapezoid_s *trap,
nxgl_mxpixel_t color);
EXTERN void nxglib_filltrapezoid_2bpp(FAR struct fb_videoinfo_s *vinfo,
FAR struct fb_planeinfo_s *pinfo,
FAR const struct nxgl_trapezoid_s *trap,
nxgl_mxpixel_t color);
EXTERN void nxglib_filltrapezoid_4bpp(FAR struct fb_videoinfo_s *vinfo,
FAR struct fb_planeinfo_s *pinfo,
FAR const struct nxgl_trapezoid_s *trap,
nxgl_mxpixel_t color);
EXTERN void nxglib_filltrapezoid_8bpp(FAR struct fb_videoinfo_s *vinfo,
FAR struct fb_planeinfo_s *pinfo,
FAR const struct nxgl_trapezoid_s *trap,
nxgl_mxpixel_t color);
EXTERN void nxglib_filltrapezoid_16bpp(FAR struct fb_videoinfo_s *vinfo,
FAR struct fb_planeinfo_s *pinfo,
FAR const struct nxgl_trapezoid_s *trap,
nxgl_mxpixel_t color);
EXTERN void nxglib_filltrapezoid_24bpp(FAR struct fb_videoinfo_s *vinfo,
FAR struct fb_planeinfo_s *pinfo,
FAR const struct nxgl_trapezoid_s *trap,
nxgl_mxpixel_t color);
EXTERN void nxglib_filltrapezoid_32bpp(FAR struct fb_videoinfo_s *vinfo,
FAR struct fb_planeinfo_s *pinfo,
FAR const struct nxgl_trapezoid_s *trap,
nxgl_mxpixel_t color);
EXTERN void nxgl_filltrapezoid_1bpp(FAR struct fb_planeinfo_s *pinfo,
FAR const struct nxgl_trapezoid_s *trap,
FAR const struct nxgl_rect_s *bounds,
nxgl_mxpixel_t color);
EXTERN void nxgl_filltrapezoid_2bpp(FAR struct fb_planeinfo_s *pinfo,
FAR const struct nxgl_trapezoid_s *trap,
FAR const struct nxgl_rect_s *bounds,
nxgl_mxpixel_t color);
EXTERN void nxgl_filltrapezoid_4bpp(FAR struct fb_planeinfo_s *pinfo,
FAR const struct nxgl_trapezoid_s *trap,
FAR const struct nxgl_rect_s *bounds,
nxgl_mxpixel_t color);
EXTERN void nxgl_filltrapezoid_8bpp(FAR struct fb_planeinfo_s *pinfo,
FAR const struct nxgl_trapezoid_s *trap,
FAR const struct nxgl_rect_s *bounds,
nxgl_mxpixel_t color);
EXTERN void nxgl_filltrapezoid_16bpp(FAR struct fb_planeinfo_s *pinfo,
FAR const struct nxgl_trapezoid_s *trap,
FAR const struct nxgl_rect_s *bounds,
nxgl_mxpixel_t color);
EXTERN void nxgl_filltrapezoid_24bpp(FAR struct fb_planeinfo_s *pinfo,
FAR const struct nxgl_trapezoid_s *trap,
FAR const struct nxgl_rect_s *bounds,
nxgl_mxpixel_t color);
EXTERN void nxgl_filltrapezoid_32bpp(FAR struct fb_planeinfo_s *pinfo,
FAR const struct nxgl_trapezoid_s *trap,
FAR const struct nxgl_rect_s *bounds,
nxgl_mxpixel_t color);
/****************************************************************************
* Name: nxgl_moverectangle_*bpp
@ -389,6 +398,30 @@ EXTERN boolean nxgl_rectoverlap(FAR struct nxgl_rect_s *rect1,
EXTERN boolean nxgl_nullrect(FAR const struct nxgl_rect_s *rect);
/****************************************************************************
* Name: nxgl_runoffset
*
* Description:
* Offset the run position by the specified dx, dy values.
*
****************************************************************************/
EXTERN void nxgl_runoffset(FAR struct nxgl_run_s *dest,
FAR const struct nxgl_run_s *src,
nxgl_coord_t dx, nxgl_coord_t dy);
/****************************************************************************
* Name: nxgl_trapoffset
*
* Description:
* Offset the trapezoid position by the specified dx, dy values.
*
****************************************************************************/
EXTERN void nxgl_trapoffset(FAR struct nxgl_trapezoid_s *dest,
FAR const struct nxgl_trapezoid_s *src,
nxgl_coord_t dx, nxgl_coord_t dy);
#undef EXTERN
#if defined(__cplusplus)
}