Revision 46d463a4
Added by Leszek Koltunski almost 4 years ago
src/main/java/org/distorted/library/effectqueue/EffectQueuePostprocess.java | ||
---|---|---|
129 | 129 |
String mainFragHeader= version + "\n"; |
130 | 130 |
|
131 | 131 |
mainVertHeader += "#define MAX_COMPON " + MeshBase.getMaxEffComponents() + "\n"; |
132 |
if( MeshBase.getUseCenters() ) mainVertHeader += "#define COMP_CENTERS\n"; |
|
132 | 133 |
|
133 | 134 |
String enabledEffectV= VertexEffect.getGLSL(); |
134 | 135 |
|
src/main/java/org/distorted/library/main/DistortedLibrary.java | ||
---|---|---|
115 | 115 |
private static int mFBOQueueSize; |
116 | 116 |
private static int mGLSL; |
117 | 117 |
private static String mGLSL_VERSION; |
118 |
private static boolean mOITCompilationAttempted; |
|
119 |
private static boolean mNeedsTransformFeedback; |
|
118 |
private static boolean mOITCompilationAttempted, mNeedsTransformFeedback; |
|
120 | 119 |
|
121 | 120 |
private static int mMaxTextureSize = Integer.MAX_VALUE; |
122 | 121 |
private static int mMaxNumberOfVerUniforms = Integer.MAX_VALUE; |
... | ... | |
248 | 247 |
String mainFragHeader= mGLSL_VERSION + ("#define NUM_FRAGMENT " + ( numF>0 ? getMax(EffectType.FRAGMENT) : 0 ) + "\n"); |
249 | 248 |
|
250 | 249 |
mainVertHeader += "#define MAX_COMPON " + MeshBase.getMaxEffComponents() + "\n"; |
250 |
if( MeshBase.getUseCenters() ) mainVertHeader += "#define COMP_CENTERS\n"; |
|
251 | 251 |
|
252 | 252 |
String enabledEffectV= VertexEffect.getGLSL(); |
253 | 253 |
String enabledEffectF= FragmentEffect.getGLSL(); |
... | ... | |
346 | 346 |
String fullFragHeader= mGLSL_VERSION + ("#define NUM_FRAGMENT " + 0 + "\n"); |
347 | 347 |
|
348 | 348 |
fullVertHeader += "#define MAX_COMPON " + MeshBase.getMaxEffComponents() + "\n"; |
349 |
if( MeshBase.getUseCenters() ) fullVertHeader += "#define COMP_CENTERS\n"; |
|
349 | 350 |
|
350 | 351 |
String enabledEffectV= VertexEffect.getAllGLSL(); |
351 | 352 |
String enabledEffectF= "{}"; |
... | ... | |
385 | 386 |
String mainFragHeader= mGLSL_VERSION + ("#define NUM_FRAGMENT " + ( numF>0 ? getMax(EffectType.FRAGMENT) : 0 ) + "\n") + ("#define OIT\n"); |
386 | 387 |
|
387 | 388 |
mainVertHeader += "#define MAX_COMPON " + MeshBase.getMaxEffComponents() + "\n"; |
389 |
if( MeshBase.getUseCenters() ) mainVertHeader += "#define COMP_CENTERS\n"; |
|
388 | 390 |
|
389 | 391 |
String enabledEffectV= VertexEffect.getGLSL(); |
390 | 392 |
String enabledEffectF= FragmentEffect.getGLSL(); |
src/main/java/org/distorted/library/mesh/DeferredJobs.java | ||
---|---|---|
48 | 48 |
private static final int JOB_TYPE_CENTER = 8; |
49 | 49 |
private static final int JOB_TYPE_ADD_EMPTY_TEX= 9; |
50 | 50 |
|
51 |
private static ArrayList<JobNode> mJobs = new ArrayList<>(); |
|
51 |
private static final ArrayList<JobNode> mJobs = new ArrayList<>();
|
|
52 | 52 |
|
53 | 53 |
////////////////////////////////////////////////////////////////////////// |
54 | 54 |
|
55 | 55 |
private static class Job |
56 | 56 |
{ |
57 |
private int mType; |
|
58 |
private MeshBase mTarget; |
|
59 |
private MeshBase[] mSource; |
|
57 |
private final int mType; |
|
58 |
private final MeshBase mTarget; |
|
59 |
private final MeshBase[] mSource; |
|
60 |
private final MatrixEffect mMatrixEffect; |
|
61 |
private final Static4D[] mMaps; |
|
62 |
private final int mComp, mAndAssoc, mEquAssoc; |
|
63 |
private final float mX,mY,mZ; |
|
64 |
|
|
60 | 65 |
private EffectQueueVertex mVertexEffects; |
61 |
private MatrixEffect mMatrixEffect; |
|
62 |
private Static4D[] mMaps; |
|
63 |
private int mComp, mAndAssoc, mEquAssoc; |
|
64 |
private float mX,mY,mZ; |
|
65 | 66 |
|
66 | 67 |
Job(int type, MeshBase target, MeshBase[] source, VertexEffect vEff, MatrixEffect mEff, |
67 | 68 |
Static4D[] maps, int comp, int and, int equ, float x, float y, float z) |
src/main/java/org/distorted/library/mesh/MeshBase.java | ||
---|---|---|
51 | 51 |
{ |
52 | 52 |
private static final int ASSOC_UBO_BINDING = 3; |
53 | 53 |
private static final int CENTER_UBO_BINDING = 4; |
54 |
public static final int MAX_EFFECT_COMPONENTS= 100;
|
|
54 |
public static final int MAX_EFFECT_COMPONENTS= 98;
|
|
55 | 55 |
|
56 | 56 |
// sizes of attributes of an individual vertex. |
57 | 57 |
private static final int POS_DATA_SIZE= 3; // vertex coordinates: x,y,z |
... | ... | |
79 | 79 |
private static final int VERT1_SIZE = VERT1_ATTRIBS*BYTES_PER_FLOAT; |
80 | 80 |
private static final int VERT2_SIZE = VERT2_ATTRIBS*BYTES_PER_FLOAT; |
81 | 81 |
|
82 |
private static final int[] mCenterBlockIndex = new int[EffectQueue.MAIN_VARIANTS]; |
|
83 |
private static final int[] mAssocBlockIndex = new int[EffectQueue.MAIN_VARIANTS]; |
|
84 |
|
|
85 |
private static final int TEX_COMP_SIZE = 5; // 5 four-byte entities inside the component |
|
86 |
|
|
87 |
private static boolean mUseCenters; |
|
88 |
|
|
82 | 89 |
private boolean mShowNormals; // when rendering this mesh, draw normal vectors? |
83 | 90 |
private InternalBuffer mVBO1, mVBO2, mTFO; // main vertex buffer and transform feedback buffer |
84 | 91 |
private int mNumVertices; |
... | ... | |
86 | 93 |
private float[] mVertAttribs2; // packed: TexS,TexT, Component |
87 | 94 |
private float mInflate; |
88 | 95 |
private final UniformBlockAssociation mUBA; |
89 |
private final UniformBlockCenter mUBC;
|
|
96 |
private UniformBlockCenter mUBC; |
|
90 | 97 |
|
91 | 98 |
DeferredJobs.JobNode[] mJobNode; |
92 | 99 |
|
93 |
private static final int[] mCenterBlockIndex = new int[EffectQueue.MAIN_VARIANTS]; |
|
94 |
private static final int[] mAssocBlockIndex = new int[EffectQueue.MAIN_VARIANTS]; |
|
95 |
|
|
96 |
private static final int TEX_COMP_SIZE = 5; // 5 four-byte entities inside the component |
|
97 |
|
|
98 | 100 |
private static class TexComponent |
99 | 101 |
{ |
100 | 102 |
private int mEndIndex; |
... | ... | |
137 | 139 |
mJobNode = new DeferredJobs.JobNode[1]; |
138 | 140 |
|
139 | 141 |
mUBA = new UniformBlockAssociation(); |
140 |
mUBC = new UniformBlockCenter(); |
|
142 |
|
|
143 |
if( mUseCenters ) mUBC = new UniformBlockCenter(); |
|
141 | 144 |
|
142 | 145 |
mVBO1= new InternalBuffer(GLES30.GL_ARRAY_BUFFER , GLES30.GL_STATIC_READ); |
143 | 146 |
mVBO2= new InternalBuffer(GLES30.GL_ARRAY_BUFFER , GLES30.GL_STATIC_READ); |
... | ... | |
154 | 157 |
mNumVertices= original.mNumVertices; |
155 | 158 |
|
156 | 159 |
mUBA = new UniformBlockAssociation(original.mUBA); |
157 |
mUBC = new UniformBlockCenter(original.mUBC); |
|
160 |
|
|
161 |
if( mUseCenters ) mUBC = new UniformBlockCenter(original.mUBC); |
|
158 | 162 |
|
159 | 163 |
if( deep ) |
160 | 164 |
{ |
... | ... | |
326 | 330 |
|
327 | 331 |
void setComponentCenterNow(int component, float x, float y, float z) |
328 | 332 |
{ |
329 |
mUBC.setEffectCenterNow(component, x, y, z); |
|
333 |
if( mUBC!=null ) |
|
334 |
{ |
|
335 |
mUBC.setEffectCenterNow(component, x, y, z); |
|
336 |
} |
|
330 | 337 |
} |
331 | 338 |
|
332 | 339 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
393 | 400 |
if( origEffComponents<MAX_EFFECT_COMPONENTS ) |
394 | 401 |
{ |
395 | 402 |
mUBA.copy(origEffComponents, mesh.mUBA, j); |
396 |
mUBC.copy(origEffComponents, mesh.mUBC, j); |
|
403 |
if( mUseCenters ) mUBC.copy(origEffComponents, mesh.mUBC, j);
|
|
397 | 404 |
origEffComponents++; |
398 | 405 |
} |
399 | 406 |
} |
... | ... | |
538 | 545 |
mVBO2.invalidate(); |
539 | 546 |
} |
540 | 547 |
|
548 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
549 |
/** |
|
550 |
* Are we going to need per-component centers (needed for correct postprocessing of concave meshes) |
|
551 |
* Switching this on allocates 16*MAX_EFFECT_COMPONENTS bytes for uniforms in the vertex shader. |
|
552 |
*/ |
|
553 |
public static void setUseCenters() |
|
554 |
{ |
|
555 |
mUseCenters = true; |
|
556 |
} |
|
557 |
|
|
558 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
559 |
/** |
|
560 |
* Are we using per-component centers? |
|
561 |
*/ |
|
562 |
public static boolean getUseCenters() |
|
563 |
{ |
|
564 |
return mUseCenters; |
|
565 |
} |
|
566 |
|
|
541 | 567 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
542 | 568 |
|
543 | 569 |
public static int getMaxEffComponents() |
... | ... | |
704 | 730 |
GLES30.glBindBufferBase(GLES30.GL_UNIFORM_BUFFER, ASSOC_UBO_BINDING, indexA); |
705 | 731 |
GLES30.glUniformBlockBinding(programH, mAssocBlockIndex[variant], ASSOC_UBO_BINDING); |
706 | 732 |
|
707 |
int indexC = mUBC.getIndex(); |
|
708 |
GLES30.glBindBufferBase(GLES30.GL_UNIFORM_BUFFER, CENTER_UBO_BINDING, indexC); |
|
709 |
GLES30.glUniformBlockBinding(programH, mCenterBlockIndex[variant], CENTER_UBO_BINDING); |
|
733 |
if( mUseCenters ) |
|
734 |
{ |
|
735 |
int indexC = mUBC.getIndex(); |
|
736 |
GLES30.glBindBufferBase(GLES30.GL_UNIFORM_BUFFER, CENTER_UBO_BINDING, indexC); |
|
737 |
GLES30.glUniformBlockBinding(programH, mCenterBlockIndex[variant], CENTER_UBO_BINDING); |
|
738 |
} |
|
710 | 739 |
} |
711 | 740 |
|
712 | 741 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
902 | 931 |
case 2 : float[] centers = new float[3*numEff]; |
903 | 932 |
floatBuf.get(centers,0,3*numEff); |
904 | 933 |
|
905 |
for(int eff=0; eff<numEff; eff++)
|
|
934 |
if( mUseCenters )
|
|
906 | 935 |
{ |
907 |
mUBC.setEffectCenterNow(eff, centers[3*eff], centers[3*eff+1], centers[3*eff+2]); |
|
936 |
for(int eff=0; eff<numEff; eff++) |
|
937 |
{ |
|
938 |
mUBC.setEffectCenterNow(eff, centers[3*eff], centers[3*eff+1], centers[3*eff+2]); |
|
939 |
} |
|
908 | 940 |
} |
909 | 941 |
|
910 | 942 |
floatBuf.get(mVertAttribs1, 0, VERT1_ATTRIBS*mNumVertices); |
... | ... | |
983 | 1015 |
stream.writeFloat((float)mEffComponent.get(i)); |
984 | 1016 |
} |
985 | 1017 |
|
986 |
float[] centers = mUBC.getBackingArray();
|
|
1018 |
float[] centers = mUseCenters ? mUBC.getBackingArray() : new float[4*numEff];
|
|
987 | 1019 |
|
988 | 1020 |
for(int i=0; i<numEff; i++) |
989 | 1021 |
{ |
... | ... | |
1075 | 1107 |
mVBO2.markForDeletion(); |
1076 | 1108 |
mTFO.markForDeletion(); |
1077 | 1109 |
mUBA.markForDeletion(); |
1078 |
mUBC.markForDeletion(); |
|
1110 |
|
|
1111 |
if( mUBC!=null ) |
|
1112 |
{ |
|
1113 |
mUBC.markForDeletion(); |
|
1114 |
} |
|
1079 | 1115 |
} |
1080 | 1116 |
|
1081 | 1117 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
src/main/res/raw/main_vertex_shader.glsl | ||
---|---|---|
39 | 39 |
uniform float u_Inflate; // how much should we inflate (>0.0) or deflate (<0.0) the mesh. |
40 | 40 |
uniform int u_TransformFeedback; // are we doing the transform feedback now? |
41 | 41 |
|
42 |
#ifdef COMP_CENTERS |
|
42 | 43 |
layout (std140) uniform componentCenter |
43 | 44 |
{ |
44 | 45 |
vec4 vComCenter[MAX_COMPON]; // centers of mesh components. 4 floats: (x,y,z,unused) |
45 | 46 |
}; |
47 |
#endif |
|
46 | 48 |
|
47 | 49 |
#if NUM_VERTEX>0 |
48 | 50 |
uniform int vNumEffects; // total number of vertex effects |
... | ... | |
117 | 119 |
void main() |
118 | 120 |
{ |
119 | 121 |
int component = int(a_Component); |
120 |
vec3 v = a_Position + u_Inflate*(a_Position - vComCenter[component].xyz); |
|
121 | 122 |
vec3 n = a_Normal; |
123 |
#ifdef COMP_CENTERS |
|
124 |
vec3 v = a_Position + u_Inflate*(a_Position - vComCenter[component].xyz); |
|
125 |
#else |
|
126 |
vec3 v = a_Position + u_Inflate*a_Position; |
|
127 |
#endif |
|
122 | 128 |
|
123 | 129 |
#if NUM_VERTEX>0 |
124 | 130 |
int effect=0; |
Also available in: Unified diff
Make per-component centers optional, controlled by API MeshBase.setUseCenters()