Project

General

Profile

Download (6.81 KB) Statistics
| Branch: | Revision:

library / src / main / res / raw / main_vertex_shader.glsl @ 073e5a7a

1
//////////////////////////////////////////////////////////////////////////////////////////////
2
// Copyright 2016 Leszek Koltunski                                                          //
3
//                                                                                          //
4
// This file is part of Distorted.                                                          //
5
//                                                                                          //
6
// Distorted is free software: you can redistribute it and/or modify                        //
7
// it under the terms of the GNU General Public License as published by                     //
8
// the Free Software Foundation, either version 2 of the License, or                        //
9
// (at your option) any later version.                                                      //
10
//                                                                                          //
11
// Distorted is distributed in the hope that it will be useful,                             //
12
// but WITHOUT ANY WARRANTY; without even the implied warranty of                           //
13
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                            //
14
// GNU General Public License for more details.                                             //
15
//                                                                                          //
16
// You should have received a copy of the GNU General Public License                        // 
17
// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                       //
18
//////////////////////////////////////////////////////////////////////////////////////////////
19

    
20
precision highp float;
21
precision highp int;
22

    
23
in vec3 a_Position;                   // Per-vertex position.
24
in vec3 a_Normal;                     // Per-vertex normal vector.
25
in vec2 a_TexCoordinate;              // Per-vertex texture coordinate.
26
in float a_Component;                 // The component a vertex belongs to.
27
                                      // to a vertex effect. An effect will only be active on a vertex iff (a_Association & vAssociation[effect]) != 0.
28
                                      // ( see VertexEffect.retSection() )
29

    
30
out vec3 v_Position;                  // for Transform Feedback only
31
out vec3 v_endPosition;               // for Transform Feedback only
32
out vec3 v_Normal;                    //
33
out vec2 v_TexCoordinate;             //
34

    
35
uniform mat4 u_MVPMatrix;             // u_MVMatrixP * projection.
36
uniform mat4 u_MVMatrixP;             // the combined model/view matrix. (for points)
37
uniform mat4 u_MVMatrixV;             // the combined model/view matrix. (for vectors)
38
                                      // which need to work differently on points and vectors
39
uniform float u_Inflate;              // how much should we inflate (>0.0) or deflate (<0.0) the mesh.
40
uniform int u_TransformFeedback;      // are we doing the transform feedback now?
41

    
42
#ifdef COMP_CENTERS
43
layout (std140) uniform componentCenter
44
  {
45
  vec4 vComCenter[MAX_COMPON];        // centers of mesh components. 4 floats: (x,y,z,unused)
46
  };
47
#endif
48

    
49
#if NUM_VERTEX>0
50
uniform int vNumEffects;              // total number of vertex effects
51

    
52
layout (std140) uniform vUniformProperties
53
  {
54
  ivec4 vProperties[NUM_VERTEX];      // their properties, 4 ints:
55
                                      // 1: name of the effect
56
                                      // 2: effect's AND association
57
                                      // 3: reserved int (probably another AND assoc in the future)
58
                                      // 4: effect's EQU association
59
  };
60

    
61
layout (std140) uniform vUniformFloats
62
  {
63
  vec4 vUniforms[3*NUM_VERTEX];       // i-th effect is 3 consecutive vec4's: [3*i], [3*i+1], [3*i+2].
64
                                      // The first vec4 is the Interpolated values,
65
                                      // second vec4: first float - cache, next 3: Center, the third -  the Region.
66
  };
67

    
68
layout (std140) uniform componentAssociation
69
  {
70
  ivec4 vComAssoc[MAX_COMPON];        // component 'AND' and 'EQU' Associations
71
  };
72

    
73
//////////////////////////////////////////////////////////////////////////////////////////////
74
// HELPER FUNCTIONS
75
//////////////////////////////////////////////////////////////////////////////////////////////
76
// Return degree of the point as defined by the Region. Currently only supports spherical regions.
77
//
78
// Let 'PS' be the vector from point P (the current vertex) to point S (the center of the effect).
79
// Let region.xyz be the vector from point S to point O (the center point of the region sphere)
80
// Let region.w be the radius of the region sphere.
81
// (This all should work regardless if S is inside or outside of the sphere).
82
//
83
// Then, the degree of a point with respect to a given (spherical!) Region is defined by:
84
//
85
// If P is outside the sphere, return 0.
86
// Otherwise, let X be the point where the halfline SP meets the sphere - then return |PX|/|SX|,
87
// aka the 'degree' of point P.
88
//
89
// We solve the triangle OPX.
90
// We know the lengths |PO|, |OX| and the angle OPX, because cos(OPX) = cos(180-OPS) = -cos(OPS) = -PS*PO/(|PS|*|PO|)
91
// then from the law of cosines PX^2 + PO^2 - 2*PX*PO*cos(OPX) = OX^2 so PX = -a + sqrt(a^2 + OX^2 - PO^2)
92
// where a = PS*PO/|PS| but we are really looking for d = |PX|/(|PX|+|PS|) = 1/(1+ (|PS|/|PX|) ) and
93
// |PX|/|PS| = -b + sqrt(b^2 + (OX^2-PO^2)/PS^2) where b=PS*PO/|PS|^2 which can be computed with only one sqrt.
94

    
95
float degree(in vec4 region, in vec3 PS)
96
  {
97
  float ps_sq = dot(PS,PS);
98

    
99
  if( ps_sq==0.0 ) return 1.0;
100

    
101
  vec3 PO = PS + region.xyz;
102
  float d = region.w*region.w-dot(PO,PO);
103

    
104
  if( d<=0.0 ) return 0.0;
105

    
106
  float b = dot(PS,PO)/ps_sq;
107

    
108
  return 1.0 / (1.0 + 1.0/(sqrt(b*b + d/ps_sq)-b));
109
  }
110

    
111
#endif  // NUM_VERTEX>0
112

    
113
//////////////////////////////////////////////////////////////////////////////////////////////
114

    
115
void main()
116
  {
117
  int component = int(a_Component);
118
  vec3 n = a_Normal;
119
#ifdef COMP_CENTERS
120
  vec3 v = a_Position + u_Inflate*(a_Position - vComCenter[component].xyz);
121
#else
122
  vec3 v = a_Position + u_Inflate*a_Position;
123
#endif
124

    
125
#if NUM_VERTEX>0
126
  int effect=0;
127

    
128
  for(int i=0; i<vNumEffects; i++)
129
    {
130
    if( ((vComAssoc[component].x & vProperties[i].y) != 0) || (vComAssoc[component].y == vProperties[i].w) )
131
      {
132
      // ENABLED EFFECTS WILL BE INSERTED HERE
133

    
134
      }
135
    effect+=3;
136
    }
137
#endif
138

    
139
#ifdef PREAPPLY
140
  v_Position   = v;
141
  v_endPosition= n;
142
#else
143
  if( u_TransformFeedback == 1 )
144
    {
145
    vec4 tmp1 =  u_MVMatrixP * vec4(v,1.0);
146
    vec4 tmp2 =  normalize(u_MVMatrixV * vec4(n,0.0));
147

    
148
    v_Position    = vec3(tmp1);
149
    v_endPosition = vec3(tmp1+100.0*tmp2);
150
    }
151
  else
152
    {
153
    v_Position = v;
154
    }
155
#endif
156

    
157
  v_TexCoordinate = a_TexCoordinate;
158
  v_Normal        = normalize(vec3(u_MVMatrixV*vec4(n,0.0)));
159
  gl_Position     = u_MVPMatrix*vec4(v,1.0);
160
  }                               
(6-6/14)