682 lines
23 KiB
C
682 lines
23 KiB
C
/****************************************************************************
|
|
*
|
|
* Copyright 2012 - 2020 Vivante Corporation, Santa Clara, California.
|
|
* All Rights Reserved.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
* a copy of this software and associated documentation files (the
|
|
* 'Software'), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sub license, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject
|
|
* to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the
|
|
* next paragraph) shall be included in all copies or substantial
|
|
* portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
|
* IN NO EVENT SHALL VIVANTE AND/OR ITS SUPPLIERS BE LIABLE FOR ANY
|
|
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#ifndef ELM_H_
|
|
#define ELM_H_
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#define ELM_VERSION 0x00010000 /* Current Version: 1.0. */
|
|
#define ELM_NULL_HANDLE 0 /*! NULL object handle, represent a void object. */
|
|
|
|
/*!
|
|
@typedef ELM_EVO_PROP_BIT
|
|
evo property bits to control evo manipulation.
|
|
*/
|
|
typedef enum {
|
|
ELM_PROP_ROTATE_BIT = 1 << 0, /*! rotate bit of evo/ego/ebo transformation property. */
|
|
ELM_PROP_TRANSFER_BIT = 1 << 1, /*! transfer bit of evo/ego/ebo transformation property. */
|
|
ELM_PROP_SCALE_BIT = 1 << 2, /*! scale bit of evo/ego/ebo transformation property. */
|
|
ELM_PROP_BLEND_BIT = 1 << 3, /*! blending bit of evo/ebo rendering property. */
|
|
ELM_PROP_QUALITY_BIT = 1 << 4, /*! quality bit of evo/ebo rendering property. */
|
|
ELM_PROP_FILL_BIT = 1 << 5, /*! fill rule bit of evo rendering property. */
|
|
ELM_PROP_COLOR_BIT = 1 << 6, /*! fill color bit of evo rendering property. */
|
|
ELM_PROP_PAINT_BIT = 1 << 7, /*! paint type bit of evo. */
|
|
ELM_PROP_ALL_BIT = 0xFFFFFFFF, /*! all transformation property bits of evo. */
|
|
} ELM_EVO_PROP_BIT;
|
|
|
|
/*!
|
|
@typedef ELM_EVO_BLEND
|
|
The blending property of the evo object when it's drawn.
|
|
D is Destination color, S is Source color;
|
|
Da is Destination alpha, S is Source alpha.
|
|
*/
|
|
typedef enum {
|
|
ELM_BLEND_NONE = 0, /*! D = S. */
|
|
ELM_BLEND_SRC_OVER, /*! D = S + (1 - Sa) * D */
|
|
ELM_BLEND_DST_OVER, /*! D = (1 - Da) * S + D */
|
|
ELM_BLEND_SRC_IN, /*! D = Da * S */
|
|
ELM_BLEND_DST_IN, /*! D = Sa * D */
|
|
ELM_BLEND_SCR, /*! D = S + D - S * D */
|
|
ELM_BLEND_MUL, /*! D = S * (1 - Da) + D * (1 - Sa) + S * D */
|
|
ELM_BLEND_ADD, /*! S + D */
|
|
ELM_BLEND_SUB /*! D * (1 - S) */
|
|
} ELM_BLEND;
|
|
|
|
/*!
|
|
@typedef ELM_EVO_QUALITY
|
|
The drawing quality of the evo object.
|
|
*/
|
|
typedef enum {
|
|
ELM_QUALITY_LOW = 0, /*! NOAA for evo, POINT SAMPLE for ebo. */
|
|
ELM_QUALITY_MED = 1, /*! 2XAA for evo, LINEAR SAMPLE for ebo. */
|
|
ELM_QULIATY_HI = 2, /*! 4XAA for evo, BI-LINEAR SAMPLE for ebo. */
|
|
} ELM_QUALITY;
|
|
|
|
/*!
|
|
@typedef ELM_PAINT_TYPE
|
|
Those are types for evo fill paint.
|
|
COLOR means solid color fill;
|
|
PATTERN means fill with an image (evo);
|
|
GRADIENT means fill with linear gradient.
|
|
*/
|
|
typedef enum {
|
|
ELM_PAINT_COLOR = 0, /*! Paint evo with solid color */
|
|
ELM_PAINT_PATTERN = 1, /*! Paint evo with ebo */
|
|
ELM_PAINT_GRADIENT = 2, /*! Paint evo with a linear gradient built-in evo object */
|
|
ELM_PAINT_RADIAL_GRADIENT = 3, /*! Paint evo with a radial gradient built-in evo object */
|
|
ELM_PAINT_TEXT = 4, /*! Paint evo-text */
|
|
} ELM_PAINT_TYPE;
|
|
|
|
/*!
|
|
@typedef ELM_PATTERN_MODE
|
|
Those are enum types for pattern fill mode.
|
|
COLOR means fill the area outside the pattern with a solid color;
|
|
PAD means extend the border color to the area outside the pattern.
|
|
*/
|
|
typedef enum {
|
|
ELM_PATTERN_MODE_COLOR = 0,
|
|
ELM_PATTERN_MODE_PAD = 1,
|
|
} ELM_PATTERN_MODE;
|
|
|
|
/*!
|
|
@typedef ELM_EVO_FILL
|
|
The filling rule of for an evo object.
|
|
EO = EVEN_ODD;
|
|
NZ = NONE_ZERO;
|
|
*/
|
|
typedef enum {
|
|
ELM_EVO_FILL_NZ = 0, /*! none-zero fill rule */
|
|
ELM_EVO_FILL_EO = 1, /*! Even-odd fill rule */
|
|
} ELM_EVO_FILL;
|
|
|
|
/*!
|
|
@typedef ELM_EVO_TYPE
|
|
the type of an evo object. could be pathes, images, or a group which contains other EVOs.
|
|
*/
|
|
typedef enum {
|
|
ELM_OBJECT_TYPE_EVO = 0, /*! elementary vector object, representing a path object. */
|
|
ELM_OBJECT_TYPE_EGO = 1, /*! elementary group object, containing multiple path objects. */
|
|
ELM_OBJECT_TYPE_EBO = 2, /*! elementary bitmap object, representing image data. */
|
|
ELM_OBJECT_TYPE_BUF = 3, /*! rendering buffer object, created by application. */
|
|
ELM_OBJECT_TYPE_FONT = 4, /*! elementary font object, representing character data. */
|
|
ELM_OBJECT_TYPE_TEXT = 5, /*! elementary text object, representing text data. */
|
|
} ELM_OBJECT_TYPE;
|
|
|
|
/*!
|
|
@typedef ELM_BUFFER_FORMAT
|
|
Enumeration for buffer format, all format name definiton is sequenced from LSB to MSB.
|
|
*/
|
|
typedef enum {
|
|
ELM_BUFFER_FORMAT_RGBA8888, /*! 32-bit RGBA format with 8 bits per color channel. Red is in bits 7:0, green in bits 15:8, blue in
|
|
bits 23:16, and the alpha channel is in bits 31:24. */
|
|
ELM_BUFFER_FORMAT_BGRA8888, /*! 32-bit RGBA format with 8 bits per color channel. Red is in bits 23:16, green in bits 15:8, blue in
|
|
bits 7:0, and the alpha channel is in bits 31:24. */
|
|
ELM_BUFFER_FORMAT_RGBX8888, /*! 32-bit RGBX format with 8 bits per color channel. Red is in bits 7:0, green in bits 15:8, blue in
|
|
bits 23:16, and the x channel is in bits 31:24. */
|
|
ELM_BUFFER_FORMAT_BGRX8888, /*! 32-bit RGBX format with 8 bits per color channel. Red is in bits 23:16, green in bits 15:8, blue in
|
|
bits 7:0, and the x channel is in bits 31:24. */
|
|
ELM_BUFFER_FORMAT_RGB565, /*! 16-bit RGB format with 5 and 6 bits per color channel. Red is in bits 4:0, green in bits 10:5, and
|
|
the blue color channel is in bits 15:11. */
|
|
ELM_BUFFER_FORMAT_BGR565, /*! 16-bit RGB format with 5 and 6 bits per color channel. Red is in bits 15:11, green in bits 10:5,
|
|
and the blue color channel is in bits 4:0. */
|
|
ELM_BUFFER_FORMAT_RGBA4444, /*! 16-bit RGBA format with 4 bits per color channel. Red is in bits 3:0, green in bits 7:4, blue in
|
|
bits 11:8 and the alpha channel is in bits 15:12. */
|
|
ELM_BUFFER_FORMAT_BGRA4444, /*! 16-bit RGBA format with 4 bits per color channel. Red is in bits 11:8, green in bits 7:4, blue in
|
|
bits 3:0 and the alpha channel is in bits 15:12. */
|
|
ELM_BUFFER_FORMAT_BGRA5551, /*! 16-bit RGBA format with 4 bits per color channel. Red is in bits 14:10, green in bits 9:5, blue in
|
|
bits 4:0 and the alpha channel is in bit 15:15. */
|
|
ELM_BUFFER_FORMAT_INDEX_1, /*! 1-bit indexed format. */
|
|
ELM_BUFFER_FORMAT_INDEX_2, /*! 2-bits indexed format. */
|
|
ELM_BUFFER_FORMAT_INDEX_4, /*! 4-bits indexed format. */
|
|
ELM_BUFFER_FORMAT_INDEX_8, /*! 8-bits indexed format. */
|
|
} ELM_BUFFER_FORMAT;
|
|
|
|
/*!
|
|
@typedef ElmHandle
|
|
common handle type for object reference.
|
|
*/
|
|
typedef unsigned int ElmHandle;
|
|
|
|
/*!
|
|
@typedef ElmVecObj
|
|
evo object handle (elemtry vector object). Created from an external binary evo file.
|
|
*/
|
|
typedef ElmHandle ElmVecObj;
|
|
|
|
/*!
|
|
@typedef ElmBitmapObj
|
|
ebo object handle (elementry image object). Created from an external ebo file.
|
|
*/
|
|
typedef ElmHandle ElmBitmapObj;
|
|
|
|
/*!
|
|
@typedef ElmGroupObj
|
|
group object handle. Create from an external ego file.
|
|
*/
|
|
typedef ElmHandle ElmGroupObj;
|
|
|
|
/*!
|
|
@typedef ElmBuffer
|
|
render buffer object handle.
|
|
*/
|
|
typedef ElmHandle ElmBuffer;
|
|
|
|
#define TRUE 1
|
|
#define FALSE 0
|
|
/*!
|
|
@typedef BOOL
|
|
boolean type define.
|
|
*/
|
|
typedef unsigned int BOOL;
|
|
|
|
/*!
|
|
@abstract Initialize Elementary context.
|
|
|
|
@discussion
|
|
It should be called as the first function of Elemenatary libary, which initializes the library. Currently
|
|
Elementary library doesn't support context concept, neigher multi-threading. Elementary library defines
|
|
origin of coordinate system is at top-left.
|
|
|
|
@param none
|
|
|
|
@return none
|
|
*/
|
|
BOOL ElmInitialize(uint32_t width, uint32_t height);
|
|
|
|
/*!
|
|
@abstract Terminate Elementary context.
|
|
|
|
@discussion
|
|
This should be called when an app exits. It frees all the resource.
|
|
|
|
@param none
|
|
|
|
@return none
|
|
*/
|
|
void ElmTerminate(void);
|
|
|
|
/*!
|
|
@abstract Create an elementary object from an existing binary file.
|
|
|
|
@discussion
|
|
This function creates an elementary object from the file whose file name is specified by param name.
|
|
Caller must match type with the binary file, otherwise create mail fail by returning ELM_NULL_HANDLE.
|
|
|
|
@param type
|
|
Specify what type of object to be created.
|
|
|
|
@param name
|
|
The name of the binary resource file.
|
|
|
|
@return ElmHandle
|
|
An object handle depending on the corresponding type. If type mismatches, it
|
|
returns ELM_NULL_HANDLE.
|
|
*/
|
|
ElmHandle ElmCreateObjectFromFile(ELM_OBJECT_TYPE type, const char *name);
|
|
|
|
/*!
|
|
@abstract Create an elementary object from build-in data within the appplication.
|
|
|
|
@discussion
|
|
This function creates an elementar object from local data pointer, which is specially useful for environment without filesystem support.
|
|
|
|
@param type
|
|
Specify what type of object to be created.
|
|
|
|
@param data
|
|
The pointer to the binary data which has exactly same layout as external resource file.
|
|
|
|
@return ElmHandle
|
|
An object handle depending on the corresponding type. If type mismatches with the binary data, it
|
|
returns ELM_NULL_HANDLE.
|
|
*/
|
|
ElmHandle ElmCreateObjectFromData(ELM_OBJECT_TYPE type, void *data, int size);
|
|
|
|
/*!
|
|
@abstract Rotate a graphics object with centain degree
|
|
|
|
@discussion
|
|
This function sets an evo/ebo/ego object rotated with specified angle. Without reset, these setting will be
|
|
accumulated.
|
|
|
|
@param obj
|
|
The graphics object will be rotated.
|
|
|
|
@param angle
|
|
A radian value to be applied on the evo object.
|
|
|
|
@return bool
|
|
Rotate is set successfully.
|
|
*/
|
|
BOOL ElmRotate(ElmHandle obj, float angle);
|
|
|
|
/*!
|
|
@abstract Transfer an graphics object at different directions.
|
|
|
|
@discussion
|
|
This function put an evo/ebo/ego object away at different directions. Without reset, the setting will be
|
|
accumulated.
|
|
|
|
@param obj
|
|
The graphics object will be transfered.
|
|
|
|
@param x
|
|
The units in pixel of X direction.
|
|
|
|
@param y
|
|
The units in pixel of Y direction.
|
|
|
|
@return bool
|
|
Transfer is set successfully.
|
|
*/
|
|
BOOL ElmTransfer(ElmHandle obj, int x, int y);
|
|
|
|
/*!
|
|
@abstract Scale an graphics object at different directions.
|
|
|
|
@discussion
|
|
This function scale up or down an evo/ego/ebo object at different directions. Without reset, the setting will
|
|
be accumateled.
|
|
|
|
@param obj
|
|
The graphics object which is targeted to manipulate.
|
|
|
|
@param x
|
|
The scale ratio in X direction.
|
|
|
|
@param y
|
|
The scale ratio in Y direction.
|
|
|
|
@return bool
|
|
Scale is set succefully.
|
|
*/
|
|
BOOL ElmScale(ElmHandle obj, float x, float y);
|
|
|
|
/*!
|
|
@abstract Reset the attribute of a graphics object for specified property bit.
|
|
|
|
@discussion
|
|
This funcion resets specified property for an elementary object. It can be applied all types of objects.
|
|
But some properties are only valid for centain types of objects. If the function is called to reset an invalid
|
|
property for this type of object, it will be siliently ignored.
|
|
After reset, the specifed property of an evo/ebo/ego object is set to the initial state. The initial states are decided
|
|
by the binary resource file. The resource creator should set right value for all properties if they want to directly render
|
|
the object without any adjustment in application. There is one issue, at present, application has no way to query current value
|
|
of each property, is it required?
|
|
|
|
@param obj
|
|
The graphics object which is targeted to manipulate.
|
|
|
|
@param mask
|
|
Specify which property or properties need to reset to initial value.
|
|
|
|
@return bool
|
|
Reset is done successfully. If some mask is not valid for this type of object, it would return false.
|
|
*/
|
|
BOOL ElmReset(ElmHandle obj, ELM_EVO_PROP_BIT mask);
|
|
|
|
/*!
|
|
@abstract Draw a graphics object onto current render target
|
|
|
|
@discussion
|
|
This is an enssentail function to do the real job, it takes all current setting of the elementary object and
|
|
render into theb buffer target.
|
|
|
|
@param buffer
|
|
The render target that an elmentary object will be rendered into.
|
|
|
|
@param obj
|
|
The elmentary object will be draw into render target.
|
|
|
|
@return bool
|
|
The draw operation for this elmentary object is sucessful.
|
|
*/
|
|
BOOL ElmDraw(ElmBuffer buffer, ElmHandle object);
|
|
|
|
/*!
|
|
@abstract Set the rendering quality of an graphics object.
|
|
|
|
@discussion
|
|
This function sets the rendering quality of an evo/ebo object. Avaliable quality setting contains:
|
|
ELM_EVO_QUALITY_LOW, ELM_EVO_QUALITY_MED, ELM_EVO_QUALITY_HI. This function is only applied to an evo or an ebo.
|
|
Group object can't be set quality. It always use the setting from its binary.
|
|
|
|
@param obj
|
|
The elementary object.
|
|
|
|
@param quality
|
|
The quality enum.
|
|
|
|
@return bool
|
|
The operation for this object is sucessful, for group object and invalid enum, would return false.
|
|
*/
|
|
BOOL ElmSetQuality(ElmHandle obj, ELM_QUALITY quality);
|
|
|
|
/*!
|
|
@abstract Set the fill rule of an evo object.
|
|
|
|
@discussion
|
|
This function sets the fill rule of an elementary object. Avaliable quality setting contains:
|
|
ELM_EVO_EO, ELM_EVO_NZ. It only applies to evo object.
|
|
|
|
@param evo
|
|
The evo object.
|
|
|
|
@param fill
|
|
The fill rule enum.
|
|
|
|
@return bool
|
|
The operation for this evo is sucessful. For non-evo object an ENUM is not a valid enum, would return false.
|
|
*/
|
|
BOOL ElmSetFill(ElmVecObj evo, ELM_EVO_FILL fill);
|
|
|
|
/*!
|
|
@abstract Set the blending mode of an evo/ebo object.
|
|
|
|
@discussion
|
|
This function sets the blending mode of an evo/ebo object. It's not applied to group object.
|
|
|
|
@param obj
|
|
The graphics object.
|
|
|
|
@param blend
|
|
The blending mode enum.
|
|
|
|
@return bool
|
|
The operation for this evo/ebo is sucessful. If object is a group object or blend mode is not a legal one, it would return false.
|
|
*/
|
|
BOOL ElmSetBlend(ElmHandle obj, ELM_BLEND blend);
|
|
|
|
/*!
|
|
@abstract Set the solid fill color of an evo object.
|
|
|
|
@discussion
|
|
This function sets the solid fill color of an evo object.
|
|
|
|
@param evo
|
|
The evo object.
|
|
|
|
@param color
|
|
The uint32 color value in rgba order.
|
|
|
|
@return bool
|
|
The operation for this evo is sucessful. If the object is not a evo object, it would return false.
|
|
*/
|
|
BOOL ElmSetColor(ElmVecObj evo, uint32_t color);
|
|
|
|
/*!
|
|
@abstract Set the image paint fill of an evo.
|
|
|
|
@discussion
|
|
This function sets the image pattern for filling an evo. The image pattern
|
|
is a loaded ebo. The ebo's transformation is applied when drawing the evo.
|
|
|
|
@param evo
|
|
The evo object.
|
|
|
|
@param pattern
|
|
The image pattern to be set for the evo.
|
|
|
|
@return bool
|
|
The operation is successful or not.
|
|
*/
|
|
BOOL ElmSetPattern(ElmVecObj evo, ElmBitmapObj pattern);
|
|
|
|
/*!
|
|
@abstract Set the image paint fill of an evo.
|
|
|
|
@discussion
|
|
This function sets the image pattern for filling an evo. The image pattern
|
|
is a loaded ebo. The ebo's transformation is applied when drawing the evo.
|
|
|
|
@param evo
|
|
The evo object.
|
|
|
|
@param pattern
|
|
The image pattern to be set for the evo.
|
|
|
|
@return bool
|
|
The operation is successful or not.
|
|
*/
|
|
BOOL ElmSetPatternMode(ElmVecObj evo, ELM_PATTERN_MODE mode, uint32_t color);
|
|
|
|
/*!
|
|
@abstract Set the paint type of an evo.
|
|
|
|
@discussion
|
|
This function selects the paint type for evo to use. An evo may have 3 types
|
|
of paint: COLOR, PATTERN, and LINEAR GRADIENT. The Linear graident is always
|
|
a built-in resource, which can not be altered. If a binary resource doesn't
|
|
have built-in gradient paint resource, it can't be selected as the paint source.
|
|
Solid color is also a built-in attribute, but it can be changed by ElmSetColor().
|
|
Paint with a pattern always need an external ebo object, which is impossible
|
|
to be embedded in resource file,i.e. ebo object. Before select paint type to
|
|
be PATTERN, ElmSetPattern() must be called to attach an EBO to an EVO.
|
|
|
|
@param evo
|
|
The evo object.
|
|
|
|
@param type
|
|
The paint type to be set for the evo.
|
|
|
|
@return bool
|
|
The operation is successful or not.
|
|
If the corresponding type is not avaiable for the evo, it returns false and
|
|
type paint type falls back to COLOR.
|
|
*/
|
|
BOOL ElmSetPaintType(ElmVecObj evo, ELM_PAINT_TYPE type);
|
|
|
|
/*!
|
|
@abstract Create internal render buffer.
|
|
|
|
@discussion
|
|
This functiois is to create an internal render buffer for Elementary rendering, ussually it's not for direct display.
|
|
The buffer which is displayed on pannel is wrapped up by another API, whose address is managed by display controller side.
|
|
|
|
@param width
|
|
The buffer's width.
|
|
|
|
@param height
|
|
The buffer's height.
|
|
|
|
@param format
|
|
The buffer's format, check enumeration of ELM_BUFFER_FORMAT.
|
|
|
|
@return
|
|
The buffer handle.
|
|
*/
|
|
ElmBuffer ElmCreateBuffer(unsigned int width, unsigned int height, ELM_BUFFER_FORMAT format);
|
|
|
|
/*!
|
|
@abstract Wrap a customized buffer.
|
|
|
|
@discussion
|
|
The application may wrap a user created buffer by giving the information of
|
|
the buffer including the size, the memory addresses and format. E.g., the
|
|
application can wrap a system framebuffer thus ELM can directly render onto
|
|
the screen.
|
|
|
|
@return
|
|
The buffer handle.
|
|
*/
|
|
ElmBuffer ElmWrapBuffer(int width, int height, int stride,
|
|
void *logical, uint32_t physical,
|
|
ELM_BUFFER_FORMAT format);
|
|
|
|
/*!
|
|
@abstract Get buffer address.
|
|
|
|
@discussion
|
|
The function is to get the address of ElmBuffer.
|
|
|
|
@return
|
|
The buffer address.
|
|
*/
|
|
|
|
uint32_t ElmGetBufferAddress(ElmBuffer buffer);
|
|
|
|
/*!
|
|
@abstract Destroy a render buffer.
|
|
|
|
@discussion
|
|
This function is to release all internal resource inside Elementary libary belonging to this buffer.
|
|
Applicatoin need make sure the buffer is not being used by elmentary library any more when calling this function.
|
|
|
|
@param buffer
|
|
The render buffer handle
|
|
|
|
@return
|
|
If destroying is completed successfully.
|
|
*/
|
|
BOOL ElmDestroyBuffer(ElmBuffer buffer);
|
|
|
|
/*!
|
|
@abstract Save a buffer to PNG file.
|
|
|
|
@discussion
|
|
This function can save the buffer into a PNG file.
|
|
|
|
@param buffer
|
|
The render buffer handle.
|
|
|
|
@param name
|
|
The name of the PNG file to sve.
|
|
|
|
@return
|
|
Save OK or NOT.
|
|
|
|
*/
|
|
BOOL ElmSaveBuffer(ElmBuffer buffer, const char *name);
|
|
|
|
/*!
|
|
@abstract Clear a render buffer with specified color and dimension.
|
|
|
|
@discussion
|
|
This function is called to clear full or partial of the buffer. If the rectangle is out of buffer space, the intersect portion will be cleared.
|
|
|
|
@param buffer
|
|
A render buffer handle.
|
|
|
|
@param color
|
|
Clear color value.
|
|
|
|
@param x
|
|
x origin of partical clear rectangle.
|
|
|
|
@param y
|
|
y origin of partial clear rectangle.
|
|
|
|
@param width
|
|
width of partical clear rectangle.
|
|
|
|
@param height
|
|
height of partical clear rectangle.
|
|
|
|
@param full
|
|
Flag to indicate a full buffer clear. If true, the dimension parameters will be ignored.
|
|
|
|
@return bool
|
|
Indicate the clear operation is set up correctly.
|
|
*/
|
|
BOOL ElmClear(ElmBuffer buffer, uint32_t color, uint32_t x, uint32_t y, uint32_t width, uint32_t height, BOOL full);
|
|
|
|
/*!
|
|
@abstract Destroy an ELM object.
|
|
|
|
@discussion
|
|
This function is to release all internal resource inside Elementary libary belonging to this object.
|
|
Applicatoin need make sure the object is not being used by elmentary library any more when calling this function.
|
|
If an EBO is being destroyed and it's attached to one EVO, it need to guarantee that EVO is not being used by elementary library too.
|
|
|
|
@param object
|
|
The object handle
|
|
|
|
@return
|
|
If destroying is completed successfully.
|
|
*/
|
|
BOOL ElmDestroyObject(ElmHandle object);
|
|
|
|
/*!
|
|
@abstract Finish all rendering on GPU issued before this call.
|
|
|
|
@discussion
|
|
This function tells the engine that it has finished the frame data and GPU can draw it now. It's blocked until GPU rendering done.
|
|
|
|
@return
|
|
If the opeartion is successfully done or not.
|
|
*/
|
|
BOOL ElmFinish();
|
|
|
|
/*!
|
|
@abstract Flush all rendering command to GPU issued before this call.
|
|
|
|
@discussion
|
|
This function tells the engine to start kicking off command to GPU side, it will return immediately after firing off GPU.
|
|
|
|
@return
|
|
If the opeartion is successfully done or not.
|
|
*/
|
|
BOOL ElmFlush();
|
|
|
|
/*!
|
|
@abstract Query the paint color of an evo object.
|
|
*/
|
|
BOOL ElmGetColor(ElmVecObj evoHandle,uint32_t *color);
|
|
|
|
/*!
|
|
@abstract Query the vectory path count of an EGO object. If the given object
|
|
is an evo/ebo, the count is 0.
|
|
*/
|
|
uint32_t ElmGetVectorCount(ElmHandle handle);
|
|
|
|
/*!
|
|
@abstract Query the type of an object (by handle).
|
|
*/
|
|
ELM_OBJECT_TYPE ElmGetObjectType(ElmHandle handle);
|
|
|
|
/*!
|
|
@abstract Set the current vectory object index to operate on.
|
|
*/
|
|
BOOL ElmSetCurrentVector(int32_t id);
|
|
|
|
BOOL ElmScalePaint(ElmHandle handle, float sx, float sy);
|
|
BOOL ElmRotatePaint(ElmHandle handle, float degrees);
|
|
BOOL ElmTranslatePaint(ElmHandle handle, float tx, float ty);
|
|
|
|
/*!
|
|
@abstract Get handle of the framebuffer.
|
|
*/
|
|
ElmBuffer ElmGetBuffer(vg_lite_buffer_t *buffer);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
#endif /* ELM_H_ */
|