| /* |
| * 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_TILE |
| #define SKC_ONCE_TILE |
| |
| // |
| // |
| // |
| |
| #include "macros.h" |
| |
| // |
| // Hard requirements: |
| // |
| // - A TTXB "block pool" extent that is at least 1GB. |
| // |
| // - A virtual surface of at least 8K x 8K |
| // |
| // - A physical surface of __don't really care__ because it's |
| // advantageous to tile the physical surface since it's likely |
| // to shrink the post-place TTCK sorting step. |
| // |
| // |
| // EXTENT TTXB BITS |
| // SIZE (MB) +------------------------------------+ |
| // | 22 23 24 25 26 27 | |
| // +----+------------------------------------+ |
| // | 8 | 128 256 512 1024 2048 4096 | |
| // TTXB | 16 | 256 512 1024 2048 4096 8192 | |
| // WORDS | 32 | 512 1024 2048 4096 8192 16384 | |
| // | 64 | 1024 2048 4096 8192 16384 32768 | |
| // +----+------------------------------------+ |
| // |
| // |
| // SURF X/Y BITS |
| // TILE +------------------------------------------------------+ |
| // | 5 6 7 8 9 10 11 12 13 | |
| // +----+------------------------------------------------------+ |
| // | 3 | 256 512 1024 2048 4096 8192 16384 32768 65536 | |
| // TILE | 4 | 512 1024 2048 4096 8192 16384 32768 65536 128K | |
| // SIDE | 5 | 1024 2048 4096 8192 16384 32768 65536 128K 256K | |
| // BITS | 6 | 2048 4096 8192 16384 32768 65536 128K 256K 512K | |
| // | 7 | 4096 8192 16384 32768 65536 128K 256K 512K 1024K | |
| // +----+------------------------------------------------------+ |
| // TILES^2 | 1024 4096 16384 65536 256K 1M 4M 16M 64M | |
| // +------------------------------------------------------+ |
| // |
| // The following values should be pretty future-proof across all GPUs: |
| // |
| // - The minimum addressable subblock size is 16 words (64 bytes) to |
| // ensure there is enough space for a path or raster header and |
| // its payload. |
| // |
| // - Blocks are power-of-2 multiples of subblocks. Larger blocks can |
| // reduce allocation activity (fewer atomic adds). |
| // |
| // - 27 bits of TTXB_ID space implies a max of 4GB-32GB of |
| // rasterized paths depending on the size of the TTXB block. |
| // This could enable interesting use cases. |
| // |
| // - A virtual rasterization surface that's from +/-16K to +/-128K |
| // depending on the size of the TTXB block. |
| // |
| // - Keys that (optionally) only require a 32-bit high word |
| // comparison. |
| // |
| // - Support for a minimum of 256K layers. This can be practically |
| // raised to 1m or 2m layers. |
| // |
| |
| // |
| // TTRK (64-bit COMPARE) |
| // |
| // 0 63 |
| // | TTSB ID | X | Y | RASTER COHORT ID | |
| // +---------+------+------+------------------+ |
| // | 27 | 12 | 12 | 13 | |
| // |
| // |
| // TTRK (32-BIT COMPARE) ( DEFAULT ) |
| // |
| // 0 63 |
| // | TTSB ID | N/A | X | Y | RASTER COHORT ID | |
| // +---------+-----+------+------+------------------+ |
| // | 27 | 5 | 12 | 12 | 8 | |
| // |
| // |
| // TTSK v1 |
| // |
| // 0 63 |
| // | TTSB ID | IS_PREFIX | N/A | X | Y | |
| // +---------+-----------+------+----+----+ |
| // | 27 | 1 (=0) | 12 | 12 | 12 | |
| // |
| // |
| // TTPK v2 ( DEFAULT ) |
| // |
| // 0 63 |
| // | TTPB ID | IS_PREFIX | SPAN | X | Y | |
| // +---------+-----------+------+-----+-----+ |
| // | 27 | 1 (=1) | 12 | 12 | 12 | |
| // |
| // |
| // TTCK (32-BIT COMPARE) v1 |
| // |
| // 0 63 |
| // | PAYLOAD/TTSB/TTPB ID | PREFIX | ESCAPE | LAYER | X | Y | |
| // +----------------------+--------+--------+-------+-----+-----+ |
| // | 30 | 1 | 1 | 18 | 7 | 7 | |
| // |
| // |
| // TTCK (32-BIT COMPARE) v2 |
| // |
| // 0 63 |
| // | PAYLOAD/TTSB/TTPB ID | PREFIX | ESCAPE | LAYER | X | Y | |
| // +----------------------+--------+--------+-------+-----+-----+ |
| // | 30 | 1 | 1 | 15 | 9 | 8 | |
| // |
| // |
| // TTCK (64-BIT COMPARE) -- achieves 4K x 4K with an 8x16 tile ( DEFAULT ) |
| // |
| // 0 63 |
| // | PAYLOAD/TTSB/TTPB ID | PREFIX | ESCAPE | LAYER | X | Y | |
| // +----------------------+--------+--------+-------+-----+-----+ |
| // | 27 | 1 | 1 | 18 | 9 | 8 | |
| // |
| |
| // |
| // |
| // |
| |
| #define SKC_SUBPIXEL_RESL_X_LOG2 5 |
| #define SKC_SUBPIXEL_RESL_Y_LOG2 5 |
| |
| // |
| // FIXME -- COMMON -- HOIST ELSEWHERE |
| // |
| |
| #define SKC_TILE_WIDTH (1 << SKC_TILE_WIDTH_LOG2) |
| #define SKC_TILE_HEIGHT (1 << SKC_TILE_HEIGHT_LOG2) |
| |
| #define SKC_SUBPIXEL_RESL_X (1 << SKC_SUBPIXEL_RESL_X_LOG2) |
| #define SKC_SUBPIXEL_RESL_Y (1 << SKC_SUBPIXEL_RESL_Y_LOG2) |
| |
| // |
| // PLATFORM SURFACE TILE SIZE |
| // |
| |
| #define SKC_TILE_WIDTH_MASK SKC_BITS_TO_MASK(SKC_TILE_WIDTH_LOG2) |
| #define SKC_TILE_HEIGHT_MASK SKC_BITS_TO_MASK(SKC_TILE_HEIGHT_LOG2) |
| |
| // |
| // TILE SUBPIXEL RESOLUTION |
| // |
| |
| #define SKC_SUBPIXEL_RESL_X (1 << SKC_SUBPIXEL_RESL_X_LOG2) |
| #define SKC_SUBPIXEL_RESL_Y (1 << SKC_SUBPIXEL_RESL_Y_LOG2) |
| |
| #define SKC_SUBPIXEL_MASK_X SKC_BITS_TO_MASK(SKC_SUBPIXEL_RESL_X_LOG2) |
| #define SKC_SUBPIXEL_MASK_Y SKC_BITS_TO_MASK(SKC_SUBPIXEL_RESL_Y_LOG2) |
| |
| #define SKC_SUBPIXEL_RESL_X_F32 ((float)(SKC_SUBPIXEL_RESL_X)) |
| #define SKC_SUBPIXEL_RESL_Y_F32 ((float)(SKC_SUBPIXEL_RESL_Y)) |
| |
| #define SKC_SUBPIXEL_X_SCALE_UP SKC_SUBPIXEL_RESL_X_F32 |
| #define SKC_SUBPIXEL_Y_SCALE_UP SKC_SUBPIXEL_RESL_Y_F32 |
| |
| #define SKC_SUBPIXEL_X_SCALE_DOWN (1.0f / SKC_SUBPIXEL_RESL_X_F32) |
| #define SKC_SUBPIXEL_Y_SCALE_DOWN (1.0f / SKC_SUBPIXEL_RESL_Y_F32) |
| |
| // |
| // SUBTILE RESOLUTION |
| // |
| |
| #define SKC_SUBTILE_RESL_X_LOG2 (SKC_TILE_WIDTH_LOG2 + SKC_SUBPIXEL_RESL_X_LOG2) |
| #define SKC_SUBTILE_RESL_Y_LOG2 (SKC_TILE_HEIGHT_LOG2 + SKC_SUBPIXEL_RESL_Y_LOG2) |
| |
| #define SKC_SUBTILE_RESL_X (1 << SKC_SUBTILE_RESL_X_LOG2) |
| #define SKC_SUBTILE_RESL_Y (1 << SKC_SUBTILE_RESL_Y_LOG2) |
| |
| #define SKC_SUBTILE_MASK_X SKC_BITS_TO_MASK(SKC_SUBTILE_RESL_X_LOG2) |
| #define SKC_SUBTILE_MASK_Y SKC_BITS_TO_MASK(SKC_SUBTILE_RESL_Y_LOG2) |
| |
| #define SKC_SUBTILE_RESL_X_F32 ((float)(SKC_SUBTILE_RESL_X)) |
| #define SKC_SUBTILE_RESL_Y_F32 ((float)(SKC_SUBTILE_RESL_Y)) |
| |
| #define SKC_SUBTILE_X_SCALE_DOWN (1.0f / SKC_SUBTILE_RESL_X_F32) |
| #define SKC_SUBTILE_Y_SCALE_DOWN (1.0f / SKC_SUBTILE_RESL_Y_F32) |
| |
| // |
| // |
| // |
| |
| #define SKC_TILE_X_OFFSET_U32 (1 << (SKC_TTSK_BITS_X-1)) |
| #define SKC_TILE_X_SPAN_U32 (1 << (SKC_TTSK_BITS_X)) // exclusive |
| |
| #define SKC_TILE_Y_OFFSET_U32 (1 << (SKC_TTSK_BITS_Y-1)) |
| #define SKC_TILE_Y_SPAN_U32 (1 << (SKC_TTSK_BITS_Y)) // exclusive |
| |
| #define SKC_TILE_X_OFFSET_F32 0 // ((float)SKC_TILE_X_OFFSET_U32) |
| #define SKC_TILE_X_SPAN_F32 ((float)SKC_TILE_X_SPAN_U32) |
| |
| #define SKC_TILE_Y_OFFSET_F32 0 // ((float)SKC_TILE_Y_OFFSET_U32) |
| #define SKC_TILE_Y_SPAN_F32 ((float)SKC_TILE_Y_SPAN_U32) |
| |
| // |
| // TILE TRACE SUBPIXEL, PREFIX & COMPOSITION KEYS |
| // |
| // These keys are are purposefully 64-bits so they can be sorted with |
| // Hotsort's 32:32 or 64-bit implementation. |
| // |
| // Tiles are 32x32 on CUDA but can be made rectangular or smaller to |
| // fit other architectures. |
| // |
| // TW : tile width |
| // TH : tile height |
| // |
| // TTS : tile trace subpixel |
| // TTSB : tile trace subpixel block |
| // TTRK : tile trace subpixel key while in raster cohort |
| // TTSK : tile trace subpixel key |
| // |
| // TTP : tile trace prefix |
| // TTPB : tile trace prefix block |
| // TTPK : tile trace prefix key |
| // |
| // TTCK : tile trace composition key |
| // |
| |
| // |
| // TILE TRACE SUBPIXEL |
| // |
| // The subpixels are encoded with either absolute tile coordinates |
| // (32-bits) or packed in delta-encoded form form. |
| // |
| // For 32-bit subpixel packing of a 32x32 or smaller tile: |
| // |
| // A tile X is encoded as: |
| // |
| // TX : 10 : unsigned min(x0,x1) tile subpixel coordinate. |
| // |
| // SX : 6 : unsigned subpixel span from min to max x with range |
| // [0,32]. The original direction is not captured. Would |
| // be nice to capture dx but not necessary right now but |
| // could be in the future. <--- SPARE VALUES AVAILABLE |
| // |
| // A tile Y is encoded as: |
| // |
| // TY : 10 : unsigned min(y0,y1) tile subpixel coordinate. |
| // |
| // DY : 6 : signed subpixel delta y1-y0. The range of delta is |
| // [-32,32] but horizontal lines are not encoded so [1,32] |
| // is mapped to [0,31]. The resulting range [-32,31] fits |
| // in 6 bits. |
| // |
| // TTS: |
| // |
| // 0 31 |
| // | TX | SX | TY | DY | |
| // +-----+------+-----+------+ |
| // | 10 | 6 | 10 | 6 | |
| // |
| |
| #define SKC_TTS_BITS_TX 10 |
| #define SKC_TTS_BITS_SX 6 |
| #define SKC_TTS_BITS_TY 10 |
| #define SKC_TTS_BITS_SY 6 |
| |
| // |
| // |
| // |
| |
| #define SKC_TTS_INVALID ( SKC_UINT_MAX ) // relies on limited range of dx |
| |
| // |
| // |
| // |
| |
| #define SKC_TTS_OFFSET_SX (SKC_TTS_BITS_TX) |
| #define SKC_TTS_OFFSET_TY (SKC_TTS_BITS_TX + SKC_TTS_BITS_SX) |
| #define SKC_TTS_OFFSET_DY (SKC_TTS_BITS_TX + SKC_TTS_BITS_SX + SKC_TTS_BITS_TY) |
| |
| #define SKC_TTS_MASK_TX SKC_BITS_TO_MASK(SKC_TTS_BITS_TX) |
| #define SKC_TTS_MASK_SX SKC_BITS_TO_MASK_AT(SKC_TTS_BITS_SX,SKC_TTS_OFFSET_SX) |
| #define SKC_TTS_MASK_TY SKC_BITS_TO_MASK_AT(SKC_TTS_BITS_TY,SKC_TTS_OFFSET_TY) |
| |
| #define SKC_TTS_MASK_TX_PIXEL SKC_BITS_TO_MASK_AT(SKC_TTS_BITS_TX-SKC_SUBPIXEL_RESL_X_LOG2, \ |
| SKC_SUBPIXEL_RESL_X_LOG2) |
| #define SKC_TTS_MASK_TY_PIXEL SKC_BITS_TO_MASK_AT(SKC_TTS_BITS_TY-SKC_SUBPIXEL_RESL_Y_LOG2, \ |
| SKC_TTS_OFFSET_TY+SKC_SUBPIXEL_RESL_Y_LOG2) |
| |
| // |
| // TTRK (64-BIT COMPARE) |
| // |
| // 0 63 |
| // | TTSB ID | X | Y | COHORT ID | |
| // +---------+------+------+-----------+ |
| // | 27 | 12 | 12 | 13 | |
| // |
| // |
| // TTRK (32-BIT COMPARE) |
| // |
| // 0 63 |
| // | TTSB ID | N/A | X | Y | COHORT ID | |
| // +---------+-----+------+------+-----------+ |
| // | 27 | 5 | 12 | 12 | 8 | |
| // |
| |
| // |
| // TTRK is sortable intermediate key format for TTSK |
| // |
| // We're going to use the 32-bit comparison version for now |
| // |
| |
| // |
| // TTSK v2: |
| // |
| // 0 63 |
| // | TTSB ID | PREFIX | N/A | X | Y | |
| // +---------+--------+------+----+----+ |
| // | 27 | 1 (=0) | 12 | 12 | 12 | |
| // |
| // |
| // TTPK v2: |
| // |
| // 0 63 |
| // | TTPB ID | PREFIX | SPAN | X | Y | |
| // +---------+--------+------+-----+-----+ |
| // | 27 | 1 (=1) | 12 | 12 | 12 | |
| // |
| |
| #define SKC_TTXK_LO_BITS_ID 27 |
| #define SKC_TTXK_LO_BITS_PREFIX 1 |
| #define SKC_TTXK_HI_BITS_Y 12 |
| #define SKC_TTXK_HI_BITS_X 12 |
| #define SKC_TTXK_BITS_SPAN 12 |
| #define SKC_TTXK_HI_BITS_YX (SKC_TTXK_HI_BITS_Y + SKC_TTXK_HI_BITS_X) |
| |
| #define SKC_TTRK_HI_MASK_X SKC_BITS_TO_MASK(SKC_TTXK_HI_BITS_X) |
| #define SKC_TTRK_HI_MASK_YX SKC_BITS_TO_MASK(SKC_TTXK_HI_BITS_YX) |
| |
| #define SKC_TTRK_HI_BITS_COHORT 8 |
| #define SKC_TTRK_LO_BITS_NA (32 - SKC_TTXK_LO_BITS_ID) |
| #define SKC_TTRK_HI_BITS_COHORT_Y (SKC_TTRK_HI_BITS_COHORT + SKC_TTXK_HI_BITS_Y) |
| |
| #define SKC_TTRK_HI_OFFSET_COHORT (32 - SKC_TTRK_HI_BITS_COHORT) |
| #define SKC_TTRK_HI_MASK_COHORT SKC_BITS_TO_MASK_AT(SKC_TTRK_HI_BITS_COHORT,SKC_TTRK_HI_OFFSET_COHORT) |
| |
| #define SKC_TTRK_HI_BITS_COHORT_YX (SKC_TTRK_HI_BITS_COHORT + SKC_TTXK_HI_BITS_Y + SKC_TTXK_HI_BITS_X) |
| |
| #define SKC_TTXK_LO_BITS_ID_PREFIX (SKC_TTXK_LO_BITS_ID + SKC_TTXK_LO_BITS_PREFIX) |
| |
| #define SKC_TTXK_LO_OFFSET_PREFIX SKC_TTXK_LO_BITS_ID |
| #define SKC_TTXK_LO_OFFSET_SPAN SKC_TTXK_LO_BITS_ID_PREFIX |
| |
| #define SKC_TTXK_LO_BITS_SPAN (32 - SKC_TTXK_LO_BITS_ID_PREFIX) |
| #define SKC_TTXK_HI_BITS_SPAN (SKC_TTXK_BITS_SPAN - SKC_TTXK_LO_BITS_SPAN) |
| |
| #define SKC_TTXK_LO_OFFSET_PREFIX SKC_TTXK_LO_BITS_ID |
| |
| #define SKC_TTXK_LO_MASK_ID SKC_BITS_TO_MASK(SKC_TTXK_LO_BITS_ID) |
| #define SKC_TTXK_LO_MASK_PREFIX SKC_BITS_TO_MASK_AT(SKC_TTXK_LO_BITS_PREFIX,SKC_TTXK_LO_OFFSET_PREFIX) |
| #define SKC_TTXK_LO_MASK_ID_PREFIX SKC_BITS_TO_MASK(SKC_TTXK_LO_BITS_ID_PREFIX) |
| |
| #define SKC_TTXK_HI_OFFSET_Y (32 - SKC_TTXK_HI_BITS_Y) |
| #define SKC_TTXK_HI_OFFSET_X (SKC_TTXK_HI_OFFSET_Y - SKC_TTXK_HI_BITS_X) |
| |
| #define SKC_TTXK_HI_ONE_X (1u << SKC_TTXK_HI_OFFSET_X) |
| |
| #define SKC_TTXK_HI_MASK_YX SKC_BITS_TO_MASK_AT(SKC_TTXK_HI_BITS_YX,SKC_TTXK_HI_OFFSET_X) |
| #define SKC_TTXK_HI_MASK_Y SKC_BITS_TO_MASK_AT(SKC_TTXK_HI_BITS_Y ,SKC_TTXK_HI_OFFSET_Y) |
| |
| #define SKC_TTPK_LO_SHL_YX_SPAN (SKC_TTXK_LO_OFFSET_SPAN - SKC_TTXK_HI_OFFSET_X) |
| #define SKC_TTPK_HI_SHR_YX_SPAN (SKC_TTXK_HI_OFFSET_X + SKC_TTXK_LO_BITS_SPAN) |
| |
| // |
| // TTCK (32-BIT COMPARE) v1 -- NOT USED: |
| // |
| // 0 63 |
| // | PAYLOAD/TTSB/TTPB ID | PREFIX | ESCAPE | LAYER | X | Y | |
| // +----------------------+--------+--------+-------+-----+-----+ |
| // | 30 | 1 | 1 | 18 | 7 | 7 | |
| // |
| // |
| // TTCK (32-BIT COMPARE) v2 -- NOT USED: |
| // |
| // 0 63 |
| // | PAYLOAD/TTSB/TTPB ID | PREFIX | ESCAPE | LAYER | X | Y | |
| // +----------------------+--------+--------+-------+-----+-----+ |
| // | 30 | 1 | 1 | 15 | 9 | 8 | |
| // |
| // |
| // TTCK (64-BIT COMPARE) -- achieves 4K x 4K with an 8x16 tile: |
| // |
| // 0 63 |
| // | PAYLOAD/TTSB/TTPB ID | PREFIX | ESCAPE | LAYER | X | Y | |
| // +----------------------+--------+--------+-------+-----+-----+ |
| // | 27 | 1 | 1 | 18 | 9 | 8 | |
| // |
| |
| #define SKC_TTCK_BITS_LAYER 18 |
| |
| #define SKC_TTCK_LO_BITS_ID SKC_TTXK_LO_BITS_ID |
| #define SKC_TTCK_LO_OFFSET_ID 0 |
| |
| #define SKC_TTCK_LO_MASK_ID SKC_BITS_TO_MASK(SKC_TTCK_LO_BITS_ID) |
| |
| #define SKC_TTCK_LO_BITS_PREFIX 1 |
| #define SKC_TTCK_LO_OFFSET_PREFIX SKC_TTCK_LO_BITS_ID |
| #define SKC_TTCK_LO_MASK_PREFIX SKC_BITS_TO_MASK_AT(SKC_TTCK_LO_BITS_PREFIX,SKC_TTCK_LO_OFFSET_PREFIX) |
| |
| #define SKC_TTCK_LO_BITS_ID_PREFIX (SKC_TTCK_LO_BITS_ID + SKC_TTCK_LO_BITS_PREFIX) |
| #define SKC_TTCK_LO_MASK_ID_PREFIX SKC_BITS_TO_MASK(SKC_TTCK_LO_BITS_ID_PREFIX) |
| |
| #define SKC_TTCK_LO_BITS_ESCAPE 1 |
| #define SKC_TTCK_LO_OFFSET_ESCAPE SKC_TTCK_LO_BITS_ID_PREFIX |
| #define SKC_TTCK_LO_MASK_ESCAPE SKC_BITS_TO_MASK_AT(SKC_TTCK_LO_BITS_ESCAPE,SKC_TTCK_LO_OFFSET_ESCAPE) |
| |
| #define SKC_TTCK_LO_BITS_ID_PREFIX_ESCAPE (SKC_TTCK_LO_BITS_ID_PREFIX + SKC_TTCK_LO_BITS_ESCAPE) |
| |
| #define SKC_TTCK_HI_OFFSET_Y 24 |
| #define SKC_TTCK_HI_OFFSET_X 15 |
| |
| #define SKC_TTCK_HI_BITS_Y 8 |
| #define SKC_TTCK_HI_BITS_X 9 |
| #define SKC_TTCK_HI_BITS_YX (SKC_TTCK_HI_BITS_X + SKC_TTCK_HI_BITS_Y) |
| #define SKC_TTCK_HI_MASK_YX SKC_BITS_TO_MASK_AT(SKC_TTCK_HI_BITS_YX,SKC_TTCK_HI_OFFSET_X) |
| |
| #define SKC_TTCK_HI_BITS_LAYER (32 - SKC_TTCK_HI_BITS_YX) |
| #define SKC_TTCK_HI_MASK_LAYER SKC_BITS_TO_MASK(SKC_TTCK_HI_BITS_LAYER) |
| #define SKC_TTCK_HI_SHR_LAYER (SKC_TTCK_HI_BITS_Y + SKC_TTCK_HI_BITS_X + SKC_TTCK_BITS_LAYER - 32) |
| |
| #define SKC_TTCK_LO_BITS_LAYER (SKC_TTCK_BITS_LAYER - SKC_TTCK_HI_BITS_LAYER) |
| |
| // |
| // TILE COORD |
| // |
| // 0 32 |
| // | N/A | X | Y | |
| // +-----+-----+-----+ |
| // | 8 | 12 | 12 | |
| // |
| // |
| // This simplifies the clip test in the place kernel. |
| // |
| |
| union skc_tile_coord |
| { |
| skc_uint u32; |
| |
| struct { |
| #if defined(__OPENCL_C_VERSION__) |
| skc_uint xy; |
| #else |
| skc_uint na0 : 32 - SKC_TTXK_HI_BITS_YX; // 8 |
| skc_uint x : SKC_TTXK_HI_BITS_X; // 12 |
| skc_uint y : SKC_TTXK_HI_BITS_Y; // 12 |
| #endif |
| }; |
| }; |
| |
| SKC_STATIC_ASSERT(sizeof(union skc_tile_coord) == sizeof(skc_uint)); |
| |
| // |
| // |
| // |
| |
| union skc_tile_clip |
| { |
| skc_uint u32a2[2]; |
| |
| skc_uint2 u32v2; |
| |
| struct { |
| union skc_tile_coord xy0; // lower left |
| union skc_tile_coord xy1; // upper right |
| }; |
| }; |
| |
| SKC_STATIC_ASSERT(sizeof(union skc_tile_clip) == sizeof(skc_uint2)); |
| |
| // |
| // |
| // |
| |
| #endif |
| |
| // |
| // |
| // |
