mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
229 lines
6.8 KiB
229 lines
6.8 KiB
/* |
|
Copyright (c) 2012, Broadcom Europe Ltd |
|
All rights reserved. |
|
|
|
Redistribution and use in source and binary forms, with or without |
|
modification, are permitted provided that the following conditions are met: |
|
* Redistributions of source code must retain the above copyright |
|
notice, this list of conditions and the following disclaimer. |
|
* 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. |
|
* Neither the name of the copyright holder 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 HOLDER 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. |
|
*/ |
|
|
|
#ifndef VG_CLIENT_H |
|
#define VG_CLIENT_H |
|
|
|
#include "interface/khronos/common/khrn_client.h" |
|
#include "interface/khronos/common/khrn_client_platform.h" |
|
#include "interface/khronos/common/khrn_client_pointermap.h" |
|
#include "interface/khronos/common/khrn_client_vector.h" |
|
|
|
#include "interface/khronos/egl/egl_client_context.h" |
|
|
|
#include "interface/khronos/include/EGL/egl.h" |
|
#include "interface/khronos/include/EGL/eglext.h" |
|
#include "interface/khronos/include/VG/openvg.h" |
|
|
|
#include "interface/khronos/vg/vg_int_config.h" |
|
#include "interface/khronos/vg/vg_int.h" |
|
#include "interface/khronos/vg/vg_int_mat3x3.h" |
|
|
|
/* should be after EGL/eglext.h */ |
|
#if EGL_BRCM_global_image && EGL_KHR_image |
|
#include "interface/khronos/common/khrn_client_global_image_map.h" |
|
#endif |
|
|
|
/****************************************************************************** |
|
shared state |
|
******************************************************************************/ |
|
|
|
#define VG_CLIENT_STEMS_COUNT_MAX 64 |
|
|
|
typedef struct { |
|
VG_CLIENT_OBJECT_TYPE_T object_type; |
|
#if EGL_BRCM_global_image && EGL_KHR_image |
|
KHRN_GLOBAL_IMAGE_MAP_T glyph_global_images; |
|
#endif |
|
} VG_CLIENT_FONT_T; |
|
|
|
typedef struct { |
|
VG_CLIENT_OBJECT_TYPE_T object_type; |
|
VGImageFormat format; |
|
VGint width; |
|
VGint height; |
|
#if EGL_BRCM_global_image && EGL_KHR_image |
|
VGuint global_image_id[2]; |
|
#endif |
|
} VG_CLIENT_IMAGE_T; |
|
|
|
typedef struct { |
|
VG_CLIENT_OBJECT_TYPE_T object_type; |
|
VGint width; |
|
VGint height; |
|
} VG_CLIENT_MASK_LAYER_T; |
|
|
|
typedef struct { |
|
VGfloat linear[4]; |
|
VGfloat radial[5]; |
|
VGColorRampSpreadMode ramp_spread_mode; |
|
bool ramp_pre; |
|
VGfloat *ramp_stops; /* NULL when count is 0 */ |
|
VGuint ramp_stops_count; |
|
} VG_CLIENT_PAINT_GRADIENT_T; |
|
|
|
typedef struct { |
|
VG_CLIENT_OBJECT_TYPE_T object_type; |
|
VGPaintType type; |
|
VGfloat color[4]; |
|
VG_CLIENT_PAINT_GRADIENT_T *gradient; /* allocated when required */ |
|
VGTilingMode pattern_tiling_mode; |
|
VGImage pattern; |
|
#if EGL_BRCM_global_image && EGL_KHR_image |
|
VGuint pattern_global_image_id[2]; |
|
#endif |
|
} VG_CLIENT_PAINT_T; |
|
|
|
typedef struct { |
|
VG_CLIENT_OBJECT_TYPE_T object_type; |
|
VGint format; |
|
VGPathDatatype datatype; |
|
VGfloat scale; |
|
VGfloat bias; |
|
VGbitfield caps; |
|
KHRN_VECTOR_T segments; |
|
} VG_CLIENT_PATH_T; |
|
|
|
typedef struct { |
|
VGuint ref_count; /* we only read/write this when holding the client mutex */ |
|
|
|
PLATFORM_MUTEX_T mutex; /* just one mutex for everything else in here */ |
|
|
|
VGuint stems_count; |
|
VGHandle stems[VG_CLIENT_STEMS_COUNT_MAX]; |
|
|
|
KHRN_POINTER_MAP_T objects; |
|
} VG_CLIENT_SHARED_STATE_T; |
|
|
|
extern VG_CLIENT_SHARED_STATE_T *vg_client_shared_state_alloc(void); |
|
extern void vg_client_shared_state_free(VG_CLIENT_SHARED_STATE_T *shared_state); |
|
|
|
static INLINE void vg_client_shared_state_acquire(VG_CLIENT_SHARED_STATE_T *shared_state) |
|
{ |
|
++shared_state->ref_count; |
|
} |
|
|
|
static INLINE void vg_client_shared_state_release(VG_CLIENT_SHARED_STATE_T *shared_state) |
|
{ |
|
if (--shared_state->ref_count == 0) { |
|
vg_client_shared_state_free(shared_state); |
|
} |
|
} |
|
|
|
/****************************************************************************** |
|
state |
|
******************************************************************************/ |
|
|
|
/* |
|
Called just before a rendering command (i.e. anything which could modify |
|
the draw surface) is executed |
|
*/ |
|
typedef void (*VG_RENDER_CALLBACK_T)(void); |
|
|
|
/* |
|
Called just after rendering has been compeleted (i.e. flush or finish). |
|
wait should be true for finish-like behaviour, false for flush-like |
|
behaviour |
|
*/ |
|
typedef void (*VG_FLUSH_CALLBACK_T)(bool wait); |
|
|
|
typedef struct { |
|
VG_MAT3X3_T client; |
|
VG_MAT3X3_T server; |
|
} VG_MAT3X3_SYNC_T; |
|
|
|
typedef struct { |
|
VG_CLIENT_SHARED_STATE_T *shared_state; |
|
|
|
VG_RENDER_CALLBACK_T render_callback; |
|
VG_FLUSH_CALLBACK_T flush_callback; |
|
|
|
/* |
|
matrices stored on client |
|
updates sent to server as necessary |
|
*/ |
|
|
|
VGMatrixMode matrix_mode; |
|
VG_MAT3X3_SYNC_T matrices[5]; |
|
|
|
/* |
|
state cached on client-side to allow dropping of redundant calls |
|
*/ |
|
|
|
VGFillRule fill_rule; |
|
VGfloat stroke_line_width; |
|
VGCapStyle stroke_cap_style; |
|
VGJoinStyle stroke_join_style; |
|
VGfloat stroke_miter_limit; |
|
VGfloat stroke_dash_pattern[VG_CONFIG_MAX_DASH_COUNT]; |
|
VGuint stroke_dash_pattern_count; |
|
VGfloat stroke_dash_phase; |
|
bool stroke_dash_phase_reset; |
|
VGImageQuality image_quality; |
|
VGImageMode image_mode; |
|
|
|
bool scissoring; |
|
VGint scissor_rects[VG_CONFIG_MAX_SCISSOR_RECTS * 4]; |
|
VGuint scissor_rects_count; |
|
|
|
VGRenderingQuality rendering_quality; |
|
|
|
VGPaint fill_paint; |
|
VGPaint stroke_paint; |
|
VGfloat tile_fill_color[4]; |
|
VGfloat clear_color[4]; |
|
|
|
bool color_transform; |
|
VGfloat color_transform_values[8]; |
|
|
|
VGBlendMode blend_mode; |
|
bool masking; |
|
|
|
bool filter_format_linear; |
|
bool filter_format_pre; |
|
VGuint filter_channel_mask; |
|
|
|
VGPixelLayout pixel_layout; |
|
} VG_CLIENT_STATE_T; |
|
|
|
extern VG_CLIENT_STATE_T *vg_client_state_alloc(VG_CLIENT_SHARED_STATE_T *shared_state); |
|
extern void vg_client_state_free(VG_CLIENT_STATE_T *state); |
|
|
|
static INLINE VG_CLIENT_STATE_T *vg_get_client_state(CLIENT_THREAD_STATE_T *thread) |
|
{ |
|
EGL_CONTEXT_T *context = thread->openvg.context; |
|
if (context) { |
|
vcos_assert(context->type == OPENVG); |
|
return (VG_CLIENT_STATE_T *)context->state; |
|
} else { |
|
return NULL; |
|
} |
|
} |
|
|
|
#define VG_GET_CLIENT_STATE(thread) vg_get_client_state(thread) |
|
|
|
#endif
|
|
|