ilo: rename 3d_pipeline to render

Follow the file renaming.

Signed-off-by: Chia-I Wu <olvaffe@gmail.com>

src/gallium/drivers/ilo/ilo_context.c

@@ -48,10 +48,10 @@ ilo_context_cp_submitted(struct ilo_cp *cp, void *data)
    struct ilo_context *ilo = ilo_context(data);
 
    /* invalidate the pipeline */
-   ilo_3d_pipeline_invalidate(ilo->pipeline,
+   ilo_render_invalidate(ilo->render,
-         ILO_3D_PIPELINE_INVALIDATE_BATCH_BO |
+         ILO_RENDER_INVALIDATE_BATCH_BO |
-         ILO_3D_PIPELINE_INVALIDATE_STATE_BO |
+         ILO_RENDER_INVALIDATE_STATE_BO |
-         ILO_3D_PIPELINE_INVALIDATE_KERNEL_BO);
+         ILO_RENDER_INVALIDATE_KERNEL_BO);
 }
 
 static void
@@ -124,8 +124,8 @@ ilo_context_destroy(struct pipe_context *pipe)
 
    if (ilo->blitter)
       ilo_blitter_destroy(ilo->blitter);
-   if (ilo->pipeline)
+   if (ilo->render)
-      ilo_3d_pipeline_destroy(ilo->pipeline);
+      ilo_render_destroy(ilo->render);
    if (ilo->shader_cache)
       ilo_shader_cache_destroy(ilo->shader_cache);
    if (ilo->cp)
@@ -159,9 +159,9 @@ ilo_context_create(struct pipe_screen *screen, void *priv)
    ilo->shader_cache = ilo_shader_cache_create();
    ilo->cp = ilo_cp_create(ilo->dev, ilo->winsys, ilo->shader_cache);
    if (ilo->cp)
-      ilo->pipeline = ilo_3d_pipeline_create(&ilo->cp->builder);
+      ilo->render = ilo_render_create(&ilo->cp->builder);
 
-   if (!ilo->cp || !ilo->shader_cache || !ilo->pipeline) {
+   if (!ilo->cp || !ilo->shader_cache || !ilo->render) {
       ilo_context_destroy(&ilo->base);
       return NULL;
    }

src/gallium/drivers/ilo/ilo_context.h

@@ -39,8 +39,8 @@
 struct u_upload_mgr;
 struct intel_winsys;
 
-struct ilo_3d_pipeline;
 struct ilo_blitter;
+struct ilo_render;
 struct ilo_screen;
 struct ilo_shader_cache;
 
@@ -56,7 +56,7 @@ struct ilo_context {
 
    struct ilo_shader_cache *shader_cache;
    struct ilo_blitter *blitter;
-   struct ilo_3d_pipeline *pipeline;
+   struct ilo_render *render;
 
    struct u_upload_mgr *uploader;
 

src/gallium/drivers/ilo/ilo_draw.c

@@ -130,7 +130,7 @@ query_begin_bo(struct ilo_context *ilo, struct ilo_query *q)
 
    /* write the beginning value to the bo */
    if (q->in_pairs)
-      ilo_3d_pipeline_emit_query(ilo->pipeline, q, q->stride * q->used);
+      ilo_render_emit_query(ilo->render, q, q->stride * q->used);
 }
 
 static void
@@ -147,7 +147,7 @@ query_end_bo(struct ilo_context *ilo, struct ilo_query *q)
    q->used++;
 
    /* write the ending value to the bo */
-   ilo_3d_pipeline_emit_query(ilo->pipeline, q, offset);
+   ilo_render_emit_query(ilo->render, q, offset);
 }
 
 bool
@@ -176,8 +176,8 @@ ilo_init_draw_query(struct ilo_context *ilo, struct ilo_query *q)
       break;
    }
 
-   q->cmd_len = ilo_3d_pipeline_estimate_size(ilo->pipeline,
+   q->cmd_len = ilo_render_estimate_size(ilo->render,
-         ILO_3D_PIPELINE_QUERY, q);
+         ILO_RENDER_QUERY, q);
 
    /* double cmd_len and stride if in pairs */
    q->cmd_len <<= q->in_pairs;
@@ -321,11 +321,11 @@ draw_vbo(struct ilo_context *ilo, const struct ilo_state_vector *vec)
    ilo_draw_set_owner(ilo);
 
    /* make sure there is enough room first */
-   max_len = ilo_3d_pipeline_estimate_size(ilo->pipeline,
+   max_len = ilo_render_estimate_size(ilo->render,
-         ILO_3D_PIPELINE_DRAW, vec);
+         ILO_RENDER_DRAW, vec);
    if (need_flush) {
-      max_len += ilo_3d_pipeline_estimate_size(ilo->pipeline,
+      max_len += ilo_render_estimate_size(ilo->render,
-            ILO_3D_PIPELINE_FLUSH, NULL);
+            ILO_RENDER_FLUSH, NULL);
    }
 
    if (max_len > ilo_cp_space(ilo->cp)) {
@@ -338,14 +338,14 @@ draw_vbo(struct ilo_context *ilo, const struct ilo_state_vector *vec)
    before_space = ilo_cp_space(ilo->cp);
 
    if (need_flush)
-      ilo_3d_pipeline_emit_flush(ilo->pipeline);
+      ilo_render_emit_flush(ilo->render);
 
    while (true) {
       struct ilo_builder_snapshot snapshot;
 
       ilo_builder_batch_snapshot(&ilo->cp->builder, &snapshot);
 
-      ilo_3d_pipeline_emit_draw(ilo->pipeline, vec);
+      ilo_render_emit_draw(ilo->render, vec);
 
       if (!ilo_builder_validate(&ilo->cp->builder, 0, NULL)) {
          ilo_builder_batch_restore(&ilo->cp->builder, &snapshot);
@@ -362,7 +362,7 @@ draw_vbo(struct ilo_context *ilo, const struct ilo_state_vector *vec)
       break;
    }
 
-   ilo->pipeline->invalidate_flags = 0x0;
+   ilo->render->invalidate_flags = 0x0;
 
    /* sanity check size estimation */
    assert(before_space - ilo_cp_space(ilo->cp) <= max_len);
@@ -380,10 +380,10 @@ ilo_draw_rectlist(struct ilo_context *ilo)
 
    ilo_draw_set_owner(ilo);
 
-   max_len = ilo_3d_pipeline_estimate_size(ilo->pipeline,
+   max_len = ilo_render_estimate_size(ilo->render,
-         ILO_3D_PIPELINE_RECTLIST, ilo->blitter);
+         ILO_RENDER_RECTLIST, ilo->blitter);
-   max_len += ilo_3d_pipeline_estimate_size(ilo->pipeline,
+   max_len += ilo_render_estimate_size(ilo->render,
-         ILO_3D_PIPELINE_FLUSH, NULL) * 2;
+         ILO_RENDER_FLUSH, NULL) * 2;
 
    if (max_len > ilo_cp_space(ilo->cp)) {
       ilo_cp_submit(ilo->cp, "out of space");
@@ -416,14 +416,14 @@ ilo_draw_rectlist(struct ilo_context *ilo)
     * Skip checking blitter->op and do the flushes.
     */
    if (need_flush)
-      ilo_3d_pipeline_emit_flush(ilo->pipeline);
+      ilo_render_emit_flush(ilo->render);
 
    while (true) {
       struct ilo_builder_snapshot snapshot;
 
       ilo_builder_batch_snapshot(&ilo->cp->builder, &snapshot);
 
-      ilo_3d_pipeline_emit_rectlist(ilo->pipeline, ilo->blitter);
+      ilo_render_emit_rectlist(ilo->render, ilo->blitter);
 
       if (!ilo_builder_validate(&ilo->cp->builder, 0, NULL)) {
          ilo_builder_batch_restore(&ilo->cp->builder, &snapshot);
@@ -438,9 +438,9 @@ ilo_draw_rectlist(struct ilo_context *ilo)
       break;
    }
 
-   ilo_3d_pipeline_invalidate(ilo->pipeline, ILO_3D_PIPELINE_INVALIDATE_HW);
+   ilo_render_invalidate(ilo->render, ILO_RENDER_INVALIDATE_HW);
 
-   ilo_3d_pipeline_emit_flush(ilo->pipeline);
+   ilo_render_emit_flush(ilo->render);
 
    /* sanity check size estimation */
    assert(before_space - ilo_cp_space(ilo->cp) <= max_len);
@@ -593,7 +593,7 @@ ilo_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *info)
    ilo->state_vector.draw = NULL;
 
    if (ilo_debug & ILO_DEBUG_NOCACHE)
-      ilo_3d_pipeline_emit_flush(ilo->pipeline);
+      ilo_render_emit_flush(ilo->render);
 }
 
 static void
@@ -604,7 +604,7 @@ ilo_texture_barrier(struct pipe_context *pipe)
    if (ilo->cp->ring != INTEL_RING_RENDER)
       return;
 
-   ilo_3d_pipeline_emit_flush(ilo->pipeline);
+   ilo_render_emit_flush(ilo->render);
 
    /* don't know why */
    if (ilo_dev_gen(ilo->dev) >= ILO_GEN(7))
@@ -619,7 +619,7 @@ ilo_get_sample_position(struct pipe_context *pipe,
 {
    struct ilo_context *ilo = ilo_context(pipe);
 
-   ilo_3d_pipeline_get_sample_position(ilo->pipeline,
+   ilo_render_get_sample_position(ilo->render,
          sample_count, sample_index,
          &out_value[0], &out_value[1]);
 }

src/gallium/drivers/ilo/ilo_gpgpu.c

@@ -29,7 +29,7 @@
 #include "ilo_gpgpu.h"
 
 /*
- * This is a placeholder.  We will need something similar to ilo_3d_pipeline.
+ * This is a placeholder.  We will need something similar to ilo_render.
  */
 
 static void

src/gallium/drivers/ilo/ilo_render.c

@@ -60,80 +60,80 @@ static const struct sample_position sample_position_8x[8] = {
    {  3, 15 }, /* distance from the center is sqrt(74) */
 };
 
-struct ilo_3d_pipeline *
+struct ilo_render *
-ilo_3d_pipeline_create(struct ilo_builder *builder)
+ilo_render_create(struct ilo_builder *builder)
 {
-   struct ilo_3d_pipeline *p;
+   struct ilo_render *render;
    int i;
 
-   p = CALLOC_STRUCT(ilo_3d_pipeline);
+   render = CALLOC_STRUCT(ilo_render);
-   if (!p)
+   if (!render)
       return NULL;
 
-   p->dev = builder->dev;
+   render->dev = builder->dev;
-   p->builder = builder;
+   render->builder = builder;
 
-   switch (ilo_dev_gen(p->dev)) {
+   switch (ilo_dev_gen(render->dev)) {
    case ILO_GEN(6):
-      ilo_3d_pipeline_init_gen6(p);
+      ilo_render_init_gen6(render);
       break;
    case ILO_GEN(7):
    case ILO_GEN(7.5):
-      ilo_3d_pipeline_init_gen7(p);
+      ilo_render_init_gen7(render);
       break;
    default:
       assert(!"unsupported GEN");
-      FREE(p);
+      FREE(render);
       return NULL;
       break;
    }
 
-   p->invalidate_flags = ILO_3D_PIPELINE_INVALIDATE_ALL;
+   render->invalidate_flags = ILO_RENDER_INVALIDATE_ALL;
 
-   p->workaround_bo = intel_winsys_alloc_buffer(builder->winsys,
+   render->workaround_bo = intel_winsys_alloc_buffer(builder->winsys,
          "PIPE_CONTROL workaround", 4096, false);
-   if (!p->workaround_bo) {
+   if (!render->workaround_bo) {
       ilo_warn("failed to allocate PIPE_CONTROL workaround bo\n");
-      FREE(p);
+      FREE(render);
       return NULL;
    }
 
-   p->packed_sample_position_1x =
+   render->packed_sample_position_1x =
       sample_position_1x[0].x << 4 |
       sample_position_1x[0].y;
 
    /* pack into dwords */
    for (i = 0; i < 4; i++) {
-      p->packed_sample_position_4x |=
+      render->packed_sample_position_4x |=
          sample_position_4x[i].x << (8 * i + 4) |
          sample_position_4x[i].y << (8 * i);
 
-      p->packed_sample_position_8x[0] |=
+      render->packed_sample_position_8x[0] |=
          sample_position_8x[i].x << (8 * i + 4) |
          sample_position_8x[i].y << (8 * i);
 
-      p->packed_sample_position_8x[1] |=
+      render->packed_sample_position_8x[1] |=
          sample_position_8x[4 + i].x << (8 * i + 4) |
          sample_position_8x[4 + i].y << (8 * i);
    }
 
-   return p;
+   return render;
 }
 
 void
-ilo_3d_pipeline_destroy(struct ilo_3d_pipeline *p)
+ilo_render_destroy(struct ilo_render *render)
 {
-   if (p->workaround_bo)
+   if (render->workaround_bo)
-      intel_bo_unreference(p->workaround_bo);
+      intel_bo_unreference(render->workaround_bo);
 
-   FREE(p);
+   FREE(render);
 }
 
 void
-ilo_3d_pipeline_get_sample_position(struct ilo_3d_pipeline *p,
+ilo_render_get_sample_position(struct ilo_render *render,
-                                    unsigned sample_count,
+                               unsigned sample_count,
-                                    unsigned sample_index,
+                               unsigned sample_index,
-                                    float *x, float *y)
+                               float *x, float *y)
 {
    const struct sample_position *pos;
 

src/gallium/drivers/ilo/ilo_render.h

@@ -37,26 +37,26 @@ struct ilo_cp;
 struct ilo_query;
 struct ilo_state_vector;
 
-enum ilo_3d_pipeline_invalidate_flags {
+enum ilo_render_invalidate_flags {
-   ILO_3D_PIPELINE_INVALIDATE_HW         = 1 << 0,
+   ILO_RENDER_INVALIDATE_HW         = 1 << 0,
-   ILO_3D_PIPELINE_INVALIDATE_BATCH_BO   = 1 << 1,
+   ILO_RENDER_INVALIDATE_BATCH_BO   = 1 << 1,
-   ILO_3D_PIPELINE_INVALIDATE_STATE_BO   = 1 << 2,
+   ILO_RENDER_INVALIDATE_STATE_BO   = 1 << 2,
-   ILO_3D_PIPELINE_INVALIDATE_KERNEL_BO  = 1 << 3,
+   ILO_RENDER_INVALIDATE_KERNEL_BO  = 1 << 3,
 
-   ILO_3D_PIPELINE_INVALIDATE_ALL        = 0xffffffff,
+   ILO_RENDER_INVALIDATE_ALL        = 0xffffffff,
 };
 
-enum ilo_3d_pipeline_action {
+enum ilo_render_action {
-   ILO_3D_PIPELINE_DRAW,
+   ILO_RENDER_DRAW,
-   ILO_3D_PIPELINE_FLUSH,
+   ILO_RENDER_FLUSH,
-   ILO_3D_PIPELINE_QUERY,
+   ILO_RENDER_QUERY,
-   ILO_3D_PIPELINE_RECTLIST,
+   ILO_RENDER_RECTLIST,
 };
 
 /**
- * 3D pipeline.
+ * Render Engine.
  */
-struct ilo_3d_pipeline {
+struct ilo_render {
    const struct ilo_dev_info *dev;
    struct ilo_builder *builder;
 
@@ -68,25 +68,25 @@ struct ilo_3d_pipeline {
    uint32_t packed_sample_position_4x;
    uint32_t packed_sample_position_8x[2];
 
-   int (*estimate_size)(struct ilo_3d_pipeline *pipeline,
+   int (*estimate_size)(struct ilo_render *render,
-                        enum ilo_3d_pipeline_action action,
+                        enum ilo_render_action action,
                         const void *arg);
 
-   void (*emit_draw)(struct ilo_3d_pipeline *pipeline,
+   void (*emit_draw)(struct ilo_render *render,
                      const struct ilo_state_vector *vec);
 
-   void (*emit_flush)(struct ilo_3d_pipeline *pipeline);
+   void (*emit_flush)(struct ilo_render *render);
 
-   void (*emit_query)(struct ilo_3d_pipeline *pipeline,
+   void (*emit_query)(struct ilo_render *render,
                       struct ilo_query *q, uint32_t offset);
 
-   void (*emit_rectlist)(struct ilo_3d_pipeline *pipeline,
+   void (*emit_rectlist)(struct ilo_render *render,
                          const struct ilo_blitter *blitter);
 
    /**
     * HW states.
     */
-   struct ilo_3d_pipeline_state {
+   struct ilo_render_state {
       /*
        * When a WA is needed before some command, we always emit the WA right
        * before the command.  Knowing what have already been done since last
@@ -145,73 +145,73 @@ struct ilo_3d_pipeline {
    } state;
 };
 
-struct ilo_3d_pipeline *
+struct ilo_render *
-ilo_3d_pipeline_create(struct ilo_builder *builder);
+ilo_render_create(struct ilo_builder *builder);
 
 void
-ilo_3d_pipeline_destroy(struct ilo_3d_pipeline *pipeline);
+ilo_render_destroy(struct ilo_render *render);
 
 
 static inline void
-ilo_3d_pipeline_invalidate(struct ilo_3d_pipeline *p, uint32_t flags)
+ilo_render_invalidate(struct ilo_render *render, uint32_t flags)
 {
-   p->invalidate_flags |= flags;
+   render->invalidate_flags |= flags;
 
    /* Kernel flushes everything.  Shouldn't we set all bits here? */
-   p->state.current_pipe_control_dw1 = 0;
+   render->state.current_pipe_control_dw1 = 0;
 }
 
 /**
  * Estimate the size of an action.
  */
 static inline int
-ilo_3d_pipeline_estimate_size(struct ilo_3d_pipeline *pipeline,
+ilo_render_estimate_size(struct ilo_render *render,
-                              enum ilo_3d_pipeline_action action,
+                         enum ilo_render_action action,
-                              const void *arg)
+                         const void *arg)
 {
-   return pipeline->estimate_size(pipeline, action, arg);
+   return render->estimate_size(render, action, arg);
 }
 
 /**
  * Emit context states and 3DPRIMITIVE.
  */
 static inline void
-ilo_3d_pipeline_emit_draw(struct ilo_3d_pipeline *p,
+ilo_render_emit_draw(struct ilo_render *render,
-                          const struct ilo_state_vector *vec)
+                     const struct ilo_state_vector *vec)
 {
-   p->emit_draw(p, vec);
+   render->emit_draw(render, vec);
 }
 
 /**
  * Emit PIPE_CONTROL to flush all caches.
  */
 static inline void
-ilo_3d_pipeline_emit_flush(struct ilo_3d_pipeline *p)
+ilo_render_emit_flush(struct ilo_render *render)
 {
-   p->emit_flush(p);
+   render->emit_flush(render);
 }
 
 /**
  * Emit PIPE_CONTROL or MI_STORE_REGISTER_MEM to save register values.
  */
 static inline void
-ilo_3d_pipeline_emit_query(struct ilo_3d_pipeline *p,
+ilo_render_emit_query(struct ilo_render *render,
-                           struct ilo_query *q, uint32_t offset)
+                      struct ilo_query *q, uint32_t offset)
 {
-   p->emit_query(p, q, offset);
+   render->emit_query(render, q, offset);
 }
 
 static inline void
-ilo_3d_pipeline_emit_rectlist(struct ilo_3d_pipeline *p,
+ilo_render_emit_rectlist(struct ilo_render *render,
-                              const struct ilo_blitter *blitter)
+                         const struct ilo_blitter *blitter)
 {
-   p->emit_rectlist(p, blitter);
+   render->emit_rectlist(render, blitter);
 }
 
 void
-ilo_3d_pipeline_get_sample_position(struct ilo_3d_pipeline *p,
+ilo_render_get_sample_position(struct ilo_render *render,
-                                    unsigned sample_count,
+                               unsigned sample_count,
-                                    unsigned sample_index,
+                               unsigned sample_index,
-                                    float *x, float *y);
+                               float *x, float *y);
 
 #endif /* ILO_RENDER_H */

src/gallium/drivers/ilo/ilo_render_gen.h

@@ -30,11 +30,11 @@
 
 #include "ilo_common.h"
 
-struct ilo_3d_pipeline;
 struct ilo_query;
+struct ilo_render;
 struct ilo_state_vector;
 
-struct gen6_pipeline_session {
+struct gen6_draw_session {
    uint32_t pipe_dirty;
 
    int reduced_prim;
@@ -46,13 +46,13 @@ struct gen6_pipeline_session {
    bool prim_changed;
    bool primitive_restart_changed;
 
-   void (*emit_draw_states)(struct ilo_3d_pipeline *p,
+   void (*emit_draw_states)(struct ilo_render *render,
                             const struct ilo_state_vector *ilo,
-                            struct gen6_pipeline_session *session);
+                            struct gen6_draw_session *session);
 
-   void (*emit_draw_commands)(struct ilo_3d_pipeline *p,
+   void (*emit_draw_commands)(struct ilo_render *render,
                               const struct ilo_state_vector *ilo,
-                              struct gen6_pipeline_session *session);
+                              struct gen6_draw_session *session);
 
    /* indirect states */
    bool viewport_state_changed;
@@ -80,86 +80,86 @@ struct gen6_rectlist_session {
 };
 
 void
-gen6_pipeline_prepare(const struct ilo_3d_pipeline *p,
+gen6_draw_prepare(const struct ilo_render *r,
-                      const struct ilo_state_vector *ilo,
-                      struct gen6_pipeline_session *session);
-
-void
-gen6_pipeline_draw(struct ilo_3d_pipeline *p,
-                   const struct ilo_state_vector *ilo,
-                   struct gen6_pipeline_session *session);
-
-void
-gen6_pipeline_end(struct ilo_3d_pipeline *p,
                   const struct ilo_state_vector *ilo,
-                  struct gen6_pipeline_session *session);
+                  struct gen6_draw_session *session);
 
 void
-gen6_pipeline_common_select(struct ilo_3d_pipeline *p,
+gen6_draw_emit(struct ilo_render *r,
-                            const struct ilo_state_vector *ilo,
+               const struct ilo_state_vector *ilo,
-                            struct gen6_pipeline_session *session);
+               struct gen6_draw_session *session);
 
 void
-gen6_pipeline_common_sip(struct ilo_3d_pipeline *p,
+gen6_draw_end(struct ilo_render *r,
-                         const struct ilo_state_vector *ilo,
+              const struct ilo_state_vector *ilo,
-                         struct gen6_pipeline_session *session);
+              struct gen6_draw_session *session);
 
 void
-gen6_pipeline_common_base_address(struct ilo_3d_pipeline *p,
+gen6_draw_common_select(struct ilo_render *r,
-                                  const struct ilo_state_vector *ilo,
-                                  struct gen6_pipeline_session *session);
-
-void
-gen6_pipeline_vf(struct ilo_3d_pipeline *p,
-                 const struct ilo_state_vector *ilo,
-                 struct gen6_pipeline_session *session);
-
-void
-gen6_pipeline_vf_statistics(struct ilo_3d_pipeline *p,
-                            const struct ilo_state_vector *ilo,
-                            struct gen6_pipeline_session *session);
-
-void
-gen6_pipeline_vs(struct ilo_3d_pipeline *p,
-                 const struct ilo_state_vector *ilo,
-                 struct gen6_pipeline_session *session);
-
-void
-gen6_pipeline_clip(struct ilo_3d_pipeline *p,
-                   const struct ilo_state_vector *ilo,
-                   struct gen6_pipeline_session *session);
-
-void
-gen6_pipeline_sf_rect(struct ilo_3d_pipeline *p,
-                      const struct ilo_state_vector *ilo,
-                      struct gen6_pipeline_session *session);
-
-void
-gen6_pipeline_wm_raster(struct ilo_3d_pipeline *p,
                         const struct ilo_state_vector *ilo,
-                        struct gen6_pipeline_session *session);
+                        struct gen6_draw_session *session);
 
 void
-gen6_pipeline_states(struct ilo_3d_pipeline *p,
+gen6_draw_common_sip(struct ilo_render *r,
                      const struct ilo_state_vector *ilo,
-                     struct gen6_pipeline_session *session);
+                     struct gen6_draw_session *session);
+
+void
+gen6_draw_common_base_address(struct ilo_render *r,
+                              const struct ilo_state_vector *ilo,
+                              struct gen6_draw_session *session);
+
+void
+gen6_draw_vf(struct ilo_render *r,
+             const struct ilo_state_vector *ilo,
+             struct gen6_draw_session *session);
+
+void
+gen6_draw_vf_statistics(struct ilo_render *r,
+                        const struct ilo_state_vector *ilo,
+                        struct gen6_draw_session *session);
+
+void
+gen6_draw_vs(struct ilo_render *r,
+             const struct ilo_state_vector *ilo,
+             struct gen6_draw_session *session);
+
+void
+gen6_draw_clip(struct ilo_render *r,
+               const struct ilo_state_vector *ilo,
+               struct gen6_draw_session *session);
+
+void
+gen6_draw_sf_rect(struct ilo_render *r,
+                  const struct ilo_state_vector *ilo,
+                  struct gen6_draw_session *session);
+
+void
+gen6_draw_wm_raster(struct ilo_render *r,
+                    const struct ilo_state_vector *ilo,
+                    struct gen6_draw_session *session);
+
+void
+gen6_draw_states(struct ilo_render *r,
+                 const struct ilo_state_vector *ilo,
+                 struct gen6_draw_session *session);
 
 int
-gen6_pipeline_estimate_state_size(const struct ilo_3d_pipeline *p,
+gen6_render_estimate_state_size(const struct ilo_render *render,
-                                  const struct ilo_state_vector *ilo);
+                                const struct ilo_state_vector *ilo);
 
 int
-gen6_pipeline_estimate_query_size(const struct ilo_3d_pipeline *p,
+gen6_render_estimate_query_size(const struct ilo_render *render,
-                                  const struct ilo_query *q);
+                                const struct ilo_query *q);
 
 void
-ilo_3d_pipeline_emit_flush_gen6(struct ilo_3d_pipeline *p);
+ilo_render_emit_flush_gen6(struct ilo_render *r);
 
 void
-ilo_3d_pipeline_emit_query_gen6(struct ilo_3d_pipeline *p,
+ilo_render_emit_query_gen6(struct ilo_render *r,
-                                struct ilo_query *q, uint32_t offset);
+                           struct ilo_query *q, uint32_t offset);
 
 void
-ilo_3d_pipeline_init_gen6(struct ilo_3d_pipeline *p);
+ilo_render_init_gen6(struct ilo_render *render);
 
 #endif /* ILO_RENDER_GEN_H */

src/gallium/drivers/ilo/ilo_render_gen7.h

@@ -30,9 +30,9 @@
 
 #include "ilo_common.h"
 
-struct ilo_3d_pipeline;
+struct ilo_render;
 
 void
-ilo_3d_pipeline_init_gen7(struct ilo_3d_pipeline *p);
+ilo_render_init_gen7(struct ilo_render *render);
 
 #endif /* ILO_RENDER_GEN7_H */