KonstantinSeurer
/
mesa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ilo: rename 3d_pipeline to render 

Follow the file renaming.

Signed-off-by: Chia-I Wu <olvaffe@gmail.com>
This commit is contained in:
Chia-I Wu 2014-09-24 14:31:07 +08:00
parent 3afe30e64b
commit 23d66a42a3
10 changed files with 897 additions and 896 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
src/gallium/drivers/ilo/ilo_context.c
View File

@ -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_3D_PIPELINE_INVALIDATE_BATCH_BO |
ILO_3D_PIPELINE_INVALIDATE_STATE_BO |
ILO_3D_PIPELINE_INVALIDATE_KERNEL_BO);
ilo_render_invalidate(ilo->render,
ILO_RENDER_INVALIDATE_BATCH_BO |
ILO_RENDER_INVALIDATE_STATE_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)
ilo_3d_pipeline_destroy(ilo->pipeline);
if (ilo->render)
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;
}

4
src/gallium/drivers/ilo/ilo_context.h
View File

@ -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;

44
src/gallium/drivers/ilo/ilo_draw.c
View File

@ -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,
ILO_3D_PIPELINE_QUERY, q);
q->cmd_len = ilo_render_estimate_size(ilo->render,
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,
ILO_3D_PIPELINE_DRAW, vec);
max_len = ilo_render_estimate_size(ilo->render,
ILO_RENDER_DRAW, vec);
if (need_flush) {
max_len += ilo_3d_pipeline_estimate_size(ilo->pipeline,
ILO_3D_PIPELINE_FLUSH, NULL);
max_len += ilo_render_estimate_size(ilo->render,
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,
ILO_3D_PIPELINE_RECTLIST, ilo->blitter);
max_len += ilo_3d_pipeline_estimate_size(ilo->pipeline,
ILO_3D_PIPELINE_FLUSH, NULL) * 2;
max_len = ilo_render_estimate_size(ilo->render,
ILO_RENDER_RECTLIST, ilo->blitter);
max_len += ilo_render_estimate_size(ilo->render,
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]);
}

2
src/gallium/drivers/ilo/ilo_gpgpu.c
View File

@ -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

56
src/gallium/drivers/ilo/ilo_render.c
View File

@ -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 *
ilo_3d_pipeline_create(struct ilo_builder *builder)
struct ilo_render *
ilo_render_create(struct ilo_builder *builder)
{
struct ilo_3d_pipeline *p;
struct ilo_render *render;
int i;
p = CALLOC_STRUCT(ilo_3d_pipeline);
if (!p)
render = CALLOC_STRUCT(ilo_render);
if (!render)
return NULL;
p->dev = builder->dev;
p->builder = builder;
render->dev = builder->dev;
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)
intel_bo_unreference(p->workaround_bo);
if (render->workaround_bo)
intel_bo_unreference(render->workaround_bo);
FREE(p);
FREE(render);
}
void
ilo_3d_pipeline_get_sample_position(struct ilo_3d_pipeline *p,
unsigned sample_count,
unsigned sample_index,
float *x, float *y)
ilo_render_get_sample_position(struct ilo_render *render,
unsigned sample_count,
unsigned sample_index,
float *x, float *y)
{
const struct sample_position *pos;

90
src/gallium/drivers/ilo/ilo_render.h
View File

@ -37,26 +37,26 @@ struct ilo_cp;
struct ilo_query;
struct ilo_state_vector;
enum ilo_3d_pipeline_invalidate_flags {
ILO_3D_PIPELINE_INVALIDATE_HW = 1 << 0,
ILO_3D_PIPELINE_INVALIDATE_BATCH_BO = 1 << 1,
ILO_3D_PIPELINE_INVALIDATE_STATE_BO = 1 << 2,
ILO_3D_PIPELINE_INVALIDATE_KERNEL_BO = 1 << 3,
enum ilo_render_invalidate_flags {
ILO_RENDER_INVALIDATE_HW = 1 << 0,
ILO_RENDER_INVALIDATE_BATCH_BO = 1 << 1,
ILO_RENDER_INVALIDATE_STATE_BO = 1 << 2,
ILO_RENDER_INVALIDATE_KERNEL_BO = 1 << 3,
ILO_3D_PIPELINE_INVALIDATE_ALL = 0xffffffff,
ILO_RENDER_INVALIDATE_ALL = 0xffffffff,
};
enum ilo_3d_pipeline_action {
ILO_3D_PIPELINE_DRAW,
ILO_3D_PIPELINE_FLUSH,
ILO_3D_PIPELINE_QUERY,
ILO_3D_PIPELINE_RECTLIST,
enum ilo_render_action {
ILO_RENDER_DRAW,
ILO_RENDER_FLUSH,
ILO_RENDER_QUERY,
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,
enum ilo_3d_pipeline_action action,
int (*estimate_size)(struct ilo_render *render,
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 *
ilo_3d_pipeline_create(struct ilo_builder *builder);
struct ilo_render *
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,
enum ilo_3d_pipeline_action action,
const void *arg)
ilo_render_estimate_size(struct ilo_render *render,
enum ilo_render_action action,
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,
const struct ilo_state_vector *vec)
ilo_render_emit_draw(struct ilo_render *render,
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,
struct ilo_query *q, uint32_t offset)
ilo_render_emit_query(struct ilo_render *render,
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,
const struct ilo_blitter *blitter)
ilo_render_emit_rectlist(struct ilo_render *render,
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,
unsigned sample_count,
unsigned sample_index,
float *x, float *y);
ilo_render_get_sample_position(struct ilo_render *render,
unsigned sample_count,
unsigned sample_index,
float *x, float *y);
#endif /* ILO_RENDER_H */

132
src/gallium/drivers/ilo/ilo_render_gen.h
View File

@ -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,
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,
gen6_draw_prepare(const struct ilo_render *r,
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,
const struct ilo_state_vector *ilo,
struct gen6_pipeline_session *session);
gen6_draw_emit(struct ilo_render *r,
const struct ilo_state_vector *ilo,
struct gen6_draw_session *session);
void
gen6_pipeline_common_sip(struct ilo_3d_pipeline *p,
const struct ilo_state_vector *ilo,
struct gen6_pipeline_session *session);
gen6_draw_end(struct ilo_render *r,
const struct ilo_state_vector *ilo,
struct gen6_draw_session *session);
void
gen6_pipeline_common_base_address(struct ilo_3d_pipeline *p,
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,
gen6_draw_common_select(struct ilo_render *r,
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,
const struct ilo_state_vector *ilo);
gen6_render_estimate_state_size(const struct ilo_render *render,
const struct ilo_state_vector *ilo);
int
gen6_pipeline_estimate_query_size(const struct ilo_3d_pipeline *p,
const struct ilo_query *q);
gen6_render_estimate_query_size(const struct ilo_render *render,
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,
struct ilo_query *q, uint32_t offset);
ilo_render_emit_query_gen6(struct ilo_render *r,
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 */

887
src/gallium/drivers/ilo/ilo_render_gen6.c
View File

File diff suppressed because it is too large Load Diff

558
src/gallium/drivers/ilo/ilo_render_gen7.c
View File

File diff suppressed because it is too large Load Diff

4
src/gallium/drivers/ilo/ilo_render_gen7.h
View File

@ -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 */