• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //
2 // Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
3 // All rights reserved.
4 //
5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions
7 // are met:
8 //
9 //    Redistributions of source code must retain the above copyright
10 //    notice, this list of conditions and the following disclaimer.
11 //
12 //    Redistributions in binary form must reproduce the above
13 //    copyright notice, this list of conditions and the following
14 //    disclaimer in the documentation and/or other materials provided
15 //    with the distribution.
16 //
17 //    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
18 //    contributors may be used to endorse or promote products derived
19 //    from this software without specific prior written permission.
20 //
21 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 // COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 // BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
29 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
31 // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32 // POSSIBILITY OF SUCH DAMAGE.
33 //
34 
35 //
36 // Traverse a tree of constants to create a single folded constant.
37 // It should only be used when the whole tree is known to be constant.
38 //
39 
40 #include "ParseHelper.h"
41 
42 namespace glslang {
43 
44 class TConstTraverser : public TIntermTraverser {
45 public:
TConstTraverser(const TConstUnionArray & cUnion,bool singleConstParam,TOperator constructType,const TType & t)46     TConstTraverser(const TConstUnionArray& cUnion, bool singleConstParam, TOperator constructType, const TType& t)
47       : unionArray(cUnion), type(t),
48         constructorType(constructType), singleConstantParam(singleConstParam), error(false), isMatrix(false),
49         matrixCols(0), matrixRows(0) {  index = 0; tOp = EOpNull; }
50 
51     virtual void visitConstantUnion(TIntermConstantUnion* node);
52     virtual bool visitAggregate(TVisit, TIntermAggregate* node);
53 
54     int index;
55     TConstUnionArray unionArray;
56     TOperator tOp;
57     const TType& type;
58     TOperator constructorType;
59     bool singleConstantParam;
60     bool error;
61     int size; // size of the constructor ( 4 for vec4)
62     bool isMatrix;
63     int matrixCols;
64     int matrixRows;
65 
66 protected:
67     TConstTraverser(TConstTraverser&);
68     TConstTraverser& operator=(TConstTraverser&);
69 };
70 
visitAggregate(TVisit,TIntermAggregate * node)71 bool TConstTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node)
72 {
73     if (! node->isConstructor() && node->getOp() != EOpComma) {
74         error = true;
75 
76         return false;
77     }
78 
79     bool flag = node->getSequence().size() == 1 && node->getSequence()[0]->getAsTyped()->getAsConstantUnion();
80     if (flag) {
81         singleConstantParam = true;
82         constructorType = node->getOp();
83         size = node->getType().computeNumComponents();
84 
85         if (node->getType().isMatrix()) {
86             isMatrix = true;
87             matrixCols = node->getType().getMatrixCols();
88             matrixRows = node->getType().getMatrixRows();
89         }
90     }
91 
92     for (TIntermSequence::iterator p = node->getSequence().begin();
93                                    p != node->getSequence().end(); p++) {
94 
95         if (node->getOp() == EOpComma)
96             index = 0;
97 
98         (*p)->traverse(this);
99     }
100     if (flag)
101     {
102         singleConstantParam = false;
103         constructorType = EOpNull;
104         size = 0;
105         isMatrix = false;
106         matrixCols = 0;
107         matrixRows = 0;
108     }
109 
110     return false;
111 }
112 
visitConstantUnion(TIntermConstantUnion * node)113 void TConstTraverser::visitConstantUnion(TIntermConstantUnion* node)
114 {
115     TConstUnionArray leftUnionArray(unionArray);
116     int instanceSize = type.computeNumComponents();
117 
118     if (index >= instanceSize)
119         return;
120 
121     if (! singleConstantParam) {
122         int rightUnionSize = node->getType().computeNumComponents();
123 
124         const TConstUnionArray& rightUnionArray = node->getConstArray();
125         for (int i = 0; i < rightUnionSize; i++) {
126             if (index >= instanceSize)
127                 return;
128             leftUnionArray[index] = rightUnionArray[i];
129 
130             index++;
131         }
132     } else {
133         int endIndex = index + size;
134         const TConstUnionArray& rightUnionArray = node->getConstArray();
135         if (! isMatrix) {
136             int count = 0;
137             int nodeComps = node->getType().computeNumComponents();
138             for (int i = index; i < endIndex; i++) {
139                 if (i >= instanceSize)
140                     return;
141 
142                 leftUnionArray[i] = rightUnionArray[count];
143 
144                 (index)++;
145 
146                 if (nodeComps > 1)
147                     count++;
148             }
149         } else {
150             // constructing a matrix, but from what?
151             if (node->isMatrix()) {
152                 // Matrix from a matrix; this has the outer matrix, node is the argument matrix.
153                 // Traverse the outer, potentially bigger matrix, fill in missing pieces with the
154                 // identity matrix.
155                 for (int c = 0; c < matrixCols; ++c) {
156                     for (int r = 0; r < matrixRows; ++r) {
157                         int targetOffset = index + c * matrixRows + r;
158                         if (r < node->getType().getMatrixRows() && c < node->getType().getMatrixCols()) {
159                             int srcOffset = c * node->getType().getMatrixRows() + r;
160                             leftUnionArray[targetOffset] = rightUnionArray[srcOffset];
161                         } else if (r == c)
162                             leftUnionArray[targetOffset].setDConst(1.0);
163                         else
164                             leftUnionArray[targetOffset].setDConst(0.0);
165                     }
166                 }
167             } else {
168                 // matrix from vector
169                 int count = 0;
170                 const int startIndex = index;
171                 int nodeComps = node->getType().computeNumComponents();
172                 for (int i = startIndex; i < endIndex; i++) {
173                     if (i >= instanceSize)
174                         return;
175                     if (i == startIndex || (i - startIndex) % (matrixRows + 1) == 0 )
176                         leftUnionArray[i] = rightUnionArray[count];
177                     else
178                         leftUnionArray[i].setDConst(0.0);
179 
180                     index++;
181 
182                     if (nodeComps > 1)
183                         count++;
184                 }
185             }
186         }
187     }
188 }
189 
parseConstTree(TIntermNode * root,TConstUnionArray unionArray,TOperator constructorType,const TType & t,bool singleConstantParam)190 bool TIntermediate::parseConstTree(TIntermNode* root, TConstUnionArray unionArray, TOperator constructorType, const TType& t, bool singleConstantParam)
191 {
192     if (root == 0)
193         return false;
194 
195     TConstTraverser it(unionArray, singleConstantParam, constructorType, t);
196 
197     root->traverse(&it);
198     if (it.error)
199         return true;
200     else
201         return false;
202 }
203 
204 } // end namespace glslang
205