diff --git a/packages/core/src/shader/Shader.ts b/packages/core/src/shader/Shader.ts index d8adca3b47..b09ed7fedd 100644 --- a/packages/core/src/shader/Shader.ts +++ b/packages/core/src/shader/Shader.ts @@ -17,6 +17,8 @@ export class Shader { "GL_OES_standard_derivatives", "GL_EXT_draw_buffers" ]; + /** @internal */ + static _propertyIdMap: Record = Object.create(null); private static _shaderMap: Record = Object.create(null); private static _propertyNameMap: Record = Object.create(null); @@ -105,6 +107,7 @@ export class Shader { } else { const property = new ShaderProperty(name); propertyNameMap[name] = property; + Shader._propertyIdMap[property._uniqueId] = property; return property; } } diff --git a/packages/core/src/shader/ShaderData.ts b/packages/core/src/shader/ShaderData.ts index 7d4aeca80f..3d86e84885 100644 --- a/packages/core/src/shader/ShaderData.ts +++ b/packages/core/src/shader/ShaderData.ts @@ -4,23 +4,12 @@ import { IRefObject } from "../asset/IRefObject"; import { CloneManager } from "../clone/CloneManager"; import { Texture } from "../texture/Texture"; import { ShaderDataGroup } from "./enums/ShaderDataGroup"; +import { ShaderPropertyType } from "./enums/ShaderPropertyType"; import { Shader } from "./Shader"; import { ShaderMacro } from "./ShaderMacro"; import { ShaderMacroCollection } from "./ShaderMacroCollection"; import { ShaderProperty } from "./ShaderProperty"; -export type ShaderPropertyValueType = - | number - | Vector2 - | Vector3 - | Vector4 - | Color - | Matrix - | Texture - | Texture[] - | Int32Array - | Float32Array; - /** * Shader data collection,Correspondence includes shader properties data and macros data. */ @@ -28,7 +17,7 @@ export class ShaderData implements IRefObject, IClone { /** @internal */ _group: ShaderDataGroup; /** @internal */ - _properties: Record = Object.create(null); + _propertyValueMap: Record = Object.create(null); /** @internal */ _macroCollection: ShaderMacroCollection = new ShaderMacroCollection(); @@ -51,13 +40,13 @@ export class ShaderData implements IRefObject, IClone { /** * Get float by shader property. - * @param property - Shader property + * @param property - Shader property, use `Shader.getPropertyByName` to get * @returns Float */ getFloat(property: ShaderProperty): number; getFloat(property: string | ShaderProperty): number { - return this._getData(property); + return this.getPropertyValue(property); } /** @@ -71,13 +60,13 @@ export class ShaderData implements IRefObject, IClone { /** * Set float by shader property. * @remarks Corresponding float shader property type. - * @param property - Shader property + * @param property - Shader property, use `Shader.getPropertyByName` to get * @param value - Float */ setFloat(property: ShaderProperty, value: number): void; setFloat(property: string | ShaderProperty, value: number): void { - this._setData(property, value); + this._setPropertyValue(property, ShaderPropertyType.Float, value); } /** @@ -89,13 +78,13 @@ export class ShaderData implements IRefObject, IClone { /** * Get int by shader property. - * @param property - Shader property + * @param property - Shader property, use `Shader.getPropertyByName` to get * @returns Int */ getInt(property: ShaderProperty): number; getInt(property: string | ShaderProperty): number { - return this._getData(property); + return this.getPropertyValue(property); } /** @@ -109,13 +98,13 @@ export class ShaderData implements IRefObject, IClone { /** * Set int by shader property. * @remarks Correspondence includes int and bool shader property type. - * @param property - Shader property + * @param property - Shader property, use `Shader.getPropertyByName` to get * @param value - Int */ setInt(property: ShaderProperty, value: number): void; setInt(property: string | ShaderProperty, value: number): void { - this._setData(property, value); + this._setPropertyValue(property, ShaderPropertyType.Int, value); } /** @@ -127,13 +116,13 @@ export class ShaderData implements IRefObject, IClone { /** * Get float array by shader property. - * @param property - Shader property + * @param property - Shader property, use `Shader.getPropertyByName` to get * @returns Float array */ getFloatArray(property: ShaderProperty): Float32Array; getFloatArray(property: string | ShaderProperty): Float32Array { - return this._getData(property); + return this.getPropertyValue(property); } /** @@ -147,13 +136,13 @@ export class ShaderData implements IRefObject, IClone { /** * Set float array by shader property. * @remarks Correspondence includes float array、vec2 array、vec3 array、vec4 array and matrix array shader property type. - * @param property - Shader property + * @param property - Shader property, use `Shader.getPropertyByName` to get * @param value - Float array */ setFloatArray(property: ShaderProperty, value: Float32Array): void; setFloatArray(property: string | ShaderProperty, value: Float32Array): void { - this._setData(property, value); + this._setPropertyValue(property, ShaderPropertyType.FloatArray, value); } /** @@ -165,13 +154,13 @@ export class ShaderData implements IRefObject, IClone { /** * Get int array by shader property. - * @param property - Shader property + * @param property - Shader property, use `Shader.getPropertyByName` to get * @returns Int Array */ getIntArray(property: ShaderProperty): Int32Array; getIntArray(property: string | ShaderProperty): Int32Array { - return this._getData(property); + return this.getPropertyValue(property); } /** @@ -185,13 +174,13 @@ export class ShaderData implements IRefObject, IClone { /** * Set int array by shader property. * @remarks Correspondence includes bool array、int array、bvec2 array、bvec3 array、bvec4 array、ivec2 array、ivec3 array and ivec4 array shader property type. - * @param property - Shader property + * @param property - Shader property, use `Shader.getPropertyByName` to get * @param value - Int Array */ setIntArray(property: ShaderProperty, value: Int32Array): void; setIntArray(property: string | ShaderProperty, value: Int32Array): void { - this._setData(property, value); + this._setPropertyValue(property, ShaderPropertyType.IntArray, value); } /** @@ -203,13 +192,13 @@ export class ShaderData implements IRefObject, IClone { /** * Get two-dimensional from shader property. - * @param property - Shader property + * @param property - Shader property, use `Shader.getPropertyByName` to get * @returns Two-dimensional vector */ getVector2(property: ShaderProperty): Vector2; getVector2(property: string | ShaderProperty): Vector2 { - return this._getData(property); + return this.getPropertyValue(property); } /** @@ -223,13 +212,13 @@ export class ShaderData implements IRefObject, IClone { /** * Set two-dimensional vector from shader property. * @remarks Correspondence includes vec2、ivec2 and bvec2 shader property type. - * @param property - Shader property + * @param property - Shader property, use `Shader.getPropertyByName` to get * @param value - Two-dimensional vector */ setVector2(property: ShaderProperty, value: Vector2): void; setVector2(property: string | ShaderProperty, value: Vector2): void { - this._setData(property, value); + this._setPropertyValue(property, ShaderPropertyType.Vector2, value); } /** @@ -241,13 +230,13 @@ export class ShaderData implements IRefObject, IClone { /** * Get vector3 by shader property. - * @param property - Shader property + * @param property - Shader property, use `Shader.getPropertyByName` to get * @returns Three-dimensional vector */ getVector3(property: ShaderProperty): Vector3; getVector3(property: string | ShaderProperty): Vector3 { - return this._getData(property); + return this.getPropertyValue(property); } /** @@ -261,13 +250,13 @@ export class ShaderData implements IRefObject, IClone { /** * Set three dimensional vector by shader property. * @remarks Correspondence includes vec3、ivec3 and bvec3 shader property type. - * @param property - Shader property + * @param property - Shader property, use `Shader.getPropertyByName` to get * @param value - Three-dimensional vector */ setVector3(property: ShaderProperty, value: Vector3): void; setVector3(property: string | ShaderProperty, value: Vector3): void { - this._setData(property, value); + this._setPropertyValue(property, ShaderPropertyType.Vector3, value); } /** @@ -279,13 +268,13 @@ export class ShaderData implements IRefObject, IClone { /** * Get vector4 by shader property. - * @param property - Shader property + * @param property - Shader property, use `Shader.getPropertyByName` to get * @returns Four-dimensional vector */ getVector4(property: ShaderProperty): Vector4; getVector4(property: string | ShaderProperty): Vector4 { - return this._getData(property); + return this.getPropertyValue(property); } /** @@ -299,13 +288,13 @@ export class ShaderData implements IRefObject, IClone { /** * Set four-dimensional vector by shader property. * @remarks Correspondence includes vec4、ivec4 and bvec4 shader property type. - * @param property - Shader property + * @param property - Shader property, use `Shader.getPropertyByName` to get * @param value - Four-dimensional vector */ setVector4(property: ShaderProperty, value: Vector4): void; setVector4(property: string | ShaderProperty, value: Vector4): void { - this._setData(property, value); + this._setPropertyValue(property, ShaderPropertyType.Vector4, value); } /** @@ -317,13 +306,13 @@ export class ShaderData implements IRefObject, IClone { /** * Get matrix by shader property. - * @param property - Shader property + * @param property - Shader property, use `Shader.getPropertyByName` to get * @returns Matrix */ getMatrix(property: ShaderProperty): Matrix; getMatrix(property: string | ShaderProperty): Matrix { - return this._getData(property); + return this.getPropertyValue(property); } /** @@ -337,13 +326,13 @@ export class ShaderData implements IRefObject, IClone { /** * Set matrix by shader property. * @remarks Correspondence includes matrix shader property type. - * @param property - Shader property + * @param property - Shader property, use `Shader.getPropertyByName` to get * @param value - Matrix */ setMatrix(property: ShaderProperty, value: Matrix); setMatrix(property: string | ShaderProperty, value: Matrix): void { - this._setData(property, value); + this._setPropertyValue(property, ShaderPropertyType.Matrix, value); } /** @@ -355,13 +344,13 @@ export class ShaderData implements IRefObject, IClone { /** * Get color by shader property. - * @param property - Shader property + * @param property - Shader property, use `Shader.getPropertyByName` to get * @returns Color */ getColor(property: ShaderProperty): Color; getColor(property: string | ShaderProperty): Color { - return this._getData(property); + return this.getPropertyValue(property); } /** @@ -375,13 +364,13 @@ export class ShaderData implements IRefObject, IClone { /** * Set color by shader property. * @remarks Correspondence includes vec4 shader property type. - * @param property - Shader property + * @param property - Shader property, use `Shader.getPropertyByName` to get * @param value - Color */ setColor(property: ShaderProperty, value: Color): void; setColor(property: string | ShaderProperty, value: Color): void { - this._setData(property, value); + this._setPropertyValue(property, ShaderPropertyType.Color, value); } /** @@ -393,13 +382,13 @@ export class ShaderData implements IRefObject, IClone { /** * Get texture by shader property. - * @param property - Shader property + * @param property - Shader property, use `Shader.getPropertyByName` to get * @returns Texture */ getTexture(property: ShaderProperty): Texture; getTexture(property: string | ShaderProperty): Texture { - return this._getData(property); + return this.getPropertyValue(property); } /** @@ -411,18 +400,18 @@ export class ShaderData implements IRefObject, IClone { /** * Set texture by shader property. - * @param property - Shader property + * @param property - Shader property, use `Shader.getPropertyByName` to get * @param value - Texture */ setTexture(property: ShaderProperty, value: Texture): void; setTexture(property: string | ShaderProperty, value: Texture): void { if (this._getRefCount() > 0) { - const lastValue = this._getData(property); + const lastValue = this.getPropertyValue(property); lastValue && lastValue._addRefCount(-1); value && value._addRefCount(1); } - this._setData(property, value); + this._setPropertyValue(property, ShaderPropertyType.Texture, value); } /** @@ -434,13 +423,13 @@ export class ShaderData implements IRefObject, IClone { /** * Get texture array by shader property. - * @param property - Shader property + * @param property - Shader property, use `Shader.getPropertyByName` to get * @returns Texture array */ getTextureArray(property: ShaderProperty): Texture[]; getTextureArray(property: string | ShaderProperty): Texture[] { - return this._getData(property); + return this.getPropertyValue(property); } /** @@ -452,14 +441,14 @@ export class ShaderData implements IRefObject, IClone { /** * Set texture array by shader property. - * @param property - Shader property + * @param property - Shader property, use `Shader.getPropertyByName` to get * @param value - Texture array */ setTextureArray(property: ShaderProperty, value: Texture[]): void; setTextureArray(property: string | ShaderProperty, value: Texture[]): void { if (this._getRefCount() > 0) { - const lastValue = this._getData(property); + const lastValue = this.getPropertyValue(property); if (lastValue) { for (let i = 0, n = lastValue.length; i < n; i++) { lastValue[i]._addRefCount(-1); @@ -471,7 +460,19 @@ export class ShaderData implements IRefObject, IClone { } } } - this._setData(property, value); + this._setPropertyValue(property, ShaderPropertyType.TextureArray, value); + } + + /** + * Get shader property value set on this shaderData. + * @param property - Shader property + * @returns Property value + */ + getPropertyValue(property: string | ShaderProperty): T { + if (typeof property === "string") { + property = Shader.getPropertyByName(property); + } + return this._propertyValueMap[property._uniqueId] as T; } /** @@ -560,6 +561,38 @@ export class ShaderData implements IRefObject, IClone { } } + /** + * Get all shader properties that have been set on this shaderData + * @returns All shader properties + */ + getProperties(): ShaderProperty[]; + + /** + * Get all shader properties that have been set on this shaderData + * @param out - All shader properties + */ + getProperties(out: ShaderProperty[]): void; + + getProperties(out?: ShaderProperty[]): void | ShaderProperty[] { + let properties: ShaderProperty[]; + if (out) { + out.length = 0; + properties = out; + } else { + properties = []; + } + + const propertyValueMap = this._propertyValueMap; + const propertyIdMap = Shader._propertyIdMap; + for (let key in propertyValueMap) { + properties.push(propertyIdMap[key]); + } + + if (!out) { + return properties; + } + } + clone(): ShaderData { const shaderData = new ShaderData(this._group); this.cloneTo(shaderData); @@ -570,29 +603,29 @@ export class ShaderData implements IRefObject, IClone { CloneManager.deepCloneObject(this._macroCollection, target._macroCollection); Object.assign(target._macroMap, this._macroMap); - const properties = this._properties; - const targetProperties = target._properties; - const keys = Object.keys(properties); + const propertyValueMap = this._propertyValueMap; + const targetPropertyValueMap = target._propertyValueMap; + const keys = Object.keys(propertyValueMap); for (let i = 0, n = keys.length; i < n; i++) { const k = keys[i]; - const property = properties[k]; + const property = propertyValueMap[k]; if (property != null) { if (typeof property === "number") { - targetProperties[k] = property; + targetPropertyValueMap[k] = property; } else if (property instanceof Texture) { - targetProperties[k] = property; + targetPropertyValueMap[k] = property; } else if (property instanceof Array || property instanceof Float32Array || property instanceof Int32Array) { - targetProperties[k] = property.slice(); + targetPropertyValueMap[k] = property.slice(); } else { - const targetProperty = targetProperties[k]; + const targetProperty = targetPropertyValueMap[k]; if (targetProperty) { targetProperty.copyFrom(property); } else { - targetProperties[k] = property.clone(); + targetPropertyValueMap[k] = property.clone(); } } } else { - targetProperties[k] = property; + targetPropertyValueMap[k] = property; } } } @@ -600,17 +633,11 @@ export class ShaderData implements IRefObject, IClone { /** * @internal */ - _getData(property: string | ShaderProperty): T { - if (typeof property === "string") { - property = Shader.getPropertyByName(property); - } - return this._properties[property._uniqueId] as T; - } - - /** - * @internal - */ - _setData(property: string | ShaderProperty, value: T): void { + _setPropertyValue( + property: string | ShaderProperty, + type: ShaderPropertyType, + value: T + ): void { if (typeof property === "string") { property = Shader.getPropertyByName(property); } @@ -619,11 +646,19 @@ export class ShaderData implements IRefObject, IClone { if (property._group === undefined) { property._group = this._group; } else { - throw `Shader property ${property.name} has been used as ${ShaderDataGroup[property._group]} property.`; + throw `Shader property ${property.name} has been used as ${ShaderDataGroup[property._group]} group.`; + } + } + + if (property._type !== type) { + if (property._type === undefined) { + property._type = type; + } else { + throw `Shader property ${property.name} has been used as ${ShaderPropertyType[property._type]} type.`; } } - this._properties[property._uniqueId] = value; + this._propertyValueMap[property._uniqueId] = value; } /** @@ -638,7 +673,7 @@ export class ShaderData implements IRefObject, IClone { */ _addRefCount(value: number): void { this._refCount += value; - const properties = this._properties; + const properties = this._propertyValueMap; for (const k in properties) { const property = properties[k]; // @todo: Separate array to speed performance. @@ -648,3 +683,15 @@ export class ShaderData implements IRefObject, IClone { } } } + +export type ShaderPropertyValueType = + | number + | Vector2 + | Vector3 + | Vector4 + | Color + | Matrix + | Texture + | Texture[] + | Int32Array + | Float32Array; diff --git a/packages/core/src/shader/ShaderProgram.ts b/packages/core/src/shader/ShaderProgram.ts index 84f5c9ebde..7320147f41 100644 --- a/packages/core/src/shader/ShaderProgram.ts +++ b/packages/core/src/shader/ShaderProgram.ts @@ -104,12 +104,12 @@ export class ShaderProgram { * @param shaderData - shader data */ uploadUniforms(uniformBlock: ShaderUniformBlock, shaderData: ShaderData): void { - const properties = shaderData._properties; + const propertyValueMap = shaderData._propertyValueMap; const constUniforms = uniformBlock.constUniforms; for (let i = 0, n = constUniforms.length; i < n; i++) { const uniform = constUniforms[i]; - const data = properties[uniform.propertyId]; + const data = propertyValueMap[uniform.propertyId]; data != null && uniform.applyFunc(uniform, data); } } @@ -120,13 +120,13 @@ export class ShaderProgram { * @param shaderData - shader data */ uploadTextures(uniformBlock: ShaderUniformBlock, shaderData: ShaderData): void { - const properties = shaderData._properties; + const propertyValueMap = shaderData._propertyValueMap; const textureUniforms = uniformBlock.textureUniforms; // textureUniforms property maybe null if ShaderUniformBlock not contain any texture. if (textureUniforms) { for (let i = 0, n = textureUniforms.length; i < n; i++) { const uniform = textureUniforms[i]; - const texture = properties[uniform.propertyId]; + const texture = propertyValueMap[uniform.propertyId]; if (texture && !texture.destroyed) { uniform.applyFunc(uniform, texture); } else { @@ -153,7 +153,7 @@ export class ShaderProgram { /** * Grouping other data. */ - groupingOtherUniformBlock() { + groupingOtherUniformBlock(): void { const { constUniforms, textureUniforms } = this.otherUniformBlock; constUniforms.length > 0 && this._groupingSubOtherUniforms(constUniforms, false); textureUniforms.length > 0 && this._groupingSubOtherUniforms(textureUniforms, true); @@ -309,7 +309,7 @@ export class ShaderProgram { /** * record the location of uniform/attribute. */ - private _recordLocation() { + private _recordLocation(): void { const gl = this._gl; const program = this._glProgram; const uniformInfos = this._getUniformInfos(); @@ -325,7 +325,6 @@ export class ShaderProgram { isArray = true; } - const group = Shader._getShaderPropertyGroup(name); const location = gl.getUniformLocation(program, name); shaderUniform.name = name; shaderUniform.propertyId = Shader.getPropertyByName(name)._uniqueId; @@ -449,6 +448,8 @@ export class ShaderProgram { } break; } + + const group = Shader._getShaderPropertyGroup(name); this._groupingUniform(shaderUniform, group, isTexture); }); diff --git a/packages/core/src/shader/ShaderProperty.ts b/packages/core/src/shader/ShaderProperty.ts index dd8945427b..f4de346b2e 100644 --- a/packages/core/src/shader/ShaderProperty.ts +++ b/packages/core/src/shader/ShaderProperty.ts @@ -1,4 +1,5 @@ import { ShaderDataGroup } from "./enums/ShaderDataGroup"; +import { ShaderPropertyType } from "./enums/ShaderPropertyType"; /** * Shader property. @@ -10,10 +11,19 @@ export class ShaderProperty { _uniqueId: number; /** @internal */ _group: ShaderDataGroup; + /** @internal */ + _type: ShaderPropertyType; /** Shader property name. */ readonly name: string; + /** + * Shader property type. + */ + get type(): ShaderPropertyType { + return this._type; + } + /** * @internal */ diff --git a/packages/core/src/shader/enums/ShaderPropertyType.ts b/packages/core/src/shader/enums/ShaderPropertyType.ts new file mode 100644 index 0000000000..594d3054ca --- /dev/null +++ b/packages/core/src/shader/enums/ShaderPropertyType.ts @@ -0,0 +1,27 @@ +/** + * Shader Property type. + */ +export enum ShaderPropertyType { + /** Float type. */ + Float, + /** Int type. */ + Int, + /** Vector2 type. */ + Vector2, + /** Vector3 type. */ + Vector3, + /** Vector4 type. */ + Vector4, + /** Matrix type. */ + Matrix, + /** Color type. */ + Color, + /** Texture type. */ + Texture, + /** Float array type. */ + FloatArray, + /** Int array type. */ + IntArray, + /** Texture array type. */ + TextureArray +} diff --git a/packages/core/src/shader/index.ts b/packages/core/src/shader/index.ts index 2b417230b3..4ba9d0bf57 100644 --- a/packages/core/src/shader/index.ts +++ b/packages/core/src/shader/index.ts @@ -4,8 +4,11 @@ export { BlendOperation } from "./enums/BlendOperation"; export { ColorWriteMask } from "./enums/ColorWriteMask"; export { CompareFunction } from "./enums/CompareFunction"; export { CullMode } from "./enums/CullMode"; +export { ShaderPropertyType } from "./enums/ShaderPropertyType"; export { StencilOperation } from "./enums/StencilOperation"; export { Shader } from "./Shader"; export { ShaderData } from "./ShaderData"; export { ShaderPass } from "./ShaderPass"; +export { ShaderProperty } from "./ShaderProperty"; + diff --git a/tests/src/core/material/Material.test.ts b/tests/src/core/material/Material.test.ts new file mode 100644 index 0000000000..16291c4be9 --- /dev/null +++ b/tests/src/core/material/Material.test.ts @@ -0,0 +1,92 @@ +import { Material, Shader, ShaderPropertyType, Texture2D, Texture2DArray } from "@oasis-engine/core"; +import { Color, Matrix, Vector2, Vector3, Vector4 } from "@oasis-engine/math"; +import { WebGLEngine } from "@oasis-engine/rhi-webgl"; +import { expect } from "chai"; + +describe("Material", () => { + const canvas = document.createElement("canvas"); + const engine = new WebGLEngine(canvas); + + it("property", () => { + const color = new Color(0.2, 0.1, 0.3, 1.0); + const vector2 = new Vector2(0.1, 0.2); + const vector3 = new Vector3(0.1, 0.2, 0.3); + const vector4 = new Vector4(0.1, 0.2, 0.4, 1.0); + const matrix = new Matrix(0.1, 0.2, 0.4, 1.0); + // @ts-ignore + const texture = new Texture2D(engine, 64, 64); + // @ts-ignore + const textureArray = new Texture2DArray(engine, 64, 64, 6); + const intArray = new Int32Array([5, 6, 6, 6]); + const floatArray = new Float32Array([0.4, 0.323, 2323.232, 23.232]); + + const material = new Material(engine, Shader.find("blinn-phong")); + const shaderData = material.shaderData; + + shaderData.setFloat("_float", 0.2); + shaderData.setInt("_int", 6); + shaderData.setColor("_color", color); + shaderData.setVector2("_vector2", vector2); + shaderData.setVector3("_vector3", vector3); + shaderData.setVector4("_vector4", vector4); + shaderData.setMatrix("_matrix", matrix); + // @ts-ignore + shaderData.setTexture("_texture", texture); + // @ts-ignore + shaderData.setTextureArray("_textureArray", textureArray); + shaderData.setIntArray("_intArray", intArray); + shaderData.setFloatArray("_floatArray", floatArray); + + expect(shaderData.getFloat("_float")).to.equal(0.2); + expect(shaderData.getInt("_int")).to.equal(6); + expect(shaderData.getFloat("_color")).to.equal(color); + expect(shaderData.getFloat("_vector2")).to.equal(vector2); + expect(shaderData.getFloat("_vector3")).to.equal(vector3); + expect(shaderData.getFloat("_vector4")).to.equal(vector4); + expect(shaderData.getFloat("_matrix")).to.equal(matrix); + expect(shaderData.getFloat("_texture")).to.equal(texture); + expect(shaderData.getFloat("_textureArray")).to.equal(textureArray); + expect(shaderData.getFloat("_intArray")).to.equal(intArray); + expect(shaderData.getFloat("_floatArray")).to.equal(floatArray); + + const shaderProperties = shaderData.getProperties(); + for (let i = 0, n = shaderProperties.length; i < n; i++) { + const shaderProperty = shaderProperties[i]; + switch (shaderProperty.type) { + case ShaderPropertyType.Float: + expect(shaderData.getFloat(shaderProperty)).to.equal(0.2); + break; + case ShaderPropertyType.Int: + expect(shaderData.getInt(shaderProperty)).to.equal(6); + break; + case ShaderPropertyType.Color: + expect(shaderData.getColor(shaderProperty)).to.equal(color); + break; + case ShaderPropertyType.Vector2: + expect(shaderData.getVector2(shaderProperty)).to.equal(vector2); + break; + case ShaderPropertyType.Vector3: + expect(shaderData.getVector3(shaderProperty)).to.equal(vector3); + break; + case ShaderPropertyType.Vector4: + expect(shaderData.getVector4(shaderProperty)).to.equal(vector4); + break; + case ShaderPropertyType.Matrix: + expect(shaderData.getMatrix(shaderProperty)).to.equal(matrix); + break; + case ShaderPropertyType.Texture: + expect(shaderData.getTexture(shaderProperty)).to.equal(texture); + break; + case ShaderPropertyType.TextureArray: + expect(shaderData.getTextureArray(shaderProperty)).to.equal(textureArray); + break; + case ShaderPropertyType.IntArray: + expect(shaderData.getIntArray(shaderProperty)).to.equal(intArray); + break; + case ShaderPropertyType.FloatArray: + expect(shaderData.getFloatArray(shaderProperty)).to.equal(floatArray); + break; + } + } + }); +});