rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/frameworks/rs/driver/runtime/rs_sample.c

649 lines
22 KiB
C
Raw Blame History

#include "rs_core.rsh"
#include "rs_structs.h"
// 565 Conversion bits taken from SkBitmap
#define SK_R16_BITS 5
#define SK_G16_BITS 6
#define SK_B16_BITS 5
#define SK_R16_SHIFT (SK_B16_BITS + SK_G16_BITS)
#define SK_G16_SHIFT (SK_B16_BITS)
#define SK_B16_SHIFT 0
#define SK_R16_MASK ((1 << SK_R16_BITS) - 1)
#define SK_G16_MASK ((1 << SK_G16_BITS) - 1)
#define SK_B16_MASK ((1 << SK_B16_BITS) - 1)
#define SkGetPackedR16(color) (((unsigned)(color) >> SK_R16_SHIFT) & SK_R16_MASK)
#define SkGetPackedG16(color) (((unsigned)(color) >> SK_G16_SHIFT) & SK_G16_MASK)
#define SkGetPackedB16(color) (((unsigned)(color) >> SK_B16_SHIFT) & SK_B16_MASK)
static inline unsigned SkR16ToR32(unsigned r) {
return (r << (8 - SK_R16_BITS)) | (r >> (2 * SK_R16_BITS - 8));
}
static inline unsigned SkG16ToG32(unsigned g) {
return (g << (8 - SK_G16_BITS)) | (g >> (2 * SK_G16_BITS - 8));
}
static inline unsigned SkB16ToB32(unsigned b) {
return (b << (8 - SK_B16_BITS)) | (b >> (2 * SK_B16_BITS - 8));
}
#define SkPacked16ToR32(c) SkR16ToR32(SkGetPackedR16(c))
#define SkPacked16ToG32(c) SkG16ToG32(SkGetPackedG16(c))
#define SkPacked16ToB32(c) SkB16ToB32(SkGetPackedB16(c))
static float3 getFrom565(uint16_t color) {
float3 result;
result.x = (float)SkPacked16ToR32(color);
result.y = (float)SkPacked16ToG32(color);
result.z = (float)SkPacked16ToB32(color);
return result;
}
/**
* Allocation sampling
*/
static inline float __attribute__((overloadable))
getElementAt1(const uint8_t *p, int32_t x) {
float r = p[x];
return r;
}
static inline float2 __attribute__((overloadable))
getElementAt2(const uint8_t *p, int32_t x) {
x *= 2;
float2 r = {p[x], p[x+1]};
return r;
}
static inline float3 __attribute__((overloadable))
getElementAt3(const uint8_t *p, int32_t x) {
x *= 4;
float3 r = {p[x], p[x+1], p[x+2]};
return r;
}
static inline float4 __attribute__((overloadable))
getElementAt4(const uint8_t *p, int32_t x) {
x *= 4;
const uchar4 *p2 = (const uchar4 *)&p[x];
return convert_float4(p2[0]);
}
static inline float3 __attribute__((overloadable))
getElementAt565(const uint8_t *p, int32_t x) {
x *= 2;
float3 r = getFrom565(((const uint16_t *)p)[0]);
return r;
}
static inline float __attribute__((overloadable))
getElementAt1(const uint8_t *p, size_t stride, int32_t x, int32_t y) {
p += y * stride;
float r = p[x];
return r;
}
static inline float2 __attribute__((overloadable))
getElementAt2(const uint8_t *p, size_t stride, int32_t x, int32_t y) {
p += y * stride;
x *= 2;
float2 r = {p[x], p[x+1]};
return r;
}
static inline float3 __attribute__((overloadable))
getElementAt3(const uint8_t *p, size_t stride, int32_t x, int32_t y) {
p += y * stride;
x *= 4;
float3 r = {p[x], p[x+1], p[x+2]};
return r;
}
static inline float4 __attribute__((overloadable))
getElementAt4(const uint8_t *p, size_t stride, int32_t x, int32_t y) {
p += y * stride;
x *= 4;
float4 r = {p[x], p[x+1], p[x+2], p[x+3]};
return r;
}
static inline float3 __attribute__((overloadable))
getElementAt565(const uint8_t *p, size_t stride, int32_t x, int32_t y) {
p += y * stride;
x *= 2;
float3 r = getFrom565(((const uint16_t *)p)[0]);
return r;
}
static float4 __attribute__((overloadable))
getSample_A(const uint8_t *p, int32_t iPixel,
int32_t next, float w0, float w1) {
float p0 = getElementAt1(p, iPixel);
float p1 = getElementAt1(p, next);
float r = p0 * w0 + p1 * w1;
r *= (1.f / 255.f);
float4 ret = {0.f, 0.f, 0.f, r};
return ret;
}
static float4 __attribute__((overloadable))
getSample_L(const uint8_t *p, int32_t iPixel,
int32_t next, float w0, float w1) {
float p0 = getElementAt1(p, iPixel);
float p1 = getElementAt1(p, next);
float r = p0 * w0 + p1 * w1;
r *= (1.f / 255.f);
float4 ret = {r, r, r, 1.f};
return ret;
}
static float4 __attribute__((overloadable))
getSample_LA(const uint8_t *p, int32_t iPixel,
int32_t next, float w0, float w1) {
float2 p0 = getElementAt2(p, iPixel);
float2 p1 = getElementAt2(p, next);
float2 r = p0 * w0 + p1 * w1;
r *= (1.f / 255.f);
float4 ret = {r.x, r.x, r.x, r.y};
return ret;
}
static float4 __attribute__((overloadable))
getSample_RGB(const uint8_t *p, int32_t iPixel,
int32_t next, float w0, float w1) {
float3 p0 = getElementAt3(p, iPixel);
float3 p1 = getElementAt3(p, next);
float3 r = p0 * w0 + p1 * w1;
r *= (1.f / 255.f);
float4 ret = {r.x, r.x, r.z, 1.f};
return ret;
}
static float4 __attribute__((overloadable))
getSample_565(const uint8_t *p, int32_t iPixel,
int32_t next, float w0, float w1) {
float3 p0 = getElementAt565(p, iPixel);
float3 p1 = getElementAt565(p, next);
float3 r = p0 * w0 + p1 * w1;
r *= (1.f / 255.f);
float4 ret = {r.x, r.x, r.z, 1.f};
return ret;
}
static float4 __attribute__((overloadable))
getSample_RGBA(const uint8_t *p, int32_t iPixel,
int32_t next, float w0, float w1) {
float4 p0 = getElementAt4(p, iPixel);
float4 p1 = getElementAt4(p, next);
float4 r = p0 * w0 + p1 * w1;
r *= (1.f / 255.f);
return r;
}
static float4 __attribute__((overloadable))
getSample_A(const uint8_t *p, size_t stride,
int locX, int locY, int nextX, int nextY,
float w0, float w1, float w2, float w3) {
float p0 = getElementAt1(p, stride, locX, locY);
float p1 = getElementAt1(p, stride, nextX, locY);
float p2 = getElementAt1(p, stride, locX, nextY);
float p3 = getElementAt1(p, stride, nextX, nextY);
float r = p0 * w0 + p1 * w1 + p2 * w2 + p3 * w3;
r *= (1.f / 255.f);
float4 ret = {0.f, 0.f, 0.f, r};
return ret;
}
static float4 __attribute__((overloadable))
getSample_L(const uint8_t *p, size_t stride,
int locX, int locY, int nextX, int nextY,
float w0, float w1, float w2, float w3) {
float p0 = getElementAt1(p, stride, locX, locY);
float p1 = getElementAt1(p, stride, nextX, locY);
float p2 = getElementAt1(p, stride, locX, nextY);
float p3 = getElementAt1(p, stride, nextX, nextY);
float r = p0 * w0 + p1 * w1 + p2 * w2 + p3 * w3;
r *= (1.f / 255.f);
float4 ret = {r, r, r, 1.f};
return ret;
}
static float4 __attribute__((overloadable))
getSample_LA(const uint8_t *p, size_t stride,
int locX, int locY, int nextX, int nextY,
float w0, float w1, float w2, float w3) {
float2 p0 = getElementAt2(p, stride, locX, locY);
float2 p1 = getElementAt2(p, stride, nextX, locY);
float2 p2 = getElementAt2(p, stride, locX, nextY);
float2 p3 = getElementAt2(p, stride, nextX, nextY);
float2 r = p0 * w0 + p1 * w1 + p2 * w2 + p3 * w3;
r *= (1.f / 255.f);
float4 ret = {r.x, r.x, r.x, r.y};
return ret;
}
static float4 __attribute__((overloadable))
getSample_RGB(const uint8_t *p, size_t stride,
int locX, int locY, int nextX, int nextY,
float w0, float w1, float w2, float w3) {
float4 p0 = getElementAt4(p, stride, locX, locY);
float4 p1 = getElementAt4(p, stride, nextX, locY);
float4 p2 = getElementAt4(p, stride, locX, nextY);
float4 p3 = getElementAt4(p, stride, nextX, nextY);
float4 r = p0 * w0 + p1 * w1 + p2 * w2 + p3 * w3;
r *= (1.f / 255.f);
float4 ret = {r.x, r.y, r.z, 1.f};
return ret;
}
static float4 __attribute__((overloadable))
getSample_RGBA(const uint8_t *p, size_t stride,
int locX, int locY, int nextX, int nextY,
float w0, float w1, float w2, float w3) {
float4 p0 = getElementAt4(p, stride, locX, locY);
float4 p1 = getElementAt4(p, stride, nextX, locY);
float4 p2 = getElementAt4(p, stride, locX, nextY);
float4 p3 = getElementAt4(p, stride, nextX, nextY);
float4 r = p0 * w0 + p1 * w1 + p2 * w2 + p3 * w3;
r *= (1.f / 255.f);
return r;
}
static float4 __attribute__((overloadable))
getSample_565(const uint8_t *p, size_t stride,
int locX, int locY, int nextX, int nextY,
float w0, float w1, float w2, float w3) {
float3 p0 = getElementAt565(p, stride, locX, locY);
float3 p1 = getElementAt565(p, stride, nextX, locY);
float3 p2 = getElementAt565(p, stride, locX, nextY);
float3 p3 = getElementAt565(p, stride, nextX, nextY);
float3 r = p0 * w0 + p1 * w1 + p2 * w2 + p3 * w3;
r *= (1.f / 255.f);
float4 ret;
ret.rgb = r;
ret.w = 1.f;
return ret;
}
static float4 __attribute__((overloadable))
getBilinearSample1D(const Allocation_t *alloc, float2 weights,
uint32_t iPixel, uint32_t next,
rs_data_kind dk, rs_data_type dt, uint32_t lod) {
const uint8_t *p = (const uint8_t *)alloc->mHal.drvState.lod[lod].mallocPtr;
switch(dk) {
case RS_KIND_PIXEL_RGBA:
return getSample_RGBA(p, iPixel, next, weights.x, weights.y);
case RS_KIND_PIXEL_A:
return getSample_A(p, iPixel, next, weights.x, weights.y);
case RS_KIND_PIXEL_RGB:
if (dt == RS_TYPE_UNSIGNED_5_6_5) {
return getSample_565(p, iPixel, next, weights.x, weights.y);
}
return getSample_RGB(p, iPixel, next, weights.x, weights.y);
case RS_KIND_PIXEL_L:
return getSample_L(p, iPixel, next, weights.x, weights.y);
case RS_KIND_PIXEL_LA:
return getSample_LA(p, iPixel, next, weights.x, weights.y);
default:
//__builtin_unreachable();
break;
}
//__builtin_unreachable();
return 0.f;
}
static uint32_t wrapI(rs_sampler_value wrap, int32_t coord, int32_t size) {
if (wrap == RS_SAMPLER_WRAP) {
coord = coord % size;
if (coord < 0) {
coord += size;
}
}
if (wrap == RS_SAMPLER_MIRRORED_REPEAT) {
coord = coord % (size * 2);
if (coord < 0) {
coord = (size * 2) + coord;
}
if (coord >= size) {
coord = (size * 2 - 1) - coord;
}
}
return (uint32_t)max(0, min(coord, size - 1));
}
static float4 __attribute__((overloadable))
getBilinearSample2D(const Allocation_t *alloc, float w0, float w1, float w2, float w3,
int lx, int ly, int nx, int ny,
rs_data_kind dk, rs_data_type dt, uint32_t lod) {
const uint8_t *p = (const uint8_t *)alloc->mHal.drvState.lod[lod].mallocPtr;
size_t stride = alloc->mHal.drvState.lod[lod].stride;
switch(dk) {
case RS_KIND_PIXEL_RGBA:
return getSample_RGBA(p, stride, lx, ly, nx, ny, w0, w1, w2, w3);
case RS_KIND_PIXEL_A:
return getSample_A(p, stride, lx, ly, nx, ny, w0, w1, w2, w3);
case RS_KIND_PIXEL_LA:
return getSample_LA(p, stride, lx, ly, nx, ny, w0, w1, w2, w3);
case RS_KIND_PIXEL_RGB:
if (dt == RS_TYPE_UNSIGNED_5_6_5) {
return getSample_565(p, stride, lx, ly, nx, ny, w0, w1, w2, w3);
}
return getSample_RGB(p, stride, lx, ly, nx, ny, w0, w1, w2, w3);
case RS_KIND_PIXEL_L:
return getSample_L(p, stride, lx, ly, nx, ny, w0, w1, w2, w3);
default:
break;
}
return 0.f;
}
static float4 __attribute__((overloadable))
getNearestSample(const Allocation_t *alloc, uint32_t iPixel, rs_data_kind dk,
rs_data_type dt, uint32_t lod) {
const uint8_t *p = (const uint8_t *)alloc->mHal.drvState.lod[lod].mallocPtr;
float4 result = {0.f, 0.f, 0.f, 255.f};
switch(dk) {
case RS_KIND_PIXEL_RGBA:
result = getElementAt4(p, iPixel);
break;
case RS_KIND_PIXEL_A:
result.w = getElementAt1(p, iPixel);
break;
case RS_KIND_PIXEL_LA:
result.zw = getElementAt2(p, iPixel);
result.xy = result.z;
break;
case RS_KIND_PIXEL_RGB:
if (dt == RS_TYPE_UNSIGNED_5_6_5) {
result.xyz = getElementAt565(p, iPixel);
} else {
result.xyz = getElementAt3(p, iPixel);
}
break;
case RS_KIND_PIXEL_L:
result.xyz = getElementAt1(p, iPixel);
default:
//__builtin_unreachable();
break;
}
return result * 0.003921569f;
}
static float4 __attribute__((overloadable))
getNearestSample(const Allocation_t *alloc, uint2 iPixel, rs_data_kind dk,
rs_data_type dt, uint32_t lod) {
const uint8_t *p = (const uint8_t *)alloc->mHal.drvState.lod[lod].mallocPtr;
size_t stride = alloc->mHal.drvState.lod[lod].stride;
float4 result = {0.f, 0.f, 0.f, 255.f};
switch(dk) {
case RS_KIND_PIXEL_RGBA:
result = getElementAt4(p, stride, iPixel.x, iPixel.y);
break;
case RS_KIND_PIXEL_A:
result.w = getElementAt1(p, stride, iPixel.x, iPixel.y);
break;
case RS_KIND_PIXEL_LA:
result.zw = getElementAt2(p, stride, iPixel.x, iPixel.y);
result.xy = result.z;
break;
case RS_KIND_PIXEL_RGB:
if (dt == RS_TYPE_UNSIGNED_5_6_5) {
result.xyz = getElementAt565(p, stride, iPixel.x, iPixel.y);
} else {
result.xyz = getElementAt3(p, stride, iPixel.x, iPixel.y);
}
break;
default:
//__builtin_unreachable();
break;
}
return result * 0.003921569f;
}
static float4 __attribute__((overloadable))
sample_LOD_LinearPixel(const Allocation_t *alloc,
rs_data_kind dk, rs_data_type dt,
rs_sampler_value wrapS,
float uv, uint32_t lod) {
int32_t sourceW = alloc->mHal.drvState.lod[lod].dimX;
float pixelUV = uv * (float)(sourceW);
int32_t iPixel = floor(pixelUV);
float frac = pixelUV - (float)iPixel;
if (frac < 0.5f) {
iPixel -= 1;
frac += 0.5f;
} else {
frac -= 0.5f;
}
float oneMinusFrac = 1.0f - frac;
float2 weights;
weights.x = oneMinusFrac;
weights.y = frac;
uint32_t next = wrapI(wrapS, iPixel + 1, sourceW);
uint32_t location = wrapI(wrapS, iPixel, sourceW);
return getBilinearSample1D(alloc, weights, location, next, dk, dt, lod);
}
static float4 __attribute__((overloadable))
sample_LOD_NearestPixel(const Allocation_t *alloc,
rs_data_kind dk, rs_data_type dt,
rs_sampler_value wrapS,
float uv, uint32_t lod) {
int32_t sourceW = alloc->mHal.drvState.lod[lod].dimX;
int32_t iPixel = floor(uv * (float)(sourceW));
uint32_t location = wrapI(wrapS, iPixel, sourceW);
return getNearestSample(alloc, location, dk, dt, lod);
}
static float4 __attribute__((overloadable))
sample_LOD_LinearPixel(const Allocation_t *alloc,
rs_data_kind dk, rs_data_type dt,
rs_sampler_value wrapS,
rs_sampler_value wrapT,
float2 uv, uint32_t lod) {
int sourceW = alloc->mHal.drvState.lod[lod].dimX;
int sourceH = alloc->mHal.drvState.lod[lod].dimY;
float pixelU = uv.x * sourceW;
float pixelV = uv.y * sourceH;
int iPixelU = floor(pixelU);
int iPixelV = floor(pixelV);
float fracU = pixelU - iPixelU;
float fracV = pixelV - iPixelV;
if (fracU < 0.5f) {
iPixelU -= 1;
fracU += 0.5f;
} else {
fracU -= 0.5f;
}
if (fracV < 0.5f) {
iPixelV -= 1;
fracV += 0.5f;
} else {
fracV -= 0.5f;
}
float oneMinusFracU = 1.0f - fracU;
float oneMinusFracV = 1.0f - fracV;
float w0 = oneMinusFracU * oneMinusFracV;
float w1 = fracU * oneMinusFracV;
float w2 = oneMinusFracU * fracV;
float w3 = fracU * fracV;
int nx = wrapI(wrapS, iPixelU + 1, sourceW);
int ny = wrapI(wrapT, iPixelV + 1, sourceH);
int lx = wrapI(wrapS, iPixelU, sourceW);
int ly = wrapI(wrapT, iPixelV, sourceH);
return getBilinearSample2D(alloc, w0, w1, w2, w3, lx, ly, nx, ny, dk, dt, lod);
}
static float4 __attribute__((overloadable))
sample_LOD_NearestPixel(const Allocation_t *alloc,
rs_data_kind dk, rs_data_type dt,
rs_sampler_value wrapS,
rs_sampler_value wrapT,
float2 uv, uint32_t lod) {
int sourceW = alloc->mHal.drvState.lod[lod].dimX;
int sourceH = alloc->mHal.drvState.lod[lod].dimY;
float2 dimF;
dimF.x = (float)(sourceW);
dimF.y = (float)(sourceH);
int2 iPixel = convert_int2(floor(uv * dimF));
uint2 location;
location.x = wrapI(wrapS, iPixel.x, sourceW);
location.y = wrapI(wrapT, iPixel.y, sourceH);
return getNearestSample(alloc, location, dk, dt, lod);
}
extern float4 __attribute__((overloadable))
rsSample(rs_allocation a, rs_sampler s, float uv, float lod) {
const Allocation_t *alloc = (const Allocation_t *)a.p;
const Sampler_t *prog = (Sampler_t *)s.p;
const Type_t *type = (Type_t *)alloc->mHal.state.type;
const Element_t *elem = type->mHal.state.element;
rs_data_kind dk = elem->mHal.state.dataKind;
rs_data_type dt = elem->mHal.state.dataType;
rs_sampler_value sampleMin = prog->mHal.state.minFilter;
rs_sampler_value sampleMag = prog->mHal.state.magFilter;
rs_sampler_value wrapS = prog->mHal.state.wrapS;
if (!(alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE)) {
return 0.f;
}
if (lod <= 0.0f) {
if (sampleMag == RS_SAMPLER_NEAREST) {
return sample_LOD_NearestPixel(alloc, dk, dt, wrapS, uv, 0);
}
return sample_LOD_LinearPixel(alloc, dk, dt, wrapS, uv, 0);
}
if (sampleMin == RS_SAMPLER_LINEAR_MIP_NEAREST) {
uint32_t maxLOD = type->mHal.state.lodCount - 1;
lod = min(lod, (float)maxLOD);
uint32_t nearestLOD = (uint32_t)round(lod);
return sample_LOD_LinearPixel(alloc, dk, dt, wrapS, uv, nearestLOD);
}
if (sampleMin == RS_SAMPLER_LINEAR_MIP_LINEAR) {
uint32_t lod0 = (uint32_t)floor(lod);
uint32_t lod1 = (uint32_t)ceil(lod);
uint32_t maxLOD = type->mHal.state.lodCount - 1;
lod0 = min(lod0, maxLOD);
lod1 = min(lod1, maxLOD);
float4 sample0 = sample_LOD_LinearPixel(alloc, dk, dt, wrapS, uv, lod0);
float4 sample1 = sample_LOD_LinearPixel(alloc, dk, dt, wrapS, uv, lod1);
float frac = lod - (float)lod0;
return sample0 * (1.0f - frac) + sample1 * frac;
}
return sample_LOD_NearestPixel(alloc, dk, dt, wrapS, uv, 0);
}
extern float4 __attribute__((overloadable))
rsSample(rs_allocation a, rs_sampler s, float location) {
return rsSample(a, s, location, 0);
}
extern float4 __attribute__((overloadable))
rsSample(rs_allocation a, rs_sampler s, float2 uv, float lod) {
const Allocation_t *alloc = (const Allocation_t *)a.p;
const Sampler_t *prog = (Sampler_t *)s.p;
const Type_t *type = (Type_t *)alloc->mHal.state.type;
const Element_t *elem = type->mHal.state.element;
rs_data_kind dk = elem->mHal.state.dataKind;
rs_data_type dt = elem->mHal.state.dataType;
rs_sampler_value sampleMin = prog->mHal.state.minFilter;
rs_sampler_value sampleMag = prog->mHal.state.magFilter;
rs_sampler_value wrapS = prog->mHal.state.wrapS;
rs_sampler_value wrapT = prog->mHal.state.wrapT;
if (!(alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE)) {
return 0.f;
}
if (lod <= 0.0f) {
if (sampleMag == RS_SAMPLER_NEAREST) {
return sample_LOD_NearestPixel(alloc, dk, dt, wrapS, wrapT, uv, 0);
}
return sample_LOD_LinearPixel(alloc, dk, dt, wrapS, wrapT, uv, 0);
}
if (sampleMin == RS_SAMPLER_LINEAR_MIP_NEAREST) {
uint32_t maxLOD = type->mHal.state.lodCount - 1;
lod = min(lod, (float)maxLOD);
uint32_t nearestLOD = (uint32_t)round(lod);
return sample_LOD_LinearPixel(alloc, dk, dt, wrapS, wrapT, uv, nearestLOD);
}
if (sampleMin == RS_SAMPLER_LINEAR_MIP_LINEAR) {
uint32_t lod0 = (uint32_t)floor(lod);
uint32_t lod1 = (uint32_t)ceil(lod);
uint32_t maxLOD = type->mHal.state.lodCount - 1;
lod0 = min(lod0, maxLOD);
lod1 = min(lod1, maxLOD);
float4 sample0 = sample_LOD_LinearPixel(alloc, dk, dt, wrapS, wrapT, uv, lod0);
float4 sample1 = sample_LOD_LinearPixel(alloc, dk, dt, wrapS, wrapT, uv, lod1);
float frac = lod - (float)lod0;
return sample0 * (1.0f - frac) + sample1 * frac;
}
return sample_LOD_NearestPixel(alloc, dk, dt, wrapS, wrapT, uv, 0);
}
extern float4 __attribute__((overloadable))
rsSample(rs_allocation a, rs_sampler s, float2 uv) {
const Allocation_t *alloc = (const Allocation_t *)a.p;
const Sampler_t *prog = (Sampler_t *)s.p;
const Type_t *type = (Type_t *)alloc->mHal.state.type;
const Element_t *elem = type->mHal.state.element;
rs_data_kind dk = elem->mHal.state.dataKind;
rs_data_type dt = elem->mHal.state.dataType;
rs_sampler_value wrapS = prog->mHal.state.wrapS;
rs_sampler_value wrapT = prog->mHal.state.wrapT;
if (!(alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE)) {
return 0.f;
}
if (prog->mHal.state.magFilter == RS_SAMPLER_NEAREST) {
return sample_LOD_NearestPixel(alloc, dk, dt, wrapS, wrapT, uv, 0);
}
return sample_LOD_LinearPixel(alloc, dk, dt, wrapS, wrapT, uv, 0);
}
Reference in New Issue View Git Blame Copy Permalink