← Back to branch summary

~ubuntu-branches/ubuntu/quantal/mesa/quantal

« back to all changes in this revision

Viewing changes to src/mesa/shader/slang/slang_link.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2007-02-21 12:44:07 UTC
  • mfrom: (1.2.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 22.
  • Revision ID: james.westby@ubuntu.com-20070221124407-rgcacs32mycrtadl
Import upstream version 6.5.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mesa/shader/slang/slang_link.c
1
1
/*
2
2
 * Mesa 3-D graphics library
3
 
 * Version:  6.5
 
3
 * Version:  6.6
4
4
 *
5
5
 * Copyright (C) 2006  Brian Paul   All Rights Reserved.
6
6
 *
32
32
#include "slang_link.h"
33
33
#include "slang_analyse.h"
34
34
 
35
 
static GLboolean entry_has_gl_prefix (slang_atom name, slang_atom_pool *atoms)
 
35
#define TABLE_GROW(PTR,TYPE,N) \
 
36
   (PTR = (TYPE *) (slang_alloc_realloc (PTR, N * sizeof (TYPE), (N + 1) * sizeof (TYPE))))
 
37
 
 
38
/*
 
39
 * Check if a given name starts with "gl_". Globals with this prefix are
 
40
 * treated differently, as they are built-in variables.
 
41
 */
 
42
static GLboolean
 
43
entry_has_gl_prefix (slang_atom name, slang_atom_pool *atoms)
36
44
{
37
 
        const char *str = slang_atom_pool_id (atoms, name);
38
 
        return str[0] == 'g' && str[1] == 'l' && str[2] == '_';
 
45
   const GLchar *str;
 
46
 
 
47
   str = slang_atom_pool_id (atoms, name);
 
48
   return str[0] == 'g' && str[1] == 'l' && str[2] == '_';
39
49
}
40
50
 
41
51
/*
42
52
 * slang_active_variables
43
53
 */
44
54
 
45
 
static GLvoid slang_active_variables_ctr (slang_active_variables *self)
46
 
{
47
 
        self->table = NULL;
48
 
        self->count = 0;
49
 
}
50
 
 
51
 
static GLvoid slang_active_variables_dtr (slang_active_variables *self)
52
 
{
53
 
        GLuint i;
54
 
 
55
 
        for (i = 0; i < self->count; i++)
56
 
                slang_alloc_free (self->table[i].name);
57
 
        slang_alloc_free (self->table);
58
 
}
59
 
 
60
 
static GLboolean add_simple_variable (slang_active_variables *self, slang_export_data_quant *q,
61
 
        const char *name)
62
 
{
63
 
        const GLuint n = self->count;
64
 
 
65
 
        self->table = (slang_active_variable *) slang_alloc_realloc (self->table,
66
 
                n * sizeof (slang_active_variable), (n + 1) * sizeof (slang_active_variable));
67
 
        if (self->table == NULL)
68
 
                return GL_FALSE;
69
 
 
70
 
        self->table[n].quant = q;
71
 
        self->table[n].name = slang_string_duplicate (name);
72
 
        if (self->table[n].name == NULL)
73
 
                return GL_FALSE;
74
 
        self->count++;
75
 
 
76
 
        return GL_TRUE;
77
 
}
78
 
 
79
 
static GLboolean add_complex_variable (slang_active_variables *self, slang_export_data_quant *q,
80
 
        char *name, slang_atom_pool *atoms)
81
 
{
82
 
        slang_string_concat (name, slang_atom_pool_id (atoms, q->name));
83
 
        if (slang_export_data_quant_array (q))
84
 
                slang_string_concat (name, "[0]");
85
 
 
86
 
        if (slang_export_data_quant_struct (q))
87
 
        {
88
 
                GLuint dot_pos, i;
89
 
                const GLuint fields = slang_export_data_quant_fields (q);
90
 
 
91
 
                slang_string_concat (name, ".");
92
 
                dot_pos = slang_string_length (name);
93
 
 
94
 
                for (i = 0; i < fields; i++)
95
 
                {
96
 
                        if (!add_complex_variable (self, &q->structure[i], name, atoms))
97
 
                                return GL_FALSE;
98
 
 
99
 
                        name[dot_pos] = '\0';
100
 
                }
101
 
 
102
 
                return GL_TRUE;
103
 
        }
104
 
 
105
 
        return add_simple_variable (self, q, name);
106
 
}
107
 
 
108
 
static GLboolean gather_active_variables (slang_active_variables *self,
109
 
        slang_export_data_table *tbl, slang_export_data_access access)
110
 
{
111
 
        GLuint i;
112
 
 
113
 
        for (i = 0; i < tbl->count; i++)
114
 
                if (tbl->entries[i].access == access)
115
 
                {
116
 
                        char name[1024] = "";
117
 
 
118
 
                        if (!add_complex_variable (self, &tbl->entries[i].quant, name, tbl->atoms))
119
 
                                return GL_FALSE;
120
 
                }
121
 
 
122
 
        return GL_TRUE;
 
55
static GLvoid
 
56
slang_active_variables_ctr (slang_active_variables *self)
 
57
{
 
58
   self->table = NULL;
 
59
   self->count = 0;
 
60
}
 
61
 
 
62
static GLvoid
 
63
slang_active_variables_dtr (slang_active_variables *self)
 
64
{
 
65
   GLuint i;
 
66
 
 
67
   for (i = 0; i < self->count; i++)
 
68
      slang_alloc_free (self->table[i].name);
 
69
   slang_alloc_free (self->table);
 
70
}
 
71
 
 
72
/*
 
73
 * Active variable queried by the application cannot be a structure. Queriable globals
 
74
 * (uniforms and attributes) are decomposited into "simple" variables if they are
 
75
 * "complex".
 
76
 */
 
77
 
 
78
static GLboolean
 
79
add_simple_variable (slang_active_variables *self, slang_export_data_quant *q, const GLchar *name)
 
80
{
 
81
   GLuint n;
 
82
   slang_active_variable *var;
 
83
 
 
84
   n = self->count;
 
85
   if (!TABLE_GROW(self->table, slang_active_variable, n))
 
86
      return GL_FALSE;
 
87
 
 
88
   /* Initialize the new element. Increment table size only when it is fully initilized. */
 
89
   var = &self->table[n];
 
90
   var->quant = q;
 
91
   var->name = slang_string_duplicate (name);
 
92
   if (var->name == NULL)
 
93
      return GL_FALSE;
 
94
   self->count++;
 
95
 
 
96
   return GL_TRUE;
 
97
}
 
98
 
 
99
static GLboolean
 
100
add_complex_variable (slang_active_variables *self, slang_export_data_quant *q, GLchar *name,
 
101
                      slang_atom_pool *atoms)
 
102
{
 
103
   slang_string_concat (name, slang_atom_pool_id (atoms, q->name));
 
104
 
 
105
   /* If array, add only first element. */
 
106
   if (slang_export_data_quant_array (q))
 
107
      slang_string_concat (name, "[0]");
 
108
 
 
109
   if (slang_export_data_quant_struct (q)) {
 
110
      GLuint field_pos, fields, i;
 
111
 
 
112
      slang_string_concat (name, ".");
 
113
      field_pos = slang_string_length (name);
 
114
 
 
115
      /* Break it down into individual fields. */
 
116
      fields = slang_export_data_quant_fields (q);
 
117
      for (i = 0; i < fields; i++) {
 
118
         if (!add_complex_variable (self, &q->structure[i], name, atoms))
 
119
            return GL_FALSE;
 
120
         name[field_pos] = '\0';
 
121
      }
 
122
 
 
123
      return GL_TRUE;
 
124
   }
 
125
 
 
126
   return add_simple_variable (self, q, name);
 
127
}
 
128
 
 
129
/*
 
130
 * Search a list of global variables with a given access (either attribute or uniform)
 
131
 * and add it to the list of active variables.
 
132
 */
 
133
static GLboolean
 
134
gather_active_variables (slang_active_variables *self, slang_export_data_table *tbl,
 
135
                         slang_export_data_access access)
 
136
{
 
137
   GLuint i;
 
138
 
 
139
   for (i = 0; i < tbl->count; i++) {
 
140
      if (tbl->entries[i].access == access) {
 
141
         GLchar name[1024] = "";
 
142
 
 
143
         if (!add_complex_variable (self, &tbl->entries[i].quant, name, tbl->atoms))
 
144
            return GL_FALSE;
 
145
      }
 
146
   }
 
147
 
 
148
   return GL_TRUE;
123
149
}
124
150
 
125
151
/*
126
152
 * slang_attrib_overrides
127
153
 */
128
154
 
129
 
static GLvoid slang_attrib_overrides_ctr (slang_attrib_overrides *self)
130
 
{
131
 
        self->table = NULL;
132
 
        self->count = 0;
133
 
}
134
 
 
135
 
static GLvoid slang_attrib_overrides_dtr (slang_attrib_overrides *self)
136
 
{
137
 
        GLuint i;
138
 
 
139
 
        for (i = 0; i < self->count; i++)
140
 
                slang_alloc_free (self->table[i].name);
141
 
        slang_alloc_free (self->table);
142
 
}
143
 
 
144
 
GLboolean slang_attrib_overrides_add (slang_attrib_overrides *self, GLuint index, const GLchar *name)
145
 
{
146
 
        const GLuint n = self->count;
147
 
        GLuint i;
148
 
 
149
 
        for (i = 0; i < n; i++)
150
 
                if (slang_string_compare (name, self->table[i].name) == 0)
151
 
                {
152
 
                        self->table[i].index = index;
153
 
                        return GL_TRUE;
154
 
                }
155
 
 
156
 
        self->table = (slang_attrib_override *) slang_alloc_realloc (self->table,
157
 
                n * sizeof (slang_attrib_override), (n + 1) * sizeof (slang_attrib_override));
158
 
        if (self->table == NULL)
159
 
                return GL_FALSE;
160
 
 
161
 
        self->table[n].index = index;
162
 
        self->table[n].name = slang_string_duplicate (name);
163
 
        if (self->table[n].name == NULL)
164
 
                return GL_FALSE;
165
 
        self->count++;
166
 
 
167
 
        return GL_TRUE;
168
 
}
169
 
 
170
 
static GLuint lookup_attrib_override (slang_attrib_overrides *self, const GLchar *name)
171
 
{
172
 
        GLuint i;
173
 
 
174
 
        for (i = 0; i < self->count; i++)
175
 
                if (slang_string_compare (name, self->table[i].name) == 0)
176
 
                        return self->table[i].index;
177
 
        return MAX_VERTEX_ATTRIBS;
 
155
static GLvoid
 
156
slang_attrib_overrides_ctr (slang_attrib_overrides *self)
 
157
{
 
158
   self->table = NULL;
 
159
   self->count = 0;
 
160
}
 
161
 
 
162
static GLvoid
 
163
slang_attrib_overrides_dtr (slang_attrib_overrides *self)
 
164
{
 
165
   GLuint i;
 
166
 
 
167
   for (i = 0; i < self->count; i++)
 
168
      slang_alloc_free (self->table[i].name);
 
169
   slang_alloc_free (self->table);
 
170
}
 
171
 
 
172
static slang_attrib_override *
 
173
lookup_attrib_override (slang_attrib_overrides *self, const GLchar *name)
 
174
{
 
175
   GLuint n, i;
 
176
 
 
177
   n = self->count;
 
178
   for (i = 0; i < n; i++) {
 
179
      if (slang_string_compare (name, self->table[i].name) == 0)
 
180
         return &self->table[i];
 
181
   }
 
182
   return NULL;
 
183
}
 
184
 
 
185
GLboolean
 
186
_slang_attrib_overrides_add (slang_attrib_overrides *self, GLuint index, const GLchar *name)
 
187
{
 
188
   slang_attrib_override *ovr;
 
189
   GLuint n;
 
190
 
 
191
   /* Attribs can be overriden multiple times. Look-up the table and replace
 
192
    * its index if it is found. */
 
193
   ovr = lookup_attrib_override (self, name);
 
194
   if (ovr != NULL) {
 
195
      ovr->index = index;
 
196
      return GL_TRUE;
 
197
   }
 
198
 
 
199
   n = self->count;
 
200
   if (!TABLE_GROW(self->table, slang_attrib_override, n))
 
201
      return GL_FALSE;
 
202
 
 
203
   /* Initialize the new element. Increment table size only when it is fully initilized. */
 
204
   ovr = &self->table[n];
 
205
   ovr->index = index;
 
206
   ovr->name = slang_string_duplicate (name);
 
207
   if (ovr->name == NULL)
 
208
      return GL_FALSE;
 
209
   self->count++;
 
210
 
 
211
   return GL_TRUE;
178
212
}
179
213
 
180
214
/*
181
215
 * slang_uniform_bindings
182
216
 */
183
217
 
184
 
static GLvoid slang_uniform_bindings_ctr (slang_uniform_bindings *self)
185
 
{
186
 
        self->table = NULL;
187
 
        self->count = 0;
188
 
}
189
 
 
190
 
static GLvoid slang_uniform_bindings_dtr (slang_uniform_bindings *self)
191
 
{
192
 
        GLuint i;
193
 
 
194
 
        for (i = 0; i < self->count; i++)
195
 
                slang_alloc_free (self->table[i].name);
196
 
        slang_alloc_free (self->table);
197
 
}
198
 
 
199
 
static GLboolean add_simple_uniform_binding (slang_uniform_bindings *self,
200
 
        slang_export_data_quant *q, const char *name, GLuint index, GLuint addr)
201
 
{
202
 
        const GLuint n = self->count;
203
 
        GLuint i;
204
 
 
205
 
        for (i = 0; i < n; i++)
206
 
                if (slang_string_compare (self->table[i].name, name) == 0)
207
 
                {
208
 
                        self->table[i].address[index] = addr;
209
 
                        return GL_TRUE;
210
 
                }
211
 
 
212
 
        self->table = (slang_uniform_binding *) slang_alloc_realloc (self->table,
213
 
                n * sizeof (slang_uniform_binding), (n + 1) * sizeof (slang_uniform_binding));
214
 
        if (self->table == NULL)
215
 
                return GL_FALSE;
216
 
 
217
 
        self->table[n].quant = q;
218
 
        self->table[n].name = slang_string_duplicate (name);
219
 
        if (self->table[n].name == NULL)
220
 
                return GL_FALSE;
221
 
        for (i = 0; i < SLANG_SHADER_MAX; i++)
222
 
                self->table[n].address[i] = ~0;
223
 
        self->table[n].address[index] = addr;
224
 
        self->count++;
225
 
 
226
 
        return GL_TRUE;
227
 
}
228
 
 
229
 
static GLboolean add_complex_uniform_binding (slang_uniform_bindings *self,
230
 
        slang_export_data_quant *q, char *name, slang_atom_pool *atoms, GLuint index, GLuint addr)
231
 
{
232
 
        GLuint count, i;
233
 
 
234
 
        slang_string_concat (name, slang_atom_pool_id (atoms, q->name));
235
 
        count = slang_export_data_quant_elements (q);
236
 
        for (i = 0; i < count; i++)
237
 
        {
238
 
                GLuint bracket_pos;
239
 
 
240
 
                bracket_pos = slang_string_length (name);
241
 
                if (slang_export_data_quant_array (q))
242
 
                        _mesa_sprintf (name + slang_string_length (name), "[%d]", i);
243
 
 
244
 
                if (slang_export_data_quant_struct (q))
245
 
                {
246
 
                        GLuint dot_pos, i;
247
 
                        const GLuint fields = slang_export_data_quant_fields (q);
248
 
 
249
 
                        slang_string_concat (name, ".");
250
 
                        dot_pos = slang_string_length (name);
251
 
 
252
 
                        for (i = 0; i < fields; i++)
253
 
                        {
254
 
                                if (!add_complex_uniform_binding (self, &q->structure[i], name, atoms, index, addr))
255
 
                                        return GL_FALSE;
256
 
 
257
 
                                name[dot_pos] = '\0';
258
 
                                addr += slang_export_data_quant_size (&q->structure[i]);
259
 
                        }
260
 
                }
261
 
                else
262
 
                {
263
 
                        if (!add_simple_uniform_binding (self, q, name, index, addr))
264
 
                                return GL_FALSE;
265
 
 
266
 
                        addr += slang_export_data_quant_size (q);
267
 
                }
268
 
 
269
 
                name[bracket_pos] = '\0';
270
 
        }
271
 
 
272
 
        return GL_TRUE;
273
 
}
274
 
 
275
 
static GLboolean gather_uniform_bindings (slang_uniform_bindings *self,
276
 
        slang_export_data_table *tbl, GLuint index)
277
 
{
278
 
        GLuint i;
279
 
 
280
 
        for (i = 0; i < tbl->count; i++)
281
 
                if (tbl->entries[i].access == slang_exp_uniform)
282
 
                {
283
 
                        char name[1024] = "";
284
 
 
285
 
                        if (!add_complex_uniform_binding (self, &tbl->entries[i].quant, name, tbl->atoms, index,
286
 
                                tbl->entries[i].address))
287
 
                                return GL_FALSE;
288
 
                }
289
 
 
290
 
        return GL_TRUE;
 
218
static GLvoid
 
219
slang_uniform_bindings_ctr (slang_uniform_bindings *self)
 
220
{
 
221
   self->table = NULL;
 
222
   self->count = 0;
 
223
}
 
224
 
 
225
static GLvoid
 
226
slang_uniform_bindings_dtr (slang_uniform_bindings *self)
 
227
{
 
228
   GLuint i;
 
229
 
 
230
   for (i = 0; i < self->count; i++)
 
231
      slang_alloc_free (self->table[i].name);
 
232
   slang_alloc_free (self->table);
 
233
}
 
234
 
 
235
static GLboolean
 
236
add_simple_uniform_binding (slang_uniform_bindings *self, slang_export_data_quant *q,
 
237
                            const GLchar *name, GLuint index, GLuint addr)
 
238
{
 
239
   GLuint n, i;
 
240
   slang_uniform_binding *bind;
 
241
 
 
242
   /* Uniform binding table is shared between vertex and fragment shaders. If the same uniform
 
243
    * is declared both in a vertex and fragment shader, only one uniform entry is maintained.
 
244
    * When add a uniform binding there can be an entry already allocated for it by the other
 
245
    * shader. */
 
246
   n = self->count;
 
247
   for (i = 0; i < n; i++) {
 
248
      if (slang_string_compare (self->table[i].name, name) == 0) {
 
249
         self->table[i].address[index] = addr;
 
250
         return GL_TRUE;
 
251
      }
 
252
   }
 
253
 
 
254
   if (!TABLE_GROW(self->table, slang_uniform_binding, n))
 
255
      return GL_FALSE;
 
256
 
 
257
   /* Initialize the new element. Increment table size only when it is fully initilized. */
 
258
   bind = &self->table[n];
 
259
   bind->quant = q;
 
260
   bind->name = slang_string_duplicate (name);
 
261
   if (bind->name == NULL)
 
262
      return GL_FALSE;
 
263
   for (i = 0; i < SLANG_SHADER_MAX; i++)
 
264
      bind->address[i] = ~0;
 
265
   bind->address[index] = addr;
 
266
   self->count++;
 
267
 
 
268
   return GL_TRUE;
 
269
}
 
270
 
 
271
static GLboolean
 
272
add_complex_uniform_binding (slang_uniform_bindings *self, slang_export_data_quant *q,
 
273
                             GLchar *name, slang_atom_pool *atoms, GLuint index, GLuint addr)
 
274
{
 
275
   GLuint count, i;
 
276
 
 
277
   slang_string_concat (name, slang_atom_pool_id (atoms, q->name));
 
278
   count = slang_export_data_quant_elements (q);
 
279
 
 
280
   /* If array, add binding for every array element. */
 
281
   for (i = 0; i < count; i++) {
 
282
      GLuint bracket_pos;
 
283
 
 
284
      bracket_pos = slang_string_length (name);
 
285
      if (slang_export_data_quant_array (q))
 
286
         _mesa_sprintf (&name[slang_string_length (name)], "[%d]", i);
 
287
 
 
288
      if (slang_export_data_quant_struct (q)) {
 
289
         GLuint field_pos, fields, i;
 
290
 
 
291
         slang_string_concat (name, ".");
 
292
         field_pos = slang_string_length (name);
 
293
 
 
294
         /* Break it down into individual fields. */
 
295
         fields = slang_export_data_quant_fields (q);
 
296
         for (i = 0; i < fields; i++) {
 
297
            if (!add_complex_uniform_binding (self, &q->structure[i], name, atoms, index, addr))
 
298
               return GL_FALSE;
 
299
 
 
300
            name[field_pos] = '\0';
 
301
            addr += slang_export_data_quant_size (&q->structure[i]);
 
302
         }
 
303
      }
 
304
      else {
 
305
         if (!add_simple_uniform_binding (self, q, name, index, addr))
 
306
            return GL_FALSE;
 
307
 
 
308
         addr += slang_export_data_quant_size (q);
 
309
      }
 
310
 
 
311
      name[bracket_pos] = '\0';
 
312
   }
 
313
 
 
314
   return GL_TRUE;
 
315
}
 
316
 
 
317
static GLboolean
 
318
gather_uniform_bindings (slang_uniform_bindings *self, slang_export_data_table *tbl, GLuint index)
 
319
{
 
320
   GLuint n, i;
 
321
 
 
322
   n = tbl->count;
 
323
   for (i = 0; i < n; i++) {
 
324
      if (tbl->entries[i].access == slang_exp_uniform) {
 
325
         GLchar name[1024] = "";
 
326
 
 
327
         if (!add_complex_uniform_binding (self, &tbl->entries[i].quant, name, tbl->atoms, index,
 
328
                                           tbl->entries[i].address))
 
329
            return GL_FALSE;
 
330
      }
 
331
   }
 
332
 
 
333
   return GL_TRUE;
291
334
}
292
335
 
293
336
/*
294
337
 * slang_attrib_bindings
295
338
 */
296
339
 
297
 
static GLvoid slang_attrib_bindings_ctr (slang_attrib_bindings *self)
 
340
static GLvoid
 
341
slang_attrib_bindings_ctr (slang_attrib_bindings *self)
298
342
{
299
 
        GLuint i;
 
343
   GLuint i;
300
344
 
301
 
        self->binding_count = 0;
302
 
        for (i = 0; i < MAX_VERTEX_ATTRIBS; i++)
303
 
                self->slots[i].addr = ~0;
 
345
   self->binding_count = 0;
 
346
   for (i = 0; i < MAX_VERTEX_ATTRIBS; i++)
 
347
      self->slots[i].addr = ~0;
304
348
}
305
349
 
306
 
static GLvoid slang_attrib_bindings_dtr (slang_attrib_bindings *self)
 
350
static GLvoid
 
351
slang_attrib_bindings_dtr (slang_attrib_bindings *self)
307
352
{
308
 
        GLuint i;
 
353
   GLuint i;
309
354
 
310
 
        for (i = 0; i < self->binding_count; i++)
311
 
                slang_alloc_free (self->bindings[i].name);
 
355
   for (i = 0; i < self->binding_count; i++)
 
356
      slang_alloc_free (self->bindings[i].name);
312
357
}
313
358
 
314
359
/*
315
360
 * NOTE: If conventional vertex attribute gl_Vertex is used, application cannot use
316
361
 *       vertex attrib index 0 for binding override. Currently this is not checked.
317
 
 *       Although attrib index 0 is not used when not explicitly asked.
 
362
 *       Anyways, attrib index 0 is not used when not explicitly asked.
318
363
 */
319
364
 
320
 
static GLuint can_allocate_attrib_slots (slang_attrib_bindings *self, GLuint index, GLuint count)
 
365
static GLuint
 
366
can_allocate_attrib_slots (slang_attrib_bindings *self, GLuint index, GLuint count)
321
367
{
322
 
        GLuint i;
 
368
   GLuint i;
323
369
 
324
 
        for (i = 0; i < count; i++)
325
 
                if (self->slots[index + i].addr != ~0)
326
 
                        break;
327
 
        return i;
 
370
   for (i = 0; i < count; i++) {
 
371
      if (self->slots[index + i].addr != ~0)
 
372
         break;
 
373
   }
 
374
   return i;
328
375
}
329
376
 
330
 
static GLuint allocate_attrib_slots (slang_attrib_bindings *self, GLuint count)
 
377
static GLuint
 
378
allocate_attrib_slots (slang_attrib_bindings *self, GLuint count)
331
379
{
332
 
        GLuint i;
333
 
 
334
 
   for (i = 1; i <= MAX_VERTEX_ATTRIBS - count; i++)
335
 
        {
336
 
                GLuint size;
337
 
                
338
 
                size = can_allocate_attrib_slots (self, i, count);
339
 
                if (size == count)
340
 
                        return i;
341
 
 
342
 
                /* speed-up the search a bit */
 
380
   GLuint i;
 
381
 
 
382
   /* Start with attrib index 1. Index 0 will be used when explicitly
 
383
    * asked by application binding. */
 
384
   for (i = 1; i <= MAX_VERTEX_ATTRIBS - count; i++) {
 
385
      GLuint size;
 
386
 
 
387
      size = can_allocate_attrib_slots (self, i, count);
 
388
      if (size == count)
 
389
         return i;
 
390
 
 
391
      /* Speed-up the search a bit. */
343
392
      i += size;
344
 
        }
345
 
        return MAX_VERTEX_ATTRIBS;
 
393
   }
 
394
 
 
395
   return MAX_VERTEX_ATTRIBS;
346
396
}
347
397
 
348
398
static GLboolean
349
 
add_attrib_binding (slang_attrib_bindings *self, slang_export_data_quant *q, const char *name,
 
399
add_attrib_binding (slang_attrib_bindings *self, slang_export_data_quant *q, const GLchar *name,
350
400
                    GLuint addr, GLuint index_override)
351
401
{
352
 
        const GLuint n = self->binding_count;
353
 
   GLuint slot_span, slot_fill, slot_index;
354
 
        GLuint i;
355
 
 
356
 
        assert (slang_export_data_quant_simple (q));
357
 
 
358
 
        switch (slang_export_data_quant_type (q))
359
 
        {
360
 
        case GL_FLOAT:
 
402
   GLuint slot_span, slot_fill, slot_index, i;
 
403
   slang_attrib_binding *bind;
 
404
 
 
405
   assert (slang_export_data_quant_simple (q));
 
406
 
 
407
   switch (slang_export_data_quant_type (q)) {
 
408
   case GL_FLOAT:
361
409
      slot_span = 1;
362
410
      slot_fill = 1;
363
411
      break;
364
 
        case GL_FLOAT_VEC2:
365
 
      slot_span = 1;
366
 
      slot_fill = 2;
367
 
      break;
368
 
        case GL_FLOAT_VEC3:
369
 
      slot_span = 1;
370
 
      slot_fill = 3;
371
 
      break;
372
 
        case GL_FLOAT_VEC4:
373
 
                slot_span = 1;
374
 
      slot_fill = 4;
375
 
                break;
376
 
        case GL_FLOAT_MAT2:
377
 
                slot_span = 2;
378
 
      slot_fill = 2;
379
 
                break;
380
 
        case GL_FLOAT_MAT3:
381
 
                slot_span = 3;
382
 
      slot_fill = 3;
383
 
                break;
384
 
        case GL_FLOAT_MAT4:
385
 
                slot_span = 4;
386
 
      slot_fill = 4;
387
 
                break;
388
 
        default:
389
 
                assert (0);
390
 
        }
391
 
 
392
 
        if (index_override == MAX_VERTEX_ATTRIBS)
393
 
                slot_index = allocate_attrib_slots (self, slot_span);
394
 
        else if (can_allocate_attrib_slots (self, index_override, slot_span) == slot_span)
395
 
                slot_index = index_override;
396
 
        else
397
 
                slot_index = MAX_VERTEX_ATTRIBS;
398
 
                        
399
 
        if (slot_index == MAX_VERTEX_ATTRIBS)
400
 
        {
401
 
                /* TODO: info log: error: MAX_VERTEX_ATTRIBS exceeded */
402
 
                return GL_FALSE;
403
 
        }
404
 
 
405
 
        self->bindings[n].quant = q;
406
 
        self->bindings[n].name = slang_string_duplicate (name);
407
 
        if (self->bindings[n].name == NULL)
408
 
                return GL_FALSE;
409
 
        self->bindings[n].first_slot_index = slot_index;
410
 
        self->binding_count++;
 
412
   case GL_FLOAT_VEC2:
 
413
      slot_span = 1;
 
414
      slot_fill = 2;
 
415
      break;
 
416
   case GL_FLOAT_VEC3:
 
417
      slot_span = 1;
 
418
      slot_fill = 3;
 
419
      break;
 
420
   case GL_FLOAT_VEC4:
 
421
      slot_span = 1;
 
422
      slot_fill = 4;
 
423
      break;
 
424
   case GL_FLOAT_MAT2:
 
425
      slot_span = 2;
 
426
      slot_fill = 2;
 
427
      break;
 
428
   case GL_FLOAT_MAT3:
 
429
      slot_span = 3;
 
430
      slot_fill = 3;
 
431
      break;
 
432
   case GL_FLOAT_MAT4:
 
433
      slot_span = 4;
 
434
      slot_fill = 4;
 
435
      break;
 
436
   default:
 
437
      assert (0);
 
438
   }
 
439
 
 
440
   if (index_override == MAX_VERTEX_ATTRIBS)
 
441
      slot_index = allocate_attrib_slots (self, slot_span);
 
442
   else if (can_allocate_attrib_slots (self, index_override, slot_span) == slot_span)
 
443
      slot_index = index_override;
 
444
   else
 
445
      slot_index = MAX_VERTEX_ATTRIBS;
 
446
 
 
447
   if (slot_index == MAX_VERTEX_ATTRIBS) {
 
448
      /* TODO: info log: error: MAX_VERTEX_ATTRIBS exceeded */
 
449
      return GL_FALSE;
 
450
   }
 
451
 
 
452
   /* Initialize the new element. Increment table size only when it is fully initilized. */
 
453
   bind = &self->bindings[self->binding_count];
 
454
   bind->quant = q;
 
455
   bind->name = slang_string_duplicate (name);
 
456
   if (bind->name == NULL)
 
457
      return GL_FALSE;
 
458
   bind->first_slot_index = slot_index;
 
459
   self->binding_count++;
411
460
 
412
461
   for (i = 0; i < slot_span; i++) {
413
 
      slang_attrib_slot *slot = &self->slots[self->bindings[n].first_slot_index + i];
 
462
      slang_attrib_slot *slot;
 
463
 
 
464
      slot = &self->slots[bind->first_slot_index + i];
414
465
      slot->addr = addr + i * slot_fill * 4;
415
466
      slot->fill = slot_fill;
416
467
   }
417
468
 
418
 
        return GL_TRUE;
 
469
   return GL_TRUE;
419
470
}
420
471
 
421
 
static GLboolean gather_attrib_bindings (slang_attrib_bindings *self, slang_export_data_table *tbl,
422
 
        slang_attrib_overrides *ovr)
 
472
static GLboolean
 
473
gather_attrib_bindings (slang_attrib_bindings *self, slang_export_data_table *tbl,
 
474
                        slang_attrib_overrides *ovr)
423
475
{
424
 
        GLuint i;
425
 
 
426
 
        /* First pass. Gather attribs that have overriden index slots. */
427
 
        for (i = 0; i < tbl->count; i++)
428
 
                if (tbl->entries[i].access == slang_exp_attribute &&
429
 
                        !entry_has_gl_prefix (tbl->entries[i].quant.name, tbl->atoms))
430
 
                {
431
 
                        slang_export_data_quant *quant = &tbl->entries[i].quant;
432
 
                        const GLchar *id = slang_atom_pool_id (tbl->atoms, quant->name);
433
 
                        GLuint index = lookup_attrib_override (ovr, id);
434
 
 
435
 
                        if (index != MAX_VERTEX_ATTRIBS)
436
 
                        {
437
 
                                if (!add_attrib_binding (self, quant, id, tbl->entries[i].address, index))
438
 
                                        return GL_FALSE;
439
 
                        }
440
 
                }
441
 
 
442
 
        /* Second pass. Gather attribs that have *NOT* overriden index slots. */
443
 
        for (i = 0; i < tbl->count; i++)
444
 
                if (tbl->entries[i].access == slang_exp_attribute &&
445
 
                        !entry_has_gl_prefix (tbl->entries[i].quant.name, tbl->atoms))
446
 
                {
447
 
                        slang_export_data_quant *quant = &tbl->entries[i].quant;
448
 
                        const GLchar *id = slang_atom_pool_id (tbl->atoms, quant->name);
449
 
                        GLuint index = lookup_attrib_override (ovr, id);
450
 
 
451
 
                        if (index == MAX_VERTEX_ATTRIBS)
452
 
                        {
453
 
                                if (!add_attrib_binding (self, quant, id, tbl->entries[i].address, index))
454
 
                                        return GL_FALSE;
455
 
                        }
456
 
                }
457
 
 
458
 
        return GL_TRUE;
 
476
   GLuint i;
 
477
 
 
478
   /* First pass. Gather attribs that have overriden index slots. */
 
479
   for (i = 0; i < tbl->count; i++) {
 
480
      if (tbl->entries[i].access == slang_exp_attribute &&
 
481
          !entry_has_gl_prefix (tbl->entries[i].quant.name, tbl->atoms)) {
 
482
         slang_export_data_quant *quant;
 
483
         const GLchar *id;
 
484
         slang_attrib_override *ao;
 
485
 
 
486
         quant = &tbl->entries[i].quant;
 
487
         id = slang_atom_pool_id (tbl->atoms, quant->name);
 
488
         ao = lookup_attrib_override (ovr, id);
 
489
         if (ao != NULL) {
 
490
            if (!add_attrib_binding (self, quant, id, tbl->entries[i].address, ao->index))
 
491
               return GL_FALSE;
 
492
         }
 
493
      }
 
494
   }
 
495
 
 
496
   /* Second pass. Gather attribs that have not overriden index slots. */
 
497
   for (i = 0; i < tbl->count; i++) {
 
498
      if (tbl->entries[i].access == slang_exp_attribute &&
 
499
          !entry_has_gl_prefix (tbl->entries[i].quant.name, tbl->atoms)) {
 
500
         slang_export_data_quant *quant;
 
501
         const GLchar *id;
 
502
         slang_attrib_override *ao;
 
503
 
 
504
         quant = &tbl->entries[i].quant;
 
505
         id = slang_atom_pool_id (tbl->atoms, quant->name);
 
506
         ao = lookup_attrib_override (ovr, id);
 
507
         if (ao == NULL) {
 
508
            if (!add_attrib_binding (self, quant, id, tbl->entries[i].address, ao->index))
 
509
               return GL_FALSE;
 
510
         }
 
511
      }
 
512
   }
 
513
 
 
514
   return GL_TRUE;
459
515
}
460
516
 
461
517
/*
462
518
 * slang_varying_bindings
463
519
 */
464
520
 
465
 
static GLvoid slang_varying_bindings_ctr (slang_varying_bindings *self)
466
 
{
467
 
        self->binding_count = 0;
468
 
        self->slot_count = 0;
469
 
}
470
 
 
471
 
static GLvoid slang_varying_bindings_dtr (slang_varying_bindings *self)
472
 
{
473
 
        GLuint i;
474
 
 
475
 
        for (i = 0; i < self->binding_count; i++)
476
 
                slang_alloc_free (self->bindings[i].name);
477
 
}
478
 
 
479
 
static GLvoid update_varying_slots (slang_varying_slot *slots, GLuint count, GLboolean is_vert,
480
 
        GLuint addr, GLuint do_offset)
481
 
{
482
 
        GLuint i;
483
 
 
484
 
        for (i = 0; i < count; i++)
485
 
                *(is_vert ? &slots[i].vert_addr : &slots[i].frag_addr) = addr + i * 4 * do_offset;
486
 
}
487
 
 
488
 
static GLboolean add_varying_binding (slang_varying_bindings *self,
489
 
        slang_export_data_quant *q, const char *name, GLboolean is_vert, GLuint addr)
490
 
{
491
 
        const GLuint n = self->binding_count;
492
 
        const GLuint slot_span =
493
 
                slang_export_data_quant_components (q) * slang_export_data_quant_elements (q);
494
 
        GLuint i;
495
 
 
496
 
        for (i = 0; i < n; i++)
497
 
                if (slang_string_compare (self->bindings[i].name, name) == 0)
498
 
                {
499
 
                        /* TODO: data quantities must match, or else link fails */
500
 
                        update_varying_slots (&self->slots[self->bindings[i].first_slot_index], slot_span,
501
 
                                is_vert, addr, 1);
502
 
                        return GL_TRUE;
503
 
                }
504
 
 
505
 
        if (self->slot_count + slot_span > MAX_VARYING_FLOATS)
506
 
        {
507
 
                /* TODO: info log: error: MAX_VARYING_FLOATS exceeded */
508
 
                return GL_FALSE;
509
 
        }
510
 
 
511
 
        self->bindings[n].quant = q;
512
 
        self->bindings[n].name = slang_string_duplicate (name);
513
 
        if (self->bindings[n].name == NULL)
514
 
                return GL_FALSE;
515
 
        self->bindings[n].first_slot_index = self->slot_count;
516
 
        self->binding_count++;
517
 
 
518
 
        update_varying_slots (&self->slots[self->bindings[n].first_slot_index], slot_span, is_vert,
519
 
                addr, 1);
520
 
        update_varying_slots (&self->slots[self->bindings[n].first_slot_index], slot_span, !is_vert,
521
 
                ~0, 0);
522
 
        self->slot_count += slot_span;
523
 
 
524
 
        return GL_TRUE;
525
 
}
526
 
 
527
 
static GLboolean gather_varying_bindings (slang_varying_bindings *self,
528
 
        slang_export_data_table *tbl, GLboolean is_vert)
529
 
{
530
 
        GLuint i;
531
 
 
532
 
        for (i = 0; i < tbl->count; i++)
533
 
                if (tbl->entries[i].access == slang_exp_varying &&
534
 
                        !entry_has_gl_prefix (tbl->entries[i].quant.name, tbl->atoms))
535
 
                {
536
 
                        if (!add_varying_binding (self, &tbl->entries[i].quant, slang_atom_pool_id (tbl->atoms,
537
 
                                tbl->entries[i].quant.name), is_vert, tbl->entries[i].address))
538
 
                                return GL_FALSE;
539
 
                }
540
 
 
541
 
        return GL_TRUE;
 
521
static GLvoid
 
522
slang_varying_bindings_ctr (slang_varying_bindings *self)
 
523
{
 
524
   self->binding_count = 0;
 
525
   self->slot_count = 0;
 
526
}
 
527
 
 
528
static GLvoid
 
529
slang_varying_bindings_dtr (slang_varying_bindings *self)
 
530
{
 
531
   GLuint i;
 
532
 
 
533
   for (i = 0; i < self->binding_count; i++)
 
534
      slang_alloc_free (self->bindings[i].name);
 
535
}
 
536
 
 
537
static GLvoid
 
538
update_varying_slots (slang_varying_slot *slots, GLuint count, GLboolean is_vert, GLuint addr,
 
539
                      GLuint do_offset)
 
540
{
 
541
   GLuint i;
 
542
 
 
543
   for (i = 0; i < count; i++) {
 
544
      if (is_vert)
 
545
         slots[i].vert_addr = addr + i * 4 * do_offset;
 
546
      else
 
547
         slots[i].frag_addr = addr + i * 4 * do_offset;
 
548
   }
 
549
}
 
550
 
 
551
static GLboolean
 
552
add_varying_binding (slang_varying_bindings *self, slang_export_data_quant *q, const GLchar *name,
 
553
                     GLboolean is_vert, GLuint addr)
 
554
{
 
555
   GLuint n, slot_span, i;
 
556
   slang_varying_binding *bind;
 
557
 
 
558
   n = self->binding_count;
 
559
   slot_span = slang_export_data_quant_components (q) * slang_export_data_quant_elements (q);
 
560
   for (i = 0; i < n; i++) {
 
561
      if (slang_string_compare (self->bindings[i].name, name) == 0) {
 
562
         /* TODO: data quantities must match, or else link fails */
 
563
         update_varying_slots (&self->slots[self->bindings[i].first_slot_index], slot_span,
 
564
                               is_vert, addr, 1);
 
565
         return GL_TRUE;
 
566
      }
 
567
   }
 
568
 
 
569
   if (self->slot_count + slot_span > MAX_VARYING_FLOATS) {
 
570
      /* TODO: info log: error: MAX_VARYING_FLOATS exceeded */
 
571
      return GL_FALSE;
 
572
   }
 
573
 
 
574
   /* Initialize the new element. Increment table size only when it is fully initilized. */
 
575
   bind = &self->bindings[n];
 
576
   bind->quant = q;
 
577
   bind->name = slang_string_duplicate (name);
 
578
   if (bind->name == NULL)
 
579
      return GL_FALSE;
 
580
   bind->first_slot_index = self->slot_count;
 
581
   self->binding_count++;
 
582
 
 
583
   update_varying_slots (&self->slots[bind->first_slot_index], slot_span, is_vert, addr, 1);
 
584
   update_varying_slots (&self->slots[bind->first_slot_index], slot_span, !is_vert, ~0, 0);
 
585
   self->slot_count += slot_span;
 
586
 
 
587
   return GL_TRUE;
 
588
}
 
589
 
 
590
static GLboolean
 
591
gather_varying_bindings (slang_varying_bindings *self, slang_export_data_table *tbl,
 
592
                         GLboolean is_vert)
 
593
{
 
594
   GLuint i;
 
595
 
 
596
   for (i = 0; i < tbl->count; i++) {
 
597
      if (tbl->entries[i].access == slang_exp_varying &&
 
598
          !entry_has_gl_prefix (tbl->entries[i].quant.name, tbl->atoms)) {
 
599
         if (!add_varying_binding (self, &tbl->entries[i].quant,
 
600
                                   slang_atom_pool_id (tbl->atoms, tbl->entries[i].quant.name),
 
601
                                   is_vert, tbl->entries[i].address))
 
602
            return GL_FALSE;
 
603
      }
 
604
   }
 
605
 
 
606
   return GL_TRUE;
542
607
}
543
608
 
544
609
/*
545
610
 * slang_texture_bindings
546
611
 */
547
612
 
548
 
GLvoid slang_texture_usages_ctr (slang_texture_usages *self)
 
613
GLvoid
 
614
_slang_texture_usages_ctr (slang_texture_usages *self)
549
615
{
550
 
        self->table = NULL;
551
 
        self->count = 0;
 
616
   self->table = NULL;
 
617
   self->count = 0;
552
618
}
553
619
 
554
 
GLvoid slang_texture_usages_dtr (slang_texture_usages *self)
 
620
GLvoid
 
621
_slang_texture_usages_dtr (slang_texture_usages *self)
555
622
{
556
 
        slang_alloc_free (self->table);
 
623
   slang_alloc_free (self->table);
557
624
}
558
625
 
559
626
/*
560
627
 * slang_program
561
628
 */
562
629
 
563
 
GLvoid slang_program_ctr (slang_program *self)
564
 
{
565
 
        GLuint i;
566
 
 
567
 
        slang_active_variables_ctr (&self->active_uniforms);
568
 
        slang_active_variables_ctr (&self->active_attribs);
569
 
        slang_attrib_overrides_ctr (&self->attrib_overrides);
570
 
        slang_uniform_bindings_ctr (&self->uniforms);
571
 
        slang_attrib_bindings_ctr (&self->attribs);
572
 
        slang_varying_bindings_ctr (&self->varyings);
573
 
        slang_texture_usages_ctr (&self->texture_usage);
574
 
        for (i = 0; i < SLANG_SHADER_MAX; i++)
575
 
        {
576
 
                GLuint j;
577
 
 
578
 
                for (j = 0; j < SLANG_COMMON_FIXED_MAX; j++)
579
 
                        self->common_fixed_entries[i][j] = ~0;
580
 
                for (j = 0; j < SLANG_COMMON_CODE_MAX; j++)
581
 
                        self->code[i][j] = ~0;
582
 
                self->machines[i] = NULL;
583
 
                self->assemblies[i] = NULL;
584
 
        }
585
 
        for (i = 0; i < SLANG_VERTEX_FIXED_MAX; i++)
586
 
                self->vertex_fixed_entries[i] = ~0;
587
 
        for (i = 0; i < SLANG_FRAGMENT_FIXED_MAX; i++)
588
 
                self->fragment_fixed_entries[i] = ~0;
589
 
}
590
 
 
591
 
GLvoid slang_program_dtr (slang_program *self)
592
 
{
593
 
        slang_active_variables_dtr (&self->active_uniforms);
594
 
        slang_active_variables_dtr (&self->active_attribs);
595
 
        slang_attrib_overrides_dtr (&self->attrib_overrides);
596
 
        slang_uniform_bindings_dtr (&self->uniforms);
597
 
        slang_attrib_bindings_dtr (&self->attribs);
598
 
        slang_varying_bindings_dtr (&self->varyings);
599
 
        slang_texture_usages_dtr (&self->texture_usage);
600
 
}
601
 
 
602
 
GLvoid slang_program_rst (slang_program *self)
603
 
{
604
 
        GLuint i;
605
 
 
606
 
        slang_active_variables_dtr (&self->active_uniforms);
607
 
        slang_active_variables_dtr (&self->active_attribs);
608
 
        slang_uniform_bindings_dtr (&self->uniforms);
609
 
        slang_attrib_bindings_dtr (&self->attribs);
610
 
        slang_varying_bindings_dtr (&self->varyings);
611
 
        slang_texture_usages_dtr (&self->texture_usage);
612
 
 
613
 
        slang_active_variables_ctr (&self->active_uniforms);
614
 
        slang_active_variables_ctr (&self->active_attribs);
615
 
        slang_uniform_bindings_ctr (&self->uniforms);
616
 
        slang_attrib_bindings_ctr (&self->attribs);
617
 
        slang_varying_bindings_ctr (&self->varyings);
618
 
        slang_texture_usages_ctr (&self->texture_usage);
619
 
        for (i = 0; i < SLANG_SHADER_MAX; i++)
620
 
        {
621
 
                GLuint j;
622
 
 
623
 
                for (j = 0; j < SLANG_COMMON_FIXED_MAX; j++)
624
 
                        self->common_fixed_entries[i][j] = ~0;
625
 
                for (j = 0; j < SLANG_COMMON_CODE_MAX; j++)
626
 
                        self->code[i][j] = ~0;
627
 
        }
628
 
        for (i = 0; i < SLANG_VERTEX_FIXED_MAX; i++)
629
 
                self->vertex_fixed_entries[i] = ~0;
630
 
        for (i = 0; i < SLANG_FRAGMENT_FIXED_MAX; i++)
631
 
                self->fragment_fixed_entries[i] = ~0;
 
630
GLvoid
 
631
_slang_program_ctr (slang_program *self)
 
632
{
 
633
   GLuint i;
 
634
 
 
635
   slang_active_variables_ctr (&self->active_uniforms);
 
636
   slang_active_variables_ctr (&self->active_attribs);
 
637
   slang_attrib_overrides_ctr (&self->attrib_overrides);
 
638
   slang_uniform_bindings_ctr (&self->uniforms);
 
639
   slang_attrib_bindings_ctr (&self->attribs);
 
640
   slang_varying_bindings_ctr (&self->varyings);
 
641
   _slang_texture_usages_ctr (&self->texture_usage);
 
642
   for (i = 0; i < SLANG_SHADER_MAX; i++) {
 
643
      GLuint j;
 
644
 
 
645
      for (j = 0; j < SLANG_COMMON_FIXED_MAX; j++)
 
646
         self->common_fixed_entries[i][j] = ~0;
 
647
      for (j = 0; j < SLANG_COMMON_CODE_MAX; j++)
 
648
         self->code[i][j] = ~0;
 
649
      self->machines[i] = NULL;
 
650
      self->assemblies[i] = NULL;
 
651
   }
 
652
   for (i = 0; i < SLANG_VERTEX_FIXED_MAX; i++)
 
653
      self->vertex_fixed_entries[i] = ~0;
 
654
   for (i = 0; i < SLANG_FRAGMENT_FIXED_MAX; i++)
 
655
      self->fragment_fixed_entries[i] = ~0;
 
656
}
 
657
 
 
658
GLvoid
 
659
_slang_program_dtr (slang_program *self)
 
660
{
 
661
   slang_active_variables_dtr (&self->active_uniforms);
 
662
   slang_active_variables_dtr (&self->active_attribs);
 
663
   slang_attrib_overrides_dtr (&self->attrib_overrides);
 
664
   slang_uniform_bindings_dtr (&self->uniforms);
 
665
   slang_attrib_bindings_dtr (&self->attribs);
 
666
   slang_varying_bindings_dtr (&self->varyings);
 
667
   _slang_texture_usages_dtr (&self->texture_usage);
 
668
}
 
669
 
 
670
GLvoid
 
671
_slang_program_rst (slang_program *self)
 
672
{
 
673
   GLuint i;
 
674
 
 
675
   slang_active_variables_dtr (&self->active_uniforms);
 
676
   slang_active_variables_dtr (&self->active_attribs);
 
677
   slang_uniform_bindings_dtr (&self->uniforms);
 
678
   slang_attrib_bindings_dtr (&self->attribs);
 
679
   slang_varying_bindings_dtr (&self->varyings);
 
680
   _slang_texture_usages_dtr (&self->texture_usage);
 
681
 
 
682
   slang_active_variables_ctr (&self->active_uniforms);
 
683
   slang_active_variables_ctr (&self->active_attribs);
 
684
   slang_uniform_bindings_ctr (&self->uniforms);
 
685
   slang_attrib_bindings_ctr (&self->attribs);
 
686
   slang_varying_bindings_ctr (&self->varyings);
 
687
   _slang_texture_usages_ctr (&self->texture_usage);
 
688
   for (i = 0; i < SLANG_SHADER_MAX; i++) {
 
689
      GLuint j;
 
690
 
 
691
      for (j = 0; j < SLANG_COMMON_FIXED_MAX; j++)
 
692
         self->common_fixed_entries[i][j] = ~0;
 
693
      for (j = 0; j < SLANG_COMMON_CODE_MAX; j++)
 
694
         self->code[i][j] = ~0;
 
695
   }
 
696
   for (i = 0; i < SLANG_VERTEX_FIXED_MAX; i++)
 
697
      self->vertex_fixed_entries[i] = ~0;
 
698
   for (i = 0; i < SLANG_FRAGMENT_FIXED_MAX; i++)
 
699
      self->fragment_fixed_entries[i] = ~0;
632
700
}
633
701
 
634
702
/*
635
703
 * _slang_link()
636
704
 */
637
705
 
638
 
static GLuint gd (slang_export_data_table *tbl, const char *name)
639
 
{
640
 
        slang_atom atom;
641
 
        GLuint i;
642
 
 
643
 
        atom = slang_atom_pool_atom (tbl->atoms, name);
644
 
        if (atom == SLANG_ATOM_NULL)
645
 
                return ~0;
646
 
 
647
 
        for (i = 0; i < tbl->count; i++)
648
 
                if (atom == tbl->entries[i].quant.name)
649
 
                        return tbl->entries[i].address;
650
 
        return ~0;
651
 
}
652
 
 
653
 
static GLvoid resolve_common_fixed (GLuint e[], slang_export_data_table *tbl)
654
 
{
655
 
        e[SLANG_COMMON_FIXED_MODELVIEWMATRIX] = gd (tbl, "gl_ModelViewMatrix");
656
 
        e[SLANG_COMMON_FIXED_PROJECTIONMATRIX] = gd (tbl, "gl_ProjectionMatrix");
657
 
        e[SLANG_COMMON_FIXED_MODELVIEWPROJECTIONMATRIX] = gd (tbl, "gl_ModelViewProjectionMatrix");
658
 
        e[SLANG_COMMON_FIXED_TEXTUREMATRIX] = gd (tbl, "gl_TextureMatrix");
659
 
        e[SLANG_COMMON_FIXED_NORMALMATRIX] = gd (tbl, "gl_NormalMatrix");
660
 
        e[SLANG_COMMON_FIXED_MODELVIEWMATRIXINVERSE] = gd (tbl, "gl_ModelViewMatrixInverse");
661
 
        e[SLANG_COMMON_FIXED_PROJECTIONMATRIXINVERSE] = gd (tbl, "gl_ProjectionMatrixInverse");
662
 
        e[SLANG_COMMON_FIXED_MODELVIEWPROJECTIONMATRIXINVERSE] =
663
 
                gd (tbl, "gl_ModelViewProjectionMatrixInverse");
664
 
        e[SLANG_COMMON_FIXED_TEXTUREMATRIXINVERSE] = gd (tbl, "gl_TextureMatrixInverse");
665
 
        e[SLANG_COMMON_FIXED_MODELVIEWMATRIXTRANSPOSE] = gd (tbl, "gl_ModelViewMatrixTranspose");
666
 
        e[SLANG_COMMON_FIXED_PROJECTIONMATRIXTRANSPOSE] = gd (tbl, "gl_ProjectionMatrixTranspose");
667
 
        e[SLANG_COMMON_FIXED_MODELVIEWPROJECTIONMATRIXTRANSPOSE] =
668
 
                gd (tbl, "gl_ModelViewProjectionMatrixTranspose");
669
 
        e[SLANG_COMMON_FIXED_TEXTUREMATRIXTRANSPOSE] = gd (tbl, "gl_TextureMatrixTranspose");
670
 
        e[SLANG_COMMON_FIXED_MODELVIEWMATRIXINVERSETRANSPOSE] =
671
 
                gd (tbl, "gl_ModelViewMatrixInverseTranspose");
672
 
        e[SLANG_COMMON_FIXED_PROJECTIONMATRIXINVERSETRANSPOSE] =
673
 
                gd (tbl, "gl_ProjectionMatrixInverseTranspose");
674
 
        e[SLANG_COMMON_FIXED_MODELVIEWPROJECTIONMATRIXINVERSETRANSPOSE] =
675
 
                gd (tbl, "gl_ModelViewProjectionMatrixInverseTranspose");
676
 
        e[SLANG_COMMON_FIXED_TEXTUREMATRIXINVERSETRANSPOSE] =
677
 
                gd (tbl, "gl_TextureMatrixInverseTranspose");
678
 
        e[SLANG_COMMON_FIXED_NORMALSCALE] = gd (tbl, "gl_NormalScale");
679
 
        e[SLANG_COMMON_FIXED_DEPTHRANGE] = gd (tbl, "gl_DepthRange");
680
 
        e[SLANG_COMMON_FIXED_CLIPPLANE] = gd (tbl, "gl_ClipPlane");
681
 
        e[SLANG_COMMON_FIXED_POINT] = gd (tbl, "gl_Point");
682
 
        e[SLANG_COMMON_FIXED_FRONTMATERIAL] = gd (tbl, "gl_FrontMaterial");
683
 
        e[SLANG_COMMON_FIXED_BACKMATERIAL] = gd (tbl, "gl_BackMaterial");
684
 
        e[SLANG_COMMON_FIXED_LIGHTSOURCE] = gd (tbl, "gl_LightSource");
685
 
        e[SLANG_COMMON_FIXED_LIGHTMODEL] = gd (tbl, "gl_LightModel");
686
 
        e[SLANG_COMMON_FIXED_FRONTLIGHTMODELPRODUCT] = gd (tbl, "gl_FrontLightModelProduct");
687
 
        e[SLANG_COMMON_FIXED_BACKLIGHTMODELPRODUCT] = gd (tbl, "gl_BackLightModelProduct");
688
 
        e[SLANG_COMMON_FIXED_FRONTLIGHTPRODUCT] = gd (tbl, "gl_FrontLightProduct");
689
 
        e[SLANG_COMMON_FIXED_BACKLIGHTPRODUCT] = gd (tbl, "gl_BackLightProduct");
690
 
        e[SLANG_COMMON_FIXED_TEXTUREENVCOLOR] = gd (tbl, "gl_TextureEnvColor");
691
 
        e[SLANG_COMMON_FIXED_EYEPLANES] = gd (tbl, "gl_EyePlaneS");
692
 
        e[SLANG_COMMON_FIXED_EYEPLANET] = gd (tbl, "gl_EyePlaneT");
693
 
        e[SLANG_COMMON_FIXED_EYEPLANER] = gd (tbl, "gl_EyePlaneR");
694
 
        e[SLANG_COMMON_FIXED_EYEPLANEQ] = gd (tbl, "gl_EyePlaneQ");
695
 
        e[SLANG_COMMON_FIXED_OBJECTPLANES] = gd (tbl, "gl_ObjectPlaneS");
696
 
        e[SLANG_COMMON_FIXED_OBJECTPLANET] = gd (tbl, "gl_ObjectPlaneT");
697
 
        e[SLANG_COMMON_FIXED_OBJECTPLANER] = gd (tbl, "gl_ObjectPlaneR");
698
 
        e[SLANG_COMMON_FIXED_OBJECTPLANEQ] = gd (tbl, "gl_ObjectPlaneQ");
699
 
        e[SLANG_COMMON_FIXED_FOG] = gd (tbl, "gl_Fog");
700
 
}
701
 
 
702
 
static GLvoid resolve_vertex_fixed (GLuint e[], slang_export_data_table *tbl)
703
 
{
704
 
        e[SLANG_VERTEX_FIXED_POSITION] = gd (tbl, "gl_Position");
705
 
        e[SLANG_VERTEX_FIXED_POINTSIZE] = gd (tbl,  "gl_PointSize");
706
 
        e[SLANG_VERTEX_FIXED_CLIPVERTEX] = gd (tbl, "gl_ClipVertex");
707
 
        e[SLANG_VERTEX_FIXED_COLOR] = gd (tbl, "gl_Color");
708
 
        e[SLANG_VERTEX_FIXED_SECONDARYCOLOR] = gd (tbl, "gl_SecondaryColor");
709
 
        e[SLANG_VERTEX_FIXED_NORMAL] = gd (tbl, "gl_Normal");
710
 
        e[SLANG_VERTEX_FIXED_VERTEX] = gd (tbl, "gl_Vertex");
711
 
        e[SLANG_VERTEX_FIXED_MULTITEXCOORD0] = gd (tbl, "gl_MultiTexCoord0");
712
 
        e[SLANG_VERTEX_FIXED_MULTITEXCOORD1] = gd (tbl, "gl_MultiTexCoord1");
713
 
        e[SLANG_VERTEX_FIXED_MULTITEXCOORD2] = gd (tbl, "gl_MultiTexCoord2");
714
 
        e[SLANG_VERTEX_FIXED_MULTITEXCOORD3] = gd (tbl, "gl_MultiTexCoord3");
715
 
        e[SLANG_VERTEX_FIXED_MULTITEXCOORD4] = gd (tbl, "gl_MultiTexCoord4");
716
 
        e[SLANG_VERTEX_FIXED_MULTITEXCOORD5] = gd (tbl, "gl_MultiTexCoord5");
717
 
        e[SLANG_VERTEX_FIXED_MULTITEXCOORD6] = gd (tbl, "gl_MultiTexCoord6");
718
 
        e[SLANG_VERTEX_FIXED_MULTITEXCOORD7] = gd (tbl, "gl_MultiTexCoord7");
719
 
        e[SLANG_VERTEX_FIXED_FOGCOORD] = gd (tbl, "gl_FogCoord");
720
 
        e[SLANG_VERTEX_FIXED_FRONTCOLOR] = gd (tbl, "gl_FrontColor");
721
 
        e[SLANG_VERTEX_FIXED_BACKCOLOR] = gd (tbl, "gl_BackColor");
722
 
        e[SLANG_VERTEX_FIXED_FRONTSECONDARYCOLOR] = gd (tbl, "gl_FrontSecondaryColor");
723
 
        e[SLANG_VERTEX_FIXED_BACKSECONDARYCOLOR] = gd (tbl, "gl_BackSecondaryColor");
724
 
        e[SLANG_VERTEX_FIXED_TEXCOORD] = gd (tbl, "gl_TexCoord");
725
 
        e[SLANG_VERTEX_FIXED_FOGFRAGCOORD] = gd (tbl, "gl_FogFragCoord");
726
 
}
727
 
 
728
 
static GLvoid resolve_fragment_fixed (GLuint e[], slang_export_data_table *tbl)
729
 
{
730
 
        e[SLANG_FRAGMENT_FIXED_FRAGCOORD] = gd (tbl, "gl_FragCoord");
731
 
        e[SLANG_FRAGMENT_FIXED_FRONTFACING] = gd (tbl, "gl_FrontFacing");
732
 
        e[SLANG_FRAGMENT_FIXED_FRAGCOLOR] = gd (tbl, "gl_FragColor");
733
 
        e[SLANG_FRAGMENT_FIXED_FRAGDATA] = gd (tbl, "gl_FragData");
734
 
        e[SLANG_FRAGMENT_FIXED_FRAGDEPTH] = gd (tbl, "gl_FragDepth");
735
 
        e[SLANG_FRAGMENT_FIXED_COLOR] = gd (tbl, "gl_Color");
736
 
        e[SLANG_FRAGMENT_FIXED_SECONDARYCOLOR] = gd (tbl, "gl_SecondaryColor");
737
 
        e[SLANG_FRAGMENT_FIXED_TEXCOORD] = gd (tbl, "gl_TexCoord");
738
 
        e[SLANG_FRAGMENT_FIXED_FOGFRAGCOORD] = gd (tbl, "gl_FogFragCoord");
739
 
}
740
 
 
741
 
static GLuint gc (slang_export_code_table *tbl, const char *name)
742
 
{
743
 
        slang_atom atom;
744
 
        GLuint i;
745
 
 
746
 
        atom = slang_atom_pool_atom (tbl->atoms, name);
747
 
        if (atom == SLANG_ATOM_NULL)
748
 
                return ~0;
749
 
 
750
 
        for (i = 0; i < tbl->count; i++)
751
 
                if (atom == tbl->entries[i].name)
752
 
                        return tbl->entries[i].address;
753
 
        return ~0;
754
 
}
755
 
 
756
 
static GLvoid resolve_common_code (GLuint code[], slang_export_code_table *tbl)
757
 
{
758
 
        code[SLANG_COMMON_CODE_MAIN] = gc (tbl, "@main");
 
706
static GLuint
 
707
gd (slang_export_data_table *tbl, const GLchar *name)
 
708
{
 
709
   slang_atom atom;
 
710
   GLuint i;
 
711
 
 
712
   atom = slang_atom_pool_atom (tbl->atoms, name);
 
713
   if (atom == SLANG_ATOM_NULL)
 
714
      return ~0;
 
715
 
 
716
   for (i = 0; i < tbl->count; i++) {
 
717
      if (atom == tbl->entries[i].quant.name)
 
718
         return tbl->entries[i].address;
 
719
   }
 
720
   return ~0;
 
721
}
 
722
 
 
723
static GLvoid
 
724
resolve_common_fixed (GLuint e[], slang_export_data_table *tbl)
 
725
{
 
726
   e[SLANG_COMMON_FIXED_MODELVIEWMATRIX] = gd (tbl, "gl_ModelViewMatrix");
 
727
   e[SLANG_COMMON_FIXED_PROJECTIONMATRIX] = gd (tbl, "gl_ProjectionMatrix");
 
728
   e[SLANG_COMMON_FIXED_MODELVIEWPROJECTIONMATRIX] = gd (tbl, "gl_ModelViewProjectionMatrix");
 
729
   e[SLANG_COMMON_FIXED_TEXTUREMATRIX] = gd (tbl, "gl_TextureMatrix");
 
730
   e[SLANG_COMMON_FIXED_NORMALMATRIX] = gd (tbl, "gl_NormalMatrix");
 
731
   e[SLANG_COMMON_FIXED_MODELVIEWMATRIXINVERSE] = gd (tbl, "gl_ModelViewMatrixInverse");
 
732
   e[SLANG_COMMON_FIXED_PROJECTIONMATRIXINVERSE] = gd (tbl, "gl_ProjectionMatrixInverse");
 
733
   e[SLANG_COMMON_FIXED_MODELVIEWPROJECTIONMATRIXINVERSE] = gd (tbl, "gl_ModelViewProjectionMatrixInverse");
 
734
   e[SLANG_COMMON_FIXED_TEXTUREMATRIXINVERSE] = gd (tbl, "gl_TextureMatrixInverse");
 
735
   e[SLANG_COMMON_FIXED_MODELVIEWMATRIXTRANSPOSE] = gd (tbl, "gl_ModelViewMatrixTranspose");
 
736
   e[SLANG_COMMON_FIXED_PROJECTIONMATRIXTRANSPOSE] = gd (tbl, "gl_ProjectionMatrixTranspose");
 
737
   e[SLANG_COMMON_FIXED_MODELVIEWPROJECTIONMATRIXTRANSPOSE] = gd (tbl, "gl_ModelViewProjectionMatrixTranspose");
 
738
   e[SLANG_COMMON_FIXED_TEXTUREMATRIXTRANSPOSE] = gd (tbl, "gl_TextureMatrixTranspose");
 
739
   e[SLANG_COMMON_FIXED_MODELVIEWMATRIXINVERSETRANSPOSE] = gd (tbl, "gl_ModelViewMatrixInverseTranspose");
 
740
   e[SLANG_COMMON_FIXED_PROJECTIONMATRIXINVERSETRANSPOSE] = gd (tbl, "gl_ProjectionMatrixInverseTranspose");
 
741
   e[SLANG_COMMON_FIXED_MODELVIEWPROJECTIONMATRIXINVERSETRANSPOSE] = gd (tbl, "gl_ModelViewProjectionMatrixInverseTranspose");
 
742
   e[SLANG_COMMON_FIXED_TEXTUREMATRIXINVERSETRANSPOSE] = gd (tbl, "gl_TextureMatrixInverseTranspose");
 
743
   e[SLANG_COMMON_FIXED_NORMALSCALE] = gd (tbl, "gl_NormalScale");
 
744
   e[SLANG_COMMON_FIXED_DEPTHRANGE] = gd (tbl, "gl_DepthRange");
 
745
   e[SLANG_COMMON_FIXED_CLIPPLANE] = gd (tbl, "gl_ClipPlane");
 
746
   e[SLANG_COMMON_FIXED_POINT] = gd (tbl, "gl_Point");
 
747
   e[SLANG_COMMON_FIXED_FRONTMATERIAL] = gd (tbl, "gl_FrontMaterial");
 
748
   e[SLANG_COMMON_FIXED_BACKMATERIAL] = gd (tbl, "gl_BackMaterial");
 
749
   e[SLANG_COMMON_FIXED_LIGHTSOURCE] = gd (tbl, "gl_LightSource");
 
750
   e[SLANG_COMMON_FIXED_LIGHTMODEL] = gd (tbl, "gl_LightModel");
 
751
   e[SLANG_COMMON_FIXED_FRONTLIGHTMODELPRODUCT] = gd (tbl, "gl_FrontLightModelProduct");
 
752
   e[SLANG_COMMON_FIXED_BACKLIGHTMODELPRODUCT] = gd (tbl, "gl_BackLightModelProduct");
 
753
   e[SLANG_COMMON_FIXED_FRONTLIGHTPRODUCT] = gd (tbl, "gl_FrontLightProduct");
 
754
   e[SLANG_COMMON_FIXED_BACKLIGHTPRODUCT] = gd (tbl, "gl_BackLightProduct");
 
755
   e[SLANG_COMMON_FIXED_TEXTUREENVCOLOR] = gd (tbl, "gl_TextureEnvColor");
 
756
   e[SLANG_COMMON_FIXED_EYEPLANES] = gd (tbl, "gl_EyePlaneS");
 
757
   e[SLANG_COMMON_FIXED_EYEPLANET] = gd (tbl, "gl_EyePlaneT");
 
758
   e[SLANG_COMMON_FIXED_EYEPLANER] = gd (tbl, "gl_EyePlaneR");
 
759
   e[SLANG_COMMON_FIXED_EYEPLANEQ] = gd (tbl, "gl_EyePlaneQ");
 
760
   e[SLANG_COMMON_FIXED_OBJECTPLANES] = gd (tbl, "gl_ObjectPlaneS");
 
761
   e[SLANG_COMMON_FIXED_OBJECTPLANET] = gd (tbl, "gl_ObjectPlaneT");
 
762
   e[SLANG_COMMON_FIXED_OBJECTPLANER] = gd (tbl, "gl_ObjectPlaneR");
 
763
   e[SLANG_COMMON_FIXED_OBJECTPLANEQ] = gd (tbl, "gl_ObjectPlaneQ");
 
764
   e[SLANG_COMMON_FIXED_FOG] = gd (tbl, "gl_Fog");
 
765
}
 
766
 
 
767
static GLvoid
 
768
resolve_vertex_fixed (GLuint e[], slang_export_data_table *tbl)
 
769
{
 
770
   e[SLANG_VERTEX_FIXED_POSITION] = gd (tbl, "gl_Position");
 
771
   e[SLANG_VERTEX_FIXED_POINTSIZE] = gd (tbl,  "gl_PointSize");
 
772
   e[SLANG_VERTEX_FIXED_CLIPVERTEX] = gd (tbl, "gl_ClipVertex");
 
773
   e[SLANG_VERTEX_FIXED_COLOR] = gd (tbl, "gl_Color");
 
774
   e[SLANG_VERTEX_FIXED_SECONDARYCOLOR] = gd (tbl, "gl_SecondaryColor");
 
775
   e[SLANG_VERTEX_FIXED_NORMAL] = gd (tbl, "gl_Normal");
 
776
   e[SLANG_VERTEX_FIXED_VERTEX] = gd (tbl, "gl_Vertex");
 
777
   e[SLANG_VERTEX_FIXED_MULTITEXCOORD0] = gd (tbl, "gl_MultiTexCoord0");
 
778
   e[SLANG_VERTEX_FIXED_MULTITEXCOORD1] = gd (tbl, "gl_MultiTexCoord1");
 
779
   e[SLANG_VERTEX_FIXED_MULTITEXCOORD2] = gd (tbl, "gl_MultiTexCoord2");
 
780
   e[SLANG_VERTEX_FIXED_MULTITEXCOORD3] = gd (tbl, "gl_MultiTexCoord3");
 
781
   e[SLANG_VERTEX_FIXED_MULTITEXCOORD4] = gd (tbl, "gl_MultiTexCoord4");
 
782
   e[SLANG_VERTEX_FIXED_MULTITEXCOORD5] = gd (tbl, "gl_MultiTexCoord5");
 
783
   e[SLANG_VERTEX_FIXED_MULTITEXCOORD6] = gd (tbl, "gl_MultiTexCoord6");
 
784
   e[SLANG_VERTEX_FIXED_MULTITEXCOORD7] = gd (tbl, "gl_MultiTexCoord7");
 
785
   e[SLANG_VERTEX_FIXED_FOGCOORD] = gd (tbl, "gl_FogCoord");
 
786
   e[SLANG_VERTEX_FIXED_FRONTCOLOR] = gd (tbl, "gl_FrontColor");
 
787
   e[SLANG_VERTEX_FIXED_BACKCOLOR] = gd (tbl, "gl_BackColor");
 
788
   e[SLANG_VERTEX_FIXED_FRONTSECONDARYCOLOR] = gd (tbl, "gl_FrontSecondaryColor");
 
789
   e[SLANG_VERTEX_FIXED_BACKSECONDARYCOLOR] = gd (tbl, "gl_BackSecondaryColor");
 
790
   e[SLANG_VERTEX_FIXED_TEXCOORD] = gd (tbl, "gl_TexCoord");
 
791
   e[SLANG_VERTEX_FIXED_FOGFRAGCOORD] = gd (tbl, "gl_FogFragCoord");
 
792
}
 
793
 
 
794
static GLvoid
 
795
resolve_fragment_fixed (GLuint e[], slang_export_data_table *tbl)
 
796
{
 
797
   e[SLANG_FRAGMENT_FIXED_FRAGCOORD] = gd (tbl, "gl_FragCoord");
 
798
   e[SLANG_FRAGMENT_FIXED_FRONTFACING] = gd (tbl, "gl_FrontFacing");
 
799
   e[SLANG_FRAGMENT_FIXED_FRAGCOLOR] = gd (tbl, "gl_FragColor");
 
800
   e[SLANG_FRAGMENT_FIXED_FRAGDATA] = gd (tbl, "gl_FragData");
 
801
   e[SLANG_FRAGMENT_FIXED_FRAGDEPTH] = gd (tbl, "gl_FragDepth");
 
802
   e[SLANG_FRAGMENT_FIXED_COLOR] = gd (tbl, "gl_Color");
 
803
   e[SLANG_FRAGMENT_FIXED_SECONDARYCOLOR] = gd (tbl, "gl_SecondaryColor");
 
804
   e[SLANG_FRAGMENT_FIXED_TEXCOORD] = gd (tbl, "gl_TexCoord");
 
805
   e[SLANG_FRAGMENT_FIXED_FOGFRAGCOORD] = gd (tbl, "gl_FogFragCoord");
 
806
}
 
807
 
 
808
static GLuint
 
809
gc (slang_export_code_table *tbl, const GLchar *name)
 
810
{
 
811
   slang_atom atom;
 
812
   GLuint i;
 
813
 
 
814
   atom = slang_atom_pool_atom (tbl->atoms, name);
 
815
   if (atom == SLANG_ATOM_NULL)
 
816
      return ~0;
 
817
 
 
818
   for (i = 0; i < tbl->count; i++) {
 
819
      if (atom == tbl->entries[i].name)
 
820
         return tbl->entries[i].address;
 
821
   }
 
822
   return ~0;
 
823
}
 
824
 
 
825
static GLvoid
 
826
resolve_common_code (GLuint code[], slang_export_code_table *tbl)
 
827
{
 
828
   code[SLANG_COMMON_CODE_MAIN] = gc (tbl, "@main");
759
829
}
760
830
 
761
831
GLboolean
762
832
_slang_link (slang_program *prog, slang_code_object **objects, GLuint count)
763
833
{
764
 
        GLuint i;
 
834
   GLuint i;
765
835
 
766
 
        for (i = 0; i < count; i++)
767
 
        {
768
 
                GLuint index;
 
836
   for (i = 0; i < count; i++) {
 
837
      GLuint index;
769
838
 
770
839
      if (objects[i]->unit.type == slang_unit_fragment_shader) {
771
 
                        index = SLANG_SHADER_FRAGMENT;
 
840
         index = SLANG_SHADER_FRAGMENT;
772
841
         resolve_fragment_fixed (prog->fragment_fixed_entries, &objects[i]->expdata);
773
 
                }
774
 
                else
775
 
                {
776
 
                        index = SLANG_SHADER_VERTEX;
 
842
      }
 
843
      else {
 
844
         index = SLANG_SHADER_VERTEX;
777
845
         resolve_vertex_fixed (prog->vertex_fixed_entries, &objects[i]->expdata);
778
846
         if (!gather_attrib_bindings (&prog->attribs, &objects[i]->expdata,
779
847
                                      &prog->attrib_overrides))
780
 
                                return GL_FALSE;
781
 
                }
 
848
            return GL_FALSE;
 
849
      }
782
850
 
783
851
      if (!gather_active_variables (&prog->active_uniforms, &objects[i]->expdata, slang_exp_uniform))
784
 
                        return GL_FALSE;
 
852
         return GL_FALSE;
785
853
      if (!gather_active_variables (&prog->active_attribs, &objects[i]->expdata, slang_exp_attribute))
786
 
                        return GL_FALSE;
 
854
         return GL_FALSE;
787
855
      if (!gather_uniform_bindings (&prog->uniforms, &objects[i]->expdata, index))
788
 
                        return GL_FALSE;
 
856
         return GL_FALSE;
789
857
      if (!gather_varying_bindings (&prog->varyings, &objects[i]->expdata,
790
858
                                    index == SLANG_SHADER_VERTEX))
791
 
                        return GL_FALSE;
 
859
         return GL_FALSE;
792
860
      resolve_common_fixed (prog->common_fixed_entries[index], &objects[i]->expdata);
793
861
      resolve_common_code (prog->code[index], &objects[i]->expcode);
794
862
      prog->machines[index] = &objects[i]->machine;
795
863
      prog->assemblies[index] = &objects[i]->assembly;
796
 
        }
797
 
 
798
 
        /* TODO: all varyings read by fragment shader must be written by vertex shader */
799
 
 
800
 
        if (!_slang_analyse_texture_usage (prog))
801
 
                return GL_FALSE;
802
 
 
803
 
        return GL_TRUE;
 
864
   }
 
865
 
 
866
   /* TODO: all varyings read by fragment shader must be written by vertex shader */
 
867
 
 
868
   if (!_slang_analyse_texture_usage (prog))
 
869
      return GL_FALSE;
 
870
 
 
871
   return GL_TRUE;
804
872
}
805
873