src/gallium/auxiliary/util/u_simple_shaders.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 /**
  29  * @file
  30  * Simple vertex/fragment shader generators.
  31  *
  32  * @author Brian Paul
  33  */
  34
  35
  36 #include "pipe/p_context.h"
  37 #include "pipe/p_debug.h"
  38 #include "pipe/p_defines.h"
  39 #include "pipe/p_inlines.h"
  40 #include "pipe/p_util.h"
  41 #include "pipe/p_winsys.h"
  42 #include "pipe/p_shader_tokens.h"
  43
  44 #include "util/u_simple_shaders.h"
  45
  46 #include "tgsi/util/tgsi_build.h"
  47 #include "tgsi/util/tgsi_dump.h"
  48 #include "tgsi/util/tgsi_parse.h"
  49
  50
  51
  52 /**
  53  * Make simple vertex pass-through shader.
  54  */
  55 void *
  56 util_make_vertex_passthrough_shader(struct pipe_context *pipe,
  57                                     uint num_attribs,
  58                                     const uint *semantic_names,
  59                                     const uint *semantic_indexes,
  60                                     struct pipe_shader_state *shader)
  61
  62 {
  63    uint maxTokens = 100;
  64    struct tgsi_token *tokens;
  65    struct tgsi_header *header;
  66    struct tgsi_processor *processor;
  67    struct tgsi_full_declaration decl;
  68    struct tgsi_full_instruction inst;
  69    const uint procType = TGSI_PROCESSOR_VERTEX;
  70    uint ti, i;
  71
  72    tokens = (struct tgsi_token *) MALLOC(maxTokens * sizeof(tokens[0]));
  73
  74    /* shader header
  75     */
  76    *(struct tgsi_version *) &tokens[0] = tgsi_build_version();
  77
  78    header = (struct tgsi_header *) &tokens[1];
  79    *header = tgsi_build_header();
  80
  81    processor = (struct tgsi_processor *) &tokens[2];
  82    *processor = tgsi_build_processor( procType, header );
  83
  84    ti = 3;
  85
  86    /* declare inputs */
  87    for (i = 0; i < num_attribs; i++) {
  88       decl = tgsi_default_full_declaration();
  89       decl.Declaration.File = TGSI_FILE_INPUT;
  90
  91       decl.Declaration.Semantic = 1;
  92       decl.Semantic.SemanticName = semantic_names[i];
  93       decl.Semantic.SemanticIndex = semantic_indexes[i];
  94
  95       decl.u.DeclarationRange.First =
  96       decl.u.DeclarationRange.Last = i;
  97       ti += tgsi_build_full_declaration(&decl,
  98                                         &tokens[ti],
  99                                         header,
 100                                         maxTokens - ti);
 101    }
 102
 103    /* declare outputs */
 104    for (i = 0; i < num_attribs; i++) {
 105       decl = tgsi_default_full_declaration();
 106       decl.Declaration.File = TGSI_FILE_OUTPUT;
 107       decl.Declaration.Semantic = 1;
 108       decl.Semantic.SemanticName = semantic_names[i];
 109       decl.Semantic.SemanticIndex = semantic_indexes[i];
 110       decl.u.DeclarationRange.First =
 111          decl.u.DeclarationRange.Last = i;
 112       ti += tgsi_build_full_declaration(&decl,
 113                                         &tokens[ti],
 114                                         header,
 115                                         maxTokens - ti);
 116    }
 117
 118    /* emit MOV instructions */
 119    for (i = 0; i < num_attribs; i++) {
 120       /* MOVE out[i], in[i]; */
 121       inst = tgsi_default_full_instruction();
 122       inst.Instruction.Opcode = TGSI_OPCODE_MOV;
 123       inst.Instruction.NumDstRegs = 1;
 124       inst.FullDstRegisters[0].DstRegister.File = TGSI_FILE_OUTPUT;
 125       inst.FullDstRegisters[0].DstRegister.Index = i;
 126       inst.Instruction.NumSrcRegs = 1;
 127       inst.FullSrcRegisters[0].SrcRegister.File = TGSI_FILE_INPUT;
 128       inst.FullSrcRegisters[0].SrcRegister.Index = i;
 129       ti += tgsi_build_full_instruction(&inst,
 130                                         &tokens[ti],
 131                                         header,
 132                                         maxTokens - ti );
 133    }
 134
 135    /* END instruction */
 136    inst = tgsi_default_full_instruction();
 137    inst.Instruction.Opcode = TGSI_OPCODE_END;
 138    inst.Instruction.NumDstRegs = 0;
 139    inst.Instruction.NumSrcRegs = 0;
 140    ti += tgsi_build_full_instruction(&inst,
 141                                      &tokens[ti],
 142                                      header,
 143                                      maxTokens - ti );
 144
 145 #if 0 /*debug*/
 146    tgsi_dump(tokens, 0);
 147 #endif
 148
 149    shader->tokens = tokens;
 150    /*shader->num_tokens = ti;*/
 151
 152    return pipe->create_vs_state(pipe, shader);
 153 }
 154
 155
 156
 157
 158 /**
 159  * Make simple fragment texture shader:
 160  *  TEX OUT[0], IN[0], SAMP[0], 2D;
 161  *  END;
 162  */
 163 void *
 164 util_make_fragment_tex_shader(struct pipe_context *pipe,
 165                               struct pipe_shader_state *shader)
 166 {
 167    uint maxTokens = 100;
 168    struct tgsi_token *tokens;
 169    struct tgsi_header *header;
 170    struct tgsi_processor *processor;
 171    struct tgsi_full_declaration decl;
 172    struct tgsi_full_instruction inst;
 173    const uint procType = TGSI_PROCESSOR_FRAGMENT;
 174    uint ti;
 175
 176    tokens = (struct tgsi_token *) MALLOC(maxTokens * sizeof(tokens[0]));
 177
 178    /* shader header
 179     */
 180    *(struct tgsi_version *) &tokens[0] = tgsi_build_version();
 181
 182    header = (struct tgsi_header *) &tokens[1];
 183    *header = tgsi_build_header();
 184
 185    processor = (struct tgsi_processor *) &tokens[2];
 186    *processor = tgsi_build_processor( procType, header );
 187
 188    ti = 3;
 189
 190    /* declare TEX[0] input */
 191    decl = tgsi_default_full_declaration();
 192    decl.Declaration.File = TGSI_FILE_INPUT;
 193    decl.Declaration.Semantic = 1;
 194    decl.Semantic.SemanticName = TGSI_SEMANTIC_GENERIC;
 195    decl.Semantic.SemanticIndex = 0;
 196    /* XXX this could be linear... */
 197    decl.Declaration.Interpolate = 1;
 198    decl.Interpolation.Interpolate = TGSI_INTERPOLATE_PERSPECTIVE;
 199    decl.u.DeclarationRange.First =
 200    decl.u.DeclarationRange.Last = 0;
 201    ti += tgsi_build_full_declaration(&decl,
 202                                      &tokens[ti],
 203                                      header,
 204                                      maxTokens - ti);
 205
 206    /* declare color[0] output */
 207    decl = tgsi_default_full_declaration();
 208    decl.Declaration.File = TGSI_FILE_OUTPUT;
 209    decl.Declaration.Semantic = 1;
 210    decl.Semantic.SemanticName = TGSI_SEMANTIC_COLOR;
 211    decl.Semantic.SemanticIndex = 0;
 212    decl.u.DeclarationRange.First =
 213    decl.u.DeclarationRange.Last = 0;
 214    ti += tgsi_build_full_declaration(&decl,
 215                                      &tokens[ti],
 216                                      header,
 217                                      maxTokens - ti);
 218
 219    /* declare sampler */
 220    decl = tgsi_default_full_declaration();
 221    decl.Declaration.File = TGSI_FILE_SAMPLER;
 222    decl.u.DeclarationRange.First =
 223    decl.u.DeclarationRange.Last = 0;
 224    ti += tgsi_build_full_declaration(&decl,
 225                                      &tokens[ti],
 226                                      header,
 227                                      maxTokens - ti);
 228
 229    /* TEX instruction */
 230    inst = tgsi_default_full_instruction();
 231    inst.Instruction.Opcode = TGSI_OPCODE_TEX;
 232    inst.Instruction.NumDstRegs = 1;
 233    inst.FullDstRegisters[0].DstRegister.File = TGSI_FILE_OUTPUT;
 234    inst.FullDstRegisters[0].DstRegister.Index = 0;
 235    inst.Instruction.NumSrcRegs = 2;
 236    inst.InstructionExtTexture.Texture = TGSI_TEXTURE_2D;
 237    inst.FullSrcRegisters[0].SrcRegister.File = TGSI_FILE_INPUT;
 238    inst.FullSrcRegisters[0].SrcRegister.Index = 0;
 239    inst.FullSrcRegisters[1].SrcRegister.File = TGSI_FILE_SAMPLER;
 240    inst.FullSrcRegisters[1].SrcRegister.Index = 0;
 241    ti += tgsi_build_full_instruction(&inst,
 242                                      &tokens[ti],
 243                                      header,
 244                                      maxTokens - ti );
 245
 246    /* END instruction */
 247    inst = tgsi_default_full_instruction();
 248    inst.Instruction.Opcode = TGSI_OPCODE_END;
 249    inst.Instruction.NumDstRegs = 0;
 250    inst.Instruction.NumSrcRegs = 0;
 251    ti += tgsi_build_full_instruction(&inst,
 252                                      &tokens[ti],
 253                                      header,
 254                                      maxTokens - ti );
 255
 256 #if 0 /*debug*/
 257    tgsi_dump(tokens, 0);
 258 #endif
 259
 260    shader->tokens = tokens;
 261    /*shader->num_tokens = ti;*/
 262
 263    return pipe->create_fs_state(pipe, shader);
 264 }
 265
 266
 267
 268
 269
 270 /**
 271  * Make simple fragment color pass-through shader.
 272  */
 273 void *
 274 util_make_fragment_passthrough_shader(struct pipe_context *pipe,
 275                                       struct pipe_shader_state *shader)
 276 {
 277    uint maxTokens = 40;
 278    struct tgsi_token *tokens;
 279    struct tgsi_header *header;
 280    struct tgsi_processor *processor;
 281    struct tgsi_full_declaration decl;
 282    struct tgsi_full_instruction inst;
 283    const uint procType = TGSI_PROCESSOR_FRAGMENT;
 284    uint ti;
 285
 286    tokens = (struct tgsi_token *) MALLOC(maxTokens * sizeof(tokens[0]));
 287
 288    /* shader header
 289     */
 290    *(struct tgsi_version *) &tokens[0] = tgsi_build_version();
 291
 292    header = (struct tgsi_header *) &tokens[1];
 293    *header = tgsi_build_header();
 294
 295    processor = (struct tgsi_processor *) &tokens[2];
 296    *processor = tgsi_build_processor( procType, header );
 297
 298    ti = 3;
 299
 300    /* declare input */
 301    decl = tgsi_default_full_declaration();
 302    decl.Declaration.File = TGSI_FILE_INPUT;
 303    decl.Declaration.Semantic = 1;
 304    decl.Semantic.SemanticName = TGSI_SEMANTIC_COLOR;
 305    decl.Semantic.SemanticIndex = 0;
 306    decl.u.DeclarationRange.First =
 307       decl.u.DeclarationRange.Last = 0;
 308    ti += tgsi_build_full_declaration(&decl,
 309                                      &tokens[ti],
 310                                      header,
 311                                      maxTokens - ti);
 312
 313    /* declare output */
 314    decl = tgsi_default_full_declaration();
 315    decl.Declaration.File = TGSI_FILE_OUTPUT;
 316    decl.Declaration.Semantic = 1;
 317    decl.Semantic.SemanticName = TGSI_SEMANTIC_COLOR;
 318    decl.Semantic.SemanticIndex = 0;
 319    decl.u.DeclarationRange.First =
 320       decl.u.DeclarationRange.Last = 0;
 321    ti += tgsi_build_full_declaration(&decl,
 322                                      &tokens[ti],
 323                                      header,
 324                                      maxTokens - ti);
 325
 326
 327    /* MOVE out[0], in[0]; */
 328    inst = tgsi_default_full_instruction();
 329    inst.Instruction.Opcode = TGSI_OPCODE_MOV;
 330    inst.Instruction.NumDstRegs = 1;
 331    inst.FullDstRegisters[0].DstRegister.File = TGSI_FILE_OUTPUT;
 332    inst.FullDstRegisters[0].DstRegister.Index = 0;
 333    inst.Instruction.NumSrcRegs = 1;
 334    inst.FullSrcRegisters[0].SrcRegister.File = TGSI_FILE_INPUT;
 335    inst.FullSrcRegisters[0].SrcRegister.Index = 0;
 336    ti += tgsi_build_full_instruction(&inst,
 337                                      &tokens[ti],
 338                                      header,
 339                                      maxTokens - ti );
 340
 341    /* END instruction */
 342    inst = tgsi_default_full_instruction();
 343    inst.Instruction.Opcode = TGSI_OPCODE_END;
 344    inst.Instruction.NumDstRegs = 0;
 345    inst.Instruction.NumSrcRegs = 0;
 346    ti += tgsi_build_full_instruction(&inst,
 347                                      &tokens[ti],
 348                                      header,
 349                                      maxTokens - ti );
 350
 351    assert(ti < maxTokens);
 352
 353 #if 0 /*debug*/
 354    tgsi_dump(tokens, 0);
 355 #endif
 356
 357    shader->tokens = tokens;
 358    /*shader->num_tokens = ti;*/
 359
 360    return pipe->create_fs_state(pipe, shader);
 361 }
 362