/src/main/java/org/distorted/library/main/DistortedLibrary.java - Annotate - Distorted Android

library / src / main / java / org / distorted / library / main / DistortedLibrary.java @ 667884b0

1	d333eb6b	Leszek Koltunski	///////////////////////////////////////////////////////////////////////////////////////////////////
2			// Copyright 2016 Leszek Koltunski //
3			// //
4	46b572b5	Leszek Koltunski	// This file is part of Distorted. //
5	d333eb6b	Leszek Koltunski	// //
6	46b572b5	Leszek Koltunski	// Distorted is free software: you can redistribute it and/or modify //
7	d333eb6b	Leszek Koltunski	// 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	46b572b5	Leszek Koltunski	// Distorted is distributed in the hope that it will be useful, //
12	d333eb6b	Leszek Koltunski	// 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	46b572b5	Leszek Koltunski	// along with Distorted. If not, see <http://www.gnu.org/licenses/>. //
18	d333eb6b	Leszek Koltunski	///////////////////////////////////////////////////////////////////////////////////////////////////
19
20	fe82a979	Leszek Koltunski	package org.distorted.library.main;
21	6a06a912	Leszek Koltunski
22	30beb34f	Leszek Koltunski	import android.app.ActivityManager;
23	7845dc66	Leszek Koltunski	import android.content.Context;
24	30beb34f	Leszek Koltunski	import android.content.pm.ConfigurationInfo;
25	d6e94c84	Leszek Koltunski	import android.content.res.Resources;
26	b7074bc6	Leszek Koltunski	import android.opengl.GLES30;
27	edea9cf3	Leszek Koltunski	import android.opengl.GLES31;
28	bfe45b4a	Leszek Koltunski	import android.util.Log;
29	310e14fb	leszek
30	bfe45b4a	Leszek Koltunski	import org.distorted.library.R;
31	26a4e5f6	leszek	import org.distorted.library.effect.Effect;
32	809dcae3	Leszek Koltunski	import org.distorted.library.effectqueue.EffectQueue;
33			import org.distorted.library.effectqueue.EffectQueuePostprocess;
34	bfe45b4a	Leszek Koltunski	import org.distorted.library.effect.EffectType;
35			import org.distorted.library.effect.FragmentEffect;
36	aa2f0486	Leszek Koltunski	import org.distorted.library.effect.PostprocessEffect;
37	bfe45b4a	Leszek Koltunski	import org.distorted.library.effect.VertexEffect;
38			import org.distorted.library.mesh.MeshBase;
39	ed06301f	Leszek Koltunski	import org.distorted.library.message.EffectMessageSender;
40	bfe45b4a	Leszek Koltunski	import org.distorted.library.program.DistortedProgram;
41	b7074bc6	Leszek Koltunski	import org.distorted.library.program.VertexCompilationException;
42	bfe45b4a	Leszek Koltunski
43			import java.io.InputStream;
44			import java.nio.ByteBuffer;
45			import java.nio.ByteOrder;
46			import java.nio.FloatBuffer;
47			import java.nio.IntBuffer;
48	6a06a912	Leszek Koltunski
49			///////////////////////////////////////////////////////////////////////////////////////////////////
50			/**
51	f953bee0	Leszek Koltunski	* A singleton class used to control various global dialog_settings.
52	6a06a912	Leszek Koltunski	*/
53	7602a827	Leszek Koltunski	public class DistortedLibrary
54	39cbf9dc	Leszek Koltunski	{
55	b7074bc6	Leszek Koltunski	private static int mGLSL;
56			private static String mGLSL_VERSION;
57			private static boolean mOITCompilationSuccessful;
58	6a06a912	Leszek Koltunski	/**
59	cacc63de	Leszek Koltunski	* When creating an instance of a DistortedTexture from another instance, clone the Bitmap that's
60			* backing up our DistortedTexture.
61	6a06a912	Leszek Koltunski	* <p>
62	cacc63de	Leszek Koltunski	* This way we can have two DistortedTextures, both backed up by the same Bitmap, to which we can
63	6a06a912	Leszek Koltunski	* apply different effects. Used in the copy constructor.
64			*/
65	29a06526	Leszek Koltunski	public static final int CLONE_SURFACE = 0x1;
66	6a06a912	Leszek Koltunski	/**
67	cacc63de	Leszek Koltunski	* When creating an instance of a DistortedEffects from another instance, clone the Matrix Effects.
68	6a06a912	Leszek Koltunski	* <p>
69	cacc63de	Leszek Koltunski	* This way we can have two different DistortedEffects sharing the MATRIX queue.
70	6a06a912	Leszek Koltunski	*/
71	015642fb	Leszek Koltunski	public static final int CLONE_MATRIX = 0x2;
72	6a06a912	Leszek Koltunski	/**
73	cacc63de	Leszek Koltunski	* When creating an instance of a DistortedEffects from another instance, clone the Vertex Effects.
74	6a06a912	Leszek Koltunski	* <p>
75	cacc63de	Leszek Koltunski	* This way we can have two different DistortedEffects sharing the VERTEX queue.
76	6a06a912	Leszek Koltunski	*/
77			public static final int CLONE_VERTEX = 0x4;
78			/**
79	cacc63de	Leszek Koltunski	* When creating an instance of a DistortedEffects from another instance, clone the Fragment Effects.
80	6a06a912	Leszek Koltunski	* <p>
81	cacc63de	Leszek Koltunski	* This way we can have two different DistortedEffects sharing the FRAGMENT queue.
82	6a06a912	Leszek Koltunski	*/
83			public static final int CLONE_FRAGMENT= 0x8;
84	d6e94c84	Leszek Koltunski	/**
85			* When creating an instance of a DistortedEffects from another instance, clone the PostProcess Effects.
86			* <p>
87			* This way we can have two different DistortedEffects sharing the POSTPROCESS queue.
88			*/
89			public static final int CLONE_POSTPROCESS= 0x10;
90	6a06a912	Leszek Koltunski	/**
91	a09ada4c	Leszek Koltunski	* When creating an instance of a DistortedNode from another instance, clone the children Nodes.
92	6a06a912	Leszek Koltunski	* <p>
93	cacc63de	Leszek Koltunski	* This is mainly useful for creating many similar sub-trees and rendering then at different places
94			* on the screen with (optionally) different Effects.
95	6a06a912	Leszek Koltunski	*/
96	d6e94c84	Leszek Koltunski	public static final int CLONE_CHILDREN= 0x20;
97	b3618cb5	Leszek Koltunski
98	586b5fa1	Leszek Koltunski	/**
99			* Work around bugs in ARM Mali driver by, instead to a single FBO, rendering to a circular queue
100			* of FBO_QUEUE_SIZE FBOs. (otherwise we sometimes get a 'full pipeline flush' and the end result
101			* might be missing part of the Objects)
102	6672d895	Leszek Koltunski	*
103	12f9e4bb	Leszek Koltunski	* This bug only exists on Mali driver r12.
104	6672d895	Leszek Koltunski	*
105			* https://community.arm.com/graphics/f/discussions/10285/opengl-es-3-1-on-mali-t880-flashes
106	586b5fa1	Leszek Koltunski	*/
107	973e99d7	Leszek Koltunski	static final int FBO_QUEUE_SIZE = 4;
108	586b5fa1	Leszek Koltunski
109	55c14a19	Leszek Koltunski	private static boolean mInitialized=false;
110	6a06a912	Leszek Koltunski
111	bfe45b4a	Leszek Koltunski	//////////////////////////////////////////////////////////////////////////////////////////////
112			/// MAIN PROGRAM ///
113			private static DistortedProgram mMainProgram;
114			private static int mMainTextureH;
115
116			/// NORMAL PROGRAM /////
117			private static DistortedProgram mNormalProgram;
118			private static int mNormalMVPMatrixH;
119
120			/// MAIN OIT PROGRAM ///
121			private static DistortedProgram mMainOITProgram;
122			private static int mMainOITTextureH;
123			private static int mMainOITSizeH;
124			private static int mMainOITNumRecordsH;
125
126			/// BLIT PROGRAM ///
127			private static DistortedProgram mBlitProgram;
128			private static int mBlitTextureH;
129			private static int mBlitDepthH;
130			private static final FloatBuffer mQuadPositions;
131
132	f046b159	Leszek Koltunski	/// FULL PROGRAM ///
133			private static DistortedProgram mFullProgram;
134
135	bfe45b4a	Leszek Koltunski	static
136			{
137			float[] positionData= { -0.5f, -0.5f, -0.5f, 0.5f, 0.5f,-0.5f, 0.5f, 0.5f };
138			mQuadPositions = ByteBuffer.allocateDirect(32).order(ByteOrder.nativeOrder()).asFloatBuffer();
139			mQuadPositions.put(positionData).position(0);
140			}
141
142			/// BLIT DEPTH PROGRAM ///
143			private static DistortedProgram mBlitDepthProgram;
144			private static int mBlitDepthTextureH;
145			private static int mBlitDepthDepthTextureH;
146			private static int mBlitDepthDepthH;
147			private static int mBlitDepthTexCorrH;
148
149			/// OIT SSBO BUFFER ///
150			private static int[] mLinkedListSSBO = new int[1];
151	7602a827	Leszek Koltunski	private static int[] mAtomicCounter = new int[DistortedLibrary.FBO_QUEUE_SIZE];
152	bfe45b4a	Leszek Koltunski	private static int mCurrBuffer;
153
154			static
155			{
156			mLinkedListSSBO[0]= -1;
157			mCurrBuffer = 0;
158
159	7602a827	Leszek Koltunski	for(int i = 0; i< DistortedLibrary.FBO_QUEUE_SIZE; i++) mAtomicCounter[i] = -1;
160	bfe45b4a	Leszek Koltunski	}
161
162			///////////////////////////////////////////////////////////////
163			// meaning: allocate 1.0 screenful of places for transparent
164			// fragments in the SSBO backing up the OIT render method.
165			private static float mBufferSize=1.0f;
166
167			/// OIT CLEAR PROGRAM ///
168			private static DistortedProgram mOITClearProgram;
169			private static int mOITClearDepthH;
170			private static int mOITClearTexCorrH;
171			private static int mOITClearSizeH;
172
173			/// OIT BUILD PROGRAM ///
174			private static DistortedProgram mOITBuildProgram;
175			private static int mOITBuildTextureH;
176			private static int mOITBuildDepthTextureH;
177			private static int mOITBuildDepthH;
178			private static int mOITBuildTexCorrH;
179			private static int mOITBuildSizeH;
180			private static int mOITBuildNumRecordsH;
181
182			/// OIT COLLAPSE PROGRAM ///
183			private static DistortedProgram mOITCollapseProgram;
184			private static int mOITCollapseDepthTextureH;
185			private static int mOITCollapseDepthH;
186			private static int mOITCollapseTexCorrH;
187			private static int mOITCollapseSizeH;
188
189			/// OIT RENDER PROGRAM ///
190			private static DistortedProgram mOITRenderProgram;
191			private static int mOITRenderDepthH;
192			private static int mOITRenderTexCorrH;
193			private static int mOITRenderSizeH;
194
195			/// END PROGRAMS //////
196
197	6a06a912	Leszek Koltunski	///////////////////////////////////////////////////////////////////////////////////////////////////
198	c638c1b0	Leszek Koltunski	// private: hide this from Javadoc
199	6a06a912	Leszek Koltunski
200	7602a827	Leszek Koltunski	private DistortedLibrary()
201	6a06a912	Leszek Koltunski	{
202	8eccf334	Leszek Koltunski
203	6a06a912	Leszek Koltunski	}
204
205	bfe45b4a	Leszek Koltunski	///////////////////////////////////////////////////////////////////////////////////////////////////
206
207	809dcae3	Leszek Koltunski	private static void createPrograms(Resources resources)
208	bfe45b4a	Leszek Koltunski	{
209			// MAIN PROGRAM ////////////////////////////////////
210			final InputStream mainVertStream = resources.openRawResource(R.raw.main_vertex_shader);
211			final InputStream mainFragStream = resources.openRawResource(R.raw.main_fragment_shader);
212
213			int numF = FragmentEffect.getNumEnabled();
214			int numV = VertexEffect.getNumEnabled();
215
216	b7074bc6	Leszek Koltunski	String mainVertHeader= mGLSL_VERSION + ("#define NUM_VERTEX " + ( numV>0 ? getMax(EffectType.VERTEX ) : 0 ) + "\n");
217			String mainFragHeader= mGLSL_VERSION + ("#define NUM_FRAGMENT " + ( numF>0 ? getMax(EffectType.FRAGMENT) : 0 ) + "\n");
218	bfe45b4a	Leszek Koltunski	String enabledEffectV= VertexEffect.getGLSL();
219			String enabledEffectF= FragmentEffect.getGLSL();
220
221			String[] feedback = { "v_Position", "v_endPosition" };
222
223			try
224			{
225			mMainProgram = new DistortedProgram(mainVertStream, mainFragStream, mainVertHeader, mainFragHeader,
226	b7074bc6	Leszek Koltunski	enabledEffectV, enabledEffectF, mGLSL, feedback);
227	bfe45b4a	Leszek Koltunski	}
228			catch(Exception e)
229			{
230			Log.e("EFFECTS", e.getClass().getSimpleName()+" trying to compile MAIN program: "+e.getMessage());
231			throw new RuntimeException(e.getMessage());
232			}
233
234			int mainProgramH = mMainProgram.getProgramHandle();
235			EffectQueue.getUniforms(mainProgramH,0);
236	b7074bc6	Leszek Koltunski	mMainTextureH= GLES30.glGetUniformLocation( mainProgramH, "u_Texture");
237	bfe45b4a	Leszek Koltunski
238			// BLIT PROGRAM ////////////////////////////////////
239			final InputStream blitVertStream = resources.openRawResource(R.raw.blit_vertex_shader);
240			final InputStream blitFragStream = resources.openRawResource(R.raw.blit_fragment_shader);
241
242			try
243			{
244	b7074bc6	Leszek Koltunski	mBlitProgram = new DistortedProgram(blitVertStream,blitFragStream, mGLSL_VERSION, mGLSL_VERSION, mGLSL);
245	bfe45b4a	Leszek Koltunski	}
246			catch(Exception e)
247			{
248			Log.e("EFFECTS", e.getClass().getSimpleName()+" trying to compile BLIT program: "+e.getMessage());
249			throw new RuntimeException(e.getMessage());
250			}
251
252			int blitProgramH = mBlitProgram.getProgramHandle();
253	b7074bc6	Leszek Koltunski	mBlitTextureH = GLES30.glGetUniformLocation( blitProgramH, "u_Texture");
254			mBlitDepthH = GLES30.glGetUniformLocation( blitProgramH, "u_Depth");
255	bfe45b4a	Leszek Koltunski
256			// BLIT DEPTH PROGRAM ////////////////////////////////////
257			final InputStream blitDepthVertStream = resources.openRawResource(R.raw.blit_depth_vertex_shader);
258			final InputStream blitDepthFragStream = resources.openRawResource(R.raw.blit_depth_fragment_shader);
259
260			try
261			{
262	b7074bc6	Leszek Koltunski	mBlitDepthProgram = new DistortedProgram(blitDepthVertStream,blitDepthFragStream, mGLSL_VERSION, mGLSL_VERSION, mGLSL);
263	bfe45b4a	Leszek Koltunski	}
264			catch(Exception e)
265			{
266			Log.e("EFFECTS", e.getClass().getSimpleName()+" trying to compile BLIT DEPTH program: "+e.getMessage());
267			throw new RuntimeException(e.getMessage());
268			}
269
270			int blitDepthProgramH = mBlitDepthProgram.getProgramHandle();
271	b7074bc6	Leszek Koltunski	mBlitDepthTextureH = GLES30.glGetUniformLocation( blitDepthProgramH, "u_Texture");
272			mBlitDepthDepthTextureH = GLES30.glGetUniformLocation( blitDepthProgramH, "u_DepthTexture");
273			mBlitDepthDepthH = GLES30.glGetUniformLocation( blitDepthProgramH, "u_Depth");
274			mBlitDepthTexCorrH = GLES30.glGetUniformLocation( blitDepthProgramH, "u_TexCorr");
275	bfe45b4a	Leszek Koltunski
276			// NORMAL PROGRAM //////////////////////////////////////
277			final InputStream normalVertexStream = resources.openRawResource(R.raw.normal_vertex_shader);
278			final InputStream normalFragmentStream = resources.openRawResource(R.raw.normal_fragment_shader);
279
280			try
281			{
282	b7074bc6	Leszek Koltunski	mNormalProgram = new DistortedProgram(normalVertexStream,normalFragmentStream, mGLSL_VERSION, mGLSL_VERSION, mGLSL);
283	bfe45b4a	Leszek Koltunski	}
284			catch(Exception e)
285			{
286			Log.e("EFFECTS", e.getClass().getSimpleName()+" trying to compile NORMAL program: "+e.getMessage());
287			throw new RuntimeException(e.getMessage());
288			}
289
290			int normalProgramH = mNormalProgram.getProgramHandle();
291	b7074bc6	Leszek Koltunski	mNormalMVPMatrixH = GLES30.glGetUniformLocation( normalProgramH, "u_MVPMatrix");
292	bfe45b4a	Leszek Koltunski	}
293
294	f046b159	Leszek Koltunski	///////////////////////////////////////////////////////////////////////////////////////////////////
295
296			private static void createFullProgram(Resources resources)
297			{
298			final InputStream fullVertStream = resources.openRawResource(R.raw.main_vertex_shader);
299			final InputStream fullFragStream = resources.openRawResource(R.raw.main_fragment_shader);
300
301			int numV = VertexEffect.getAllEnabled();
302
303			String fullVertHeader= mGLSL_VERSION + ("#define NUM_VERTEX " + ( numV>0 ? getMax(EffectType.VERTEX ) : 0 ) + "\n");
304			String fullFragHeader= mGLSL_VERSION + ("#define NUM_FRAGMENT " + 0 + "\n");
305			String enabledEffectV= VertexEffect.getAllGLSL();
306			String enabledEffectF= "{}";
307
308	667884b0	Leszek Koltunski	fullVertHeader += "#define PREAPPLY\n";
309
310	f046b159	Leszek Koltunski	String[] feedback = { "v_Position", "v_endPosition" };
311
312			try
313			{
314			mFullProgram = new DistortedProgram(fullVertStream, fullFragStream, fullVertHeader, fullFragHeader,
315			enabledEffectV, enabledEffectF, mGLSL, feedback);
316			}
317			catch(Exception e)
318			{
319			Log.e("EFFECTS", e.getClass().getSimpleName()+" trying to compile FULL program: "+e.getMessage());
320			throw new RuntimeException(e.getMessage());
321			}
322
323			int fullProgramH = mFullProgram.getProgramHandle();
324			EffectQueue.getUniforms(fullProgramH,3);
325			}
326
327	bfe45b4a	Leszek Koltunski	///////////////////////////////////////////////////////////////////////////////////////////////////
328
329	809dcae3	Leszek Koltunski	private static void createProgramsOIT(Resources resources)
330	bfe45b4a	Leszek Koltunski	{
331			// MAIN OIT PROGRAM ////////////////////////////////
332			final InputStream mainVertStream = resources.openRawResource(R.raw.main_vertex_shader);
333			final InputStream mainFragStream = resources.openRawResource(R.raw.main_fragment_shader);
334
335			int numF = FragmentEffect.getNumEnabled();
336			int numV = VertexEffect.getNumEnabled();
337
338	b7074bc6	Leszek Koltunski	String mainVertHeader= mGLSL_VERSION + ("#define NUM_VERTEX " + ( numV>0 ? getMax(EffectType.VERTEX ) : 0 ) + "\n") + ("#define OIT\n");
339			String mainFragHeader= mGLSL_VERSION + ("#define NUM_FRAGMENT " + ( numF>0 ? getMax(EffectType.FRAGMENT) : 0 ) + "\n") + ("#define OIT\n");
340	bfe45b4a	Leszek Koltunski
341			String enabledEffectV= VertexEffect.getGLSL();
342			String enabledEffectF= FragmentEffect.getGLSL();
343
344			try
345			{
346			mMainOITProgram = new DistortedProgram(mainVertStream, mainFragStream, mainVertHeader, mainFragHeader,
347	b7074bc6	Leszek Koltunski	enabledEffectV, enabledEffectF, mGLSL, null);
348	bfe45b4a	Leszek Koltunski	}
349			catch(Exception e)
350			{
351			Log.e("EFFECTS", e.getClass().getSimpleName()+" trying to compile MAIN OIT program: "+e.getMessage());
352			throw new RuntimeException(e.getMessage());
353			}
354
355			int mainOITProgramH = mMainOITProgram.getProgramHandle();
356			EffectQueue.getUniforms(mainOITProgramH,1);
357	b7074bc6	Leszek Koltunski	mMainOITTextureH = GLES30.glGetUniformLocation( mainOITProgramH, "u_Texture");
358			mMainOITSizeH = GLES30.glGetUniformLocation( mainOITProgramH, "u_Size");
359			mMainOITNumRecordsH = GLES30.glGetUniformLocation( mainOITProgramH, "u_numRecords");
360	bfe45b4a	Leszek Koltunski
361			// OIT CLEAR PROGRAM ////////////////////////////////////
362			final InputStream oitClearVertStream = resources.openRawResource(R.raw.oit_vertex_shader);
363			final InputStream oitClearFragStream = resources.openRawResource(R.raw.oit_clear_fragment_shader);
364
365			try
366			{
367	b7074bc6	Leszek Koltunski	mOITClearProgram = new DistortedProgram(oitClearVertStream,oitClearFragStream, mGLSL_VERSION, mGLSL_VERSION, mGLSL);
368	bfe45b4a	Leszek Koltunski	}
369			catch(Exception e)
370			{
371			Log.e("EFFECTS", e.getClass().getSimpleName()+" trying to compile OIT CLEAR program: "+e.getMessage());
372			throw new RuntimeException(e.getMessage());
373			}
374
375			int oitClearProgramH = mOITClearProgram.getProgramHandle();
376	b7074bc6	Leszek Koltunski	mOITClearDepthH = GLES30.glGetUniformLocation( oitClearProgramH, "u_Depth");
377			mOITClearTexCorrH = GLES30.glGetUniformLocation( oitClearProgramH, "u_TexCorr");
378			mOITClearSizeH = GLES30.glGetUniformLocation( oitClearProgramH, "u_Size");
379	bfe45b4a	Leszek Koltunski
380			// OIT BUILD PROGRAM ////////////////////////////////////
381			final InputStream oitBuildVertStream = resources.openRawResource(R.raw.oit_vertex_shader);
382			final InputStream oitBuildFragStream = resources.openRawResource(R.raw.oit_build_fragment_shader);
383
384			try
385			{
386	b7074bc6	Leszek Koltunski	mOITBuildProgram = new DistortedProgram(oitBuildVertStream,oitBuildFragStream, mGLSL_VERSION, mGLSL_VERSION, mGLSL);
387	bfe45b4a	Leszek Koltunski	}
388			catch(Exception e)
389			{
390			Log.e("EFFECTS", e.getClass().getSimpleName()+" trying to compile OIT BUILD program: "+e.getMessage());
391			throw new RuntimeException(e.getMessage());
392			}
393
394			int oitBuildProgramH = mOITBuildProgram.getProgramHandle();
395	b7074bc6	Leszek Koltunski	mOITBuildTextureH = GLES30.glGetUniformLocation( oitBuildProgramH, "u_Texture");
396			mOITBuildDepthTextureH = GLES30.glGetUniformLocation( oitBuildProgramH, "u_DepthTexture");
397			mOITBuildDepthH = GLES30.glGetUniformLocation( oitBuildProgramH, "u_Depth");
398			mOITBuildTexCorrH = GLES30.glGetUniformLocation( oitBuildProgramH, "u_TexCorr");
399			mOITBuildSizeH = GLES30.glGetUniformLocation( oitBuildProgramH, "u_Size");
400			mOITBuildNumRecordsH = GLES30.glGetUniformLocation( oitBuildProgramH, "u_numRecords");
401	bfe45b4a	Leszek Koltunski
402			// OIT COLLAPSE PROGRAM ///////////////////////////
403			final InputStream oitCollapseVertStream = resources.openRawResource(R.raw.oit_vertex_shader);
404			final InputStream oitCollapseFragStream = resources.openRawResource(R.raw.oit_collapse_fragment_shader);
405
406			try
407			{
408	b7074bc6	Leszek Koltunski	mOITCollapseProgram = new DistortedProgram(oitCollapseVertStream,oitCollapseFragStream, mGLSL_VERSION, mGLSL_VERSION, mGLSL);
409	bfe45b4a	Leszek Koltunski	}
410			catch(Exception e)
411			{
412			Log.e("EFFECTS", e.getClass().getSimpleName()+" trying to compile OIT COLLAPSE program: "+e.getMessage());
413			throw new RuntimeException(e.getMessage());
414			}
415
416			int oitCollapseProgramH = mOITCollapseProgram.getProgramHandle();
417	b7074bc6	Leszek Koltunski	mOITCollapseDepthTextureH = GLES30.glGetUniformLocation( oitCollapseProgramH, "u_DepthTexture");
418			mOITCollapseDepthH = GLES30.glGetUniformLocation( oitCollapseProgramH, "u_Depth");
419			mOITCollapseTexCorrH = GLES30.glGetUniformLocation( oitCollapseProgramH, "u_TexCorr");
420			mOITCollapseSizeH = GLES30.glGetUniformLocation( oitCollapseProgramH, "u_Size");
421	bfe45b4a	Leszek Koltunski
422			// OIT RENDER PROGRAM ///////////////////////////
423			final InputStream oitRenderVertStream = resources.openRawResource(R.raw.oit_vertex_shader);
424			final InputStream oitRenderFragStream = resources.openRawResource(R.raw.oit_render_fragment_shader);
425
426			try
427			{
428	b7074bc6	Leszek Koltunski	mOITRenderProgram = new DistortedProgram(oitRenderVertStream,oitRenderFragStream, mGLSL_VERSION, mGLSL_VERSION, mGLSL);
429	bfe45b4a	Leszek Koltunski	}
430			catch(Exception e)
431			{
432			Log.e("EFFECTS", e.getClass().getSimpleName()+" trying to compile OIT RENDER program: "+e.getMessage());
433			throw new RuntimeException(e.getMessage());
434			}
435
436			int oitRenderProgramH = mOITRenderProgram.getProgramHandle();
437	b7074bc6	Leszek Koltunski	mOITRenderDepthH = GLES30.glGetUniformLocation( oitRenderProgramH, "u_Depth");
438			mOITRenderTexCorrH = GLES30.glGetUniformLocation( oitRenderProgramH, "u_TexCorr");
439			mOITRenderSizeH = GLES30.glGetUniformLocation( oitRenderProgramH, "u_Size");
440	bfe45b4a	Leszek Koltunski	}
441
442			///////////////////////////////////////////////////////////////////////////////////////////////////
443
444			private static void displayNormals(EffectQueue[] queues, MeshBase mesh)
445			{
446			int num = mesh.getNumVertices();
447			int tfo = mesh.getTFO();
448
449	b7074bc6	Leszek Koltunski	GLES30.glBindBufferBase(GLES30.GL_TRANSFORM_FEEDBACK_BUFFER, 0, tfo );
450			GLES30.glBeginTransformFeedback( GLES30.GL_POINTS);
451	7602a827	Leszek Koltunski	InternalRenderState.switchOffDrawing();
452	b7074bc6	Leszek Koltunski	GLES30.glDrawArrays( GLES30.GL_POINTS, 0, num );
453	7602a827	Leszek Koltunski	InternalRenderState.restoreDrawing();
454	b7074bc6	Leszek Koltunski	GLES30.glEndTransformFeedback();
455			GLES30.glBindBufferBase(GLES30.GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0);
456	bfe45b4a	Leszek Koltunski
457	f046b159	Leszek Koltunski	mNormalProgram.useProgram();
458			GLES30.glUniformMatrix4fv(mNormalMVPMatrixH, 1, false, EffectQueue.getMVP(queues) , 0);
459			mesh.bindTransformAttribs(mNormalProgram);
460	b7074bc6	Leszek Koltunski	GLES30.glLineWidth(8.0f);
461			GLES30.glDrawArrays(GLES30.GL_LINES, 0, 2*num);
462	bfe45b4a	Leszek Koltunski	}
463
464	f046b159	Leszek Koltunski	///////////////////////////////////////////////////////////////////////////////////////////////////
465			// execute all VertexEffects and adjust all vertices
466
467			public static void adjustVertices(MeshBase mesh)
468			{
469			if( mFullProgram!=null )
470			{
471			GLES30.glViewport(0, 0, 500, 500 ); // TODO ???
472
473			int num = mesh.getNumVertices();
474			int tfo = mesh.getTFO();
475
476			mFullProgram.useProgram();
477			mesh.bindVertexAttribs(mFullProgram);
478			mesh.computeQueue();
479			mesh.sendQueue();
480
481			GLES30.glBindBufferBase(GLES30.GL_TRANSFORM_FEEDBACK_BUFFER, 0, tfo );
482			GLES30.glBeginTransformFeedback( GLES30.GL_POINTS);
483			InternalRenderState.switchOffDrawing();
484			GLES30.glDrawArrays( GLES30.GL_POINTS, 0, num );
485			InternalRenderState.restoreDrawing();
486			GLES30.glEndTransformFeedback();
487			mesh.copyTransformToVertex();
488	b5be333a	Leszek Koltunski	GLES30.glBindBufferBase(GLES30.GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0);
489	f046b159	Leszek Koltunski	}
490			}
491
492	bfe45b4a	Leszek Koltunski	///////////////////////////////////////////////////////////////////////////////////////////////////
493
494	c90aca24	Leszek Koltunski	static void drawPrivOIT(DistortedEffects effects, MeshBase mesh, InternalOutputSurface surface, long currTime)
495	bfe45b4a	Leszek Koltunski	{
496	c90aca24	Leszek Koltunski	EffectQueue[] queues = effects.getQueues();
497
498	644c21f2	Leszek Koltunski	EffectQueue.compute(queues, currTime);
499	b7074bc6	Leszek Koltunski	GLES30.glViewport(0, 0, surface.mWidth, surface.mHeight );
500	bfe45b4a	Leszek Koltunski
501	7602a827	Leszek Koltunski	DistortedLibrary.mMainOITProgram.useProgram();
502	b7074bc6	Leszek Koltunski	GLES30.glUniform1i(DistortedLibrary.mMainOITTextureH, 0);
503			GLES30.glUniform2ui(DistortedLibrary.mMainOITSizeH, surface.mWidth, surface.mHeight);
504			GLES30.glUniform1ui(DistortedLibrary.mMainOITNumRecordsH, (int)(DistortedLibrary.mBufferSizesurface.mWidthsurface.mHeight) );
505	7602a827	Leszek Koltunski	mesh.bindVertexAttribs(DistortedLibrary.mMainOITProgram);
506	bfe45b4a	Leszek Koltunski
507	809dcae3	Leszek Koltunski	float inflate = mesh.getInflate();
508			float distance = surface.mDistance;
509			float mipmap = surface.mMipmap;
510			float[] projection= surface.mProjectionMatrix;
511	bfe45b4a	Leszek Koltunski
512	23b733db	Leszek Koltunski	EffectQueue.send(queues, distance, mipmap, projection, inflate, mesh, 1 );
513	b7074bc6	Leszek Koltunski	GLES30.glDrawArrays(GLES30.GL_TRIANGLE_STRIP, 0, mesh.getNumVertices() );
514	bfe45b4a	Leszek Koltunski
515			if( mesh.getShowNormals() )
516			{
517	7602a827	Leszek Koltunski	DistortedLibrary.mMainProgram.useProgram();
518	23b733db	Leszek Koltunski	EffectQueue.send(queues, distance, mipmap, projection, inflate, mesh, 0 );
519	bfe45b4a	Leszek Koltunski	displayNormals(queues,mesh);
520			}
521			}
522
523			///////////////////////////////////////////////////////////////////////////////////////////////////
524
525	c90aca24	Leszek Koltunski	static void drawPriv(DistortedEffects effects, MeshBase mesh, InternalOutputSurface surface, long currTime)
526	bfe45b4a	Leszek Koltunski	{
527	f046b159	Leszek Koltunski	if( mMainProgram!=null )
528	f482efa3	Leszek Koltunski	{
529			EffectQueue[] queues = effects.getQueues();
530	bfe45b4a	Leszek Koltunski
531	f482efa3	Leszek Koltunski	EffectQueue.compute(queues, currTime);
532			GLES30.glViewport(0, 0, surface.mWidth, surface.mHeight );
533	46b572b5	Leszek Koltunski
534	f482efa3	Leszek Koltunski	mMainProgram.useProgram();
535			GLES30.glUniform1i(DistortedLibrary.mMainTextureH, 0);
536			mesh.bindVertexAttribs(DistortedLibrary.mMainProgram);
537	809dcae3	Leszek Koltunski
538	f482efa3	Leszek Koltunski	float inflate = mesh.getInflate();
539			float distance = surface.mDistance;
540			float mipmap = surface.mMipmap;
541			float[] projection= surface.mProjectionMatrix;
542	809dcae3	Leszek Koltunski
543	f482efa3	Leszek Koltunski	EffectQueue.send(queues, distance, mipmap, projection, inflate, mesh, 0 );
544			GLES30.glDrawArrays(GLES30.GL_TRIANGLE_STRIP, 0, mesh.getNumVertices() );
545	bfe45b4a	Leszek Koltunski
546	f482efa3	Leszek Koltunski	if( mesh.getShowNormals() ) displayNormals(queues,mesh);
547			}
548	bfe45b4a	Leszek Koltunski	}
549
550			///////////////////////////////////////////////////////////////////////////////////////////////////
551
552	7602a827	Leszek Koltunski	static void blitPriv(InternalOutputSurface surface)
553	bfe45b4a	Leszek Koltunski	{
554	f482efa3	Leszek Koltunski	if( mBlitProgram!=null )
555			{
556			mBlitProgram.useProgram();
557	bfe45b4a	Leszek Koltunski
558	f482efa3	Leszek Koltunski	GLES30.glViewport(0, 0, surface.mWidth, surface.mHeight );
559			GLES30.glUniform1i(mBlitTextureH, 0);
560			GLES30.glUniform1f( mBlitDepthH , 1.0f-surface.mNear);
561			GLES30.glVertexAttribPointer(mBlitProgram.mAttribute[0], 2, GLES30.GL_FLOAT, false, 0, mQuadPositions);
562			GLES30.glDrawArrays(GLES30.GL_TRIANGLE_STRIP, 0, 4);
563			}
564	bfe45b4a	Leszek Koltunski	}
565
566			///////////////////////////////////////////////////////////////////////////////////////////////////
567
568	7602a827	Leszek Koltunski	static void blitDepthPriv(InternalOutputSurface surface, float corrW, float corrH)
569	bfe45b4a	Leszek Koltunski	{
570	f482efa3	Leszek Koltunski	if( mBlitDepthProgram!=null )
571			{
572			mBlitDepthProgram.useProgram();
573
574			GLES30.glViewport(0, 0, surface.mWidth, surface.mHeight );
575			GLES30.glUniform1i(mBlitDepthTextureH, 0);
576			GLES30.glUniform1i(mBlitDepthDepthTextureH, 1);
577			GLES30.glUniform2f(mBlitDepthTexCorrH, corrW, corrH );
578			GLES30.glUniform1f( mBlitDepthDepthH , 1.0f-surface.mNear);
579			GLES30.glVertexAttribPointer(mBlitDepthProgram.mAttribute[0], 2, GLES30.GL_FLOAT, false, 0, mQuadPositions);
580			GLES30.glDrawArrays(GLES30.GL_TRIANGLE_STRIP, 0, 4);
581			}
582	bfe45b4a	Leszek Koltunski	}
583
584			///////////////////////////////////////////////////////////////////////////////////////////////////
585	b7074bc6	Leszek Koltunski	// yes it is safe to be mixing 3.0 and 3.1 like that, senior members of the OpenGL discussions forum assert
586	bfe45b4a	Leszek Koltunski
587			private static int printPreviousBuffer()
588			{
589			int counter = 0;
590
591	b7074bc6	Leszek Koltunski	ByteBuffer atomicBuf = (ByteBuffer)GLES30.glMapBufferRange( GLES31.GL_ATOMIC_COUNTER_BUFFER, 0, 4,
592			GLES30.GL_MAP_READ_BIT);
593	bfe45b4a	Leszek Koltunski	if( atomicBuf!=null )
594			{
595			IntBuffer atomicIntBuf = atomicBuf.order(ByteOrder.nativeOrder()).asIntBuffer();
596			counter = atomicIntBuf.get(0);
597			}
598			else
599			{
600	b7074bc6	Leszek Koltunski	Log.e("effects", "print: failed to map atomic buffer");
601	bfe45b4a	Leszek Koltunski	}
602
603	b7074bc6	Leszek Koltunski	GLES30.glUnmapBuffer(GLES31.GL_ATOMIC_COUNTER_BUFFER);
604	bfe45b4a	Leszek Koltunski
605			return counter;
606			}
607
608			///////////////////////////////////////////////////////////////////////////////////////////////////
609
610			private static void zeroBuffer()
611			{
612	b7074bc6	Leszek Koltunski	ByteBuffer atomicBuf = (ByteBuffer)GLES30.glMapBufferRange( GLES31.GL_ATOMIC_COUNTER_BUFFER, 0, 4,
613			GLES30.GL_MAP_WRITE_BIT\|GLES30.GL_MAP_INVALIDATE_BUFFER_BIT);
614	bfe45b4a	Leszek Koltunski	if( atomicBuf!=null )
615			{
616			IntBuffer atomicIntBuf = atomicBuf.order(ByteOrder.nativeOrder()).asIntBuffer();
617			atomicIntBuf.put(0,0);
618			}
619			else
620			{
621	b7074bc6	Leszek Koltunski	Log.e("effects", "zero: failed to map atomic buffer");
622	bfe45b4a	Leszek Koltunski	}
623
624	b7074bc6	Leszek Koltunski	GLES30.glUnmapBuffer(GLES31.GL_ATOMIC_COUNTER_BUFFER);
625	bfe45b4a	Leszek Koltunski	}
626
627			///////////////////////////////////////////////////////////////////////////////////////////////////
628			// reset atomic counter to 0
629
630			static int zeroOutAtomic()
631			{
632			int counter = 0;
633
634			if( mAtomicCounter[0]<0 )
635			{
636	b7074bc6	Leszek Koltunski	GLES30.glGenBuffers(DistortedLibrary.FBO_QUEUE_SIZE,mAtomicCounter,0);
637	bfe45b4a	Leszek Koltunski
638	7602a827	Leszek Koltunski	for(int i = 0; i< DistortedLibrary.FBO_QUEUE_SIZE; i++)
639	bfe45b4a	Leszek Koltunski	{
640	b7074bc6	Leszek Koltunski	GLES30.glBindBuffer(GLES31.GL_ATOMIC_COUNTER_BUFFER, mAtomicCounter[i]);
641			GLES30.glBufferData(GLES31.GL_ATOMIC_COUNTER_BUFFER, 4, null, GLES30.GL_DYNAMIC_DRAW);
642	bfe45b4a	Leszek Koltunski	zeroBuffer();
643			}
644			}
645
646			// reading the value of the buffer on every frame would slow down rendering by
647	f953bee0	Leszek Koltunski	// dialog_about 3%; doing it only once every 5 frames affects speed by less than 1%.
648	bfe45b4a	Leszek Koltunski	if( mCurrBuffer==0 )
649			{
650	b7074bc6	Leszek Koltunski	GLES30.glBindBufferBase(GLES31.GL_ATOMIC_COUNTER_BUFFER, 0, mAtomicCounter[mCurrBuffer]);
651	bfe45b4a	Leszek Koltunski	counter = printPreviousBuffer();
652			}
653
654	7602a827	Leszek Koltunski	if( ++mCurrBuffer>= DistortedLibrary.FBO_QUEUE_SIZE ) mCurrBuffer = 0;
655	bfe45b4a	Leszek Koltunski
656	b7074bc6	Leszek Koltunski	GLES30.glBindBufferBase(GLES31.GL_ATOMIC_COUNTER_BUFFER, 0, mAtomicCounter[mCurrBuffer]);
657	bfe45b4a	Leszek Koltunski	zeroBuffer();
658
659			return counter;
660			}
661
662			///////////////////////////////////////////////////////////////////////////////////////////////////
663	809dcae3	Leszek Koltunski	// Pass1 of the OIT algorithm. Clear per-pixel head-pointers.
664	bfe45b4a	Leszek Koltunski
665	7602a827	Leszek Koltunski	static void oitClear(InternalOutputSurface surface, int counter)
666	bfe45b4a	Leszek Koltunski	{
667	f482efa3	Leszek Koltunski	if( mOITClearProgram!=null )
668	bfe45b4a	Leszek Koltunski	{
669	f482efa3	Leszek Koltunski	if( mLinkedListSSBO[0]<0 )
670			{
671			GLES30.glGenBuffers(1,mLinkedListSSBO,0);
672	bfe45b4a	Leszek Koltunski
673	f482efa3	Leszek Koltunski	int size = (int)(surface.mWidthsurface.mHeight(3mBufferSize+1)4);
674			GLES30.glBindBuffer(GLES31.GL_SHADER_STORAGE_BUFFER, mLinkedListSSBO[0]);
675			GLES30.glBufferData(GLES31.GL_SHADER_STORAGE_BUFFER, size, null, GLES30.GL_DYNAMIC_READ\|GLES30.GL_DYNAMIC_DRAW);
676			GLES30.glBindBuffer(GLES31.GL_SHADER_STORAGE_BUFFER, 0);
677	bfe45b4a	Leszek Koltunski
678	f482efa3	Leszek Koltunski	GLES30.glBindBufferBase(GLES31.GL_SHADER_STORAGE_BUFFER, 1, mLinkedListSSBO[0]);
679			}
680	bfe45b4a	Leszek Koltunski
681	f482efa3	Leszek Koltunski	// See if we have overflown the SSBO in one of the previous frames.
682			// If yes, assume we need to make the SSBO larger.
683			float overflow = counter/(mBufferSizesurface.mWidthsurface.mHeight);
684	bfe45b4a	Leszek Koltunski
685	f482efa3	Leszek Koltunski	if( overflow>1.0f )
686			{
687			//android.util.Log.e("effects", "previous frame rendered "+counter+
688			// " fragments, but there was only "+(mBufferSizesurface.mWidthsurface.mHeight)+" space");
689
690			mBufferSize *= (int)(overflow+1.0f);
691			int size = (int)(surface.mWidthsurface.mHeight(3mBufferSize+1)4);
692			GLES30.glBindBuffer(GLES31.GL_SHADER_STORAGE_BUFFER, mLinkedListSSBO[0]);
693			GLES30.glBufferData(GLES31.GL_SHADER_STORAGE_BUFFER, size, null, GLES30.GL_DYNAMIC_READ\|GLES30.GL_DYNAMIC_DRAW);
694			GLES30.glBindBuffer(GLES31.GL_SHADER_STORAGE_BUFFER, 0);
695			}
696	bfe45b4a	Leszek Koltunski
697	f482efa3	Leszek Koltunski	mOITClearProgram.useProgram();
698	bfe45b4a	Leszek Koltunski
699	f482efa3	Leszek Koltunski	GLES30.glViewport(0, 0, surface.mWidth, surface.mHeight );
700			GLES30.glUniform2f(mOITClearTexCorrH, 1.0f, 1.0f ); // corrections do not really matter here - only present because of common vertex shader.
701			GLES30.glUniform1f( mOITClearDepthH , 1.0f); // likewise depth
702			GLES30.glUniform2ui(mOITClearSizeH, surface.mWidth, surface.mHeight);
703			GLES30.glVertexAttribPointer(mOITClearProgram.mAttribute[0], 2, GLES30.GL_FLOAT, false, 0, mQuadPositions);
704			GLES30.glDrawArrays(GLES30.GL_TRIANGLE_STRIP, 0, 4);
705			}
706	bfe45b4a	Leszek Koltunski	}
707
708			///////////////////////////////////////////////////////////////////////////////////////////////////
709			// Pass2 of the OIT algorithm - build per-pixel linked lists.
710
711	7602a827	Leszek Koltunski	static void oitBuild(InternalOutputSurface surface, float corrW, float corrH)
712	bfe45b4a	Leszek Koltunski	{
713	f482efa3	Leszek Koltunski	if( mOITBuildProgram!=null )
714			{
715			mOITBuildProgram.useProgram();
716
717			GLES30.glViewport(0, 0, surface.mWidth, surface.mHeight );
718			GLES30.glUniform1i(mOITBuildTextureH, 0);
719			GLES30.glUniform1i(mOITBuildDepthTextureH, 1);
720			GLES30.glUniform2f(mOITBuildTexCorrH, corrW, corrH );
721			GLES30.glUniform2ui(mOITBuildSizeH, surface.mWidth, surface.mHeight);
722			GLES30.glUniform1ui(mOITBuildNumRecordsH, (int)(mBufferSizesurface.mWidthsurface.mHeight) );
723			GLES30.glUniform1f(mOITBuildDepthH , 1.0f-surface.mNear);
724			GLES30.glVertexAttribPointer(mOITBuildProgram.mAttribute[0], 2, GLES30.GL_FLOAT, false, 0, mQuadPositions);
725			GLES30.glDrawArrays(GLES30.GL_TRIANGLE_STRIP, 0, 4);
726			}
727	bfe45b4a	Leszek Koltunski	}
728
729			///////////////////////////////////////////////////////////////////////////////////////////////////
730			// Pass3 of the OIT algorithm. Cut occluded parts of the linked list.
731
732	7602a827	Leszek Koltunski	static void oitCollapse(InternalOutputSurface surface, float corrW, float corrH)
733	bfe45b4a	Leszek Koltunski	{
734	f482efa3	Leszek Koltunski	if( mOITCollapseProgram!=null )
735			{
736			mOITCollapseProgram.useProgram();
737
738			GLES30.glViewport(0, 0, surface.mWidth, surface.mHeight );
739			GLES30.glUniform1i(mOITCollapseDepthTextureH, 1);
740			GLES30.glUniform2f(mOITCollapseTexCorrH, corrW, corrH );
741			GLES30.glUniform2ui(mOITCollapseSizeH, surface.mWidth, surface.mHeight);
742			GLES30.glUniform1f( mOITCollapseDepthH , 1.0f-surface.mNear);
743			GLES30.glVertexAttribPointer(mOITCollapseProgram.mAttribute[0], 2, GLES30.GL_FLOAT, false, 0, mQuadPositions);
744			GLES30.glDrawArrays(GLES30.GL_TRIANGLE_STRIP, 0, 4);
745			}
746	bfe45b4a	Leszek Koltunski	}
747
748			///////////////////////////////////////////////////////////////////////////////////////////////////
749			// Pass4 of the OIT algorithm. Render all the transparent pixels from the per-pixel linked lists.
750
751	7602a827	Leszek Koltunski	static void oitRender(InternalOutputSurface surface, float corrW, float corrH)
752	bfe45b4a	Leszek Koltunski	{
753	f482efa3	Leszek Koltunski	if( mOITRenderProgram!=null )
754			{
755			mOITRenderProgram.useProgram();
756
757			GLES30.glViewport(0, 0, surface.mWidth, surface.mHeight );
758			GLES30.glUniform2f(mOITRenderTexCorrH, corrW, corrH );
759			GLES30.glUniform2ui(mOITRenderSizeH, surface.mWidth, surface.mHeight);
760			GLES30.glUniform1f( mOITRenderDepthH , 1.0f-surface.mNear);
761			GLES30.glVertexAttribPointer(mOITRenderProgram.mAttribute[0], 2, GLES30.GL_FLOAT, false, 0, mQuadPositions);
762			GLES30.glDrawArrays(GLES30.GL_TRIANGLE_STRIP, 0, 4);
763			}
764	bfe45b4a	Leszek Koltunski	}
765
766			///////////////////////////////////////////////////////////////////////////////////////////////////
767
768			static void setSSBOSize(float size)
769			{
770			mBufferSize = size;
771			}
772
773	edea9cf3	Leszek Koltunski	///////////////////////////////////////////////////////////////////////////////////////////////////
774			// ARM Mali driver r12 has problems when we keep swapping many FBOs (fixed in r22)
775	b7074bc6	Leszek Koltunski	// PowerVR GE8100 / GE8300 compiler fails to compile OIT programs.
776	edea9cf3	Leszek Koltunski
777	c43abe6c	Leszek Koltunski	private static void detectBuggyDrivers()
778	edea9cf3	Leszek Koltunski	{
779	b7074bc6	Leszek Koltunski	String vendor = GLES30.glGetString(GLES30.GL_VENDOR);
780			String version = GLES30.glGetString(GLES30.GL_VERSION);
781			String renderer= GLES30.glGetString(GLES30.GL_RENDERER);
782	edea9cf3	Leszek Koltunski
783			/*
784	b7074bc6	Leszek Koltunski	android.util.Log.e("DISTORTED", "GLSL Version "+GLES30.glGetString(GLES31.GL_SHADING_LANGUAGE_VERSION));
785			android.util.Log.e("DISTORTED", "GL Version " +GLES30.glGetString(GLES31.GL_VERSION));
786			android.util.Log.e("DISTORTED", "GL Vendor " +GLES30.glGetString(GLES31.GL_VENDOR));
787			android.util.Log.e("DISTORTED", "GL Renderer " +GLES30.glGetString(GLES31.GL_RENDERER));
788	edea9cf3	Leszek Koltunski	*/
789
790			if( vendor.contains("ARM") )
791			{
792			if( version.contains("r12") )
793			{
794	b7074bc6	Leszek Koltunski	Log.e("DISTORTED", "You are running this on a ARM Mali driver r12.\nThis is a buggy driver, please update to r22. Problems with flashing expected.");
795	edea9cf3	Leszek Koltunski	}
796			}
797			else if( vendor.contains("Imagination") )
798			{
799			if( renderer.contains("GE8") )
800			{
801	b7074bc6	Leszek Koltunski	Log.e("DISTORTED", "You are running this on a PowerVR GE8XXX.\nDue to a buggy compiler OIT rendering will not work");
802	edea9cf3	Leszek Koltunski	}
803			}
804			}
805
806	b7074bc6	Leszek Koltunski	///////////////////////////////////////////////////////////////////////////////////////////////////
807			/**
808			* Return OpenGL ES version supported by the hardware we are running on.
809			* There are only two possibilities: 300 (OpenGL ES 3.0) or 310 (at least OpenGL ES 3.1)
810			*/
811			static int getGLSL()
812			{
813			return mGLSL;
814			}
815
816			///////////////////////////////////////////////////////////////////////////////////////////////////
817			/**
818			* Have we successfully managed to compile the OIT programs?
819			* Some hardware ( Imagination GE8100 / 8300, driver build 1.8@4490469 present in my HTC phone and,
820			* sadly, Amazon Fire Stick 4K ) fails to compile the shaders. See relevant thread in Imagination's
821			* support forum:
822			*
823			* https://forums.imgtec.com/t/ge8100-in-htc-desire-12-android-7-1-1-fragment-shader-fails-to-compile/2708
824			*/
825			public static boolean OITCompilationSuccessful()
826			{
827			return mOITCompilationSuccessful;
828			}
829
830	421c2728	Leszek Koltunski	///////////////////////////////////////////////////////////////////////////////////////////////////
831	310e14fb	leszek	/**
832			* Have we called onCreate yet, ie have we initialized the library?
833	1dfc9074	leszek	* @return <code>true</code> if the library is initialized and ready for action.
834	310e14fb	leszek	*/
835			public static boolean isInitialized()
836	421c2728	Leszek Koltunski	{
837	55c14a19	Leszek Koltunski	return mInitialized;
838	421c2728	Leszek Koltunski	}
839
840	6a06a912	Leszek Koltunski	///////////////////////////////////////////////////////////////////////////////////////////////////
841			/**
842	c43abe6c	Leszek Koltunski	* When OpenGL context gets created, call this method so that the library can initialise its internal data structures.
843	432442f9	Leszek Koltunski	* I.e. best called from GLSurfaceView.onCreate().
844	6a06a912	Leszek Koltunski	* <p>
845	432442f9	Leszek Koltunski	* Needs to be called from a thread holding the OpenGL context.
846	6a06a912	Leszek Koltunski	*
847	015642fb	Leszek Koltunski	* @param context Context of the App using the library - used to open up Resources and read Shader code.
848	6a06a912	Leszek Koltunski	*/
849	edea9cf3	Leszek Koltunski	public static void onCreate(final Context context) throws Exception
850	d6e94c84	Leszek Koltunski	{
851	30beb34f	Leszek Koltunski	final ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
852			final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
853	b7074bc6	Leszek Koltunski
854			int glESversion = configurationInfo.reqGlEsVersion;
855			int major = glESversion >> 16;
856			int minor = glESversion & 0xff;
857
858			if( major< 3 )
859			{
860			mGLSL = 100major + 10minor;
861			throw new VertexCompilationException("at least OpenGL ES 3.0 required, this device supports only "+major+"."+minor);
862			}
863			else
864			{
865			mGLSL = (major==3 && minor==0) ? 300 : 310;
866			}
867
868			android.util.Log.e("DISTORTED", "Using OpenGL ES "+major+"."+minor);
869			mGLSL_VERSION = "#version "+mGLSL+" es\n";
870	edea9cf3	Leszek Koltunski
871			mInitialized = true;
872	b7074bc6	Leszek Koltunski	mOITCompilationSuccessful = false;
873	edea9cf3	Leszek Koltunski
874			detectBuggyDrivers();
875
876	0e924ba5	Leszek Koltunski	EffectMessageSender.startSending();
877
878	d6e94c84	Leszek Koltunski	final Resources resources = context.getResources();
879	c90b9e01	Leszek Koltunski
880	edea9cf3	Leszek Koltunski	Exception exception=null;
881
882			try
883			{
884	bfe45b4a	Leszek Koltunski	createPrograms(resources);
885	edea9cf3	Leszek Koltunski	}
886			catch(Exception ex)
887			{
888			exception = ex;
889			}
890
891	f046b159	Leszek Koltunski	try
892			{
893			createFullProgram(resources);
894			}
895			catch(Exception ex)
896			{
897			exception = ex;
898			}
899
900	b7074bc6	Leszek Koltunski	if( mGLSL>=310)
901	edea9cf3	Leszek Koltunski	{
902	b7074bc6	Leszek Koltunski	try
903			{
904			createProgramsOIT(resources);
905			mOITCompilationSuccessful = true;
906			}
907			catch(Exception ex)
908			{
909			exception = ex;
910			}
911	edea9cf3	Leszek Koltunski	}
912
913	a13dde77	Leszek Koltunski	try
914			{
915	b7074bc6	Leszek Koltunski	EffectQueuePostprocess.createPrograms(resources, mGLSL);
916	a13dde77	Leszek Koltunski	}
917			catch(Exception ex)
918			{
919			exception = ex;
920			}
921
922	edea9cf3	Leszek Koltunski	try
923			{
924	b7074bc6	Leszek Koltunski	PostprocessEffect.createPrograms(mGLSL);
925	edea9cf3	Leszek Koltunski	}
926			catch(Exception ex)
927			{
928			exception = ex;
929			}
930
931			if( exception!=null)
932			{
933			throw exception;
934			}
935	6a06a912	Leszek Koltunski	}
936
937	05ecc6fe	Leszek Koltunski	///////////////////////////////////////////////////////////////////////////////////////////////////
938			/**
939	78e89fb5	Leszek Koltunski	* Call this so that the Library can release the OpenGL related data that needs to be recreated.
940	05ecc6fe	Leszek Koltunski	* Must be called from Activity.onPause().
941			*/
942			public static void onPause()
943			{
944	7602a827	Leszek Koltunski	InternalObject.onPause();
945	bfe45b4a	Leszek Koltunski
946			mLinkedListSSBO[0]= -1;
947
948	7602a827	Leszek Koltunski	for(int i = 0; i< DistortedLibrary.FBO_QUEUE_SIZE; i++) mAtomicCounter[i] = -1;
949	05ecc6fe	Leszek Koltunski	}
950
951	6a06a912	Leszek Koltunski	///////////////////////////////////////////////////////////////////////////////////////////////////
952			/**
953			* Call this so that the Library can release its internal data structures.
954			* Must be called from Activity.onDestroy().
955			*/
956			public static void onDestroy()
957			{
958	7602a827	Leszek Koltunski	InternalObject.onDestroy();
959			InternalNodeData.onDestroy();
960			InternalMaster.onDestroy();
961			InternalOutputSurface.onDestroy();
962	46b572b5	Leszek Koltunski	DistortedEffects.onDestroy();
963	42571056	Leszek Koltunski	EffectQueue.onDestroy();
964	26a4e5f6	leszek	Effect.onDestroy();
965	6a06a912	Leszek Koltunski	EffectMessageSender.stopSending();
966	f8686932	Leszek Koltunski
967	55c14a19	Leszek Koltunski	mInitialized = false;
968	6a06a912	Leszek Koltunski	}
969	bfe45b4a	Leszek Koltunski
970			///////////////////////////////////////////////////////////////////////////////////////////////////
971			/**
972			* Returns the maximum number of effects of a given type that can be simultaneously applied to a
973			* single (InputSurface,MeshBase) combo.
974			*
975			* @param type {@link EffectType}
976			* @return The maximum number of effects of a given type.
977			*/
978			@SuppressWarnings("unused")
979			public static int getMax(EffectType type)
980			{
981			return EffectQueue.getMax(type.ordinal());
982			}
983
984			///////////////////////////////////////////////////////////////////////////////////////////////////
985			/**
986			* Sets the maximum number of effects that can be stored in a single EffectQueue at one time.
987			* This can fail if:
988			* <ul>
989			* <li>the value of 'max' is outside permitted range (0 ≤ max ≤ Byte.MAX_VALUE)
990			* <li>We try to increase the value of 'max' when it is too late to do so already. It needs to be called
991	7602a827	Leszek Koltunski	* before the Vertex Shader gets compiled, i.e. before the call to {@link DistortedLibrary#onCreate}. After this
992	bfe45b4a	Leszek Koltunski	* time only decreasing the value of 'max' is permitted.
993			* <li>Furthermore, this needs to be called before any instances of the DistortedEffects class get created.
994			* </ul>
995			*
996			* @param type {@link EffectType}
997			* @param max new maximum number of simultaneous effects. Has to be a non-negative number not greater
998			* than Byte.MAX_VALUE
999			* @return <code>true</code> if operation was successful, <code>false</code> otherwise.
1000			*/
1001			@SuppressWarnings("unused")
1002			public static boolean setMax(EffectType type, int max)
1003			{
1004			return EffectQueue.setMax(type.ordinal(),max);
1005			}
1006	f8f6d457	leszek	}

Project

General

Profile

Distorted Android

library / src / main / java / org / distorted / library / main / DistortedLibrary.java @ 667884b0