mesa/vbo/vbo_save_draw.c

/*
 * Mesa 3-D graphics library
 *
 * Copyright (C) 1999-2008  Brian Paul   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 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.
 */

/* Author:
 *    Keith Whitwell <[email protected]>
 */

#include <stdbool.h>
#include "main/arrayobj.h"
#include "util/glheader.h"
#include "main/bufferobj.h"
#include "main/context.h"
#include "main/enable.h"
#include "main/mesa_private.h"
#include "main/macros.h"
#include "main/light.h"
#include "main/state.h"
#include "main/varray.h"
#include "util/bitscan.h"
#include "state_tracker/st_draw.h"
#include "pipe/p_context.h"

#include "vbo_private.h"

static void
copy_vao(struct gl_context *ctx, const struct gl_vertex_array_object *vao,
         GLbitfield mask, GLbitfield state, GLbitfield pop_state,
         int shift, fi_type **data, bool *color0_changed)
{
   struct vbo_context *vbo = vbo_context(ctx);

   mask &= vao->Enabled;
   while (mask) {
      const int i = u_bit_scan(&mask);
      const struct gl_array_attributes *attrib = &vao->VertexAttrib[i];
      unsigned current_index = shift + i;
      struct gl_array_attributes *currval = &vbo->current[current_index];
      const GLubyte size = attrib->Format.User.Size;
      const GLenum16 type = attrib->Format.User.Type;
      fi_type tmp[8];
      int dmul_shift = 0;

      if (type == GL_DOUBLE ||
          type == GL_UNSIGNED_INT64_ARB) {
         dmul_shift = 1;
         memcpy(tmp, *data, size * 2 * sizeof(GLfloat));
      } else {
         COPY_CLEAN_4V_TYPE_AS_UNION(tmp, size, *data, type);
      }

      if (memcmp(currval->Ptr, tmp, 4 * sizeof(GLfloat) << dmul_shift) != 0) {
         memcpy((fi_type*)currval->Ptr, tmp, 4 * sizeof(GLfloat) << dmul_shift);

         if (current_index == VBO_ATTRIB_COLOR0)
            *color0_changed = true;

         /* The fixed-func vertex program uses this. */
         if (current_index == VBO_ATTRIB_MAT_FRONT_SHININESS ||
             current_index == VBO_ATTRIB_MAT_BACK_SHININESS)
            ctx->NewState |= _NEW_FF_VERT_PROGRAM;

         if (current_index == VBO_ATTRIB_EDGEFLAG)
            _mesa_update_edgeflag_state_vao(ctx);

         ctx->NewState |= state;
         ctx->PopAttribState |= pop_state;
      }

      if (type != currval->Format.User.Type ||
          (size >> dmul_shift) != currval->Format.User.Size) {
         vbo_set_vertex_format(&currval->Format, size >> dmul_shift, type);
         /* The format changed. We need to update gallium vertex elements. */
         if (state == _NEW_CURRENT_ATTRIB)
            ctx->NewState |= state;
      }

      *data += size;
   }
}

/**
 * After playback, copy everything but the position from the
 * last vertex to the saved state
 */
static void
playback_copy_to_current(struct gl_context *ctx,
                         const struct vbo_save_vertex_list *node)
{
   if (!node->cold->current_data)
      return;

   fi_type *data = node->cold->current_data;
   bool color0_changed = false;

   /* Copy conventional attribs and generics except pos */
   copy_vao(ctx, node->cold->VAO[VP_MODE_SHADER], ~VERT_BIT_POS,
            _NEW_CURRENT_ATTRIB, GL_CURRENT_BIT, 0, &data, &color0_changed);
   /* Copy materials */
   copy_vao(ctx, node->cold->VAO[VP_MODE_FF], VERT_BIT_MAT_ALL,
            _NEW_MATERIAL, GL_LIGHTING_BIT,
            VBO_MATERIAL_SHIFT, &data, &color0_changed);

   if (color0_changed && ctx->Light.ColorMaterialEnabled) {
      _mesa_update_color_material(ctx, ctx->Current.Attrib[VBO_ATTRIB_COLOR0]);
   }

   /* CurrentExecPrimitive
    */
   if (node->cold->prim_count) {
      const struct _mesa_prim *prim = &node->cold->prims[node->cold->prim_count - 1];
      if (prim->end)
         ctx->Driver.CurrentExecPrimitive = PRIM_OUTSIDE_BEGIN_END;
      else
         ctx->Driver.CurrentExecPrimitive = prim->mode;
   }
}


static void
loopback_vertex_list(struct gl_context *ctx,
                     const struct vbo_save_vertex_list *list)
{
   struct gl_buffer_object *bo = list->cold->VAO[0]->BufferBinding[0].BufferObj;
   void *buffer = NULL;

   /* Reuse BO mapping when possible to avoid costly mapping on every glCallList(). */
   if (_mesa_bufferobj_mapped(bo, MAP_INTERNAL)) {
      if (list->cold->bo_bytes_used <= bo->Mappings[MAP_INTERNAL].Length)
         buffer = bo->Mappings[MAP_INTERNAL].Pointer;
      else
         _mesa_bufferobj_unmap(ctx, bo, MAP_INTERNAL);
   }

   if (!buffer && list->cold->bo_bytes_used)
      buffer = _mesa_bufferobj_map_range(ctx, 0, list->cold->bo_bytes_used, GL_MAP_READ_BIT,
                                         bo, MAP_INTERNAL);

   /* TODO: in this case, we shouldn't create a bo at all and instead keep
    * the in-RAM buffer. */
   _vbo_loopback_vertex_list(ctx, list, buffer);

   if (!ctx->Const.AllowMappedBuffersDuringExecution && buffer)
      _mesa_bufferobj_unmap(ctx, bo, MAP_INTERNAL);
}


void
vbo_save_playback_vertex_list_loopback(struct gl_context *ctx, void *data)
{
   const struct vbo_save_vertex_list *node =
      (const struct vbo_save_vertex_list *) data;

   FLUSH_FOR_DRAW(ctx);

   if (_mesa_inside_begin_end(ctx) && node->draw_begins) {
      /* Error: we're about to begin a new primitive but we're already
       * inside a glBegin/End pair.
       */
      _mesa_error(ctx, GL_INVALID_OPERATION,
                  "draw operation inside glBegin/End");
      return;
   }
   /* Various degenerate cases: translate into immediate mode
    * calls rather than trying to execute in place.
    */
   loopback_vertex_list(ctx, node);
}

enum vbo_save_status {
   DONE,
   USE_SLOW_PATH,
};

static enum vbo_save_status
vbo_save_playback_vertex_list_gallium(struct gl_context *ctx,
                                      const struct vbo_save_vertex_list *node,
                                      bool copy_to_current)
{
   /* Don't use this if selection or feedback mode is enabled. st/mesa can't
    * handle it.
    */
   if (!ctx->Const.HasDrawVertexState || ctx->RenderMode != GL_RENDER)
      return USE_SLOW_PATH;

   const gl_vertex_processing_mode mode = ctx->VertexProgram._VPMode;

   /* This sets which vertex arrays are enabled, which determines
    * which attribs have stride = 0 and whether edge flags are enabled.
    */
   const GLbitfield enabled = node->enabled_attribs[mode];
   _mesa_set_varying_vp_inputs(ctx, enabled);

   if (ctx->NewState)
      _mesa_update_state(ctx);

   /* Return precomputed GL errors such as invalid shaders. */
   if (!ctx->ValidPrimMask) {
      _mesa_error(ctx, ctx->DrawGLError, "glCallList");
      return DONE;
   }

   /* Use the slow path when there are vertex inputs without vertex
    * elements. This happens with zero-stride attribs and non-fixed-func
    * shaders.
    *
    * Dual-slot inputs are also unsupported because the higher slot is
    * always missing in vertex elements.
    *
    * TODO: Add support for zero-stride attribs.
    */
   struct gl_program *vp = ctx->VertexProgram._Current;

   if (vp->info.inputs_read & ~enabled || vp->DualSlotInputs)
      return USE_SLOW_PATH;

   struct pipe_vertex_state *state = node->state[mode];
   struct pipe_draw_vertex_state_info info;

   info.mode = node->mode;
   info.take_vertex_state_ownership = false;

   if (node->ctx == ctx) {
      /* This mechanism allows passing references to the driver without
       * using atomics to increase the reference count.
       *
       * This private refcount can be decremented without atomics but only
       * one context (ctx above) can use this counter (so that it's only
       * used by 1 thread).
       *
       * This number is atomically added to reference.count at
       * initialization. If it's never used, the same number is atomically
       * subtracted from reference.count before destruction. If this number
       * is decremented, we can pass one reference to the driver without
       * touching reference.count with atomics. At destruction we only
       * subtract the number of references we have not returned. This can
       * possibly turn a million atomic increments into 1 add and 1 subtract
       * atomic op over the whole lifetime of an app.
       */
      int16_t * const private_refcount = (int16_t*)&node->private_refcount[mode];
      assert(*private_refcount >= 0);

      if (unlikely(*private_refcount == 0)) {
         /* pipe_vertex_state can be reused through util_vertex_state_cache,
          * and there can be many display lists over-incrementing this number,
          * causing it to overflow.
          *
          * Guess that the same state can never be used by N=500000 display
          * lists, so one display list can only increment it by
          * INT_MAX / N.
          */
         const int16_t add_refs = INT_MAX / 500000;
         p_atomic_add(&state->reference.count, add_refs);
         *private_refcount = add_refs;
      }

      (*private_refcount)--;
      info.take_vertex_state_ownership = true;
   }

   /* Set edge flags. */
   _mesa_update_edgeflag_state_explicit(ctx, enabled & VERT_BIT_EDGEFLAG);

   st_prepare_draw(ctx, ST_PIPELINE_RENDER_STATE_MASK_NO_VARRAYS);

   struct pipe_context *pipe = ctx->pipe;
   uint32_t velem_mask = ctx->VertexProgram._Current->info.inputs_read;

   /* Fast path using a pre-built gallium vertex buffer state. */
   if (node->modes || node->num_draws > 1) {
      const struct pipe_draw_start_count_bias *draws = node->start_counts;
      const uint8_t *mode = node->modes;
      unsigned num_draws = node->num_draws;

      if (!mode) {
         pipe->draw_vertex_state(pipe, state, velem_mask, info, draws, num_draws);
      } else {
         /* Find consecutive draws where mode doesn't vary. */
         for (unsigned i = 0, first = 0; i <= num_draws; i++) {
            if (i == num_draws || mode[i] != mode[first]) {
               unsigned current_num_draws = i - first;

               /* Increase refcount to be able to use take_vertex_state_ownership
                * with all draws.
                */
               if (i != num_draws && info.take_vertex_state_ownership)
                  p_atomic_inc(&state->reference.count);

               info.mode = mode[first];
               pipe->draw_vertex_state(pipe, state, velem_mask, info, &draws[first],
                                       current_num_draws);
               first = i;
            }
         }
      }
   } else if (node->num_draws) {
      pipe->draw_vertex_state(pipe, state, velem_mask, info,
                              &node->start_count, 1);
   }

   /* Restore edge flag state and ctx->VertexProgram._VaryingInputs. */
   _mesa_update_edgeflag_state_vao(ctx);

   if (copy_to_current)
      playback_copy_to_current(ctx, node);
   return DONE;
}

/**
 * Execute the buffer and save copied verts.
 * This is called from the display list code when executing
 * a drawing command.
 */
void
vbo_save_playback_vertex_list(struct gl_context *ctx, void *data, bool copy_to_current)
{
   const struct vbo_save_vertex_list *node =
      (const struct vbo_save_vertex_list *) data;

   FLUSH_FOR_DRAW(ctx);

   if (_mesa_inside_begin_end(ctx) && node->draw_begins) {
      /* Error: we're about to begin a new primitive but we're already
       * inside a glBegin/End pair.
       */
      _mesa_error(ctx, GL_INVALID_OPERATION,
                  "draw operation inside glBegin/End");
      return;
   }

   if (vbo_save_playback_vertex_list_gallium(ctx, node, copy_to_current) == DONE)
      return;

   /* Save the Draw VAO before we override it. */
   const gl_vertex_processing_mode mode = ctx->VertexProgram._VPMode;
   GLbitfield vao_filter = _vbo_get_vao_filter(mode);
   struct gl_vertex_array_object *old_vao;
   GLbitfield old_vp_input_filter;

   _mesa_save_and_set_draw_vao(ctx, node->cold->VAO[mode], vao_filter,
                               &old_vao, &old_vp_input_filter);
   _mesa_set_varying_vp_inputs(ctx, vao_filter &
                               ctx->Array._DrawVAO->_EnabledWithMapMode);

   /* Need that at least one time. */
   if (ctx->NewState)
      _mesa_update_state(ctx);

   /* Return precomputed GL errors such as invalid shaders. */
   if (!ctx->ValidPrimMask) {
      _mesa_restore_draw_vao(ctx, old_vao, old_vp_input_filter);
      _mesa_error(ctx, ctx->DrawGLError, "glCallList");
      return;
   }

   assert(ctx->NewState == 0);

   struct pipe_draw_info *info = (struct pipe_draw_info *) &node->cold->info;

   st_prepare_draw(ctx, ST_PIPELINE_RENDER_STATE_MASK);

   if (node->modes) {
      ctx->Driver.DrawGalliumMultiMode(ctx, info,
                                       node->start_counts,
                                       node->modes,
                                       node->num_draws);
   } else if (node->num_draws == 1) {
      ctx->Driver.DrawGallium(ctx, info, 0, NULL, &node->start_count, 1);
   } else if (node->num_draws) {
      ctx->Driver.DrawGallium(ctx, info, 0, NULL, node->start_counts,
                              node->num_draws);
   }

   _mesa_restore_draw_vao(ctx, old_vao, old_vp_input_filter);

   if (copy_to_current)
      playback_copy_to_current(ctx, node);
}