1
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
2
|
// Copyright 2016 Leszek Koltunski //
|
3
|
// //
|
4
|
// This file is part of Distorted. //
|
5
|
// //
|
6
|
// Distorted is free software: you can redistribute it and/or modify //
|
7
|
// it under the terms of the GNU General Public License as published by //
|
8
|
// the Free Software Foundation, either version 2 of the License, or //
|
9
|
// (at your option) any later version. //
|
10
|
// //
|
11
|
// Distorted is distributed in the hope that it will be useful, //
|
12
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of //
|
13
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
|
14
|
// GNU General Public License for more details. //
|
15
|
// //
|
16
|
// You should have received a copy of the GNU General Public License //
|
17
|
// along with Distorted. If not, see <http://www.gnu.org/licenses/>. //
|
18
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
19
|
|
20
|
package org.distorted.library.main;
|
21
|
|
22
|
import android.opengl.GLES31;
|
23
|
|
24
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
25
|
/**
|
26
|
* Remember the OpenGL state.
|
27
|
* <p>
|
28
|
* This is a member of DistortedNode. Remembers the OpenGL state we want to set just before rendering
|
29
|
* the Node.
|
30
|
* <p>
|
31
|
* Only for use by the library itself.
|
32
|
*
|
33
|
* @y.exclude
|
34
|
*/
|
35
|
public class DistortedRenderState
|
36
|
{
|
37
|
// TODO: figure this out dynamically; this assumes 8 bit stencil buffer.
|
38
|
private static final int STENCIL_MASK = (1<<8)-1;
|
39
|
|
40
|
private static class RenderState
|
41
|
{
|
42
|
private int colorMaskR, colorMaskG, colorMaskB, colorMaskA;
|
43
|
private int depthMask;
|
44
|
private int stencilMask;
|
45
|
private int depthTest;
|
46
|
private int stencilTest;
|
47
|
private int stencilFuncFunc, stencilFuncRef, stencilFuncMask;
|
48
|
private int stencilOpSfail, stencilOpDpfail, stencilOpDppass;
|
49
|
private int depthFunc;
|
50
|
private int blend;
|
51
|
private int blendSrc, blendDst;
|
52
|
}
|
53
|
|
54
|
private RenderState mState; // state the current object wants to have
|
55
|
static private RenderState cState = new RenderState(); // current OpenGL Stave
|
56
|
static private RenderState sState = new RenderState(); // saved OpenGL state
|
57
|
|
58
|
private int mClear;
|
59
|
|
60
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
61
|
// default: color writes on, depth test and writes on, blending on, stencil off.
|
62
|
|
63
|
DistortedRenderState()
|
64
|
{
|
65
|
mState = new RenderState();
|
66
|
|
67
|
mState.colorMaskR = 1;
|
68
|
mState.colorMaskG = 1;
|
69
|
mState.colorMaskB = 1;
|
70
|
mState.colorMaskA = 1;
|
71
|
|
72
|
mState.depthTest = 1;
|
73
|
mState.depthMask = 1;
|
74
|
mState.depthFunc = GLES31.GL_LEQUAL;
|
75
|
|
76
|
mState.blend = 1;
|
77
|
mState.blendSrc = GLES31.GL_SRC_ALPHA;
|
78
|
mState.blendDst = GLES31.GL_ONE_MINUS_SRC_ALPHA;
|
79
|
|
80
|
mState.stencilTest = 0;
|
81
|
mState.stencilMask = STENCIL_MASK;
|
82
|
mState.stencilFuncFunc = GLES31.GL_NEVER;
|
83
|
mState.stencilFuncRef = 0;
|
84
|
mState.stencilFuncMask = STENCIL_MASK;
|
85
|
mState.stencilOpSfail = GLES31.GL_KEEP;
|
86
|
mState.stencilOpDpfail = GLES31.GL_KEEP;
|
87
|
mState.stencilOpDppass = GLES31.GL_KEEP;
|
88
|
|
89
|
mClear = 0;
|
90
|
}
|
91
|
|
92
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
93
|
// reset state of everything to a known state.
|
94
|
|
95
|
static void reset()
|
96
|
{
|
97
|
cState.colorMaskR = 1;
|
98
|
cState.colorMaskG = 1;
|
99
|
cState.colorMaskB = 1;
|
100
|
cState.colorMaskA = 1;
|
101
|
GLES31.glColorMask(true,true,true,true);
|
102
|
|
103
|
cState.depthTest = 1;
|
104
|
cState.depthMask = 1;
|
105
|
cState.depthFunc = GLES31.GL_LEQUAL;
|
106
|
GLES31.glEnable(GLES31.GL_DEPTH_TEST);
|
107
|
GLES31.glDepthMask(true);
|
108
|
GLES31.glDepthFunc(cState.depthFunc);
|
109
|
|
110
|
cState.stencilTest = 0;
|
111
|
cState.stencilMask = STENCIL_MASK;
|
112
|
cState.stencilFuncFunc = GLES31.GL_NEVER;
|
113
|
cState.stencilFuncRef = 0;
|
114
|
cState.stencilFuncMask = STENCIL_MASK;
|
115
|
cState.stencilOpSfail = GLES31.GL_KEEP;
|
116
|
cState.stencilOpDpfail = GLES31.GL_KEEP;
|
117
|
cState.stencilOpDppass = GLES31.GL_KEEP;
|
118
|
GLES31.glDisable(GLES31.GL_STENCIL_TEST);
|
119
|
GLES31.glStencilMask(cState.stencilMask);
|
120
|
|
121
|
cState.blend = 1;
|
122
|
cState.blendSrc = GLES31.GL_SRC_ALPHA;
|
123
|
cState.blendDst = GLES31.GL_ONE_MINUS_SRC_ALPHA;
|
124
|
GLES31.glEnable(GLES31.GL_BLEND);
|
125
|
GLES31.glBlendFunc(cState.blendSrc,cState.blendDst);
|
126
|
}
|
127
|
|
128
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
129
|
|
130
|
static void colorDepthStencilOn()
|
131
|
{
|
132
|
sState.colorMaskR = cState.colorMaskR;
|
133
|
sState.colorMaskG = cState.colorMaskG;
|
134
|
sState.colorMaskB = cState.colorMaskB;
|
135
|
sState.colorMaskA = cState.colorMaskA;
|
136
|
|
137
|
if( cState.colorMaskR!=1 || cState.colorMaskG!=1 || cState.colorMaskB!=1 || cState.colorMaskA!=1 )
|
138
|
{
|
139
|
cState.colorMaskR = 1;
|
140
|
cState.colorMaskG = 1;
|
141
|
cState.colorMaskB = 1;
|
142
|
cState.colorMaskA = 1;
|
143
|
GLES31.glColorMask(true,true,true,true);
|
144
|
}
|
145
|
|
146
|
sState.depthMask = cState.depthMask;
|
147
|
|
148
|
if( cState.depthMask!=1 )
|
149
|
{
|
150
|
cState.depthMask = 1;
|
151
|
GLES31.glDepthMask(true);
|
152
|
}
|
153
|
|
154
|
sState.stencilMask = cState.stencilMask;
|
155
|
|
156
|
if( cState.stencilMask!= STENCIL_MASK )
|
157
|
{
|
158
|
cState.stencilMask = STENCIL_MASK;
|
159
|
GLES31.glStencilMask(cState.stencilMask);
|
160
|
}
|
161
|
}
|
162
|
|
163
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
164
|
|
165
|
static void colorDepthStencilRestore()
|
166
|
{
|
167
|
if( sState.colorMaskR!=cState.colorMaskR || sState.colorMaskG!=cState.colorMaskG || sState.colorMaskB!=cState.colorMaskB || sState.colorMaskA!=cState.colorMaskA)
|
168
|
{
|
169
|
cState.colorMaskR = sState.colorMaskR;
|
170
|
cState.colorMaskG = sState.colorMaskG;
|
171
|
cState.colorMaskB = sState.colorMaskB;
|
172
|
cState.colorMaskA = sState.colorMaskA;
|
173
|
GLES31.glColorMask(cState.colorMaskR==1,cState.colorMaskG==1,cState.colorMaskB==1,cState.colorMaskA==1);
|
174
|
}
|
175
|
if( sState.depthMask!=cState.depthMask )
|
176
|
{
|
177
|
cState.depthMask = sState.depthMask;
|
178
|
GLES31.glDepthMask(cState.depthMask==1);
|
179
|
}
|
180
|
if( sState.stencilMask!=cState.stencilMask )
|
181
|
{
|
182
|
cState.stencilMask = sState.stencilMask;
|
183
|
GLES31.glStencilMask(cState.stencilMask);
|
184
|
}
|
185
|
}
|
186
|
|
187
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
188
|
|
189
|
static void enableDepthTest()
|
190
|
{
|
191
|
sState.depthTest = cState.depthTest;
|
192
|
|
193
|
if (cState.depthTest != 1)
|
194
|
{
|
195
|
cState.depthTest = 1;
|
196
|
GLES31.glEnable(GLES31.GL_DEPTH_TEST);
|
197
|
}
|
198
|
}
|
199
|
|
200
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
201
|
|
202
|
static void restoreDepthTest()
|
203
|
{
|
204
|
if (sState.depthTest != cState.depthTest)
|
205
|
{
|
206
|
cState.depthTest = sState.depthTest;
|
207
|
|
208
|
if (cState.depthTest == 0)
|
209
|
{
|
210
|
GLES31.glDisable(GLES31.GL_DEPTH_TEST);
|
211
|
}
|
212
|
else
|
213
|
{
|
214
|
GLES31.glEnable(GLES31.GL_DEPTH_TEST);
|
215
|
}
|
216
|
}
|
217
|
}
|
218
|
|
219
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
220
|
|
221
|
static void switchOffDrawing()
|
222
|
{
|
223
|
GLES31.glEnable(GLES31.GL_SCISSOR_TEST);
|
224
|
GLES31.glScissor(0,0,0,0);
|
225
|
}
|
226
|
|
227
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
228
|
|
229
|
static void restoreDrawing()
|
230
|
{
|
231
|
GLES31.glDisable(GLES31.GL_SCISSOR_TEST);
|
232
|
}
|
233
|
|
234
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
235
|
|
236
|
static void switchOffColorDepthStencil()
|
237
|
{
|
238
|
sState.stencilTest = cState.stencilTest;
|
239
|
|
240
|
if( cState.stencilTest!=0 )
|
241
|
{
|
242
|
cState.stencilTest = 0;
|
243
|
//android.util.Log.d("State", "stencil test off");
|
244
|
GLES31.glDisable(GLES31.GL_STENCIL_TEST);
|
245
|
}
|
246
|
|
247
|
sState.depthTest = cState.depthTest;
|
248
|
|
249
|
if( cState.depthTest!=0 )
|
250
|
{
|
251
|
cState.depthTest = 0;
|
252
|
//android.util.Log.d("State", "depth test off");
|
253
|
GLES31.glDisable(GLES31.GL_DEPTH_TEST);
|
254
|
}
|
255
|
|
256
|
sState.colorMaskR = cState.colorMaskR;
|
257
|
sState.colorMaskG = cState.colorMaskG;
|
258
|
sState.colorMaskB = cState.colorMaskB;
|
259
|
sState.colorMaskA = cState.colorMaskA;
|
260
|
|
261
|
if( cState.colorMaskR!=0 || cState.colorMaskG!=0 || cState.colorMaskB!=0 || cState.colorMaskA!=0 )
|
262
|
{
|
263
|
cState.colorMaskR = 0;
|
264
|
cState.colorMaskG = 0;
|
265
|
cState.colorMaskB = 0;
|
266
|
cState.colorMaskA = 0;
|
267
|
//android.util.Log.d("State", "switch off color writing");
|
268
|
GLES31.glColorMask(false,false,false,false);
|
269
|
}
|
270
|
|
271
|
sState.depthMask = cState.depthMask;
|
272
|
|
273
|
if( cState.depthMask!=0 )
|
274
|
{
|
275
|
cState.depthMask = 0;
|
276
|
//android.util.Log.d("State", "switch off depth writing");
|
277
|
GLES31.glDepthMask(false);
|
278
|
}
|
279
|
|
280
|
sState.stencilMask = cState.stencilMask;
|
281
|
|
282
|
if( cState.stencilMask!= 0x00 )
|
283
|
{
|
284
|
cState.stencilMask = 0x00;
|
285
|
//android.util.Log.d("State", "stencil mask off");
|
286
|
GLES31.glStencilMask(cState.stencilMask);
|
287
|
}
|
288
|
}
|
289
|
|
290
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
291
|
|
292
|
static void switchColorDepthOnStencilOff()
|
293
|
{
|
294
|
sState.stencilTest = cState.stencilTest;
|
295
|
|
296
|
if( cState.stencilTest!=0 )
|
297
|
{
|
298
|
cState.stencilTest = 0;
|
299
|
//android.util.Log.d("State", "stencil test off");
|
300
|
GLES31.glDisable(GLES31.GL_STENCIL_TEST);
|
301
|
}
|
302
|
|
303
|
sState.depthTest = cState.depthTest;
|
304
|
|
305
|
if( cState.depthTest!=0 )
|
306
|
{
|
307
|
cState.depthTest = 0;
|
308
|
//android.util.Log.d("State", "depth test off");
|
309
|
GLES31.glDisable(GLES31.GL_DEPTH_TEST);
|
310
|
}
|
311
|
|
312
|
sState.colorMaskR = cState.colorMaskR;
|
313
|
sState.colorMaskG = cState.colorMaskG;
|
314
|
sState.colorMaskB = cState.colorMaskB;
|
315
|
sState.colorMaskA = cState.colorMaskA;
|
316
|
|
317
|
if( cState.colorMaskR!=1 || cState.colorMaskG!=1 || cState.colorMaskB!=1 || cState.colorMaskA!=1 )
|
318
|
{
|
319
|
cState.colorMaskR = 1;
|
320
|
cState.colorMaskG = 1;
|
321
|
cState.colorMaskB = 1;
|
322
|
cState.colorMaskA = 1;
|
323
|
//android.util.Log.d("State", "switch on color writing");
|
324
|
GLES31.glColorMask(true,true,true,true);
|
325
|
}
|
326
|
|
327
|
sState.depthMask = cState.depthMask;
|
328
|
|
329
|
if( cState.depthMask!=1 )
|
330
|
{
|
331
|
cState.depthMask = 1;
|
332
|
//android.util.Log.d("State", "switch on depth writing");
|
333
|
GLES31.glDepthMask(true);
|
334
|
}
|
335
|
|
336
|
sState.stencilMask = cState.stencilMask;
|
337
|
|
338
|
if( cState.stencilMask!= 0x00 )
|
339
|
{
|
340
|
cState.stencilMask = 0x00;
|
341
|
//android.util.Log.d("State", "stencil mask off");
|
342
|
GLES31.glStencilMask(cState.stencilMask);
|
343
|
}
|
344
|
}
|
345
|
|
346
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
347
|
|
348
|
static void restoreColorDepthStencil()
|
349
|
{
|
350
|
if( sState.stencilTest!=cState.stencilTest )
|
351
|
{
|
352
|
cState.stencilTest = sState.stencilTest;
|
353
|
|
354
|
if (cState.stencilTest == 0)
|
355
|
{
|
356
|
GLES31.glDisable(GLES31.GL_STENCIL_TEST);
|
357
|
}
|
358
|
else
|
359
|
{
|
360
|
GLES31.glEnable(GLES31.GL_STENCIL_TEST);
|
361
|
}
|
362
|
}
|
363
|
if( sState.depthTest!=cState.depthTest )
|
364
|
{
|
365
|
cState.depthTest = sState.depthTest;
|
366
|
|
367
|
if (cState.depthTest == 0)
|
368
|
{
|
369
|
GLES31.glDisable(GLES31.GL_DEPTH_TEST);
|
370
|
}
|
371
|
else
|
372
|
{
|
373
|
GLES31.glEnable(GLES31.GL_DEPTH_TEST);
|
374
|
}
|
375
|
}
|
376
|
if( sState.colorMaskR!=cState.colorMaskR || sState.colorMaskG!=cState.colorMaskG || sState.colorMaskB!=cState.colorMaskB || sState.colorMaskA!=cState.colorMaskA)
|
377
|
{
|
378
|
cState.colorMaskR = sState.colorMaskR;
|
379
|
cState.colorMaskG = sState.colorMaskG;
|
380
|
cState.colorMaskB = sState.colorMaskB;
|
381
|
cState.colorMaskA = sState.colorMaskA;
|
382
|
GLES31.glColorMask(cState.colorMaskR==1,cState.colorMaskG==1,cState.colorMaskB==1,cState.colorMaskA==1);
|
383
|
}
|
384
|
if( sState.depthMask!=cState.depthMask )
|
385
|
{
|
386
|
cState.depthMask = sState.depthMask;
|
387
|
GLES31.glDepthMask(cState.depthMask==1);
|
388
|
}
|
389
|
if( sState.stencilMask!=cState.stencilMask )
|
390
|
{
|
391
|
cState.stencilMask = sState.stencilMask;
|
392
|
GLES31.glStencilMask(cState.stencilMask);
|
393
|
}
|
394
|
}
|
395
|
|
396
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
397
|
|
398
|
static void disableStencil()
|
399
|
{
|
400
|
sState.stencilTest = cState.stencilTest;
|
401
|
|
402
|
if (cState.stencilTest != 0)
|
403
|
{
|
404
|
cState.stencilTest = 0;
|
405
|
GLES31.glDisable(GLES31.GL_STENCIL_TEST);
|
406
|
}
|
407
|
|
408
|
sState.stencilFuncFunc = cState.stencilFuncFunc;
|
409
|
sState.stencilFuncRef = cState.stencilFuncRef;
|
410
|
sState.stencilFuncMask = cState.stencilFuncMask;
|
411
|
|
412
|
if( cState.stencilFuncFunc!=GLES31.GL_EQUAL || cState.stencilFuncRef!=1 || cState.stencilFuncMask!=STENCIL_MASK )
|
413
|
{
|
414
|
cState.stencilFuncFunc = GLES31.GL_EQUAL;
|
415
|
cState.stencilFuncRef = 1;
|
416
|
cState.stencilFuncMask = STENCIL_MASK;
|
417
|
GLES31.glStencilFunc(cState.stencilFuncFunc,cState.stencilFuncRef,cState.stencilFuncMask);
|
418
|
}
|
419
|
|
420
|
sState.stencilMask = cState.stencilMask;
|
421
|
|
422
|
if( cState.stencilMask!= 0x00 )
|
423
|
{
|
424
|
cState.stencilMask = 0x00;
|
425
|
GLES31.glStencilMask(cState.stencilMask);
|
426
|
}
|
427
|
}
|
428
|
|
429
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
430
|
|
431
|
static void restoreStencil()
|
432
|
{
|
433
|
if (sState.stencilTest != cState.stencilTest)
|
434
|
{
|
435
|
cState.stencilTest = sState.stencilTest;
|
436
|
|
437
|
if (cState.stencilTest == 0)
|
438
|
{
|
439
|
GLES31.glDisable(GLES31.GL_STENCIL_TEST);
|
440
|
}
|
441
|
else
|
442
|
{
|
443
|
GLES31.glEnable(GLES31.GL_STENCIL_TEST);
|
444
|
}
|
445
|
}
|
446
|
if( sState.stencilFuncFunc!=cState.stencilFuncFunc || sState.stencilFuncRef!=cState.stencilFuncRef || sState.stencilFuncMask!=cState.stencilFuncMask )
|
447
|
{
|
448
|
cState.stencilFuncFunc = sState.stencilFuncFunc;
|
449
|
cState.stencilFuncRef = sState.stencilFuncRef ;
|
450
|
cState.stencilFuncMask = sState.stencilFuncMask;
|
451
|
GLES31.glStencilFunc(cState.stencilFuncFunc,cState.stencilFuncRef,cState.stencilFuncMask);
|
452
|
}
|
453
|
if( sState.stencilMask!=cState.stencilMask )
|
454
|
{
|
455
|
cState.stencilMask = sState.stencilMask;
|
456
|
GLES31.glStencilMask(cState.stencilMask);
|
457
|
}
|
458
|
}
|
459
|
|
460
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
461
|
|
462
|
static void setUpStencilMark(boolean color)
|
463
|
{
|
464
|
sState.stencilTest = cState.stencilTest;
|
465
|
|
466
|
if( cState.stencilTest!=1 )
|
467
|
{
|
468
|
cState.stencilTest = 1;
|
469
|
//android.util.Log.d("State", "stencil test on");
|
470
|
GLES31.glEnable(GLES31.GL_STENCIL_TEST);
|
471
|
}
|
472
|
|
473
|
sState.stencilFuncFunc = cState.stencilFuncFunc;
|
474
|
sState.stencilFuncRef = cState.stencilFuncRef;
|
475
|
sState.stencilFuncMask = cState.stencilFuncMask;
|
476
|
|
477
|
if( cState.stencilFuncFunc!=GLES31.GL_ALWAYS || cState.stencilFuncRef!=1 || cState.stencilFuncMask!=STENCIL_MASK )
|
478
|
{
|
479
|
cState.stencilFuncFunc = GLES31.GL_ALWAYS;
|
480
|
cState.stencilFuncRef = 1;
|
481
|
cState.stencilFuncMask = STENCIL_MASK;
|
482
|
//android.util.Log.d("State", "stencil func on");
|
483
|
GLES31.glStencilFunc(cState.stencilFuncFunc,cState.stencilFuncRef,cState.stencilFuncMask);
|
484
|
}
|
485
|
|
486
|
sState.stencilOpSfail = cState.stencilOpSfail;
|
487
|
sState.stencilOpDpfail= cState.stencilOpDpfail;
|
488
|
sState.stencilOpDppass= cState.stencilOpDppass;
|
489
|
|
490
|
if( cState.stencilOpSfail!=GLES31.GL_KEEP || cState.stencilOpDpfail!=GLES31.GL_KEEP || cState.stencilOpDppass!=GLES31.GL_REPLACE )
|
491
|
{
|
492
|
cState.stencilOpSfail = GLES31.GL_KEEP;
|
493
|
cState.stencilOpDpfail= GLES31.GL_KEEP;
|
494
|
cState.stencilOpDppass= GLES31.GL_REPLACE;
|
495
|
//android.util.Log.d("State", "stencil op on");
|
496
|
GLES31.glStencilOp(cState.stencilOpSfail,cState.stencilOpDpfail,cState.stencilOpDppass);
|
497
|
}
|
498
|
|
499
|
sState.colorMaskR = cState.colorMaskR;
|
500
|
sState.colorMaskG = cState.colorMaskG;
|
501
|
sState.colorMaskB = cState.colorMaskB;
|
502
|
sState.colorMaskA = cState.colorMaskA;
|
503
|
|
504
|
int clr = color ? 1:0;
|
505
|
|
506
|
if( cState.colorMaskR!=clr || cState.colorMaskG!=clr || cState.colorMaskB!=clr || cState.colorMaskA!=clr )
|
507
|
{
|
508
|
cState.colorMaskR = clr;
|
509
|
cState.colorMaskG = clr;
|
510
|
cState.colorMaskB = clr;
|
511
|
cState.colorMaskA = clr;
|
512
|
//android.util.Log.d("State", "switch off color writing");
|
513
|
GLES31.glColorMask(color,color,color,color);
|
514
|
}
|
515
|
|
516
|
sState.depthMask = cState.depthMask;
|
517
|
|
518
|
if( cState.depthMask!=1 )
|
519
|
{
|
520
|
cState.depthMask = 1;
|
521
|
//android.util.Log.d("State", "switch on depth writing");
|
522
|
GLES31.glDepthMask(true);
|
523
|
}
|
524
|
|
525
|
sState.stencilMask = cState.stencilMask;
|
526
|
|
527
|
if( cState.stencilMask!= STENCIL_MASK )
|
528
|
{
|
529
|
cState.stencilMask = STENCIL_MASK;
|
530
|
//android.util.Log.d("State", "stencil mask on");
|
531
|
GLES31.glStencilMask(cState.stencilMask);
|
532
|
}
|
533
|
}
|
534
|
|
535
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
536
|
|
537
|
static void unsetUpStencilMark()
|
538
|
{
|
539
|
if( sState.stencilTest!=cState.stencilTest )
|
540
|
{
|
541
|
cState.stencilTest = sState.stencilTest;
|
542
|
|
543
|
if (cState.stencilTest == 0)
|
544
|
{
|
545
|
GLES31.glDisable(GLES31.GL_STENCIL_TEST);
|
546
|
}
|
547
|
else
|
548
|
{
|
549
|
GLES31.glEnable(GLES31.GL_STENCIL_TEST);
|
550
|
}
|
551
|
}
|
552
|
if( sState.colorMaskR!=cState.colorMaskR || sState.colorMaskG!=cState.colorMaskG || sState.colorMaskB!=cState.colorMaskB || sState.colorMaskA!=cState.colorMaskA)
|
553
|
{
|
554
|
cState.colorMaskR = sState.colorMaskR;
|
555
|
cState.colorMaskG = sState.colorMaskG;
|
556
|
cState.colorMaskB = sState.colorMaskB;
|
557
|
cState.colorMaskA = sState.colorMaskA;
|
558
|
GLES31.glColorMask(cState.colorMaskR==1,cState.colorMaskG==1,cState.colorMaskB==1,cState.colorMaskA==1);
|
559
|
}
|
560
|
if( sState.depthMask!=cState.depthMask )
|
561
|
{
|
562
|
cState.depthMask = sState.depthMask;
|
563
|
GLES31.glDepthMask(cState.depthMask==1);
|
564
|
}
|
565
|
if( sState.stencilMask!=cState.stencilMask )
|
566
|
{
|
567
|
cState.stencilMask = sState.stencilMask;
|
568
|
GLES31.glStencilMask(cState.stencilMask);
|
569
|
}
|
570
|
}
|
571
|
|
572
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
573
|
/**
|
574
|
* Only for use by the library itself.
|
575
|
*
|
576
|
* @y.exclude
|
577
|
*/
|
578
|
public static void useStencilMark()
|
579
|
{
|
580
|
sState.stencilMask = cState.stencilMask;
|
581
|
|
582
|
if( cState.stencilTest!=1 )
|
583
|
{
|
584
|
cState.stencilTest = 1;
|
585
|
GLES31.glEnable(GLES31.GL_STENCIL_TEST);
|
586
|
}
|
587
|
|
588
|
sState.stencilFuncFunc = cState.stencilFuncFunc;
|
589
|
sState.stencilFuncRef = cState.stencilFuncRef;
|
590
|
sState.stencilFuncMask = cState.stencilFuncMask;
|
591
|
|
592
|
if( cState.stencilFuncFunc!=GLES31.GL_EQUAL || cState.stencilFuncRef!=1 || cState.stencilFuncMask!=STENCIL_MASK )
|
593
|
{
|
594
|
cState.stencilFuncFunc = GLES31.GL_EQUAL;
|
595
|
cState.stencilFuncRef = 1;
|
596
|
cState.stencilFuncMask = STENCIL_MASK;
|
597
|
GLES31.glStencilFunc(cState.stencilFuncFunc,cState.stencilFuncRef,cState.stencilFuncMask);
|
598
|
}
|
599
|
|
600
|
sState.stencilMask = cState.stencilMask;
|
601
|
|
602
|
if( cState.stencilMask!= 0x00 )
|
603
|
{
|
604
|
cState.stencilMask = 0x00;
|
605
|
GLES31.glStencilMask(cState.stencilMask);
|
606
|
}
|
607
|
|
608
|
sState.depthMask = cState.depthMask;
|
609
|
|
610
|
if( cState.depthMask!=0 )
|
611
|
{
|
612
|
cState.depthMask = 0;
|
613
|
GLES31.glDepthMask(false);
|
614
|
}
|
615
|
|
616
|
sState.depthTest = cState.depthTest;
|
617
|
|
618
|
if( cState.depthTest!=0 )
|
619
|
{
|
620
|
cState.depthTest = 0;
|
621
|
GLES31.glDisable(GLES31.GL_DEPTH_TEST);
|
622
|
}
|
623
|
}
|
624
|
|
625
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
626
|
/**
|
627
|
* Only for use by the library itself.
|
628
|
*
|
629
|
* @y.exclude
|
630
|
*/
|
631
|
public static void unuseStencilMark()
|
632
|
{
|
633
|
if( sState.stencilTest!=cState.stencilTest )
|
634
|
{
|
635
|
cState.stencilTest = sState.stencilTest;
|
636
|
|
637
|
if (cState.stencilTest == 0)
|
638
|
{
|
639
|
GLES31.glDisable(GLES31.GL_STENCIL_TEST);
|
640
|
}
|
641
|
else
|
642
|
{
|
643
|
GLES31.glEnable(GLES31.GL_STENCIL_TEST);
|
644
|
}
|
645
|
}
|
646
|
if( sState.stencilFuncFunc!=cState.stencilFuncFunc || sState.stencilFuncRef!=cState.stencilFuncRef || sState.stencilFuncMask!=cState.stencilFuncMask )
|
647
|
{
|
648
|
cState.stencilFuncFunc = sState.stencilFuncFunc;
|
649
|
cState.stencilFuncRef = sState.stencilFuncRef ;
|
650
|
cState.stencilFuncMask = sState.stencilFuncMask;
|
651
|
GLES31.glStencilFunc(cState.stencilFuncFunc,cState.stencilFuncRef,cState.stencilFuncMask);
|
652
|
}
|
653
|
if( sState.stencilMask!=cState.stencilMask )
|
654
|
{
|
655
|
cState.stencilMask = sState.stencilMask;
|
656
|
GLES31.glStencilMask(cState.stencilMask);
|
657
|
}
|
658
|
if( sState.depthMask!=cState.depthMask )
|
659
|
{
|
660
|
cState.depthMask = sState.depthMask;
|
661
|
GLES31.glDepthMask(cState.depthMask==1);
|
662
|
}
|
663
|
if( sState.depthTest!=cState.depthTest )
|
664
|
{
|
665
|
cState.depthTest = sState.depthTest;
|
666
|
|
667
|
if (cState.depthTest == 0)
|
668
|
{
|
669
|
GLES31.glDisable(GLES31.GL_DEPTH_TEST);
|
670
|
}
|
671
|
else
|
672
|
{
|
673
|
GLES31.glEnable(GLES31.GL_DEPTH_TEST);
|
674
|
}
|
675
|
}
|
676
|
}
|
677
|
|
678
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
679
|
|
680
|
void apply()
|
681
|
{
|
682
|
//android.util.Log.e("State", "APPLYING STATE");
|
683
|
|
684
|
/////////////////////////////////////////////////////
|
685
|
// 1. Write to color buffer?
|
686
|
if( mState.colorMaskR!=cState.colorMaskR || mState.colorMaskG!=cState.colorMaskG || mState.colorMaskB!=cState.colorMaskB || mState.colorMaskA!=cState.colorMaskA)
|
687
|
{
|
688
|
//android.util.Log.d("State", "setting color mask");
|
689
|
cState.colorMaskR = mState.colorMaskR;
|
690
|
cState.colorMaskG = mState.colorMaskG;
|
691
|
cState.colorMaskB = mState.colorMaskB;
|
692
|
cState.colorMaskA = mState.colorMaskA;
|
693
|
GLES31.glColorMask(cState.colorMaskR==1,cState.colorMaskG==1,cState.colorMaskB==1,cState.colorMaskA==1);
|
694
|
}
|
695
|
|
696
|
/////////////////////////////////////////////////////
|
697
|
// 2. Enable Depth test?
|
698
|
if( mState.depthTest!=cState.depthTest )
|
699
|
{
|
700
|
cState.depthTest = mState.depthTest;
|
701
|
|
702
|
if (cState.depthTest == 0)
|
703
|
{
|
704
|
//android.util.Log.d("State", "disabling depth test");
|
705
|
GLES31.glDisable(GLES31.GL_DEPTH_TEST);
|
706
|
}
|
707
|
else
|
708
|
{
|
709
|
//android.util.Log.d("State", "enable depth test");
|
710
|
GLES31.glEnable(GLES31.GL_DEPTH_TEST);
|
711
|
}
|
712
|
}
|
713
|
|
714
|
/////////////////////////////////////////////////////
|
715
|
// 3. Change Depth Function?
|
716
|
if( mState.depthFunc!=cState.depthFunc )
|
717
|
{
|
718
|
//android.util.Log.d("State", "setting depth func");
|
719
|
cState.depthFunc = mState.depthFunc;
|
720
|
GLES31.glDepthFunc(cState.depthFunc);
|
721
|
}
|
722
|
|
723
|
/////////////////////////////////////////////////////
|
724
|
// 4. Write to Depth buffer?
|
725
|
if( mState.depthMask!=cState.depthMask )
|
726
|
{
|
727
|
//android.util.Log.d("State", "setting depth mask");
|
728
|
cState.depthMask = mState.depthMask;
|
729
|
GLES31.glDepthMask(cState.depthMask==1);
|
730
|
}
|
731
|
|
732
|
/////////////////////////////////////////////////////
|
733
|
// 5. Enable Blending?
|
734
|
if( mState.blend!=cState.blend )
|
735
|
{
|
736
|
cState.blend = mState.blend;
|
737
|
|
738
|
if (cState.blend == 0)
|
739
|
{
|
740
|
//android.util.Log.d("State", "disabling blending");
|
741
|
GLES31.glDisable(GLES31.GL_BLEND);
|
742
|
}
|
743
|
else
|
744
|
{
|
745
|
//android.util.Log.d("State", "enabling blending");
|
746
|
GLES31.glEnable(GLES31.GL_BLEND);
|
747
|
}
|
748
|
}
|
749
|
|
750
|
/////////////////////////////////////////////////////
|
751
|
// 6. Change Blend function?
|
752
|
if( mState.blendSrc!=cState.blendSrc || mState.blendDst!=cState.blendDst )
|
753
|
{
|
754
|
//android.util.Log.d("State", "setting blend function");
|
755
|
cState.blendSrc = mState.blendSrc;
|
756
|
cState.blendDst = mState.blendDst;
|
757
|
GLES31.glBlendFunc(cState.blendSrc,cState.blendDst);
|
758
|
}
|
759
|
|
760
|
/////////////////////////////////////////////////////
|
761
|
// 7. Enable/Disable Stencil Test?
|
762
|
if( mState.stencilTest!=cState.stencilTest )
|
763
|
{
|
764
|
cState.stencilTest = mState.stencilTest;
|
765
|
|
766
|
if (cState.stencilTest == 0)
|
767
|
{
|
768
|
//android.util.Log.d("State", "disabling stencil test");
|
769
|
GLES31.glDisable(GLES31.GL_STENCIL_TEST);
|
770
|
}
|
771
|
else
|
772
|
{
|
773
|
//android.util.Log.d("State", "enabling stencil test");
|
774
|
GLES31.glEnable(GLES31.GL_STENCIL_TEST);
|
775
|
}
|
776
|
}
|
777
|
|
778
|
/////////////////////////////////////////////////////
|
779
|
// 8. Adjust Stencil function?
|
780
|
if( mState.stencilFuncFunc!=cState.stencilFuncFunc || mState.stencilFuncRef!=cState.stencilFuncRef || mState.stencilFuncMask!=cState.stencilFuncMask )
|
781
|
{
|
782
|
//android.util.Log.d("State", "setting stencil function");
|
783
|
cState.stencilFuncFunc = mState.stencilFuncFunc;
|
784
|
cState.stencilFuncRef = mState.stencilFuncRef ;
|
785
|
cState.stencilFuncMask = mState.stencilFuncMask;
|
786
|
GLES31.glStencilFunc(cState.stencilFuncFunc,cState.stencilFuncRef,cState.stencilFuncMask);
|
787
|
}
|
788
|
|
789
|
/////////////////////////////////////////////////////
|
790
|
// 9. Adjust Stencil operation?
|
791
|
if( mState.stencilOpSfail!=cState.stencilOpSfail || mState.stencilOpDpfail!=cState.stencilOpDpfail || mState.stencilOpDppass!=cState.stencilOpDppass )
|
792
|
{
|
793
|
//android.util.Log.d("State", "setting stencil op");
|
794
|
cState.stencilOpSfail = mState.stencilOpSfail;
|
795
|
cState.stencilOpDpfail= mState.stencilOpDpfail;
|
796
|
cState.stencilOpDppass= mState.stencilOpDppass;
|
797
|
GLES31.glStencilOp(cState.stencilOpSfail,cState.stencilOpDpfail,cState.stencilOpDppass);
|
798
|
}
|
799
|
|
800
|
/////////////////////////////////////////////////////
|
801
|
// 10. Write to Stencil buffer?
|
802
|
if( mState.stencilMask!=cState.stencilMask )
|
803
|
{
|
804
|
//android.util.Log.d("State", "setting stencil mask");
|
805
|
cState.stencilMask = mState.stencilMask;
|
806
|
GLES31.glStencilMask(cState.stencilMask);
|
807
|
}
|
808
|
|
809
|
/////////////////////////////////////////////////////
|
810
|
// 11. Clear buffers?
|
811
|
if( mClear!=0 )
|
812
|
{
|
813
|
//android.util.Log.d("State", "clearing buffer");
|
814
|
GLES31.glClear(mClear);
|
815
|
}
|
816
|
}
|
817
|
|
818
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
819
|
|
820
|
void glColorMask(boolean r, boolean g, boolean b, boolean a)
|
821
|
{
|
822
|
mState.colorMaskR = (r ? 1:0);
|
823
|
mState.colorMaskG = (g ? 1:0);
|
824
|
mState.colorMaskB = (b ? 1:0);
|
825
|
mState.colorMaskA = (a ? 1:0);
|
826
|
}
|
827
|
|
828
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
829
|
|
830
|
void glDepthMask(boolean mask)
|
831
|
{
|
832
|
mState.depthMask = (mask ? 1:0);
|
833
|
}
|
834
|
|
835
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
836
|
|
837
|
void glStencilMask(int mask)
|
838
|
{
|
839
|
mState.stencilMask = mask;
|
840
|
}
|
841
|
|
842
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
843
|
|
844
|
void glEnable(int test)
|
845
|
{
|
846
|
if( test==GLES31.GL_DEPTH_TEST ) mState.depthTest = 1;
|
847
|
else if( test==GLES31.GL_STENCIL_TEST ) mState.stencilTest = 1;
|
848
|
else if( test==GLES31.GL_BLEND ) mState.blend = 1;
|
849
|
}
|
850
|
|
851
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
852
|
|
853
|
void glDisable(int test)
|
854
|
{
|
855
|
if( test==GLES31.GL_DEPTH_TEST ) mState.depthTest = 0;
|
856
|
else if( test==GLES31.GL_STENCIL_TEST ) mState.stencilTest = 0;
|
857
|
else if( test==GLES31.GL_BLEND ) mState.blend = 0;
|
858
|
}
|
859
|
|
860
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
861
|
|
862
|
void glStencilFunc(int func, int ref, int mask)
|
863
|
{
|
864
|
mState.stencilFuncFunc = func;
|
865
|
mState.stencilFuncRef = ref;
|
866
|
mState.stencilFuncMask = mask;
|
867
|
}
|
868
|
|
869
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
870
|
|
871
|
void glStencilOp(int sfail, int dpfail, int dppass)
|
872
|
{
|
873
|
mState.stencilOpSfail = sfail;
|
874
|
mState.stencilOpDpfail= dpfail;
|
875
|
mState.stencilOpDppass= dppass;
|
876
|
}
|
877
|
|
878
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
879
|
|
880
|
void glDepthFunc(int func)
|
881
|
{
|
882
|
mState.depthFunc = func;
|
883
|
}
|
884
|
|
885
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
886
|
|
887
|
void glBlendFunc(int src, int dst)
|
888
|
{
|
889
|
mState.blendSrc = src;
|
890
|
mState.blendDst = dst;
|
891
|
}
|
892
|
|
893
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
894
|
|
895
|
void glClear(int mask)
|
896
|
{
|
897
|
mClear = mask;
|
898
|
}
|
899
|
}
|