/**************************************************************************
*
* Copyright 2009 VMware, Inc. 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, sub license, 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 NON-INFRINGEMENT.
* IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS 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
* Surface utility functions.
*
* @author Brian Paul
*/
#include "pipe/p_defines.h"
#include "pipe/p_screen.h"
#include "pipe/p_state.h"
#include "util/u_format.h"
#include "util/u_inlines.h"
#include "util/u_rect.h"
#include "util/u_surface.h"
#include "util/u_pack_color.h"
/**
* Initialize a pipe_surface object. 'view' is considered to have
* uninitialized contents.
*/
void
u_surface_default_template(struct pipe_surface *surf,
const struct pipe_resource *texture)
{
memset(surf, 0, sizeof(*surf));
surf->format = texture->format;
}
/**
* Copy 2D rect from one place to another.
* Position and sizes are in pixels.
* src_stride may be negative to do vertical flip of pixels from source.
*/
void
util_copy_rect(ubyte * dst,
enum pipe_format format,
unsigned dst_stride,
unsigned dst_x,
unsigned dst_y,
unsigned width,
unsigned height,
const ubyte * src,
int src_stride,
unsigned src_x,
unsigned src_y)
{
unsigned i;
int src_stride_pos = src_stride < 0 ? -src_stride : src_stride;
int blocksize = util_format_get_blocksize(format);
int blockwidth = util_format_get_blockwidth(format);
int blockheight = util_format_get_blockheight(format);
assert(blocksize > 0);
assert(blockwidth > 0);
assert(blockheight > 0);
dst_x /= blockwidth;
dst_y /= blockheight;
width = (width + blockwidth - 1)/blockwidth;
height = (height + blockheight - 1)/blockheight;
src_x /= blockwidth;
src_y /= blockheight;
dst += dst_x * blocksize;
src += src_x * blocksize;
dst += dst_y * dst_stride;
src += src_y * src_stride_pos;
width *= blocksize;
if (width == dst_stride && width == (unsigned)src_stride)
memcpy(dst, src, height * width);
else {
for (i = 0; i < height; i++) {
memcpy(dst, src, width);
dst += dst_stride;
src += src_stride;
}
}
}
/**
* Copy 3D box from one place to another.
* Position and sizes are in pixels.
*/
void
util_copy_box(ubyte * dst,
enum pipe_format format,
unsigned dst_stride, unsigned dst_slice_stride,
unsigned dst_x, unsigned dst_y, unsigned dst_z,
unsigned width, unsigned height, unsigned depth,
const ubyte * src,
int src_stride, unsigned src_slice_stride,
unsigned src_x, unsigned src_y, unsigned src_z)
{
unsigned z;
dst += dst_z * dst_slice_stride;
src += src_z * src_slice_stride;
for (z = 0; z < depth; ++z) {
util_copy_rect(dst,
format,
dst_stride,
dst_x, dst_y,
width, height,
src,
src_stride,
src_x, src_y);
dst += dst_slice_stride;
src += src_slice_stride;
}
}
void
util_fill_rect(ubyte * dst,
enum pipe_format format,
unsigned dst_stride,
unsigned dst_x,
unsigned dst_y,
unsigned width,
unsigned height,
union util_color *uc)
{
const struct util_format_description *desc = util_format_description(format);
unsigned i, j;
unsigned width_size;
int blocksize = desc->block.bits / 8;
int blockwidth = desc->block.width;
int blockheight = desc->block.height;
assert(blocksize > 0);
assert(blockwidth > 0);
assert(blockheight > 0);
dst_x /= blockwidth;
dst_y /= blockheight;
width = (width + blockwidth - 1)/blockwidth;
height = (height + blockheight - 1)/blockheight;
dst += dst_x * blocksize;
dst += dst_y * dst_stride;
width_size = width * blocksize;
switch (blocksize) {
case 1:
if(dst_stride == width_size)
memset(dst, uc->ub, height * width_size);
else {
for (i = 0; i < height; i++) {
memset(dst, uc->ub, width_size);
dst += dst_stride;
}
}
break;
case 2:
for (i = 0; i < height; i++) {
uint16_t *row = (uint16_t *)dst;
for (j = 0; j < width; j++)
*row++ = uc->us;
dst += dst_stride;
}
break;
case 4:
for (i = 0; i < height; i++) {
uint32_t *row = (uint32_t *)dst;
for (j = 0; j < width; j++)
*row++ = uc->ui[0];
dst += dst_stride;
}
break;
default:
for (i = 0; i < height; i++) {
ubyte *row = dst;
for (j = 0; j < width; j++) {
memcpy(row, uc, blocksize);
row += blocksize;
}
dst += dst_stride;
}
break;
}
}
void
util_fill_box(ubyte * dst,
enum pipe_format format,
unsigned stride,
unsigned layer_stride,
unsigned x,
unsigned y,
unsigned z,
unsigned width,
unsigned height,
unsigned depth,
union util_color *uc)
{
unsigned layer;
dst += z * layer_stride;
for (layer = z; layer < depth; layer++) {
util_fill_rect(dst, format,
stride,
x, y, width, height, uc);
dst += layer_stride;
}
}
/**
* Fallback function for pipe->resource_copy_region().
* We support copying between different formats (including compressed/
* uncompressed) if the bytes per block or pixel matches. If copying
* compressed -> uncompressed, the dst region is reduced by the block
* width, height. If copying uncompressed -> compressed, the dest region
* is expanded by the block width, height. See GL_ARB_copy_image.
* Note: (X,Y)=(0,0) is always the upper-left corner.
*/
void
util_resource_copy_region(struct pipe_context *pipe,
struct pipe_resource *dst,
unsigned dst_level,
unsigned dst_x, unsigned dst_y, unsigned dst_z,
struct pipe_resource *src,
unsigned src_level,
const struct pipe_box *src_box_in)
{
struct pipe_transfer *src_trans, *dst_trans;
uint8_t *dst_map;
const uint8_t *src_map;
enum pipe_format src_format;
enum pipe_format dst_format;
struct pipe_box src_box, dst_box;
unsigned src_bs, dst_bs, src_bw, dst_bw, src_bh, dst_bh;
assert(src && dst);
if (!src || !dst)
return;
assert((src->target == PIPE_BUFFER && dst->target == PIPE_BUFFER) ||
(src->target != PIPE_BUFFER && dst->target != PIPE_BUFFER));
src_format = src->format;
dst_format = dst->format;
/* init src box */
src_box = *src_box_in;
/* init dst box */
dst_box.x = dst_x;
dst_box.y = dst_y;
dst_box.z = dst_z;
dst_box.width = src_box.width;
dst_box.height = src_box.height;
dst_box.depth = src_box.depth;
src_bs = util_format_get_blocksize(src_format);
src_bw = util_format_get_blockwidth(src_format);
src_bh = util_format_get_blockheight(src_format);
dst_bs = util_format_get_blocksize(dst_format);
dst_bw = util_format_get_blockwidth(dst_format);
dst_bh = util_format_get_blockheight(dst_format);
/* Note: all box positions and sizes are in pixels */
if (src_bw > 1 && dst_bw == 1) {
/* Copy from compressed to uncompressed.
* Shrink dest box by the src block size.
*/
dst_box.width /= src_bw;
dst_box.height /= src_bh;
}
else if (src_bw == 1 && dst_bw > 1) {
/* Copy from uncompressed to compressed.
* Expand dest box by the dest block size.
*/
dst_box.width *= dst_bw;
dst_box.height *= dst_bh;
}
else {
/* compressed -> compressed or uncompressed -> uncompressed copy */
assert(src_bw == dst_bw);
assert(src_bh == dst_bh);
}
assert(src_bs == dst_bs);
if (src_bs != dst_bs) {
/* This can happen if we fail to do format checking before hand.
* Don't crash below.
*/
return;
}
/* check that region boxes are block aligned */
assert(src_box.x % src_bw == 0);
assert(src_box.y % src_bh == 0);
assert(dst_box.x % dst_bw == 0);
assert(dst_box.y % dst_bh == 0);
/* check that region boxes are not out of bounds */
assert(src_box.x + src_box.width <= (int)u_minify(src->width0, src_level));
assert(src_box.y + src_box.height <= (int)u_minify(src->height0, src_level));
assert(dst_box.x + dst_box.width <= (int)u_minify(dst->width0, dst_level));
assert(dst_box.y + dst_box.height <= (int)u_minify(dst->height0, dst_level));
/* check that total number of src, dest bytes match */
assert((src_box.width / src_bw) * (src_box.height / src_bh) * src_bs ==
(dst_box.width / dst_bw) * (dst_box.height / dst_bh) * dst_bs);
src_map = pipe->transfer_map(pipe,
src,
src_level,
PIPE_TRANSFER_READ,
&src_box, &src_trans);
assert(src_map);
if (!src_map) {
goto no_src_map;
}
dst_map = pipe->transfer_map(pipe,
dst,
dst_level,
PIPE_TRANSFER_WRITE |
PIPE_TRANSFER_DISCARD_RANGE, &dst_box,
&dst_trans);
assert(dst_map);
if (!dst_map) {
goto no_dst_map;
}
if (dst->target == PIPE_BUFFER && src->target == PIPE_BUFFER) {
assert(src_box.height == 1);
assert(src_box.depth == 1);
memcpy(dst_map, src_map, src_box.width);
} else {
util_copy_box(dst_map,
src_format,
dst_trans->stride, dst_trans->layer_stride,
0, 0, 0,
src_box.width, src_box.height, src_box.depth,
src_map,
src_trans->stride, src_trans->layer_stride,
0, 0, 0);
}
pipe->transfer_unmap(pipe, dst_trans);
no_dst_map:
pipe->transfer_unmap(pipe, src_trans);
no_src_map:
;
}
static void
util_clear_color_texture_helper(struct pipe_transfer *dst_trans,
ubyte *dst_map,
enum pipe_format format,
const union pipe_color_union *color,
unsigned width, unsigned height, unsigned depth)
{
union util_color uc;
assert(dst_trans->stride > 0);
if (util_format_is_pure_integer(format)) {
/*
* We expect int/uint clear values here, though some APIs
* might disagree (but in any case util_pack_color()
* couldn't handle it)...
*/
if (util_format_is_pure_sint(format)) {
util_format_write_4i(format, color->i, 0, &uc, 0, 0, 0, 1, 1);
} else {
assert(util_format_is_pure_uint(format));
util_format_write_4ui(format, color->ui, 0, &uc, 0, 0, 0, 1, 1);
}
} else {
util_pack_color(color->f, format, &uc);
}
util_fill_box(dst_map, format,
dst_trans->stride, dst_trans->layer_stride,
0, 0, 0, width, height, depth, &uc);
}
static void
util_clear_color_texture(struct pipe_context *pipe,
struct pipe_resource *texture,
enum pipe_format format,
const union pipe_color_union *color,
unsigned level,
unsigned dstx, unsigned dsty, unsigned dstz,
unsigned width, unsigned height, unsigned depth)
{
struct pipe_transfer *dst_trans;
ubyte *dst_map;
dst_map = pipe_transfer_map_3d(pipe,
texture,
level,
PIPE_TRANSFER_WRITE,
dstx, dsty, dstz,
width, height, depth,
&dst_trans);
if (!dst_map)
return;
if (dst_trans->stride > 0) {
util_clear_color_texture_helper(dst_trans, dst_map, format, color,
width, height, depth);
}
pipe->transfer_unmap(pipe, dst_trans);
}
#define UBYTE_TO_USHORT(B) ((B) | ((B) << 8))
/**
* Fallback for pipe->clear_render_target() function.
* XXX this looks too hackish to be really useful.
* cpp > 4 looks like a gross hack at best...
* Plus can't use these transfer fallbacks when clearing
* multisampled surfaces for instance.
* Clears all bound layers.
*/
void
util_clear_render_target(struct pipe_context *pipe,
struct pipe_surface *dst,
const union pipe_color_union *color,
unsigned dstx, unsigned dsty,
unsigned width, unsigned height)
{
struct pipe_transfer *dst_trans;
ubyte *dst_map;
assert(dst->texture);
if (!dst->texture)
return;
if (dst->texture->target == PIPE_BUFFER) {
/*
* The fill naturally works on the surface format, however
* the transfer uses resource format which is just bytes for buffers.
*/
unsigned dx, w;
unsigned pixstride = util_format_get_blocksize(dst->format);
dx = (dst->u.buf.first_element + dstx) * pixstride;
w = width * pixstride;
dst_map = pipe_transfer_map(pipe,
dst->texture,
0, 0,
PIPE_TRANSFER_WRITE,
dx, 0, w, 1,
&dst_trans);
if (dst_map) {
util_clear_color_texture_helper(dst_trans, dst_map, dst->format,
color, width, height, 1);
pipe->transfer_unmap(pipe, dst_trans);
}
}
else {
unsigned depth = dst->u.tex.last_layer - dst->u.tex.first_layer + 1;
util_clear_color_texture(pipe, dst->texture, dst->format, color,
dst->u.tex.level, dstx, dsty,
dst->u.tex.first_layer, width, height, depth);
}
}
static void
util_clear_depth_stencil_texture(struct pipe_context *pipe,
struct pipe_resource *texture,
enum pipe_format format,
unsigned clear_flags,
uint64_t zstencil, unsigned level,
unsigned dstx, unsigned dsty, unsigned dstz,
unsigned width, unsigned height, unsigned depth)
{
struct pipe_transfer *dst_trans;
ubyte *dst_map;
boolean need_rmw = FALSE;
unsigned dst_stride;
ubyte *dst_layer;
unsigned i, j, layer;
if ((clear_flags & PIPE_CLEAR_DEPTHSTENCIL) &&
((clear_flags & PIPE_CLEAR_DEPTHSTENCIL) != PIPE_CLEAR_DEPTHSTENCIL) &&
util_format_is_depth_and_stencil(format))
need_rmw = TRUE;
dst_map = pipe_transfer_map_3d(pipe,
texture,
level,
(need_rmw ? PIPE_TRANSFER_READ_WRITE :
PIPE_TRANSFER_WRITE),
dstx, dsty, dstz,
width, height, depth, &dst_trans);
assert(dst_map);
if (!dst_map)
return;
dst_stride = dst_trans->stride;
dst_layer = dst_map;
assert(dst_trans->stride > 0);
for (layer = 0; layer < depth; layer++) {
dst_map = dst_layer;
switch (util_format_get_blocksize(format)) {
case 1:
assert(format == PIPE_FORMAT_S8_UINT);
if(dst_stride == width)
memset(dst_map, (uint8_t) zstencil, height * width);
else {
for (i = 0; i < height; i++) {
memset(dst_map, (uint8_t) zstencil, width);
dst_map += dst_stride;
}
}
break;
case 2:
assert(format == PIPE_FORMAT_Z16_UNORM);
for (i = 0; i < height; i++) {
uint16_t *row = (uint16_t *)dst_map;
for (j = 0; j < width; j++)
*row++ = (uint16_t) zstencil;
dst_map += dst_stride;
}
break;
case 4:
if (!need_rmw) {
for (i = 0; i < height; i++) {
uint32_t *row = (uint32_t *)dst_map;
for (j = 0; j < width; j++)
*row++ = (uint32_t) zstencil;
dst_map += dst_stride;
}
}
else {
uint32_t dst_mask;
if (format == PIPE_FORMAT_Z24_UNORM_S8_UINT)
dst_mask = 0x00ffffff;
else {
assert(format == PIPE_FORMAT_S8_UINT_Z24_UNORM);
dst_mask = 0xffffff00;
}
if (clear_flags & PIPE_CLEAR_DEPTH)
dst_mask = ~dst_mask;
for (i = 0; i < height; i++) {
uint32_t *row = (uint32_t *)dst_map;
for (j = 0; j < width; j++) {
uint32_t tmp = *row & dst_mask;
*row++ = tmp | ((uint32_t) zstencil & ~dst_mask);
}
dst_map += dst_stride;
}
}
break;
case 8:
if (!need_rmw) {
for (i = 0; i < height; i++) {
uint64_t *row = (uint64_t *)dst_map;
for (j = 0; j < width; j++)
*row++ = zstencil;
dst_map += dst_stride;
}
}
else {
uint64_t src_mask;
if (clear_flags & PIPE_CLEAR_DEPTH)
src_mask = 0x00000000ffffffffull;
else
src_mask = 0x000000ff00000000ull;
for (i = 0; i < height; i++) {
uint64_t *row = (uint64_t *)dst_map;
for (j = 0; j < width; j++) {
uint64_t tmp = *row & ~src_mask;
*row++ = tmp | (zstencil & src_mask);
}
dst_map += dst_stride;
}
}
break;
default:
assert(0);
break;
}
dst_layer += dst_trans->layer_stride;
}
pipe->transfer_unmap(pipe, dst_trans);
}
void
util_clear_texture(struct pipe_context *pipe,
struct pipe_resource *tex,
unsigned level,
const struct pipe_box *box,
const void *data)
{
const struct util_format_description *desc =
util_format_description(tex->format);
if (level > tex->last_level)
return;
if (util_format_is_depth_or_stencil(tex->format)) {
unsigned clear = 0;
float depth = 0.0f;
uint8_t stencil = 0;
uint64_t zstencil;
if (util_format_has_depth(desc)) {
clear |= PIPE_CLEAR_DEPTH;
desc->unpack_z_float(&depth, 0, data, 0, 1, 1);
}
if (util_format_has_stencil(desc)) {
clear |= PIPE_CLEAR_STENCIL;
desc->unpack_s_8uint(&stencil, 0, data, 0, 1, 1);
}
zstencil = util_pack64_z_stencil(tex->format, depth, stencil);
util_clear_depth_stencil_texture(pipe, tex, tex->format, clear, zstencil,
level, box->x, box->y, box->z,
box->width, box->height, box->depth);
} else {
union pipe_color_union color;
if (util_format_is_pure_uint(tex->format))
desc->unpack_rgba_uint(color.ui, 0, data, 0, 1, 1);
else if (util_format_is_pure_sint(tex->format))
desc->unpack_rgba_sint(color.i, 0, data, 0, 1, 1);
else
desc->unpack_rgba_float(color.f, 0, data, 0, 1, 1);
util_clear_color_texture(pipe, tex, tex->format, &color, level,
box->x, box->y, box->z,
box->width, box->height, box->depth);
}
}
/**
* Fallback for pipe->clear_stencil() function.
* sw fallback doesn't look terribly useful here.
* Plus can't use these transfer fallbacks when clearing
* multisampled surfaces for instance.
* Clears all bound layers.
*/
void
util_clear_depth_stencil(struct pipe_context *pipe,
struct pipe_surface *dst,
unsigned clear_flags,
double depth,
unsigned stencil,
unsigned dstx, unsigned dsty,
unsigned width, unsigned height)
{
uint64_t zstencil;
unsigned max_layer;
assert(dst->texture);
if (!dst->texture)
return;
zstencil = util_pack64_z_stencil(dst->format, depth, stencil);
max_layer = dst->u.tex.last_layer - dst->u.tex.first_layer;
util_clear_depth_stencil_texture(pipe, dst->texture, dst->format,
clear_flags, zstencil, dst->u.tex.level,
dstx, dsty, dst->u.tex.first_layer,
width, height, max_layer + 1);
}
/* Return if the box is totally inside the resource.
*/
static boolean
is_box_inside_resource(const struct pipe_resource *res,
const struct pipe_box *box,
unsigned level)
{
unsigned width = 1, height = 1, depth = 1;
switch (res->target) {
case PIPE_BUFFER:
width = res->width0;
height = 1;
depth = 1;
break;
case PIPE_TEXTURE_1D:
width = u_minify(res->width0, level);
height = 1;
depth = 1;
break;
case PIPE_TEXTURE_2D:
case PIPE_TEXTURE_RECT:
width = u_minify(res->width0, level);
height = u_minify(res->height0, level);
depth = 1;
break;
case PIPE_TEXTURE_3D:
width = u_minify(res->width0, level);
height = u_minify(res->height0, level);
depth = u_minify(res->depth0, level);
break;
case PIPE_TEXTURE_CUBE:
width = u_minify(res->width0, level);
height = u_minify(res->height0, level);
depth = 6;
break;
case PIPE_TEXTURE_1D_ARRAY:
width = u_minify(res->width0, level);
height = 1;
depth = res->array_size;
break;
case PIPE_TEXTURE_2D_ARRAY:
width = u_minify(res->width0, level);
height = u_minify(res->height0, level);
depth = res->array_size;
break;
case PIPE_TEXTURE_CUBE_ARRAY:
width = u_minify(res->width0, level);
height = u_minify(res->height0, level);
depth = res->array_size;
assert(res->array_size % 6 == 0);
break;
case PIPE_MAX_TEXTURE_TYPES:
break;
}
return box->x >= 0 &&
box->x + box->width <= (int) width &&
box->y >= 0 &&
box->y + box->height <= (int) height &&
box->z >= 0 &&
box->z + box->depth <= (int) depth;
}
static unsigned
get_sample_count(const struct pipe_resource *res)
{
return res->nr_samples ? res->nr_samples : 1;
}
/**
* Check if a blit() command can be implemented with a resource_copy_region().
* If tight_format_check is true, only allow the resource_copy_region() if
* the blit src/dst formats are identical, ignoring the resource formats.
* Otherwise, check for format casting and compatibility.
*/
boolean
util_can_blit_via_copy_region(const struct pipe_blit_info *blit,
boolean tight_format_check)
{
const struct util_format_description *src_desc, *dst_desc;
src_desc = util_format_description(blit->src.resource->format);
dst_desc = util_format_description(blit->dst.resource->format);
if (tight_format_check) {
/* no format conversions allowed */
if (blit->src.format != blit->dst.format) {
return FALSE;
}
}
else {
/* do loose format compatibility checking */
if (blit->src.resource->format != blit->src.format ||
blit->dst.resource->format != blit->dst.format ||
!util_is_format_compatible(src_desc, dst_desc)) {
return FALSE;
}
}
unsigned mask = util_format_get_mask(blit->dst.format);
/* No masks, no filtering, no scissor, no blending */
if ((blit->mask & mask) != mask ||
blit->filter != PIPE_TEX_FILTER_NEAREST ||
blit->scissor_enable ||
blit->num_window_rectangles > 0 ||
blit->alpha_blend) {
return FALSE;
}
/* Only the src box can have negative dims for flipping */
assert(blit->dst.box.width >= 1);
assert(blit->dst.box.height >= 1);
assert(blit->dst.box.depth >= 1);
/* No scaling or flipping */
if (blit->src.box.width != blit->dst.box.width ||
blit->src.box.height != blit->dst.box.height ||
blit->src.box.depth != blit->dst.box.depth) {
return FALSE;
}
/* No out-of-bounds access. */
if (!is_box_inside_resource(blit->src.resource, &blit->src.box,
blit->src.level) ||
!is_box_inside_resource(blit->dst.resource, &blit->dst.box,
blit->dst.level)) {
return FALSE;
}
/* Sample counts must match. */
if (get_sample_count(blit->src.resource) !=
get_sample_count(blit->dst.resource)) {
return FALSE;
}
return TRUE;
}
/**
* Try to do a blit using resource_copy_region. The function calls
* resource_copy_region if the blit description is compatible with it.
*
* It returns TRUE if the blit was done using resource_copy_region.
*
* It returns FALSE otherwise and the caller must fall back to a more generic
* codepath for the blit operation. (e.g. by using u_blitter)
*/
boolean
util_try_blit_via_copy_region(struct pipe_context *ctx,
const struct pipe_blit_info *blit)
{
if (util_can_blit_via_copy_region(blit, FALSE)) {
ctx->resource_copy_region(ctx, blit->dst.resource, blit->dst.level,
blit->dst.box.x, blit->dst.box.y,
blit->dst.box.z,
blit->src.resource, blit->src.level,
&blit->src.box);
return TRUE;
}
else {
return FALSE;
}
}