import {
|
AlphaMode,
|
AttributeType,
|
CustomShader,
|
CustomShaderPipelineStage,
|
LightingModel,
|
ModelAlphaOptions,
|
ModelLightingOptions,
|
Pass,
|
ShaderBuilder,
|
UniformType,
|
VaryingType,
|
_shadersCustomShaderStageVS,
|
_shadersCustomShaderStageFS,
|
} from "../../../Source/Cesium.js";
|
import ShaderBuilderTester from "../../ShaderBuilderTester.js";
|
|
describe("Scene/ModelExperimental/CustomShaderPipelineStage", function () {
|
var primitive = {
|
attributes: [
|
{
|
semantic: "POSITION",
|
type: AttributeType.VEC3,
|
},
|
{
|
semantic: "NORMAL",
|
type: AttributeType.VEC3,
|
},
|
{
|
semantic: "TEXCOORD",
|
setIndex: 0,
|
type: AttributeType.VEC2,
|
},
|
],
|
};
|
|
var primitiveWithCustomAttributes = {
|
attributes: [
|
{
|
semantic: "POSITION",
|
type: AttributeType.VEC3,
|
},
|
{
|
name: "_TEMPERATURE",
|
type: AttributeType.SCALAR,
|
},
|
],
|
};
|
|
var emptyVertexShader =
|
"void vertexMain(VertexInput vsInput, inout vec3 positionMC) {}";
|
var emptyFragmentShader =
|
"void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material) {}";
|
var emptyShader = new CustomShader({
|
vertexShaderText: emptyVertexShader,
|
fragmentShaderText: emptyFragmentShader,
|
});
|
|
it("sets defines in the shader", function () {
|
var shaderBuilder = new ShaderBuilder();
|
var model = {
|
customShader: emptyShader,
|
};
|
var renderResources = {
|
shaderBuilder: shaderBuilder,
|
model: model,
|
lightingOptions: new ModelLightingOptions(),
|
alphaOptions: new ModelAlphaOptions(),
|
};
|
|
CustomShaderPipelineStage.process(renderResources, primitive);
|
|
ShaderBuilderTester.expectHasVertexDefines(shaderBuilder, [
|
"HAS_CUSTOM_VERTEX_SHADER",
|
]);
|
ShaderBuilderTester.expectHasFragmentDefines(shaderBuilder, [
|
"HAS_CUSTOM_FRAGMENT_SHADER",
|
"CUSTOM_SHADER_MODIFY_MATERIAL",
|
]);
|
});
|
|
it("adds uniforms from the custom shader", function () {
|
var uniforms = {
|
u_time: {
|
type: UniformType.FLOAT,
|
},
|
u_enableAnimation: {
|
type: UniformType.BOOL,
|
},
|
};
|
var customShader = new CustomShader({
|
uniforms: uniforms,
|
vertexShaderText: emptyVertexShader,
|
fragmentShaderText: emptyFragmentShader,
|
});
|
var model = {
|
customShader: customShader,
|
};
|
var uniformMap = {};
|
var shaderBuilder = new ShaderBuilder();
|
|
var renderResources = {
|
shaderBuilder: shaderBuilder,
|
uniformMap: uniformMap,
|
model: model,
|
lightingOptions: new ModelLightingOptions(),
|
alphaOptions: new ModelAlphaOptions(),
|
};
|
|
CustomShaderPipelineStage.process(renderResources, primitive);
|
|
ShaderBuilderTester.expectHasVertexUniforms(shaderBuilder, [
|
"uniform bool u_enableAnimation;",
|
"uniform float u_time;",
|
]);
|
|
ShaderBuilderTester.expectHasFragmentUniforms(shaderBuilder, [
|
"uniform bool u_enableAnimation;",
|
"uniform float u_time;",
|
]);
|
|
expect(renderResources.uniformMap).toEqual(customShader.uniformMap);
|
});
|
|
it("adds varying declarations from the custom shader", function () {
|
var varyings = {
|
v_distanceFromCenter: VaryingType.FLOAT,
|
v_computedMatrix: VaryingType.MAT3,
|
};
|
var customShader = new CustomShader({
|
vertexShaderText: emptyVertexShader,
|
fragmentShaderText: emptyFragmentShader,
|
varyings: varyings,
|
});
|
var model = {
|
customShader: customShader,
|
};
|
var shaderBuilder = new ShaderBuilder();
|
|
var renderResources = {
|
shaderBuilder: shaderBuilder,
|
model: model,
|
lightingOptions: new ModelLightingOptions(),
|
alphaOptions: new ModelAlphaOptions(),
|
};
|
|
CustomShaderPipelineStage.process(renderResources, primitive);
|
|
ShaderBuilderTester.expectHasVaryings(shaderBuilder, [
|
"varying float v_distanceFromCenter;",
|
"varying mat2 v_computedMatrix;",
|
]);
|
});
|
|
it("overrides the lighting model if specified in the custom shader", function () {
|
var shaderBuilder = new ShaderBuilder();
|
var model = {
|
customShader: new CustomShader({
|
vertexShaderText: emptyVertexShader,
|
fragmentShaderText: emptyFragmentShader,
|
lightingModel: LightingModel.PBR,
|
}),
|
};
|
var renderResources = {
|
shaderBuilder: shaderBuilder,
|
model: model,
|
lightingOptions: new ModelLightingOptions(),
|
alphaOptions: new ModelAlphaOptions(),
|
};
|
|
CustomShaderPipelineStage.process(renderResources, primitive);
|
|
expect(renderResources.lightingOptions.lightingModel).toBe(
|
LightingModel.PBR
|
);
|
});
|
|
it("sets alpha options", function () {
|
var shaderBuilder = new ShaderBuilder();
|
var model = {
|
customShader: new CustomShader({
|
vertexShaderText: emptyVertexShader,
|
fragmentShaderText: emptyFragmentShader,
|
}),
|
};
|
var renderResources = {
|
shaderBuilder: shaderBuilder,
|
model: model,
|
lightingOptions: new ModelLightingOptions(),
|
alphaOptions: new ModelAlphaOptions(),
|
};
|
|
CustomShaderPipelineStage.process(renderResources, primitive);
|
|
expect(renderResources.alphaOptions.pass).not.toBeDefined();
|
expect(renderResources.alphaOptions.alphaMode).toBe(AlphaMode.OPAQUE);
|
});
|
|
it("sets alpha options for translucent custom shader", function () {
|
var shaderBuilder = new ShaderBuilder();
|
var model = {
|
customShader: new CustomShader({
|
vertexShaderText: emptyVertexShader,
|
fragmentShaderText: emptyFragmentShader,
|
isTranslucent: true,
|
}),
|
};
|
var renderResources = {
|
shaderBuilder: shaderBuilder,
|
model: model,
|
lightingOptions: new ModelLightingOptions(),
|
alphaOptions: new ModelAlphaOptions(),
|
};
|
|
CustomShaderPipelineStage.process(renderResources, primitive);
|
|
expect(renderResources.alphaOptions.pass).toBe(Pass.TRANSLUCENT);
|
expect(renderResources.alphaOptions.alphaMode).toBe(AlphaMode.BLEND);
|
});
|
|
it("generates shader code from built-in attributes", function () {
|
var shaderBuilder = new ShaderBuilder();
|
var model = {
|
customShader: new CustomShader({
|
vertexShaderText: [
|
"void vertexMain(VertexInput vsInput, inout vec3 positionMC)",
|
"{",
|
" vec3 normalMC = vsInput.attributes.normalMC;",
|
" vec2 texCoord = vsInput.attributes.texCoord_0;",
|
" positionMC = vsInput.attributes.positionMC;",
|
"}",
|
].join("\n"),
|
fragmentShaderText: [
|
"void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material)",
|
"{",
|
" vec3 positionMC = fsInput.attributes.positionMC;",
|
" vec3 normalEC = fsInput.attributes.normalEC;",
|
" vec2 texCoord = fsInput.attributes.texCoord_0;",
|
"}",
|
].join("\n"),
|
}),
|
};
|
var renderResources = {
|
shaderBuilder: shaderBuilder,
|
model: model,
|
lightingOptions: new ModelLightingOptions(),
|
alphaOptions: new ModelAlphaOptions(),
|
};
|
|
CustomShaderPipelineStage.process(renderResources, primitive);
|
|
ShaderBuilderTester.expectHasVertexStruct(
|
shaderBuilder,
|
CustomShaderPipelineStage.STRUCT_ID_ATTRIBUTES_VS,
|
CustomShaderPipelineStage.STRUCT_NAME_ATTRIBUTES,
|
[" vec3 positionMC;", " vec3 normalMC;", " vec2 texCoord_0;"]
|
);
|
ShaderBuilderTester.expectHasFragmentStruct(
|
shaderBuilder,
|
CustomShaderPipelineStage.STRUCT_ID_ATTRIBUTES_FS,
|
CustomShaderPipelineStage.STRUCT_NAME_ATTRIBUTES,
|
[" vec3 positionMC;", " vec3 normalEC;", " vec2 texCoord_0;"]
|
);
|
|
ShaderBuilderTester.expectHasVertexStruct(
|
shaderBuilder,
|
CustomShaderPipelineStage.STRUCT_ID_VERTEX_INPUT,
|
"VertexInput",
|
[" Attributes attributes;"]
|
);
|
ShaderBuilderTester.expectHasFragmentStruct(
|
shaderBuilder,
|
CustomShaderPipelineStage.STRUCT_ID_FRAGMENT_INPUT,
|
"FragmentInput",
|
[" Attributes attributes;"]
|
);
|
|
ShaderBuilderTester.expectHasVertexFunction(
|
shaderBuilder,
|
CustomShaderPipelineStage.FUNCTION_ID_INITIALIZE_INPUT_STRUCT_VS,
|
CustomShaderPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_INPUT_STRUCT_VS,
|
[
|
" vsInput.attributes.positionMC = attributes.positionMC;",
|
" vsInput.attributes.normalMC = attributes.normalMC;",
|
" vsInput.attributes.texCoord_0 = attributes.texCoord_0;",
|
]
|
);
|
ShaderBuilderTester.expectHasFragmentFunction(
|
shaderBuilder,
|
CustomShaderPipelineStage.FUNCTION_ID_INITIALIZE_INPUT_STRUCT_FS,
|
CustomShaderPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_INPUT_STRUCT_FS,
|
[
|
" fsInput.attributes.positionMC = attributes.positionMC;",
|
" fsInput.attributes.normalEC = attributes.normalEC;",
|
" fsInput.attributes.texCoord_0 = attributes.texCoord_0;",
|
]
|
);
|
});
|
|
it("generates shader code for custom attributes", function () {
|
var shaderBuilder = new ShaderBuilder();
|
var model = {
|
customShader: new CustomShader({
|
vertexShaderText: [
|
"void vertexMain(VertexInput vsInput, inout vec3 positionMC)",
|
"{",
|
" float temperature = vsInput.attributes.temperature;",
|
" positionMC = vsInput.attributes.positionMC;",
|
"}",
|
].join("\n"),
|
fragmentShaderText: [
|
"void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material)",
|
"{",
|
" float temperature = fsInput.attributes.temperature;",
|
" vec3 positionMC = fsInput.attributes.positionMC;",
|
"}",
|
].join("\n"),
|
}),
|
};
|
var renderResources = {
|
shaderBuilder: shaderBuilder,
|
model: model,
|
lightingOptions: new ModelLightingOptions(),
|
alphaOptions: new ModelAlphaOptions(),
|
};
|
|
CustomShaderPipelineStage.process(
|
renderResources,
|
primitiveWithCustomAttributes
|
);
|
|
ShaderBuilderTester.expectHasVertexStruct(
|
shaderBuilder,
|
CustomShaderPipelineStage.STRUCT_ID_ATTRIBUTES_VS,
|
CustomShaderPipelineStage.STRUCT_NAME_ATTRIBUTES,
|
[" vec3 positionMC;", " float temperature;"]
|
);
|
ShaderBuilderTester.expectHasFragmentStruct(
|
shaderBuilder,
|
CustomShaderPipelineStage.STRUCT_ID_ATTRIBUTES_FS,
|
CustomShaderPipelineStage.STRUCT_NAME_ATTRIBUTES,
|
[" vec3 positionMC;", " float temperature;"]
|
);
|
|
ShaderBuilderTester.expectHasVertexStruct(
|
shaderBuilder,
|
CustomShaderPipelineStage.STRUCT_ID_VERTEX_INPUT,
|
"VertexInput",
|
[" Attributes attributes;"]
|
);
|
ShaderBuilderTester.expectHasFragmentStruct(
|
shaderBuilder,
|
CustomShaderPipelineStage.STRUCT_ID_FRAGMENT_INPUT,
|
"FragmentInput",
|
[" Attributes attributes;"]
|
);
|
|
ShaderBuilderTester.expectHasVertexFunction(
|
shaderBuilder,
|
CustomShaderPipelineStage.FUNCTION_ID_INITIALIZE_INPUT_STRUCT_VS,
|
CustomShaderPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_INPUT_STRUCT_VS,
|
[
|
" vsInput.attributes.positionMC = attributes.positionMC;",
|
" vsInput.attributes.temperature = attributes.temperature;",
|
]
|
);
|
ShaderBuilderTester.expectHasFragmentFunction(
|
shaderBuilder,
|
CustomShaderPipelineStage.FUNCTION_ID_INITIALIZE_INPUT_STRUCT_FS,
|
CustomShaderPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_INPUT_STRUCT_FS,
|
[
|
" fsInput.attributes.positionMC = attributes.positionMC;",
|
" fsInput.attributes.temperature = attributes.temperature;",
|
]
|
);
|
});
|
|
it("only generates input lines for attributes that are used", function () {
|
var shaderBuilder = new ShaderBuilder();
|
var model = {
|
customShader: new CustomShader({
|
vertexShaderText: [
|
"void vertexMain(VertexInput vsInput, inout vec3 positionMC)",
|
"{",
|
" positionMC = 2.0 * vsInput.attributes.positionMC - 1.0;",
|
"}",
|
].join("\n"),
|
fragmentShaderText: [
|
"void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material)",
|
"{",
|
" float temperature = fsInput.attributes.temperature",
|
" material.diffuse = vec3(temperature / 90.0, 0.0, 0.0);",
|
"}",
|
].join("\n"),
|
}),
|
};
|
var renderResources = {
|
shaderBuilder: shaderBuilder,
|
model: model,
|
lightingOptions: new ModelLightingOptions(),
|
alphaOptions: new ModelAlphaOptions(),
|
};
|
|
CustomShaderPipelineStage.process(
|
renderResources,
|
primitiveWithCustomAttributes
|
);
|
|
ShaderBuilderTester.expectHasVertexStruct(
|
shaderBuilder,
|
CustomShaderPipelineStage.STRUCT_ID_ATTRIBUTES_VS,
|
CustomShaderPipelineStage.STRUCT_NAME_ATTRIBUTES,
|
[" vec3 positionMC;"]
|
);
|
ShaderBuilderTester.expectHasFragmentStruct(
|
shaderBuilder,
|
CustomShaderPipelineStage.STRUCT_ID_ATTRIBUTES_FS,
|
CustomShaderPipelineStage.STRUCT_NAME_ATTRIBUTES,
|
[" float temperature;"]
|
);
|
|
ShaderBuilderTester.expectHasVertexStruct(
|
shaderBuilder,
|
CustomShaderPipelineStage.STRUCT_ID_VERTEX_INPUT,
|
"VertexInput",
|
[" Attributes attributes;"]
|
);
|
ShaderBuilderTester.expectHasFragmentStruct(
|
shaderBuilder,
|
CustomShaderPipelineStage.STRUCT_ID_FRAGMENT_INPUT,
|
"FragmentInput",
|
[" Attributes attributes;"]
|
);
|
|
ShaderBuilderTester.expectHasVertexFunction(
|
shaderBuilder,
|
CustomShaderPipelineStage.FUNCTION_ID_INITIALIZE_INPUT_STRUCT_VS,
|
CustomShaderPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_INPUT_STRUCT_VS,
|
[" vsInput.attributes.positionMC = attributes.positionMC;"]
|
);
|
ShaderBuilderTester.expectHasFragmentFunction(
|
shaderBuilder,
|
CustomShaderPipelineStage.FUNCTION_ID_INITIALIZE_INPUT_STRUCT_FS,
|
CustomShaderPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_INPUT_STRUCT_FS,
|
[" fsInput.attributes.temperature = attributes.temperature;"]
|
);
|
});
|
|
it("generates the shader lines in the correct order", function () {
|
var shaderBuilder = new ShaderBuilder();
|
var model = {
|
customShader: emptyShader,
|
};
|
var renderResources = {
|
shaderBuilder: shaderBuilder,
|
model: model,
|
lightingOptions: new ModelLightingOptions(),
|
alphaOptions: new ModelAlphaOptions(),
|
};
|
|
CustomShaderPipelineStage.process(renderResources, primitive);
|
|
expect(shaderBuilder._vertexShaderParts.structIds).toEqual([
|
CustomShaderPipelineStage.STRUCT_ID_ATTRIBUTES_VS,
|
CustomShaderPipelineStage.STRUCT_ID_VERTEX_INPUT,
|
]);
|
expect(shaderBuilder._fragmentShaderParts.structIds).toEqual([
|
CustomShaderPipelineStage.STRUCT_ID_ATTRIBUTES_FS,
|
CustomShaderPipelineStage.STRUCT_ID_FRAGMENT_INPUT,
|
]);
|
|
ShaderBuilderTester.expectVertexLinesEqual(shaderBuilder, [
|
"#line 0",
|
emptyVertexShader,
|
_shadersCustomShaderStageVS,
|
]);
|
|
ShaderBuilderTester.expectFragmentLinesEqual(shaderBuilder, [
|
"#line 0",
|
emptyFragmentShader,
|
_shadersCustomShaderStageFS,
|
]);
|
});
|
|
it("does not add positions in other coordinate systems if not needed", function () {
|
var shaderBuilder = new ShaderBuilder();
|
var model = {
|
customShader: emptyShader,
|
};
|
var renderResources = {
|
shaderBuilder: shaderBuilder,
|
model: model,
|
lightingOptions: new ModelLightingOptions(),
|
alphaOptions: new ModelAlphaOptions(),
|
};
|
|
CustomShaderPipelineStage.process(renderResources, primitive);
|
|
ShaderBuilderTester.expectHasFragmentStruct(
|
shaderBuilder,
|
CustomShaderPipelineStage.STRUCT_ID_FRAGMENT_INPUT,
|
"FragmentInput",
|
[" Attributes attributes;"]
|
);
|
});
|
|
it("configures positions in other coordinate systems when present in the shader", function () {
|
var shaderBuilder = new ShaderBuilder();
|
var model = {
|
customShader: new CustomShader({
|
vertexShaderText: emptyVertexShader,
|
fragmentShaderText: [
|
"void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material)",
|
"{",
|
" material.diffuse = fsInput.attributes.positionMC;",
|
" material.specular = fsInput.attributes.positionWC;",
|
" material.normal = fsInput.attributes.positionEC;",
|
"}",
|
].join("\n"),
|
}),
|
};
|
var renderResources = {
|
shaderBuilder: shaderBuilder,
|
model: model,
|
lightingOptions: new ModelLightingOptions(),
|
alphaOptions: new ModelAlphaOptions(),
|
};
|
|
CustomShaderPipelineStage.process(renderResources, primitive);
|
|
expect(shaderBuilder._vertexShaderParts.defineLines).toEqual([
|
"COMPUTE_POSITION_WC",
|
"HAS_CUSTOM_VERTEX_SHADER",
|
]);
|
|
ShaderBuilderTester.expectHasVertexStruct(
|
shaderBuilder,
|
CustomShaderPipelineStage.STRUCT_ID_ATTRIBUTES_VS,
|
CustomShaderPipelineStage.STRUCT_NAME_ATTRIBUTES,
|
[]
|
);
|
ShaderBuilderTester.expectHasFragmentStruct(
|
shaderBuilder,
|
CustomShaderPipelineStage.STRUCT_ID_ATTRIBUTES_FS,
|
CustomShaderPipelineStage.STRUCT_NAME_ATTRIBUTES,
|
[" vec3 positionMC;", " vec3 positionWC;", " vec3 positionEC;"]
|
);
|
|
ShaderBuilderTester.expectHasVertexStruct(
|
shaderBuilder,
|
CustomShaderPipelineStage.STRUCT_ID_VERTEX_INPUT,
|
"VertexInput",
|
[" Attributes attributes;"]
|
);
|
ShaderBuilderTester.expectHasFragmentStruct(
|
shaderBuilder,
|
CustomShaderPipelineStage.STRUCT_ID_FRAGMENT_INPUT,
|
"FragmentInput",
|
[" Attributes attributes;"]
|
);
|
|
ShaderBuilderTester.expectHasVertexFunction(
|
shaderBuilder,
|
CustomShaderPipelineStage.FUNCTION_ID_INITIALIZE_INPUT_STRUCT_VS,
|
CustomShaderPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_INPUT_STRUCT_VS,
|
[]
|
);
|
ShaderBuilderTester.expectHasFragmentFunction(
|
shaderBuilder,
|
CustomShaderPipelineStage.FUNCTION_ID_INITIALIZE_INPUT_STRUCT_FS,
|
CustomShaderPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_INPUT_STRUCT_FS,
|
[
|
" fsInput.attributes.positionMC = attributes.positionMC;",
|
" fsInput.attributes.positionWC = attributes.positionWC;",
|
" fsInput.attributes.positionEC = attributes.positionEC;",
|
]
|
);
|
});
|
|
it("infers default values for built-in attributes", function () {
|
var shaderBuilder = new ShaderBuilder();
|
var model = {
|
customShader: new CustomShader({
|
vertexShaderText: [
|
"void vertexMain(VertexInput vsInput, inout vec3 positionMC)",
|
"{",
|
" vec2 texCoords = vsInput.attributes.texCoord_1;",
|
"}",
|
].join("\n"),
|
fragmentShaderText: [
|
"void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material)",
|
"{",
|
" material.diffuse = vec3(fsInput.attributes.tangentEC);",
|
"}",
|
].join("\n"),
|
}),
|
};
|
var renderResources = {
|
shaderBuilder: shaderBuilder,
|
model: model,
|
lightingOptions: new ModelLightingOptions(),
|
alphaOptions: new ModelAlphaOptions(),
|
};
|
|
CustomShaderPipelineStage.process(renderResources, primitive);
|
|
ShaderBuilderTester.expectHasVertexStruct(
|
shaderBuilder,
|
CustomShaderPipelineStage.STRUCT_ID_ATTRIBUTES_VS,
|
CustomShaderPipelineStage.STRUCT_NAME_ATTRIBUTES,
|
[" vec2 texCoord_1;"]
|
);
|
ShaderBuilderTester.expectHasFragmentStruct(
|
shaderBuilder,
|
CustomShaderPipelineStage.STRUCT_ID_ATTRIBUTES_FS,
|
CustomShaderPipelineStage.STRUCT_NAME_ATTRIBUTES,
|
[" vec3 tangentEC;"]
|
);
|
|
ShaderBuilderTester.expectHasVertexStruct(
|
shaderBuilder,
|
CustomShaderPipelineStage.STRUCT_ID_VERTEX_INPUT,
|
"VertexInput",
|
[" Attributes attributes;"]
|
);
|
ShaderBuilderTester.expectHasFragmentStruct(
|
shaderBuilder,
|
CustomShaderPipelineStage.STRUCT_ID_FRAGMENT_INPUT,
|
"FragmentInput",
|
[" Attributes attributes;"]
|
);
|
|
ShaderBuilderTester.expectHasVertexFunction(
|
shaderBuilder,
|
CustomShaderPipelineStage.FUNCTION_ID_INITIALIZE_INPUT_STRUCT_VS,
|
CustomShaderPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_INPUT_STRUCT_VS,
|
[" vsInput.attributes.texCoord_1 = vec2(0.0);"]
|
);
|
ShaderBuilderTester.expectHasFragmentFunction(
|
shaderBuilder,
|
CustomShaderPipelineStage.FUNCTION_ID_INITIALIZE_INPUT_STRUCT_FS,
|
CustomShaderPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_INPUT_STRUCT_FS,
|
[" fsInput.attributes.tangentEC = vec3(1.0, 0.0, 0.0);"]
|
);
|
});
|
|
it("handles incompatible primitives gracefully", function () {
|
var shaderBuilder = new ShaderBuilder();
|
var model = {
|
customShader: new CustomShader({
|
vertexShaderText: [
|
"void vertexMain(VertexInput vsInput, inout vec3 positionMC)",
|
"{",
|
" vec3 texCoords = vsInput.attributes.notAnAttribute;",
|
"}",
|
].join("\n"),
|
fragmentShaderText: [
|
"void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material)",
|
"{",
|
" material.diffuse *= fsInput.attributes.alsoNotAnAttribute;",
|
"}",
|
].join("\n"),
|
}),
|
};
|
var renderResources = {
|
shaderBuilder: shaderBuilder,
|
model: model,
|
lightingOptions: new ModelLightingOptions(),
|
alphaOptions: new ModelAlphaOptions(),
|
};
|
|
spyOn(CustomShaderPipelineStage, "_oneTimeWarning");
|
|
CustomShaderPipelineStage.process(renderResources, primitive);
|
|
// once for the vertex shader, once for the fragment shader
|
expect(CustomShaderPipelineStage._oneTimeWarning.calls.count()).toBe(2);
|
|
expect(shaderBuilder._vertexShaderParts.defineLines).toEqual([]);
|
expect(shaderBuilder._fragmentShaderParts.defineLines).toEqual([]);
|
});
|
|
it("disables vertex shader if vertexShaderText is not provided", function () {
|
var shaderBuilder = new ShaderBuilder();
|
var model = {
|
customShader: new CustomShader({
|
fragmentShaderText: emptyFragmentShader,
|
}),
|
};
|
var renderResources = {
|
shaderBuilder: shaderBuilder,
|
model: model,
|
lightingOptions: new ModelLightingOptions(),
|
uniformMap: {},
|
alphaOptions: new ModelAlphaOptions(),
|
};
|
|
CustomShaderPipelineStage.process(renderResources, primitive);
|
|
expect(shaderBuilder._vertexShaderParts.defineLines).toEqual([]);
|
expect(shaderBuilder._fragmentShaderParts.defineLines).toEqual([
|
"HAS_CUSTOM_FRAGMENT_SHADER",
|
"CUSTOM_SHADER_MODIFY_MATERIAL",
|
]);
|
|
expect(shaderBuilder._vertexShaderParts.shaderLines).toEqual([]);
|
var fragmentShaderIndex = shaderBuilder._fragmentShaderParts.shaderLines.indexOf(
|
emptyFragmentShader
|
);
|
expect(fragmentShaderIndex).not.toBe(-1);
|
});
|
|
it("disables fragment shader if fragmentShaderText is not provided", function () {
|
var shaderBuilder = new ShaderBuilder();
|
var model = {
|
customShader: new CustomShader({
|
vertexShaderText: emptyVertexShader,
|
}),
|
};
|
var renderResources = {
|
shaderBuilder: shaderBuilder,
|
model: model,
|
lightingOptions: new ModelLightingOptions(),
|
alphaOptions: new ModelAlphaOptions(),
|
uniformMap: {},
|
};
|
|
CustomShaderPipelineStage.process(renderResources, primitive);
|
|
expect(shaderBuilder._vertexShaderParts.defineLines).toEqual([
|
"HAS_CUSTOM_VERTEX_SHADER",
|
]);
|
expect(shaderBuilder._fragmentShaderParts.defineLines).toEqual([]);
|
|
var vertexShaderIndex = shaderBuilder._vertexShaderParts.shaderLines.indexOf(
|
emptyVertexShader
|
);
|
expect(vertexShaderIndex).not.toBe(-1);
|
expect(shaderBuilder._fragmentShaderParts.shaderLines).toEqual([]);
|
});
|
|
it("disables custom shader if neither fragmentShaderText nor vertexShaderText are provided", function () {
|
var shaderBuilder = new ShaderBuilder();
|
var model = {
|
customShader: new CustomShader(),
|
};
|
var renderResources = {
|
shaderBuilder: shaderBuilder,
|
model: model,
|
lightingOptions: new ModelLightingOptions(),
|
alphaOptions: new ModelAlphaOptions(),
|
uniformMap: {},
|
};
|
|
CustomShaderPipelineStage.process(renderResources, primitive);
|
|
// Essentially the shader stage is skipped, so nothing should be updated
|
expect(shaderBuilder).toEqual(new ShaderBuilder());
|
expect(renderResources.uniformMap).toEqual({});
|
expect(renderResources.lightingOptions).toEqual(new ModelLightingOptions());
|
});
|
|
it("handles fragment-only custom shader that computes positionWC", function () {
|
var shaderBuilder = new ShaderBuilder();
|
var model = {
|
customShader: new CustomShader({
|
fragmentShaderText: [
|
"void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material)",
|
"{",
|
" material.diffuse = fsInput.attributes.positionWC;",
|
"}",
|
].join("\n"),
|
}),
|
};
|
var renderResources = {
|
shaderBuilder: shaderBuilder,
|
model: model,
|
lightingOptions: new ModelLightingOptions(),
|
alphaOptions: new ModelAlphaOptions(),
|
};
|
|
CustomShaderPipelineStage.process(renderResources, primitive);
|
|
ShaderBuilderTester.expectHasVertexDefines(shaderBuilder, [
|
"COMPUTE_POSITION_WC",
|
]);
|
|
expect(shaderBuilder._vertexShaderParts.structIds).toEqual([]);
|
ShaderBuilderTester.expectHasFragmentStruct(
|
shaderBuilder,
|
CustomShaderPipelineStage.STRUCT_ID_ATTRIBUTES_FS,
|
CustomShaderPipelineStage.STRUCT_NAME_ATTRIBUTES,
|
[" vec3 positionWC;"]
|
);
|
|
ShaderBuilderTester.expectHasFragmentStruct(
|
shaderBuilder,
|
CustomShaderPipelineStage.STRUCT_ID_FRAGMENT_INPUT,
|
"FragmentInput",
|
[" Attributes attributes;"]
|
);
|
|
expect(shaderBuilder._vertexShaderParts.functionIds).toEqual([]);
|
ShaderBuilderTester.expectHasFragmentFunction(
|
shaderBuilder,
|
CustomShaderPipelineStage.FUNCTION_ID_INITIALIZE_INPUT_STRUCT_FS,
|
CustomShaderPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_INPUT_STRUCT_FS,
|
[" fsInput.attributes.positionWC = attributes.positionWC;"]
|
);
|
});
|
});
|
