예제 #1
0
static void
copy_miptrees(struct brw_context *brw,
              struct intel_mipmap_tree *src_mt,
              int src_x, int src_y, int src_z, unsigned src_level,
              struct intel_mipmap_tree *dst_mt,
              int dst_x, int dst_y, int dst_z, unsigned dst_level,
              int src_width, int src_height)
{
   unsigned bw, bh;

   if (brw->gen >= 6) {
      brw_blorp_copy_miptrees(brw,
                              src_mt, src_level, src_z,
                              dst_mt, dst_level, dst_z,
                              src_x, src_y, dst_x, dst_y,
                              src_width, src_height);
      return;
   }

   /* We are now going to try and copy the texture using the blitter.  If
    * that fails, we will fall back mapping the texture and using memcpy.
    * In either case, we need to do a full resolve.
    */
   intel_miptree_all_slices_resolve_hiz(brw, src_mt);
   intel_miptree_all_slices_resolve_depth(brw, src_mt);
   intel_miptree_resolve_color(brw, src_mt, 0);

   intel_miptree_all_slices_resolve_hiz(brw, dst_mt);
   intel_miptree_all_slices_resolve_depth(brw, dst_mt);
   intel_miptree_resolve_color(brw, dst_mt, 0);

   _mesa_get_format_block_size(src_mt->format, &bw, &bh);

   /* It's legal to have a WxH that's smaller than a compressed block. This
    * happens for example when you are using a higher level LOD. For this case,
    * we still want to copy the entire block, or else the decompression will be
    * incorrect.
    */
   if (src_width < bw)
      src_width = ALIGN_NPOT(src_width, bw);

   if (src_height < bh)
      src_height = ALIGN_NPOT(src_height, bh);

   if (copy_image_with_blitter(brw, src_mt, src_level,
                               src_x, src_y, src_z,
                               dst_mt, dst_level,
                               dst_x, dst_y, dst_z,
                               src_width, src_height))
      return;

   /* This is a worst-case scenario software fallback that maps the two
    * textures and does a memcpy between them.
    */
   copy_image_with_memcpy(brw, src_mt, src_level,
                          src_x, src_y, src_z,
                          dst_mt, dst_level,
                          dst_x, dst_y, dst_z,
                          src_width, src_height);
}
예제 #2
0
static void
intel_copy_image_sub_data(struct gl_context *ctx,
                          struct gl_texture_image *src_image,
                          int src_x, int src_y, int src_z,
                          struct gl_texture_image *dst_image,
                          int dst_x, int dst_y, int dst_z,
                          int src_width, int src_height)
{
   struct brw_context *brw = brw_context(ctx);
   struct intel_texture_image *intel_src_image = intel_texture_image(src_image);
   struct intel_texture_image *intel_dst_image = intel_texture_image(dst_image);

   if (_mesa_meta_CopyImageSubData_uncompressed(ctx,
                                                src_image, src_x, src_y, src_z,
                                                dst_image, dst_x, dst_y, dst_z,
                                                src_width, src_height)) {
      return;
   }

   if (intel_src_image->mt->num_samples > 0 ||
       intel_dst_image->mt->num_samples > 0) {
      _mesa_problem(ctx, "Failed to copy multisampled texture with meta path\n");
      return;
   }

   /* Cube maps actually have different images per face */
   if (src_image->TexObject->Target == GL_TEXTURE_CUBE_MAP)
      src_z = src_image->Face;
   if (dst_image->TexObject->Target == GL_TEXTURE_CUBE_MAP)
      dst_z = dst_image->Face;

   /* We are now going to try and copy the texture using the blitter.  If
    * that fails, we will fall back mapping the texture and using memcpy.
    * In either case, we need to do a full resolve.
    */
   intel_miptree_all_slices_resolve_hiz(brw, intel_src_image->mt);
   intel_miptree_all_slices_resolve_depth(brw, intel_src_image->mt);
   intel_miptree_resolve_color(brw, intel_src_image->mt);

   intel_miptree_all_slices_resolve_hiz(brw, intel_dst_image->mt);
   intel_miptree_all_slices_resolve_depth(brw, intel_dst_image->mt);
   intel_miptree_resolve_color(brw, intel_dst_image->mt);

   unsigned src_level = src_image->Level + src_image->TexObject->MinLevel;
   unsigned dst_level = dst_image->Level + dst_image->TexObject->MinLevel;
   if (copy_image_with_blitter(brw, intel_src_image->mt, src_level,
                               src_x, src_y, src_z,
                               intel_dst_image->mt, dst_level,
                               dst_x, dst_y, dst_z,
                               src_width, src_height))
      return;

   /* This is a worst-case scenario software fallback that maps the two
    * textures and does a memcpy between them.
    */
   copy_image_with_memcpy(brw, intel_src_image->mt, src_level,
                          src_x, src_y, src_z,
                          intel_dst_image->mt, dst_level,
                          dst_x, dst_y, dst_z,
                          src_width, src_height);
}