Pubovl (including extras)

Resources/Scripts/Gui/Client/ChatSayWindow.as

@@ -190,6 +190,7 @@ namespace spades {
                 @field = CommandField(Manager, ui.chatHistory);
                 field.Bounds = AABB2(winX, winY, winW, 30.f);
                 field.Placeholder = _Tr("Client", "Chat Text");
+                field.MaxLength = 93;
                 @field.Changed = spades::ui::EventHandler(this.OnFieldChanged);
                 AddChild(field);
             }

Resources/Scripts/Gui/Preferences.as

@@ -644,6 +644,19 @@ namespace spades {
                                                      _Tr("Preferences", "OFF")},
                                     array<int> = {2, 1, 0});
 
+            layouter.AddHeading(_Tr("Preferences", "OpenGL Effects"));
+            layouter.AddToggleField(_Tr("Preferences", "Outlines"), "cg_outlines");
+            layouter.AddSliderField(_Tr("Preferences", "Outline Strength"), "cg_outlineStrength", 1, 3, 1,
+                                    ConfigNumberFormatter(0, "px"));
+            layouter.AddToggleField(_Tr("Preferences", "Textures"), "cg_textures");
+            layouter.AddToggleField(_Tr("Preferences", "Multi-Texture Mode"), "cg_multiTextures");
+            layouter.AddSliderField(_Tr("Preferences", "Texture Strength"), "cg_textureStrength", 0, 100, 1,
+                                    ConfigNumberFormatter(0, "%"));
+
+            layouter.AddHeading(_Tr("Preferences", "Spectator Tools"));
+            layouter.AddToggleField(_Tr("Preferences", "Spectator Player Names"), "dd_specNames");
+            layouter.AddToggleField(_Tr("Preferences", "Spectator Wallhack"), "dd_specWallhack");
+
             layouter.AddHeading(_Tr("Preferences", "Feedbacks"));
             layouter.AddToggleField(_Tr("Preferences", "Chat Notify Sounds"), "cg_chatBeep");
             layouter.AddToggleField(_Tr("Preferences", "Hit Indicator"), "cg_hitIndicator");
@@ -654,6 +667,8 @@ namespace spades {
             layouter.AddToggleField(_Tr("Preferences", "Server Alert"), "cg_serverAlert");
 
             layouter.AddHeading(_Tr("Preferences", "Misc"));
+            layouter.AddSliderField(_Tr("Preferences", "Volume"), "s_volume", 0, 100, 1,
+                                    ConfigNumberFormatter(0, "%"));
             layouter.AddSliderField(_Tr("Preferences", "Field of View"), "cg_fov", 45, 90, 1,
                                     ConfigNumberFormatter(0, " deg"));
             layouter.AddSliderField(_Tr("Preferences", "Minimap size"), "cg_minimapSize", 128, 256,

Resources/Shaders/BasicBlockOutlines.fs

@@ -0,0 +1,16 @@
+uniform vec3 fogColor;
+uniform vec3 outlineColor;
+
+varying vec3 fogDensity;
+
+void main() {
+
+	gl_FragColor.rgb = mix(outlineColor, fogColor, fogDensity);
+	gl_FragColor.a = 1.0;
+
+#if !LINEAR_FRAMEBUFFER
+	// gamma correct
+	gl_FragColor.xyz = sqrt(gl_FragColor.xyz);
+#endif
+}
+

Resources/Shaders/BasicBlockOutlines.program

@@ -0,0 +1,4 @@
+Shaders/BasicBlockOutlines.fs
+Shaders/BasicBlockOutlines.vs
+*shadow*
+Shaders/Fog.vs

Resources/Shaders/BasicBlockOutlines.vs

@@ -0,0 +1,26 @@
+uniform mat4 projectionViewMatrix;
+uniform mat4 viewMatrix;
+uniform vec3 chunkPosition;
+uniform vec3 viewOriginVector;
+
+attribute vec3 positionAttribute;
+
+varying vec3 fogDensity;
+
+vec4 FogDensity(float poweredLength);
+
+void main() {
+
+	vec4 vertexPos = vec4(chunkPosition, 1.);
+
+	vertexPos.xyz += positionAttribute.xyz;
+
+	gl_Position = projectionViewMatrix * vertexPos;
+
+	vec4 viewPos = viewMatrix * vertexPos;
+	vec2 horzRelativePos = vertexPos.xy - viewOriginVector.xy;
+	float horzDistance = dot(horzRelativePos, horzRelativePos);
+	fogDensity = FogDensity(horzDistance).xyz;
+
+}
+

Resources/Shaders/BasicBlockPhysTextures.fs

@@ -0,0 +1,105 @@
+/*
+ Copyright (c) 2013 yvt
+
+ This file is part of OpenSpades.
+
+ OpenSpades is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ OpenSpades is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with OpenSpades.  If not, see <http://www.gnu.org/licenses/>.
+
+ */
+
+
+
+varying vec4 color;
+varying vec2 ambientOcclusionCoord;
+varying vec3 fogDensity;
+varying vec2 blockTexCoord;
+
+varying vec3 viewSpaceCoord;
+varying vec3 viewSpaceNormal;
+uniform vec3 viewSpaceLight;
+
+varying vec3 reflectionDir;
+
+uniform sampler2D ambientOcclusionTexture;
+uniform sampler2D detailTexture;
+uniform vec3 fogColor;
+
+uniform sampler2D blockTexture;
+uniform float blockTextureStrength;
+
+vec3 EvaluateSunLight();
+vec3 EvaluateAmbientLight(float detailAmbientOcclusion);
+vec3 EvaluateDirectionalAmbientLight(float detailAmbientOcclusion, vec3 direction);
+//void VisibilityOfSunLight_Model_Debug();
+
+float OrenNayar(float sigma, float dotLight, float dotEye);
+float CockTorrance(vec3 eyeVec, vec3 lightVec, vec3 normal);
+
+void main() {
+	// color is linear
+	gl_FragColor = vec4(color.xyz, 1.);
+
+	gl_FragColor.rgb = mix(gl_FragColor.rgb, texture2D(blockTexture, blockTexCoord).rgb, blockTextureStrength);
+
+	vec3 shading = vec3(OrenNayar(.8, color.w,
+							 -dot(viewSpaceNormal, normalize(viewSpaceCoord))));
+	vec3 sunLight = EvaluateSunLight();
+	shading *= sunLight;
+
+	float ao = texture2D(ambientOcclusionTexture, ambientOcclusionCoord).x;
+
+	shading += EvaluateAmbientLight(ao);
+
+	// apply diffuse shading
+	gl_FragColor.xyz *= shading;
+
+	// fresnel term
+	// FIXME: use split-sum approximation from UE4
+	float fresnel2 = 1. - (-dot(viewSpaceNormal, normalize(viewSpaceCoord)));
+	float fresnel = fresnel2 * fresnel2;
+
+	fresnel = .03 + fresnel * 0.1;
+
+	// blurred reflections
+	vec3 reflectWS = normalize(reflectionDir);
+	vec3 reflection = EvaluateDirectionalAmbientLight(ao, reflectWS);
+
+	gl_FragColor.xyz = mix(gl_FragColor.xyz, reflection, fresnel);
+
+	// specular shading
+	if(color.w > .1 && dot(sunLight, vec3(1.)) > 0.001){
+		vec3 specularColor = sunLight;
+		gl_FragColor.xyz += specularColor * CockTorrance(-normalize(viewSpaceCoord),
+													viewSpaceLight,
+													viewSpaceNormal);
+	}
+
+	// apply fog
+	gl_FragColor.xyz = mix(gl_FragColor.xyz, fogColor, fogDensity);
+
+	gl_FragColor.xyz = max(gl_FragColor.xyz, 0.);
+
+	// gamma correct
+#if !LINEAR_FRAMEBUFFER
+	gl_FragColor.xyz = sqrt(gl_FragColor.xyz);
+#endif
+
+#if USE_HDR
+	// somehow denormal occurs, so detect it here and remove
+	// (denormal destroys screen)
+	if(gl_FragColor.xyz != gl_FragColor.xyz)
+		gl_FragColor.xyz = vec3(0.);
+#endif
+}
+

Resources/Shaders/BasicBlockPhysTextures.program

@@ -0,0 +1,6 @@
+Shaders/BasicBlockPhysTextures.fs
+Shaders/BasicBlockPhysTextures.vs
+Shaders/PhysicalModel/OrenNayar.fs
+Shaders/PhysicalModel/CookTorrance.fs
+*shadow*
+Shaders/Fog.vs

Resources/Shaders/BasicBlockPhysTextures.vs

@@ -0,0 +1,102 @@
+/*
+ Copyright (c) 2013 yvt
+
+ This file is part of OpenSpades.
+
+ OpenSpades is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ OpenSpades is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with OpenSpades.  If not, see <http://www.gnu.org/licenses/>.
+
+ */
+
+
+
+uniform mat4 projectionViewMatrix;
+uniform mat4 viewMatrix;
+uniform vec3 chunkPosition;
+uniform float fogDistance;
+uniform vec3 viewOriginVector;
+
+// --- Vertex attribute ---
+// [x, y, z]
+attribute vec3 positionAttribute;
+
+// [ax, ay]
+attribute vec2 ambientOcclusionCoordAttribute;
+
+// [R, G, B, diffuse]
+attribute vec4 colorAttribute;
+
+// [nx, ny, nz]
+attribute vec3 normalAttribute;
+
+// [sx, sy, sz]
+attribute vec3 fixedPositionAttribute;
+
+// [ux, uy]
+attribute vec2 blockTexCoordAttribute;
+
+varying vec2 ambientOcclusionCoord;
+varying vec4 color;
+varying vec3 fogDensity;
+varying vec2 blockTexCoord;
+
+varying vec3 viewSpaceCoord;
+varying vec3 viewSpaceNormal;
+
+varying vec3 reflectionDir;
+
+void PrepareForShadowForMap(vec3 vertexCoord, vec3 fixedVertexCoord, vec3 normal);
+vec4 FogDensity(float poweredLength);
+
+void main() {
+
+	blockTexCoord = blockTexCoordAttribute;
+
+	vec4 vertexPos = vec4(chunkPosition, 1.);
+
+	vertexPos.xyz += positionAttribute.xyz;
+
+	gl_Position = projectionViewMatrix * vertexPos;
+
+	color = colorAttribute;
+	color.xyz *= color.xyz; // linearize
+
+	// lambert reflection
+	vec3 sunDir = normalize(vec3(0, -1., -1.));
+	color.w = dot(sunDir, normalAttribute);
+
+
+	// ambient occlusion
+	ambientOcclusionCoord = (ambientOcclusionCoordAttribute + .5) * (1. / 256.);
+
+	vec4 viewPos = viewMatrix * vertexPos;
+	vec2 horzRelativePos = vertexPos.xy - viewOriginVector.xy;
+	float horzDistance = dot(horzRelativePos, horzRelativePos);
+	fogDensity = FogDensity(horzDistance).xyz;
+
+	vec3 fixedPosition = chunkPosition;
+	fixedPosition += fixedPositionAttribute * 0.5;
+	fixedPosition += normalAttribute * 0.1;
+
+	vec3 normal = normalAttribute;
+	vec3 shadowVertexPos = vertexPos.xyz;
+	PrepareForShadowForMap(shadowVertexPos, fixedPosition, normal);
+
+	// reflection vector (used for specular lighting)
+	reflectionDir = reflect(vertexPos.xyz - viewOriginVector, normal);
+
+	// used for diffuse lighting
+	viewSpaceCoord = viewPos.xyz;
+	viewSpaceNormal = (viewMatrix * vec4(normal, 0.)).xyz;
+}
+

Resources/Shaders/BasicBlockTextures.fs

@@ -0,0 +1,64 @@
+/*
+ Copyright (c) 2013 yvt
+
+ This file is part of OpenSpades.
+
+ OpenSpades is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ OpenSpades is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with OpenSpades.  If not, see <http://www.gnu.org/licenses/>.
+
+ */
+
+
+
+varying vec4 color;
+varying vec2 ambientOcclusionCoord;
+varying vec2 detailCoord;
+varying vec3 fogDensity;
+varying vec2 blockTexCoord;
+
+uniform sampler2D ambientOcclusionTexture;
+uniform sampler2D detailTexture;
+uniform vec3 fogColor;
+
+uniform sampler2D blockTexture;
+uniform float blockTextureStrength;
+
+vec3 EvaluateSunLight();
+vec3 EvaluateAmbientLight(float detailAmbientOcclusion);
+//void VisibilityOfSunLight_Model_Debug();
+
+void main() {
+	// color is linear
+	gl_FragColor = vec4(color.xyz, 1.);
+
+	gl_FragColor.rgb = mix(gl_FragColor.rgb, texture2D(blockTexture, blockTexCoord).rgb, blockTextureStrength);
+
+	vec3 shading = vec3(color.w);
+	shading *= EvaluateSunLight();
+
+	float ao = texture2D(ambientOcclusionTexture, ambientOcclusionCoord).x;
+
+	shading += EvaluateAmbientLight(ao);
+
+	// apply diffuse shading
+	gl_FragColor.xyz *= shading;
+
+	// apply fog
+	gl_FragColor.xyz = mix(gl_FragColor.xyz, fogColor, fogDensity);
+
+#if !LINEAR_FRAMEBUFFER
+	// gamma correct
+	gl_FragColor.xyz = sqrt(gl_FragColor.xyz);
+#endif
+}
+

Resources/Shaders/BasicBlockTextures.program

@@ -0,0 +1,4 @@
+Shaders/BasicBlockTextures.fs
+Shaders/BasicBlockTextures.vs
+*shadow*
+Shaders/Fog.vs