|
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 disableBlending()
|
|
190
|
{
|
|
191
|
sState.blend = cState.blend;
|
|
192
|
|
|
193
|
if (cState.blend != 0)
|
|
194
|
{
|
|
195
|
cState.blend = 0;
|
|
196
|
GLES31.glDisable(GLES31.GL_BLEND);
|
|
197
|
}
|
|
198
|
}
|
|
199
|
|
|
200
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
201
|
|
|
202
|
static void restoreBlending()
|
|
203
|
{
|
|
204
|
if (sState.blend != cState.blend)
|
|
205
|
{
|
|
206
|
cState.blend = sState.blend;
|
|
207
|
|
|
208
|
if (cState.blend == 0)
|
|
209
|
{
|
|
210
|
GLES31.glDisable(GLES31.GL_BLEND);
|
|
211
|
}
|
|
212
|
else
|
|
213
|
{
|
|
214
|
GLES31.glEnable(GLES31.GL_BLEND);
|
|
215
|
}
|
|
216
|
}
|
|
217
|
}
|
|
218
|
|
|
219
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
220
|
|
|
221
|
static void enableDepthTest()
|
|
222
|
{
|
|
223
|
sState.depthTest = cState.depthTest;
|
|
224
|
|
|
225
|
if (cState.depthTest != 1)
|
|
226
|
{
|
|
227
|
cState.depthTest = 1;
|
|
228
|
GLES31.glEnable(GLES31.GL_DEPTH_TEST);
|
|
229
|
}
|
|
230
|
}
|
|
231
|
|
|
232
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
233
|
|
|
234
|
static void restoreDepthTest()
|
|
235
|
{
|
|
236
|
if (sState.depthTest != cState.depthTest)
|
|
237
|
{
|
|
238
|
cState.depthTest = sState.depthTest;
|
|
239
|
|
|
240
|
if (cState.depthTest == 0)
|
|
241
|
{
|
|
242
|
GLES31.glDisable(GLES31.GL_DEPTH_TEST);
|
|
243
|
}
|
|
244
|
else
|
|
245
|
{
|
|
246
|
GLES31.glEnable(GLES31.GL_DEPTH_TEST);
|
|
247
|
}
|
|
248
|
}
|
|
249
|
}
|
|
250
|
|
|
251
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
252
|
|
|
253
|
static void switchOffDrawing()
|
|
254
|
{
|
|
255
|
GLES31.glEnable(GLES31.GL_SCISSOR_TEST);
|
|
256
|
GLES31.glScissor(0,0,0,0);
|
|
257
|
}
|
|
258
|
|
|
259
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
260
|
|
|
261
|
static void restoreDrawing()
|
|
262
|
{
|
|
263
|
GLES31.glDisable(GLES31.GL_SCISSOR_TEST);
|
|
264
|
}
|
|
265
|
|
|
266
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
267
|
|
|
268
|
static void switchOffColorDepthStencil()
|
|
269
|
{
|
|
270
|
sState.stencilTest = cState.stencilTest;
|
|
271
|
|
|
272
|
if( cState.stencilTest!=0 )
|
|
273
|
{
|
|
274
|
cState.stencilTest = 0;
|
|
275
|
//android.util.Log.d("State", "stencil test off");
|
|
276
|
GLES31.glDisable(GLES31.GL_STENCIL_TEST);
|
|
277
|
}
|
|
278
|
|
|
279
|
sState.depthTest = cState.depthTest;
|
|
280
|
|
|
281
|
if( cState.depthTest!=0 )
|
|
282
|
{
|
|
283
|
cState.depthTest = 0;
|
|
284
|
//android.util.Log.d("State", "depth test off");
|
|
285
|
GLES31.glDisable(GLES31.GL_DEPTH_TEST);
|
|
286
|
}
|
|
287
|
|
|
288
|
sState.colorMaskR = cState.colorMaskR;
|
|
289
|
sState.colorMaskG = cState.colorMaskG;
|
|
290
|
sState.colorMaskB = cState.colorMaskB;
|
|
291
|
sState.colorMaskA = cState.colorMaskA;
|
|
292
|
|
|
293
|
if( cState.colorMaskR!=0 || cState.colorMaskG!=0 || cState.colorMaskB!=0 || cState.colorMaskA!=0 )
|
|
294
|
{
|
|
295
|
cState.colorMaskR = 0;
|
|
296
|
cState.colorMaskG = 0;
|
|
297
|
cState.colorMaskB = 0;
|
|
298
|
cState.colorMaskA = 0;
|
|
299
|
//android.util.Log.d("State", "switch off color writing");
|
|
300
|
GLES31.glColorMask(false,false,false,false);
|
|
301
|
}
|
|
302
|
|
|
303
|
sState.depthMask = cState.depthMask;
|
|
304
|
|
|
305
|
if( cState.depthMask!=0 )
|
|
306
|
{
|
|
307
|
cState.depthMask = 0;
|
|
308
|
//android.util.Log.d("State", "switch off depth writing");
|
|
309
|
GLES31.glDepthMask(false);
|
|
310
|
}
|
|
311
|
|
|
312
|
sState.stencilMask = cState.stencilMask;
|
|
313
|
|
|
314
|
if( cState.stencilMask!= 0x00 )
|
|
315
|
{
|
|
316
|
cState.stencilMask = 0x00;
|
|
317
|
//android.util.Log.d("State", "stencil mask off");
|
|
318
|
GLES31.glStencilMask(cState.stencilMask);
|
|
319
|
}
|
|
320
|
}
|
|
321
|
|
|
322
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
323
|
|
|
324
|
static void switchColorDepthOnStencilOff()
|
|
325
|
{
|
|
326
|
sState.stencilTest = cState.stencilTest;
|
|
327
|
|
|
328
|
if( cState.stencilTest!=0 )
|
|
329
|
{
|
|
330
|
cState.stencilTest = 0;
|
|
331
|
//android.util.Log.d("State", "stencil test off");
|
|
332
|
GLES31.glDisable(GLES31.GL_STENCIL_TEST);
|
|
333
|
}
|
|
334
|
|
|
335
|
sState.depthTest = cState.depthTest;
|
|
336
|
|
|
337
|
if( cState.depthTest!=0 )
|
|
338
|
{
|
|
339
|
cState.depthTest = 0;
|
|
340
|
//android.util.Log.d("State", "depth test off");
|
|
341
|
GLES31.glDisable(GLES31.GL_DEPTH_TEST);
|
|
342
|
}
|
|
343
|
|
|
344
|
sState.colorMaskR = cState.colorMaskR;
|
|
345
|
sState.colorMaskG = cState.colorMaskG;
|
|
346
|
sState.colorMaskB = cState.colorMaskB;
|
|
347
|
sState.colorMaskA = cState.colorMaskA;
|
|
348
|
|
|
349
|
if( cState.colorMaskR!=1 || cState.colorMaskG!=1 || cState.colorMaskB!=1 || cState.colorMaskA!=1 )
|
|
350
|
{
|
|
351
|
cState.colorMaskR = 1;
|
|
352
|
cState.colorMaskG = 1;
|
|
353
|
cState.colorMaskB = 1;
|
|
354
|
cState.colorMaskA = 1;
|
|
355
|
//android.util.Log.d("State", "switch on color writing");
|
|
356
|
GLES31.glColorMask(true,true,true,true);
|
|
357
|
}
|
|
358
|
|
|
359
|
sState.depthMask = cState.depthMask;
|
|
360
|
|
|
361
|
if( cState.depthMask!=1 )
|
|
362
|
{
|
|
363
|
cState.depthMask = 1;
|
|
364
|
//android.util.Log.d("State", "switch on depth writing");
|
|
365
|
GLES31.glDepthMask(true);
|
|
366
|
}
|
|
367
|
|
|
368
|
sState.stencilMask = cState.stencilMask;
|
|
369
|
|
|
370
|
if( cState.stencilMask!= 0x00 )
|
|
371
|
{
|
|
372
|
cState.stencilMask = 0x00;
|
|
373
|
//android.util.Log.d("State", "stencil mask off");
|
|
374
|
GLES31.glStencilMask(cState.stencilMask);
|
|
375
|
}
|
|
376
|
}
|
|
377
|
|
|
378
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
379
|
|
|
380
|
static void restoreColorDepthStencil()
|
|
381
|
{
|
|
382
|
if( sState.stencilTest!=cState.stencilTest )
|
|
383
|
{
|
|
384
|
cState.stencilTest = sState.stencilTest;
|
|
385
|
|
|
386
|
if (cState.stencilTest == 0)
|
|
387
|
{
|
|
388
|
GLES31.glDisable(GLES31.GL_STENCIL_TEST);
|
|
389
|
}
|
|
390
|
else
|
|
391
|
{
|
|
392
|
GLES31.glEnable(GLES31.GL_STENCIL_TEST);
|
|
393
|
}
|
|
394
|
}
|
|
395
|
if( sState.depthTest!=cState.depthTest )
|
|
396
|
{
|
|
397
|
cState.depthTest = sState.depthTest;
|
|
398
|
|
|
399
|
if (cState.depthTest == 0)
|
|
400
|
{
|
|
401
|
GLES31.glDisable(GLES31.GL_DEPTH_TEST);
|
|
402
|
}
|
|
403
|
else
|
|
404
|
{
|
|
405
|
GLES31.glEnable(GLES31.GL_DEPTH_TEST);
|
|
406
|
}
|
|
407
|
}
|
|
408
|
if( sState.colorMaskR!=cState.colorMaskR || sState.colorMaskG!=cState.colorMaskG || sState.colorMaskB!=cState.colorMaskB || sState.colorMaskA!=cState.colorMaskA)
|
|
409
|
{
|
|
410
|
cState.colorMaskR = sState.colorMaskR;
|
|
411
|
cState.colorMaskG = sState.colorMaskG;
|
|
412
|
cState.colorMaskB = sState.colorMaskB;
|
|
413
|
cState.colorMaskA = sState.colorMaskA;
|
|
414
|
GLES31.glColorMask(cState.colorMaskR==1,cState.colorMaskG==1,cState.colorMaskB==1,cState.colorMaskA==1);
|
|
415
|
}
|
|
416
|
if( sState.depthMask!=cState.depthMask )
|
|
417
|
{
|
|
418
|
cState.depthMask = sState.depthMask;
|
|
419
|
GLES31.glDepthMask(cState.depthMask==1);
|
|
420
|
}
|
|
421
|
if( sState.stencilMask!=cState.stencilMask )
|
|
422
|
{
|
|
423
|
cState.stencilMask = sState.stencilMask;
|
|
424
|
GLES31.glStencilMask(cState.stencilMask);
|
|
425
|
}
|
|
426
|
}
|
|
427
|
|
|
428
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
429
|
|
|
430
|
static void disableStencil()
|
|
431
|
{
|
|
432
|
sState.stencilTest = cState.stencilTest;
|
|
433
|
|
|
434
|
if (cState.stencilTest != 0)
|
|
435
|
{
|
|
436
|
cState.stencilTest = 0;
|
|
437
|
GLES31.glDisable(GLES31.GL_STENCIL_TEST);
|
|
438
|
}
|
|
439
|
|
|
440
|
sState.stencilFuncFunc = cState.stencilFuncFunc;
|
|
441
|
sState.stencilFuncRef = cState.stencilFuncRef;
|
|
442
|
sState.stencilFuncMask = cState.stencilFuncMask;
|
|
443
|
|
|
444
|
if( cState.stencilFuncFunc!=GLES31.GL_EQUAL || cState.stencilFuncRef!=1 || cState.stencilFuncMask!=STENCIL_MASK )
|
|
445
|
{
|
|
446
|
cState.stencilFuncFunc = GLES31.GL_EQUAL;
|
|
447
|
cState.stencilFuncRef = 1;
|
|
448
|
cState.stencilFuncMask = STENCIL_MASK;
|
|
449
|
GLES31.glStencilFunc(cState.stencilFuncFunc,cState.stencilFuncRef,cState.stencilFuncMask);
|
|
450
|
}
|
|
451
|
|
|
452
|
sState.stencilMask = cState.stencilMask;
|
|
453
|
|
|
454
|
if( cState.stencilMask!= 0x00 )
|
|
455
|
{
|
|
456
|
cState.stencilMask = 0x00;
|
|
457
|
GLES31.glStencilMask(cState.stencilMask);
|
|
458
|
}
|
|
459
|
}
|
|
460
|
|
|
461
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
462
|
|
|
463
|
static void restoreStencil()
|
|
464
|
{
|
|
465
|
if (sState.stencilTest != cState.stencilTest)
|
|
466
|
{
|
|
467
|
cState.stencilTest = sState.stencilTest;
|
|
468
|
|
|
469
|
if (cState.stencilTest == 0)
|
|
470
|
{
|
|
471
|
GLES31.glDisable(GLES31.GL_STENCIL_TEST);
|
|
472
|
}
|
|
473
|
else
|
|
474
|
{
|
|
475
|
GLES31.glEnable(GLES31.GL_STENCIL_TEST);
|
|
476
|
}
|
|
477
|
}
|
|
478
|
if( sState.stencilFuncFunc!=cState.stencilFuncFunc || sState.stencilFuncRef!=cState.stencilFuncRef || sState.stencilFuncMask!=cState.stencilFuncMask )
|
|
479
|
{
|
|
480
|
cState.stencilFuncFunc = sState.stencilFuncFunc;
|
|
481
|
cState.stencilFuncRef = sState.stencilFuncRef ;
|
|
482
|
cState.stencilFuncMask = sState.stencilFuncMask;
|
|
483
|
GLES31.glStencilFunc(cState.stencilFuncFunc,cState.stencilFuncRef,cState.stencilFuncMask);
|
|
484
|
}
|
|
485
|
if( sState.stencilMask!=cState.stencilMask )
|
|
486
|
{
|
|
487
|
cState.stencilMask = sState.stencilMask;
|
|
488
|
GLES31.glStencilMask(cState.stencilMask);
|
|
489
|
}
|
|
490
|
}
|
|
491
|
|
|
492
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
493
|
|
|
494
|
static void setUpStencilMark(boolean color)
|
|
495
|
{
|
|
496
|
sState.stencilTest = cState.stencilTest;
|
|
497
|
|
|
498
|
if( cState.stencilTest!=1 )
|
|
499
|
{
|
|
500
|
cState.stencilTest = 1;
|
|
501
|
//android.util.Log.d("State", "stencil test on");
|
|
502
|
GLES31.glEnable(GLES31.GL_STENCIL_TEST);
|
|
503
|
}
|
|
504
|
|
|
505
|
sState.stencilFuncFunc = cState.stencilFuncFunc;
|
|
506
|
sState.stencilFuncRef = cState.stencilFuncRef;
|
|
507
|
sState.stencilFuncMask = cState.stencilFuncMask;
|
|
508
|
|
|
509
|
if( cState.stencilFuncFunc!=GLES31.GL_ALWAYS || cState.stencilFuncRef!=1 || cState.stencilFuncMask!=STENCIL_MASK )
|
|
510
|
{
|
|
511
|
cState.stencilFuncFunc = GLES31.GL_ALWAYS;
|
|
512
|
cState.stencilFuncRef = 1;
|
|
513
|
cState.stencilFuncMask = STENCIL_MASK;
|
|
514
|
//android.util.Log.d("State", "stencil func on");
|
|
515
|
GLES31.glStencilFunc(cState.stencilFuncFunc,cState.stencilFuncRef,cState.stencilFuncMask);
|
|
516
|
}
|
|
517
|
|
|
518
|
sState.stencilOpSfail = cState.stencilOpSfail;
|
|
519
|
sState.stencilOpDpfail= cState.stencilOpDpfail;
|
|
520
|
sState.stencilOpDppass= cState.stencilOpDppass;
|
|
521
|
|
|
522
|
if( cState.stencilOpSfail!=GLES31.GL_KEEP || cState.stencilOpDpfail!=GLES31.GL_KEEP || cState.stencilOpDppass!=GLES31.GL_REPLACE )
|
|
523
|
{
|
|
524
|
cState.stencilOpSfail = GLES31.GL_KEEP;
|
|
525
|
cState.stencilOpDpfail= GLES31.GL_KEEP;
|
|
526
|
cState.stencilOpDppass= GLES31.GL_REPLACE;
|
|
527
|
//android.util.Log.d("State", "stencil op on");
|
|
528
|
GLES31.glStencilOp(cState.stencilOpSfail,cState.stencilOpDpfail,cState.stencilOpDppass);
|
|
529
|
}
|
|
530
|
|
|
531
|
sState.colorMaskR = cState.colorMaskR;
|
|
532
|
sState.colorMaskG = cState.colorMaskG;
|
|
533
|
sState.colorMaskB = cState.colorMaskB;
|
|
534
|
sState.colorMaskA = cState.colorMaskA;
|
|
535
|
|
|
536
|
int clr = color ? 1:0;
|
|
537
|
|
|
538
|
if( cState.colorMaskR!=clr || cState.colorMaskG!=clr || cState.colorMaskB!=clr || cState.colorMaskA!=clr )
|
|
539
|
{
|
|
540
|
cState.colorMaskR = clr;
|
|
541
|
cState.colorMaskG = clr;
|
|
542
|
cState.colorMaskB = clr;
|
|
543
|
cState.colorMaskA = clr;
|
|
544
|
//android.util.Log.d("State", "switch off color writing");
|
|
545
|
GLES31.glColorMask(color,color,color,color);
|
|
546
|
}
|
|
547
|
|
|
548
|
sState.depthMask = cState.depthMask;
|
|
549
|
|
|
550
|
if( cState.depthMask!=1 )
|
|
551
|
{
|
|
552
|
cState.depthMask = 1;
|
|
553
|
//android.util.Log.d("State", "switch on depth writing");
|
|
554
|
GLES31.glDepthMask(true);
|
|
555
|
}
|
|
556
|
|
|
557
|
sState.stencilMask = cState.stencilMask;
|
|
558
|
|
|
559
|
if( cState.stencilMask!= STENCIL_MASK )
|
|
560
|
{
|
|
561
|
cState.stencilMask = STENCIL_MASK;
|
|
562
|
//android.util.Log.d("State", "stencil mask on");
|
|
563
|
GLES31.glStencilMask(cState.stencilMask);
|
|
564
|
}
|
|
565
|
}
|
|
566
|
|
|
567
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
568
|
|
|
569
|
static void unsetUpStencilMark()
|
|
570
|
{
|
|
571
|
if( sState.stencilTest!=cState.stencilTest )
|
|
572
|
{
|
|
573
|
cState.stencilTest = sState.stencilTest;
|
|
574
|
|
|
575
|
if (cState.stencilTest == 0)
|
|
576
|
{
|
|
577
|
GLES31.glDisable(GLES31.GL_STENCIL_TEST);
|
|
578
|
}
|
|
579
|
else
|
|
580
|
{
|
|
581
|
GLES31.glEnable(GLES31.GL_STENCIL_TEST);
|
|
582
|
}
|
|
583
|
}
|
|
584
|
if( sState.colorMaskR!=cState.colorMaskR || sState.colorMaskG!=cState.colorMaskG || sState.colorMaskB!=cState.colorMaskB || sState.colorMaskA!=cState.colorMaskA)
|
|
585
|
{
|
|
586
|
cState.colorMaskR = sState.colorMaskR;
|
|
587
|
cState.colorMaskG = sState.colorMaskG;
|
|
588
|
cState.colorMaskB = sState.colorMaskB;
|
|
589
|
cState.colorMaskA = sState.colorMaskA;
|
|
590
|
GLES31.glColorMask(cState.colorMaskR==1,cState.colorMaskG==1,cState.colorMaskB==1,cState.colorMaskA==1);
|
|
591
|
}
|
|
592
|
if( sState.depthMask!=cState.depthMask )
|
|
593
|
{
|
|
594
|
cState.depthMask = sState.depthMask;
|
|
595
|
GLES31.glDepthMask(cState.depthMask==1);
|
|
596
|
}
|
|
597
|
if( sState.stencilMask!=cState.stencilMask )
|
|
598
|
{
|
|
599
|
cState.stencilMask = sState.stencilMask;
|
|
600
|
GLES31.glStencilMask(cState.stencilMask);
|
|
601
|
}
|
|
602
|
}
|
|
603
|
|
|
604
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
605
|
/**
|
|
606
|
* Only for use by the library itself.
|
|
607
|
*
|
|
608
|
* @y.exclude
|
|
609
|
*/
|
|
610
|
public static void useStencilMark()
|
|
611
|
{
|
|
612
|
sState.stencilMask = cState.stencilMask;
|
|
613
|
|
|
614
|
if( cState.stencilTest!=1 )
|
|
615
|
{
|
|
616
|
cState.stencilTest = 1;
|
|
617
|
GLES31.glEnable(GLES31.GL_STENCIL_TEST);
|
|
618
|
}
|
|
619
|
|
|
620
|
sState.stencilFuncFunc = cState.stencilFuncFunc;
|
|
621
|
sState.stencilFuncRef = cState.stencilFuncRef;
|
|
622
|
sState.stencilFuncMask = cState.stencilFuncMask;
|
|
623
|
|
|
624
|
if( cState.stencilFuncFunc!=GLES31.GL_EQUAL || cState.stencilFuncRef!=1 || cState.stencilFuncMask!=STENCIL_MASK )
|
|
625
|
{
|
|
626
|
cState.stencilFuncFunc = GLES31.GL_EQUAL;
|
|
627
|
cState.stencilFuncRef = 1;
|
|
628
|
cState.stencilFuncMask = STENCIL_MASK;
|
|
629
|
GLES31.glStencilFunc(cState.stencilFuncFunc,cState.stencilFuncRef,cState.stencilFuncMask);
|
|
630
|
}
|
|
631
|
|
|
632
|
sState.stencilMask = cState.stencilMask;
|
|
633
|
|
|
634
|
if( cState.stencilMask!= 0x00 )
|
|
635
|
{
|
|
636
|
cState.stencilMask = 0x00;
|
|
637
|
GLES31.glStencilMask(cState.stencilMask);
|
|
638
|
}
|
|
639
|
|
|
640
|
sState.depthMask = cState.depthMask;
|
|
641
|
|
|
642
|
if( cState.depthMask!=0 )
|
|
643
|
{
|
|
644
|
cState.depthMask = 0;
|
|
645
|
GLES31.glDepthMask(false);
|
|
646
|
}
|
|
647
|
|
|
648
|
sState.depthTest = cState.depthTest;
|
|
649
|
|
|
650
|
if( cState.depthTest!=0 )
|
|
651
|
{
|
|
652
|
cState.depthTest = 0;
|
|
653
|
GLES31.glDisable(GLES31.GL_DEPTH_TEST);
|
|
654
|
}
|
|
655
|
}
|
|
656
|
|
|
657
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
658
|
/**
|
|
659
|
* Only for use by the library itself.
|
|
660
|
*
|
|
661
|
* @y.exclude
|
|
662
|
*/
|
|
663
|
public static void unuseStencilMark()
|
|
664
|
{
|
|
665
|
if( sState.stencilTest!=cState.stencilTest )
|
|
666
|
{
|
|
667
|
cState.stencilTest = sState.stencilTest;
|
|
668
|
|
|
669
|
if (cState.stencilTest == 0)
|
|
670
|
{
|
|
671
|
GLES31.glDisable(GLES31.GL_STENCIL_TEST);
|
|
672
|
}
|
|
673
|
else
|
|
674
|
{
|
|
675
|
GLES31.glEnable(GLES31.GL_STENCIL_TEST);
|
|
676
|
}
|
|
677
|
}
|
|
678
|
if( sState.stencilFuncFunc!=cState.stencilFuncFunc || sState.stencilFuncRef!=cState.stencilFuncRef || sState.stencilFuncMask!=cState.stencilFuncMask )
|
|
679
|
{
|
|
680
|
cState.stencilFuncFunc = sState.stencilFuncFunc;
|
|
681
|
cState.stencilFuncRef = sState.stencilFuncRef ;
|
|
682
|
cState.stencilFuncMask = sState.stencilFuncMask;
|
|
683
|
GLES31.glStencilFunc(cState.stencilFuncFunc,cState.stencilFuncRef,cState.stencilFuncMask);
|
|
684
|
}
|
|
685
|
if( sState.stencilMask!=cState.stencilMask )
|
|
686
|
{
|
|
687
|
cState.stencilMask = sState.stencilMask;
|
|
688
|
GLES31.glStencilMask(cState.stencilMask);
|
|
689
|
}
|
|
690
|
if( sState.depthMask!=cState.depthMask )
|
|
691
|
{
|
|
692
|
cState.depthMask = sState.depthMask;
|
|
693
|
GLES31.glDepthMask(cState.depthMask==1);
|
|
694
|
}
|
|
695
|
if( sState.depthTest!=cState.depthTest )
|
|
696
|
{
|
|
697
|
cState.depthTest = sState.depthTest;
|
|
698
|
|
|
699
|
if (cState.depthTest == 0)
|
|
700
|
{
|
|
701
|
GLES31.glDisable(GLES31.GL_DEPTH_TEST);
|
|
702
|
}
|
|
703
|
else
|
|
704
|
{
|
|
705
|
GLES31.glEnable(GLES31.GL_DEPTH_TEST);
|
|
706
|
}
|
|
707
|
}
|
|
708
|
}
|
|
709
|
|
|
710
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
711
|
|
|
712
|
void apply()
|
|
713
|
{
|
|
714
|
//android.util.Log.e("State", "APPLYING STATE");
|
|
715
|
|
|
716
|
/////////////////////////////////////////////////////
|
|
717
|
// 1. Write to color buffer?
|
|
718
|
if( mState.colorMaskR!=cState.colorMaskR || mState.colorMaskG!=cState.colorMaskG || mState.colorMaskB!=cState.colorMaskB || mState.colorMaskA!=cState.colorMaskA)
|
|
719
|
{
|
|
720
|
//android.util.Log.d("State", "setting color mask");
|
|
721
|
cState.colorMaskR = mState.colorMaskR;
|
|
722
|
cState.colorMaskG = mState.colorMaskG;
|
|
723
|
cState.colorMaskB = mState.colorMaskB;
|
|
724
|
cState.colorMaskA = mState.colorMaskA;
|
|
725
|
GLES31.glColorMask(cState.colorMaskR==1,cState.colorMaskG==1,cState.colorMaskB==1,cState.colorMaskA==1);
|
|
726
|
}
|
|
727
|
|
|
728
|
/////////////////////////////////////////////////////
|
|
729
|
// 2. Enable Depth test?
|
|
730
|
if( mState.depthTest!=cState.depthTest )
|
|
731
|
{
|
|
732
|
cState.depthTest = mState.depthTest;
|
|
733
|
|
|
734
|
if (cState.depthTest == 0)
|
|
735
|
{
|
|
736
|
//android.util.Log.d("State", "disabling depth test");
|
|
737
|
GLES31.glDisable(GLES31.GL_DEPTH_TEST);
|
|
738
|
}
|
|
739
|
else
|
|
740
|
{
|
|
741
|
//android.util.Log.d("State", "enable depth test");
|
|
742
|
GLES31.glEnable(GLES31.GL_DEPTH_TEST);
|
|
743
|
}
|
|
744
|
}
|
|
745
|
|
|
746
|
/////////////////////////////////////////////////////
|
|
747
|
// 3. Change Depth Function?
|
|
748
|
if( mState.depthFunc!=cState.depthFunc )
|
|
749
|
{
|
|
750
|
//android.util.Log.d("State", "setting depth func");
|
|
751
|
cState.depthFunc = mState.depthFunc;
|
|
752
|
GLES31.glDepthFunc(cState.depthFunc);
|
|
753
|
}
|
|
754
|
|
|
755
|
/////////////////////////////////////////////////////
|
|
756
|
// 4. Write to Depth buffer?
|
|
757
|
if( mState.depthMask!=cState.depthMask )
|
|
758
|
{
|
|
759
|
//android.util.Log.d("State", "setting depth mask");
|
|
760
|
cState.depthMask = mState.depthMask;
|
|
761
|
GLES31.glDepthMask(cState.depthMask==1);
|
|
762
|
}
|
|
763
|
|
|
764
|
/////////////////////////////////////////////////////
|
|
765
|
// 5. Enable Blending?
|
|
766
|
if( mState.blend!=cState.blend )
|
|
767
|
{
|
|
768
|
cState.blend = mState.blend;
|
|
769
|
|
|
770
|
if (cState.blend == 0)
|
|
771
|
{
|
|
772
|
//android.util.Log.d("State", "disabling blending");
|
|
773
|
GLES31.glDisable(GLES31.GL_BLEND);
|
|
774
|
}
|
|
775
|
else
|
|
776
|
{
|
|
777
|
//android.util.Log.d("State", "enabling blending");
|
|
778
|
GLES31.glEnable(GLES31.GL_BLEND);
|
|
779
|
}
|
|
780
|
}
|
|
781
|
|
|
782
|
/////////////////////////////////////////////////////
|
|
783
|
// 6. Change Blend function?
|
|
784
|
if( mState.blendSrc!=cState.blendSrc || mState.blendDst!=cState.blendDst )
|
|
785
|
{
|
|
786
|
//android.util.Log.d("State", "setting blend function");
|
|
787
|
cState.blendSrc = mState.blendSrc;
|
|
788
|
cState.blendDst = mState.blendDst;
|
|
789
|
GLES31.glBlendFunc(cState.blendSrc,cState.blendDst);
|
|
790
|
}
|
|
791
|
|
|
792
|
/////////////////////////////////////////////////////
|
|
793
|
// 7. Enable/Disable Stencil Test?
|
|
794
|
if( mState.stencilTest!=cState.stencilTest )
|
|
795
|
{
|
|
796
|
cState.stencilTest = mState.stencilTest;
|
|
797
|
|
|
798
|
if (cState.stencilTest == 0)
|
|
799
|
{
|
|
800
|
//android.util.Log.d("State", "disabling stencil test");
|
|
801
|
GLES31.glDisable(GLES31.GL_STENCIL_TEST);
|
|
802
|
}
|
|
803
|
else
|
|
804
|
{
|
|
805
|
//android.util.Log.d("State", "enabling stencil test");
|
|
806
|
GLES31.glEnable(GLES31.GL_STENCIL_TEST);
|
|
807
|
}
|
|
808
|
}
|
|
809
|
|
|
810
|
/////////////////////////////////////////////////////
|
|
811
|
// 8. Adjust Stencil function?
|
|
812
|
if( mState.stencilFuncFunc!=cState.stencilFuncFunc || mState.stencilFuncRef!=cState.stencilFuncRef || mState.stencilFuncMask!=cState.stencilFuncMask )
|
|
813
|
{
|
|
814
|
//android.util.Log.d("State", "setting stencil function");
|
|
815
|
cState.stencilFuncFunc = mState.stencilFuncFunc;
|
|
816
|
cState.stencilFuncRef = mState.stencilFuncRef ;
|
|
817
|
cState.stencilFuncMask = mState.stencilFuncMask;
|
|
818
|
GLES31.glStencilFunc(cState.stencilFuncFunc,cState.stencilFuncRef,cState.stencilFuncMask);
|
|
819
|
}
|
|
820
|
|
|
821
|
/////////////////////////////////////////////////////
|
|
822
|
// 9. Adjust Stencil operation?
|
|
823
|
if( mState.stencilOpSfail!=cState.stencilOpSfail || mState.stencilOpDpfail!=cState.stencilOpDpfail || mState.stencilOpDppass!=cState.stencilOpDppass )
|
|
824
|
{
|
|
825
|
//android.util.Log.d("State", "setting stencil op");
|
|
826
|
cState.stencilOpSfail = mState.stencilOpSfail;
|
|
827
|
cState.stencilOpDpfail= mState.stencilOpDpfail;
|
|
828
|
cState.stencilOpDppass= mState.stencilOpDppass;
|
|
829
|
GLES31.glStencilOp(cState.stencilOpSfail,cState.stencilOpDpfail,cState.stencilOpDppass);
|
|
830
|
}
|
|
831
|
|
|
832
|
/////////////////////////////////////////////////////
|
|
833
|
// 10. Write to Stencil buffer?
|
|
834
|
if( mState.stencilMask!=cState.stencilMask )
|
|
835
|
{
|
|
836
|
//android.util.Log.d("State", "setting stencil mask");
|
|
837
|
cState.stencilMask = mState.stencilMask;
|
|
838
|
GLES31.glStencilMask(cState.stencilMask);
|
|
839
|
}
|
|
840
|
|
|
841
|
/////////////////////////////////////////////////////
|
|
842
|
// 11. Clear buffers?
|
|
843
|
if( mClear!=0 )
|
|
844
|
{
|
|
845
|
//android.util.Log.d("State", "clearing buffer");
|
|
846
|
GLES31.glClear(mClear);
|
|
847
|
}
|
|
848
|
}
|
|
849
|
|
|
850
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
851
|
|
|
852
|
void glColorMask(boolean r, boolean g, boolean b, boolean a)
|
|
853
|
{
|
|
854
|
mState.colorMaskR = (r ? 1:0);
|
|
855
|
mState.colorMaskG = (g ? 1:0);
|
|
856
|
mState.colorMaskB = (b ? 1:0);
|
|
857
|
mState.colorMaskA = (a ? 1:0);
|
|
858
|
}
|
|
859
|
|
|
860
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
861
|
|
|
862
|
void glDepthMask(boolean mask)
|
|
863
|
{
|
|
864
|
mState.depthMask = (mask ? 1:0);
|
|
865
|
}
|
|
866
|
|
|
867
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
868
|
|
|
869
|
void glStencilMask(int mask)
|
|
870
|
{
|
|
871
|
mState.stencilMask = mask;
|
|
872
|
}
|
|
873
|
|
|
874
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
875
|
|
|
876
|
void glEnable(int test)
|
|
877
|
{
|
|
878
|
if( test==GLES31.GL_DEPTH_TEST ) mState.depthTest = 1;
|
|
879
|
else if( test==GLES31.GL_STENCIL_TEST ) mState.stencilTest = 1;
|
|
880
|
else if( test==GLES31.GL_BLEND ) mState.blend = 1;
|
|
881
|
}
|
|
882
|
|
|
883
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
884
|
|
|
885
|
void glDisable(int test)
|
|
886
|
{
|
|
887
|
if( test==GLES31.GL_DEPTH_TEST ) mState.depthTest = 0;
|
|
888
|
else if( test==GLES31.GL_STENCIL_TEST ) mState.stencilTest = 0;
|
|
889
|
else if( test==GLES31.GL_BLEND ) mState.blend = 0;
|
|
890
|
}
|
|
891
|
|
|
892
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
893
|
|
|
894
|
void glStencilFunc(int func, int ref, int mask)
|
|
895
|
{
|
|
896
|
mState.stencilFuncFunc = func;
|
|
897
|
mState.stencilFuncRef = ref;
|
|
898
|
mState.stencilFuncMask = mask;
|
|
899
|
}
|
|
900
|
|
|
901
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
902
|
|
|
903
|
void glStencilOp(int sfail, int dpfail, int dppass)
|
|
904
|
{
|
|
905
|
mState.stencilOpSfail = sfail;
|
|
906
|
mState.stencilOpDpfail= dpfail;
|
|
907
|
mState.stencilOpDppass= dppass;
|
|
908
|
}
|
|
909
|
|
|
910
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
911
|
|
|
912
|
void glDepthFunc(int func)
|
|
913
|
{
|
|
914
|
mState.depthFunc = func;
|
|
915
|
}
|
|
916
|
|
|
917
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
918
|
|
|
919
|
void glBlendFunc(int src, int dst)
|
|
920
|
{
|
|
921
|
mState.blendSrc = src;
|
|
922
|
mState.blendDst = dst;
|
|
923
|
}
|
|
924
|
|
|
925
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
926
|
|
|
927
|
void glClear(int mask)
|
|
928
|
{
|
|
929
|
mClear = mask;
|
|
930
|
}
|
|
931
|
}
|