Skip to content

Commit 6a47319

Browse files
shadowislordshadowislord
committed
DefineList: fix build error
Also add additional unit tests for DefineList.
1 parent 9d035f7 commit 6a47319

2 files changed

Lines changed: 213 additions & 41 deletions

File tree

‎jme3-core/src/main/java/com/jme3/shader/DefineList.java‎

Lines changed: 20 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -38,12 +38,10 @@
3838
*
3939
* @author Kirill Vainer
4040
*/
41-
public final class DefineList implements Cloneable {
41+
public final class DefineList {
4242

4343
public static final int MAX_DEFINES = 64;
4444

45-
public static final int SAVABLE_VERSION = 1;
46-
4745
private long hash;
4846
private final int[] vals;
4947

@@ -78,6 +76,18 @@ public void set(int id, boolean val) {
7876
set(id, val ? 1 : 0);
7977
}
8078

79+
public boolean getBoolean(int id) {
80+
return vals[id] != 0;
81+
}
82+
83+
public float getFloat(int id) {
84+
return Float.intBitsToFloat(vals[id]);
85+
}
86+
87+
public int getInt(int id) {
88+
return vals[id];
89+
}
90+
8191
@Override
8292
public int hashCode() {
8393
return (int)((hash >> 32) ^ hash);
@@ -110,7 +120,7 @@ public void generateSource(StringBuilder sb, List<String> defineNames, List<VarT
110120

111121
if (defineTypes != null && defineTypes.get(i) == VarType.Float) {
112122
float val = Float.intBitsToFloat(vals[i]);
113-
if (!Float.isFinite(val)) {
123+
if (Float.isInfinite(val) || Float.isNaN(val)) {
114124
throw new IllegalArgumentException(
115125
"GLSL does not support NaN "
116126
+ "or Infinite float literals");
@@ -123,6 +133,11 @@ public void generateSource(StringBuilder sb, List<String> defineNames, List<VarT
123133
sb.append("\n");
124134
}
125135
}
126-
System.out.println(sb.toString());
136+
}
137+
138+
public String generateSource(List<String> defineNames, List<VarType> defineTypes) {
139+
StringBuilder sb = new StringBuilder();
140+
generateSource(sb, defineNames, defineTypes);
141+
return sb.toString();
127142
}
128143
}

‎jme3-core/src/test/java/com/jme3/shader/DefineListTest.java‎

Lines changed: 193 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -33,14 +33,22 @@
3333

3434
import com.jme3.math.FastMath;
3535
import java.util.Arrays;
36+
import java.util.HashMap;
3637
import java.util.List;
3738
import org.junit.Test;
3839

40+
import static org.junit.Assert.*;
41+
3942
public class DefineListTest {
4043

41-
private List<String> defineNames;
42-
private List<VarType> defineTypes;
43-
44+
private static final List<String> DEFINE_NAMES = Arrays.asList("BOOL_VAR", "INT_VAR", "FLOAT_VAR");
45+
private static final List<VarType> DEFINE_TYPES = Arrays.asList(VarType.Boolean, VarType.Int, VarType.Float);
46+
private static final int NUM_DEFINES = DEFINE_NAMES.size();
47+
private static final int BOOL_VAR = 0;
48+
private static final int INT_VAR = 1;
49+
private static final int FLOAT_VAR = 2;
50+
private static final DefineList EMPTY = new DefineList(NUM_DEFINES);
51+
4452
@Test
4553
public void testHashCollision() {
4654
DefineList dl1 = new DefineList(64);
@@ -58,86 +66,235 @@ public void testHashCollision() {
5866
assert dl1.equals(dl2);
5967
}
6068

69+
@Test
70+
public void testGetSet() {
71+
DefineList dl = new DefineList(NUM_DEFINES);
72+
73+
assertFalse(dl.getBoolean(BOOL_VAR));
74+
assertEquals(dl.getInt(INT_VAR), 0);
75+
assertEquals(dl.getFloat(FLOAT_VAR), 0f, 0f);
76+
77+
dl.set(BOOL_VAR, true);
78+
dl.set(INT_VAR, -1);
79+
dl.set(FLOAT_VAR, Float.NaN);
80+
81+
assertTrue(dl.getBoolean(BOOL_VAR));
82+
assertEquals(dl.getInt(INT_VAR), -1);
83+
assertTrue(Float.isNaN(dl.getFloat(FLOAT_VAR)));
84+
}
85+
6186
private String generateSource(DefineList dl) {
6287
StringBuilder sb = new StringBuilder();
63-
dl.generateSource(sb, defineNames, defineTypes);
88+
dl.generateSource(sb, DEFINE_NAMES, DEFINE_TYPES);
6489
return sb.toString();
6590
}
6691

6792
@Test
68-
public void testInitial() {
69-
DefineList dl = new DefineList(3);
70-
defineNames = Arrays.asList("A", "B", "C");
71-
defineTypes = Arrays.asList(VarType.Boolean, VarType.Int, VarType.Float);
72-
93+
public void testSourceInitial() {
94+
DefineList dl = new DefineList(NUM_DEFINES);
7395
assert dl.hashCode() == 0;
7496
assert generateSource(dl).equals("");
7597
}
7698

7799
@Test
78-
public void testBooleanDefine() {
79-
DefineList dl = new DefineList(1);
80-
defineNames = Arrays.asList("BOOL_VAR");
81-
defineTypes = Arrays.asList(VarType.Boolean);
82-
83-
dl.set(0, true);
100+
public void testSourceBooleanDefine() {
101+
DefineList dl = new DefineList(NUM_DEFINES);
102+
103+
dl.set(BOOL_VAR, true);
84104
assert dl.hashCode() == 1;
85105
assert generateSource(dl).equals("#define BOOL_VAR 1\n");
86106

87-
dl.set(0, false);
107+
dl.set(BOOL_VAR, false);
88108
assert dl.hashCode() == 0;
89109
assert generateSource(dl).equals("");
90110
}
91111

92112
@Test
93-
public void testFloatDefine() {
94-
DefineList dl = new DefineList(1);
95-
defineNames = Arrays.asList("FLOAT_VAR");
96-
defineTypes = Arrays.asList(VarType.Float);
113+
public void testSourceIntDefine() {
114+
DefineList dl = new DefineList(NUM_DEFINES);
115+
116+
int hashCodeWithInt = 1 << INT_VAR;
97117

98-
dl.set(0, 1f);
99-
assert dl.hashCode() == 1;
118+
dl.set(INT_VAR, 123);
119+
assert dl.hashCode() == hashCodeWithInt;
120+
assert generateSource(dl).equals("#define INT_VAR 123\n");
121+
122+
dl.set(INT_VAR, 0);
123+
assert dl.hashCode() == 0;
124+
assert generateSource(dl).equals("");
125+
126+
dl.set(INT_VAR, -99);
127+
assert dl.hashCode() == hashCodeWithInt;
128+
assert generateSource(dl).equals("#define INT_VAR -99\n");
129+
130+
dl.set(INT_VAR, Integer.MAX_VALUE);
131+
assert dl.hashCode() == hashCodeWithInt;
132+
assert generateSource(dl).equals("#define INT_VAR 2147483647\n");
133+
}
134+
135+
@Test
136+
public void testSourceFloatDefine() {
137+
DefineList dl = new DefineList(NUM_DEFINES);
138+
139+
dl.set(FLOAT_VAR, 1f);
140+
assert dl.hashCode() == (1 << FLOAT_VAR);
100141
assert generateSource(dl).equals("#define FLOAT_VAR 1.0\n");
101142

102-
dl.set(0, 0f);
143+
dl.set(FLOAT_VAR, 0f);
103144
assert dl.hashCode() == 0;
104145
assert generateSource(dl).equals("");
105146

106-
dl.set(0, -1f);
147+
dl.set(FLOAT_VAR, -1f);
107148
assert generateSource(dl).equals("#define FLOAT_VAR -1.0\n");
108149

109-
dl.set(0, FastMath.FLT_EPSILON);
150+
dl.set(FLOAT_VAR, FastMath.FLT_EPSILON);
110151
assert generateSource(dl).equals("#define FLOAT_VAR 1.1920929E-7\n");
111152

112-
dl.set(0, FastMath.PI);
153+
dl.set(FLOAT_VAR, FastMath.PI);
113154
assert generateSource(dl).equals("#define FLOAT_VAR 3.1415927\n");
114155

115156
try {
116-
dl.set(0, Float.NaN);
157+
dl.set(FLOAT_VAR, Float.NaN);
117158
generateSource(dl);
118159
assert false;
119160
} catch (IllegalArgumentException ex) { }
120161

121162
try {
122-
dl.set(0, Float.POSITIVE_INFINITY);
163+
dl.set(FLOAT_VAR, Float.POSITIVE_INFINITY);
123164
generateSource(dl);
124165
assert false;
125166
} catch (IllegalArgumentException ex) { }
126167

127168
try {
128-
dl.set(0, Float.NEGATIVE_INFINITY);
169+
dl.set(FLOAT_VAR, Float.NEGATIVE_INFINITY);
129170
generateSource(dl);
130171
assert false;
131172
} catch (IllegalArgumentException ex) { }
132173
}
133174

134175
@Test
135-
public void testSourceGeneration() {
136-
DefineList dl = new DefineList(64);
137-
defineNames = Arrays.asList("BOOL_VAR", "INT_VAR", "FLOAT_VAR");
138-
defineTypes = Arrays.asList(VarType.Boolean, VarType.Int, VarType.Float);
139-
dl.set(0, true);
140-
dl.set(1, -1);
141-
dl.set(2, Float.NaN);
176+
public void testEqualsAndHashCode() {
177+
DefineList dl1 = new DefineList(NUM_DEFINES);
178+
DefineList dl2 = new DefineList(NUM_DEFINES);
179+
180+
assertTrue(dl1.hashCode() == 0);
181+
assertEquals(dl1, dl2);
182+
183+
dl1.set(BOOL_VAR, true);
184+
185+
assertTrue(dl1.hashCode() == 1);
186+
assertNotSame(dl1, dl2);
187+
188+
dl2.set(BOOL_VAR, true);
189+
190+
assertEquals(dl1, dl2);
191+
192+
dl1.set(INT_VAR, 2);
193+
194+
assertTrue(dl1.hashCode() == (1|2));
195+
assertNotSame(dl1, dl2);
196+
197+
dl2.set(INT_VAR, 2);
198+
199+
assertEquals(dl1, dl2);
200+
201+
dl1.set(BOOL_VAR, false);
202+
203+
assertTrue(dl1.hashCode() == 2);
204+
assertNotSame(dl1, dl2);
205+
}
206+
207+
@Test
208+
public void testDeepClone() {
209+
DefineList dl1 = new DefineList(NUM_DEFINES);
210+
DefineList dl2 = dl1.deepClone();
211+
212+
assertFalse(dl1 == dl2);
213+
assertTrue(dl1.equals(dl2));
214+
assertTrue(dl1.hashCode() == dl2.hashCode());
215+
216+
dl1.set(BOOL_VAR, true);
217+
dl2 = dl1.deepClone();
218+
219+
assertTrue(dl1.equals(dl2));
220+
assertTrue(dl1.hashCode() == dl2.hashCode());
221+
222+
dl1.set(INT_VAR, 123);
223+
224+
assertFalse(dl1.equals(dl2));
225+
assertFalse(dl1.hashCode() == dl2.hashCode());
226+
227+
dl2 = dl1.deepClone();
228+
229+
assertTrue(dl1.equals(dl2));
230+
assertTrue(dl1.hashCode() == dl2.hashCode());
231+
}
232+
233+
@Test
234+
public void testGenerateSource() {
235+
DefineList dl = new DefineList(NUM_DEFINES);
236+
237+
assertEquals("", generateSource(dl));
238+
239+
dl.set(BOOL_VAR, true);
240+
241+
assertEquals("#define BOOL_VAR 1\n", generateSource(dl));
242+
243+
dl.set(INT_VAR, 123);
244+
245+
assertEquals("#define BOOL_VAR 1\n" +
246+
"#define INT_VAR 123\n", generateSource(dl));
247+
248+
dl.set(BOOL_VAR, false);
249+
250+
assertEquals("#define INT_VAR 123\n", generateSource(dl));
251+
252+
dl.set(BOOL_VAR, true);
253+
254+
// should have predictable ordering based on defineId
255+
assertEquals("#define BOOL_VAR 1\n" +
256+
"#define INT_VAR 123\n", generateSource(dl));
257+
}
258+
259+
private static String doLookup(HashMap<DefineList, String> map, boolean boolVal, int intVal, float floatVal) {
260+
DefineList dl = new DefineList(NUM_DEFINES);
261+
dl.set(BOOL_VAR, boolVal);
262+
dl.set(INT_VAR, intVal);
263+
dl.set(FLOAT_VAR, floatVal);
264+
return map.get(dl);
265+
}
266+
267+
@Test
268+
public void testHashLookup() {
269+
String STR_EMPTY = "This is an empty define list";
270+
String STR_INT = "This define list has an int value";
271+
String STR_BOOL = "This define list just has boolean value set";
272+
String STR_BOOL_INT = "This define list has both a boolean and int value";
273+
String STR_BOOL_INT_FLOAT = "This define list has a boolean, int, and float value";
274+
275+
HashMap<DefineList, String> map = new HashMap<DefineList, String>();
276+
277+
DefineList lookup = new DefineList(NUM_DEFINES);
278+
279+
map.put(lookup.deepClone(), STR_EMPTY);
280+
281+
lookup.set(BOOL_VAR, true);
282+
map.put(lookup.deepClone(), STR_BOOL);
283+
284+
lookup.set(BOOL_VAR, false);
285+
lookup.set(INT_VAR, 123);
286+
map.put(lookup.deepClone(), STR_INT);
287+
288+
lookup.set(BOOL_VAR, true);
289+
map.put(lookup.deepClone(), STR_BOOL_INT);
290+
291+
lookup.set(FLOAT_VAR, FastMath.PI);
292+
map.put(lookup.deepClone(), STR_BOOL_INT_FLOAT);
293+
294+
assertEquals(doLookup(map, false, 0, 0f), STR_EMPTY);
295+
assertEquals(doLookup(map, false, 123, 0f), STR_INT);
296+
assertEquals(doLookup(map, true, 0, 0f), STR_BOOL);
297+
assertEquals(doLookup(map, true, 123, 0f), STR_BOOL_INT);
298+
assertEquals(doLookup(map, true, 123, FastMath.PI), STR_BOOL_INT_FLOAT);
142299
}
143300
}

0 commit comments

Comments
 (0)