src/mesa/shader/slang/slang_storage.h

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  6.5
   4  *
   5  * Copyright (C) 2005-2006  Brian Paul   All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 #if !defined SLANG_STORAGE_H
  26 #define SLANG_STORAGE_H
  27
  28 #include "slang_compile.h"
  29
  30 #if defined __cplusplus
  31 extern "C" {
  32 #endif
  33
  34 /*
  35  * Program variable data storage is kept completely transparent to the front-end compiler. It is
  36  * up to the back-end how the data is actually allocated. The slang_storage_type enum
  37  * provides the basic information about how the memory is interpreted. This abstract piece
  38  * of memory is called a data slot. A data slot of a particular type has a fixed size.
  39  *
  40  * For now, only the three basic types are supported, that is bool, int and float. Other built-in
  41  * types like vector or matrix can easily be decomposed into a series of basic types.
  42  */
  43 typedef enum slang_storage_type_
  44 {
  45         slang_stor_aggregate,
  46         slang_stor_bool,
  47         slang_stor_int,
  48         slang_stor_float
  49 } slang_storage_type;
  50
  51 /*
  52  * The slang_storage_array structure groups data slots of the same type into an array. This
  53  * array has a fixed length. Arrays are required to have a size equal to the sum of sizes of its
  54  * elements. They are also required to support indirect addressing. That is, if B references
  55  * first data slot in the array, S is the size of the data slot and I is the integral index that
  56  * is not known at compile time, B+I*S references I-th data slot.
  57  *
  58  * This structure is also used to break down built-in data types that are not supported directly.
  59  * Vectors, like vec3, are constructed from arrays of their basic types. Matrices are formed of
  60  * an array of column vectors, which are in turn processed as other vectors.
  61  */
  62 typedef struct slang_storage_array_
  63 {
  64         slang_storage_type type;
  65         struct slang_storage_aggregate_ *aggregate;     /* slang_stor_aggregate */
  66         GLuint length;
  67 } slang_storage_array;
  68
  69 GLboolean slang_storage_array_construct (slang_storage_array *);
  70 GLvoid slang_storage_array_destruct (slang_storage_array *);
  71
  72 /*
  73  * The slang_storage_aggregate structure relaxes the indirect addressing requirement for
  74  * slang_storage_array structure. Aggregates are always accessed statically - its member
  75  * addresses are well-known at compile time. For example, user-defined types are implemented as
  76  * aggregates. Aggregates can collect data of a different type.
  77  */
  78 typedef struct slang_storage_aggregate_
  79 {
  80         slang_storage_array *arrays;
  81         GLuint count;
  82 } slang_storage_aggregate;
  83
  84 GLboolean slang_storage_aggregate_construct (slang_storage_aggregate *);
  85 GLvoid slang_storage_aggregate_destruct (slang_storage_aggregate *);
  86
  87 GLboolean _slang_aggregate_variable (slang_storage_aggregate *, struct slang_type_specifier_ *,
  88         struct slang_operation_ *, struct slang_function_scope_ *, slang_struct_scope *,
  89         slang_variable_scope *, struct slang_machine_ *, struct slang_assembly_file_ *,
  90         slang_atom_pool *);
  91
  92 /*
  93  * Returns total size (in machine units) of the given aggregate.
  94  * Returns 0 on error.
  95  */
  96 GLuint _slang_sizeof_aggregate (const slang_storage_aggregate *);
  97
  98 /*
  99  * Converts structured aggregate to a flat one, with arrays of generic type being
 100  * one-element long.
 101  * Returns GL_TRUE on success.
 102  * Returns GL_FALSE otherwise.
 103  */
 104 GLboolean _slang_flatten_aggregate (slang_storage_aggregate *, const slang_storage_aggregate *);
 105
 106 #ifdef __cplusplus
 107 }
 108 #endif
 109
 110 #endif
 111