x_ite 4.2.17 → 4.7.7

package/src/x_ite/Browser/Shaders/X3DShadersContext.js

@@ -51,60 +51,27 @@ define ([
 	"x_ite/Browser/Core/Shading",
 	"x_ite/Components/Shaders/ComposedShader",
 	"x_ite/Components/Shaders/ShaderPart",
-	"text!x_ite/Browser/Shaders/PointSet.fs",
-	"text!x_ite/Browser/Shaders/Wireframe.vs",
-	"text!x_ite/Browser/Shaders/Wireframe.fs",
-	"text!x_ite/Browser/Shaders/Gouraud.vs",
-	"text!x_ite/Browser/Shaders/Gouraud.fs",
-	"text!x_ite/Browser/Shaders/Phong.vs",
-	"text!x_ite/Browser/Shaders/Phong.fs",
-	"text!x_ite/Browser/Shaders/Depth.vs",
-	"text!x_ite/Browser/Shaders/Depth.fs",
 	"x_ite/Browser/Shaders/ShaderTest",
+	"x_ite/Browser/Networking/urls",
 ],
 function (Shading,
           ComposedShader,
           ShaderPart,
-          pointSetFS,
-          wireframeVS,
-          wireframeFS,
-          gouraudVS,
-          gouraudFS,
-          phongVS,
-          phongFS,
-          depthVS,
-          depthFS,
-          verifyShader)
+          ShaderTest,
+          urls)
 {
 "use strict";
 
 	function X3DShadersContext ()
 	{
-		this .shaders = { };
+		this .shaders = new Set ();
 	}
 
 	X3DShadersContext .prototype =
 	{
 		initialize: function ()
 		{
-			// Create shaders.
-	
-			this .depthShader   = this .createShader ("DepthShader",     depthVS,     depthFS,     false);
-			this .pointShader   = this .createShader ("PointShader",     wireframeVS, pointSetFS,  false);
-			this .lineShader    = this .createShader ("WireframeShader", wireframeVS, wireframeFS, false);
-			this .gouraudShader = this .createShader ("GouraudShader",   gouraudVS,   gouraudFS,   false);
-			this .phongShader   = this .createShader ("PhongShader",     phongVS,     phongFS,     false);
-			this .shadowShader  = this .createShader ("ShadowShader",    phongVS,     phongFS,     true);
-
-			this .pointShader   .shadowShader = this .pointShader;
-			this .lineShader    .shadowShader = this .lineShader;
-			this .gouraudShader .shadowShader = this .shadowShader;
-			this .phongShader   .shadowShader = this .shadowShader;
-	
-			this .setShading (Shading .GOURAUD);
-	
-			this .phongShader  .isValid_ .addInterest ("set_phong_shader_valid__",  this);
-			this .shadowShader .isValid_ .addInterest ("set_shadow_shader_valid__", this);
+			this .setShading (this .getBrowserOptions () .getShading ());
 		},
 		getShadingLanguageVersion: function ()
 		{
@@ -124,12 +91,13 @@ function (Shading,
 		},
 		addShader: function (shader)
 		{
-			this .shaders [shader .getId ()] = shader;
+			this .shaders .add (shader);
+
 			shader .setShading (this .getBrowserOptions () .getShading ());
 		},
 		removeShader: function (shader)
 		{
-			delete this .shaders [shader .getId ()];
+			this .shaders .delete (shader);
 		},
 		getShaders: function ()
 		{
@@ -139,29 +107,96 @@ function (Shading,
 		{
 			return this .defaultShader;
 		},
+		hasPointShader: function ()
+		{
+			return !! this .pointShader;
+		},
 		getPointShader: function ()
 		{
+			this .pointShader = this .createShader ("PointShader", "PointSet");
+
+			this .getPointShader = function () { return this .pointShader; };
+
 			return this .pointShader;
 		},
+		hasLineShader: function ()
+		{
+			return !! this .lineShader;
+		},
 		getLineShader: function ()
 		{
+			this .lineShader = this .createShader ("WireframeShader", "Wireframe");
+
+			this .getLineShader = function () { return this .lineShader; };
+
 			return this .lineShader;
 		},
+		hasUnlitShader: function ()
+		{
+			return !! this .unlitShader;
+		},
+		getUnlitShader: function ()
+		{
+			this .unlitShader = this .createShader ("UnlitShader", "Unlit");
+
+			this .unlitShader .isValid_ .addInterest ("set_unlit_shader_valid__", this);
+
+			this .getUnlitShader = function () { return this .unlitShader; };
+
+			return this .unlitShader;
+		},
+		hasGouraudShader: function ()
+		{
+			return !! this .gouraudShader;
+		},
 		getGouraudShader: function ()
 		{
-			// There must always be a gouraud shader available.
+			this .gouraudShader = this .createShader ("GouraudShader", "Gouraud", false);
+
+			this .gouraudShader .isValid_ .addInterest ("set_gouraud_shader_valid__", this);
+
+			this .getGouraudShader = function () { return this .gouraudShader; };
+
 			return this .gouraudShader;
 		},
+		hasPhongShader: function ()
+		{
+			return !! this .phongShader;
+		},
 		getPhongShader: function ()
 		{
+			this .phongShader = this .createShader ("PhongShader", "Phong", false);
+
+			this .phongShader .isValid_ .addInterest ("set_phong_shader_valid__", this);
+
+			this .getPhongShader = function () { return this .phongShader; };
+
 			return this .phongShader;
 		},
+		hasShadowShader: function ()
+		{
+			return !! this .shadowShader;
+		},
 		getShadowShader: function ()
 		{
-			return this .defaultShader .shadowShader;
+			this .shadowShader = this .createShader ("ShadowShader", "Phong", true);
+
+			this .shadowShader .isValid_ .addInterest ("set_shadow_shader_valid__", this);
+
+			this .getShadowShader = function () { return this .shadowShader; };
+
+			return this .shadowShader;
+		},
+		hasDepthShader: function ()
+		{
+			return !! this .depthShader;
 		},
 		getDepthShader: function ()
 		{
+			this .depthShader = this .createShader ("DepthShader", "Depth");
+
+			this .getDepthShader = function () { return this .depthShader; };
+
 			return this .depthShader;
 		},
 		setShading: function (type)
@@ -170,78 +205,103 @@ function (Shading,
 			{
 				case Shading .PHONG:
 				{
-					this .defaultShader = this .phongShader;
+					this .defaultShader = this .getPhongShader ();
 					break;
 				}
 				default:
 				{
-					this .defaultShader = this .gouraudShader;
+					this .defaultShader = this .getGouraudShader ();
 					break;
 				}
 			}
-	
-			this .pointShader   .setShading (type);
-			this .lineShader    .setShading (type);
-			this .gouraudShader .setShading (type);
-			this .phongShader   .setShading (type);
-			this .shadowShader  .setShading (type);
 
-			// Configure custom shaders
+			// Configure shaders.
 
-			var shaders = this .getShaders ();
-
-			for (var id in shaders)
-				shaders [id] .setShading (type);
+			for (const shader of this .getShaders ())
+				shader .setShading (type);
 		},
-		createShader: function (name, vs, fs, shadow)
+		createShader: function (name, file, shadow = false)
 		{
-			if (shadow)
-			{
-				vs = "\n#define X3D_SHADOWS\n" + vs;
-				fs = "\n#define X3D_SHADOWS\n" + fs;
-			}
+			if (this .getDebug ())
+				console .log ("Initializing " + name);
+
+			const version = this .getContext () .getVersion ();
 
-			var vertexShader = new ShaderPart (this .getPrivateScene ());
+			const vertexShader = new ShaderPart (this .getPrivateScene ());
 			vertexShader .setName (name + "Vertex");
-			vertexShader .url_ .push ("data:text/plain;charset=utf-8," + vs);
+			vertexShader .url_ .push (urls .getShaderUrl ("webgl" + version + "/" + file + ".vs"));
+			vertexShader .setShadow (shadow);
 			vertexShader .setup ();
 
-			var fragmentShader = new ShaderPart (this .getPrivateScene ());
+			const fragmentShader = new ShaderPart (this .getPrivateScene ());
 			fragmentShader .setName (name + "Fragment");
-			fragmentShader .type_ = "FRAGMENT";
-			fragmentShader .url_ .push ("data:text/plain;charset=utf-8," + fs);
+			fragmentShader .type_  = "FRAGMENT";
+			fragmentShader .url_ .push (urls .getShaderUrl ("webgl" + version + "/" + file + ".fs"));
+			fragmentShader .setShadow (shadow);
 			fragmentShader .setup ();
-	
-			var shader = new ComposedShader (this .getPrivateScene ());
+
+			const shader = new ComposedShader (this .getPrivateScene ());
 			shader .setName (name);
 			shader .language_ = "GLSL";
 			shader .parts_ .push (vertexShader);
 			shader .parts_ .push (fragmentShader);
 			shader .setCustom (false);
+			shader .setShading (this .getBrowserOptions () .getShading ());
 			shader .setup ();
 
-			this .getLoadSensor () .watchList_ .push (vertexShader);
-			this .getLoadSensor () .watchList_ .push (fragmentShader);
+			this .addShader (shader);
 
 			return shader;
 		},
+		set_unlit_shader_valid__: function (valid)
+		{
+			this .unlitShader .isValid_ .removeInterest ("set_unlit_shader_valid__", this);
+
+			if (valid .getValue () && ShaderTest .verify (this, this .unlitShader))
+				return;
+
+			console .error ("X_ITE: Unlit shading is not available, using fallback VRML shader.");
+
+			// Recompile shader.
+			this .unlitShader .parts_ [0] .url = [ urls .getShaderUrl ("webgl1/FallbackUnlit.vs") ];
+			this .unlitShader .parts_ [1] .url = [ urls .getShaderUrl ("webgl1/FallbackUnlit.fs") ];
+		},
+		set_gouraud_shader_valid__: function (valid)
+		{
+			this .gouraudShader .isValid_ .removeInterest ("set_gouraud_shader_valid__", this);
+
+			if (valid .getValue () && ShaderTest .verify (this, this .gouraudShader))
+				return;
+
+			console .warn ("X_ITE: All else fails, using fallback VRML shader.");
+
+			// Recompile shader.
+			this .gouraudShader .parts_ [0] .url = [ urls .getShaderUrl ("webgl1/Fallback.vs") ];
+			this .gouraudShader .parts_ [1] .url = [ urls .getShaderUrl ("webgl1/Fallback.fs") ];
+		},
 		set_phong_shader_valid__: function (valid)
 		{
-			if (valid .getValue () && verifyShader (this, this .phongShader))
+			this .phongShader .isValid_ .removeInterest ("set_phong_shader_valid__", this);
+
+			if (valid .getValue () && ShaderTest .verify (this, this .phongShader))
 				return;
 
 			console .warn ("X_ITE: Phong shading is not available, using Gouraud shading.");
 
-			this .phongShader = this .gouraudShader;
+			this .phongShader = this .getGouraudShader ();
+
+			this .setShading (this .getBrowserOptions () .getShading ());
 		},
 		set_shadow_shader_valid__: function (valid)
 		{
-			if (valid .getValue () && verifyShader (this, this .shadowShader))
+			this .shadowShader .isValid_ .removeInterest ("set_shadow_shader_valid__", this);
+
+			if (valid .getValue () && ShaderTest .verify (this, this .shadowShader))
 				return;
 
 			console .warn ("X_ITE: Shadow shading is not available, using Gouraud shading.");
 
-			this .shadowShader = this .gouraudShader;
+			this .shadowShader = this .getGouraudShader ();
 		},
 	};
 

package/src/x_ite/Browser/Shape/AlphaMode.js

@@ -0,0 +1,65 @@
+/* -*- Mode: JavaScript; coding: utf-8; tab-width: 3; indent-tabs-mode: tab; c-basic-offset: 3 -*-
+ *******************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright create3000, Scheffelstraße 31a, Leipzig, Germany 2011.
+ *
+ * All rights reserved. Holger Seelig <holger.seelig@yahoo.de>.
+ *
+ * The copyright notice above does not evidence any actual of intended
+ * publication of such source code, and is an unpublished work by create3000.
+ * This material contains CONFIDENTIAL INFORMATION that is the property of
+ * create3000.
+ *
+ * No permission is granted to copy, distribute, or create derivative works from
+ * the contents of this software, in whole or in part, without the prior written
+ * permission of create3000.
+ *
+ * NON-MILITARY USE ONLY
+ *
+ * All create3000 software are effectively free software with a non-military use
+ * restriction. It is free. Well commented source is provided. You may reuse the
+ * source in any way you please with the exception anything that uses it must be
+ * marked to indicate is contains 'non-military use only' components.
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2015, 2016 Holger Seelig <holger.seelig@yahoo.de>.
+ *
+ * This file is part of the X_ITE Project.
+ *
+ * X_ITE is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License version 3 only, as published by the
+ * Free Software Foundation.
+ *
+ * X_ITE 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 version 3 for more
+ * details (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version 3
+ * along with X_ITE.  If not, see <http://www.gnu.org/licenses/gpl.html> for a
+ * copy of the GPLv3 License.
+ *
+ * For Silvio, Joy and Adi.
+ *
+ ******************************************************************************/
+
+
+define (function ()
+{
+"use strict";
+
+	var i = 0;
+
+	var AlphaMode =
+	{
+		AUTO:   i ++,
+		OPAQUE: i ++,
+		MASK:   i ++,
+		BLEND:  i ++,
+	};
+
+	return AlphaMode;
+});

package/src/x_ite/Browser/Shape/X3DShapeContext.js

@@ -49,25 +49,129 @@
 
 define ([
 	"x_ite/Components/Shape/Appearance",
+	"x_ite/Components/Shape/PointProperties",
+	"x_ite/Components/Shape/LineProperties",
+	"x_ite/Components/Shape/FillProperties",
+	"x_ite/Components/Shape/UnlitMaterial",
+	"x_ite/Components/Texturing/ImageTexture",
+	"x_ite/Components/Texturing/TextureProperties",
+	"x_ite/Browser/Networking/urls",
 ],
-function (Appearance)
+function (Appearance,
+          PointProperties,
+          LineProperties,
+          FillProperties,
+          UnlitMaterial,
+          ImageTexture,
+          TextureProperties,
+          urls)
 {
 "use strict";
 
 	function X3DShapeContext ()
 	{
-		this .defaultAppearance = new Appearance (this .getPrivateScene ());
+		this .linetypeTextures   = [ ];
+		this .hatchStyleTextures = [ ];
 	}
 
 	X3DShapeContext .prototype =
 	{
 		initialize: function ()
+		{ },
+		getDefaultAppearance: function ()
 		{
+			this .defaultAppearance = new Appearance (this .getPrivateScene ());
 			this .defaultAppearance .setup ();
+
+			this .getDefaultAppearance = function () { return this .defaultAppearance; };
+
+			return this .defaultAppearance;
 		},
-		getDefaultAppearance: function ()
+		getDefaultPointProperties: function ()
 		{
-			return this .defaultAppearance;
+			this .defaultPointProperties = new PointProperties (this .getPrivateScene ());
+			this .defaultPointProperties .setup ();
+
+			this .getDefaultPointProperties = function () { return this .defaultPointProperties; };
+
+			return this .defaultPointProperties;
+		},
+		getDefaultLineProperties: function ()
+		{
+			this .defaultLineProperties = new LineProperties (this .getPrivateScene ());
+
+			this .defaultLineProperties .applied_ = false;
+			this .defaultLineProperties .setup ();
+
+			this .getDefaultLineProperties = function () { return this .defaultLineProperties; };
+
+			return this .defaultLineProperties;
+		},
+		getDefaultFillProperties: function ()
+		{
+			this .defaultFillProperties = new FillProperties (this .getPrivateScene ());
+
+			this .defaultFillProperties .hatched_ = false;
+			this .defaultFillProperties .setup ();
+
+			this .getDefaultFillProperties = function () { return this .defaultFillProperties; };
+
+			return this .defaultFillProperties;
+		},
+		getDefaultMaterial: function ()
+		{
+			this .defaultMaterial = new UnlitMaterial (this .getPrivateScene ());
+
+			this .defaultMaterial .setup ();
+
+			this .getDefaultMaterial = function () { return this .defaultMaterial; };
+
+			return this .defaultMaterial;
+		},
+		getLinetype: function (index)
+		{
+			if (index < 1 || index > 15)
+				index = 1;
+
+			var linetypeTexture = this .linetypeTextures [index];
+
+			if (linetypeTexture)
+				return linetypeTexture;
+
+			linetypeTexture = this .linetypeTextures [index] = new ImageTexture (this .getPrivateScene ());
+
+			linetypeTexture .url_ [0]           = urls .getLinetypeUrl (index);
+			linetypeTexture .textureProperties_ = this .getLineFillTextureProperties ();
+			linetypeTexture .setup ();
+
+			return linetypeTexture;
+		},
+		getHatchStyle: function (index)
+		{
+			if (index < 1 || index > 19)
+				index = 1;
+
+			var hatchStyleTexture = this .hatchStyleTextures [index];
+
+			if (hatchStyleTexture)
+				return hatchStyleTexture;
+
+			hatchStyleTexture = this .hatchStyleTextures [index] = new ImageTexture (this .getPrivateScene ());
+
+			hatchStyleTexture .url_ [0]           = urls .getHatchingUrl (index);
+			hatchStyleTexture .textureProperties_ = this .getLineFillTextureProperties ();
+			hatchStyleTexture .setup ();
+
+			return hatchStyleTexture;
+		},
+		getLineFillTextureProperties: function ()
+		{
+			this .lineFillTextureProperties = new TextureProperties (this .getPrivateScene ());
+			this .lineFillTextureProperties .setup ();
+
+			this .getLineFillTextureProperties = function () { return this .lineFillTextureProperties; };
+
+			return this .lineFillTextureProperties;
 		},
 	};