Revision a2878a67
Added by Leszek Koltunski over 4 years ago
src/main/java/org/distorted/library/effect/VertexEffectQuaternion.java | ||
---|---|---|
78 | 78 |
|
79 | 79 |
+ "n.x = qw*nx + qz*ny - qy*nz - qx*nw; \n" |
80 | 80 |
+ "n.y = qw*ny - qz*nx - qy*nw + qx*nz; \n" |
81 |
+ "n.z = qw*nz - qz*nw + qy*nx - qx*ny; \n" |
|
82 |
|
|
83 |
+ "#ifdef PREAPPLY \n" |
|
84 |
|
|
85 |
+ "float ix = - inf.z*qy + inf.y*qz + inf.x*qw; \n" |
|
86 |
+ "float iy = + inf.z*qx + inf.y*qw - inf.x*qz; \n" |
|
87 |
+ "float iz = + inf.z*qw - inf.y*qx + inf.x*qy; \n" |
|
88 |
+ "float iw = - inf.z*qz - inf.y*qy - inf.x*qx; \n" |
|
89 |
|
|
90 |
+ "inf.x = qw*ix + qz*iy - qy*iz - qx*iw; \n" |
|
91 |
+ "inf.y = qw*iy - qz*ix - qy*iw + qx*iz; \n" |
|
92 |
+ "inf.z = qw*iz - qz*iw + qy*ix - qx*iy; \n" |
|
93 |
|
|
94 |
+ "#endif \n"; |
|
81 |
+ "n.z = qw*nz - qz*nw + qy*nx - qx*ny; \n"; |
|
95 | 82 |
} |
96 | 83 |
|
97 | 84 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
src/main/java/org/distorted/library/effect/VertexEffectRotate.java | ||
---|---|---|
95 | 95 |
|
96 | 96 |
+ "n.x = qw*nx + qz*ny - qy*nz - qx*nw; \n" |
97 | 97 |
+ "n.y = qw*ny - qz*nx - qy*nw + qx*nz; \n" |
98 |
+ "n.z = qw*nz - qz*nw + qy*nx - qx*ny; \n" |
|
99 |
|
|
100 |
+ "#ifdef PREAPPLY \n" |
|
101 |
|
|
102 |
+ "float ix = - inf.z*qy + inf.y*qz + inf.x*qw; \n" |
|
103 |
+ "float iy = + inf.z*qx + inf.y*qw - inf.x*qz; \n" |
|
104 |
+ "float iz = + inf.z*qw - inf.y*qx + inf.x*qy; \n" |
|
105 |
+ "float iw = - inf.z*qz - inf.y*qy - inf.x*qx; \n" |
|
106 |
|
|
107 |
+ "inf.x = qw*ix + qz*iy - qy*iz - qx*iw; \n" |
|
108 |
+ "inf.y = qw*iy - qz*ix - qy*iw + qx*iz; \n" |
|
109 |
+ "inf.z = qw*iz - qz*iw + qy*ix - qx*iy; \n" |
|
110 |
|
|
111 |
+ "#endif \n"; |
|
98 |
+ "n.z = qw*nz - qz*nw + qy*nx - qx*ny; \n"; |
|
112 | 99 |
} |
113 | 100 |
|
114 | 101 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
src/main/java/org/distorted/library/effect/VertexEffectShear.java | ||
---|---|---|
72 | 72 |
+ "float new_nx = n.x - sy*n.y + sy*sz*n.z; \n" |
73 | 73 |
+ "float new_ny =-sx*n.x + tmp*(n.y - sz*n.z); \n" |
74 | 74 |
+ "n.x = new_nx; \n" |
75 |
+ "n.y = new_ny; \n" |
|
76 |
|
|
77 |
+ "#ifdef PREAPPLY \n" |
|
78 |
|
|
79 |
+ "float new_ix = inf.x - sy*inf.y + sy*sz*inf.z; \n" |
|
80 |
+ "float new_iy =-sx*inf.x + tmp*(inf.y - sz*inf.z);\n" |
|
81 |
+ "inf.x = new_ix; \n" |
|
82 |
+ "inf.y = new_iy; \n" |
|
83 |
|
|
84 |
+ "#endif \n"; |
|
75 |
+ "n.y = new_ny; \n"; |
|
85 | 76 |
} |
86 | 77 |
|
87 | 78 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
src/main/java/org/distorted/library/main/DistortedLibrary.java | ||
---|---|---|
347 | 347 |
|
348 | 348 |
fullVertHeader += "#define PREAPPLY\n"; |
349 | 349 |
|
350 |
String[] feedback = { "v_Position", "v_endPosition", "v_Inflate" };
|
|
350 |
String[] feedback = { "v_Position", "v_endPosition" }; |
|
351 | 351 |
|
352 | 352 |
try |
353 | 353 |
{ |
src/main/java/org/distorted/library/mesh/AssociationUniformBlock.java | ||
---|---|---|
1 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
2 |
// Copyright 2020 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.mesh; |
|
21 |
|
|
22 |
import android.opengl.GLES30; |
|
23 |
|
|
24 |
import org.distorted.library.main.InternalBuffer; |
|
25 |
|
|
26 |
import static org.distorted.library.mesh.MeshBase.MAX_EFFECT_COMPONENTS; |
|
27 |
|
|
28 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
29 |
|
|
30 |
class AssociationUniformBlock |
|
31 |
{ |
|
32 |
private static final int ASSOCIATION_SIZE = 16*MAX_EFFECT_COMPONENTS; |
|
33 |
private static final int DEFAULT_ASSOCIATION = 0xffffffff; |
|
34 |
|
|
35 |
private InternalBuffer mUBO; |
|
36 |
private int[] mAssociations; |
|
37 |
|
|
38 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
39 |
|
|
40 |
AssociationUniformBlock() |
|
41 |
{ |
|
42 |
mAssociations= new int[ASSOCIATION_SIZE/4]; |
|
43 |
|
|
44 |
for(int i=0; i<MAX_EFFECT_COMPONENTS; i++) |
|
45 |
{ |
|
46 |
mAssociations[4*i ] = DEFAULT_ASSOCIATION; |
|
47 |
mAssociations[4*i+2] = i; |
|
48 |
} |
|
49 |
|
|
50 |
mUBO = new InternalBuffer(GLES30.GL_UNIFORM_BUFFER, GLES30.GL_STATIC_READ); |
|
51 |
} |
|
52 |
|
|
53 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
54 |
|
|
55 |
AssociationUniformBlock( AssociationUniformBlock original) |
|
56 |
{ |
|
57 |
int size = original.mAssociations.length; |
|
58 |
mAssociations= new int[size]; |
|
59 |
System.arraycopy(original.mAssociations, 0, mAssociations, 0, size); |
|
60 |
|
|
61 |
mUBO = new InternalBuffer(GLES30.GL_UNIFORM_BUFFER, GLES30.GL_STATIC_READ); |
|
62 |
} |
|
63 |
|
|
64 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
65 |
|
|
66 |
boolean matchesAssociation( int comp, int andAssoc, int equAssoc) |
|
67 |
{ |
|
68 |
return (andAssoc & mAssociations[4*comp]) != 0 || (equAssoc == mAssociations[4*comp+2]); |
|
69 |
} |
|
70 |
|
|
71 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
72 |
|
|
73 |
void setEffectAssociationNow(int comp, int andAssociation, int equAssociation) |
|
74 |
{ |
|
75 |
mAssociations[4*comp ] = andAssociation; |
|
76 |
mAssociations[4*comp+2] = equAssociation; |
|
77 |
|
|
78 |
mUBO.invalidate(); |
|
79 |
} |
|
80 |
|
|
81 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
82 |
|
|
83 |
int getIndex() |
|
84 |
{ |
|
85 |
return mUBO.createImmediatelyInt( ASSOCIATION_SIZE, mAssociations); |
|
86 |
} |
|
87 |
|
|
88 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
89 |
|
|
90 |
void copy( int compTo, AssociationUniformBlock assocFrom, int compFrom) |
|
91 |
{ |
|
92 |
mAssociations[4*compTo ] = assocFrom.mAssociations[4*compFrom ]; |
|
93 |
mAssociations[4*compTo+2] = assocFrom.mAssociations[4*compFrom+2]; |
|
94 |
} |
|
95 |
} |
src/main/java/org/distorted/library/mesh/MeshBase.java | ||
---|---|---|
46 | 46 |
*/ |
47 | 47 |
public abstract class MeshBase |
48 | 48 |
{ |
49 |
private static final int UBO_BINDING = 3; |
|
49 |
private static final int ASSOC_UBO_BINDING = 3; |
|
50 |
private static final int CENTER_UBO_BINDING = 4; |
|
50 | 51 |
static final int MAX_EFFECT_COMPONENTS= 100; |
51 | 52 |
|
52 | 53 |
// sizes of attributes of an individual vertex. |
53 | 54 |
private static final int POS_DATA_SIZE= 3; // vertex coordinates: x,y,z |
54 | 55 |
private static final int NOR_DATA_SIZE= 3; // normal vector: x,y,z |
55 |
private static final int INF_DATA_SIZE= 3; // 'inflate' vector: x,y,z |
|
56 | 56 |
private static final int TEX_DATA_SIZE= 2; // texture coordinates: s,t |
57 | 57 |
private static final int COM_DATA_SIZE= 1; // component number, a single float |
58 | 58 |
|
59 | 59 |
static final int POS_ATTRIB = 0; |
60 | 60 |
static final int NOR_ATTRIB = POS_DATA_SIZE; |
61 |
static final int INF_ATTRIB = POS_DATA_SIZE + NOR_DATA_SIZE; |
|
62 | 61 |
static final int TEX_ATTRIB = 0; |
63 | 62 |
static final int COM_ATTRIB = TEX_DATA_SIZE; |
64 | 63 |
|
65 |
static final int VERT1_ATTRIBS= POS_DATA_SIZE + NOR_DATA_SIZE + INF_DATA_SIZE; // number of attributes of a vertex (the part changed by preapply)
|
|
66 |
static final int VERT2_ATTRIBS= TEX_DATA_SIZE + COM_DATA_SIZE; // number of attributes of a vertex (the 'preapply invariant' part)
|
|
67 |
static final int TRAN_ATTRIBS = POS_DATA_SIZE + NOR_DATA_SIZE + INF_DATA_SIZE; // number of attributes of a transform feedback vertex
|
|
64 |
static final int VERT1_ATTRIBS= POS_DATA_SIZE + NOR_DATA_SIZE; // number of attributes of a vertex (the part changed by preapply) |
|
65 |
static final int VERT2_ATTRIBS= TEX_DATA_SIZE + COM_DATA_SIZE; // number of attributes of a vertex (the 'preapply invariant' part) |
|
66 |
static final int TRAN_ATTRIBS = POS_DATA_SIZE + NOR_DATA_SIZE; // number of attributes of a transform feedback vertex |
|
68 | 67 |
|
69 | 68 |
private static final int BYTES_PER_FLOAT = 4; |
70 | 69 |
|
71 | 70 |
private static final int OFFSET_POS = POS_ATTRIB*BYTES_PER_FLOAT; |
72 | 71 |
private static final int OFFSET_NOR = NOR_ATTRIB*BYTES_PER_FLOAT; |
73 |
private static final int OFFSET_INF = INF_ATTRIB*BYTES_PER_FLOAT; |
|
74 | 72 |
private static final int OFFSET_TEX = TEX_ATTRIB*BYTES_PER_FLOAT; |
75 | 73 |
private static final int OFFSET_COM = COM_ATTRIB*BYTES_PER_FLOAT; |
76 | 74 |
|
... | ... | |
81 | 79 |
private boolean mShowNormals; // when rendering this mesh, draw normal vectors? |
82 | 80 |
private InternalBuffer mVBO1, mVBO2, mTFO; // main vertex buffer and transform feedback buffer |
83 | 81 |
private int mNumVertices; |
84 |
private float[] mVertAttribs1; // packed: PosX,PosY,PosZ, NorX,NorY,NorZ, InfX,InfY,InfZ
|
|
82 |
private float[] mVertAttribs1; // packed: PosX,PosY,PosZ, NorX,NorY,NorZ |
|
85 | 83 |
private float[] mVertAttribs2; // packed: TexS,TexT, Component |
86 | 84 |
private float mInflate; |
87 |
private AssociationUniformBlock mAUB; |
|
85 |
private UniformBlockAssociation mUBA; |
|
86 |
private UniformBlockCenter mUBC; |
|
88 | 87 |
|
89 | 88 |
DeferredJobs.JobNode[] mJobNode; |
90 | 89 |
|
91 |
private static final int TEX_COMP_SIZE = 5; // 5 four-bytes entities inside the component
|
|
90 |
private static final int TEX_COMP_SIZE = 5; // 5 four-byte entities inside the component |
|
92 | 91 |
|
93 | 92 |
private static class TexComponent |
94 | 93 |
{ |
... | ... | |
131 | 130 |
|
132 | 131 |
mJobNode = new DeferredJobs.JobNode[1]; |
133 | 132 |
|
134 |
mAUB = new AssociationUniformBlock(); |
|
133 |
mUBA = new UniformBlockAssociation(); |
|
134 |
mUBC = new UniformBlockCenter(); |
|
135 | 135 |
|
136 | 136 |
mVBO1= new InternalBuffer(GLES30.GL_ARRAY_BUFFER , GLES30.GL_STATIC_READ); |
137 | 137 |
mVBO2= new InternalBuffer(GLES30.GL_ARRAY_BUFFER , GLES30.GL_STATIC_READ); |
... | ... | |
147 | 147 |
mInflate = original.mInflate; |
148 | 148 |
mNumVertices= original.mNumVertices; |
149 | 149 |
|
150 |
mAUB = new AssociationUniformBlock(original.mAUB); |
|
150 |
mUBA = new UniformBlockAssociation(original.mUBA); |
|
151 |
mUBC = new UniformBlockCenter(original.mUBC); |
|
151 | 152 |
|
152 | 153 |
if( deep ) |
153 | 154 |
{ |
... | ... | |
254 | 255 |
start = end+1; |
255 | 256 |
end = mEffComponent.get(comp); |
256 | 257 |
|
257 |
if( mAUB.matchesAssociation(comp, andAssoc, equAssoc) )
|
|
258 |
if( mUBA.matchesAssociation(comp, andAssoc, equAssoc) )
|
|
258 | 259 |
{ |
259 | 260 |
applyMatrixToComponent(matrixP, matrixV, start, end); |
260 | 261 |
} |
... | ... | |
299 | 300 |
mVertAttribs1[index+NOR_ATTRIB+1] /= len1; |
300 | 301 |
mVertAttribs1[index+NOR_ATTRIB+2] /= len1; |
301 | 302 |
} |
302 |
|
|
303 |
x = mVertAttribs1[index+INF_ATTRIB ]; |
|
304 |
y = mVertAttribs1[index+INF_ATTRIB+1]; |
|
305 |
z = mVertAttribs1[index+INF_ATTRIB+2]; |
|
306 |
|
|
307 |
mVertAttribs1[index+INF_ATTRIB ] = matrixV[0]*x + matrixV[4]*y + matrixV[ 8]*z; |
|
308 |
mVertAttribs1[index+INF_ATTRIB+1] = matrixV[1]*x + matrixV[5]*y + matrixV[ 9]*z; |
|
309 |
mVertAttribs1[index+INF_ATTRIB+2] = matrixV[2]*x + matrixV[6]*y + matrixV[10]*z; |
|
310 |
|
|
311 |
x = mVertAttribs1[index+INF_ATTRIB ]; |
|
312 |
y = mVertAttribs1[index+INF_ATTRIB+1]; |
|
313 |
z = mVertAttribs1[index+INF_ATTRIB+2]; |
|
314 |
|
|
315 |
float len2 = (float)Math.sqrt(x*x + y*y + z*z); |
|
316 |
|
|
317 |
if( len2>0.0f ) |
|
318 |
{ |
|
319 |
mVertAttribs1[index+INF_ATTRIB ] /= len2; |
|
320 |
mVertAttribs1[index+INF_ATTRIB+1] /= len2; |
|
321 |
mVertAttribs1[index+INF_ATTRIB+2] /= len2; |
|
322 |
} |
|
323 | 303 |
} |
324 | 304 |
} |
325 | 305 |
|
... | ... | |
327 | 307 |
|
328 | 308 |
void setEffectAssociationNow(int component, int andAssociation, int equAssociation) |
329 | 309 |
{ |
330 |
mAUB.setEffectAssociationNow(component, andAssociation, equAssociation); |
|
310 |
mUBA.setEffectAssociationNow(component, andAssociation, equAssociation); |
|
311 |
} |
|
312 |
|
|
313 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
314 |
|
|
315 |
void setEffectCenterNow(int component, float x, float y, float z) |
|
316 |
{ |
|
317 |
mUBC.setEffectCenterNow(component, x, y, z); |
|
331 | 318 |
} |
332 | 319 |
|
333 | 320 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
393 | 380 |
|
394 | 381 |
if( origEffComponents<MAX_EFFECT_COMPONENTS ) |
395 | 382 |
{ |
396 |
mAUB.copy(origEffComponents, mesh.mAUB, j); |
|
383 |
mUBA.copy(origEffComponents, mesh.mUBA, j); |
|
384 |
mUBC.copy(origEffComponents, mesh.mUBC, j); |
|
397 | 385 |
origEffComponents++; |
398 | 386 |
} |
399 | 387 |
} |
... | ... | |
690 | 678 |
*/ |
691 | 679 |
public void send(int programH) |
692 | 680 |
{ |
693 |
int index = mAUB.getIndex(); |
|
694 |
GLES30.glBindBufferBase(GLES30.GL_UNIFORM_BUFFER, UBO_BINDING, index); |
|
695 |
GLES30.glUniformBlockBinding(programH, UBO_BINDING, index); |
|
681 |
int indexA = mUBA.getIndex(); |
|
682 |
GLES30.glBindBufferBase(GLES30.GL_UNIFORM_BUFFER, ASSOC_UBO_BINDING, indexA); |
|
683 |
GLES30.glUniformBlockBinding(programH, ASSOC_UBO_BINDING, indexA); |
|
684 |
|
|
685 |
int indexC = mUBC.getIndex(); |
|
686 |
GLES30.glBindBufferBase(GLES30.GL_UNIFORM_BUFFER, CENTER_UBO_BINDING, indexC); |
|
687 |
GLES30.glUniformBlockBinding(programH, CENTER_UBO_BINDING, indexC); |
|
696 | 688 |
} |
697 | 689 |
|
698 | 690 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
727 | 719 |
GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, index1 ); |
728 | 720 |
GLES30.glVertexAttribPointer(program.mAttribute[0], POS_DATA_SIZE, GLES30.GL_FLOAT, false, VERT1_SIZE, OFFSET_POS); |
729 | 721 |
GLES30.glVertexAttribPointer(program.mAttribute[1], NOR_DATA_SIZE, GLES30.GL_FLOAT, false, VERT1_SIZE, OFFSET_NOR); |
730 |
GLES30.glVertexAttribPointer(program.mAttribute[2], INF_DATA_SIZE, GLES30.GL_FLOAT, false, VERT1_SIZE, OFFSET_INF); |
|
731 | 722 |
GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, index2 ); |
732 |
GLES30.glVertexAttribPointer(program.mAttribute[3], TEX_DATA_SIZE, GLES30.GL_FLOAT, false, VERT2_SIZE, OFFSET_TEX);
|
|
733 |
GLES30.glVertexAttribPointer(program.mAttribute[4], COM_DATA_SIZE, GLES30.GL_FLOAT, false, VERT2_SIZE, OFFSET_COM);
|
|
723 |
GLES30.glVertexAttribPointer(program.mAttribute[2], TEX_DATA_SIZE, GLES30.GL_FLOAT, false, VERT2_SIZE, OFFSET_TEX);
|
|
724 |
GLES30.glVertexAttribPointer(program.mAttribute[3], COM_DATA_SIZE, GLES30.GL_FLOAT, false, VERT2_SIZE, OFFSET_COM);
|
|
734 | 725 |
GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, 0); |
735 | 726 |
} |
736 | 727 |
|
... | ... | |
786 | 777 |
|
787 | 778 |
version = byteBuf.getInt(0); |
788 | 779 |
|
789 |
if( version==1 ) |
|
780 |
if( version==1 || version==2 )
|
|
790 | 781 |
{ |
791 | 782 |
mNumVertices= byteBuf.getInt(4); |
792 | 783 |
numTex = byteBuf.getInt(8); |
... | ... | |
811 | 802 |
mVertAttribs1 = new float[VERT1_ATTRIBS*mNumVertices]; |
812 | 803 |
mVertAttribs2 = new float[VERT2_ATTRIBS*mNumVertices]; |
813 | 804 |
|
814 |
buffer = new byte[BYTES_PER_FLOAT*(size + mNumVertices*(VERT1_ATTRIBS+VERT2_ATTRIBS))]; |
|
805 |
// version 1 had extra 3 floats (the 'inflate' vector) in its vert1 array |
|
806 |
int vert1InFile = version==1 ? VERT1_ATTRIBS+3 : VERT1_ATTRIBS; |
|
807 |
|
|
808 |
buffer = new byte[BYTES_PER_FLOAT*(size + mNumVertices*(vert1InFile+VERT2_ATTRIBS))]; |
|
815 | 809 |
|
816 | 810 |
try |
817 | 811 |
{ |
... | ... | |
827 | 821 |
FloatBuffer floatBuf = byteBuf.asFloatBuffer(); |
828 | 822 |
|
829 | 823 |
floatBuf.get(tmp,0,size); |
830 |
floatBuf.get(mVertAttribs1, 0, VERT1_ATTRIBS*mNumVertices); |
|
824 |
|
|
825 |
switch(version) |
|
826 |
{ |
|
827 |
case 1 : int index = floatBuf.position(); |
|
828 |
|
|
829 |
for(int vert=0; vert<mNumVertices; vert++) |
|
830 |
{ |
|
831 |
mVertAttribs1[VERT1_ATTRIBS*vert+POS_ATTRIB ] = floatBuf.get(index+POS_ATTRIB ); |
|
832 |
mVertAttribs1[VERT1_ATTRIBS*vert+POS_ATTRIB+1] = floatBuf.get(index+POS_ATTRIB+1); |
|
833 |
mVertAttribs1[VERT1_ATTRIBS*vert+POS_ATTRIB+2] = floatBuf.get(index+POS_ATTRIB+2); |
|
834 |
mVertAttribs1[VERT1_ATTRIBS*vert+NOR_ATTRIB ] = floatBuf.get(index+NOR_ATTRIB ); |
|
835 |
mVertAttribs1[VERT1_ATTRIBS*vert+NOR_ATTRIB+1] = floatBuf.get(index+NOR_ATTRIB+1); |
|
836 |
mVertAttribs1[VERT1_ATTRIBS*vert+NOR_ATTRIB+2] = floatBuf.get(index+NOR_ATTRIB+2); |
|
837 |
index+=vert1InFile; |
|
838 |
} |
|
839 |
floatBuf.position(index); |
|
840 |
break; |
|
841 |
case 2 : floatBuf.get(mVertAttribs1, 0, VERT1_ATTRIBS*mNumVertices); |
|
842 |
break; |
|
843 |
default: android.util.Log.e("mesh", "Error: unknown mesh file version "+String.format("0x%08X", version)); |
|
844 |
return 0; |
|
845 |
} |
|
846 |
|
|
831 | 847 |
floatBuf.get(mVertAttribs2, 0, VERT2_ATTRIBS*mNumVertices); |
832 | 848 |
|
833 | 849 |
TexComponent tex; |
... | ... | |
902 | 918 |
|
903 | 919 |
try |
904 | 920 |
{ |
905 |
stream.writeInt(1); // version
|
|
921 |
stream.writeInt(2); // version
|
|
906 | 922 |
stream.writeInt(mNumVertices); |
907 | 923 |
stream.writeInt(numTex); |
908 | 924 |
stream.writeInt(numEff); |
... | ... | |
1152 | 1168 |
* Copy the Mesh. |
1153 | 1169 |
* |
1154 | 1170 |
* @param deep If to be a deep or shallow copy of mVertAttribs1, i.e. the array holding vertices, |
1155 |
* normals and inflates (the rest, in particular the mVertAttribs2 containing texture
|
|
1171 |
* and normals (the rest, in particular the mVertAttribs2 containing texture
|
|
1156 | 1172 |
* coordinates and effect associations, is always deep copied) |
1157 | 1173 |
*/ |
1158 | 1174 |
public abstract MeshBase copy(boolean deep); |
src/main/java/org/distorted/library/mesh/MeshCubes.java | ||
---|---|---|
628 | 628 |
attribs1[VERT1_ATTRIBS*currVert + NOR_ATTRIB+1] = mNormalY[index]; |
629 | 629 |
attribs1[VERT1_ATTRIBS*currVert + NOR_ATTRIB+2] = mNormalZ[index]; |
630 | 630 |
|
631 |
attribs1[VERT1_ATTRIBS*currVert + INF_ATTRIB ] = mInflateX[row][col]/2.0f; |
|
632 |
attribs1[VERT1_ATTRIBS*currVert + INF_ATTRIB+1] = mInflateY[row][col]/2.0f; |
|
633 |
attribs1[VERT1_ATTRIBS*currVert + INF_ATTRIB+2] = vectZ; |
|
634 |
|
|
635 | 631 |
if( vectZ>0 ) |
636 | 632 |
{ |
637 | 633 |
attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB ] = mTexMappingX[FRONT] + x * mTexMappingW[FRONT]; |
... | ... | |
669 | 665 |
attribs1[VERT1_ATTRIBS*currVert + NOR_ATTRIB+1] = 1.0f; |
670 | 666 |
attribs1[VERT1_ATTRIBS*currVert + NOR_ATTRIB+2] = (slice==0 ? R : (slice==mSlices ? -R:0) ); |
671 | 667 |
|
672 |
attribs1[VERT1_ATTRIBS*currVert + INF_ATTRIB ] = mInflateX[row][col]/2.0f; |
|
673 |
attribs1[VERT1_ATTRIBS*currVert + INF_ATTRIB+1] = mInflateY[row][col]/2.0f; |
|
674 |
attribs1[VERT1_ATTRIBS*currVert + INF_ATTRIB+2] = z; |
|
675 |
|
|
676 | 668 |
attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB ] = mTexMappingX[TOP] + x * mTexMappingW[TOP]; |
677 | 669 |
attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB+1] = mTexMappingY[TOP] + (0.5f-z) * mTexMappingH[TOP]; |
678 | 670 |
|
... | ... | |
691 | 683 |
attribs1[VERT1_ATTRIBS*currVert + NOR_ATTRIB+1] =-1.0f; |
692 | 684 |
attribs1[VERT1_ATTRIBS*currVert + NOR_ATTRIB+2] = (slice==0 ? R : (slice==mSlices ? -R:0) ); |
693 | 685 |
|
694 |
attribs1[VERT1_ATTRIBS*currVert + INF_ATTRIB ] = mInflateX[row][col]/2.0f; |
|
695 |
attribs1[VERT1_ATTRIBS*currVert + INF_ATTRIB+1] = mInflateY[row][col]/2.0f; |
|
696 |
attribs1[VERT1_ATTRIBS*currVert + INF_ATTRIB+2] = z; |
|
697 |
|
|
698 | 686 |
attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB ] = mTexMappingX[BOTTOM] + x * mTexMappingW[BOTTOM]; |
699 | 687 |
attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB+1] = mTexMappingY[BOTTOM] + (0.5f-z) * mTexMappingH[BOTTOM]; |
700 | 688 |
|
... | ... | |
713 | 701 |
attribs1[VERT1_ATTRIBS*currVert + NOR_ATTRIB+1] = side==WEST ? 0.0f : (side==NORTH?-R:R); |
714 | 702 |
attribs1[VERT1_ATTRIBS*currVert + NOR_ATTRIB+2] = (slice==0 ? R : (slice==mSlices ? -R:0) ); |
715 | 703 |
|
716 |
attribs1[VERT1_ATTRIBS*currVert + INF_ATTRIB ] = mInflateX[row][col]/2.0f; |
|
717 |
attribs1[VERT1_ATTRIBS*currVert + INF_ATTRIB+1] = mInflateY[row][col]/2.0f; |
|
718 |
attribs1[VERT1_ATTRIBS*currVert + INF_ATTRIB+2] = z; |
|
719 |
|
|
720 | 704 |
attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB ] = mTexMappingX[LEFT] + (0.5f-z) * mTexMappingW[LEFT]; |
721 | 705 |
attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB+1] = mTexMappingY[LEFT] + (1.0f-y) * mTexMappingH[LEFT]; |
722 | 706 |
|
... | ... | |
735 | 719 |
attribs1[VERT1_ATTRIBS*currVert + NOR_ATTRIB+1] = side==EAST ? 0.0f : (side==SOUTH?-R:R); |
736 | 720 |
attribs1[VERT1_ATTRIBS*currVert + NOR_ATTRIB+2] = (slice==0 ? R : (slice==mSlices ? -R:0) ); |
737 | 721 |
|
738 |
attribs1[VERT1_ATTRIBS*currVert + INF_ATTRIB ] = mInflateX[row][col]/2.0f; |
|
739 |
attribs1[VERT1_ATTRIBS*currVert + INF_ATTRIB+1] = mInflateY[row][col]/2.0f; |
|
740 |
attribs1[VERT1_ATTRIBS*currVert + INF_ATTRIB+2] = z; |
|
741 |
|
|
742 | 722 |
attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB ] = mTexMappingX[RIGHT] + (0.5f-z) * mTexMappingW[RIGHT]; |
743 | 723 |
attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB+1] = mTexMappingY[RIGHT] + (1.0f-y) * mTexMappingH[RIGHT]; |
744 | 724 |
|
... | ... | |
760 | 740 |
attribs1[VERT1_ATTRIBS*currVert + NOR_ATTRIB+1] = attribs1[VERT1_ATTRIBS*(currVert-1) + NOR_ATTRIB+1]; |
761 | 741 |
attribs1[VERT1_ATTRIBS*currVert + NOR_ATTRIB+2] = attribs1[VERT1_ATTRIBS*(currVert-1) + NOR_ATTRIB+2]; |
762 | 742 |
|
763 |
attribs1[VERT1_ATTRIBS*currVert + INF_ATTRIB ] = attribs1[VERT1_ATTRIBS*(currVert-1) + INF_ATTRIB ]; |
|
764 |
attribs1[VERT1_ATTRIBS*currVert + INF_ATTRIB+1] = attribs1[VERT1_ATTRIBS*(currVert-1) + INF_ATTRIB+1]; |
|
765 |
attribs1[VERT1_ATTRIBS*currVert + INF_ATTRIB+2] = attribs1[VERT1_ATTRIBS*(currVert-1) + INF_ATTRIB+2]; |
|
766 |
|
|
767 | 743 |
attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB ] = attribs2[VERT2_ATTRIBS*(currVert-1) + TEX_ATTRIB ]; |
768 | 744 |
attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB+1] = attribs2[VERT2_ATTRIBS*(currVert-1) + TEX_ATTRIB+1]; |
769 | 745 |
|
src/main/java/org/distorted/library/mesh/MeshQuad.java | ||
---|---|---|
40 | 40 |
attribs1[VERT1_ATTRIBS*index + NOR_ATTRIB+1] = 0.0f; |
41 | 41 |
attribs1[VERT1_ATTRIBS*index + NOR_ATTRIB+2] = 1.0f; |
42 | 42 |
|
43 |
attribs1[VERT1_ATTRIBS*index + INF_ATTRIB ] = (x-0.5f); |
|
44 |
attribs1[VERT1_ATTRIBS*index + INF_ATTRIB+1] = (0.5f-y); |
|
45 |
attribs1[VERT1_ATTRIBS*index + INF_ATTRIB+2] = 0.01f ; // Inflated surface needs to be slightly in front |
|
46 |
|
|
47 | 43 |
attribs2[VERT2_ATTRIBS*index + TEX_ATTRIB ] = x; |
48 | 44 |
attribs2[VERT2_ATTRIBS*index + TEX_ATTRIB+1] = 1.0f-y; |
49 | 45 |
} |
src/main/java/org/distorted/library/mesh/MeshRectangles.java | ||
---|---|---|
67 | 67 |
attribs1[VERT1_ATTRIBS*vertex + NOR_ATTRIB+1] = 0.0f; |
68 | 68 |
attribs1[VERT1_ATTRIBS*vertex + NOR_ATTRIB+2] = 1.0f; |
69 | 69 |
|
70 |
attribs1[VERT1_ATTRIBS*vertex + INF_ATTRIB ] = x; |
|
71 |
attribs1[VERT1_ATTRIBS*vertex + INF_ATTRIB+1] = -y; |
|
72 |
attribs1[VERT1_ATTRIBS*vertex + INF_ATTRIB+2] = 0.01f; // Inflated surface needs to be slightly in front |
|
73 |
|
|
74 | 70 |
attribs2[VERT2_ATTRIBS*vertex + TEX_ATTRIB ] = x+0.5f; |
75 | 71 |
attribs2[VERT2_ATTRIBS*vertex + TEX_ATTRIB+1] = 0.5f-y; |
76 | 72 |
|
... | ... | |
93 | 89 |
attribs1[VERT1_ATTRIBS*vertex + NOR_ATTRIB+1] = attribs1[VERT1_ATTRIBS*(vertex-1) + NOR_ATTRIB+1]; |
94 | 90 |
attribs1[VERT1_ATTRIBS*vertex + NOR_ATTRIB+2] = attribs1[VERT1_ATTRIBS*(vertex-1) + NOR_ATTRIB+2]; |
95 | 91 |
|
96 |
attribs1[VERT1_ATTRIBS*vertex + INF_ATTRIB ] = attribs1[VERT1_ATTRIBS*(vertex-1) + INF_ATTRIB ]; |
|
97 |
attribs1[VERT1_ATTRIBS*vertex + INF_ATTRIB+1] = attribs1[VERT1_ATTRIBS*(vertex-1) + INF_ATTRIB+1]; |
|
98 |
attribs1[VERT1_ATTRIBS*vertex + INF_ATTRIB+2] = attribs1[VERT1_ATTRIBS*(vertex-1) + INF_ATTRIB+2]; |
|
99 |
|
|
100 | 92 |
attribs2[VERT2_ATTRIBS*vertex + TEX_ATTRIB ] = attribs2[VERT2_ATTRIBS*(vertex-1) + TEX_ATTRIB ]; |
101 | 93 |
attribs2[VERT2_ATTRIBS*vertex + TEX_ATTRIB+1] = attribs2[VERT2_ATTRIBS*(vertex-1) + TEX_ATTRIB+1]; |
102 | 94 |
|
src/main/java/org/distorted/library/mesh/MeshSphere.java | ||
---|---|---|
89 | 89 |
attribs1[VERT1_ATTRIBS*currentVert + NOR_ATTRIB+1] = attribs1[VERT1_ATTRIBS*(currentVert-1) + NOR_ATTRIB+1]; |
90 | 90 |
attribs1[VERT1_ATTRIBS*currentVert + NOR_ATTRIB+2] = attribs1[VERT1_ATTRIBS*(currentVert-1) + NOR_ATTRIB+2]; |
91 | 91 |
|
92 |
attribs1[VERT1_ATTRIBS*currentVert + INF_ATTRIB ] = attribs1[VERT1_ATTRIBS*(currentVert-1) + INF_ATTRIB ]; |
|
93 |
attribs1[VERT1_ATTRIBS*currentVert + INF_ATTRIB+1] = attribs1[VERT1_ATTRIBS*(currentVert-1) + INF_ATTRIB+1]; |
|
94 |
attribs1[VERT1_ATTRIBS*currentVert + INF_ATTRIB+2] = attribs1[VERT1_ATTRIBS*(currentVert-1) + INF_ATTRIB+2]; |
|
95 |
|
|
96 | 92 |
attribs2[VERT2_ATTRIBS*currentVert + TEX_ATTRIB ] = attribs2[VERT2_ATTRIBS*(currentVert-1) + TEX_ATTRIB ]; |
97 | 93 |
attribs2[VERT2_ATTRIBS*currentVert + TEX_ATTRIB+1] = attribs2[VERT2_ATTRIBS*(currentVert-1) + TEX_ATTRIB+1]; |
98 | 94 |
|
... | ... | |
191 | 187 |
attribs1[VERT1_ATTRIBS*currentVert + NOR_ATTRIB ] = 2*x;// the vertex coords, normal vector, and |
192 | 188 |
attribs1[VERT1_ATTRIBS*currentVert + NOR_ATTRIB+1] = 2*y;// inflate vector have identical (x,y,z). |
193 | 189 |
attribs1[VERT1_ATTRIBS*currentVert + NOR_ATTRIB+2] = 2*z;// |
194 |
// TODO: think about some more efficient |
|
195 |
attribs1[VERT1_ATTRIBS*currentVert + INF_ATTRIB ] = x; // representation. |
|
196 |
attribs1[VERT1_ATTRIBS*currentVert + INF_ATTRIB+1] = y; // |
|
197 |
attribs1[VERT1_ATTRIBS*currentVert + INF_ATTRIB+2] = z; // |
|
198 | 190 |
|
199 | 191 |
attribs2[VERT2_ATTRIBS*currentVert + TEX_ATTRIB ] = (float)texX; |
200 | 192 |
attribs2[VERT2_ATTRIBS*currentVert + TEX_ATTRIB+1] = (float)texY; |
src/main/java/org/distorted/library/mesh/MeshTriangles.java | ||
---|---|---|
42 | 42 |
attribs1[VERT1_ATTRIBS*vertex + NOR_ATTRIB+1] = 0.0f; |
43 | 43 |
attribs1[VERT1_ATTRIBS*vertex + NOR_ATTRIB+2] = 1.0f; |
44 | 44 |
|
45 |
attribs1[VERT1_ATTRIBS*vertex + INF_ATTRIB ] = (x-0.5f); |
|
46 |
attribs1[VERT1_ATTRIBS*vertex + INF_ATTRIB+1] = (y-0.33f); |
|
47 |
attribs1[VERT1_ATTRIBS*vertex + INF_ATTRIB+2] = 0.01f ; // Inflated surface needs to be slightly in front |
|
48 |
|
|
49 | 45 |
attribs2[VERT2_ATTRIBS*vertex + TEX_ATTRIB ] = x; |
50 | 46 |
attribs2[VERT2_ATTRIBS*vertex + TEX_ATTRIB+1] = y; |
51 | 47 |
|
src/main/java/org/distorted/library/mesh/UniformBlockAssociation.java | ||
---|---|---|
1 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
2 |
// Copyright 2020 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.mesh; |
|
21 |
|
|
22 |
import android.opengl.GLES30; |
|
23 |
|
|
24 |
import org.distorted.library.main.InternalBuffer; |
|
25 |
|
|
26 |
import static org.distorted.library.mesh.MeshBase.MAX_EFFECT_COMPONENTS; |
|
27 |
|
|
28 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
29 |
|
|
30 |
class UniformBlockAssociation |
|
31 |
{ |
|
32 |
private static final int BLOCK_SIZE = 16*MAX_EFFECT_COMPONENTS; |
|
33 |
private static final int DEFAULT_ASSOCIATION = 0xffffffff; |
|
34 |
|
|
35 |
private InternalBuffer mUBO; |
|
36 |
private int[] mAssociations; |
|
37 |
|
|
38 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
39 |
|
|
40 |
UniformBlockAssociation() |
|
41 |
{ |
|
42 |
mAssociations= new int[BLOCK_SIZE/4]; |
|
43 |
|
|
44 |
for(int i=0; i<MAX_EFFECT_COMPONENTS; i++) |
|
45 |
{ |
|
46 |
mAssociations[4*i ] = DEFAULT_ASSOCIATION; |
|
47 |
mAssociations[4*i+2] = i; |
|
48 |
} |
|
49 |
|
|
50 |
mUBO = new InternalBuffer(GLES30.GL_UNIFORM_BUFFER, GLES30.GL_STATIC_READ); |
|
51 |
} |
|
52 |
|
|
53 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
54 |
|
|
55 |
UniformBlockAssociation(UniformBlockAssociation original) |
|
56 |
{ |
|
57 |
int size = original.mAssociations.length; |
|
58 |
mAssociations= new int[size]; |
|
59 |
System.arraycopy(original.mAssociations, 0, mAssociations, 0, size); |
|
60 |
|
|
61 |
mUBO = new InternalBuffer(GLES30.GL_UNIFORM_BUFFER, GLES30.GL_STATIC_READ); |
|
62 |
} |
|
63 |
|
|
64 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
65 |
|
|
66 |
boolean matchesAssociation( int comp, int andAssoc, int equAssoc) |
|
67 |
{ |
|
68 |
return (andAssoc & mAssociations[4*comp]) != 0 || (equAssoc == mAssociations[4*comp+2]); |
|
69 |
} |
|
70 |
|
|
71 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
72 |
|
|
73 |
void setEffectAssociationNow(int comp, int andAssociation, int equAssociation) |
|
74 |
{ |
|
75 |
mAssociations[4*comp ] = andAssociation; |
|
76 |
mAssociations[4*comp+2] = equAssociation; |
|
77 |
|
|
78 |
mUBO.invalidate(); |
|
79 |
} |
|
80 |
|
|
81 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
82 |
|
|
83 |
int getIndex() |
|
84 |
{ |
|
85 |
return mUBO.createImmediatelyInt( BLOCK_SIZE, mAssociations); |
|
86 |
} |
|
87 |
|
|
88 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
89 |
|
|
90 |
void copy(int compTo, UniformBlockAssociation assocFrom, int compFrom) |
|
91 |
{ |
|
92 |
mAssociations[4*compTo ] = assocFrom.mAssociations[4*compFrom ]; |
|
93 |
mAssociations[4*compTo+2] = assocFrom.mAssociations[4*compFrom+2]; |
|
94 |
} |
|
95 |
} |
src/main/java/org/distorted/library/mesh/UniformBlockCenter.java | ||
---|---|---|
1 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
2 |
// Copyright 2020 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.mesh; |
|
21 |
|
|
22 |
import android.opengl.GLES30; |
|
23 |
|
|
24 |
import org.distorted.library.main.InternalBuffer; |
|
25 |
|
|
26 |
import static org.distorted.library.mesh.MeshBase.MAX_EFFECT_COMPONENTS; |
|
27 |
|
|
28 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
29 |
|
|
30 |
class UniformBlockCenter |
|
31 |
{ |
|
32 |
private static final int BLOCK_SIZE = 16*MAX_EFFECT_COMPONENTS; |
|
33 |
|
|
34 |
private InternalBuffer mUBO; |
|
35 |
private float[] mCenter; |
|
36 |
|
|
37 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
38 |
|
|
39 |
UniformBlockCenter() |
|
40 |
{ |
|
41 |
mCenter= new float[BLOCK_SIZE/4]; |
|
42 |
mUBO = new InternalBuffer(GLES30.GL_UNIFORM_BUFFER, GLES30.GL_STATIC_READ); |
|
43 |
} |
|
44 |
|
|
45 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
46 |
|
|
47 |
UniformBlockCenter(UniformBlockCenter original) |
|
48 |
{ |
|
49 |
int size = original.mCenter.length; |
|
50 |
mCenter= new float[size]; |
|
51 |
System.arraycopy(original.mCenter, 0, mCenter, 0, size); |
|
52 |
|
|
53 |
mUBO = new InternalBuffer(GLES30.GL_UNIFORM_BUFFER, GLES30.GL_STATIC_READ); |
|
54 |
} |
|
55 |
|
|
56 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
57 |
|
|
58 |
void setEffectCenterNow(int comp, float x, float y, float z) |
|
59 |
{ |
|
60 |
mCenter[4*comp ] = x; |
|
61 |
mCenter[4*comp+1] = y; |
|
62 |
mCenter[4*comp+2] = z; |
|
63 |
|
|
64 |
mUBO.invalidate(); |
|
65 |
} |
|
66 |
|
|
67 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
68 |
|
|
69 |
int getIndex() |
|
70 |
{ |
|
71 |
return mUBO.createImmediatelyFloat( BLOCK_SIZE, mCenter); |
|
72 |
} |
|
73 |
|
|
74 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
75 |
|
|
76 |
void copy(int compTo, UniformBlockCenter blockFrom, int compFrom) |
|
77 |
{ |
|
78 |
mCenter[4*compTo ] = blockFrom.mCenter[4*compFrom ]; |
|
79 |
mCenter[4*compTo+1] = blockFrom.mCenter[4*compFrom+1]; |
|
80 |
mCenter[4*compTo+2] = blockFrom.mCenter[4*compFrom+2]; |
|
81 |
} |
|
82 |
} |
src/main/res/raw/main_vertex_shader.glsl | ||
---|---|---|
22 | 22 |
|
23 | 23 |
in vec3 a_Position; // Per-vertex position. |
24 | 24 |
in vec3 a_Normal; // Per-vertex normal vector. |
25 |
in vec3 a_Inflate; // This vector describes the direction this vertex needs to go when we 'inflate' the whole mesh. |
|
26 |
// If the mesh is locally smooth, this is equal to the normal vector. Otherwise (on sharp edges) - no. |
|
27 | 25 |
in vec2 a_TexCoordinate; // Per-vertex texture coordinate. |
28 | 26 |
in float a_Component; // The component a vertex belongs to. |
29 | 27 |
// to a vertex effect. An effect will only be active on a vertex iff (a_Association & vAssociation[effect]) != 0. |
30 | 28 |
// ( see VertexEffect.retSection() ) |
31 | 29 |
|
32 |
out vec3 v_Position; // |
|
30 |
out vec3 v_Position; // for Transform Feedback only
|
|
33 | 31 |
out vec3 v_endPosition; // for Transform Feedback only |
34 |
|
|
35 |
#ifdef PREAPPLY |
|
36 |
out vec3 v_Inflate; // Transform Feedback for preapply effects |
|
37 |
#endif |
|
38 |
|
|
39 | 32 |
out vec3 v_Normal; // |
40 | 33 |
out vec2 v_TexCoordinate; // |
41 | 34 |
|
... | ... | |
46 | 39 |
uniform float u_Inflate; // how much should we inflate (>0.0) or deflate (<0.0) the mesh. |
47 | 40 |
uniform int u_TransformFeedback; // are we doing the transform feedback now? |
48 | 41 |
|
42 |
layout (std140, binding=4) uniform componentCenter |
|
43 |
{ |
|
44 |
vec4 vComCenter[MAX_COMPON]; // centers of earch mesh component. 4 floats: |
|
45 |
// (x,y,z,unused) |
|
46 |
}; |
|
47 |
|
|
49 | 48 |
#if NUM_VERTEX>0 |
50 | 49 |
uniform int vNumEffects; // total number of vertex effects |
51 | 50 |
uniform ivec4 vProperties[NUM_VERTEX];// their properties, 4 ints: |
... | ... | |
58 | 57 |
// The first vec4 is the Interpolated values, |
59 | 58 |
// second vec4: first float - cache, next 3: Center, the third - the Region. |
60 | 59 |
|
61 |
layout (std140, binding=3) uniform meshAssociation
|
|
60 |
layout (std140, binding=3) uniform componentAssociation
|
|
62 | 61 |
{ |
63 | 62 |
ivec4 vComAssoc[MAX_COMPON]; // component Associations, 4 ints: |
64 | 63 |
// 1: component's AND association |
... | ... | |
111 | 110 |
|
112 | 111 |
void main() |
113 | 112 |
{ |
114 |
vec3 v = a_Position + u_Inflate*a_Inflate; |
|
113 |
int component = int(a_Component); |
|
114 |
vec3 v = a_Position + u_Inflate*(a_Position - vComCenter[component].xyz); |
|
115 | 115 |
vec3 n = a_Normal; |
116 | 116 |
|
117 |
#ifdef PREAPPLY |
|
118 |
vec3 inf = a_Inflate; |
|
119 |
#endif |
|
120 |
|
|
121 | 117 |
#if NUM_VERTEX>0 |
122 | 118 |
int effect=0; |
123 |
int component = int(a_Component); |
|
124 | 119 |
|
125 | 120 |
for(int i=0; i<vNumEffects; i++) |
126 | 121 |
{ |
... | ... | |
136 | 131 |
#ifdef PREAPPLY |
137 | 132 |
v_Position = v; |
138 | 133 |
v_endPosition= n; |
139 |
v_Inflate = inf; |
|
140 | 134 |
#else |
141 | 135 |
if( u_TransformFeedback == 1 ) |
142 | 136 |
{ |
Also available in: Unified diff
Remove the 'inflate' vertex attributs from the Mesh and file format, and replace that with a per-component 'inflate centers' (which are as of yet untested)