import {
|
ShaderBuilder,
|
ShaderDestination,
|
ShaderSource,
|
} from "../../Source/Cesium.js";
|
import createContext from "../createContext.js";
|
|
describe(
|
"Renderer/ShaderBuilder",
|
function () {
|
var context;
|
beforeAll(function () {
|
context = createContext();
|
});
|
|
afterAll(function () {
|
context.destroyForSpecs();
|
});
|
|
function checkVertexShader(
|
shaderProgram,
|
expectedDefines,
|
expectedSources
|
) {
|
// the ShaderBuilder joins the generated lines with \n
|
// to avoid creating #line 0 at every line. We need to do the same here
|
expectedSources = [expectedSources.join("\n")];
|
var expectedText = new ShaderSource({
|
defines: expectedDefines,
|
sources: expectedSources,
|
}).createCombinedVertexShader(context);
|
expect(shaderProgram._vertexShaderText).toEqual(expectedText);
|
}
|
|
function checkFragmentShader(
|
shaderProgram,
|
expectedDefines,
|
expectedSources
|
) {
|
// the ShaderBuilder joins the generated lines with \n
|
// to avoid creating #line 0 at every line. We need to do the same here
|
expectedSources = [expectedSources.join("\n")];
|
var expectedText = new ShaderSource({
|
defines: expectedDefines,
|
sources: expectedSources,
|
}).createCombinedFragmentShader(context);
|
expect(shaderProgram._fragmentShaderText).toEqual(expectedText);
|
}
|
|
it("creates an empty shader by default", function () {
|
var shaderBuilder = new ShaderBuilder();
|
var shaderProgram = shaderBuilder.buildShaderProgram(context);
|
checkVertexShader(shaderProgram, [], []);
|
checkFragmentShader(shaderProgram, [], []);
|
});
|
|
it("addDefine throws for undefined identifier", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addDefine(undefined);
|
}).toThrowDeveloperError();
|
});
|
|
it("addDefine throws for invalid identifier", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addDefine(42);
|
}).toThrowDeveloperError();
|
});
|
|
it("addDefine defines macros without values", function () {
|
var shaderBuilder = new ShaderBuilder();
|
shaderBuilder.addDefine("USE_SHADOWS");
|
var shaderProgram = shaderBuilder.buildShaderProgram(context);
|
checkVertexShader(shaderProgram, ["USE_SHADOWS"], []);
|
checkFragmentShader(shaderProgram, ["USE_SHADOWS"], []);
|
});
|
|
it("addDefine defines macros with values", function () {
|
var shaderBuilder = new ShaderBuilder();
|
shaderBuilder.addDefine("PI", 3.1415);
|
var shaderProgram = shaderBuilder.buildShaderProgram(context);
|
checkVertexShader(shaderProgram, ["PI 3.1415"], []);
|
checkFragmentShader(shaderProgram, ["PI 3.1415"], []);
|
});
|
|
it("addDefine puts the define in the destination shader(s)", function () {
|
var shaderBuilder = new ShaderBuilder();
|
shaderBuilder.addDefine("POINT_SIZE", 2, ShaderDestination.VERTEX);
|
shaderBuilder.addDefine("PI", 3.1415, ShaderDestination.FRAGMENT);
|
shaderBuilder.addDefine(
|
"USE_FRAGMENT_SHADING",
|
1,
|
ShaderDestination.BOTH
|
);
|
var shaderProgram = shaderBuilder.buildShaderProgram(context);
|
checkVertexShader(
|
shaderProgram,
|
["POINT_SIZE 2", "USE_FRAGMENT_SHADING 1"],
|
[]
|
);
|
checkFragmentShader(
|
shaderProgram,
|
["PI 3.1415", "USE_FRAGMENT_SHADING 1"],
|
[]
|
);
|
});
|
|
it("addDefine defaults to both shaders", function () {
|
var shaderBuilder = new ShaderBuilder();
|
shaderBuilder.addDefine("PI", 3.1415);
|
var shaderProgram = shaderBuilder.buildShaderProgram(context);
|
checkVertexShader(shaderProgram, ["PI 3.1415"], []);
|
checkFragmentShader(shaderProgram, ["PI 3.1415"], []);
|
});
|
|
it("addStruct throws for undefined structId", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addStruct(
|
undefined,
|
"TestStruct",
|
ShaderDestination.FRAGMENT
|
);
|
}).toThrowDeveloperError();
|
});
|
|
it("addStruct throws for invalid structId", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addStruct(
|
{},
|
"TestStruct",
|
ShaderDestination.FRAGMENT
|
);
|
}).toThrowDeveloperError();
|
});
|
|
it("addStruct throws for undefined structName", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addStruct(
|
"testStruct",
|
undefined,
|
ShaderDestination.FRAGMENT
|
);
|
}).toThrowDeveloperError();
|
});
|
|
it("addStruct throws for invalid structId", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addStruct(
|
"testStruct",
|
{},
|
ShaderDestination.FRAGMENT
|
);
|
}).toThrowDeveloperError();
|
});
|
|
it("addStruct throws for undefined destination", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addStruct("testStruct", "TestStruct", undefined);
|
}).toThrowDeveloperError();
|
});
|
|
it("addStruct throws for invalid structId", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addStruct("testStruct", "TestStruct", "vertex");
|
}).toThrowDeveloperError();
|
});
|
|
it("addStruct adds a struct to the shader", function () {
|
var shaderBuilder = new ShaderBuilder();
|
shaderBuilder.addStruct(
|
"structVS",
|
"TestStruct",
|
ShaderDestination.VERTEX
|
);
|
shaderBuilder.addStruct(
|
"structFS",
|
"TestStruct",
|
ShaderDestination.FRAGMENT
|
);
|
|
var shaderProgram = shaderBuilder.buildShaderProgram(context);
|
checkVertexShader(
|
shaderProgram,
|
[],
|
["struct TestStruct", "{", " float _empty;", "};"]
|
);
|
checkFragmentShader(
|
shaderProgram,
|
[],
|
["struct TestStruct", "{", " float _empty;", "};"]
|
);
|
});
|
|
it("addStructField throws for undefined structId", function () {
|
var shaderBuilder = new ShaderBuilder();
|
shaderBuilder.addStruct(
|
"structVS",
|
"TestStruct",
|
ShaderDestination.VERTEX
|
);
|
expect(function () {
|
return shaderBuilder.addStructField(undefined, "vec3", "positionMC");
|
}).toThrowDeveloperError();
|
});
|
|
it("addStructField throws for invalid structId", function () {
|
var shaderBuilder = new ShaderBuilder();
|
shaderBuilder.addStruct(
|
"structVS",
|
"TestStruct",
|
ShaderDestination.VERTEX
|
);
|
expect(function () {
|
return shaderBuilder.addStructField(-1, "vec3", "positionMC");
|
}).toThrowDeveloperError();
|
});
|
|
it("addStructField throws for undefined type", function () {
|
var shaderBuilder = new ShaderBuilder();
|
shaderBuilder.addStruct(
|
"structVS",
|
"TestStruct",
|
ShaderDestination.VERTEX
|
);
|
expect(function () {
|
return shaderBuilder.addStructField(
|
"structVS",
|
undefined,
|
"positionMC"
|
);
|
}).toThrowDeveloperError();
|
});
|
|
it("addStructField throws for invalid type", function () {
|
var shaderBuilder = new ShaderBuilder();
|
shaderBuilder.addStruct(
|
"structVS",
|
"TestStruct",
|
ShaderDestination.VERTEX
|
);
|
expect(function () {
|
return shaderBuilder.addStructField("structVS", -1, "positionMC");
|
}).toThrowDeveloperError();
|
});
|
|
it("addStructField throws for undefined identifier", function () {
|
var shaderBuilder = new ShaderBuilder();
|
shaderBuilder.addStruct(
|
"structVS",
|
"TestStruct",
|
ShaderDestination.VERTEX
|
);
|
expect(function () {
|
return shaderBuilder.addStructField("structVS", "vec3", undefined);
|
}).toThrowDeveloperError();
|
});
|
|
it("addStructField throws for invalid identifier", function () {
|
var shaderBuilder = new ShaderBuilder();
|
shaderBuilder.addStruct(
|
"structVS",
|
"TestStruct",
|
ShaderDestination.VERTEX
|
);
|
expect(function () {
|
return shaderBuilder.addStructField("structVS", "vec3", -1);
|
}).toThrowDeveloperError();
|
});
|
|
it("addStructField adds a struct field to the shader", function () {
|
var shaderBuilder = new ShaderBuilder();
|
shaderBuilder.addStruct(
|
"structVS",
|
"TestStruct",
|
ShaderDestination.VERTEX
|
);
|
shaderBuilder.addStruct(
|
"structFS",
|
"TestStruct",
|
ShaderDestination.FRAGMENT
|
);
|
|
shaderBuilder.addStructField("structVS", "vec3", "positionMC");
|
shaderBuilder.addStructField("structFS", "vec3", "positionMC");
|
shaderBuilder.addStructField("structFS", "float", "temperature");
|
|
var shaderProgram = shaderBuilder.buildShaderProgram(context);
|
checkVertexShader(
|
shaderProgram,
|
[],
|
["struct TestStruct", "{", " vec3 positionMC;", "};"]
|
);
|
checkFragmentShader(
|
shaderProgram,
|
[],
|
[
|
"struct TestStruct",
|
"{",
|
" vec3 positionMC;",
|
" float temperature;",
|
"};",
|
]
|
);
|
});
|
|
var signature = "float circleMask(float radius)";
|
it("addFunction throws for undefined functionName", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addFunction(
|
undefined,
|
signature,
|
ShaderDestination.FRAGMENT
|
);
|
}).toThrowDeveloperError();
|
});
|
|
it("addFunction throws for invalid functionName", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addFunction(
|
{},
|
signature,
|
ShaderDestination.FRAGMENT
|
);
|
}).toThrowDeveloperError();
|
});
|
|
it("addFunction throws for undefined signature", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addFunction(
|
"testFunction",
|
undefined,
|
ShaderDestination.FRAGMENT
|
);
|
}).toThrowDeveloperError();
|
});
|
|
it("addFunction throws for invalid signature", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addFunction(
|
"testFunction",
|
-1,
|
ShaderDestination.FRAGMENT
|
);
|
}).toThrowDeveloperError();
|
});
|
|
it("addFunction throws for undefined destination", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addFunction("testFunction", signature, undefined);
|
}).toThrowDeveloperError();
|
});
|
|
it("addFunction throws for invalid structId", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addFunction("testFunction", signature, "fragment");
|
}).toThrowDeveloperError();
|
});
|
|
it("addFunction adds a struct to the shader", function () {
|
var shaderBuilder = new ShaderBuilder();
|
shaderBuilder.addFunction(
|
"testFunctionVS",
|
signature,
|
ShaderDestination.VERTEX
|
);
|
shaderBuilder.addFunction(
|
"testFunctionFS",
|
signature,
|
ShaderDestination.FRAGMENT
|
);
|
|
var shaderProgram = shaderBuilder.buildShaderProgram(context);
|
checkVertexShader(shaderProgram, [], [signature, "{", "}"]);
|
checkFragmentShader(shaderProgram, [], [signature, "{", "}"]);
|
});
|
|
it("addFunctionLines throws for undefined functionName", function () {
|
var shaderBuilder = new ShaderBuilder();
|
shaderBuilder.addFunction(
|
"testFunctionVS",
|
signature,
|
ShaderDestination.VERTEX
|
);
|
expect(function () {
|
return shaderBuilder.addFunctionLines(undefined, "return 1.0;");
|
}).toThrowDeveloperError();
|
});
|
|
it("addFunctionLines throws for invalid functionName", function () {
|
var shaderBuilder = new ShaderBuilder();
|
shaderBuilder.addFunction(
|
"testFunctionVS",
|
signature,
|
ShaderDestination.VERTEX
|
);
|
expect(function () {
|
return shaderBuilder.addFunctionLines(-1, "return 1.0;");
|
}).toThrowDeveloperError();
|
});
|
|
it("addFunctionLines throws for undefined lines", function () {
|
var shaderBuilder = new ShaderBuilder();
|
shaderBuilder.addFunction(
|
"testFunctionVS",
|
signature,
|
ShaderDestination.VERTEX
|
);
|
expect(function () {
|
return shaderBuilder.addFunctionLines("testFunctionVS", undefined);
|
}).toThrowDeveloperError();
|
});
|
|
it("addFunctionLines throws for invalid lines", function () {
|
var shaderBuilder = new ShaderBuilder();
|
shaderBuilder.addFunction(
|
"testFunctionVS",
|
signature,
|
ShaderDestination.VERTEX
|
);
|
expect(function () {
|
return shaderBuilder.addFunctionLines("testFunctionVS", -1);
|
}).toThrowDeveloperError();
|
});
|
|
it("addFunctionLines adds lines to the body of a function", function () {
|
var shaderBuilder = new ShaderBuilder();
|
shaderBuilder.addFunction(
|
"testFunctionVS",
|
signature,
|
ShaderDestination.VERTEX
|
);
|
shaderBuilder.addFunction(
|
"testFunctionFS",
|
signature,
|
ShaderDestination.FRAGMENT
|
);
|
|
shaderBuilder.addFunctionLines("testFunctionVS", [
|
"v_color = vec3(0.0);",
|
"return 1.0;",
|
]);
|
shaderBuilder.addFunctionLines("testFunctionFS", [
|
"return 1.0 - step(0.3, radius);",
|
]);
|
|
var shaderProgram = shaderBuilder.buildShaderProgram(context);
|
checkVertexShader(
|
shaderProgram,
|
[],
|
[signature, "{", " v_color = vec3(0.0);", " return 1.0;", "}"]
|
);
|
checkFragmentShader(
|
shaderProgram,
|
[],
|
[signature, "{", " return 1.0 - step(0.3, radius);", "}"]
|
);
|
});
|
|
it("addUniform throws for undefined type", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addUniform(undefined, "u_time");
|
}).toThrowDeveloperError();
|
});
|
|
it("addUniform throws for invalid type", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addUniform(10, "u_time");
|
}).toThrowDeveloperError();
|
});
|
|
it("addUniform throws for undefined identifier", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addUniform("vec3");
|
}).toThrowDeveloperError();
|
});
|
|
it("addUniform throws for invalid identifier", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addUniform("vec3", 0);
|
}).toThrowDeveloperError();
|
});
|
|
it("addUniform puts the uniform in the destination shader(s)", function () {
|
var shaderBuilder = new ShaderBuilder();
|
shaderBuilder.addUniform(
|
"vec3",
|
"u_gridDimensions",
|
ShaderDestination.VERTEX
|
);
|
shaderBuilder.addUniform(
|
"vec2",
|
"u_mousePosition",
|
ShaderDestination.FRAGMENT
|
);
|
shaderBuilder.addUniform("float", "u_time", ShaderDestination.BOTH);
|
var shaderProgram = shaderBuilder.buildShaderProgram(context);
|
checkVertexShader(
|
shaderProgram,
|
[],
|
["uniform vec3 u_gridDimensions;", "uniform float u_time;"]
|
);
|
checkFragmentShader(
|
shaderProgram,
|
[],
|
["uniform vec2 u_mousePosition;", "uniform float u_time;"]
|
);
|
});
|
|
it("addUniform defaults to both shaders", function () {
|
var shaderBuilder = new ShaderBuilder();
|
shaderBuilder.addUniform("float", "u_time");
|
var shaderProgram = shaderBuilder.buildShaderProgram(context);
|
checkVertexShader(shaderProgram, [], ["uniform float u_time;"]);
|
checkFragmentShader(shaderProgram, [], ["uniform float u_time;"]);
|
});
|
|
it("setPositionAttribute throws for undefined type", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.setPositionAttribute(undefined, "a_position");
|
}).toThrowDeveloperError();
|
});
|
|
it("setPositionAttribute throws for invalid type", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.setPositionAttribute(0, "a_position");
|
}).toThrowDeveloperError();
|
});
|
|
it("setPositionAttribute throws for undefined identifier", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.setPositionAttribute("vec3", undefined);
|
}).toThrowDeveloperError();
|
});
|
|
it("setPositionAttribute throws for invalid identifier", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.setPositionAttribute("vec3", 0);
|
}).toThrowDeveloperError();
|
});
|
|
it("setPositionAttribute creates a position attribute in location 0", function () {
|
var shaderBuilder = new ShaderBuilder();
|
|
// even though these are declared out of order, the results to
|
var normalLocation = shaderBuilder.addAttribute("vec3", "a_normal");
|
var positionLocation = shaderBuilder.setPositionAttribute(
|
"vec3",
|
"a_position"
|
);
|
expect(positionLocation).toBe(0);
|
expect(normalLocation).toBe(1);
|
var shaderProgram = shaderBuilder.buildShaderProgram(context);
|
var expectedAttributes = [
|
"attribute vec3 a_position;",
|
"attribute vec3 a_normal;",
|
];
|
checkVertexShader(shaderProgram, [], expectedAttributes);
|
checkFragmentShader(shaderProgram, [], []);
|
|
var expectedLocations = {
|
a_position: 0,
|
a_normal: 1,
|
};
|
expect(shaderBuilder.attributeLocations).toEqual(expectedLocations);
|
expect(shaderProgram._attributeLocations).toEqual(expectedLocations);
|
});
|
|
it("setPositionAttribute throws if called twice", function () {
|
var shaderBuilder = new ShaderBuilder();
|
var positionLocation = shaderBuilder.setPositionAttribute(
|
"vec3",
|
"a_position"
|
);
|
expect(positionLocation).toBe(0);
|
expect(function () {
|
return shaderBuilder.setPositionAttribute("vec3", "a_position2");
|
}).toThrowDeveloperError();
|
});
|
|
it("addAttribute throws for undefined type", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addAttribute(undefined, "a_position");
|
}).toThrowDeveloperError();
|
});
|
|
it("addAttribute throws for invalid type", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addAttribute(0, "a_position");
|
}).toThrowDeveloperError();
|
});
|
|
it("addAttribute throws for undefined identifier", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addAttribute("vec2", undefined);
|
}).toThrowDeveloperError();
|
});
|
|
it("addAttribute throws for invalid identifier", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addAttribute("vec2", 0);
|
}).toThrowDeveloperError();
|
});
|
|
it("addAttribute creates an attribute in the vertex shader", function () {
|
var shaderBuilder = new ShaderBuilder();
|
|
// even though these are declared out of order, the results to
|
var colorLocation = shaderBuilder.addAttribute("vec4", "a_color");
|
var normalLocation = shaderBuilder.addAttribute("vec3", "a_normal");
|
expect(colorLocation).toBe(1);
|
expect(normalLocation).toBe(2);
|
var shaderProgram = shaderBuilder.buildShaderProgram(context);
|
var expectedAttributes = [
|
"attribute vec4 a_color;",
|
"attribute vec3 a_normal;",
|
];
|
checkVertexShader(shaderProgram, [], expectedAttributes);
|
checkFragmentShader(shaderProgram, [], []);
|
var expectedLocations = {
|
a_color: 1,
|
a_normal: 2,
|
};
|
expect(shaderBuilder.attributeLocations).toEqual(expectedLocations);
|
expect(shaderProgram._attributeLocations).toEqual(expectedLocations);
|
});
|
|
it("addVarying throws for undefined type", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addVarying(undefined, "v_uv");
|
}).toThrowDeveloperError();
|
});
|
|
it("addVarying throws for invalid type", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addVarying(0, "v_uv");
|
}).toThrowDeveloperError();
|
});
|
|
it("addVarying throws for undefined identifier", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addVarying("vec2", undefined);
|
}).toThrowDeveloperError();
|
});
|
|
it("addVarying throws for invalid identifier", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addVarying("vec2", 0);
|
}).toThrowDeveloperError();
|
});
|
|
it("addVarying adds varyings to both shaders", function () {
|
var shaderBuilder = new ShaderBuilder();
|
shaderBuilder.addVarying("vec2", "v_uv");
|
var expectedLines = ["varying vec2 v_uv;"];
|
var shaderProgram = shaderBuilder.buildShaderProgram(context);
|
checkVertexShader(shaderProgram, [], expectedLines);
|
checkFragmentShader(shaderProgram, [], expectedLines);
|
});
|
|
it("addVertexLines throws for undefined lines", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addVertexLines(undefined);
|
}).toThrowDeveloperError();
|
});
|
|
it("addVertexLines throws for invalid lines", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addVertexLines("v_uv = a_uv;");
|
}).toThrowDeveloperError();
|
});
|
|
it("addVertexLines appends lines to the vertex shader", function () {
|
var shaderBuilder = new ShaderBuilder();
|
var vertexLines = [
|
"void main()",
|
"{",
|
" gl_Position = vec4(0.0, 0.0, 0.0, 1.0);",
|
"}",
|
];
|
shaderBuilder.addVertexLines(vertexLines);
|
var shaderProgram = shaderBuilder.buildShaderProgram(context);
|
checkVertexShader(shaderProgram, [], vertexLines);
|
});
|
|
it("addFragmentLines throws for undefined lines", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addFragmentLines(undefined);
|
}).toThrowDeveloperError();
|
});
|
|
it("addFragmentLines throws for invalid lines", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.addFragmentLines("gl_FragColor = vec4(1.0);");
|
}).toThrowDeveloperError();
|
});
|
|
it("addFragmentLines appends lines to the vertex shader", function () {
|
var shaderBuilder = new ShaderBuilder();
|
var fragmentLines = [
|
"void main()",
|
"{",
|
" gl_FragColor = vec4(1.0, 0.5, 0.0, 1.0);",
|
"}",
|
];
|
shaderBuilder.addFragmentLines(fragmentLines);
|
var shaderProgram = shaderBuilder.buildShaderProgram(context);
|
checkFragmentShader(shaderProgram, [], fragmentLines);
|
});
|
|
it("buildShaderProgram throws for undefined context", function () {
|
var shaderBuilder = new ShaderBuilder();
|
expect(function () {
|
return shaderBuilder.buildShaderProgram(undefined);
|
}).toThrowDeveloperError();
|
});
|
|
it("buildShaderProgram creates a shaderProgram", function () {
|
var shaderBuilder = new ShaderBuilder();
|
shaderBuilder.setPositionAttribute("vec3", "a_position");
|
shaderBuilder.addAttribute("vec3", "a_uv");
|
shaderBuilder.addVarying("vec2", "v_uv");
|
shaderBuilder.addDefine("BLUE_TINT", 0.5, ShaderDestination.FRAGMENT);
|
var vertexLines = [
|
"void main()",
|
"{",
|
" v_uv = a_uv",
|
" gl_Position = vec4(a_position, 1.0);",
|
"}",
|
];
|
shaderBuilder.addVertexLines(vertexLines);
|
|
var fragmentLines = [
|
"void main()",
|
"{",
|
" gl_FragColor = vec4(v_uv, BLUE_TINT, 1.0);",
|
"}",
|
];
|
shaderBuilder.addFragmentLines(fragmentLines);
|
|
var expectedAttributes = [
|
"attribute vec3 a_position;",
|
"attribute vec3 a_uv;",
|
];
|
|
var expectedVaryings = ["varying vec2 v_uv;"];
|
|
var shaderProgram = shaderBuilder.buildShaderProgram(context);
|
checkVertexShader(
|
shaderProgram,
|
[],
|
expectedAttributes.concat(expectedVaryings, vertexLines)
|
);
|
checkFragmentShader(
|
shaderProgram,
|
["BLUE_TINT 0.5"],
|
expectedVaryings.concat(fragmentLines)
|
);
|
});
|
},
|
"WebGL"
|
);
|
