| /* |
| * Copyright 2016 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can |
| * be found in the LICENSE file. |
| * |
| */ |
| |
| #include <memory.h> |
| |
| #include "styling.h" |
| #include "styling_types.h" |
| #include "skc.h" |
| |
| // |
| // FIXME -- x86'isms are temporary |
| // |
| |
| #include <immintrin.h> |
| |
| // |
| // |
| // |
| |
| skc_err |
| skc_styling_retain(skc_styling_t styling) |
| { |
| styling->ref_count += 1; |
| |
| return SKC_ERR_SUCCESS; |
| } |
| |
| skc_err |
| skc_styling_release(skc_styling_t styling) |
| { |
| // |
| // blocks and waits if grid is active |
| // |
| styling->release(styling->impl); |
| |
| return SKC_ERR_SUCCESS; |
| } |
| |
| skc_err |
| skc_styling_seal(skc_styling_t styling) |
| { |
| // |
| // no-op if sealed |
| // |
| styling->seal(styling->impl); |
| |
| return SKC_ERR_SUCCESS; |
| } |
| |
| skc_err |
| skc_styling_unseal(skc_styling_t styling) |
| { |
| // |
| // no-op if unsealed |
| // blocks and waits if sealed and grid is active |
| // |
| styling->unseal(styling->impl,false); |
| |
| return SKC_ERR_SUCCESS; |
| } |
| |
| skc_err |
| skc_styling_reset(skc_styling_t styling) |
| { |
| styling->unseal(styling->impl,true); |
| |
| styling->layers.count = 0; |
| styling->groups.count = 0; |
| styling->extras.count = 0; |
| |
| return SKC_ERR_SUCCESS; |
| } |
| |
| // |
| // FIXME -- various robustifications can be made to this builder but |
| // we don't want to make this heavyweight too soon |
| // |
| // - out of range layer_id is an error |
| // - extras[] overflow is an error |
| // |
| |
| skc_err |
| skc_styling_group_alloc(skc_styling_t styling, |
| skc_group_id * group_id) |
| { |
| styling->unseal(styling->impl,true); |
| |
| *group_id = styling->groups.count++; |
| |
| return SKC_ERR_SUCCESS; |
| } |
| |
| skc_err |
| skc_styling_group_enter(skc_styling_t styling, |
| skc_group_id group_id, |
| uint32_t n, |
| skc_styling_cmd_t const * cmds) |
| { |
| styling->unseal(styling->impl,true); |
| |
| styling->groups.extent[group_id].cmds.enter = styling->extras.count; |
| |
| memcpy(styling->extras.extent + styling->extras.count,cmds,n * sizeof(*cmds)); |
| |
| styling->extras.count += n; |
| |
| return SKC_ERR_SUCCESS; |
| } |
| |
| skc_err |
| skc_styling_group_leave(skc_styling_t styling, |
| skc_group_id group_id, |
| uint32_t n, |
| skc_styling_cmd_t const * cmds) |
| { |
| styling->unseal(styling->impl,true); |
| |
| styling->groups.extent[group_id].cmds.leave = styling->extras.count; |
| |
| memcpy(styling->extras.extent + styling->extras.count,cmds,n * sizeof(*cmds)); |
| |
| styling->extras.count += n; |
| |
| return SKC_ERR_SUCCESS; |
| } |
| |
| skc_err |
| skc_styling_group_parents(skc_styling_t styling, |
| skc_group_id group_id, |
| uint32_t n, |
| skc_group_id const * parents) |
| { |
| styling->unseal(styling->impl,true); |
| |
| styling->groups.extent[group_id].parents = (union skc_group_parents) |
| { |
| .depth = n, // starts at 0 |
| .base = styling->extras.count |
| }; |
| |
| while (n-- > 0) |
| styling->extras.extent[styling->extras.count++].parent = parents[n]; |
| |
| return SKC_ERR_SUCCESS; |
| } |
| |
| skc_err |
| skc_styling_group_range_lo(skc_styling_t styling, |
| skc_group_id group_id, |
| skc_layer_id layer_lo) |
| { |
| styling->unseal(styling->impl,true); |
| |
| styling->groups.extent[group_id].range.lo = layer_lo; |
| |
| return SKC_ERR_SUCCESS; |
| } |
| |
| skc_err |
| skc_styling_group_range_hi(skc_styling_t styling, |
| skc_group_id group_id, |
| skc_layer_id layer_hi) |
| { |
| styling->unseal(styling->impl,true); |
| |
| styling->groups.extent[group_id].range.hi = layer_hi; |
| |
| return SKC_ERR_SUCCESS; |
| } |
| |
| skc_err |
| skc_styling_group_layer(skc_styling_t styling, |
| skc_group_id group_id, |
| skc_layer_id layer_id, |
| uint32_t n, |
| skc_styling_cmd_t const * cmds) |
| { |
| styling->unseal(styling->impl,true); |
| |
| styling->layers.extent[layer_id] = (union skc_layer_node) |
| { |
| .cmds = styling->extras.count, |
| .parent = group_id |
| }; |
| |
| memcpy(styling->extras.extent + styling->extras.count,cmds,n * sizeof(*cmds)); |
| |
| styling->extras.count += n; |
| |
| return SKC_ERR_SUCCESS; |
| } |
| |
| // |
| // FIXME -- get rid of these x86'isms ASAP -- let compiler figure it |
| // out with a vector type |
| // |
| |
| static |
| __m128i |
| skc_convert_colors_4(float const * const colors) |
| { |
| __m128i c; |
| |
| c = _mm_cvtps_ph(*(__m128*)colors,0); |
| |
| return c; |
| } |
| |
| static |
| __m128i |
| skc_convert_colors_8(float const * const colors) |
| { |
| __m128i c; |
| |
| c = _mm256_cvtps_ph(*(__m256*)colors,0); |
| |
| return c; |
| } |
| |
| // |
| // |
| // |
| |
| static |
| void |
| skc_styling_layer_cmd_rgba_encoder(skc_styling_cmd_t * const cmds, |
| skc_styling_opcode_e const opcode, |
| float const rgba[4]) |
| { |
| __m128i const c = skc_convert_colors_4(rgba); |
| |
| cmds[0] = opcode; |
| cmds[1] = c.m128i_u32[0]; |
| cmds[2] = c.m128i_u32[1]; |
| } |
| |
| void |
| skc_styling_background_over_encoder(skc_styling_cmd_t * cmds, float const rgba[4]) |
| { |
| skc_styling_layer_cmd_rgba_encoder(cmds,SKC_STYLING_OPCODE_BACKGROUND_OVER,rgba); |
| } |
| |
| void |
| skc_styling_layer_fill_rgba_encoder(skc_styling_cmd_t * cmds, float const rgba[4]) |
| { |
| // encode a solid fill |
| skc_styling_layer_cmd_rgba_encoder(cmds,SKC_STYLING_OPCODE_COLOR_FILL_SOLID,rgba); |
| } |
| |
| // |
| // |
| // |
| |
| void |
| skc_styling_layer_fill_gradient_encoder(skc_styling_cmd_t * cmds, |
| float x0, |
| float y0, |
| float x1, |
| float y1, |
| skc_styling_gradient_type_e type, |
| uint32_t n, |
| float const stops[], |
| float const colors[]) |
| { |
| union skc_styling_cmd * const cmds_u = (union skc_styling_cmd *)cmds; |
| |
| // |
| // encode a gradient fill |
| // |
| cmds_u[0].opcode = SKC_STYLING_OPCODE_COLOR_FILL_GRADIENT_LINEAR; |
| |
| float const dx = x1 - x0; |
| float const dy = y1 - y0; |
| float const c1 = x0 * dx + y0 * dy; |
| float const c2 = x1 * dx + y1 * dy; |
| |
| cmds_u[1].f32 = dx; // dx |
| cmds_u[2].f32 = -c1; // p0 |
| cmds_u[3].f32 = dy; // dy |
| cmds_u[4].f32 = 1.0f / (c2 - c1); // denom |
| |
| // |
| // store type |
| // |
| cmds_u[5].gradient_type = type; |
| |
| // |
| // Write out slopes |
| // |
| // Note: make sure that that the first and last stop pairs don't |
| // have a span of zero. Why? Because it's meaningless and the |
| // zero-span stops can simply be dropped. |
| // |
| // And obviously the stops need to monotonically increasing. |
| // |
| // These validations can be perfomed elsewhere. |
| // |
| // After a pile of simple algebra the slope necessary to map a stop |
| // percentage on [0,1] to an INDEX.LERP real number from [0.0,N.0] |
| // is simply: |
| // |
| // delta_stop_prev |
| // slope_curr = --------------- - 1 |
| // delta_stop_curr |
| // |
| // Each delta stop equal to zero reduces the stop count by 1. |
| // |
| // Note that color pairs are what's stored so this simplified |
| // representation works for both linear gradients with non-zero |
| // delta stops and linear gradients that double-up the stops in |
| // order to produce "stripes". |
| // |
| float ds_prev = stops[1] - stops[0]; |
| union skc_styling_cmd * const slopes = cmds_u + 8; |
| |
| slopes[0].f32 = 1.0f / ds_prev; |
| |
| uint32_t ds_count = 1; |
| |
| for (uint32_t ii=1; ii<n-1; ii++) |
| { |
| float const ds_curr = stops[ii+1] - stops[ii]; |
| |
| if (ds_curr > 0.0f) |
| { |
| slopes[ds_count++].f32 = ds_prev / ds_curr - 1.0f; |
| ds_prev = ds_curr; |
| } |
| } |
| |
| // |
| // save a potentially compressed delta slope count |
| // |
| cmds_u[6].u32 = ds_count; |
| cmds_u[7].u32 = n; // REMOVE ME -------------------------------------------- REMOVE |
| |
| // |
| // FIXME -- encode color pair as a single color diff as noted by HERB @ CHAP <------------- FIXME |
| // |
| |
| // |
| // write out color pairs while skipping delta stops equal to zero |
| // |
| uint32_t const color_count = ds_count + 1; |
| |
| union skc_styling_cmd * color_r = cmds_u + 8 + ds_count; |
| union skc_styling_cmd * color_g = color_r + color_count; |
| union skc_styling_cmd * color_b = color_r + color_count * 2; |
| union skc_styling_cmd * color_a = color_r + color_count * 3; |
| |
| for (uint32_t ii=0; ii<n-1; ii++) |
| { |
| if (stops[ii+1] > stops[ii]) |
| { |
| __m128i const c = skc_convert_colors_8(colors+ii*4); |
| |
| color_r->u16v2.lo = c.m128i_u16[0]; |
| color_r->u16v2.hi = c.m128i_u16[4]; |
| color_g->u16v2.lo = c.m128i_u16[1]; |
| color_g->u16v2.hi = c.m128i_u16[5]; |
| color_b->u16v2.lo = c.m128i_u16[2]; |
| color_b->u16v2.hi = c.m128i_u16[6]; |
| color_a->u16v2.lo = c.m128i_u16[3]; |
| color_a->u16v2.hi = c.m128i_u16[7]; |
| |
| ++color_r; |
| ++color_g; |
| ++color_b; |
| ++color_a; |
| } |
| } |
| |
| float laststop[8]; // sentinel to lerp against same color |
| |
| for (int ii=0; ii<4; ii++) |
| laststop[ii+4] = laststop[ii] = colors[(n-1)*4+ii]; |
| |
| __m128i const c = skc_convert_colors_8(laststop); |
| |
| color_r->u16v2.lo = c.m128i_u16[0]; |
| color_r->u16v2.hi = c.m128i_u16[4]; |
| color_g->u16v2.lo = c.m128i_u16[1]; |
| color_g->u16v2.hi = c.m128i_u16[5]; |
| color_b->u16v2.lo = c.m128i_u16[2]; |
| color_b->u16v2.hi = c.m128i_u16[6]; |
| color_a->u16v2.lo = c.m128i_u16[3]; |
| color_a->u16v2.hi = c.m128i_u16[7]; |
| } |
| |
| // |
| // |
| // |
