Include only referenced shaders

Assets/deferred_pass_resource.json

@@ -6,20 +6,9 @@
                     "blend_destination": "blend_zero", 
                     "blend_source": "blend_one", 
                     "compare_mode": "always", 
-                    "constants": [
-                         {
-                            "id": "light", 
-                            "link": "_lightPosition", 
-                            "type": "vec3"
-                        }, 
-                        {
-                            "id": "eye", 
-                            "link": "_cameraPosition", 
-                            "type": "vec3"
-                        }
-                    ], 
+                    "constants": [], 
                     "cull_mode": "none", 
-                    "depth_write": true, 
+                    "depth_write": false, 
                     "fragment_shader": "deferred_pass.frag", 
                     "id": "deferred_pass", 
                     "texture_units": [

Assets/pipeline_resource.json

@@ -1,7 +1,7 @@
 {
     "pipeline_resources": [
         {
-            "id": "blender_pipeline",
+            "id": "forward_pipeline",
             "render_targets": [],
             "stages": [
                 
@@ -16,7 +16,7 @@
                 },
                 {
                     "command": "draw_geometry",
-                    "params": ["blender"]
+                    "params": ["forward"]
                 }
             ]
         },
@@ -25,8 +25,8 @@
             "render_targets": [
             	{
                     "id": "gbuffer",
-                    "width": 1136,
-                    "height": 640,
+                    "width": 0,
+                    "height": 0,
                     "color_buffers": 3,
                     "depth": true,
                     "format": "RGBA128"

blender/armory.py

@@ -1,5 +1,5 @@
 # =============================================================
-#  Lue Scene Exporter
+#  Armory Scene Exporter
 #  http://lue3d.org/
 #  by Lubos Lenco
 #
@@ -9,23 +9,20 @@
 # 
 #  Export plugin for Blender
 #  by Eric Lengyel
-#
 #  Version 1.1.2.2
-# 
 #  Copyright 2015, Terathon Software LLC
 # 
 #  This software is licensed under the Creative Commons
 #  Attribution-ShareAlike 3.0 Unported License:
-# 
 #  http://creativecommons.org/licenses/by-sa/3.0/deed.en_US
 #
 # =============================================================
 
 
 bl_info = {
-	"name": "Lue format (.json)",
-	"description": "Lue Exporter",
-	"author": "Eric Lengyel, adapted by Lubos Lenco",
+	"name": "Armory format (.json)",
+	"description": "Armory Exporter",
+	"author": "Eric Lengyel, Armory by Lubos Lenco",
 	"version": (1, 0, 0, 0),
 	"location": "File > Import-Export",
 	"wiki_url": "http://lue3d.org/",
@@ -111,15 +108,17 @@ class Object:
 		return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
 
 
-class LueExporter(bpy.types.Operator, ExportHelper):
-	"""Export to Lue format"""
-	bl_idname = "export_scene.lue"
-	bl_label = "Export Lue"
+class ArmoryExporter(bpy.types.Operator, ExportHelper):
+	"""Export to Armory format"""
+	bl_idname = "export_scene.armory"
+	bl_label = "Export Armory"
 	filename_ext = ".json"
 
 	option_export_selection = bpy.props.BoolProperty(name = "Export Selection Only", description = "Export only selected objects", default = False)
 	option_sample_animation = bpy.props.BoolProperty(name = "Force Sampled Animation", description = "Always export animation as per-frame samples", default = False)
-	option_no_cycles = bpy.props.BoolProperty(name = "Export Pure Lue", description = "Export pure lue data", default = False)
+	option_no_cycles = bpy.props.BoolProperty(name = "Export Pure Armory", description = "Export pure armory data", default = False)
+
+	shader_references = None
 
 	def WriteColor(self, color):
 		return [color[0], color[1], color[2]]
@@ -341,9 +340,9 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 	@staticmethod
 	def AnimationPresent(fcurve, kind):
 		if (kind != kAnimationBezier):
-			return (LueExporter.AnimationKeysDifferent(fcurve))
+			return (ArmoryExporter.AnimationKeysDifferent(fcurve))
 
-		return ((LueExporter.AnimationKeysDifferent(fcurve)) or (LueExporter.AnimationTangentsNonzero(fcurve)))
+		return ((ArmoryExporter.AnimationKeysDifferent(fcurve)) or (ArmoryExporter.AnimationTangentsNonzero(fcurve)))
 
 
 	@staticmethod
@@ -534,7 +533,7 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 		for i in range(len(exportVertexArray)):
 			ev = exportVertexArray[i]
 			bucket = ev.hash & (bucketCount - 1)
-			index = LueExporter.FindExportVertex(hashTable[bucket], exportVertexArray, ev)
+			index = ArmoryExporter.FindExportVertex(hashTable[bucket], exportVertexArray, ev)
 			if (index < 0):
 				indexTable.append(len(unifiedVertexArray))
 				unifiedVertexArray.append(ev)
@@ -596,7 +595,7 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 		for i in range(self.beginFrame, self.endFrame):
 			scene.frame_set(i)
 			m2 = node.matrix_local
-			if (LueExporter.MatricesDifferent(m1, m2)):
+			if (ArmoryExporter.MatricesDifferent(m1, m2)):
 				animationFlag = True
 				break
 
@@ -642,7 +641,7 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 		for i in range(self.beginFrame, self.endFrame):
 			scene.frame_set(i)
 			m2 = poseBone.matrix
-			if (LueExporter.MatricesDifferent(m1, m2)):
+			if (ArmoryExporter.MatricesDifferent(m1, m2)):
 				animationFlag = True
 				break
 
@@ -718,49 +717,49 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 			action = node.animation_data.action
 			if (action):
 				for fcurve in action.fcurves:
-					kind = LueExporter.ClassifyAnimationCurve(fcurve)
+					kind = ArmoryExporter.ClassifyAnimationCurve(fcurve)
 					if (kind != kAnimationSampled):
 						if (fcurve.data_path == "location"):
 							for i in range(3):
 								if ((fcurve.array_index == i) and (not posAnimCurve[i])):
 									posAnimCurve[i] = fcurve
 									posAnimKind[i] = kind
-									if (LueExporter.AnimationPresent(fcurve, kind)):
+									if (ArmoryExporter.AnimationPresent(fcurve, kind)):
 										posAnimated[i] = True
 						elif (fcurve.data_path == "delta_location"):
 							for i in range(3):
 								if ((fcurve.array_index == i) and (not deltaPosAnimCurve[i])):
 									deltaPosAnimCurve[i] = fcurve
 									deltaPosAnimKind[i] = kind
-									if (LueExporter.AnimationPresent(fcurve, kind)):
+									if (ArmoryExporter.AnimationPresent(fcurve, kind)):
 										deltaPosAnimated[i] = True
 						elif (fcurve.data_path == "rotation_euler"):
 							for i in range(3):
 								if ((fcurve.array_index == i) and (not rotAnimCurve[i])):
 									rotAnimCurve[i] = fcurve
 									rotAnimKind[i] = kind
-									if (LueExporter.AnimationPresent(fcurve, kind)):
+									if (ArmoryExporter.AnimationPresent(fcurve, kind)):
 										rotAnimated[i] = True
 						elif (fcurve.data_path == "delta_rotation_euler"):
 							for i in range(3):
 								if ((fcurve.array_index == i) and (not deltaRotAnimCurve[i])):
 									deltaRotAnimCurve[i] = fcurve
 									deltaRotAnimKind[i] = kind
-									if (LueExporter.AnimationPresent(fcurve, kind)):
+									if (ArmoryExporter.AnimationPresent(fcurve, kind)):
 										deltaRotAnimated[i] = True
 						elif (fcurve.data_path == "scale"):
 							for i in range(3):
 								if ((fcurve.array_index == i) and (not sclAnimCurve[i])):
 									sclAnimCurve[i] = fcurve
 									sclAnimKind[i] = kind
-									if (LueExporter.AnimationPresent(fcurve, kind)):
+									if (ArmoryExporter.AnimationPresent(fcurve, kind)):
 										sclAnimated[i] = True
 						elif (fcurve.data_path == "delta_scale"):
 							for i in range(3):
 								if ((fcurve.array_index == i) and (not deltaSclAnimCurve[i])):
 									deltaSclAnimCurve[i] = fcurve
 									deltaSclAnimKind[i] = kind
-									if (LueExporter.AnimationPresent(fcurve, kind)):
+									if (ArmoryExporter.AnimationPresent(fcurve, kind)):
 										deltaSclAnimated[i] = True
 						elif ((fcurve.data_path == "rotation_axis_angle") or (fcurve.data_path == "rotation_quaternion") or (fcurve.data_path == "delta_rotation_quaternion")):
 							sampledAnimation = True
@@ -1107,7 +1106,7 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 
 	def ProcessNode(self, node):
 		if ((self.exportAllFlag) or (node.select)):
-			type = LueExporter.GetNodeType(node)
+			type = ArmoryExporter.GetNodeType(node)
 			self.nodeArray[node] = {"nodeType" : type, "structName" : node.name}
 
 			if (node.parent_type == "BONE"):
@@ -1233,7 +1232,7 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 				for i in range(len(node.particle_systems)):
 					self.ExportParticleSystemRef(node.particle_systems[i], i, o)
 
-				#shapeKeys = LueExporter.GetShapeKeys(object)
+				#shapeKeys = ArmoryExporter.GetShapeKeys(object)
 				#if (shapeKeys):
 				#	self.ExportMorphWeights(node, shapeKeys, scene, o)
 				# TODO
@@ -1491,7 +1490,7 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 		showOnlyShapeKey = node.show_only_shape_key
 		currentMorphValue = []
 
-		shapeKeys = LueExporter.GetShapeKeys(mesh)
+		shapeKeys = ArmoryExporter.GetShapeKeys(mesh)
 		if (shapeKeys):
 			node.active_shape_key_index = 0
 			node.show_only_shape_key = True
@@ -1552,11 +1551,11 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 		# Triangulate mesh and remap vertices to eliminate duplicates.
 
 		materialTable = []
-		exportVertexArray = LueExporter.DeindexMesh(exportMesh, materialTable)
+		exportVertexArray = ArmoryExporter.DeindexMesh(exportMesh, materialTable)
 		triangleCount = len(materialTable)
 
 		indexTable = []
-		unifiedVertexArray = LueExporter.UnifyVertices(exportVertexArray, indexTable)
+		unifiedVertexArray = ArmoryExporter.UnifyVertices(exportVertexArray, indexTable)
 		vertexCount = len(unifiedVertexArray)
 
 		# Write the position array.
@@ -1935,7 +1934,7 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 		o.near_plane = object.clip_start
 		o.far_plane = object.clip_end
 		o.frustum_culling = False
-		o.pipeline = "pipeline_resource/blender_pipeline"
+		o.pipeline = "pipeline_resource/forward_pipeline"
 		
 		if 'Background' in bpy.data.worlds[0].node_tree.nodes: # TODO: parse node tree
 			col = bpy.data.worlds[0].node_tree.nodes['Background'].inputs[0].default_value
@@ -1985,7 +1984,7 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 			o.contexts = []
 			
 			c = Object()
-			c.id = "blender"
+			c.id = "forward"
 			c.bind_constants = []
 			const1 = Object()
 			const1.id = "diffuseColor"
@@ -2086,9 +2085,12 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 				# Merge duplicates and sort
 				defs = sorted(list(set(defs)))
 				# Select correct shader variant
-				o.shader = "blender_resource/blender"
+				o.shader = "forward_resource/forward"
+				ext = ''
 				for d in defs:
-					o.shader += d
+					ext += d
+				o.shader += ext
+				ArmoryExporter.shader_references.append('forward' + ext)
 			else:
 				o.shader = material.custom_shader_name
 
@@ -2174,6 +2176,9 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 	def execute(self, context):
 		self.output = Object()
 
+		# Store used shaders in this scene
+		ArmoryExporter.shader_references = []
+
 		scene = context.scene
 
 		originalFrame = scene.frame_current
@@ -2233,15 +2238,15 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 
 
 def menu_func(self, context):
-	self.layout.operator(LueExporter.bl_idname, text = "Lue (.json)")
+	self.layout.operator(ArmoryExporter.bl_idname, text = "Armory (.json)")
 
 def register():
-	bpy.utils.register_class(LueExporter)
+	bpy.utils.register_class(ArmoryExporter)
 	bpy.types.INFO_MT_file_export.append(menu_func)
 
 def unregister():
 	bpy.types.INFO_MT_file_export.remove(menu_func)
-	bpy.utils.unregister_class(LueExporter)
+	bpy.utils.unregister_class(ArmoryExporter)
 
 if __name__ == "__main__":
 	register()

blender/plugin/cyclesgame.py

@@ -1,12 +1,11 @@
 # Cycles Game Engine
 # https://github.com/luboslenco/cyclesgame
-# cyclesgame.py 15.12.0
 bl_info = {
     "name": "Cycles Game",
     "category": "Game Engine",
     "description": "3D Game Engine built for Cycles",
     "author": "Lubos Lenco",
-    "version": (15, 12, 0, 0),
+    "version": (16, 1, 0, 0),
     "wiki_url": "http://cyclesgame.org/"
 }
 
@@ -87,7 +86,7 @@ def start_plugin():
 
     output = subprocess.check_output([haxelib_path + " path cyclesgame"], shell=True)
     output = str(output).split("\\n")[0].split("'")[1]
-    scripts_path = output + "blender/"
+    scripts_path = output[:-8] + "blender/" # Remove 'Sources/' from haxelib path
     
     sys.path.append(scripts_path)
     import start

blender/project.py

@@ -9,10 +9,11 @@ import subprocess
 import atexit
 import webbrowser
 import write_data
+from armory import ArmoryExporter
 
 def defaultSettings():
     wrd = bpy.data.worlds[0]
-    wrd['CGVersion'] = "15.12.0"
+    wrd['CGVersion'] = "16.1.0"
     wrd['CGProjectTarget'] = 0
     wrd['CGProjectName'] = "cycles_game"
     wrd['CGProjectPackage'] = "game"
@@ -125,9 +126,11 @@ def exportGameData():
             o.location.z = 0
 
     # Export scene data
+    shader_references = []
     for scene in bpy.data.scenes:
         if scene.name[0] != '.': # Skip hidden scenes
-            bpy.ops.export_scene.lue({"scene":scene}, filepath='Assets/' + scene.name + '.json')
+            bpy.ops.export_scene.armory({"scene":scene}, filepath='Assets/' + scene.name + '.json')
+            shader_references += ArmoryExporter.shader_references
 
     # Move armatures back
     for a in armatures:
@@ -136,7 +139,7 @@ def exportGameData():
         a.armature.location.z = a.z
     
     # Write khafile.js
-    write_data.write_khafilejs()
+    write_data.write_khafilejs(shader_references)
 
     # Write Main.hx
     write_data.write_main()
@@ -194,7 +197,7 @@ def buildProject(self, build_type=0):
 
     output = subprocess.check_output([haxelib_path + " path cyclesgame"], shell=True)
     output = str(output).split("\\n")[0].split("'")[1]
-    scripts_path = output + "blender/"
+    scripts_path = output[:-8] + "blender/"
 
     blender_path = bpy.app.binary_path
     blend_path = bpy.data.filepath

blender/start.py

@@ -1,6 +1,6 @@
 import project
 import nodes
-import scene
+import armory
 import traits_animation
 import traits
 import props
@@ -8,7 +8,7 @@ import props
 def register():
     project.register()
     nodes.register()
-    scene.register()
+    armory.register()
     traits_animation.register()
     traits.register()
     props.register()
@@ -16,7 +16,7 @@ def register():
 def unregister():
     project.unregister()
     nodes.unregister()
-    scene.unregister()
+    armory.unregister()
     traits_animation.unregister()
     traits.unregister()
     props.unregister()

blender/write_data.py

@@ -2,7 +2,7 @@ import bpy
 import os
 
 # Write khafile.js
-def write_khafilejs():
+def write_khafilejs(shader_references):
 	with open('khafile.js', 'w') as f:
 			f.write(
 """// Auto-generated
@@ -10,15 +10,18 @@ var project = new Project('""" + bpy.data.worlds[0]['CGProjectName'] + """');
 
 project.addSources('Sources');
 project.addShaders('Sources/Shaders/**');
-project.addAssets('Libraries/cyclesgame/Assets/**');
 project.addAssets('Assets/**');
-project.addLibrary('lue');
-project.addLibrary('cyclesgame');
-project.addLibrary('haxebullet');
 
-return project;
+project.addLibrary('cyclesgame');
+project.addAssets('Libraries/cyclesgame/Assets/**');
 """)
 
+			for ref in shader_references:
+				f.write("project.addShaders('Libraries/cyclesgame/compiled/Shaders/" + ref + ".frag.glsl');\n")
+				f.write("project.addShaders('Libraries/cyclesgame/compiled/Shaders/" + ref + ".vert.glsl');\n")
+
+			f.write("\nreturn project;")
+
 # Write Main.hx
 def write_main():
 	#if not os.path.isfile('Sources/Main.hx'):

compiled/Assets/deferred_pass_resource.json

@@ -0,0 +1,37 @@
+{
+    "shader_resources": [
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "always", 
+                    "constants": [], 
+                    "cull_mode": "none", 
+                    "depth_write": false, 
+                    "fragment_shader": "deferred_pass.frag", 
+                    "id": "deferred_pass", 
+                    "texture_units": [
+                        {
+                            "id": "gbuffer0"
+                        }, 
+                        {
+                            "id": "gbuffer1"
+                        }, 
+                        {
+                            "id": "gbuffer2"
+                        }
+                    ], 
+                    "vertex_shader": "deferred_pass.vert"
+                }
+            ], 
+            "id": "deferred_pass", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 2
+                }
+            ]
+        }
+    ]
+}

compiled/Assets/env_map_resource.json

@@ -0,0 +1,42 @@
+{
+    "shader_resources": [
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "always", 
+                    "constants": [
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }
+                    ], 
+                    "cull_mode": "none", 
+                    "depth_write": false, 
+                    "fragment_shader": "env_map.frag", 
+                    "id": "env_map", 
+                    "texture_units": [
+                        {
+                            "id": "envmap"
+                        }
+                    ], 
+                    "vertex_shader": "env_map.vert"
+                }
+            ], 
+            "id": "env_map", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 2
+                }
+            ]
+        }
+    ]
+}

compiled/Shaders/attrib_pass_Instancing.frag.glsl

@@ -0,0 +1,41 @@
+#define _Instancing
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_Instancing_NormalMapping.frag.glsl

@@ -0,0 +1,42 @@
+#define _Instancing
+#define _NormalMapping
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning.frag.glsl

@@ -0,0 +1,43 @@
+#define _Instancing
+#define _NormalMapping
+#define _Skinning
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning_Texturing.frag.glsl

@@ -0,0 +1,44 @@
+#define _Instancing
+#define _NormalMapping
+#define _Skinning
+#define _Texturing
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning_Texturing_VCols.frag.glsl

@@ -0,0 +1,45 @@
+#define _Instancing
+#define _NormalMapping
+#define _Skinning
+#define _Texturing
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning_VCols.frag.glsl

@@ -0,0 +1,44 @@
+#define _Instancing
+#define _NormalMapping
+#define _Skinning
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_Instancing_NormalMapping_Texturing.frag.glsl

@@ -0,0 +1,43 @@
+#define _Instancing
+#define _NormalMapping
+#define _Texturing
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_Instancing_NormalMapping_Texturing_VCols.frag.glsl

@@ -0,0 +1,44 @@
+#define _Instancing
+#define _NormalMapping
+#define _Texturing
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_Instancing_NormalMapping_VCols.frag.glsl

@@ -0,0 +1,43 @@
+#define _Instancing
+#define _NormalMapping
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_Instancing_Skinning.frag.glsl

@@ -0,0 +1,42 @@
+#define _Instancing
+#define _Skinning
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_Instancing_Skinning_Texturing.frag.glsl

@@ -0,0 +1,43 @@
+#define _Instancing
+#define _Skinning
+#define _Texturing
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_Instancing_Skinning_Texturing_VCols.frag.glsl

@@ -0,0 +1,44 @@
+#define _Instancing
+#define _Skinning
+#define _Texturing
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_Instancing_Skinning_VCols.frag.glsl

@@ -0,0 +1,43 @@
+#define _Instancing
+#define _Skinning
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_Instancing_Texturing.frag.glsl

@@ -0,0 +1,42 @@
+#define _Instancing
+#define _Texturing
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_Instancing_Texturing_VCols.frag.glsl

@@ -0,0 +1,43 @@
+#define _Instancing
+#define _Texturing
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_Instancing_VCols.frag.glsl

@@ -0,0 +1,42 @@
+#define _Instancing
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_NormalMapping.frag.glsl

@@ -0,0 +1,41 @@
+#define _NormalMapping
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_NormalMapping_Skinning.frag.glsl

@@ -0,0 +1,42 @@
+#define _NormalMapping
+#define _Skinning
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_NormalMapping_Skinning_Texturing.frag.glsl

@@ -0,0 +1,43 @@
+#define _NormalMapping
+#define _Skinning
+#define _Texturing
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_NormalMapping_Skinning_Texturing_VCols.frag.glsl

@@ -0,0 +1,44 @@
+#define _NormalMapping
+#define _Skinning
+#define _Texturing
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_NormalMapping_Skinning_VCols.frag.glsl

@@ -0,0 +1,43 @@
+#define _NormalMapping
+#define _Skinning
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_NormalMapping_Texturing.frag.glsl

@@ -0,0 +1,42 @@
+#define _NormalMapping
+#define _Texturing
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_NormalMapping_Texturing_VCols.frag.glsl

@@ -0,0 +1,43 @@
+#define _NormalMapping
+#define _Texturing
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_NormalMapping_VCols.frag.glsl

@@ -0,0 +1,42 @@
+#define _NormalMapping
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_Skinning.frag.glsl

@@ -0,0 +1,41 @@
+#define _Skinning
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_Skinning_Texturing.frag.glsl

@@ -0,0 +1,42 @@
+#define _Skinning
+#define _Texturing
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_Skinning_Texturing_VCols.frag.glsl

@@ -0,0 +1,43 @@
+#define _Skinning
+#define _Texturing
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_Skinning_VCols.frag.glsl

@@ -0,0 +1,42 @@
+#define _Skinning
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_Texturing.frag.glsl

@@ -0,0 +1,41 @@
+#define _Texturing
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_Texturing_VCols.frag.glsl

@@ -0,0 +1,42 @@
+#define _Texturing
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}

compiled/Shaders/attrib_pass_VCols.frag.glsl

@@ -0,0 +1,41 @@
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}