Skip to content

Commit 01ccaf1

Browse files
gohaigohai
committed
Increase the maximum number of lights to 4 for Mesa vc4
Testing on the latest Raspbian release shows that the open-source Mesa driver can handle 4 lights on all P3D examples without tripping up during register allocation. Still an issue with 8 lights, so leave it at 4 for now, and re-test with 6 next time around.
1 parent 32a8fbf commit 01ccaf1

5 files changed

Lines changed: 324 additions & 6 deletions

File tree

‎core/src/processing/opengl/PGraphicsOpenGL.java‎

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -6895,8 +6895,12 @@ protected void getGLParameters() {
68956895

68966896
// overwrite the default shaders with vendor specific versions
68976897
// if needed
6898-
if (OPENGL_RENDERER.equals("VideoCore IV HW") || // Broadcom's binary driver for Raspberry Pi
6899-
OPENGL_RENDERER.contains("VC4")) { // Mesa driver for same hardware
6898+
if (OPENGL_RENDERER.equals("VideoCore IV HW")) { // Broadcom's binary driver for Raspberry Pi
6899+
defLightShaderVertURL =
6900+
PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/LightVert-brcm.glsl");
6901+
defTexlightShaderVertURL =
6902+
PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/TexLightVert-brcm.glsl");
6903+
} else if (OPENGL_RENDERER.contains("VC4")) { // Mesa driver for same hardware
69006904
defLightShaderVertURL =
69016905
PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/LightVert-vc4.glsl");
69026906
defTexlightShaderVertURL =

‎core/src/processing/opengl/shaders/LightVert-brcm.glsl‎

Lines changed: 154 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,154 @@
1+
/*
2+
Part of the Processing project - http://processing.org
3+
4+
Copyright (c) 2012-15 The Processing Foundation
5+
Copyright (c) 2004-12 Ben Fry and Casey Reas
6+
Copyright (c) 2001-04 Massachusetts Institute of Technology
7+
8+
This library is free software; you can redistribute it and/or
9+
modify it under the terms of the GNU Lesser General Public
10+
License as published by the Free Software Foundation, version 2.1.
11+
12+
This library is distributed in the hope that it will be useful,
13+
but WITHOUT ANY WARRANTY; without even the implied warranty of
14+
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15+
Lesser General Public License for more details.
16+
17+
You should have received a copy of the GNU Lesser General
18+
Public License along with this library; if not, write to the
19+
Free Software Foundation, Inc., 59 Temple Place, Suite 330,
20+
Boston, MA 02111-1307 USA
21+
*/
22+
23+
uniform mat4 modelviewMatrix;
24+
uniform mat4 transformMatrix;
25+
uniform mat3 normalMatrix;
26+
27+
uniform int lightCount;
28+
uniform vec4 lightPosition[8];
29+
uniform vec3 lightNormal[8];
30+
uniform vec3 lightAmbient[8];
31+
uniform vec3 lightDiffuse[8];
32+
uniform vec3 lightSpecular[8];
33+
uniform vec3 lightFalloff[8];
34+
uniform vec2 lightSpot[8];
35+
36+
attribute vec4 position;
37+
attribute vec4 color;
38+
attribute vec3 normal;
39+
40+
attribute vec4 ambient;
41+
attribute vec4 specular;
42+
attribute vec4 emissive;
43+
attribute float shininess;
44+
45+
varying vec4 vertColor;
46+
varying vec4 backVertColor;
47+
48+
const float zero_float = 0.0;
49+
const float one_float = 1.0;
50+
const vec3 zero_vec3 = vec3(0.0);
51+
const vec3 minus_one_vec3 = vec3(0.0-1.0);
52+
53+
float falloffFactor(vec3 lightPos, vec3 vertPos, vec3 coeff) {
54+
vec3 lpv = lightPos - vertPos;
55+
vec3 dist = vec3(one_float);
56+
dist.z = dot(lpv, lpv);
57+
dist.y = sqrt(dist.z);
58+
return one_float / dot(dist, coeff);
59+
}
60+
61+
float spotFactor(vec3 lightPos, vec3 vertPos, vec3 lightNorm, float minCos, float spotExp) {
62+
vec3 lpv = normalize(lightPos - vertPos);
63+
vec3 nln = minus_one_vec3 * lightNorm;
64+
float spotCos = dot(nln, lpv);
65+
return spotCos <= minCos ? zero_float : pow(spotCos, spotExp);
66+
}
67+
68+
float lambertFactor(vec3 lightDir, vec3 vecNormal) {
69+
return max(zero_float, dot(lightDir, vecNormal));
70+
}
71+
72+
float blinnPhongFactor(vec3 lightDir, vec3 vertPos, vec3 vecNormal, float shine) {
73+
vec3 np = normalize(vertPos);
74+
vec3 ldp = normalize(lightDir - np);
75+
return pow(max(zero_float, dot(ldp, vecNormal)), shine);
76+
}
77+
78+
void main() {
79+
// Vertex in clip coordinates
80+
gl_Position = transformMatrix * position;
81+
82+
// Vertex in eye coordinates
83+
vec3 ecVertex = vec3(modelviewMatrix * position);
84+
85+
// Normal vector in eye coordinates
86+
vec3 ecNormal = normalize(normalMatrix * normal);
87+
vec3 ecNormalInv = ecNormal * minus_one_vec3;
88+
89+
// Light calculations
90+
vec3 totalAmbient = vec3(0, 0, 0);
91+
92+
vec3 totalFrontDiffuse = vec3(0, 0, 0);
93+
vec3 totalFrontSpecular = vec3(0, 0, 0);
94+
95+
vec3 totalBackDiffuse = vec3(0, 0, 0);
96+
vec3 totalBackSpecular = vec3(0, 0, 0);
97+
98+
// prevent register allocation failure by limiting ourselves to
99+
// two lights for now
100+
for (int i = 0; i < 2; i++) {
101+
if (lightCount == i) break;
102+
103+
vec3 lightPos = lightPosition[i].xyz;
104+
bool isDir = lightPosition[i].w < one_float;
105+
float spotCos = lightSpot[i].x;
106+
float spotExp = lightSpot[i].y;
107+
108+
vec3 lightDir;
109+
float falloff;
110+
float spotf;
111+
112+
if (isDir) {
113+
falloff = one_float;
114+
lightDir = minus_one_vec3 * lightNormal[i];
115+
} else {
116+
falloff = falloffFactor(lightPos, ecVertex, lightFalloff[i]);
117+
lightDir = normalize(lightPos - ecVertex);
118+
}
119+
120+
spotf = spotExp > zero_float ? spotFactor(lightPos, ecVertex, lightNormal[i],
121+
spotCos, spotExp)
122+
: one_float;
123+
124+
if (any(greaterThan(lightAmbient[i], zero_vec3))) {
125+
totalAmbient += lightAmbient[i] * falloff;
126+
}
127+
128+
if (any(greaterThan(lightDiffuse[i], zero_vec3))) {
129+
totalFrontDiffuse += lightDiffuse[i] * falloff * spotf *
130+
lambertFactor(lightDir, ecNormal);
131+
totalBackDiffuse += lightDiffuse[i] * falloff * spotf *
132+
lambertFactor(lightDir, ecNormalInv);
133+
}
134+
135+
if (any(greaterThan(lightSpecular[i], zero_vec3))) {
136+
totalFrontSpecular += lightSpecular[i] * falloff * spotf *
137+
blinnPhongFactor(lightDir, ecVertex, ecNormal, shininess);
138+
totalBackSpecular += lightSpecular[i] * falloff * spotf *
139+
blinnPhongFactor(lightDir, ecVertex, ecNormalInv, shininess);
140+
}
141+
}
142+
143+
// Calculating final color as result of all lights (plus emissive term).
144+
// Transparency is determined exclusively by the diffuse component.
145+
vertColor = vec4(totalAmbient, 0) * ambient +
146+
vec4(totalFrontDiffuse, 1) * color +
147+
vec4(totalFrontSpecular, 0) * specular +
148+
vec4(emissive.rgb, 0);
149+
150+
backVertColor = vec4(totalAmbient, 0) * ambient +
151+
vec4(totalBackDiffuse, 1) * color +
152+
vec4(totalBackSpecular, 0) * specular +
153+
vec4(emissive.rgb, 0);
154+
}

‎core/src/processing/opengl/shaders/LightVert-vc4.glsl‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -96,8 +96,8 @@ void main() {
9696
vec3 totalBackSpecular = vec3(0, 0, 0);
9797

9898
// prevent register allocation failure by limiting ourselves to
99-
// two lights for now
100-
for (int i = 0; i < 2; i++) {
99+
// four lights for now
100+
for (int i = 0; i < 4; i++) {
101101
if (lightCount == i) break;
102102

103103
vec3 lightPos = lightPosition[i].xyz;

‎core/src/processing/opengl/shaders/TexLightVert-brcm.glsl‎

Lines changed: 160 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,160 @@
1+
/*
2+
Part of the Processing project - http://processing.org
3+
4+
Copyright (c) 2012-15 The Processing Foundation
5+
Copyright (c) 2004-12 Ben Fry and Casey Reas
6+
Copyright (c) 2001-04 Massachusetts Institute of Technology
7+
8+
This library is free software; you can redistribute it and/or
9+
modify it under the terms of the GNU Lesser General Public
10+
License as published by the Free Software Foundation, version 2.1.
11+
12+
This library is distributed in the hope that it will be useful,
13+
but WITHOUT ANY WARRANTY; without even the implied warranty of
14+
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15+
Lesser General Public License for more details.
16+
17+
You should have received a copy of the GNU Lesser General
18+
Public License along with this library; if not, write to the
19+
Free Software Foundation, Inc., 59 Temple Place, Suite 330,
20+
Boston, MA 02111-1307 USA
21+
*/
22+
23+
uniform mat4 modelviewMatrix;
24+
uniform mat4 transformMatrix;
25+
uniform mat3 normalMatrix;
26+
uniform mat4 texMatrix;
27+
28+
uniform int lightCount;
29+
uniform vec4 lightPosition[8];
30+
uniform vec3 lightNormal[8];
31+
uniform vec3 lightAmbient[8];
32+
uniform vec3 lightDiffuse[8];
33+
uniform vec3 lightSpecular[8];
34+
uniform vec3 lightFalloff[8];
35+
uniform vec2 lightSpot[8];
36+
37+
attribute vec4 position;
38+
attribute vec4 color;
39+
attribute vec3 normal;
40+
attribute vec2 texCoord;
41+
42+
attribute vec4 ambient;
43+
attribute vec4 specular;
44+
attribute vec4 emissive;
45+
attribute float shininess;
46+
47+
varying vec4 vertColor;
48+
varying vec4 backVertColor;
49+
varying vec4 vertTexCoord;
50+
51+
const float zero_float = 0.0;
52+
const float one_float = 1.0;
53+
const vec3 zero_vec3 = vec3(0.0);
54+
const vec3 minus_one_vec3 = vec3(0.0-1.0);
55+
56+
float falloffFactor(vec3 lightPos, vec3 vertPos, vec3 coeff) {
57+
vec3 lpv = lightPos - vertPos;
58+
vec3 dist = vec3(one_float);
59+
dist.z = dot(lpv, lpv);
60+
dist.y = sqrt(dist.z);
61+
return one_float / dot(dist, coeff);
62+
}
63+
64+
float spotFactor(vec3 lightPos, vec3 vertPos, vec3 lightNorm, float minCos, float spotExp) {
65+
vec3 lpv = normalize(lightPos - vertPos);
66+
vec3 nln = minus_one_vec3 * lightNorm;
67+
float spotCos = dot(nln, lpv);
68+
return spotCos <= minCos ? zero_float : pow(spotCos, spotExp);
69+
}
70+
71+
float lambertFactor(vec3 lightDir, vec3 vecNormal) {
72+
return max(zero_float, dot(lightDir, vecNormal));
73+
}
74+
75+
float blinnPhongFactor(vec3 lightDir, vec3 vertPos, vec3 vecNormal, float shine) {
76+
vec3 np = normalize(vertPos);
77+
vec3 ldp = normalize(lightDir - np);
78+
return pow(max(zero_float, dot(ldp, vecNormal)), shine);
79+
}
80+
81+
void main() {
82+
// Vertex in clip coordinates
83+
gl_Position = transformMatrix * position;
84+
85+
// Vertex in eye coordinates
86+
vec3 ecVertex = vec3(modelviewMatrix * position);
87+
88+
// Normal vector in eye coordinates
89+
vec3 ecNormal = normalize(normalMatrix * normal);
90+
vec3 ecNormalInv = ecNormal * minus_one_vec3;
91+
92+
// Light calculations
93+
vec3 totalAmbient = vec3(0, 0, 0);
94+
95+
vec3 totalFrontDiffuse = vec3(0, 0, 0);
96+
vec3 totalFrontSpecular = vec3(0, 0, 0);
97+
98+
vec3 totalBackDiffuse = vec3(0, 0, 0);
99+
vec3 totalBackSpecular = vec3(0, 0, 0);
100+
101+
// prevent register allocation failure by limiting ourselves to
102+
// two lights for now
103+
for (int i = 0; i < 2; i++) {
104+
if (lightCount == i) break;
105+
106+
vec3 lightPos = lightPosition[i].xyz;
107+
bool isDir = lightPosition[i].w < one_float;
108+
float spotCos = lightSpot[i].x;
109+
float spotExp = lightSpot[i].y;
110+
111+
vec3 lightDir;
112+
float falloff;
113+
float spotf;
114+
115+
if (isDir) {
116+
falloff = one_float;
117+
lightDir = minus_one_vec3 * lightNormal[i];
118+
} else {
119+
falloff = falloffFactor(lightPos, ecVertex, lightFalloff[i]);
120+
lightDir = normalize(lightPos - ecVertex);
121+
}
122+
123+
spotf = spotExp > zero_float ? spotFactor(lightPos, ecVertex, lightNormal[i],
124+
spotCos, spotExp)
125+
: one_float;
126+
127+
if (any(greaterThan(lightAmbient[i], zero_vec3))) {
128+
totalAmbient += lightAmbient[i] * falloff;
129+
}
130+
131+
if (any(greaterThan(lightDiffuse[i], zero_vec3))) {
132+
totalFrontDiffuse += lightDiffuse[i] * falloff * spotf *
133+
lambertFactor(lightDir, ecNormal);
134+
totalBackDiffuse += lightDiffuse[i] * falloff * spotf *
135+
lambertFactor(lightDir, ecNormalInv);
136+
}
137+
138+
if (any(greaterThan(lightSpecular[i], zero_vec3))) {
139+
totalFrontSpecular += lightSpecular[i] * falloff * spotf *
140+
blinnPhongFactor(lightDir, ecVertex, ecNormal, shininess);
141+
totalBackSpecular += lightSpecular[i] * falloff * spotf *
142+
blinnPhongFactor(lightDir, ecVertex, ecNormalInv, shininess);
143+
}
144+
}
145+
146+
// Calculating final color as result of all lights (plus emissive term).
147+
// Transparency is determined exclusively by the diffuse component.
148+
vertColor = vec4(totalAmbient, 0) * ambient +
149+
vec4(totalFrontDiffuse, 1) * color +
150+
vec4(totalFrontSpecular, 0) * specular +
151+
vec4(emissive.rgb, 0);
152+
153+
backVertColor = vec4(totalAmbient, 0) * ambient +
154+
vec4(totalBackDiffuse, 1) * color +
155+
vec4(totalBackSpecular, 0) * specular +
156+
vec4(emissive.rgb, 0);
157+
158+
// Calculating texture coordinates, with r and q set both to one
159+
vertTexCoord = texMatrix * vec4(texCoord, 1.0, 1.0);
160+
}

‎core/src/processing/opengl/shaders/TexLightVert-vc4.glsl‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -99,8 +99,8 @@ void main() {
9999
vec3 totalBackSpecular = vec3(0, 0, 0);
100100

101101
// prevent register allocation failure by limiting ourselves to
102-
// two lights for now
103-
for (int i = 0; i < 2; i++) {
102+
// four lights for now
103+
for (int i = 0; i < 4; i++) {
104104
if (lightCount == i) break;
105105

106106
vec3 lightPos = lightPosition[i].xyz;

0 commit comments

Comments
 (0)