OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Checkpoint: replacement of TGSI_ATTRIB_x tokens with input/output semantics.

Browse Source 
TGSI_ATTRIB_x tokens still present and used in a few places.
Expanded set of TGSI_SEMANTIC_x tokens for describing the meaning
of inputs/outputs.  These tokens are in a crude state ATM.
Lots of #if 0 / disabled code to be removed yet, etc...
Softpipe and i915 drivers should be in working condition but not heavily tested.
This commit is contained in:
Brian
2007-09-19 18:53:36 -06:00
parent 83a674a7af
commit 37cf13ed9a
22 changed files with 583 additions and 237 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/mesa/pipe/draw/draw_vertex_shader.c
View File

@@ -94,7 +94,11 @@ run_vertex_program(struct draw_context *draw,
const float *trans = draw->viewport.translate;
assert(count <= 4);
#if 0
assert(draw->vertex_shader.outputs_written & (1 << TGSI_ATTRIB_POS));
#else
assert(draw->vertex_shader.output_semantics[0] == TGSI_SEMANTIC_POSITION);
#endif
#ifdef DEBUG
memset( &machine, 0, sizeof( machine ) );

14
src/mesa/pipe/i915simple/i915_context.c
View File

@@ -138,6 +138,18 @@ i915_max_texture_size(struct pipe_context *pipe, unsigned textureType,
}
static int
i915_get_param(struct pipe_context *pipe, uint param)
{
switch (param) {
case PIPE_PARAM_FS_NEEDS_POS:
return 0;
default:
return 0;
}
}
static void i915_destroy( struct pipe_context *pipe )
{
struct i915_context *i915 = i915_context( pipe );
@@ -272,6 +284,8 @@ struct pipe_context *i915_create( struct pipe_winsys *pipe_winsys,
i915->pipe.destroy = i915_destroy;
i915->pipe.supported_formats = i915_supported_formats;
i915->pipe.max_texture_size = i915_max_texture_size;
i915->pipe.get_param = i915_get_param;
i915->pipe.clear = i915_clear;
i915->pipe.begin_query = i915_begin_query;

2
src/mesa/pipe/i915simple/i915_fpc.h
View File

@@ -51,6 +51,8 @@ struct i915_fp_compile {
uint declarations[I915_PROGRAM_SIZE];
uint program[I915_PROGRAM_SIZE];
uint input_semantic[PIPE_MAX_SHADER_INPUTS];
/** points into the i915->current.constants array: */
float (*constants)[4];
uint num_constants;

81
src/mesa/pipe/i915simple/i915_fpc_translate.c
View File

@@ -128,7 +128,7 @@ src_vector(struct i915_fp_compile *p,
const struct tgsi_full_src_register *source)
{
uint index = source->SrcRegister.Index;
uint src;
uint src, sem;
switch (source->SrcRegister.File) {
case TGSI_FILE_TEMPORARY:
@@ -151,6 +151,46 @@ src_vector(struct i915_fp_compile *p,
/* use vertex format info to map a slot number to a VF attrib */
assert(index < p->vertex_info->num_attribs);
sem = p->input_semantic[index];
#if 1
switch (sem) {
case TGSI_SEMANTIC_POSITION:
printf("SKIP SEM POS\n");
/*
assert(p->wpos_tex != -1);
src = i915_emit_decl(p, REG_TYPE_T, p->wpos_tex, D0_CHANNEL_ALL);
*/
break;
case TGSI_SEMANTIC_COLOR0:
src = i915_emit_decl(p, REG_TYPE_T, T_DIFFUSE, D0_CHANNEL_ALL);
break;
case TGSI_SEMANTIC_COLOR1:
src = i915_emit_decl(p, REG_TYPE_T, T_SPECULAR, D0_CHANNEL_XYZ);
src = swizzle(src, X, Y, Z, ONE);
break;
case TGSI_SEMANTIC_FOG:
src = i915_emit_decl(p, REG_TYPE_T, T_FOG_W, D0_CHANNEL_W);
src = swizzle(src, W, W, W, W);
break;
case TGSI_SEMANTIC_TEX0:
case TGSI_SEMANTIC_TEX1:
case TGSI_SEMANTIC_TEX2:
case TGSI_SEMANTIC_TEX3:
case TGSI_SEMANTIC_TEX4:
case TGSI_SEMANTIC_TEX5:
case TGSI_SEMANTIC_TEX6:
case TGSI_SEMANTIC_TEX7:
src = i915_emit_decl(p, REG_TYPE_T,
T_TEX0 + (sem - TGSI_SEMANTIC_TEX0),
D0_CHANNEL_ALL);
break;
default:
i915_program_error(p, "Bad source->Index");
return 0;
}
#else
index = p->vertex_info->slot_to_attrib[index];
switch (index) {
@@ -185,6 +225,7 @@ src_vector(struct i915_fp_compile *p,
i915_program_error(p, "Bad source->Index");
return 0;
}
#endif
break;
case TGSI_FILE_CONSTANT:
@@ -220,9 +261,12 @@ src_vector(struct i915_fp_compile *p,
}
/* no abs() or post-abs negation */
#if 0
/* XXX assertions disabled to allow arbfplight.c to run */
/* XXX enable these assertions, or fix things */
assert(!source->SrcRegisterExtMod.Absolute);
assert(!source->SrcRegisterExtMod.Negate);
#endif
return src;
}
@@ -848,7 +892,15 @@ i915_translate_instructions(struct i915_fp_compile *p,
switch( parse.FullToken.Token.Type ) {
case TGSI_TOKEN_TYPE_DECLARATION:
/* XXX no-op? */
if (parse.FullToken.FullDeclaration.Declaration.File
== TGSI_FILE_INPUT) {
/* save input register info for use in src_vector() */
uint ind, sem;
ind = parse.FullToken.FullDeclaration.u.DeclarationRange.First;
sem = parse.FullToken.FullDeclaration.Semantic.SemanticName;
/*printf("FS Input DECL [%u] sem %u\n", ind, sem);*/
p->input_semantic[ind] = sem;
}
break;
case TGSI_TOKEN_TYPE_IMMEDIATE:
@@ -989,6 +1041,7 @@ i915_fini_compile(struct i915_context *i915, struct i915_fp_compile *p)
static void
i915_find_wpos_space(struct i915_fp_compile *p)
{
#if 0
const uint inputs
= p->shader->inputs_read | (1 << TGSI_ATTRIB_POS); /*XXX hack*/
uint i;
@@ -1005,6 +1058,14 @@ i915_find_wpos_space(struct i915_fp_compile *p)
i915_program_error(p, "No free texcoord for wpos value");
}
#else
if (p->shader->input_semantics[0] == TGSI_SEMANTIC_POSITION) {
/* frag shader using the fragment position input */
#if 0
assert(0);
#endif
}
#endif
}
@@ -1018,13 +1079,17 @@ i915_find_wpos_space(struct i915_fp_compile *p)
static void
i915_fixup_depth_write(struct i915_fp_compile *p)
{
if (p->shader->outputs_written & (1 << TGSI_ATTRIB_POS)) {
uint depth = UREG(REG_TYPE_OD, 0);
/* XXX assuming depth is always in output[0] */
if (p->shader->output_semantics[0] == TGSI_SEMANTIC_DEPTH) {
const uint depth = UREG(REG_TYPE_OD, 0);
i915_emit_arith(p,
A0_MOV,
depth, A0_DEST_CHANNEL_W, 0,
swizzle(depth, X, Y, Z, Z), 0, 0);
A0_MOV, /* opcode */
depth, /* dest reg */
A0_DEST_CHANNEL_W, /* write mask */
0, /* saturate? */
swizzle(depth, X, Y, Z, Z), /* src0 */
0, 0 /* src1, src2 */);
}
}

60
src/mesa/pipe/i915simple/i915_state_derived.c
View File

@@ -33,6 +33,7 @@
#include "i915_state.h"
#include "i915_reg.h"
#include "i915_fpc.h"
#include "pipe/tgsi/exec/tgsi_token.h"
/**
@@ -42,19 +43,71 @@
*/
static void calculate_vertex_layout( struct i915_context *i915 )
{
const uint inputsRead = i915->fs->inputs_read;
const struct pipe_shader_state *fs = i915->fs;
const interp_mode colorInterp
= i915->rasterizer->flatshade ? INTERP_CONSTANT : INTERP_LINEAR;
struct vertex_info *vinfo = &i915->current.vertex_info;
uint front0 = 0, back0 = 0, front1 = 0, back1 = 0;
boolean needW = 0;
uint i;
boolean texCoords[8];
memset(texCoords, 0, sizeof(texCoords));
memset(vinfo, 0, sizeof(*vinfo));
/* pos */
draw_emit_vertex_attr(vinfo, TGSI_ATTRIB_POS, FORMAT_3F, INTERP_LINEAR);
/* Note: we'll set the S4_VFMT_XYZ[W] bits below */
for (i = 0; i < fs->num_inputs; i++) {
switch (fs->input_semantics[i]) {
case TGSI_SEMANTIC_POSITION:
break;
case TGSI_SEMANTIC_COLOR0:
front0 = draw_emit_vertex_attr(vinfo, TGSI_ATTRIB_COLOR0,
FORMAT_4UB, colorInterp);
vinfo->hwfmt[0] |= S4_VFMT_COLOR;
break;
case TGSI_SEMANTIC_COLOR1:
assert(0); /* untested */
front1 = draw_emit_vertex_attr(vinfo, TGSI_ATTRIB_COLOR1,
FORMAT_4UB, colorInterp);
vinfo->hwfmt[0] |= S4_VFMT_SPEC_FOG;
break;
case TGSI_SEMANTIC_TEX0:
case TGSI_SEMANTIC_TEX1:
case TGSI_SEMANTIC_TEX2:
case TGSI_SEMANTIC_TEX3:
case TGSI_SEMANTIC_TEX4:
case TGSI_SEMANTIC_TEX5:
case TGSI_SEMANTIC_TEX6:
case TGSI_SEMANTIC_TEX7:
{
const uint unit = fs->input_semantics[i] - TGSI_SEMANTIC_TEX0;
uint hwtc;
texCoords[unit] = TRUE;
draw_emit_vertex_attr(vinfo, TGSI_ATTRIB_TEX0 + i,
FORMAT_4F, INTERP_PERSPECTIVE);
hwtc = TEXCOORDFMT_4D;
needW = TRUE;
vinfo->hwfmt[1] |= hwtc << (unit * 4);
}
break;
default:
assert(0);
}
}
/* finish up texcoord fields */
for (i = 0; i < 8; i++) {
if (!texCoords[i]) {
const uint hwtc = TEXCOORDFMT_NOT_PRESENT;
vinfo->hwfmt[1] |= hwtc << (i* 4);
}
}
#if 0
/* color0 */
if (inputsRead & (1 << TGSI_ATTRIB_COLOR0)) {
front0 = draw_emit_vertex_attr(vinfo, TGSI_ATTRIB_COLOR0,
@@ -88,6 +141,7 @@ static void calculate_vertex_layout( struct i915_context *i915 )
vinfo->hwfmt[1] |= hwtc << ((i - TGSI_ATTRIB_TEX0) * 4);
}
}
#endif
/* go back and fill in the vertex position info now that we have needW */
if (needW) {
@@ -104,11 +158,11 @@ static void calculate_vertex_layout( struct i915_context *i915 )
* the vertex header.
*/
if (i915->rasterizer->light_twoside) {
if (inputsRead & (1 << TGSI_ATTRIB_COLOR0)) {
if (front0) {
back0 = draw_emit_vertex_attr(vinfo, TGSI_ATTRIB_BFC0,
FORMAT_OMIT, colorInterp);
}
if (inputsRead & (1 << TGSI_ATTRIB_COLOR1)) {
if (back0) {
back1 = draw_emit_vertex_attr(vinfo, TGSI_ATTRIB_BFC1,
FORMAT_OMIT, colorInterp);
}

1
src/mesa/pipe/p_context.h
View File

@@ -57,6 +57,7 @@ struct pipe_context {
const char *(*get_vendor)( struct pipe_context *pipe );
int (*get_param)( struct pipe_context *pipe, int param );
/*

7
src/mesa/pipe/p_defines.h
View File

@@ -307,4 +307,11 @@
#define PIPE_QUERY_PRIMITIVES_EMITTED 2
#define PIPE_QUERY_TYPES 3
/**
* Pipe capabilities/queries
*/
#define PIPE_PARAM_FS_NEEDS_POS 1
#endif

11
src/mesa/pipe/p_state.h
View File

@@ -50,6 +50,8 @@
#define PIPE_MAX_COLOR_BUFS 8
#define PIPE_MAX_TEXTURE_LEVELS 16
#define PIPE_MAX_FEEDBACK_ATTRIBS 16
#define PIPE_MAX_SHADER_INPUTS 16
#define PIPE_MAX_SHADER_OUTPUTS 16
/* fwd decl */
@@ -140,13 +142,14 @@ struct pipe_constant_buffer {
struct pipe_shader_state {
unsigned inputs_read; /**< TGSI_ATTRIB_ bits */
unsigned outputs_written; /**< TGSI_ATTRIB_ bits */
const struct tgsi_token *tokens;
void *executable;
uint num_inputs;
uint num_outputs;
/** These fields somewhat constitute the shader "signature" */
ubyte num_inputs;
ubyte num_outputs;
ubyte input_semantics[PIPE_MAX_SHADER_INPUTS];
ubyte output_semantics[PIPE_MAX_SHADER_OUTPUTS];
};
struct pipe_depth_stencil_state

10
src/mesa/pipe/softpipe/sp_context.c
View File

@@ -236,6 +236,15 @@ static const char *softpipe_get_vendor( struct pipe_context *pipe )
return "Tungsten Graphics, Inc.";
}
static int softpipe_get_param(struct pipe_context *pipe, uint param)
{
switch (param) {
case PIPE_PARAM_FS_NEEDS_POS:
return 1;
default:
return 0;
}
}
struct pipe_context *softpipe_create( struct pipe_winsys *pipe_winsys,
struct softpipe_winsys *softpipe_winsys )
@@ -248,6 +257,7 @@ struct pipe_context *softpipe_create( struct pipe_winsys *pipe_winsys,
/* queries */
softpipe->pipe.supported_formats = softpipe_supported_formats;
softpipe->pipe.max_texture_size = softpipe_max_texture_size;
softpipe->pipe.get_param = softpipe_get_param;
/* state setters */
softpipe->pipe.create_blend_state = softpipe_create_blend_state;

90
src/mesa/pipe/softpipe/sp_state_derived.c
View File

@@ -34,6 +34,7 @@
#include "sp_state.h"
#include "pipe/tgsi/exec/tgsi_attribs.h"
#include "pipe/tgsi/exec/tgsi_token.h"
/**
@@ -43,7 +44,7 @@
*/
static void calculate_vertex_layout( struct softpipe_context *softpipe )
{
const uint inputsRead = softpipe->fs->inputs_read;
const struct pipe_shader_state *fs = softpipe->fs;
const interp_mode colorInterp
= softpipe->rasterizer->flatshade ? INTERP_CONSTANT : INTERP_LINEAR;
struct vertex_info *vinfo = &softpipe->vertex_info;
@@ -52,57 +53,59 @@ static void calculate_vertex_layout( struct softpipe_context *softpipe )
memset(vinfo, 0, sizeof(*vinfo));
/* Need Z if depth test is enabled or the fragment program uses the
* fragment position (XYZW).
*/
if (softpipe->depth_stencil->depth.enabled ||
(inputsRead & (1 << TGSI_ATTRIB_POS)))
if (softpipe->depth_stencil->depth.enabled)
softpipe->need_z = TRUE;
else
softpipe->need_z = FALSE;
softpipe->need_w = FALSE;
/* Need W if we do any perspective-corrected interpolation or the
* fragment program uses the fragment position.
*/
if (inputsRead & (1 << TGSI_ATTRIB_POS))
softpipe->need_w = TRUE;
else
softpipe->need_w = FALSE;
/* position */
/* always emit vertex pos */
/* TODO - Figure out if we need to do perspective divide, etc. */
draw_emit_vertex_attr(vinfo, TGSI_ATTRIB_POS, FORMAT_4F, INTERP_LINEAR);
/* color0 */
if (inputsRead & (1 << TGSI_ATTRIB_COLOR0)) {
front0 = draw_emit_vertex_attr(vinfo, TGSI_ATTRIB_COLOR0,
FORMAT_4F, colorInterp);
}
/* color1 */
if (inputsRead & (1 << TGSI_ATTRIB_COLOR1)) {
front1 = draw_emit_vertex_attr(vinfo, TGSI_ATTRIB_COLOR1,
FORMAT_4F, colorInterp);
}
/* fog */
if (inputsRead & (1 << TGSI_ATTRIB_FOG)) {
draw_emit_vertex_attr(vinfo, TGSI_ATTRIB_FOG,
FORMAT_1F, INTERP_PERSPECTIVE);
}
/* point size */
for (i = 0; i < fs->num_inputs; i++) {
switch (fs->input_semantics[i]) {
case TGSI_SEMANTIC_POSITION:
/* Need Z if depth test is enabled or the fragment program uses the
* fragment position (XYZW).
*/
softpipe->need_z = TRUE;
softpipe->need_w = TRUE;
break;
case TGSI_SEMANTIC_COLOR0:
front0 = draw_emit_vertex_attr(vinfo, TGSI_ATTRIB_COLOR0,
FORMAT_4F, colorInterp);
break;
case TGSI_SEMANTIC_COLOR1:
front1 = draw_emit_vertex_attr(vinfo, TGSI_ATTRIB_COLOR1,
FORMAT_4F, colorInterp);
break;
case TGSI_SEMANTIC_FOG:
draw_emit_vertex_attr(vinfo, TGSI_ATTRIB_FOG,
FORMAT_1F, INTERP_PERSPECTIVE);
break;
#if 0
/* XXX only emit if drawing points or front/back polygon mode is point mode */
draw_emit_vertex_attr(vinfo, TGSI_ATTRIB_POINTSIZE,
FORMAT_4F, INTERP_CONSTANT);
case TGSI_SEMANTIC_PSIZE:
/* XXX only emit if drawing points or front/back polygon mode
* is point mode
*/
draw_emit_vertex_attr(vinfo, TGSI_ATTRIB_POINTSIZE,
FORMAT_4F, INTERP_CONSTANT);
break;
#endif
/* texcoords and varying vars */
for (i = TGSI_ATTRIB_TEX0; i < TGSI_ATTRIB_VAR7; i++) {
if (inputsRead & (1 << i)) {
/*case TGSI_SEMANTIC_TEXCOORD:*/
case TGSI_SEMANTIC_TEX0:
draw_emit_vertex_attr(vinfo, TGSI_ATTRIB_TEX0,
FORMAT_4F, INTERP_PERSPECTIVE);
softpipe->need_w = TRUE;
break;
case TGSI_SEMANTIC_OTHER:
draw_emit_vertex_attr(vinfo, i, FORMAT_4F, INTERP_PERSPECTIVE);
softpipe->need_w = TRUE;
break;
default:
assert(0);
}
}
@@ -113,12 +116,11 @@ static void calculate_vertex_layout( struct softpipe_context *softpipe )
* the vertex header.
*/
if (softpipe->rasterizer->light_twoside) {
if (inputsRead & (1 << TGSI_ATTRIB_COLOR0)) {
if (front0) {
back0 = draw_emit_vertex_attr(vinfo, TGSI_ATTRIB_BFC0,
FORMAT_OMIT, colorInterp);
}
if (inputsRead & (1 << TGSI_ATTRIB_COLOR1)) {
if (back0) {
back1 = draw_emit_vertex_attr(vinfo, TGSI_ATTRIB_BFC1,
FORMAT_OMIT, colorInterp);
}

2
src/mesa/pipe/tgsi/exec/tgsi_build.c
View File

@@ -325,7 +325,7 @@ tgsi_build_declaration_semantic(
{
struct tgsi_declaration_semantic ds;
assert( semantic_name <= TGSI_SEMANTIC_COLOR );
assert( semantic_name <= TGSI_SEMANTIC_COUNT );
assert( semantic_index <= 0xFFFF );
ds = tgsi_default_declaration_semantic();

18
src/mesa/pipe/tgsi/exec/tgsi_dump.c
View File

@@ -202,13 +202,27 @@ static const char *TGSI_INTERPOLATES_SHORT[] =
static const char *TGSI_SEMANTICS[] =
{
"SEMANTIC_DEPTH",
"SEMANTIC_COLOR"
"SEMANTIC_COLOR0",
"SEMANTIC_COLOR1",
"SEMANTIC_COLOR0B",
"SEMANTIC_COLOR1B",
"SEMANTIC_POSITION",
"SEMANTIC_FOG",
"SEMANTIC_OTHER,"
"SEMANTIC_TEX0",
};
static const char *TGSI_SEMANTICS_SHORT[] =
{
"DEPTH",
"COLOR"
"COLOR0",
"COLOR1",
"COLOR0B",
"COLOR1B",
"POSITION",
"FOG",
"OTHER",
"TEX0"
};
static const char *TGSI_IMMS[] =

31
src/mesa/pipe/tgsi/exec/tgsi_token.h
View File

@@ -73,11 +73,11 @@ struct tgsi_declaration
{
unsigned Type : 4; /* TGSI_TOKEN_TYPE_DECLARATION */
unsigned Size : 8; /* UINT */
unsigned File : 4; /* TGSI_FILE_ */
unsigned Declare : 4; /* TGSI_DECLARE_ */
unsigned UsageMask : 4; /* TGSI_WRITEMASK_ */
unsigned Interpolate : 1; /* BOOL */
unsigned Semantic : 1; /* BOOL */
unsigned File : 4; /* one of TGSI_FILE_x */
unsigned Declare : 4; /* one of TGSI_DECLARE_x */
unsigned UsageMask : 4; /* bitmask of TGSI_WRITEMASK_x flags */
unsigned Interpolate : 1; /* BOOL, any interpolation info? */
unsigned Semantic : 1; /* BOOL, any semantic info? */
unsigned Padding : 5;
unsigned Extended : 1; /* BOOL */
};
@@ -103,12 +103,27 @@ struct tgsi_declaration_interpolation
unsigned Padding : 28;
};
#define TGSI_SEMANTIC_DEPTH 0
#define TGSI_SEMANTIC_COLOR 1
#define TGSI_SEMANTIC_DEPTH 0
#define TGSI_SEMANTIC_COLOR0 1
#define TGSI_SEMANTIC_COLOR1 2
#define TGSI_SEMANTIC_COLOR0B 3 /**< back-face primary color */
#define TGSI_SEMANTIC_COLOR1B 4 /**< back-face secondary color */
#define TGSI_SEMANTIC_POSITION 5
#define TGSI_SEMANTIC_FOG 6
#define TGSI_SEMANTIC_OTHER 7 /* XXX temp */
#define TGSI_SEMANTIC_TEX0 8
#define TGSI_SEMANTIC_TEX1 9
#define TGSI_SEMANTIC_TEX2 10
#define TGSI_SEMANTIC_TEX3 11
#define TGSI_SEMANTIC_TEX4 12
#define TGSI_SEMANTIC_TEX5 13
#define TGSI_SEMANTIC_TEX6 14
#define TGSI_SEMANTIC_TEX7 15
#define TGSI_SEMANTIC_COUNT 16 /**< number of semantic values */
struct tgsi_declaration_semantic
{
unsigned SemanticName : 8; /* TGSI_SEMANTIC_ */
unsigned SemanticName : 8; /* one of TGSI_SEMANTIC_ */
unsigned SemanticIndex : 16; /* UINT */
unsigned Padding : 8;
};

118
src/mesa/pipe/tgsi/mesa/mesa_to_tgsi.c
View File

@@ -3,9 +3,9 @@
#include "pipe/tgsi/exec/tgsi_attribs.h"
#include "pipe/tgsi/mesa/mesa_to_tgsi.h"
#define TGSI_DEBUG 1
#define TGSI_DEBUG 0
#if 0
/**
* Convert a VERT_ATTRIB_x to a TGSI_ATTRIB_y
*/
@@ -209,9 +209,10 @@ tgsi_mesa_translate_fragment_output(GLuint attrib)
return 0;
}
}
#endif
#if 01
#if 0
uint
tgsi_mesa_translate_vertex_input_mask(GLbitfield mask)
{
@@ -225,7 +226,6 @@ tgsi_mesa_translate_vertex_input_mask(GLbitfield mask)
}
return tgsiMask;
}
#endif
uint
tgsi_mesa_translate_vertex_output_mask(GLbitfield mask)
@@ -271,6 +271,7 @@ tgsi_mesa_translate_fragment_output_mask(GLbitfield mask)
}
#endif
@@ -319,12 +320,16 @@ map_register_file_index(
GLuint processor,
GLuint file,
GLuint index,
#if 0
GLbitfield usage_bitmask,
#endif
const GLuint inputMapping[],
const GLuint outputMapping[])
{
GLuint mapped_index;
#if 0
GLuint i;
#endif
assert(processor == TGSI_PROCESSOR_FRAGMENT
|| processor == TGSI_PROCESSOR_VERTEX);
@@ -345,7 +350,8 @@ map_register_file_index(
inputMapping[index]);
return inputMapping[index];
}
assert(0);
#if 0
assert( usage_bitmask & (1 << index) );
mapped_index = 0;
for( i = 0; i < index; i++ ) {
@@ -354,6 +360,7 @@ map_register_file_index(
}
}
printf("Map %d input %d to %d\n", processor, index, mapped_index);
#endif
break;
case TGSI_FILE_OUTPUT:
@@ -375,14 +382,17 @@ map_register_file_index(
else {
/* vertex output slots are tightly packed, find mapped pos */
/* mapped_index = VERT_RESULT_x */
#if 0
mapped_index = 0;
for( i = 0; i < index; i++ ) {
if( usage_bitmask & (1 << i) ) {
mapped_index++;
}
}
printf("Map VP output from %d to %d\n", index, mapped_index);
assert(outputMapping[index] == mapped_index);
#endif
mapped_index = outputMapping[index];
printf("Map VP output from %d to %d\n", index, mapped_index);
}
break;
@@ -452,8 +462,10 @@ static GLboolean
compile_instruction(
const struct prog_instruction *inst,
struct tgsi_full_instruction *fullinst,
#if 0
GLuint inputs_read,
GLuint outputs_written,
#endif
const GLuint inputMapping[],
const GLuint outputMapping[],
GLuint preamble_size,
@@ -475,8 +487,14 @@ compile_instruction(
processor,
fulldst->DstRegister.File,
inst->DstReg.Index,
#if 0
outputs_written,
#endif
#if 0
NULL,
#else
inputMapping,
#endif
outputMapping
);
fulldst->DstRegister.WriteMask = convert_writemask( inst->DstReg.WriteMask );
@@ -490,7 +508,9 @@ compile_instruction(
processor,
fullsrc->SrcRegister.File,
inst->SrcReg[i].Index,
#if 0
inputs_read,
#endif
inputMapping,
outputMapping );
@@ -766,10 +786,10 @@ compile_instruction(
static struct tgsi_full_declaration
make_frag_input_decl(
GLuint first,
GLuint last,
GLuint index,
GLuint interpolate,
GLuint usage_mask )
GLuint usage_mask,
GLuint semantic_name )
{
struct tgsi_full_declaration decl;
@@ -777,9 +797,11 @@ make_frag_input_decl(
decl.Declaration.File = TGSI_FILE_INPUT;
decl.Declaration.Declare = TGSI_DECLARE_RANGE;
decl.Declaration.UsageMask = usage_mask;
decl.Declaration.Semantic = 1;
decl.Declaration.Interpolate = 1;
decl.u.DeclarationRange.First = first;
decl.u.DeclarationRange.Last = last;
decl.u.DeclarationRange.First = index;
decl.u.DeclarationRange.Last = index;
decl.Semantic.SemanticName = semantic_name;
decl.Interpolation.Interpolate = interpolate;
return decl;
@@ -809,15 +831,20 @@ make_frag_output_decl(
/**
* Convert Mesa fragment program to TGSI format.
* \param inputMapping array to map original Mesa fragment program inputs
* registers to TGSI generic input indexes
* \param interpMode array[FRAG_ATTRIB_x] of TGSI_INTERPOLATE_LINEAR/PERSP.
* \param inputMapping maps Mesa fragment program inputs to TGSI generic
* input indexes
* \param inputSemantic the TGSI_SEMANTIC flag for each input
* \param interpMode the TGSI_INTERPOLATE_LINEAR/PERSP mode for each input
* \param outputMapping maps Mesa fragment program outputs to TGSI
* generic outputs
*
*/
GLboolean
tgsi_mesa_compile_fp_program(
const struct gl_fragment_program *program,
GLuint numInputs,
const GLuint inputMapping[],
const ubyte inputSemantic[],
const GLuint interpMode[],
const GLuint outputMapping[],
struct tgsi_token *tokens,
@@ -831,9 +858,9 @@ tgsi_mesa_compile_fp_program(
/*
struct tgsi_full_dst_register *fulldst;
struct tgsi_full_src_register *fullsrc;
*/
GLuint inputs_read;
GLboolean reads_wpos;
*/
GLuint preamble_size = 0;
*(struct tgsi_version *) &tokens[0] = tgsi_build_version();
@@ -846,6 +873,7 @@ tgsi_mesa_compile_fp_program(
ti = 3;
#if 0
reads_wpos = program->Base.InputsRead & (1 << FRAG_ATTRIB_WPOS);
inputs_read = program->Base.InputsRead | (1 << FRAG_ATTRIB_WPOS);
@@ -856,10 +884,10 @@ tgsi_mesa_compile_fp_program(
/* Fragment position. */
if( reads_wpos ) {
fulldecl = make_frag_input_decl(
0,
0,
TGSI_INTERPOLATE_CONSTANT,
TGSI_WRITEMASK_XY );
TGSI_WRITEMASK_XY,
TGSI_SEMANTIC_POSITION );
ti += tgsi_build_full_declaration(
&fulldecl,
&tokens[ti],
@@ -869,10 +897,10 @@ tgsi_mesa_compile_fp_program(
/* Fragment zw. */
fulldecl = make_frag_input_decl(
0,
0,
TGSI_INTERPOLATE_LINEAR,
reads_wpos ? TGSI_WRITEMASK_ZW : TGSI_WRITEMASK_Z );
reads_wpos ? TGSI_WRITEMASK_ZW : TGSI_WRITEMASK_Z,
TGSI_SEMANTIC_POSITION );
ti += tgsi_build_full_declaration(
&fulldecl,
&tokens[ti],
@@ -884,15 +912,55 @@ tgsi_mesa_compile_fp_program(
if( inputs_read & (1 << i) ) {
count++;
fulldecl = make_frag_input_decl(count,
count,
interpMode[i],
TGSI_WRITEMASK_XYZW );
TGSI_WRITEMASK_XYZW,
inputSemantic[count] );
ti += tgsi_build_full_declaration(&fulldecl,
&tokens[ti],
header,
maxTokens - ti );
}
}
#else
for (i = 0; i < numInputs; i++) {
switch (inputSemantic[i]) {
case TGSI_SEMANTIC_POSITION:
/* Fragment XY pos */
fulldecl = make_frag_input_decl(i,
TGSI_INTERPOLATE_CONSTANT,
TGSI_WRITEMASK_XY,
TGSI_SEMANTIC_POSITION );
ti += tgsi_build_full_declaration(
&fulldecl,
&tokens[ti],
header,
maxTokens - ti );
/* Fragment ZW pos */
fulldecl = make_frag_input_decl(i,
TGSI_INTERPOLATE_LINEAR,
TGSI_WRITEMASK_ZW,
TGSI_SEMANTIC_POSITION );
ti += tgsi_build_full_declaration(
&fulldecl,
&tokens[ti],
header,
maxTokens - ti );
break;
default:
fulldecl = make_frag_input_decl(i,
interpMode[i],
TGSI_WRITEMASK_XYZW,
inputSemantic[i] );
ti += tgsi_build_full_declaration(&fulldecl,
&tokens[ti],
header,
maxTokens - ti );
break;
}
}
#endif
/*
* Declare output attributes.
@@ -914,7 +982,7 @@ tgsi_mesa_compile_fp_program(
if( program->Base.OutputsWritten & (1 << FRAG_RESULT_COLR) ) {
fulldecl = make_frag_output_decl(
1,
TGSI_SEMANTIC_COLOR,
TGSI_SEMANTIC_COLOR0,
TGSI_WRITEMASK_XYZW );
ti += tgsi_build_full_declaration(
&fulldecl,
@@ -956,8 +1024,10 @@ tgsi_mesa_compile_fp_program(
if( compile_instruction(
&program->Base.Instructions[i],
&fullinst,
#if 0
inputs_read,
~0, /*outputs_written*/
#endif
inputMapping,
outputMapping,
preamble_size,
@@ -992,10 +1062,12 @@ tgsi_mesa_compile_vp_program(
struct tgsi_header *header;
struct tgsi_processor *processor;
struct tgsi_full_instruction fullinst;
#if 0
GLuint inputs_read = ~0;
GLuint outputs_written;
outputs_written = program->Base.OutputsWritten;
#endif
*(struct tgsi_version *) &tokens[0] = tgsi_build_version();
@@ -1011,8 +1083,10 @@ tgsi_mesa_compile_vp_program(
if( compile_instruction(
&program->Base.Instructions[i],
&fullinst,
#if 0
inputs_read,
outputs_written,
#endif
inputMapping,
outputMapping,
0,

2
src/mesa/pipe/tgsi/mesa/mesa_to_tgsi.h
View File

@@ -10,7 +10,9 @@ struct tgsi_token;
GLboolean
tgsi_mesa_compile_fp_program(
const struct gl_fragment_program *program,
GLuint numInputs,
const GLuint inputMapping[],
const ubyte inputSemantic[],
const GLuint interpMode[],
const GLuint outputMapping[],
struct tgsi_token *tokens,

121
src/mesa/state_tracker/st_atom_fs.c
View File

@@ -27,6 +27,7 @@
/*
* Authors:
* Keith Whitwell <keith@tungstengraphics.com>
* Brian Paul
*/
#include "shader/prog_parameter.h"
@@ -42,55 +43,121 @@
#include "st_atom.h"
#include "st_program.h"
#define TGSI_DEBUG 1
static void compile_fs( struct st_context *st )
/**
* Translate a Mesa fragment shader into a TGSI shader.
* \return pointer to cached pipe_shader object.
*/
struct pipe_shader_state *
st_translate_fragment_shader(struct st_context *st,
struct st_fragment_program *stfp)
{
/* Map FRAG_RESULT_COLR to output 1, map FRAG_RESULT_DEPR to output 0 */
static const GLuint outputMapping[2] = {1, 0};
struct st_fragment_program *fp = st->fp;
GLuint outputMapping[FRAG_RESULT_MAX];
GLuint inputMapping[PIPE_MAX_SHADER_INPUTS];
struct pipe_shader_state fs;
struct pipe_shader_state *cached;
GLuint interpMode[16]; /* XXX size? */
GLuint i;
GLbitfield inputsRead = stfp->Base.Base.InputsRead;
/* Check if all fragment programs need the fragment position (in order
* to do perspective-corrected interpolation).
*/
if (st->pipe->get_param(st->pipe, PIPE_PARAM_FS_NEEDS_POS))
inputsRead |= FRAG_BIT_WPOS;
memset(&fs, 0, sizeof(fs));
for (i = 0; i < 16; i++) {
if (fp->Base.Base.InputsRead & (1 << i)) {
if (i == FRAG_ATTRIB_COL0 || i == FRAG_ATTRIB_COL1) {
interpMode[i] = TGSI_INTERPOLATE_LINEAR;
if (inputsRead & (1 << i)) {
inputMapping[i] = fs.num_inputs;
switch (i) {
case FRAG_ATTRIB_WPOS:
fs.input_semantics[fs.num_inputs] = TGSI_SEMANTIC_POSITION;
interpMode[fs.num_inputs] = TGSI_INTERPOLATE_CONSTANT;
break;
case FRAG_ATTRIB_COL0:
fs.input_semantics[fs.num_inputs] = TGSI_SEMANTIC_COLOR0;
interpMode[fs.num_inputs] = TGSI_INTERPOLATE_LINEAR;
break;
case FRAG_ATTRIB_COL1:
fs.input_semantics[fs.num_inputs] = TGSI_SEMANTIC_COLOR1;
interpMode[fs.num_inputs] = TGSI_INTERPOLATE_LINEAR;
break;
case FRAG_ATTRIB_TEX0:
fs.input_semantics[fs.num_inputs] = TGSI_SEMANTIC_TEX0;
interpMode[fs.num_inputs] = TGSI_INTERPOLATE_PERSPECTIVE;
break;
default:
assert(0);
}
else {
interpMode[i] = TGSI_INTERPOLATE_PERSPECTIVE;
fs.num_inputs++;
}
}
/*
* Outputs
*/
for (i = 0; i < FRAG_RESULT_MAX; i++) {
if (stfp->Base.Base.OutputsWritten & (1 << i)) {
switch (i) {
case FRAG_RESULT_DEPR:
fs.output_semantics[fs.num_outputs] = TGSI_SEMANTIC_DEPTH;
outputMapping[i] = fs.num_outputs;
break;
case FRAG_RESULT_COLR:
fs.output_semantics[fs.num_outputs] = TGSI_SEMANTIC_COLOR0;
outputMapping[i] = fs.num_outputs;
break;
default:
assert(0);
}
fs.num_outputs++;
}
}
/* XXX: fix static allocation of tokens:
*/
tgsi_mesa_compile_fp_program( &fp->Base, NULL, interpMode,
tgsi_mesa_compile_fp_program( &stfp->Base,
fs.num_inputs,
inputMapping,
fs.input_semantics,
interpMode,
outputMapping,
fp->tokens, ST_FP_MAX_TOKENS );
stfp->tokens, ST_FP_MAX_TOKENS );
memset(&fs, 0, sizeof(fs));
#if 0
fs.inputs_read
= tgsi_mesa_translate_fragment_input_mask(fp->Base.Base.InputsRead);
= tgsi_mesa_translate_fragment_input_mask(stfp->Base.Base.InputsRead);
#endif
#if 0
fs.outputs_written
= tgsi_mesa_translate_fragment_output_mask(fp->Base.Base.OutputsWritten);
fs.tokens = &fp->tokens[0];
= tgsi_mesa_translate_fragment_output_mask(stfp->Base.Base.OutputsWritten);
#endif
fs.tokens = &stfp->tokens[0];
cached = st_cached_fs_state(st, &fs);
fp->fsx = cached;
stfp->fs = cached;
if (TGSI_DEBUG)
tgsi_dump( fp->tokens, 0/*TGSI_DUMP_VERBOSE*/ );
tgsi_dump( stfp->tokens, 0/*TGSI_DUMP_VERBOSE*/ );
fp->dirty = 0;
stfp->dirty = 0;
return cached;
}
static void update_fs( struct st_context *st )
{
struct st_fragment_program *fp = NULL;
struct st_fragment_program *stfp = NULL;
/* find active shader and params. Changes to this Mesa state
* should be covered by ST_NEW_FRAGMENT_PROGRAM, thanks to the
@@ -101,21 +168,21 @@ static void update_fs( struct st_context *st )
st->ctx->Shader.CurrentProgram->FragmentProgram) {
struct gl_fragment_program *f
= st->ctx->Shader.CurrentProgram->FragmentProgram;
fp = st_fragment_program(f);
stfp = st_fragment_program(f);
}
else {
assert(st->ctx->FragmentProgram._Current);
fp = st_fragment_program(st->ctx->FragmentProgram._Current);
stfp = st_fragment_program(st->ctx->FragmentProgram._Current);
}
/* translate shader to TGSI format */
if (st->fp != fp || fp->dirty) {
st->fp = fp;
/* if new binding, or shader has changed */
if (st->fp != stfp || stfp->dirty) {
/* Bind the program */
st->fp = stfp;
if (fp->dirty)
compile_fs( st );
if (stfp->dirty)
st->state.fs = st_translate_fragment_shader( st, st->fp );
st->state.fs = fp->fsx;
st->pipe->bind_fs_state(st->pipe, st->state.fs);
}
}

120
src/mesa/state_tracker/st_atom_vs.c
View File

@@ -49,14 +49,15 @@
#define TGSI_DEBUG 1
/**
* Translate Mesa shader to TGSI format
* Translate a Mesa vertex shader into a TGSI shader.
* \return pointer to cached pipe_shader object.
*/
static void compile_vs( struct st_context *st )
struct pipe_shader_state *
st_translate_vertex_shader(struct st_context *st,
struct st_vertex_program *stvp)
{
struct st_vertex_program *vp = st->vp;
GLuint outputMapping[PIPE_MAX_SHADER_INPUTS];
struct pipe_shader_state vs;
struct pipe_shader_state *cached;
GLuint i;
@@ -69,20 +70,56 @@ static void compile_vs( struct st_context *st )
* values and TGSI generic input indexes.
*/
for (i = 0; i < MAX_VERTEX_PROGRAM_ATTRIBS; i++) {
if (vp->Base.Base.InputsRead & (1 << i)) {
vp->input_to_index[i] = vs.num_inputs;
vp->index_to_input[vs.num_inputs] = i;
if (stvp->Base.Base.InputsRead & (1 << i)) {
stvp->input_to_index[i] = vs.num_inputs;
stvp->index_to_input[vs.num_inputs] = i;
switch (i) {
case VERT_ATTRIB_POS:
vs.input_semantics[vs.num_inputs] = TGSI_SEMANTIC_POSITION;
break;
case VERT_ATTRIB_COLOR0:
vs.input_semantics[vs.num_inputs] = TGSI_SEMANTIC_COLOR0;
break;
case VERT_ATTRIB_COLOR1:
vs.input_semantics[vs.num_inputs] = TGSI_SEMANTIC_COLOR1;
break;
default:
vs.input_semantics[vs.num_inputs] = TGSI_SEMANTIC_OTHER;
}
vs.num_inputs++;
}
}
/*
* Determine output register mapping.
* Determine number of outputs and the register mapping.
*/
for (i = 0; i < VERT_RESULT_MAX; i++) {
if (vp->Base.Base.OutputsWritten & (1 << i)) {
vp->output_to_index[i] = vs.num_outputs;
vp->index_to_output[vs.num_outputs] = i;
if (stvp->Base.Base.OutputsWritten & (1 << i)) {
#if 0
stvp->output_to_index[i] = vs.num_outputs;
stvp->index_to_output[vs.num_outputs] = i;
#endif
outputMapping[i] = vs.num_outputs;
switch (i) {
case VERT_RESULT_HPOS:
vs.output_semantics[vs.num_outputs] = TGSI_SEMANTIC_POSITION;
break;
case VERT_RESULT_COL0:
vs.input_semantics[vs.num_inputs] = TGSI_SEMANTIC_COLOR0;
break;
case VERT_RESULT_COL1:
vs.input_semantics[vs.num_inputs] = TGSI_SEMANTIC_COLOR1;
break;
case VERT_RESULT_BFC0:
vs.input_semantics[vs.num_inputs] = TGSI_SEMANTIC_COLOR0B;
break;
case VERT_RESULT_BFC1:
vs.input_semantics[vs.num_inputs] = TGSI_SEMANTIC_COLOR1B;
break;
default:
vs.output_semantics[vs.num_outputs] = TGSI_SEMANTIC_OTHER;
}
vs.num_outputs++;
}
}
@@ -90,43 +127,50 @@ static void compile_vs( struct st_context *st )
/* XXX: fix static allocation of tokens:
*/
tgsi_mesa_compile_vp_program( &vp->Base,
vp->input_to_index,
vp->output_to_index,
vp->tokens, ST_FP_MAX_TOKENS );
#if 01
vs.inputs_read
= tgsi_mesa_translate_vertex_input_mask(vp->Base.Base.InputsRead);
tgsi_mesa_compile_vp_program( &stvp->Base,
stvp->input_to_index,
#if 0
stvp->output_to_index,
#else
outputMapping,
#endif
vs.outputs_written
= tgsi_mesa_translate_vertex_output_mask(vp->Base.Base.OutputsWritten);
stvp->tokens, ST_FP_MAX_TOKENS );
vs.tokens = &vp->tokens[0];
#if 0
vs.inputs_read
= tgsi_mesa_translate_vertex_input_mask(stvp->Base.Base.InputsRead);
#endif
#if 0
vs.outputs_written
= tgsi_mesa_translate_vertex_output_mask(stvp->Base.Base.OutputsWritten);
#endif
vs.tokens = &stvp->tokens[0];
cached = st_cached_vs_state(st, &vs);
vp->vs = cached;
stvp->vs = cached;
if (TGSI_DEBUG)
tgsi_dump( vp->tokens, 0 );
tgsi_dump( stvp->tokens, 0 );
#if defined(USE_X86_ASM) || defined(SLANG_X86)
if (vp->sse2_program.csr == vp->sse2_program.store)
tgsi_emit_sse2( vp->tokens, &vp->sse2_program );
if (stvp->sse2_program.csr == stvp->sse2_program.store)
tgsi_emit_sse2( stvp->tokens, &stvp->sse2_program );
if (!cached->executable)
cached->executable = (void *) x86_get_func( &vp->sse2_program );
cached->executable = (void *) x86_get_func( &stvp->sse2_program );
#endif
vp->dirty = 0;
stvp->dirty = 0;
return cached;
}
static void update_vs( struct st_context *st )
{
struct st_vertex_program *vp;
struct st_vertex_program *stvp;
/* find active shader and params -- Should be covered by
* ST_NEW_VERTEX_PROGRAM
@@ -136,20 +180,20 @@ static void update_vs( struct st_context *st )
st->ctx->Shader.CurrentProgram->VertexProgram) {
struct gl_vertex_program *f
= st->ctx->Shader.CurrentProgram->VertexProgram;
vp = st_vertex_program(f);
stvp = st_vertex_program(f);
}
else {
assert(st->ctx->VertexProgram._Current);
vp = st_vertex_program(st->ctx->VertexProgram._Current);
stvp = st_vertex_program(st->ctx->VertexProgram._Current);
}
if (st->vp != vp || vp->dirty) {
st->vp = vp;
if (st->vp != stvp || stvp->dirty) {
/* Bind the vertex program */
st->vp = stvp;
if (vp->dirty)
compile_vs( st );
if (stvp->dirty)
st->state.vs = st_translate_vertex_shader( st, st->vp );
st->state.vs = st->vp->vs;
st->pipe->bind_vs_state(st->pipe, st->state.vs);
}
}

45
src/mesa/state_tracker/st_cb_clear.c
View File

@@ -121,11 +121,9 @@ is_depth_stencil_format(GLuint pipeFormat)
static struct st_fragment_program *
make_frag_shader(struct st_context *st)
{
static const GLuint outputMapping[] = { 1, 0 };
GLcontext *ctx = st->ctx;
struct st_fragment_program *stfp;
struct gl_program *p;
GLboolean b;
GLuint interpMode[16];
GLuint i;
@@ -157,11 +155,7 @@ make_frag_shader(struct st_context *st)
p->OutputsWritten = (1 << FRAG_RESULT_COLR);
stfp = (struct st_fragment_program *) p;
/* compile into tgsi format */
b = tgsi_mesa_compile_fp_program(&stfp->Base, NULL, interpMode,
outputMapping,
stfp->tokens, ST_FP_MAX_TOKENS);
assert(b);
st_translate_fragment_shader(st, stfp);
return stfp;
}
@@ -174,15 +168,9 @@ make_frag_shader(struct st_context *st)
static struct st_vertex_program *
make_vertex_shader(struct st_context *st)
{
/* Map VERT_ATTRIB_POS to 0, VERT_ATTRIB_COLOR0 to 1 */
static const GLuint inputMapping[4] = { 0, 0, 0, 1 };
/* Map VERT_RESULT_HPOS to 0, VERT_RESULT_COL0 to 1 */
static const GLuint outputMapping[2] = { 0, 1 };
GLcontext *ctx = st->ctx;
struct st_vertex_program *stvp;
struct gl_program *p;
GLboolean b;
p = ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0);
if (!p)
@@ -215,12 +203,8 @@ make_vertex_shader(struct st_context *st)
(1 << VERT_RESULT_HPOS));
stvp = (struct st_vertex_program *) p;
/* compile into tgsi format */
b = tgsi_mesa_compile_vp_program(&stvp->Base,
inputMapping,
outputMapping,
stvp->tokens, ST_FP_MAX_TOKENS);
assert(b);
st_translate_vertex_shader(st, stvp);
assert(stvp->vs);
return stvp;
}
@@ -361,33 +345,19 @@ clear_with_quad(GLcontext *ctx,
/* fragment shader state: color pass-through program */
{
static struct st_fragment_program *stfp = NULL;
struct pipe_shader_state fs;
const struct pipe_shader_state *cached;
if (!stfp) {
stfp = make_frag_shader(st);
}
memset(&fs, 0, sizeof(fs));
fs.inputs_read = tgsi_mesa_translate_fragment_input_mask(stfp->Base.Base.InputsRead);
fs.outputs_written = tgsi_mesa_translate_fragment_output_mask(stfp->Base.Base.OutputsWritten);
fs.tokens = &stfp->tokens[0];
cached = st_cached_fs_state(st, &fs);
pipe->bind_fs_state(pipe, cached);
pipe->bind_fs_state(pipe, stfp->fs);
}
/* vertex shader state: color/position pass-through */
{
static struct st_vertex_program *stvp = NULL;
struct pipe_shader_state vs;
const struct pipe_shader_state *cached;
if (!stvp) {
stvp = make_vertex_shader(st);
}
memset(&vs, 0, sizeof(vs));
vs.inputs_read = stvp->Base.Base.InputsRead;
vs.outputs_written = stvp->Base.Base.OutputsWritten;
vs.tokens = &stvp->tokens[0];
cached = st_cached_vs_state(st, &vs);
pipe->bind_vs_state(pipe, cached);
pipe->bind_vs_state(pipe, stvp->vs);
}
/* viewport state: viewport matching window dims */
@@ -522,12 +492,15 @@ clear_depth_buffer(GLcontext *ctx, struct gl_renderbuffer *rb)
assert(strb->surface->format);
#if 01
if (ctx->Scissor.Enabled ||
(isDS && ctx->DrawBuffer->Visual.stencilBits > 0)) {
/* scissoring or we have a combined depth/stencil buffer */
clear_with_quad(ctx, GL_FALSE, GL_TRUE, GL_FALSE);
}
else {
else
#endif
{
/* simple clear of whole buffer */
GLuint clearValue = depth_value(strb->surface->format, ctx->Depth.Clear);
ctx->st->pipe->clear(ctx->st->pipe, strb->surface, clearValue);

33
src/mesa/state_tracker/st_cb_drawpixels.c
View File

@@ -56,11 +56,9 @@
static struct st_fragment_program *
make_fragment_shader(struct st_context *st)
{
static const GLuint outputMapping[2] = { 1, 0 };
GLcontext *ctx = st->ctx;
struct st_fragment_program *stfp;
struct gl_program *p;
GLboolean b;
GLuint interpMode[16];
GLuint i;
@@ -94,11 +92,7 @@ make_fragment_shader(struct st_context *st)
p->OutputsWritten = (1 << FRAG_RESULT_COLR);
stfp = (struct st_fragment_program *) p;
/* compile into tgsi format */
b = tgsi_mesa_compile_fp_program(&stfp->Base, NULL, interpMode,
outputMapping,
stfp->tokens, ST_FP_MAX_TOKENS);
assert(b);
st_translate_fragment_shader(st, stfp);
return stfp;
}
@@ -112,11 +106,9 @@ static struct st_vertex_program *
make_vertex_shader(struct st_context *st)
{
/* Map VERT_RESULT_HPOS to 0, VERT_RESULT_TEX0 to 1 */
static const GLuint outputMapping[] = { 0, 0, 0, 0, 1 };
GLcontext *ctx = st->ctx;
struct st_vertex_program *stvp;
struct gl_program *p;
GLboolean b;
p = ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0);
if (!p)
@@ -149,11 +141,7 @@ make_vertex_shader(struct st_context *st)
(1 << VERT_RESULT_HPOS));
stvp = (struct st_vertex_program *) p;
/* compile into tgsi format */
b = tgsi_mesa_compile_vp_program(&stvp->Base, NULL,
outputMapping,
stvp->tokens, ST_FP_MAX_TOKENS);
assert(b);
st_translate_vertex_shader(st, stvp);
return stvp;
}
@@ -339,32 +327,19 @@ draw_textured_quad(GLcontext *ctx, GLint x, GLint y, GLfloat z,
/* fragment shader state: TEX lookup program */
{
static struct st_fragment_program *stfp = NULL;
struct pipe_shader_state fs;
struct pipe_shader_state *cached;
if (!stfp) {
stfp = make_fragment_shader(ctx->st);
}
memset(&fs, 0, sizeof(fs));
fs.inputs_read = stfp->Base.Base.InputsRead;
fs.tokens = &stfp->tokens[0];
cached = st_cached_fs_state(ctx->st, &fs);
pipe->bind_fs_state(pipe, cached);
pipe->bind_fs_state(pipe, stfp->fs);
}
/* vertex shader state: position + texcoord pass-through */
{
static struct st_vertex_program *stvp = NULL;
struct pipe_shader_state vs;
struct pipe_shader_state *cached;
if (!stvp) {
stvp = make_vertex_shader(ctx->st);
}
memset(&vs, 0, sizeof(vs));
vs.inputs_read = stvp->Base.Base.InputsRead;
vs.outputs_written = stvp->Base.Base.OutputsWritten;
vs.tokens = &stvp->tokens[0];
cached = st_cached_vs_state(ctx->st, &vs);
pipe->bind_vs_state(pipe, cached);
pipe->bind_vs_state(pipe, stvp->vs);
}
/* texture sampling state: */

13
src/mesa/state_tracker/st_cb_rasterpos.c
View File

@@ -53,6 +53,7 @@ static void
setup_vertex_attribs(GLcontext *ctx)
{
struct pipe_context *pipe = ctx->st->pipe;
#if 0
const uint inputAttrs = ctx->st->state.vs->inputs_read;
uint attr;
@@ -77,6 +78,9 @@ setup_vertex_attribs(GLcontext *ctx)
pipe->set_vertex_element(pipe, attr, &velement);
}
}
#else
assert(0);
#endif
}
@@ -84,7 +88,7 @@ static void
setup_feedback(GLcontext *ctx)
{
struct pipe_context *pipe = ctx->st->pipe;
const uint outputAttrs = ctx->st->state.vs->outputs_written;
const struct pipe_shader_state *vs = ctx->st->state.vs;
struct pipe_feedback_state feedback;
uint i;
@@ -94,8 +98,8 @@ setup_feedback(GLcontext *ctx)
feedback.discard = 1;
feedback.num_attribs = 0;
for (i = 0; i < TGSI_ATTRIB_VAR0; i++) {
if ((1 << i) & outputAttrs) {
for (i = 0; i < vs->num_outputs; i++) {
if (1/***(1 << i) & outputAttrs***/) {
feedback.attrib[feedback.num_attribs] = i;
feedback.size[feedback.num_attribs] = 4;
feedback.num_attribs++;
@@ -306,6 +310,7 @@ st_RasterPos(GLcontext *ctx, const GLfloat v[4])
PIPE_BUFFER_FLAG_READ);
/* extract values and update rasterpos state */
#if 0 /* XXX update */
{
const uint outputAttrs = ctx->st->state.vs->outputs_written;
const float *pos, *color0, *color1, *tex0;
@@ -333,7 +338,7 @@ st_RasterPos(GLcontext *ctx, const GLfloat v[4])
update_rasterpos(ctx, pos, color0, color1, tex0);
}
#endif
/* free vertex feedback buffer */
pipe->winsys->buffer_unmap(pipe->winsys, fb_buf.buffer);

8
src/mesa/state_tracker/st_draw.c
View File

@@ -356,7 +356,7 @@ st_draw_vertices(GLcontext *ctx, unsigned prim,
velement.vertex_buffer_index = 0;
velement.src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
velement.dst_offset = 0;
pipe->set_vertex_element(pipe, attribs[i], &velement);
pipe->set_vertex_element(pipe, i/**attribs[i]**/, &velement);
}
/* draw */
@@ -411,7 +411,7 @@ st_feedback_draw_vbo(GLcontext *ctx,
update_default_attribs_buffer(ctx);
#if 0
/* this must be after state validation */
attrsNeeded = ctx->st->state.vs->inputs_read;
@@ -480,7 +480,9 @@ st_feedback_draw_vbo(GLcontext *ctx,
draw_set_mapped_vertex_buffer(draw, attr, map);
}
}
#else
assert(0);
#endif
if (ib) {
unsigned indexSize;

27
src/mesa/state_tracker/st_program.h
View File

@@ -45,16 +45,15 @@ struct st_fragment_program
{
struct gl_fragment_program Base;
GLboolean error; /* If program is malformed for any reason. */
GLuint id; /* String id, for tracking
* ProgramStringNotify changes.
*/
GLuint id; /**< String id, for tracking ProgramStringNotify changes. */
struct tgsi_token tokens[ST_FP_MAX_TOKENS];
GLboolean dirty;
const struct pipe_shader_state *fsx;
/** Pointer to the corresponding cached shader */
const struct pipe_shader_state *fs;
GLuint param_state;
};
@@ -63,16 +62,17 @@ struct st_vertex_program
{
struct gl_vertex_program Base; /**< The Mesa vertex program */
GLboolean error; /**< Set if program is malformed for any reason. */
GLuint id; /**< String id, for tracking ProgramStringNotify changes. */
GLuint id; /**< String id, for tracking ProgramStringNotify changes. */
/** maps a Mesa VERT_ATTRIB_x to a packed TGSI input index */
GLuint input_to_index[MAX_VERTEX_PROGRAM_ATTRIBS];
/** maps a TGSI input index back to a Mesa VERT_ATTRIB_x */
GLuint index_to_input[MAX_VERTEX_PROGRAM_ATTRIBS];
#if 0
GLuint output_to_index[MAX_VERTEX_PROGRAM_ATTRIBS];
GLuint index_to_output[MAX_VERTEX_PROGRAM_ATTRIBS];
#endif
/** The program in TGSI format */
struct tgsi_token tokens[ST_FP_MAX_TOKENS];
@@ -82,7 +82,9 @@ struct st_vertex_program
struct x86_function sse2_program;
#endif
/** Pointer to the corresponding cached shader */
const struct pipe_shader_state *vs;
GLuint param_state;
};
@@ -102,4 +104,15 @@ st_vertex_program( struct gl_vertex_program *vp )
return (struct st_vertex_program *)vp;
}
extern struct pipe_shader_state *
st_translate_fragment_shader(struct st_context *st,
struct st_fragment_program *fp);
extern struct pipe_shader_state *
st_translate_vertex_shader(struct st_context *st,
struct st_vertex_program *vp);
#endif