| /* |
| * Copyright 2016 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can |
| * be found in the LICENSE file. |
| * |
| */ |
| |
| #ifndef SKC_ONCE_STYLING_TYPES |
| #define SKC_ONCE_STYLING_TYPES |
| |
| // |
| // |
| // |
| |
| #include "types.h" |
| #include "macros.h" |
| #include "skc_styling.h" |
| |
| // |
| // |
| // |
| |
| typedef skc_uint skc_layer_id; |
| typedef skc_uint skc_group_id; |
| |
| // |
| // |
| // |
| |
| union skc_styling_cmd |
| { |
| skc_uint u32; |
| skc_int s32; |
| skc_float f32; |
| skc_half f16a2[2]; |
| skc_ushort2 u16v2; |
| skc_styling_opcode_e opcode; |
| skc_styling_gradient_type_e gradient_type; |
| skc_group_id parent; |
| |
| #if 0 |
| #if !defined(__OPENCL_C_VERSION__) |
| struct { |
| skc_uint opcode : 31; |
| skc_uint final : 1; |
| }; |
| #endif |
| #endif |
| }; |
| |
| #define SKC_STYLING_OPCODE_MASK_OPCODE SKC_BITS_TO_MASK(31) |
| #define SKC_STYLING_OPCODE_MASK_IS_FINAL SKC_BITS_TO_MASK_AT(1,31) |
| |
| SKC_STATIC_ASSERT(sizeof(union skc_styling_cmd) == sizeof(skc_uint)); |
| |
| // |
| // |
| // |
| |
| union skc_layer_node |
| { |
| skc_uint2 u32v2; |
| |
| struct { |
| skc_uint cmds; // starting index of sequence of command words |
| skc_group_id parent; // index of parent group |
| }; |
| }; |
| |
| SKC_STATIC_ASSERT(sizeof(union skc_layer_node) == sizeof(skc_uint2)); |
| |
| // |
| // |
| // |
| |
| union skc_group_parents |
| { |
| skc_uint2 u32v2; |
| |
| struct { |
| skc_uint depth; // zero-based depth of this group |
| skc_uint base; // index to sequence of group ids leading back to root |
| }; |
| }; |
| |
| SKC_STATIC_ASSERT(sizeof(union skc_group_parents) == sizeof(skc_uint2)); |
| |
| // |
| // inclusive layer range [lo,hi] |
| // |
| |
| union skc_group_range |
| { |
| skc_uint2 u32v2; |
| |
| struct { |
| skc_uint lo; // first layer |
| skc_uint hi; // last layer |
| }; |
| }; |
| |
| SKC_STATIC_ASSERT(sizeof(union skc_group_range) == sizeof(skc_uint2)); |
| |
| // |
| // |
| // |
| |
| struct skc_group_node |
| { |
| union skc_group_parents parents; // path of parent groups leading back to root |
| |
| union skc_group_range range; // range of layers enclosed by this group |
| |
| struct { |
| skc_uint enter; // starting index of sequence of command words |
| skc_uint leave; // starting index of sequence of command words |
| } cmds; |
| }; |
| |
| SKC_STATIC_ASSERT(sizeof(struct skc_group_node) == sizeof(skc_uint2) * 3); // 6 words |
| |
| // |
| // |
| // |
| |
| union skc_gradient_slope |
| { |
| skc_float slope; |
| skc_half color_pair[2]; |
| }; |
| |
| SKC_STATIC_ASSERT(sizeof(union skc_gradient_slope) == sizeof(skc_float)); |
| |
| // |
| // |
| // |
| |
| union skc_gradient_vector |
| { |
| skc_float4 f32v4; |
| |
| struct { |
| skc_float dx; |
| skc_float p0; |
| skc_float dy; |
| skc_float denom; |
| }; |
| |
| union skc_gradient_slope slopes[4]; |
| }; |
| |
| SKC_STATIC_ASSERT(sizeof(union skc_gradient_vector) == sizeof(skc_float4)); |
| |
| // |
| // FIXME -- will eventually need to know if this gradient is |
| // perspective transformed and if so additional values will need to be |
| // encoded |
| // |
| // VERSION 1 |
| // ============================================================= |
| // |
| // LINEAR GRADIENT HEADER FOR N STOPS |
| // |
| // +----------+----------+------------+----------+-------------+ |
| // | HEADER | INFO | LUTS | FLOORS | COLORS | |
| // +----------+----------+------------+----------+-------------+ |
| // | uintv4 | u32v2[1] | f32v2[N-1] | f32[N-2] | ushort2[4N] | |
| // +----------+----------+------------+----------+-------------+ |
| // |
| // COLOR PAIR WORD EXPANSION TOTAL |
| // +------------+---------------------------------+--------+-------------------------+ |
| // | ushort2 | 4 + 2 + 2*(N-1) + N - 2 + 4*N | 7N + 2 | = 7(N-1+1)+2 = 7(N-1)+9 | |
| // +------------+---------------------------------+--------+-------------------------+ |
| // |
| // COLOR LAYOUT: |
| // |
| // R[0]R[1], R[1]R[2], ... R[N-1]R[N-1] |
| // G[0]G[1], G[1]G[2], ... G[N-1]G[N-1] |
| // B[0]B[1], B[1]B[2], ... B[N-1]B[N-1] |
| // A[0]A[1], A[1]A[2], ... A[N-1]A[N-1] |
| // |
| // |
| // MINIMUM WORDS: N=2 --> 16 |
| // |
| // |
| // VERSION 2 |
| // ============================================================= |
| // |
| // LINEAR GRADIENT DESCRIPTOR FOR N STOPS |
| // |
| // +--------------- REMOVE ME LATER |
| // v |
| // +--------+------+-------+---+----------+-----------+ |
| // | VECTOR | TYPE | COUNT | N | SLOPES | COLORS | |
| // +--------+------+-------+---+----------+-----------+ |
| // | f32v4 | 1 | 1 | 1 | f32[N-1] | f16v2[4N] | |
| // +--------+------+-------+---+----------+-----------+ |
| // |
| // COLOR PAIR WORD EXPANSION TOTAL |
| // +------------+--------------------------------+--------+ |
| // | f16v2 | 4 + 1 + 1 + 1 + [N-1] + [4*N] | 5N + 6 | |
| // +------------+--------------------------------+--------+ |
| // |
| // COLOR LAYOUT: |
| // |
| // R[0]R[1], R[1]R[2], ... R[N-1]R[N-1] <-------------------------- FIXME -- USE HERB'S SINGLE FMA REPRESENTATION |
| // G[0]G[1], G[1]G[2], ... G[N-1]G[N-1] <-------------------------- FIXME -- USE HERB'S SINGLE FMA REPRESENTATION |
| // B[0]B[1], B[1]B[2], ... B[N-1]B[N-1] <-------------------------- FIXME -- USE HERB'S SINGLE FMA REPRESENTATION |
| // A[0]A[1], A[1]A[2], ... A[N-1]A[N-1] <-------------------------- FIXME -- USE HERB'S SINGLE FMA REPRESENTATION |
| // |
| // |
| // MINIMUM WORDS: N=2 --> 16 |
| // |
| // |
| // VERSION 3+ |
| // ============================================================= |
| // |
| // FIXME -- will probably want to try using the sampler/texture |
| // hardware to interpolate colors. |
| // |
| // This will require that the colors are laid out in sampler-friendly |
| // order: |
| // |
| // RGBA[0]RGBA[1], RGBA[1]RGBA[2], ..., RGBA[N-1]RGBA[N-1] |
| // |
| // |
| |
| #if 0 |
| #define SKC_GRADIENT_HEADER_WORDS_LUTS_OFFSET 4 |
| #define SKC_GRADIENT_HEADER_WORDS_TOTAL(n_minus_1) (7 * (n_minus_1) + 9) |
| #define SKC_GRADIENT_HEADER_WORDS_MIN SKC_GRADIENT_HEADER_WORDS_TOTAL(1) |
| #define SKC_GRADIENT_CMD_WORDS_V1(n) (1 + SKC_GRADIENT_HEADER_WORDS_TOTAL(n-1)) |
| #endif |
| |
| #define SKC_GRADIENT_CMD_WORDS_V1(n) (7 * (n) + 2) |
| #define SKC_GRADIENT_CMD_WORDS_V2(n) (5 * (n) + 6) |
| #define SKC_GRADIENT_CMD_WORDS_V2_ADJUST(v1,v2) (SKC_GRADIENT_CMD_WORDS_V1(v1) - ((v2) + 6)) |
| |
| // |
| // |
| // |
| |
| #endif |
| |
| // |
| // |
| // |
| |
| |