077a220c |
1 | // Author: Ilya Khramov |
2 | // Copyright (c) 2019 OPEN CASCADE SAS |
3 | // |
4 | // This file is part of Open CASCADE Technology software library. |
5 | // |
6 | // This library is free software; you can redistribute it and/or modify it under |
7 | // the terms of the GNU Lesser General Public License version 2.1 as published |
8 | // by the Free Software Foundation, with special exception defined in the file |
9 | // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT |
10 | // distribution for complete text of the license and disclaimer of any warranty. |
11 | // |
12 | // Alternatively, this file may be used under the terms of Open CASCADE |
13 | // commercial license or contractual agreement. |
14 | |
15 | #include <Graphic3d_CubeMapOrder.hxx> |
16 | |
17 | #include <Standard_Failure.hxx> |
18 | |
19 | #include <bitset> |
20 | |
21 | // ======================================================================= |
22 | // function : Graphic3d_CubeMapOrder |
23 | // purpose : |
24 | // ======================================================================= |
25 | Graphic3d_CubeMapOrder::Graphic3d_CubeMapOrder() |
26 | : |
27 | myConvolution (0), |
28 | myHasOverflows (false) |
29 | {} |
30 | |
31 | // ======================================================================= |
32 | // function : Graphic3d_CubeMapOrder |
33 | // purpose : |
34 | // ======================================================================= |
35 | Graphic3d_CubeMapOrder::Graphic3d_CubeMapOrder (unsigned char thePosXLocation, |
36 | unsigned char theNegXLocation, |
37 | unsigned char thePosYLocation, |
38 | unsigned char theNegYLocation, |
39 | unsigned char thePosZLocation, |
40 | unsigned char theNegZLocation) |
41 | : |
42 | myConvolution (0), |
43 | myHasOverflows (false) |
44 | { |
45 | Set (Graphic3d_CMS_POS_X, thePosXLocation); |
46 | Set (Graphic3d_CMS_NEG_X, theNegXLocation); |
47 | Set (Graphic3d_CMS_POS_Y, thePosYLocation); |
48 | Set (Graphic3d_CMS_NEG_Y, theNegYLocation); |
49 | Set (Graphic3d_CMS_POS_Z, thePosZLocation); |
50 | Set (Graphic3d_CMS_NEG_Z, theNegZLocation); |
51 | } |
52 | |
53 | // ======================================================================= |
54 | // function : Graphic3d_CubeMapOrder |
55 | // purpose : |
56 | // ======================================================================= |
57 | Graphic3d_CubeMapOrder::Graphic3d_CubeMapOrder (const Graphic3d_ValidatedCubeMapOrder theOrder) |
58 | : |
59 | myConvolution (theOrder.Order.myConvolution), |
60 | myHasOverflows (theOrder.Order.myHasOverflows) |
61 | {} |
62 | |
63 | // ======================================================================= |
64 | // function : Set |
65 | // purpose : |
66 | // ======================================================================= |
67 | Graphic3d_CubeMapOrder& Graphic3d_CubeMapOrder::Set (const Graphic3d_CubeMapOrder& theOrder) |
68 | { |
69 | myConvolution = theOrder.myConvolution; |
70 | myHasOverflows = theOrder.myHasOverflows; |
71 | return *this; |
72 | } |
73 | |
74 | // ======================================================================= |
75 | // function : operator= |
76 | // purpose : |
77 | // ======================================================================= |
78 | Graphic3d_ValidatedCubeMapOrder Graphic3d_CubeMapOrder::Validated() const |
79 | { |
80 | if (!IsValid()) |
81 | { |
82 | throw Standard_Failure("Try of Graphic3d_ValidatedCubeMapOrder creation using invalid Graphic3d_CubeMapOrder"); |
83 | } |
84 | |
85 | return *this; |
86 | } |
87 | |
88 | // ======================================================================= |
89 | // function : Set |
90 | // purpose : |
91 | // ======================================================================= |
92 | Graphic3d_CubeMapOrder& Graphic3d_CubeMapOrder::Set (Graphic3d_CubeMapSide theCubeMapSide, unsigned char theValue) |
93 | { |
94 | if (theValue > 5) |
95 | { |
96 | myHasOverflows = true; |
97 | return *this; |
98 | } |
99 | set (theCubeMapSide, theValue); |
100 | return *this; |
101 | } |
102 | |
103 | // ======================================================================= |
104 | // function : Get |
105 | // purpose : |
106 | // ======================================================================= |
107 | unsigned char Graphic3d_CubeMapOrder::Get (Graphic3d_CubeMapSide theCubeMapSide) const |
108 | { |
109 | return get (static_cast<unsigned char> (theCubeMapSide)); |
110 | } |
111 | |
112 | // ======================================================================= |
113 | // function : operator[] |
114 | // purpose : |
115 | // ======================================================================= |
116 | unsigned char Graphic3d_CubeMapOrder::operator[] (Graphic3d_CubeMapSide theCubeMapSide) const |
117 | { |
118 | return Get (theCubeMapSide); |
119 | } |
120 | |
121 | // ======================================================================= |
122 | // function : SetDefault |
123 | // purpose : |
124 | // ======================================================================= |
125 | Graphic3d_CubeMapOrder& Graphic3d_CubeMapOrder::SetDefault() |
126 | { |
127 | for (unsigned char i = 0; i < 6; ++i) |
128 | { |
129 | set (Graphic3d_CubeMapSide (i), i); |
130 | } |
131 | return *this; |
132 | } |
133 | |
134 | // ======================================================================= |
135 | // function : Permute |
136 | // purpose : |
137 | // ======================================================================= |
138 | Graphic3d_CubeMapOrder& Graphic3d_CubeMapOrder::Permute (Graphic3d_ValidatedCubeMapOrder thePermutation) |
139 | { |
140 | for (unsigned char i = 0; i < 6; ++i) |
141 | { |
142 | set (i, thePermutation->get (get (i))); |
143 | } |
144 | |
145 | return *this; |
146 | } |
147 | |
148 | // ======================================================================= |
149 | // function : Permuted |
150 | // purpose : |
151 | // ======================================================================= |
152 | Graphic3d_CubeMapOrder Graphic3d_CubeMapOrder::Permuted (Graphic3d_ValidatedCubeMapOrder thePermutation) const |
153 | { |
154 | Graphic3d_CubeMapOrder anOrder = *this; |
155 | anOrder.Permute (thePermutation); |
156 | return anOrder; |
157 | } |
158 | |
159 | // ======================================================================= |
160 | // function : Swap |
161 | // purpose : |
162 | // ======================================================================= |
163 | Graphic3d_CubeMapOrder& Graphic3d_CubeMapOrder::Swap (Graphic3d_CubeMapSide theFirstSide, |
164 | Graphic3d_CubeMapSide theSecondSide) |
165 | { |
166 | unsigned char aTmp = Get (theFirstSide); |
167 | set (theFirstSide, Get(theSecondSide)); |
168 | set (theSecondSide, aTmp); |
169 | return *this; |
170 | } |
171 | |
172 | // ======================================================================= |
173 | // function : Swapped |
174 | // purpose : |
175 | // ======================================================================= |
176 | Graphic3d_CubeMapOrder Graphic3d_CubeMapOrder::Swapped (Graphic3d_CubeMapSide theFirstSide, |
177 | Graphic3d_CubeMapSide theSecondSide) const |
178 | { |
179 | Graphic3d_CubeMapOrder anOrder = *this; |
180 | anOrder.Swap (theFirstSide, theSecondSide); |
181 | return anOrder; |
182 | } |
183 | |
184 | // ======================================================================= |
185 | // function : Clear |
186 | // purpose : |
187 | // ======================================================================= |
188 | Graphic3d_CubeMapOrder& Graphic3d_CubeMapOrder::Clear() |
189 | { |
190 | myConvolution = 0; |
191 | myHasOverflows = false; |
192 | return *this; |
193 | } |
194 | |
195 | // ======================================================================= |
196 | // function : IsEmpty |
197 | // purpose : |
198 | // ======================================================================= |
199 | bool Graphic3d_CubeMapOrder::IsEmpty() const |
200 | { |
201 | return myConvolution == 0; |
202 | } |
203 | |
204 | // ======================================================================= |
205 | // function : HasRepetitions |
206 | // purpose : |
207 | // ======================================================================= |
208 | bool Graphic3d_CubeMapOrder::HasRepetitions() const |
209 | { |
210 | std::bitset<6> aBitSet; |
211 | for (unsigned char i = 0; i < 6; ++i) |
212 | { |
213 | std::bitset<6>::reference aFlag = aBitSet[get (i)]; |
214 | if (aFlag) |
215 | { |
216 | return true; |
217 | } |
218 | aFlag = true; |
219 | } |
220 | return false; |
221 | } |
222 | |
223 | // ======================================================================= |
224 | // function : HasOverflows |
225 | // purpose : |
226 | // ======================================================================= |
227 | bool Graphic3d_CubeMapOrder::HasOverflows() const |
228 | { |
229 | return myHasOverflows; |
230 | } |
231 | |
232 | // ======================================================================= |
233 | // function : IsValid |
234 | // purpose : |
235 | // ======================================================================= |
236 | bool Graphic3d_CubeMapOrder::IsValid() const |
237 | { |
238 | return !HasRepetitions() && !HasOverflows(); |
239 | } |
240 | |
241 | // ======================================================================= |
242 | // function : get |
243 | // purpose : |
244 | // ======================================================================= |
245 | unsigned char Graphic3d_CubeMapOrder::get (unsigned char theCubeMapSide) const |
246 | { |
247 | return (myConvolution / (1 << (theCubeMapSide * 3))) % (1 << 3); |
248 | } |
249 | |
250 | // ======================================================================= |
251 | // function : set |
252 | // purpose : |
253 | // ======================================================================= |
254 | void Graphic3d_CubeMapOrder::set (unsigned char theCubeMapSide, unsigned char theValue) |
255 | { |
256 | unsigned int aValuePlace = 1 << (theCubeMapSide * 3); |
257 | myConvolution -= aValuePlace * get (theCubeMapSide); |
258 | myConvolution += aValuePlace * theValue; |
259 | } |
260 | |
261 | // ======================================================================= |
262 | // function : set |
263 | // purpose : |
264 | // ======================================================================= |
265 | void Graphic3d_CubeMapOrder::set (Graphic3d_CubeMapSide theCubeMapSide, unsigned char theValue) |
266 | { |
267 | set (static_cast<unsigned char> (theCubeMapSide), theValue); |
268 | } |
269 | |
270 | // ======================================================================= |
271 | // function : Default |
272 | // purpose : |
273 | // ======================================================================= |
274 | const Graphic3d_ValidatedCubeMapOrder& Graphic3d_CubeMapOrder::Default() |
275 | { |
276 | static const Graphic3d_ValidatedCubeMapOrder aCubeMapOrder = Graphic3d_CubeMapOrder().SetDefault().Validated(); |
277 | return aCubeMapOrder; |
278 | } |