(function() {
var state = new State(new ShaderGeneratorProxy());
var fakeRenderer = mockup.createFakeRenderer();
fakeRenderer.validateProgram = function() {
return true;
};
fakeRenderer.getProgramParameter = function() {
return true;
};
fakeRenderer.isContextLost = function() {
return false;
};
state.setGraphicContext(fakeRenderer);
var stateSet0 = new StateSet();
stateSet0.setAttributeAndModes(new Material());
var stateSet1 = new StateSet();
stateSet1.setTextureAttributeAndModes(0, new Texture(undefined));
state.pushStateSet(stateSet0);
state.applyStateSet(stateSet1);
assert.isOk(true, 'check not exception on material generator use');
})();
(function() {
var state = new State(new ShaderGeneratorProxy());
var fakeRenderer = mockup.createFakeRenderer();
fakeRenderer.validateProgram = function() {
return true;
};
fakeRenderer.getProgramParameter = function() {
return true;
};
fakeRenderer.isContextLost = function() {
return false;
};
state.setGraphicContext(fakeRenderer);
var stateSet = new StateSet();
function getShader() {
var vertexshader = [
'',
'attribute vec3 Vertex;',
'varying vec4 position;',
'void main(void) {',
' gl_Position = vec4(Vertex,1.0);',
'}'
].join('\n');
var fragmentshader = [
'',
'precision highp float;',
'varying vec4 position;',
'void main(void) {',
' gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);',
'}',
''
].join('\n');
var program = new Program(
new Shader('VERTEX_SHADER', vertexshader),
new Shader('FRAGMENT_SHADER', fragmentshader)
);
program.setTrackAttributes({});
program.getTrackAttributes().attributeKeys = [];
return program;
}
stateSet.setAttributeAndModes(getShader());
state.applyStateSet(stateSet);
assert.isOk(true, 'check not exception on stateset generator use');
})();
_buildPass: function(index, passes) {
var pass = passes[index];
var passName = pass.out.name;
this._setOrCreateTextureKey(this._usages[passName], passName, pass.out);
var feedbackName = pass.out.name + 'FeedbackTexture';
if (pass.feedbackLoop) {
this._setOrCreateTextureKey(this._usages[feedbackName], feedbackName, pass.out);
}
// internal pass (user texture)
if (!pass.funcs.length) {
var key = this._textures[passName].key;
this._userTextures[passName] = this._texturePool[key].texture;
return;
}
var stateSet = new StateSet();
this._addStateSet(pass, stateSet);
var i;
for (i = 0; i < pass.uniforms.length; i++) {
stateSet.addUniform(pass.uniforms[i]);
}
var uniforms = [];
var previousTextureUnit = undefined;
for (i = 0; i < pass.textures.length; i++) {
var texInfo = pass.textures[i];
var isFeedback = texInfo.name === feedbackName;
if (!isFeedback && !this._externalTextures[texInfo.name]) {
var poolKey = this._textures[texInfo.name].key;
this._texturePool[poolKey].usage--;
}
var unit = this._addTextureToStateSet(texInfo, stateSet, i, uniforms, isFeedback);
if (unit !== undefined) {
previousTextureUnit = unit;
}
if (this._feedbackData[texInfo.name] === undefined) {
continue;
}
var nextPass = {
stateSet: stateSet,
textureUnit: i
};
this._feedbackData[texInfo.name].nextPasses.push(nextPass);
}
var outputTexture = undefined;
if (index !== passes.length - 1) {
var outputKey = this._textures[passName].key;
outputTexture = this._texturePool[outputKey].texture;
}
this._addTextureUniforms('TextureOutput', outputTexture, stateSet, uniforms);
stateSet.setAttributeAndModes(this._createProgram(pass, uniforms));
if (pass.feedbackLoop) {
this._feedbackData[passName] = this._createFeedbackLoopCameras(
passName,
stateSet,
outputTexture,
previousTextureUnit
);
} else {
this.addChild(this._createCamera(passName, stateSet, outputTexture));
}
},
loadMaterials: function() {
var materials = this._gltfJSON.materials;
var hasTransparentMaterial = false;
var hasDoubleSidedMaterial = false;
var rootStateSet = this._rootStateSet;
rootStateSet.addUniform(
Uniform.createInt(
ReaderWriterGLTF.EMISSIVE_TEXTURE_UNIT,
ReaderWriterGLTF.EMISSIVE_UNIFORM
)
);
rootStateSet.addUniform(
Uniform.createInt(ReaderWriterGLTF.AO_TEXTURE_UNIT, ReaderWriterGLTF.AO_UNIFORM)
);
rootStateSet.addUniform(
Uniform.createInt(ReaderWriterGLTF.NORMAL_TEXTURE_UNIT, ReaderWriterGLTF.NORMAL_UNIFORM)
);
rootStateSet.addUniform(Uniform.createFloat3(vec3.ZERO, 'uEmissiveFactor'));
for (var i = 0; i < materials.length; i++) {
var material = materials[i];
var stateSet = new StateSet();
var osgjsTexture;
material.osgjsStateSet = stateSet;
if (material.pbrMetallicRoughness) {
this._pbrMetallicRoughness(material.pbrMetallicRoughness, stateSet);
} else if (material.extensions.KHR_materials_pbrSpecularGlossiness) {
// https://github.com/KhronosGroup/glTF/blob/master/extensions/Khronos/KHR_materials_pbrSpecularGlossiness/README.md
this._KHR_materials_pbrSpecularGlossiness(
material.extensions.KHR_materials_pbrSpecularGlossiness,
stateSet
);
}
if (material.normalTexture) {
osgjsTexture = this._texture(material.normalTexture);
stateSet.setTextureAttributeAndModes(
ReaderWriterGLTF.NORMAL_TEXTURE_UNIT,
osgjsTexture
);
}
if (material.occlusionTexture) {
osgjsTexture = this._texture(material.occlusionTexture);
stateSet.setTextureAttributeAndModes(
ReaderWriterGLTF.AO_TEXTURE_UNIT,
osgjsTexture
);
}
if (material.emissiveTexture) {
osgjsTexture = this._texture(material.emissiveTexture);
stateSet.setTextureAttributeAndModes(
ReaderWriterGLTF.EMISSIVE_TEXTURE_UNIT,
osgjsTexture
);
}
if (material.emissiveFactor) {
stateSet.addUniform(
Uniform.createFloat3(material.emissiveFactor, 'uEmissiveFactor')
);
}
if (material.alphaMode === 'BLEND') {
hasTransparentMaterial = true;
stateSet.setAttributeAndModes(this._transparentBlendFunc);
stateSet.setRenderingHint('TRANSPARENT_BIN');
}
if (material.doubleSided) {
hasDoubleSidedMaterial = true;
stateSet.setAttributeAndModes(this._doubleSideCullFace);
}
}
// need to add a default blend func if we have transparent materials in the model
if (hasTransparentMaterial) {
rootStateSet.setAttributeAndModes(this._defaultBlendFunc);
}
if (hasDoubleSidedMaterial) {
rootStateSet.setAttributeAndModes(this._defaultCullFace);
}
},