/** * @file * @brief VGA screen layout * @author Miroslav Nemecek * @see ScreenGroup */ #ifndef _VGA_SCREEN_H #define _VGA_SCREEN_H /** * @addtogroup ScreenGroup * @brief Defining the layout of the display * @details When displaying screen image, the default pointer is pScreen for the library. It points to the sScreen structure that * describes the contents of the display. The Raspberry Pico has a limited RAM size and cannot accommodate a high resolution image. * Therefore, the image must be composed of smaller segments to minimize the memory-intensive parts. * @note The following descriptions of the image format only apply to the base image layer 0. It is the only one that can contain * segments in different formats. Overlay layers 1 through 3 are independent of the base layer format, sharing only the total * screen area with the base layer but using their own image format. * @{ */ /// Video segment (on change update SSEGM_* in define.h) typedef struct { u16 width; ///< SSEGM_WIDTH width of this video segment in pixels (must be multiple of 4, 0=inactive segment) u16 wb; ///< SSEGM_WB pitch - number of bytes between lines s16 offx; ///< SSEGM_OFFX display offset at X direction (must be multiple of 4) s16 offy; ///< SSEGM_OFFY display offset at Y direction u16 wrapx; ///< SSEGM_WRAPX wrap width in X direction (number of pixels, must be multiply of 4 and > 0) ///< text modes: wrapx must be multiply of 8 u16 wrapy; ///< SSEGM_WRAPY wrap width in Y direction (number of lines, cannot be 0) const void* data; ///< SSEGM_DATA pointer to video buffer with image data u8 form; ///< SSEGM_FORM graphics format GF_* bool dbly; ///< SSEGM_DBLY double Y (2 scanlines per 1 image line) u16 par3; ///< SSEGM_PAR3 parameter 3 u32 par; ///< SSEGM_PAR parameter 1 u32 par2; ///< SSEGM_PAR2 parameter 2 } sSegm; /// Video strip (on change update SSTRIP_* in define.h) typedef struct { u16 height; ///< SSTRIP_HEIGHT height of this strip in number of scanlines u16 num; ///< SSTRIP_NUM number of video segments sSegm seg[SEGMAX]; ///< SSTRIP_SEG list of video segments } sStrip; /// Video screen (on change update SSCREEN_* in define.h) typedef struct { u16 num; ///< SSCREEN_NUM number of video strips u16 backup; ///< SSCREEN_BACKUP backup number of video strips during display OFF sStrip strip[STRIPMAX]; ///< SSCREEN_STRIP list of video strips } sScreen; extern sScreen Screen; ///< Default video screen extern sScreen* pScreen; ///< Pointer to current video screen /** * @brief Clear screen (set 0 strips, does not modify sprites) * @details Resets the display handler structures, clearing the display. At a minimum, this function should be called * before initializing the videmode. It initializes the display content descriptor structure pointed to by pScreen * (usually the default structure Screen of the library) by setting the number of segments to 0. The screen will be black * until we fill it with content descriptors * @param s Pointer to screen to clear */ void ScreenClear(sScreen* s); /** * @brief Add empty strip to the screen * @details This function adds a new horizontal bar of the specified number of video lines to the end of the screen definition. * The maximum number of stripes is specified by the STRIPMAX constant (8 by default) in the vga_config.h file. Without added * segments, the bar is empty (black). * @param s The screen to add strip * @param height The number of video lines in the strip * @returns Pointer to the new strip */ sStrip* ScreenAddStrip(sScreen* s, int height); /** * @brief Add empty segment to video strip; returns pointer to the segment and initialises it to defaults * @details This function adds a new image segment of the specified width to the end of the strip. The segment will contain * one image format. For the vast majority of formats, the width must be a multiple of 4 (a multiple of 4 pixels). * @param strip The strip to add the segment to * @param width The width of the segment in pixels (for many formats must be a multiple of 4) * @returns Pointer to new segment initialized to defaults */ sSegm* ScreenAddSegm(sStrip* strip, int width); /** * @brief Set video segment to simple color format GF_COLOR * @param segm Segment to configure * @param col1 Color pattern 4-pixels even line (use macro MULTICOL) * @param col2 Color pattern 4-pixels odd line (use macro MULTICOL) */ void ScreenSegmColor(sSegm* segm, u32 col1, u32 col2); /** * @brief Set video segment to gradient with 1 line * @details The segment will be filled with a color gradient (GF_GRAD1). The gradient is 1 line of 8-bit pixels. * @note The gradient can be scrolled horizontally with the offx parameter. * @param segm Segment to configure * @param data Pointer to data buffer with gradient * @param wb Length of buffer */ void ScreenSegmGrad1(sSegm* segm, const void* data, int wb); /** * @brief Set video segment to gradient with 2 lines * @details Gradient with 2 lines, even and odd (GF_GRAD2). * @note To scroll gradient, set virtual dimension wrapx, then shift offx * @param segm Segment to configure * @param data Pointer to data buffer with gradient * @param wb Length of buffer */ void ScreenSegmGrad2(sSegm* segm, const void* data, int wb); /** * @brief Set video segment to native 8-bit graphics (R3G3B2) * @details 8-bit graphics 256 colors (GF_GRAPH8). Each pixel is 1 byte. This mode is one of the fastest, the data is simply sent * from the frame buffer to the PIO controller using a DMA transfer. However, it is also one of the most memory intensive. * Really, the memory can hold a maximum image resolution of 512x400 pixels (EGA video mode). * @note To scroll image, set virtual dimension wrapx and wrapy, then shift offx and offy. * @param segm Segment to configure * @param data Pointer to data buffer * @param wb Line length in bytes */ void ScreenSegmGraph8(sSegm* segm, const void* data, int wb); /** * @brief Generate 16-color palette translation table * @details Generates a palette translation table for the ScreenSegmGraph4() function. The translation table is 256 entries of * 16 bits, so it takes 512 bytes in memory. The table is used during display for internal purposes, must be aligned to 4 bytes, * and must be available for the entire time the segment is displayed. The input to the function is the palette table, which is * 16 color entries of 1 byte. * @param trans Pointer to destination palette translation table (u16 trans[256]) * @param pal Pointer to source palette of 16 colors (u8 pal[16]) */ void GenPal16Trans(u16* trans, const u8* pal); /** * @brief Set video segment to 4-bit palette graphics * @details 4-bit palette graphics 16 colors (GF_GRAPH4). There are 2 pixels in 1 byte (the first pixel is in the higher 4 bits * of the byte). The function requires a palette translation table. * @note To scroll image, set virtual dimension wrapx and wrapy, then shift offx and offy. * @param segm Segment to configure * @param data Pointer to data buffer * @param trans Pointer to 16-color palette translation table (generated with GenPal16Trans function) * @param wb The line length in bytes */ void ScreenSegmGraph4(sSegm* segm, const void* data, const void* trans, int wb); /** * @brief Generate palette 4 translation table for function * @details Generate a palette translation table for the ScreenSegmGraph2() function. The translation table is 256 entries with * a size of 32 bits, so it takes 1024 bytes in memory. The table is used during display for internal purposes, must be aligned * to 4 bytes, and must be available for the entire time the segment is displayed. The input to the function is the palette table, * which is 4 color entries of 1 byte. * @param trans Pointer to destination palette translation table (u32 trans[256]) * @param pal Pointer to source palette of 4 colors (u8 pal[4]) */ void GenPal4Trans(u32* trans, const u8* pal); /** * @brief Set video segment to 2-bit palette graphics * @details * @note To scroll image, set virtual dimension wrapx and wrapy, then shift offx and offy. * @param segm Segment to configure * @param data Pointer to data buffer * @param trans Pointer to 4-color palette translation table (generated with GenPal4Trans function) * @param wb The line length in bytes */ void ScreenSegmGraph2(sSegm* segm, const void* data, const void* trans, int wb); /** * @brief Set video segment to 1-bit palette graphics * @details 1-bit mono graphics 2 colors (GF_GRAPH1). There are 8 pixels in 1 byte (first pixel in the highest bit). The function requires background color * and foreground color. * @note To scroll image, set virtual dimension wrapx and wrapy, then shift offx and offy. * @param segm Segment to configure * @param data Pointer to data buffer * @param bg Background color * @param fg Foreground color * @param wb The line length in bytes */ void ScreenSegmGraph1(sSegm* segm, const void* data, u8 bg, u8 fg, int wb); /** * @brief Set video segment to 8-pixel mono text * @details Mono text (GF_MTEXT). For mono text, the foreground and background color is valid for the entire segment. * In the display memory there are single characters, 1 byte is one character. * @param segm Segment to configure * @param data Pointer to text buffer * @param font Pointer to 1-bit font of 256 characters of width 8 (total width of image 2048 pixels) * @param fontheight Font height * @param bg Background color * @param fg Foregound color * @param wb The line length in bytes */ void ScreenSegmMText(sSegm* segm, const void* data, const void* font, u16 fontheight, u8 bg, u8 fg, int wb); /** * @brief Set video segment to 8-pixel attribute text * @details Attribute text (GF_ATEXT). In attribute text, each character is a pair of bytes. The first byte is the ASCII * value of the character, the second byte is the color attribute. The higher 4 bits of the attribute represent the background * color, the lower 4 bits of the attribute represent the foreground color. The colors are translated from a palette table of * 16 colors. * @param segm Segment to configure * @param data Pointer to text buffer (character + 2x4 bit attributes) * @param font Pointer to 1-bit font of 256 characters of width 8 (total width of image 2048 pixels) * @param fontheight Font height * @param pal Pointer to palette of 16 colors * @param wb The line length in bytes */ void ScreenSegmAText(sSegm* segm, const void* data, const void* font, u16 fontheight, const void* pal, int wb); /** * @brief Set video segment to 8-pixel foreground color text * @details Text with foreground color (GF_FTEXT). In text with foreground, each character is represented by a pair of bytes. * The first byte is ASCII value of the character, the second byte is foreground color. The background color is common, specified * by the 'bg' parameter. * @note Library's default fonts include an inverted lower half of the font in the upper half (bit 7 set) - this can provide a * character with an optional background color. * @param segm Segment to configure * @param data Pointer to text buffer (character + foreground color) * @param font Pointer to 1-bit font of 256 characters of width 8 (total width of image 2048 pixels) * @param fontheight Font height * @param bg Background color * @param wb The line length in bytes */ void ScreenSegmFText(sSegm* segm, const void* data, const void* font, u16 fontheight, u8 bg, int wb); /** * @brief Set video segment to 8-pixel color text * @details Text with color (GF_CTEXT). For text with color, each character occupies 3 bytes. The first byte is the ASCII value * of the character, the second byte is the background color, and the third byte is the foreground color. * @param segm Segment to configure * @param data Pointer to text buffer (character + background color + foreground color) * @param font Pointer to 1-bit font of 256 characters of width 8 (total width of image 2048 pixels) * @param fontheight Font height * @param wb The line length in bytes */ void ScreenSegmCText(sSegm* segm, const void* data, const void* font, u16 fontheight, int wb); /** * @brief Set video segment to 8-pixel gradient color text * @details Text with gradient (GF_GTEXT). In this mode, each character is represented by 1 byte in memory and the background * color is specified by the 'bg' parameter, similar to the mono text. Instead of the foreground color, there is a parameter * 'grad', which is a pointer to a color gradient of length equal to the graphic length of the line of text (e.g. for 40 * characters, the gradient is 320 bytes). The foreground color for each pixel of the character is taken from the gradient table. * @param segm Segment to configure * @param data Pointer to text buffer (character + foreground color) * @param font Pointer to 1-bit font of 256 characters of width 8 (total width of image 2048 pixels) * @param fontheight Font height * @param bg Background color * @param grad Pointer to array of gradient colors * @param wb The line length in bytes */ void ScreenSegmGText(sSegm* segm, const void* data, const void* font, u8 fontheight, u8 bg, const void* grad, int wb); /** * @brief Set video segment to 8-pixel double gradient color text * @details Double gradient text (GF_DTEXT). The function is identical to the previous function, except that each character pixel * is generated as 2 image pixels. Thus, the character has twice the width. It is the only text mode that allows displaying * characters with double width. The color gradient works similarly here, but 1 byte of the gradient represents 1 pixel of the * character (as in the previous function), not 1 pixel displayed. Thus a line of 40 characters again requires a gradient of * 320 bytes. * @param segm Segment to configure * @param data Pointer to text buffer (character + foreground color) * @param font Pointer to 1-bit font of 256 characters of width 8 (total width of image 2048 pixels) * @param fontheight Font height * @param bg Background color * @param grad Pointer to array of gradient colors * @param wb The line length in bytes */ void ScreenSegmDText(sSegm* segm, const void* data, const void* font, u8 fontheight, u8 bg, const void* grad, int wb); /** * @brief Set video segment to tiles * @details Tiles in column (GF_TILE). Tiles are image segments of the specified size (tile width and height are 'w' and 'h'). * The tile patterns are arranged in a single image. In this case, into a column of width 1 tile. The 'tiles' parameter is a * pointer to the image of the tile column. The 'data' parameter is a pointer to an array of bytes, where each byte represents * number of displayed tile. Thus, there can be a maximum of 256 tiles. The 'wb' parameter refers to the length of the row of * the index array (not the length of the tile image). The width of a tile must be a multiple of 4, at least 8. Tiles allow * efficient display of image information by allowing the image to repeat. Thus, high image resolution can be achieved with * low memory requirements. * @param segm Segment to configure * @param data Pointer to tile map buffer (with tile indices) * @param tiles Pointer to 1 column of tiles, 1 pixel = 8 bits * @param w tile width (must be multiple of 4) * @param h tile height * @param wb Number of bytes between tile map rows */ void ScreenSegmTile(sSegm* segm, const void* data, const void* tiles, int w, int h, int wb); /** * @brief Set video segment to alternate tiles * @details Tiles in a row (GF_TILE2). This function is an alternative to ScreenSegmTile(), except that the tile patterns * are arranged in a single row in the image. This may be more convenient when creating a tile image, however, you must * additionally specify the parameter 'tilewb' representing the line length of the tile image. * Usually tilewb = number of tiles * tile width. * @param segm Segment to configure * @param data Pointer to tile map buffer (with tile indices) * @param tiles Pointer to 1 row of tiles, 1 pixel = 8 bits * @param w tile width (must be multiple of 4) * @param h tile height * @param tilewb Tile width bytes (usually tile width * number of tiles) * @param wb Number of bytes between tile map rows */ void ScreenSegmTile2(sSegm* segm, const void* data, const void* tiles, int w, int h, int tilewb, int wb); /** * @brief Set video segment to level graph GF_LEVEL * @details Level display segment (GF_LEVEL). This segment is used to display graphs. The input is an array of 'data' bytes of * length corresponding to the width of the array in pixels. The byte value represents the height of the graph at the given X * coordinate. The display will show a foreground or background color depending on whether the displayed pixel lies above or * below the value from the data array. The 'zero' parameter specifies the height of the reference zero. Zero does not imply * negative numbers in the data, the numbers are still given as unsigned (with zero at the bottom). Starting from reference zero, * the background and foreground colour is swapped. This results in the graph looking visually symmetrical around the reference * zero. You can see the appearance of the segment in the Oscilloscope sample program (lower curve). * @param segm Segment to configure * @param data Pointer to buffer with line samples 0..255 * @param zero Y zero level * @param bg Background color * @param fg Foregound color */ void ScreenSegmLevel(sSegm* segm, const void* data, u8 zero, u8 bg, u8 fg); /** * @brief Set video segment to leve gradient graph GF_LEVELGRAD * @details Level display segment with gradient (GF_LEVELGRAD). This segment is used to display graphs, similar to the previous * function. It differs in that the color is given as a vertical gradient with a height corresponding to the height of the segment. * If a pixel lies below the data value, the color from the first gradient is used. Otherwise, the second gradient is used. * An example use case can be seen in the Level Meter sample program, to display the spectrum. * @param segm Segment to configure * @param data Pointer to buffer with values 0..255 of 4-pixels in rows * @param sample1 Scanline sample < data * @param sample2 Scanline sample >= data */ void ScreenSegmLevelGrad(sSegm* segm, const void* data, const void* sample1, const void* sample2); /** * @brief Set video segment to oscilloscope 1-pixel graph GF_OSCIL * @details Oscilloscope waveform display segment (GF_OSCIL). The segment is similar in function to the level display segment. * It differs in that the curve is displayed as a line of 'pixh' pixel thickness. This function is already more demanding and * may not be able to service the full width of the image. * @param segm Segment to configure * @param data Pointer to buffer with line samples 0..255 * @param bg Background color * @param fg Foregound color * @param pixh Height of pixels - 1 */ void ScreenSegmOscil(sSegm* segm, const void* data, u8 bg, u8 fg, int pixh); /** * @brief Set video segment to oscilloscope line graph GF_OSCLIN * @details Oscilloscope continuous waveform segment (GF_OSCLINE). The curve is displayed as a continuous line with a thickness * of 1 pixel. This mode is already very demanding to render and is therefore accelerated by halving the horizontal resolution * (renders points 2 pixels wide). * @param segm Segment to configure * @param data Pointer to buffer with line samples 0..255 * @param bg Background color * @param fg Foregound color */ void ScreenSegmOscLine(sSegm* segm, const void* data, u8 bg, u8 fg); /** * @brief Generate palette 4-color translation table for function ScreenSegmPlane2() * @details Generate a palette translation table for the ScreenSegmPlane2() function. The translation table is 256 entries of * 32 bits, so it takes 1024 bytes in memory. The table is used during display for internal purposes, must be aligned to 4 bytes, * and must be available for the entire time the segment is displayed. The input to the function is the palette table, which is * 4 color entries of 1 byte. Although there is no program in the PicoVGA library utilities that prepares an image in 2-plane * mode, there is an internal function Plane2Conv that converts a 4-color image to 2-plane mode. Thus, the image is attached to * the program as a 4-color image, and the conversion function is used to prepare a copy in RAM. * @param trans Pointer to destination palette translation table (u32 trans[256]) * @param pal Pointer to source palette of 4 colors (u8 pal[4]) */ void GenPal4Plane(u32* trans, const u8* pal); /** * @brief Set video segment to 4-color on 2-planes graphics * @details 2-bit palette graphics 4 colors in 2 planes (GF_PLANE2). The mode is functionally similar to the 2-bit color * graphics mode, but the individual pixel bits are stored in 2 separate color planes. This mode is similar to the CGA * graphics mode of PC computers. The individual planes correspond to two separate monochrome graphics modes. Each byte * of the plane contains 8 pixels (the first pixel in the highest bit). The parameter 'plane' is the relative offset of * the second plane from the first plane, given by the parameter 'data'. The function requires a palette translation table, * which is generated by the GenPal4Plane() function. * @note To scroll image, set virtual dimension wrapx and wrapy, then shift offx and offy. * @param segm Segment to configure * @param data Pointer to data buffer * @param plane Offset of 2nd graphics plane (in bytes), size of one graphics plane * @param trans Pointer to 4-color palette translation table (generated with GenPal4Plane function) * @param wb Number of bytes between lines */ void ScreenSegmPlane2(sSegm* segm, const void* data, int plane, const void* trans, int wb); /** * @brief Set video segment to 2x4 bit color attribute per 8x8 pixel sample graphics * @details Graphical mode with attributes (GF_ATTRIB8). This mode is known from ZX Spectrum computers. The 'data' parameter * is a pointer to the pixel data. This corresponds to the monochrome display mode, where each bit distinguishes whether * foreground or background color is used. The 'attr' parameter is a pointer to an array of color attributes. The color * attribute is a byte, where the lower 4 bits represent the foreground color and the upper 4 bits the background color. * The attribute is converted to a colored pixel using the palette table 'pal', which is an array of 16 bytes of colors. * Each attribute specifies the foreground and background colors for a group of 8 x 8 pixels. Thus, for every 8 bytes of pixels, * there is 1 byte of color attributes. The 'wb' parameter here specifies the line width in bytes for both the pixel array and * the attribute array. The difference is that the address in the attributes array is not incremented after each line, but after * 8 lines.

* Although there is no program in the PicoVGA library utilities that prepares an image in attribute mode, there is an internal * function Attr8Conv that converts an image in 16 colors to attribute mode. Thus, the image is attached to the program as a * 16-color image, and the conversion function is used to prepare a copy in RAM. * @note To scroll image, set virtual dimension wrapx and wrapy, then shift offx and offy. * @param segm Segment to configure * @param data Pointer to data buffer with mono pixels * @param attr Pointer to color attributes * @param pal Pointer to 16-color palette table * @param wb Number of bytes between lines */ void ScreenSegmAttrib8(sSegm* segm, const void* data, const void* attr, const u8* pal, int wb); /** * @brief Set video segment to horizontal progress indicator GF_PROGRESS * @details Progress indicator (GF_PROGRESS). Progress indicator is a horizontal indicator. The parameter 'data' is an array of * bytes of length corresponding to the height of the segment. The byte value indicates the line length in multiples of 4 pixels. * Thus, a value of 0 to 255 represents an indicator length of 0 to 1020 pixels. For the first part of the indicator (< data) * the colour gradient 'sample1' is displayed, for the second part (>= data) 'sample2' is displayed. * @param segm Segment to configure * @param data Pointer to buffer with values 0..255 of 4-pixels in rows * @param sample1 Scanline sample < data * @param sample2 Scanline sample >= data */ void ScreenSegmProgress(sSegm* segm, const void* data, const void* sample1, const void* sample2); /** * @brief Set video segment to 8-bit graphics with 2D matrix transformation * @details 8-bit graphics with 2D matrix transformation. This segment displays an 8-bit image with transformations - rotate, * scale, skew and shift. The image must have width and height as a power of 2. The width and height of the image are specified * using the xbits and ybits parameters as the number of bits of the dimension. For example, for a 512 x 256 pixel image, * xbits = 9, ybits = 8. The 'mat' parameter is a pointer to an array of 6 integer transformation matrix parameters - see the * Transformation matrix section. The segment does not support parameters for image shifting and wrapping, they must be left at * default values. * @note Use default settings of parameters: offx = 0, offy = 0, wrapx = segment width, wrapy = segment height * @param segm Segment to configure * @param data Pointer to image data (width and height of image must be power of 2) * @param mat Pointer to array of 6 matrix integer parameters m11, m12...m23 (exported with ExportInt function) * @param xbits Number of bits of image width (image width must be power of 2 and must be = pitch width bytes) * @param ybits Number of bits of image height (image height must be power of 2) */ void ScreenSegmGraph8Mat(sSegm* segm, const void* data, const int* mat, u16 xbits, u16 ybits); /** * @brief Set video segment to 8-bit graphics with perspective projection * @note Use default settings of parameters: offx = 0, offy = 0, wrapx = segment width, wrapy = segment height * @param segm Segment to configure * @param data Pointer to image data (width and height of image must be power of 2) * @param mat Pointer to array of 6 matrix integer parameters m11, m12...m23 (exported with ExportInt function) * @param xbits Number of bits of image width (image width must be power of 2 and must be = pitch width bytes) * @param ybits Number of bits of image height (image height must be power of 2) * @param horiz Horizon offset */ void ScreenSegmGraph8Persp(sSegm* segm, const void* data, const int* mat, u16 xbits, u16 ybits, u16 horiz); /** * @brief Set video segment to tiles with perspective * @details Tile graphics with 3D perspective. Similar to the previous function, it is used to display terrain with 3D projection. * It uses tile definition instead of 8-bit graphics. This allows the display of very large terrains. The 'map' parameter is a * pointer to a map of tiles - tile indices 0 to 255. The width and height of the map must be powers of 2 and are specified as the * number of mapwbits and maphbits. Tiles must have a square dimension, which must also be a power of 2. The tile dimension is * specified by the tilebits parameter as the number of dimension bits. The 'tiles' parameter is a pointer to an image with a * pattern of tiles arranged in 1 column of tiles. The 'horizon' parameter specifies the horizon offset over the segment boundary * / 4. A positive number represents the horizon offset, a negative number will invert the perspective (can be used to display * the sky). A zero value turns off the perspective - in this case the function is similar to the function for displaying an image * with a transformation matrix (the array of tiles can be rotated, skewed, etc). * @note Use default settings of parameters: offx = 0, offy = 0, wrapx = segment width, wrapy = segment height * @param segm Segment to configure * @param map Pointer to tile map with tile indices (width and height must be power of 2) * @param tiles Pointer to 1 column of square tiles, 1 pixel = 8 bits (width and height must be power of 2) * @param mat Pointer to array of 6 matrix integer parameters m11, m12...m23 (exported with ExportInt function) * @param mapwbits Number of bits of tile map width * @param maphbits Number of bits of tile map height * @param tilebits Number of bits of tile width and height * @param horizon Horizon offset/4 (0=do not use perspective projection, <0=vertical flip to display ceiling) */ void ScreenSegmTilePersp(sSegm* segm, const u8* map, const u8* tiles, const int* mat, u8 mapwbits, u8 maphbits, u8 tilebits, s8 horizon); /** * @brief Set video segment to tiles with perspective, 1.5 pixels * @details Similar to ScreenSegmTilePersp(), but the pixels are rendered 1.5 pixels wide. This function can be used if * the previous function does not keep up with the rendering speed. * @note Use default settings of parameters: offx = 0, offy = 0, wrapx = segment width, wrapy = segment height * @param segm Segment to configure * @param map Pointer to tile map with tile indices (width and height must be power of 2) * @param tiles Pointer to 1 column of square tiles, 1 pixel = 8 bits (width and height must be power of 2) * @param mat Pointer to array of 6 matrix integer parameters m11, m12...m23 (exported with ExportInt function) * @param mapwbits Number of bits of tile map width * @param maphbits Number of bits of tile map height * @param tilebits Number of bits of tile width and height * @param horizon Horizon offset/4 (0=do not use perspective projection, <0=vertical flip to display ceiling) */ void ScreenSegmTilePersp15(sSegm* segm, const u8* map, const u8* tiles, const int* mat, u8 mapwbits, u8 maphbits, u8 tilebits, s8 horizon); /** * @brief Set video segment to tiles with perspective, double pixels * @details Similar to ScreenSegmTilePersp(), but the pixels are rendered 2 pixels wide. This function can be used if * the previous function does not keep up with the rendering speed. * @note Use default settings of parameters: offx = 0, offy = 0, wrapx = segment width, wrapy = segment height * @param segm Segment to configure * @param map Pointer to tile map with tile indices (width and height must be power of 2) * @param tiles Pointer to 1 column of square tiles, 1 pixel = 8 bits (width and height must be power of 2) * @param mat Pointer to array of 6 matrix integer parameters m11, m12...m23 (exported with ExportInt function) * @param mapwbits Number of bits of tile map width * @param maphbits Number of bits of tile map height * @param tilebits Number of bits of tile width and height * @param horizon Horizon offset/4 (0=do not use perspective projection, <0=vertical flip to display ceiling) */ void ScreenSegmTilePersp2(sSegm* segm, const u8* map, const u8* tiles, const int* mat, u8 mapwbits, u8 maphbits, u8 tilebits, s8 horizon); /** * @brief Set video segment to tiles with perspective, triple pixels * @details Similar to ScreenSegmTilePersp(), but the pixels are rendered 3 pixels wide. This function can be used if * the previous function does not keep up with the rendering speed. * @note Use default settings of parameters: offx = 0, offy = 0, wrapx = segment width, wrapy = segment height * @param segm Segment to configure * @param map Pointer to tile map with tile indices (width and height must be power of 2) * @param tiles Pointer to 1 column of square tiles, 1 pixel = 8 bits (width and height must be power of 2) * @param mat Pointer to array of 6 matrix integer parameters m11, m12...m23 (exported with ExportInt function) * @param mapwbits Number of bits of tile map width * @param maphbits Number of bits of tile map height * @param tilebits Number of bits of tile width and height * @param horizon Horizon offset/4 (0=do not use perspective projection, <0=vertical flip to display ceiling) */ void ScreenSegmTilePersp3(sSegm* segm, const u8* map, const u8* tiles, const int* mat, u8 mapwbits, u8 maphbits, u8 tilebits, s8 horizon); /** * @brief Set video segment to tiles with perspective, quadruple pixels * @details Similar to ScreenSegmTilePersp(), but the pixels are rendered 4 pixels wide. This function can be used if * the previous function does not keep up with the rendering speed. * @note Use default settings of parameters: offx = 0, offy = 0, wrapx = segment width, wrapy = segment height * @param segm Segment to configure * @param map Pointer to tile map with tile indices (width and height must be power of 2) * @param tiles Pointer to 1 column of square tiles, 1 pixel = 8 bits (width and height must be power of 2) * @param mat Pointer to array of 6 matrix integer parameters m11, m12...m23 (exported with ExportInt function) * @param mapwbits Number of bits of tile map width * @param maphbits Number of bits of tile map height * @param tilebits Number of bits of tile width and height * @param horizon Horizon offset/4 (0=do not use perspective projection, <0=vertical flip to display ceiling) */ void ScreenSegmTilePersp4(sSegm* segm, const u8* map, const u8* tiles, const int* mat, u8 mapwbits, u8 maphbits, u8 tilebits, s8 horizon); /// @} #endif // _VGA_SCREEN_H