src/mesa/shader/slang/slang_storage.h

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  6.3
   4  *
   5  * Copyright (C) 2005  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         unsigned int length;
  67 } slang_storage_array;
  68
  69 void slang_storage_array_construct (slang_storage_array *);
  70 void 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         unsigned int count;
  82 } slang_storage_aggregate;
  83
  84 void slang_storage_aggregate_construct (slang_storage_aggregate *);
  85 void slang_storage_aggregate_destruct (slang_storage_aggregate *);
  86
  87 int _slang_aggregate_variable (slang_storage_aggregate *, struct slang_type_specifier_ *,
  88         struct slang_operation_ *, struct slang_function_scope_ *, slang_struct_scope *);
  89
  90 /*
  91         returns total size (in machine units) of the given aggregate
  92         returns 0 on error
  93 */
  94 unsigned int _slang_sizeof_aggregate (const slang_storage_aggregate *);
  95
  96 /*
  97         converts structured aggregate to a flat one, with arrays of generic type being
  98         one-element long
  99         returns 1 on success
 100         returns 0 otherwise
 101 */
 102 int _slang_flatten_aggregate (slang_storage_aggregate *, const slang_storage_aggregate *);
 103
 104 #ifdef __cplusplus
 105 }
 106 #endif
 107
 108 #endif
 109