path: root/src/gallium/drivers/ilo/core/ilo_state_shader.h

/*
 * Mesa 3-D graphics library
 *
 * Copyright (C) 2015 LunarG, Inc.
 *
 * 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.
 *
 * Authors:
 *    Chia-I Wu <olv@lunarg.com>
 */

#ifndef ILO_STATE_SHADER_H
#define ILO_STATE_SHADER_H

#include "genhw/genhw.h"

#include "ilo_core.h"
#include "ilo_dev.h"

/**
 * Kernel information.
 */
struct ilo_state_shader_kernel_info {
   /* usually 0 unless the shader has multiple kernels */
   uint32_t offset;

   uint8_t grf_start;
   uint8_t pcb_attr_count;
};

/**
 * Shader resources.
 */
struct ilo_state_shader_resource_info {
   /* for prefetches */
   uint8_t sampler_count;
   uint8_t surface_count;

   bool has_uav;
};

/**
 * URB inputs/outputs.
 */
struct ilo_state_shader_urb_info {
   uint8_t cv_input_attr_count;

   uint8_t read_base;
   uint8_t read_count;

   uint8_t output_attr_count;

   uint8_t user_cull_enables;
   uint8_t user_clip_enables;
};

struct ilo_state_vs_info {
   struct ilo_state_shader_kernel_info kernel;
   struct ilo_state_shader_resource_info resource;
   struct ilo_state_shader_urb_info urb;

   uint32_t per_thread_scratch_size;
   bool dispatch_enable;
   bool stats_enable;
};

struct ilo_state_hs_info {
   struct ilo_state_shader_kernel_info kernel;
   struct ilo_state_shader_resource_info resource;
   struct ilo_state_shader_urb_info urb;

   uint32_t per_thread_scratch_size;
   bool dispatch_enable;
   bool stats_enable;
};

struct ilo_state_ds_info {
   struct ilo_state_shader_kernel_info kernel;
   struct ilo_state_shader_resource_info resource;
   struct ilo_state_shader_urb_info urb;

   uint32_t per_thread_scratch_size;
   bool dispatch_enable;
   bool stats_enable;
};

/**
 * Stream output.  Must be consistent with ilo_state_sol_info.
 */
struct ilo_state_gs_sol_info {
   bool sol_enable;
   bool stats_enable;
   bool render_disable;

   uint16_t svbi_post_inc;

   enum gen_reorder_mode tristrip_reorder;
};

struct ilo_state_gs_info {
   struct ilo_state_shader_kernel_info kernel;
   struct ilo_state_shader_resource_info resource;
   struct ilo_state_shader_urb_info urb;

   struct ilo_state_gs_sol_info sol;

   uint32_t per_thread_scratch_size;
   bool dispatch_enable;
   bool stats_enable;
};

struct ilo_state_ps_io_info {
   /* inputs */
   enum gen_position_offset posoffset;
   uint8_t attr_count;
   bool use_z;
   bool use_w;
   bool use_coverage_mask;

   /* outputs */
   enum gen_pscdepth_mode pscdepth;
   bool has_rt_write;
   bool write_pixel_mask;
   bool write_omask;
};

struct ilo_state_ps_params_info {
   /* compatibility with raster states */
   uint32_t sample_mask;
   bool earlyz_control_psexec;

   /* compatibility with cc states */
   bool alpha_may_kill;
   bool dual_source_blending;
   bool has_writeable_rt;
};

struct ilo_state_ps_info {
   struct ilo_state_shader_kernel_info kernel_8;
   struct ilo_state_shader_kernel_info kernel_16;
   struct ilo_state_shader_kernel_info kernel_32;
   struct ilo_state_shader_resource_info resource;

   struct ilo_state_ps_io_info io;
   struct ilo_state_ps_params_info params;

   uint32_t per_thread_scratch_size;

   /* bitmask of GEN6_PS_DISPATCH_x */
   uint8_t valid_kernels;
   bool per_sample_dispatch;
   bool sample_count_one;
   bool cv_per_sample_interp;
   bool cv_has_earlyz_op;

   bool rt_clear_enable;
   bool rt_resolve_enable;

   bool cv_has_depth_buffer;
};

struct ilo_state_vs {
   uint32_t vs[5];
   uint32_t scratch_size;
};

struct ilo_state_hs {
   uint32_t hs[4];
   uint32_t scratch_size;
};

struct ilo_state_ds {
   uint32_t te[3];
   uint32_t ds[5];
   uint32_t scratch_size;
};

struct ilo_state_gs {
   uint32_t gs[5];
   uint32_t scratch_size;
};

struct ilo_state_ps {
   uint32_t ps[8];
   uint32_t scratch_size;

   struct ilo_state_ps_dispatch_conds {
      bool ps_valid;

      bool has_rt_write;
      bool write_odepth;
      bool write_ostencil;
      bool has_uav_write;
      bool ps_may_kill;
   } conds;
};

bool
ilo_state_vs_init(struct ilo_state_vs *vs,
                  const struct ilo_dev *dev,
                  const struct ilo_state_vs_info *info);

bool
ilo_state_vs_init_disabled(struct ilo_state_vs *vs,
                           const struct ilo_dev *dev);

static inline uint32_t
ilo_state_vs_get_scratch_size(const struct ilo_state_vs *vs)
{
   return vs->scratch_size;
}

bool
ilo_state_hs_init(struct ilo_state_hs *hs,
                  const struct ilo_dev *dev,
                  const struct ilo_state_hs_info *info);

bool
ilo_state_hs_init_disabled(struct ilo_state_hs *hs,
                           const struct ilo_dev *dev);


static inline uint32_t
ilo_state_hs_get_scratch_size(const struct ilo_state_hs *hs)
{
   return hs->scratch_size;
}

bool
ilo_state_ds_init(struct ilo_state_ds *ds,
                  const struct ilo_dev *dev,
                  const struct ilo_state_ds_info *info);

bool
ilo_state_ds_init_disabled(struct ilo_state_ds *ds,
                           const struct ilo_dev *dev);

static inline uint32_t
ilo_state_ds_get_scratch_size(const struct ilo_state_ds *ds)
{
   return ds->scratch_size;
}

bool
ilo_state_gs_init(struct ilo_state_gs *gs,
                  const struct ilo_dev *dev,
                  const struct ilo_state_gs_info *info);

bool
ilo_state_gs_init_disabled(struct ilo_state_gs *gs,
                           const struct ilo_dev *dev);

static inline uint32_t
ilo_state_gs_get_scratch_size(const struct ilo_state_gs *gs)
{
   return gs->scratch_size;
}

bool
ilo_state_ps_init(struct ilo_state_ps *ps,
                  const struct ilo_dev *dev,
                  const struct ilo_state_ps_info *info);

bool
ilo_state_ps_init_disabled(struct ilo_state_ps *ps,
                           const struct ilo_dev *dev);

bool
ilo_state_ps_set_params(struct ilo_state_ps *ps,
                        const struct ilo_dev *dev,
                        const struct ilo_state_ps_params_info *params);

static inline uint32_t
ilo_state_ps_get_scratch_size(const struct ilo_state_ps *ps)
{
   return ps->scratch_size;
}

#endif /* ILO_STATE_SHADER_H */