Revision 03cb451d
Added by Leszek Koltunski almost 8 years ago
src/main/java/org/distorted/library/DistortedEffects.java | ||
---|---|---|
55 | 55 |
private static final int TEX_DATA_SIZE = 2; // Main Program: size of the texture coordinate data in elements. |
56 | 56 |
|
57 | 57 |
private static DistortedProgram mProgram; |
58 |
private static boolean[] mEffectEnabled = new boolean[EffectNames.size()]; |
|
59 |
|
|
60 |
static |
|
61 |
{ |
|
62 |
int len = EffectNames.size(); |
|
63 |
|
|
64 |
for(int i=0; i<len; i++) |
|
65 |
{ |
|
66 |
mEffectEnabled[i] = false; |
|
67 |
} |
|
68 |
} |
|
58 | 69 |
|
59 | 70 |
/// DEBUG ONLY ///// |
60 | 71 |
private static DistortedProgram mDebugProgram; |
... | ... | |
91 | 102 |
static void createProgram(Resources resources) |
92 | 103 |
throws FragmentCompilationException,VertexCompilationException,VertexUniformsException,FragmentUniformsException,LinkingException |
93 | 104 |
{ |
94 |
final InputStream mainVertexStream = resources.openRawResource(R.raw.main_vertex_shader); |
|
95 |
final InputStream mainFragmentStream = resources.openRawResource(R.raw.main_fragment_shader); |
|
105 |
final InputStream mainVertStream = resources.openRawResource(R.raw.main_vertex_shader); |
|
106 |
final InputStream mainFragStream = resources.openRawResource(R.raw.main_fragment_shader); |
|
107 |
|
|
108 |
String mainVertHeader= ("#version 100\n"); |
|
109 |
String mainFragHeader= ("#version 100\n"); |
|
96 | 110 |
|
97 |
String mainVertexHeader= ("#version 100\n#define NUM_VERTEX " + getMaxVertex()+"\n"); |
|
111 |
EffectNames name; |
|
112 |
EffectTypes type; |
|
113 |
boolean foundF = false; |
|
114 |
boolean foundV = false; |
|
98 | 115 |
|
99 |
for(EffectNames name: EffectNames.values() )
|
|
116 |
for(int i=0; i<mEffectEnabled.length; i++)
|
|
100 | 117 |
{ |
101 |
if( name.getType()== EffectTypes.VERTEX) |
|
102 |
mainVertexHeader += ("#define "+name.name()+" "+name.ordinal()+"\n"); |
|
118 |
if( mEffectEnabled[i] ) |
|
119 |
{ |
|
120 |
name = EffectNames.getName(i); |
|
121 |
type = EffectNames.getType(i); |
|
122 |
|
|
123 |
if( type == EffectTypes.VERTEX ) |
|
124 |
{ |
|
125 |
mainVertHeader += ("#define "+name.name()+" "+name.ordinal()+"\n"); |
|
126 |
foundV = true; |
|
127 |
} |
|
128 |
else if( type == EffectTypes.FRAGMENT ) |
|
129 |
{ |
|
130 |
mainFragHeader += ("#define "+name.name()+" "+name.ordinal()+"\n"); |
|
131 |
foundF = true; |
|
132 |
} |
|
133 |
} |
|
103 | 134 |
} |
104 | 135 |
|
105 |
String mainFragmentHeader= ("#version 100\n#define NUM_FRAGMENT " + getMaxFragment()+"\n"); |
|
136 |
mainVertHeader += ("#define NUM_VERTEX " + ( foundV ? getMaxVertex() : 0 ) + "\n"); |
|
137 |
mainFragHeader += ("#define NUM_FRAGMENT " + ( foundF ? getMaxFragment() : 0 ) + "\n"); |
|
106 | 138 |
|
107 |
for(EffectNames name: EffectNames.values() ) |
|
108 |
{ |
|
109 |
if( name.getType()== EffectTypes.FRAGMENT) |
|
110 |
mainFragmentHeader += ("#define "+name.name()+" "+name.ordinal()+"\n"); |
|
111 |
} |
|
139 |
//android.util.Log.e("Effects", "vertHeader= "+mainVertHeader); |
|
140 |
//android.util.Log.e("Effects", "fragHeader= "+mainFragHeader); |
|
112 | 141 |
|
113 |
mProgram = new DistortedProgram(mainVertexStream,mainFragmentStream, mainVertexHeader, mainFragmentHeader);
|
|
142 |
mProgram = new DistortedProgram(mainVertStream,mainFragStream, mainVertHeader, mainFragHeader);
|
|
114 | 143 |
|
115 | 144 |
int mainProgramH = mProgram.getProgramHandle(); |
116 | 145 |
EffectQueueFragment.getUniforms(mainProgramH); |
... | ... | |
332 | 361 |
static void onDestroy() |
333 | 362 |
{ |
334 | 363 |
mNextID = 0; |
364 |
|
|
365 |
int len = EffectNames.size(); |
|
366 |
|
|
367 |
for(int i=0; i<len; i++) |
|
368 |
{ |
|
369 |
mEffectEnabled[i] = false; |
|
370 |
} |
|
335 | 371 |
} |
336 | 372 |
|
337 | 373 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
498 | 534 |
return false; |
499 | 535 |
} |
500 | 536 |
|
537 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
538 |
/** |
|
539 |
* Enables a given Effect. |
|
540 |
* <p> |
|
541 |
* By default, all effects are disabled. One has to explicitly enable each effect one intends to use. |
|
542 |
* This needs to be called BEFORE shaders get compiled, i.e. before the call to Distorted.onCreate(). |
|
543 |
* The point: by enabling only the effects we need, we can optimize the shaders. |
|
544 |
* |
|
545 |
* @param name Name of the Effect to enable. |
|
546 |
*/ |
|
547 |
public static void enableEffect(EffectNames name) |
|
548 |
{ |
|
549 |
mEffectEnabled[name.ordinal()] = true; |
|
550 |
} |
|
551 |
|
|
501 | 552 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
502 | 553 |
/** |
503 | 554 |
* Returns the maximum number of Matrix effects. |
src/main/java/org/distorted/library/EffectNames.java | ||
---|---|---|
372 | 372 |
return false; |
373 | 373 |
} |
374 | 374 |
|
375 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
376 |
|
|
377 |
static int size() |
|
378 |
{ |
|
379 |
return values().length; |
|
380 |
} |
|
381 |
|
|
375 | 382 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
376 | 383 |
// PUBLIC API |
377 | 384 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
src/main/res/raw/main_fragment_shader.glsl | ||
---|---|---|
85 | 85 |
} |
86 | 86 |
#endif |
87 | 87 |
|
88 |
#endif |
|
88 |
#endif // NUM_FRAGMENT>0
|
|
89 | 89 |
|
90 | 90 |
////////////////////////////////////////////////////////////////////////////////////////////// |
91 | 91 |
|
... | ... | |
96 | 96 |
#if NUM_FRAGMENT>0 |
97 | 97 |
vec2 diff; |
98 | 98 |
float pointDegree; |
99 |
|
|
99 |
int j=0; |
|
100 |
|
|
100 | 101 |
for(int i=0; i<fNumEffects; i++) |
101 | 102 |
{ |
102 |
diff = (v_Position.xy - fUniforms[2*i+1].xy)/fUniforms[2*i+1].zw;
|
|
103 |
diff = (v_Position.xy - fUniforms[j+1].xy)/fUniforms[j+1].zw;
|
|
103 | 104 |
pointDegree = max(0.0,1.0-dot(diff,diff)); |
104 | 105 |
|
105 | 106 |
#ifdef CHROMA |
106 |
if( fType[i]==CHROMA ) chroma (sign(pointDegree),2*i,pixel); else
|
|
107 |
if( fType[i]==CHROMA ) chroma (sign(pointDegree),j,pixel); else
|
|
107 | 108 |
#endif |
108 | 109 |
#ifdef SMOOTH_CHROMA |
109 |
if( fType[i]==SMOOTH_CHROMA ) chroma ( pointDegree ,2*i,pixel); else
|
|
110 |
if( fType[i]==SMOOTH_CHROMA ) chroma ( pointDegree ,j,pixel); else
|
|
110 | 111 |
#endif |
111 | 112 |
#ifdef ALPHA |
112 |
if( fType[i]==ALPHA ) alpha (sign(pointDegree),2*i,pixel); else
|
|
113 |
if( fType[i]==ALPHA ) alpha (sign(pointDegree),j,pixel); else
|
|
113 | 114 |
#endif |
114 | 115 |
#ifdef SMOOTH_ALPHA |
115 |
if( fType[i]==SMOOTH_ALPHA ) alpha ( pointDegree ,2*i,pixel); else
|
|
116 |
if( fType[i]==SMOOTH_ALPHA ) alpha ( pointDegree ,j,pixel); else
|
|
116 | 117 |
#endif |
117 | 118 |
#ifdef BRIGHTNESS |
118 |
if( fType[i]==BRIGHTNESS ) brightness(sign(pointDegree),2*i,pixel); else
|
|
119 |
if( fType[i]==BRIGHTNESS ) brightness(sign(pointDegree),j,pixel); else
|
|
119 | 120 |
#endif |
120 | 121 |
#ifdef SMOOTH_BRIGHTNESS |
121 |
if( fType[i]==SMOOTH_BRIGHTNESS ) brightness( pointDegree ,2*i,pixel); else
|
|
122 |
if( fType[i]==SMOOTH_BRIGHTNESS ) brightness( pointDegree ,j,pixel); else
|
|
122 | 123 |
#endif |
123 | 124 |
#ifdef CONTRAST |
124 |
if( fType[i]==CONTRAST ) contrast (sign(pointDegree),2*i,pixel); else
|
|
125 |
if( fType[i]==CONTRAST ) contrast (sign(pointDegree),j,pixel); else
|
|
125 | 126 |
#endif |
126 | 127 |
#ifdef SMOOTH_CONTRAST |
127 |
if( fType[i]==SMOOTH_CONTRAST ) contrast ( pointDegree ,2*i,pixel); else
|
|
128 |
if( fType[i]==SMOOTH_CONTRAST ) contrast ( pointDegree ,j,pixel); else
|
|
128 | 129 |
#endif |
129 | 130 |
#ifdef SATURATION |
130 |
if( fType[i]==SATURATION ) saturation(sign(pointDegree),2*i,pixel); else
|
|
131 |
if( fType[i]==SATURATION ) saturation(sign(pointDegree),j,pixel); else
|
|
131 | 132 |
#endif |
132 | 133 |
#ifdef SMOOTH_SATURATION |
133 |
if( fType[i]==SMOOTH_SATURATION ) saturation( pointDegree ,2*i,pixel); else
|
|
134 |
if( fType[i]==SMOOTH_SATURATION ) saturation( pointDegree ,j,pixel); else
|
|
134 | 135 |
#endif |
135 | 136 |
{} |
137 |
|
|
138 |
j+=2; |
|
136 | 139 |
} |
137 | 140 |
#endif |
138 | 141 |
|
Also available in: Unified diff
Speed up shaders (both compilation and execution) by explicitly enabling only the needed effects.