| /**************************************************************************** |
| * Copyright (C) 2014-2015 Intel Corporation. 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, sublicense, |
| * 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 NONINFRINGEMENT. IN NO EVENT SHALL |
| * THE AUTHORS OR COPYRIGHT HOLDERS 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. |
| * |
| * @file depthstencil.h |
| * |
| * @brief Implements depth/stencil functionality |
| * |
| ******************************************************************************/ |
| #pragma once |
| #include "common/os.h" |
| #include "format_conversion.h" |
| |
| INLINE |
| void StencilOp(SWR_STENCILOP op, simdscalar const &mask, simdscalar const &stencilRefps, simdscalar &stencilps) |
| { |
| simdscalari stencil = _simd_castps_si(stencilps); |
| |
| switch (op) |
| { |
| case STENCILOP_KEEP: |
| break; |
| case STENCILOP_ZERO: |
| stencilps = _simd_blendv_ps(stencilps, _simd_setzero_ps(), mask); |
| break; |
| case STENCILOP_REPLACE: |
| stencilps = _simd_blendv_ps(stencilps, stencilRefps, mask); |
| break; |
| case STENCILOP_INCRSAT: |
| { |
| simdscalari stencilincr = _simd_adds_epu8(stencil, _simd_set1_epi32(1)); |
| stencilps = _simd_blendv_ps(stencilps, _simd_castsi_ps(stencilincr), mask); |
| break; |
| } |
| case STENCILOP_DECRSAT: |
| { |
| simdscalari stencildecr = _simd_subs_epu8(stencil, _simd_set1_epi32(1)); |
| stencilps = _simd_blendv_ps(stencilps, _simd_castsi_ps(stencildecr), mask); |
| break; |
| } |
| case STENCILOP_INCR: |
| { |
| simdscalari stencilincr = _simd_add_epi8(stencil, _simd_set1_epi32(1)); |
| stencilps = _simd_blendv_ps(stencilps, _simd_castsi_ps(stencilincr), mask); |
| break; |
| } |
| case STENCILOP_DECR: |
| { |
| simdscalari stencildecr = _simd_add_epi8(stencil, _simd_set1_epi32((-1) & 0xff)); |
| stencilps = _simd_blendv_ps(stencilps, _simd_castsi_ps(stencildecr), mask); |
| break; |
| } |
| case STENCILOP_INVERT: |
| { |
| simdscalar stencilinvert = _simd_andnot_ps(stencilps, _simd_cmpeq_ps(_simd_setzero_ps(), _simd_setzero_ps())); |
| stencilps = _simd_blendv_ps(stencilps, stencilinvert, mask); |
| break; |
| } |
| default: |
| break; |
| } |
| } |
| |
| |
| template<SWR_FORMAT depthFormatT> |
| simdscalar QuantizeDepth(simdscalar const &depth) |
| { |
| SWR_TYPE depthType = FormatTraits<depthFormatT>::GetType(0); |
| uint32_t depthBpc = FormatTraits<depthFormatT>::GetBPC(0); |
| |
| if (depthType == SWR_TYPE_FLOAT) |
| { |
| // assume only 32bit float depth supported |
| SWR_ASSERT(depthBpc == 32); |
| |
| // matches shader precision, no quantizing needed |
| return depth; |
| } |
| |
| // should be unorm depth if not float |
| SWR_ASSERT(depthType == SWR_TYPE_UNORM); |
| |
| float quantize = (float)((1 << depthBpc) - 1); |
| simdscalar result = _simd_mul_ps(depth, _simd_set1_ps(quantize)); |
| result = _simd_add_ps(result, _simd_set1_ps(0.5f)); |
| result = _simd_round_ps(result, _MM_FROUND_TO_ZERO); |
| |
| if (depthBpc > 16) |
| { |
| result = _simd_div_ps(result, _simd_set1_ps(quantize)); |
| } |
| else |
| { |
| result = _simd_mul_ps(result, _simd_set1_ps(1.0f / quantize)); |
| } |
| |
| return result; |
| } |
| |
| INLINE |
| simdscalar DepthStencilTest(const API_STATE* pState, |
| bool frontFacing, uint32_t viewportIndex, simdscalar const &iZ, uint8_t* pDepthBase, simdscalar const &coverageMask, |
| uint8_t *pStencilBase, simdscalar* pStencilMask) |
| { |
| static_assert(KNOB_DEPTH_HOT_TILE_FORMAT == R32_FLOAT, "Unsupported depth hot tile format"); |
| static_assert(KNOB_STENCIL_HOT_TILE_FORMAT == R8_UINT, "Unsupported stencil hot tile format"); |
| |
| const SWR_DEPTH_STENCIL_STATE* pDSState = &pState->depthStencilState; |
| const SWR_VIEWPORT* pViewport = &pState->vp[viewportIndex]; |
| |
| simdscalar depthResult = _simd_set1_ps(-1.0f); |
| simdscalar zbuf; |
| |
| // clamp Z to viewport [minZ..maxZ] |
| simdscalar vMinZ = _simd_broadcast_ss(&pViewport->minZ); |
| simdscalar vMaxZ = _simd_broadcast_ss(&pViewport->maxZ); |
| simdscalar interpZ = _simd_min_ps(vMaxZ, _simd_max_ps(vMinZ, iZ)); |
| |
| if (pDSState->depthTestEnable) |
| { |
| switch (pDSState->depthTestFunc) |
| { |
| case ZFUNC_NEVER: depthResult = _simd_setzero_ps(); break; |
| case ZFUNC_ALWAYS: break; |
| default: |
| zbuf = _simd_load_ps((const float*)pDepthBase); |
| } |
| |
| switch (pDSState->depthTestFunc) |
| { |
| case ZFUNC_LE: depthResult = _simd_cmple_ps(interpZ, zbuf); break; |
| case ZFUNC_LT: depthResult = _simd_cmplt_ps(interpZ, zbuf); break; |
| case ZFUNC_GT: depthResult = _simd_cmpgt_ps(interpZ, zbuf); break; |
| case ZFUNC_GE: depthResult = _simd_cmpge_ps(interpZ, zbuf); break; |
| case ZFUNC_EQ: depthResult = _simd_cmpeq_ps(interpZ, zbuf); break; |
| case ZFUNC_NE: depthResult = _simd_cmpneq_ps(interpZ, zbuf); break; |
| } |
| } |
| |
| simdscalar stencilMask = _simd_set1_ps(-1.0f); |
| |
| if (pDSState->stencilTestEnable) |
| { |
| uint8_t stencilRefValue; |
| uint32_t stencilTestFunc; |
| uint8_t stencilTestMask; |
| if (frontFacing || !pDSState->doubleSidedStencilTestEnable) |
| { |
| stencilRefValue = pDSState->stencilRefValue; |
| stencilTestFunc = pDSState->stencilTestFunc; |
| stencilTestMask = pDSState->stencilTestMask; |
| } |
| else |
| { |
| stencilRefValue = pDSState->backfaceStencilRefValue; |
| stencilTestFunc = pDSState->backfaceStencilTestFunc; |
| stencilTestMask = pDSState->backfaceStencilTestMask; |
| } |
| |
| simdvector sbuf; |
| simdscalar stencilWithMask; |
| simdscalar stencilRef; |
| switch(stencilTestFunc) |
| { |
| case ZFUNC_NEVER: stencilMask = _simd_setzero_ps(); break; |
| case ZFUNC_ALWAYS: break; |
| default: |
| LoadSOA<R8_UINT>(pStencilBase, sbuf); |
| |
| // apply stencil read mask |
| stencilWithMask = _simd_castsi_ps(_simd_and_si(_simd_castps_si(sbuf.v[0]), _simd_set1_epi32(stencilTestMask))); |
| |
| // do stencil compare in float to avoid simd integer emulation in AVX1 |
| stencilWithMask = _simd_cvtepi32_ps(_simd_castps_si(stencilWithMask)); |
| |
| stencilRef = _simd_set1_ps((float)(stencilRefValue & stencilTestMask)); |
| break; |
| } |
| |
| switch(stencilTestFunc) |
| { |
| case ZFUNC_LE: stencilMask = _simd_cmple_ps(stencilRef, stencilWithMask); break; |
| case ZFUNC_LT: stencilMask = _simd_cmplt_ps(stencilRef, stencilWithMask); break; |
| case ZFUNC_GT: stencilMask = _simd_cmpgt_ps(stencilRef, stencilWithMask); break; |
| case ZFUNC_GE: stencilMask = _simd_cmpge_ps(stencilRef, stencilWithMask); break; |
| case ZFUNC_EQ: stencilMask = _simd_cmpeq_ps(stencilRef, stencilWithMask); break; |
| case ZFUNC_NE: stencilMask = _simd_cmpneq_ps(stencilRef, stencilWithMask); break; |
| } |
| } |
| |
| simdscalar depthWriteMask = _simd_and_ps(depthResult, stencilMask); |
| depthWriteMask = _simd_and_ps(depthWriteMask, coverageMask); |
| |
| *pStencilMask = stencilMask; |
| return depthWriteMask; |
| } |
| |
| INLINE |
| void DepthStencilWrite(const SWR_VIEWPORT* pViewport, const SWR_DEPTH_STENCIL_STATE* pDSState, |
| bool frontFacing, simdscalar const &iZ, uint8_t* pDepthBase, const simdscalar& depthMask, const simdscalar& coverageMask, |
| uint8_t *pStencilBase, const simdscalar& stencilMask) |
| { |
| if (pDSState->depthWriteEnable) |
| { |
| // clamp Z to viewport [minZ..maxZ] |
| simdscalar vMinZ = _simd_broadcast_ss(&pViewport->minZ); |
| simdscalar vMaxZ = _simd_broadcast_ss(&pViewport->maxZ); |
| simdscalar interpZ = _simd_min_ps(vMaxZ, _simd_max_ps(vMinZ, iZ)); |
| |
| simdscalar vMask = _simd_and_ps(depthMask, coverageMask); |
| _simd_maskstore_ps((float*)pDepthBase, _simd_castps_si(vMask), interpZ); |
| } |
| |
| if (pDSState->stencilWriteEnable) |
| { |
| simdvector sbuf; |
| LoadSOA<R8_UINT>(pStencilBase, sbuf); |
| simdscalar stencilbuf = sbuf.v[0]; |
| |
| uint8_t stencilRefValue; |
| uint32_t stencilFailOp; |
| uint32_t stencilPassDepthPassOp; |
| uint32_t stencilPassDepthFailOp; |
| uint8_t stencilWriteMask; |
| if (frontFacing || !pDSState->doubleSidedStencilTestEnable) |
| { |
| stencilRefValue = pDSState->stencilRefValue; |
| stencilFailOp = pDSState->stencilFailOp; |
| stencilPassDepthPassOp = pDSState->stencilPassDepthPassOp; |
| stencilPassDepthFailOp = pDSState->stencilPassDepthFailOp; |
| stencilWriteMask = pDSState->stencilWriteMask; |
| } |
| else |
| { |
| stencilRefValue = pDSState->backfaceStencilRefValue; |
| stencilFailOp = pDSState->backfaceStencilFailOp; |
| stencilPassDepthPassOp = pDSState->backfaceStencilPassDepthPassOp; |
| stencilPassDepthFailOp = pDSState->backfaceStencilPassDepthFailOp; |
| stencilWriteMask = pDSState->backfaceStencilWriteMask; |
| } |
| |
| simdscalar stencilps = stencilbuf; |
| simdscalar stencilRefps = _simd_castsi_ps(_simd_set1_epi32(stencilRefValue)); |
| |
| simdscalar stencilFailMask = _simd_andnot_ps(stencilMask, coverageMask); |
| simdscalar stencilPassDepthPassMask = _simd_and_ps(stencilMask, depthMask); |
| simdscalar stencilPassDepthFailMask = _simd_and_ps(stencilMask, _simd_andnot_ps(depthMask, _simd_set1_ps(-1))); |
| |
| simdscalar origStencil = stencilps; |
| |
| StencilOp((SWR_STENCILOP)stencilFailOp, stencilFailMask, stencilRefps, stencilps); |
| StencilOp((SWR_STENCILOP)stencilPassDepthFailOp, stencilPassDepthFailMask, stencilRefps, stencilps); |
| StencilOp((SWR_STENCILOP)stencilPassDepthPassOp, stencilPassDepthPassMask, stencilRefps, stencilps); |
| |
| // apply stencil write mask |
| simdscalari vWriteMask = _simd_set1_epi32(stencilWriteMask); |
| stencilps = _simd_and_ps(stencilps, _simd_castsi_ps(vWriteMask)); |
| stencilps = _simd_or_ps(_simd_andnot_ps(_simd_castsi_ps(vWriteMask), origStencil), stencilps); |
| |
| simdvector stencilResult; |
| stencilResult.v[0] = _simd_blendv_ps(origStencil, stencilps, coverageMask); |
| StoreSOA<R8_UINT>(stencilResult, pStencilBase); |
| } |
| |
| } |
