/**************************************************************************
 *
 * Copyright 2007 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.
 *
 **************************************************************************/

 /*
  * Authors:
  *   Keith Whitwell <keithw@vmware.com>
  */

#ifndef DRAW_PT_H
#define DRAW_PT_H

#include "pipe/p_compiler.h"

struct draw_pt_middle_end;
struct draw_context;
struct draw_prim_info;
struct draw_vertex_info;


#define PT_SHADE      0x1
#define PT_CLIPTEST   0x2
#define PT_PIPELINE   0x4
#define PT_MAX_MIDDLE 0x8


/* The "front end" - prepare sets of fetch, draw elements for the
 * middle end.
 *
 * The fetch elements are indices to the vertices.  The draw elements are
 * indices to the fetched vertices.  When both arrays of elements are both
 * linear, middle->run_linear is called;  When only the fetch elements are
 * linear, middle->run_linear_elts is called;  Otherwise, middle->run is
 * called.
 *
 * When the number of the draw elements exceeds max_vertex of the middle end,
 * the draw elements (as well as the fetch elements) are splitted and the
 * middle end is called multiple times.
 *
 * Currenly there is:
 *    - vsplit - catchall implementation, splits big prims
 */
struct draw_pt_front_end {
   void (*prepare)(struct draw_pt_front_end *,
                   enum pipe_prim_type prim,
                   struct draw_pt_middle_end *,
                   unsigned opt);

   void (*run)(struct draw_pt_front_end *,
               unsigned start,
               unsigned count);

   void (*flush)(struct draw_pt_front_end *, unsigned flags);
   void (*destroy)(struct draw_pt_front_end *);
};


/* The "middle end" - prepares actual hardware vertices for the
 * hardware backend.
 *
 * prim_flags is as defined by pipe_draw_info::flags.
 *
 * Currently two versions of this:
 *     - fetch, vertex shade, cliptest, prim-pipeline
 *     - fetch, emit (ie passthrough)
 */
struct draw_pt_middle_end {
   void (*prepare)(struct draw_pt_middle_end *,
                   enum pipe_prim_type prim,
                   unsigned opt,
                   unsigned *max_vertices);

   /**
    * Bind/update parameter state such as constants, viewport dims
    * and clip planes.  Basically, stuff which isn't "baked" into the
    * shader or pipeline state.
    */
   void (*bind_parameters)(struct draw_pt_middle_end *);

   void (*run)(struct draw_pt_middle_end *,
               const unsigned *fetch_elts,
               unsigned fetch_count,
               const ushort *draw_elts,
               unsigned draw_count,
               unsigned prim_flags);

   void (*run_linear)(struct draw_pt_middle_end *,
                      unsigned start,
                      unsigned count,
                      unsigned prim_flags);

   /* Transform all vertices in a linear range and then draw them with
    * the supplied element list.  May fail and return FALSE.
    */
   boolean (*run_linear_elts)(struct draw_pt_middle_end *,
                              unsigned fetch_start,
                              unsigned fetch_count,
                              const ushort *draw_elts,
                              unsigned draw_count,
                              unsigned prim_flags);

   int (*get_max_vertex_count)(struct draw_pt_middle_end *);

   void (*finish)(struct draw_pt_middle_end *);
   void (*destroy)(struct draw_pt_middle_end *);
};


/* The "back end" - supplied by the driver, defined in draw_vbuf.h.
 */
struct vbuf_render;
struct vertex_header;


/* Frontends:
 *
 * Currently only the general-purpose vsplit implementation.
 */
struct draw_pt_front_end *draw_pt_vsplit(struct draw_context *draw);


/* Middle-ends:
 *
 * Currently one general-purpose case which can do all possibilities,
 * at the slight expense of creating a vertex_header in some cases
 * unecessarily.
 */
struct draw_pt_middle_end *draw_pt_middle_fse(struct draw_context *draw);
struct draw_pt_middle_end *draw_pt_fetch_pipeline_or_emit(struct draw_context *draw);
struct draw_pt_middle_end *draw_pt_fetch_pipeline_or_emit_llvm(struct draw_context *draw);



/*******************************************************************************
 * HW vertex emit:
 */
struct pt_emit;

void
draw_pt_emit_prepare(struct pt_emit *emit,
                     enum pipe_prim_type prim,
                     unsigned *max_vertices);

void
draw_pt_emit(struct pt_emit *emit,
             const struct draw_vertex_info *vert_info,
             const struct draw_prim_info *prim_info);

void
draw_pt_emit_linear(struct pt_emit *emit,
                    const struct draw_vertex_info *vert_info,
                    const struct draw_prim_info *prim_info);

void
draw_pt_emit_destroy(struct pt_emit *emit);

struct pt_emit *
draw_pt_emit_create(struct draw_context *draw);


/*******************************************************************************
 * HW stream output emit:
 */
struct pt_so_emit;

void
draw_pt_so_emit_prepare(struct pt_so_emit *emit, boolean use_pre_clip_pos);

void
draw_pt_so_emit(struct pt_so_emit *emit,
                int num_vertex_streams,
                const struct draw_vertex_info *vert_info,
                const struct draw_prim_info *prim_info);

void
draw_pt_so_emit_destroy(struct pt_so_emit *emit);

struct pt_so_emit *
draw_pt_so_emit_create(struct draw_context *draw);


/*******************************************************************************
 * API vertex fetch:
 */

struct pt_fetch;

void
draw_pt_fetch_prepare(struct pt_fetch *fetch,
                      unsigned vertex_input_count,
                      unsigned vertex_size,
                      unsigned instance_id_index);

void
draw_pt_fetch_run(struct pt_fetch *fetch,
                  const unsigned *elts,
                  unsigned count,
                  char *verts);

void
draw_pt_fetch_run_linear(struct pt_fetch *fetch,
                         unsigned start,
                         unsigned count,
                         char *verts);

void
draw_pt_fetch_destroy(struct pt_fetch *fetch);

struct pt_fetch *
draw_pt_fetch_create(struct draw_context *draw);

/*******************************************************************************
 * Post-VS: cliptest, rhw, viewport
 */
struct pt_post_vs;

boolean
draw_pt_post_vs_run(struct pt_post_vs *pvs,
                    struct draw_vertex_info *info,
                    const struct draw_prim_info *prim_info);

void
draw_pt_post_vs_prepare(struct pt_post_vs *pvs,
                        boolean clip_xy,
                        boolean clip_z,
                        boolean clip_user,
                        boolean guard_band,
                        boolean bypass_viewport,
                        boolean clip_halfz,
                        boolean need_edgeflags);

struct pt_post_vs *
draw_pt_post_vs_create(struct draw_context *draw);

void
draw_pt_post_vs_destroy(struct pt_post_vs *pvs);


/*******************************************************************************
 * Utils:
 */
void
draw_pt_split_prim(enum pipe_prim_type prim, unsigned *first, unsigned *incr);

unsigned
draw_pt_trim_count(unsigned count, unsigned first, unsigned incr);


#endif
