/* <copyright>
Copyright (c) 2012, Motorola Mobility, Inc
All Rights Reserved.
BSD License.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of Motorola Mobility nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
</copyright> */
var MaterialParser = require("js/lib/rdge/materials/material-parser").MaterialParser;
var Material = require("js/lib/rdge/materials/material").Material;
var Texture = require("js/lib/rdge/texture").Texture;
var UberMaterial = function UberMaterial() {
///////////////////////////////////////////////////////////////////////
// Instance variables
///////////////////////////////////////////////////////////////////////
this._name = "Uber";
this._shaderName = "uber";
this.getShaderName = function () { return this._shaderName; };
// set some default values
this._ambientColor = [0.0, 0.0, 0.0, 1.0];
this._diffuseColor = [1.0, 1.0, 1.0, 1.0];
this._specularColor = [1.0, 1.0, 1.0, 1.0];
this._specularPower = 32.0;
this._environmentAmount = 0.2; // 0 .. 1
// set the default maps
this._diffuseMapOb = { 'texture' : 'assets/images/rocky-diffuse.jpg', 'wrap' : 'REPEAT' };
//this._diffuseMapOb = { 'texture' : 'texture', 'wrap' : 'REPEAT' };
this._normalMapOb = { 'texture': 'assets/images/rocky-normal.jpg', 'wrap': 'REPEAT' };
this._specularMapOb = { 'texture': 'assets/images/rocky-spec.jpg', 'wrap': 'REPEAT' };
this._environmentMapOb = { 'texture': 'assets/images/silver.png', 'wrap': 'CLAMP', 'envReflection': this._environmentAmount };
this._useDiffuseMap = true;
this._useNormalMap = true;
this._useSpecularMap = true;
this._useEnvironmentMap = true;
this._useLights = [true, true, true, true];
// these are the abstracted texture objects - defined where they are set
this._diffuseTexture;
this._MAX_LIGHTS = 4;
// array textures indexed by shader uniform name
this._glTextures = [];
///////////////////////////////////////////////////////////////////////
// Material Property Accessors
///////////////////////////////////////////////////////////////////////
this._propNames = ["ambientColor", "diffuseColor", "specularColor", "specularPower", "diffuseMap", "normalMap", "specularMap", "environmentMap", "environmentAmount"];
this._propLabels = ["Ambient Color", "Diffuse Color", "Specular Color", "Specular Power", "Texture Map", "Bump Map", "Specular Map", "Environment Map", "Environment Map Amount"];
this._propTypes = ["color", "color", "color", "float", "file", "file", "file", "file", "float"];
this._propValues = [];
this._propValues[this._propNames[0]] = this._ambientColor.slice(0);
this._propValues[this._propNames[1]] = this._diffuseColor.slice(0);
this._propValues[this._propNames[2]] = this._specularColor.slice(0);
this._propValues[this._propNames[3]] = this._specularPower;
this._propValues[this._propNames[4]] = this._diffuseMapOb['texture'];
this._propValues[this._propNames[5]] = this._normalMapOb['texture'];
this._propValues[this._propNames[6]] = this._specularMapOb['texture'];
this._propValues[this._propNames[7]] = this._environmentMapOb['texture'];
this._propValues[this._propNames[8]] = this._environmentMapOb['envReflection'];
this.setProperty = function (prop, value) {
if (prop == "color") prop = "ambientColor";
var valid = this.validateProperty(prop, value);
if (valid) {
this._propValues[prop] = value;
switch (prop) {
case "diffuseMap":
this.updateDiffuseMap();
break;
case "normalMap":
this.updateNormalMap();
break;
case "specularMap":
this.updateSpecularMap();
break;
case "environmentMap":
this.updateEnvironmentMap();
break;
case "environmentAmount":
this.updateEnvironmentAmount(value);
break;
case "specularPower":
this.updateSpecularPower(value);
break;
case "ambientColor":
this.updateAmbientColor(value);
break;
case "diffuseColor":
this.updateDiffuseColor(value);
break;
case "specularColor":
this.updateSpecularColor(value);
break;
}
}
};
this.hasProperty = function( prop )
{
if(prop === "color") return true;
var propNames = [], dummy = [];
this.getAllProperties( propNames, dummy, dummy, dummy )
for (var i=0; i<propNames.length; i++)
{
if (prop === propNames[i]) return true;
}
};
///////////////////////////////////////////////////////////////////////
// define the 4 lights
this._lights = [
{
'type': 'point', // can be 'directional', 'point' or 'spot'
'spotInnerCutoff': 14.0, // fragments in the inner cutoff 'cone' are full intensity.
'spotOuterCutoff': 15.0, // fragments outside the outer cutoff 'cone' are unlit.
'position': [8.0, 2.0, 8.0], // light position; ignored for directional lights
'direction': [-1.0, -1.0, -1.0], // light direction; ignored for point lights
'attenuation': [1.0, 0.025, 0.00125], // light attenuation; constant, linear, quadratic
'diffuseColor': [1.0, 0.5, 0.5, 1.0], // diffuse light color
'specularColor': [1.0, 1.0, 1.0, 1.0] // specular light color
},
{
'type': 'point',
'spotInnerCutoff': 9.0,
'spotOuterCutoff': 20.0,
'position': [-8.0, 2.0, 8.0],
'direction': [1.0, -1.0, -1.0],
'attenuation': [1.0, 0.025, 0.00125],
'diffuseColor': [0.5, 1.0, 0.5, 1.0],
'specularColor': [1.0, 1.0, 1.0, 1.0]
},
{
'type': 'point',
'spotInnerCutoff': 9.0,
'spotOuterCutoff': 20.0,
'position': [-8.0, 2.0, -8.0],
'direction': [1.0, -1.0, 1.0],
'attenuation': [1.0, 0.25, 0.0125],
'diffuseColor': [0.5, 0.5, 1.0, 1.0],
'specularColor': [1.0, 1.0, 1.0, 1.0]
},
{
'type': 'point',
'spotInnerCutoff': 9.0,
'spotOuterCutoff': 20.0,
'position': [8.0, 4.0, -8.0],
'direction': [-1.0, -1.0, 1.0],
'attenuation': [1.0, 0.25, 0.0125],
'diffuseColor': [1.0, 1.0, 0.5, 1.0],
'specularColor': [1.0, 1.0, 1.0, 1.0]
}
];
this._ubershaderCaps =
{
// ubershader material properties.
'material': {
'ambientColor': this._ambientColor, // material ambient color
'diffuseColor': this._diffuseColor, // material diffuse color
'specularColor': this._specularColor, // material specular color
'specularPower': this._specularPower // material specular power (shininess)
},
// ubershader supports up to four lights.
'lighting': {
'light0': this._lights[0],
'light1': this._lights[1],
'light2': this._lights[2],
'light3': this._lights[3]
},
// uvTransform can be used to scale or offset the texture coordinates.
'uvTransform': [2.0, 0, 0, 0, 0, 2.0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 1],
// optional diffuse map
'diffuseMap': this._diffuseMapOb,
// optional normal map
'normalMap': this._normalMapOb,
// optional specular map
'specularMap': this._specularMapOb,
// optional environment map
'environmentMap': this._environmentMapOb
};
this.updateAmbientColor = function () {
this._ambientColor = this._propValues['ambientColor'].slice(0);
var material = this._materialNode;
//console.log( "ambient color: " + this._ambientColor );
if (material) {
var technique = material.shaderProgram.defaultTechnique;
technique.u_ambientColor.set(this._ambientColor);
}
};
this.updateDiffuseColor = function () {
this._diffuseColor = this._propValues['diffuseColor'].slice(0);
var material = this._materialNode;
if (material) {
var technique = material.shaderProgram.defaultTechnique;
technique.u_diffuseColor.set(this._diffuseColor);
this.getWorld().restartRenderLoop();
}
};
this.updateSpecularColor = function (value) {
this._specularColor = this._propValues['specularColor'];
var material = this._materialNode;
if (material) {
var technique = material.shaderProgram.defaultTechnique;
technique.u_specularColor.set(this._specularColor);
}
};
this.updateSpecularPower = function (value) {
this._specularPower = this._propValues['specularPower'];
var material = this._materialNode;
if (material) {
var technique = material.shaderProgram.defaultTechnique;
technique.u_specularPower.set([this._specularPower]);
}
};
this.updateEnvironmentAmount = function (value) {
this._environmentMapOb.envReflectionAmount = value;
var material = this._materialNode;
if (material) {
var technique = material.shaderProgram.defaultTechnique;
technique.u_envReflection.set([this._environmentMapOb.envReflection]);
}
};
this.updateEnvironmentMap = function () {
var value = this._propValues["environmentMap"];
this._environmentMapOb.texture = value;
if ((value == null) || (value.length == 0)) {
if (this._useEnvironmentMap) {
this._useEnvironmentMap = false;
this.rebuildShader();
}
} else {
if (!this._useEnvironmentMap) {
this._useEnvironmentMap = true;
this.rebuildShader();
} else {
var material = this._materialNode;
if (material) {
var technique = material.shaderProgram.defaultTechnique;
var renderer = RDGE.globals.engine.getContext().renderer;
if (renderer && technique) {
var tex = renderer.getTextureByName(value, this._ubershaderCaps.environmentMap.wrap);
this.registerTexture(tex);
technique.s_envMap.set(tex);
}
}
}
}
};
this.updateDiffuseMap = function(value) {
var value = this._propValues[ "diffuseMap" ];
this._diffuseMapOb.texture = value;
if ((value == null) || (value.length == 0)) {
if (this._useDiffuseMap) {
this._useDiffuseMap = false;
this._diffuseTexture = undefined;
this.rebuildShader();
}
} else {
if (!this._useDiffuseMap) {
this._useDiffuseMap = true;
this.rebuildShader();
} else {
var material = this._materialNode;
if (material) {
var technique = material.shaderProgram.defaultTechnique;
var renderer = RDGE.globals.engine.getContext().renderer;
if (renderer && technique) {
this._diffuseTexture = new Texture( this.getWorld(), value, this._ubershaderCaps.diffuseMap.wrap );
var tex = this._diffuseTexture.getTexture();
technique.s_diffuseMap.set( tex );
}
}
}
}
};
this.updateSpecularMap = function () {
var value = this._propValues["specularMap"];
this._specularMapOb.texture = value;
if ((value == null) || (value.length == 0)) {
if (this._useSpecularMap) {
this._useSpecularMap = false;
this.rebuildShader();
}
} else {
if (!this._useSpecularMap) {
this._useSpecularMap = true;
this.rebuildShader();
} else {
var material = this._materialNode;
if (material) {
var technique = material.shaderProgram.defaultTechnique;
var renderer = RDGE.globals.engine.getContext().renderer;
if (renderer && technique) {
var tex = renderer.getTextureByName(value, this._ubershaderCaps.specularMap.wrap);
this.registerTexture(tex);
technique.s_specMap.set(tex);
}
}
}
}
};
this.updateNormalMap = function (value) {
var value = this._propValues["normalMap"];
this._normalMapOb.texture = value;
if ((value == null) || (value.length == 0)) {
if (this._useNormalMap) {
this._useNormalMap = false;
this.rebuildShader();
}
} else {
if (!this._useNormalMap) {
this._useNormalMap = true;
this.rebuildShader();
} else {
var material = this._materialNode;
if (material) {
var technique = material.shaderProgram.defaultTechnique;
var renderer = RDGE.globals.engine.getContext().renderer;
if (renderer && technique) {
var tex = renderer.getTextureByName(value, this._ubershaderCaps.normalMap.wrap);
this.registerTexture(tex);
technique.s_normalMap.set(tex);
}
}
}
}
};
// duplcate method requirde
this.dup = function () {
// get the current values;
var propNames = [], propValues = [], propTypes = [], propLabels = [];
this.getAllProperties(propNames, propValues, propTypes, propLabels);
// allocate a new material
var newMat = new UberMaterial();
newMat._useDiffuseMap = this._useDiffuseMap;
newMat._useEnvironmentMap = this._useEnvironmentMap;
newMat._useLights = this._useLights;
newMat._useNormalMap = this._useNormalMap;
newMat._useSpecularMap = this._useSpecularMap;
// copy over the current values;
var n = propNames.length;
for (var i = 0; i < n; i++)
newMat.setProperty(propNames[i], propValues[i]);
newMat.rebuildShader();
return newMat;
};
this.init = function (world) {
// save the world
if (world) this.setWorld(world);
// set up the shader
this._shader = this.buildUberShader(this._ubershaderCaps);
// set up the material node
this._materialNode = RDGE.createMaterialNode("uberMaterial" + "_" + world.generateUniqueNodeID());
this._materialNode.setShader(this._shader);
};
this.update = function()
{
var material = this._materialNode;
if (material)
{
var technique = material.shaderProgram.defaultTechnique;
var renderer = RDGE.globals.engine.getContext().renderer;
if (renderer && technique)
{
if (this._diffuseTexture && this._diffuseTexture.isAnimated())
{
this._diffuseTexture.render();
technique.s_diffuseMap.set( this._diffuseTexture.getTexture() );
}
}
}
}
this.isAnimated = function()
{
var anim = (this._diffuseTexture && this._diffuseTexture.isAnimated());
return anim;
}
this.importJSON = function (jObj)
{
if (this.getShaderName() != jObj.material) throw new Error("ill-formed material");
this.setName(jObj.name);
if (jObj.materialProps) {
var ambientColor = jObj.materialProps.ambientColor; this.setProperty("ambientColor", ambientColor);
var diffuseColor = jObj.materialProps.diffuseColor; this.setProperty("diffuseColor", diffuseColor);
var specularColor = jObj.materialProps.specularColor; this.setProperty("specularColor", specularColor);
var specularPower = jObj.materialProps.specularPower; this.setProperty("specularPower", specularPower);
}
var lightArray = jObj.lights;
if (lightArray) {
this._lights = [];
for (var i = 0; i < this._MAX_LIGHTS; i++) {
var lightObj = lightArray[i];
if (lightObj) {
var type = lightObj['light' + i];
if (type) {
var light = new Object;
switch (type) {
case "directional":
light.direction = lightObj['light' + i + 'Dir'];
break;
case "spot":
light.position = lightObj['light' + i + 'Pos'];
light['spotInnerCutoff'] = lightObj['light' + i + 'OuterSpotCutoff'];
light['spotOuterCutoff'] = lightObj['light' + i + 'InnerSpotCutoff'];
break;
case "point":
light.position = lightObj['light' + i + 'Pos'];
light.attenuation = lightObj['light' + i + 'Attenuation'];
break;
default:
throw new Error("unrecognized light type on import: " + type);
break;
}
// common to all lights
light.diffuseColor = lightObj['light' + i + 'Color'];
light.specularColor = lightObj['light' + i + 'SpecularColor'];
// push the light
this._lights.push(light);
}
else
this._lights[i] = 'undefined';
}
}
if (this._lights.length > 0) {
this._ubershaderCaps.lighting =
{
'light0': this._lights[0],
'light1': this._lights[1],
'light2': this._lights[2],
'light3': this._lights[3]
}
}
}
var diffuseMap = jObj['diffuseMap'];
if (diffuseMap) {
this.setProperty("diffuseMap", diffuseMap);
}
var normalMap = jObj['normalMap'];
if (normalMap) {
this.setProperty("normalMap", normalMap);
}
var specularMap = jObj['specularMap'];
if (specularMap) {
this.setProperty("specularMap", specularMap);
}
var environmentMap = jObj['environmentMap'];
if (environmentMap) {
this.setProperty("environmentMap", environmentMap);
this.setProperty("environmentAmount", jObj['environmentAmount']);
}
this.rebuildShader();
};
this.exportJSON = function () {
// every material needs the base type and instance name
var caps = this._ubershaderCaps;
var jObj =
{
'material': this.getShaderName(),
'name': this.getName()
};
// export the material properties
if (typeof caps.material != 'undefined') {
jObj.materialProps =
{
'ambientColor': this._ambientColor,
'diffuseColor': this._diffuseColor,
'specularColor': this._specularColor,
'specularPower': this._specularPower
};
}
if (typeof caps.lighting != 'undefined') {
var lightArray = [];
for (var i = 0; i < this._MAX_LIGHTS; i++) {
var light = caps.lighting["light" + i];
if (typeof light != "undefined") {
var lightObj = {}
lightObj['light' + i] = light.type;
// output the light secific data
if (light.type === 'directional') {
lightObj['light' + i + 'Dir'] = light['direction'];
}
else if (light.type === 'spot') {
lightObj['light' + i + 'Pos'] = light['position'];
lightObj['light' + i + 'SpotInnerCutoff'] = light['spotInnerCutoff'];
lightObj['light' + i + 'SpotOuterCutoff'] = light['spotOuterCutoff'];
}
else // light.type === 'point'
{
lightObj['light' + i + 'Pos'] = (light['position'] || [0, 0, 0]);
lightObj['light' + i + 'Attenuation'] = (light['attenuation'] || [1, 0, 0]);
}
// common to all lights
lightObj['light' + i + 'Color'] = (light['diffuseColor'] || [1, 1, 1, 1]);
lightObj['light' + i + 'SpecularColor'] = (light['specularColor'] || [1, 1, 1, 1]);
lightArray.push(lightObj);
}
}
if (lightArray.length > 0)
jObj.lights = lightArray;
}
if (typeof caps.diffuseMap != 'undefined') {
jObj['diffuseMap'] = caps.diffuseMap.texture;
}
if (typeof caps.normalMap != 'undefined') {
jObj['normalMap'] = caps.normalMap.texture;
}
if (typeof caps.specularMap != 'undefined') {
jObj['specularMap'] = caps.specularMap.texture;
}
if (typeof caps.environmentMap != 'undefined') {
jObj['environmentMap'] = caps.environmentMap.texture;
jObj['environmentAmount'] = caps.environmentMap.envReflection;
}
return jObj;
};
this.buildUberShader = function (caps) {
var preproc = "";
var paramBlock = {};
paramBlock['u_uvMatrix'] = { 'type': 'mat4' };
if (typeof caps.material != 'undefined') {
preproc += '#define MATERIAL\n';
paramBlock['u_ambientColor'] = { 'type': 'vec4' };
paramBlock['u_diffuseColor'] = { 'type': 'vec4' };
paramBlock['u_specularColor'] = { 'type': 'vec4' };
paramBlock['u_specularPower'] = { 'type': 'float' };
}
if (typeof caps.lighting != 'undefined') {
preproc += '#define LIGHTING\n';
preproc += '#define SPECULAR\n';
for (var i = 0; i < 4; ++i) {
var light = caps.lighting['light' + i];
var t;
if (typeof light != 'undefined') {
switch (light.type) {
case 'directional': t = 0; break;
case 'point': t = 1; break;
case 'spot': t = 2; break;
}
preproc += '#define LIGHT_' + i + ' ' + t + '\n';
preproc += '#define LIGHT_' + i + '_SPECULAR\n';
if (t == 0 || t == 2) {
paramBlock['u_light' + i + 'Dir'] = { 'type': 'vec3' };
}
if (t == 2) {
paramBlock['u_light' + i + 'Spot'] = { 'type': 'vec2' };
}
paramBlock['u_light' + i + 'Pos'] = { 'type': 'vec3' };
paramBlock['u_light' + i + 'Color'] = { 'type': 'vec4' };
paramBlock['u_light' + i + 'Atten'] = { 'type': 'vec3' };
paramBlock['u_light' + i + 'Specular'] = { 'type': 'vec4' };
}
}
}
if (typeof caps.diffuseMap != 'undefined') {
preproc += '#define DIFFUSE_MAP\n';
paramBlock['s_diffuseMap'] = { 'type': 'tex2d' };
}
if (typeof caps.normalMap != 'undefined') {
preproc += '#define NORMAL_MAP\n';
paramBlock['s_normalMap'] = { 'type': 'tex2d' };
}
if (typeof caps.specularMap != 'undefined') {
preproc += '#define SPECULAR_MAP\n';
paramBlock['s_specMap'] = { 'type': 'tex2d' };
}
if (typeof caps.environmentMap != 'undefined') {
preproc += '#define ENVIRONMENT_MAP\n';
paramBlock['s_envMap'] = { 'type': 'tex2d' };
paramBlock['u_envReflection'] = { 'type': 'float' };
}
// load the shaders as text
var uberVShader, uberFShader;
var r = new XMLHttpRequest();
r.open('GET', "assets/shaders/ub_vshader.glsl", false);
r.send(null);
if (r.status == 200) {
uberVShader = r.responseText;
}
r.open('GET', "assets/shaders/ub_fshader.glsl", false);
r.send(null);
if (r.status == 200) {
uberFShader = r.responseText;
}
// prefix preprocessor settings
var vshader = preproc + uberVShader;
var fshader = preproc + uberFShader;
// build output jshader
var uberJShader = new RDGE.jshader();
uberJShader.def = {
'shaders': {
'defaultVShader': vshader,
'defaultFShader': fshader
},
'techniques': {
'defaultTechnique': [{
'vshader': 'defaultVShader',
'fshader': 'defaultFShader',
'attributes': {
'a_pos': { 'type': 'vec3' },
'a_normal': { 'type': 'vec3' },
'a_texcoord': { 'type': 'vec2' }
},
'params': paramBlock,
'states': {
'depthEnable': true,
'blendEnable': false,
'culling': true,
'cullFace': "FRONT"
}
}]
}
};
// initialize the jshader
try {
uberJShader.init();
}
catch (e) {
console.log("error initializing the uber shader: " + e);
}
// initialize shader parameters
var technique = uberJShader.defaultTechnique;
if (typeof caps.material != 'undefined') {
technique.u_ambientColor.set(caps.material.ambientColor);
technique.u_diffuseColor.set(caps.material.diffuseColor);
technique.u_specularColor.set(caps.material.specularColor);
technique.u_specularPower.set([caps.material.specularPower]);
}
if (typeof caps.lighting != 'undefined') {
for (i = 0; i < 4; ++i) {
var light = caps.lighting["light" + i];
if (typeof light != "undefined") {
if (light.type == 'directional') {
paramBlock['u_light' + i + 'Dir'] = { 'type': 'vec3' };
technique['u_light' + i + 'Dir'].set(light['direction'] || [0, 0, 1]);
} else if (light.type == 'spot') {
paramBlock['u_light' + i + 'Spot'] = { 'type': 'vec2' };
technique['u_light' + i + 'Pos'].set(light['position'] || [0, 0, 0]);
var deg2Rad = Math.PI / 180;
technique['u_light' + i + 'Spot'].set([Math.cos((light['spotInnerCutoff'] || 45.0) * deg2Rad),
Math.cos((light['spotOuterCutoff'] || 90.0) * deg2Rad)]);
technique['u_light' + i + 'Atten'].set(light['attenuation'] || [1, 0, 0]);
} else {
technique['u_light' + i + 'Pos'].set(light['position'] || [0, 0, 0]);
technique['u_light' + i + 'Atten'].set(light['attenuation'] || [1, 0, 0]);
}
technique['u_light' + i + 'Color'].set(light['diffuseColor'] || [1, 1, 1, 1]);
technique['u_light' + i + 'Specular'].set(light['specularColor'] || [1, 1, 1, 1]);
}
}
}
technique.u_uvMatrix.set(caps.uvTransform || RDGE.mat4.identity());
var renderer = RDGE.globals.engine.getContext().renderer;
if (this._useDiffuseMap) {
this._diffuseTexture = new Texture( this.getWorld(), caps.diffuseMap.texture, caps.diffuseMap.wrap, caps.diffuseMap.mips );
var tex = this._diffuseTexture.getTexture();
technique.s_diffuseMap.set( tex );
}
if (this._useNormalMap) {
var tex = renderer.getTextureByName(caps.normalMap.texture, caps.normalMap.wrap, caps.normalMap.mips);
this.registerTexture(tex);
technique.s_normalMap.set(tex);
}
if (this._useSpecularMap) {
var tex = renderer.getTextureByName(caps.specularMap.texture, caps.specularMap.wrap);
this.registerTexture(tex);
technique.s_specMap.set(tex);
}
if (this._useEnvironmentMap) {
var tex = renderer.getTextureByName(caps.environmentMap.texture, caps.environmentMap.wrap);
this.registerTexture(tex);
technique.s_envMap.set(tex);
technique.u_envReflection.set([caps.environmentMap.envReflection || 1.0]);
}
return uberJShader;
};
this.rebuildShader = function () {
this._ubershaderCaps['material']['ambientColor'] = this._ambientColor;
this._ubershaderCaps['material']['diffuseColor'] = this._diffuseColor;
this._ubershaderCaps['material']['specularColor'] = this._specularColor;
this._ubershaderCaps['material']['specularPower'] = this._specularPower;
var useDiffuse = this._useDiffuseMap;
if (!useDiffuse) {
if (typeof this._ubershaderCaps['diffuseMap'] != 'undefined') {
delete this._ubershaderCaps['diffuseMap'];
}
} else {
this._ubershaderCaps['diffuseMap'] = this._diffuseMapOb;
}
var useNormal = this._useNormalMap;
if (!useNormal) {
if (typeof this._ubershaderCaps['normalMap'] != 'undefined') {
delete this._ubershaderCaps['normalMap'];
}
} else {
this._ubershaderCaps['normalMap'] = this._normalMapOb;
}
var useSpecular = this._useSpecularMap;
if (!useSpecular) {
if (typeof this._ubershaderCaps['specularMap'] != 'undefined') {
delete this._ubershaderCaps['specularMap'];
}
} else {
this._ubershaderCaps['specularMap'] = this._specularMapOb;
}
var useEnvironment = this._useEnvironmentMap;
if (!useEnvironment) {
if (typeof this._ubershaderCaps['environmentMap'] != 'undefined') {
delete this._ubershaderCaps['environmentMap'];
}
} else {
this._ubershaderCaps['environmentMap'] = this._environmentMapOb;
}
for (i = 0; i < 4; ++i) {
var useLight = this._useLights[i];
if (!useLight) {
if (typeof this._ubershaderCaps['lighting']['light' + i] != 'undefined') {
delete this._ubershaderCaps['lighting']['light' + i];
}
} else {
this._ubershaderCaps['lighting']['light' + i] = this._lights[i];
}
}
var material = this._materialNode;
if (material) {
material.setShader( this.buildUberShader(this._ubershaderCaps) );
}
};
};
UberMaterial.prototype = new Material();
if (typeof exports === "object") {
exports.UberMaterial = UberMaterial;
}