1371 lines
43 KiB
JavaScript
1371 lines
43 KiB
JavaScript
defineSuite([
|
|
'Renderer/Texture',
|
|
'Core/Cartesian2',
|
|
'Core/Color',
|
|
'Core/loadKTX',
|
|
'Core/PixelFormat',
|
|
'Core/Resource',
|
|
'Renderer/ClearCommand',
|
|
'Renderer/ContextLimits',
|
|
'Renderer/PixelDatatype',
|
|
'Renderer/Sampler',
|
|
'Renderer/TextureMagnificationFilter',
|
|
'Renderer/TextureMinificationFilter',
|
|
'Renderer/TextureWrap',
|
|
'Specs/createContext',
|
|
'ThirdParty/when'
|
|
], function(
|
|
Texture,
|
|
Cartesian2,
|
|
Color,
|
|
loadKTX,
|
|
PixelFormat,
|
|
Resource,
|
|
ClearCommand,
|
|
ContextLimits,
|
|
PixelDatatype,
|
|
Sampler,
|
|
TextureMagnificationFilter,
|
|
TextureMinificationFilter,
|
|
TextureWrap,
|
|
createContext,
|
|
when) {
|
|
'use strict';
|
|
|
|
var context;
|
|
var greenImage;
|
|
var blueImage;
|
|
var blueAlphaImage;
|
|
var blueOverRedImage;
|
|
var red16x16Image;
|
|
|
|
var greenDXTImage;
|
|
var greenPVRImage;
|
|
var greenETC1Image;
|
|
|
|
var fs =
|
|
'uniform sampler2D u_texture;' +
|
|
'void main() { gl_FragColor = texture2D(u_texture, vec2(0.0)); }';
|
|
var texture;
|
|
var uniformMap = {
|
|
u_texture : function() {
|
|
return texture;
|
|
}
|
|
};
|
|
|
|
beforeAll(function() {
|
|
context = createContext();
|
|
|
|
var promises = [];
|
|
promises.push(Resource.fetchImage('./Data/Images/Green.png').then(function(image) {
|
|
greenImage = image;
|
|
}));
|
|
promises.push(Resource.fetchImage('./Data/Images/Blue.png').then(function(image) {
|
|
blueImage = image;
|
|
}));
|
|
promises.push(Resource.fetchImage('./Data/Images/BlueAlpha.png').then(function(image) {
|
|
blueAlphaImage = image;
|
|
}));
|
|
promises.push(Resource.fetchImage('./Data/Images/BlueOverRed.png').then(function(image) {
|
|
blueOverRedImage = image;
|
|
}));
|
|
promises.push(Resource.fetchImage('./Data/Images/Red16x16.png').then(function(image) {
|
|
red16x16Image = image;
|
|
}));
|
|
promises.push(loadKTX('./Data/Images/Green4x4DXT1.ktx').then(function(image) {
|
|
greenDXTImage = image;
|
|
}));
|
|
promises.push(loadKTX('./Data/Images/Green4x4PVR.ktx').then(function(image) {
|
|
greenPVRImage = image;
|
|
}));
|
|
promises.push(loadKTX('./Data/Images/Green4x4ETC1.ktx').then(function(image) {
|
|
greenETC1Image = image;
|
|
}));
|
|
|
|
return when.all(promises);
|
|
});
|
|
|
|
afterAll(function() {
|
|
context.destroyForSpecs();
|
|
});
|
|
|
|
afterEach(function() {
|
|
texture = texture && texture.destroy();
|
|
});
|
|
|
|
it('has expected default values for pixel format and datatype', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
source : blueImage
|
|
});
|
|
|
|
expect(texture.id).toBeDefined();
|
|
expect(texture.pixelFormat).toEqual(PixelFormat.RGBA);
|
|
expect(texture.pixelDatatype).toEqual(PixelDatatype.UNSIGNED_BYTE);
|
|
});
|
|
|
|
it('can create a texture from the framebuffer', function() {
|
|
var command = new ClearCommand({
|
|
color : Color.RED
|
|
});
|
|
command.execute(context);
|
|
|
|
texture = Texture.fromFramebuffer({
|
|
context : context
|
|
});
|
|
|
|
var expectedWidth = context.canvas.clientWidth;
|
|
var expectedHeight = context.canvas.clientHeight;
|
|
expect(texture.width).toEqual(expectedWidth);
|
|
expect(texture.height).toEqual(expectedHeight);
|
|
expect(texture.sizeInBytes).toEqual(expectedWidth * expectedHeight * PixelFormat.componentsLength(texture.pixelFormat));
|
|
|
|
command.color = Color.WHITE;
|
|
command.execute(context);
|
|
expect(context).toReadPixels([255, 255, 255, 255]);
|
|
|
|
expect({
|
|
context : context,
|
|
fragmentShader : fs,
|
|
uniformMap : uniformMap
|
|
}).contextToRender([255, 0, 0, 255]);
|
|
});
|
|
|
|
it('can copy from the framebuffer', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
source : blueImage,
|
|
pixelFormat : PixelFormat.RGB
|
|
});
|
|
|
|
// Render blue
|
|
expect({
|
|
context : context,
|
|
fragmentShader : fs,
|
|
uniformMap : uniformMap
|
|
}).contextToRender([0, 0, 255, 255]);
|
|
|
|
// Clear to red
|
|
var command = new ClearCommand({
|
|
color : Color.RED
|
|
});
|
|
command.execute(context);
|
|
expect(context).toReadPixels(Color.RED.toBytes());
|
|
|
|
texture.copyFromFramebuffer();
|
|
|
|
var expectedWidth = context.canvas.clientWidth;
|
|
var expectedHeight = context.canvas.clientHeight;
|
|
expect(texture.width).toEqual(expectedWidth);
|
|
expect(texture.height).toEqual(expectedHeight);
|
|
expect(texture.sizeInBytes).toEqual(expectedWidth * expectedHeight * PixelFormat.componentsLength(texture.pixelFormat));
|
|
|
|
// Clear to white
|
|
command.color = Color.WHITE;
|
|
command.execute(context);
|
|
expect(context).toReadPixels(Color.WHITE.toBytes());
|
|
|
|
// Render red
|
|
expect({
|
|
context : context,
|
|
fragmentShader : fs,
|
|
uniformMap : uniformMap
|
|
}).contextToRender([255, 0, 0, 255]);
|
|
});
|
|
|
|
it('draws the expected texture color', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
source : blueImage,
|
|
pixelFormat : PixelFormat.RGBA
|
|
});
|
|
|
|
expect({
|
|
context : context,
|
|
fragmentShader : fs,
|
|
uniformMap : uniformMap
|
|
}).contextToRender([0, 0, 255, 255]);
|
|
});
|
|
|
|
it('draws the expected floating-point texture color', function() {
|
|
if (!context.floatingPointTexture) {
|
|
return;
|
|
}
|
|
|
|
var color = new Color(0.2, 0.4, 0.6, 1.0);
|
|
var floats = new Float32Array([color.red, color.green, color.blue, color.alpha]);
|
|
|
|
texture = new Texture({
|
|
context : context,
|
|
pixelFormat : PixelFormat.RGBA,
|
|
pixelDatatype : PixelDatatype.FLOAT,
|
|
source : {
|
|
width : 1,
|
|
height : 1,
|
|
arrayBufferView : floats
|
|
}
|
|
});
|
|
|
|
expect(texture.sizeInBytes).toEqual(16);
|
|
|
|
expect({
|
|
context : context,
|
|
fragmentShader : fs,
|
|
uniformMap : uniformMap
|
|
}).contextToRender(color.toBytes());
|
|
});
|
|
|
|
it('draws the expected floating-point texture color with linear filtering', function() {
|
|
if (!context.floatingPointTexture) {
|
|
return;
|
|
}
|
|
|
|
var color0 = new Color(0.2, 0.4, 0.6, 1.0);
|
|
var color1 = new Color(0.1, 0.3, 0.5, 1.0);
|
|
var floats = new Float32Array([color0.red, color0.green, color0.blue, color0.alpha,
|
|
color1.red, color1.green, color1.blue, color1.alpha]);
|
|
|
|
texture = new Texture({
|
|
context : context,
|
|
pixelFormat : PixelFormat.RGBA,
|
|
pixelDatatype : PixelDatatype.FLOAT,
|
|
source : {
|
|
width : 2,
|
|
height : 1,
|
|
arrayBufferView : floats
|
|
},
|
|
sampler : new Sampler({
|
|
wrapS : TextureWrap.CLAMP_TO_EDGE,
|
|
wrapT : TextureWrap.CLAMP_TO_EDGE,
|
|
minificationFilter : TextureMinificationFilter.LINEAR,
|
|
magnificationFilter : TextureMagnificationFilter.LINEAR
|
|
})
|
|
});
|
|
|
|
expect(texture.sizeInBytes).toEqual(32);
|
|
|
|
var fs =
|
|
'uniform sampler2D u_texture;' +
|
|
'void main() { gl_FragColor = texture2D(u_texture, vec2(0.5, 0.0)); }';
|
|
|
|
if (!context.textureFloatLinear) {
|
|
expect({
|
|
context : context,
|
|
fragmentShader : fs,
|
|
uniformMap : uniformMap,
|
|
epsilon : 1
|
|
}).contextToRender(color1.toBytes());
|
|
} else {
|
|
Color.multiplyByScalar(color0, 1.0 - 0.5, color0);
|
|
Color.multiplyByScalar(color1, 0.5, color1);
|
|
Color.add(color0, color1, color1);
|
|
expect({
|
|
context : context,
|
|
fragmentShader : fs,
|
|
uniformMap : uniformMap
|
|
}).contextToRender(color1.toBytes());
|
|
}
|
|
});
|
|
|
|
it('draws the expected half floating-point texture color', function() {
|
|
if (!context.halfFloatingPointTexture) {
|
|
return;
|
|
}
|
|
|
|
var color = new Color(0.2, 0.4, 0.6, 1.0);
|
|
var floats = new Uint16Array([12902, 13926, 14541, 15360]);
|
|
|
|
texture = new Texture({
|
|
context : context,
|
|
pixelFormat : PixelFormat.RGBA,
|
|
pixelDatatype : PixelDatatype.HALF_FLOAT,
|
|
source : {
|
|
width : 1,
|
|
height : 1,
|
|
arrayBufferView : floats
|
|
},
|
|
flipY : false
|
|
});
|
|
|
|
expect(texture.sizeInBytes).toEqual(8);
|
|
|
|
expect({
|
|
context : context,
|
|
fragmentShader : fs,
|
|
uniformMap : uniformMap
|
|
}).contextToRender(color.toBytes());
|
|
});
|
|
|
|
it('draws the expected half floating-point texture color with linear filtering', function() {
|
|
if (!context.halfFloatingPointTexture) {
|
|
return;
|
|
}
|
|
|
|
var color0 = new Color(0.2, 0.4, 0.6, 1.0);
|
|
var color1 = new Color(0.1, 0.3, 0.5, 1.0);
|
|
var floats = new Uint16Array([12902, 13926, 14541, 15360,
|
|
11878, 13517, 14336, 15360]);
|
|
|
|
texture = new Texture({
|
|
context : context,
|
|
pixelFormat : PixelFormat.RGBA,
|
|
pixelDatatype : PixelDatatype.HALF_FLOAT,
|
|
source : {
|
|
width : 2,
|
|
height : 1,
|
|
arrayBufferView : floats
|
|
},
|
|
flipY : false
|
|
});
|
|
|
|
expect(texture.sizeInBytes).toEqual(16);
|
|
|
|
var fs =
|
|
'uniform sampler2D u_texture;' +
|
|
'void main() { gl_FragColor = texture2D(u_texture, vec2(0.5, 0.0)); }';
|
|
|
|
if (!context.textureHalfFloatLinear) {
|
|
expect({
|
|
context : context,
|
|
fragmentShader : fs,
|
|
uniformMap : uniformMap,
|
|
epsilon : 1
|
|
}).contextToRender(color1.toBytes());
|
|
} else {
|
|
Color.multiplyByScalar(color0, 1.0 - 0.5, color0);
|
|
Color.multiplyByScalar(color1, 0.5, color1);
|
|
Color.add(color0, color1, color1);
|
|
expect({
|
|
context : context,
|
|
fragmentShader : fs,
|
|
uniformMap : uniformMap
|
|
}).contextToRender(color1.toBytes());
|
|
}
|
|
});
|
|
|
|
it('draws the expected DXT compressed texture color', function() {
|
|
if (!context.s3tc) {
|
|
return;
|
|
}
|
|
|
|
texture = new Texture({
|
|
context : context,
|
|
pixelFormat : greenDXTImage.internalFormat,
|
|
source : {
|
|
width : greenDXTImage.width,
|
|
height : greenDXTImage.height,
|
|
arrayBufferView : greenDXTImage.bufferView
|
|
}
|
|
});
|
|
|
|
expect(texture.sizeInBytes).toBe(8);
|
|
|
|
expect({
|
|
context : context,
|
|
fragmentShader : fs,
|
|
uniformMap : uniformMap
|
|
}).contextToRender([0, 255, 0, 255]);
|
|
});
|
|
|
|
it('draws the expected PVR compressed texture color', function() {
|
|
if (!context.pvrtc) {
|
|
return;
|
|
}
|
|
|
|
texture = new Texture({
|
|
context : context,
|
|
pixelFormat : greenPVRImage.internalFormat,
|
|
source : {
|
|
width : greenPVRImage.width,
|
|
height : greenPVRImage.height,
|
|
arrayBufferView : greenPVRImage.bufferView
|
|
}
|
|
});
|
|
|
|
expect(texture.sizeInBytes).toBe(32);
|
|
|
|
expect({
|
|
context : context,
|
|
fragmentShader : fs,
|
|
uniformMap : uniformMap
|
|
}).contextToRender([0, 255, 0, 255]);
|
|
});
|
|
|
|
it('draws the expected ETC1 compressed texture color', function() {
|
|
if (!context.etc1) {
|
|
return;
|
|
}
|
|
|
|
texture = new Texture({
|
|
context : context,
|
|
pixelFormat : greenETC1Image.internalFormat,
|
|
source : {
|
|
width : greenETC1Image.width,
|
|
height : greenETC1Image.height,
|
|
arrayBufferView : greenETC1Image.bufferView
|
|
}
|
|
});
|
|
|
|
expect(texture.sizeInBytes).toBe(8);
|
|
|
|
expect({
|
|
context : context,
|
|
fragmentShader : fs,
|
|
uniformMap : uniformMap
|
|
}).contextToRender([0, 253, 0, 255]);
|
|
});
|
|
|
|
it('renders with premultiplied alpha', function() {
|
|
var cxt = createContext({
|
|
webgl : {
|
|
alpha : true
|
|
}
|
|
});
|
|
var texture = new Texture({
|
|
context : cxt,
|
|
source : blueAlphaImage,
|
|
pixelFormat : PixelFormat.RGBA,
|
|
preMultiplyAlpha : true
|
|
});
|
|
var uniformMap = {
|
|
u_texture : function() {
|
|
return texture;
|
|
}
|
|
};
|
|
|
|
expect(texture.preMultiplyAlpha).toEqual(true);
|
|
expect({
|
|
context : cxt,
|
|
fragmentShader : fs,
|
|
uniformMap : uniformMap,
|
|
epsilon : 1
|
|
}).contextToRender([0, 0, 127, 127]);
|
|
|
|
texture.destroy();
|
|
cxt.destroyForSpecs();
|
|
});
|
|
|
|
it('draws textured blue and red points', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
source : blueOverRedImage,
|
|
pixelFormat : PixelFormat.RGBA
|
|
});
|
|
|
|
var fragmentShaderSource = '';
|
|
fragmentShaderSource += 'uniform sampler2D u_texture;';
|
|
fragmentShaderSource += 'uniform mediump vec2 u_txCoords;';
|
|
fragmentShaderSource += 'void main() { gl_FragColor = texture2D(u_texture, u_txCoords); }';
|
|
|
|
var txCoords;
|
|
var um = {
|
|
u_texture : function() {
|
|
return texture;
|
|
},
|
|
u_txCoords : function() {
|
|
return txCoords;
|
|
}
|
|
};
|
|
|
|
// Blue on top
|
|
txCoords = new Cartesian2(0.5, 0.75);
|
|
expect({
|
|
context : context,
|
|
fragmentShader : fragmentShaderSource,
|
|
uniformMap : um
|
|
}).contextToRender([0, 0, 255, 255]);
|
|
|
|
// Red on bottom
|
|
txCoords = new Cartesian2(0.5, 0.25);
|
|
expect({
|
|
context : context,
|
|
fragmentShader : fragmentShaderSource,
|
|
uniformMap : um
|
|
}).contextToRender([255, 0, 0, 255]);
|
|
});
|
|
|
|
it('can be created from a typed array', function() {
|
|
var bytes = new Uint8Array([0, 255, 0, 255]);
|
|
|
|
texture = new Texture({
|
|
context : context,
|
|
pixelFormat : PixelFormat.RGBA,
|
|
pixelDatatype : PixelDatatype.UNSIGNED_BYTE,
|
|
source : {
|
|
width : 1,
|
|
height : 1,
|
|
arrayBufferView : bytes
|
|
}
|
|
});
|
|
|
|
expect(texture.width).toEqual(1);
|
|
expect(texture.height).toEqual(1);
|
|
expect(texture.sizeInBytes).toEqual(4);
|
|
|
|
expect({
|
|
context : context,
|
|
fragmentShader : fs,
|
|
uniformMap : uniformMap
|
|
}).contextToRender([0, 255, 0, 255]);
|
|
});
|
|
|
|
it('can copy from a typed array', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
pixelFormat : PixelFormat.RGBA,
|
|
pixelDatatype : PixelDatatype.UNSIGNED_BYTE,
|
|
width : 1,
|
|
height : 1
|
|
});
|
|
|
|
var bytes = new Uint8Array(Color.NAVY.toBytes());
|
|
texture.copyFrom({
|
|
width : 1,
|
|
height : 1,
|
|
arrayBufferView : bytes
|
|
});
|
|
|
|
expect(texture.width).toEqual(1);
|
|
expect(texture.height).toEqual(1);
|
|
expect(texture.sizeInBytes).toEqual(4);
|
|
|
|
expect({
|
|
context : context,
|
|
fragmentShader : fs,
|
|
uniformMap : uniformMap
|
|
}).contextToRender(Color.NAVY.toBytes());
|
|
});
|
|
|
|
it('can copy from a DOM element', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
pixelFormat : PixelFormat.RGB,
|
|
pixelDatatype : PixelDatatype.UNSIGNED_BYTE,
|
|
width : blueImage.width,
|
|
height : blueImage.height
|
|
});
|
|
|
|
texture.copyFrom(blueImage);
|
|
|
|
expect({
|
|
context : context,
|
|
fragmentShader : fs,
|
|
uniformMap : uniformMap,
|
|
epsilon : 1
|
|
}).contextToRender([0, 0, 255, 255]);
|
|
});
|
|
|
|
it('can replace a subset of a texture', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
source : blueOverRedImage,
|
|
pixelFormat : PixelFormat.RGBA
|
|
});
|
|
|
|
var fragmentShaderSource = '';
|
|
fragmentShaderSource += 'uniform sampler2D u_texture;';
|
|
fragmentShaderSource += 'uniform mediump vec2 u_txCoords;';
|
|
fragmentShaderSource += 'void main() { gl_FragColor = texture2D(u_texture, u_txCoords); }';
|
|
|
|
var txCoords;
|
|
var um = {
|
|
u_texture : function() {
|
|
return texture;
|
|
},
|
|
u_txCoords : function() {
|
|
return txCoords;
|
|
}
|
|
};
|
|
|
|
// Blue on top
|
|
txCoords = new Cartesian2(0.5, 0.75);
|
|
expect({
|
|
context : context,
|
|
fragmentShader : fragmentShaderSource,
|
|
uniformMap : um
|
|
}).contextToRender([0, 0, 255, 255]);
|
|
|
|
// Red on bottom
|
|
txCoords = new Cartesian2(0.5, 0.25);
|
|
expect({
|
|
context : context,
|
|
fragmentShader : fragmentShaderSource,
|
|
uniformMap : um
|
|
}).contextToRender([255, 0, 0, 255]);
|
|
|
|
// After copy...
|
|
texture.copyFrom(greenImage, 0, 1);
|
|
|
|
// Now green on top
|
|
txCoords = new Cartesian2(0.5, 0.75);
|
|
expect({
|
|
context : context,
|
|
fragmentShader : fragmentShaderSource,
|
|
uniformMap : um
|
|
}).contextToRender(Color.LIME.toBytes());
|
|
|
|
// Still red on bottom
|
|
txCoords = new Cartesian2(0.5, 0.25);
|
|
expect({
|
|
context : context,
|
|
fragmentShader : fragmentShaderSource,
|
|
uniformMap : um
|
|
}).contextToRender([255, 0, 0, 255]);
|
|
});
|
|
|
|
it('can generate mipmaps', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
source : red16x16Image,
|
|
pixelFormat : PixelFormat.RGBA,
|
|
sampler : new Sampler({
|
|
minificationFilter : TextureMinificationFilter.NEAREST_MIPMAP_LINEAR
|
|
})
|
|
});
|
|
texture.generateMipmap();
|
|
expect(texture.sizeInBytes).toEqualEpsilon((16*16 + 8*8 + 4*4 + 2*2 + 1) * 4, 1);
|
|
|
|
expect({
|
|
context : context,
|
|
fragmentShader : fs,
|
|
uniformMap : uniformMap
|
|
}).contextToRender([255, 0, 0, 255]);
|
|
});
|
|
|
|
it('can set a sampler property', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
source : blueImage,
|
|
pixelFormat : PixelFormat.RGBA
|
|
});
|
|
|
|
var sampler = new Sampler({
|
|
wrapS : TextureWrap.REPEAT,
|
|
wrapT : TextureWrap.MIRRORED_REPEAT,
|
|
minificationFilter : TextureMinificationFilter.NEAREST,
|
|
magnificationFilter : TextureMagnificationFilter.NEAREST,
|
|
maximumAnisotropy : 2.0
|
|
});
|
|
texture.sampler = sampler;
|
|
|
|
var s = texture.sampler;
|
|
expect(s.wrapS).toEqual(sampler.wrapS);
|
|
expect(s.wrapT).toEqual(sampler.wrapT);
|
|
expect(s.minificationFilter).toEqual(sampler.minificationFilter);
|
|
expect(s.magnificationFilter).toEqual(sampler.magnificationFilter);
|
|
expect(s.maximumAnisotropy).toEqual(2.0);
|
|
});
|
|
|
|
it('can set sampler at construction', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
source : blueImage,
|
|
pixelFormat : PixelFormat.RGBA,
|
|
sampler : new Sampler({
|
|
wrapS : TextureWrap.REPEAT,
|
|
wrapT : TextureWrap.MIRRORED_REPEAT,
|
|
minificationFilter : TextureMinificationFilter.NEAREST,
|
|
magnificationFilter : TextureMagnificationFilter.NEAREST,
|
|
maximumAnisotropy : 2.0
|
|
})
|
|
});
|
|
|
|
var s = texture.sampler;
|
|
expect(s.wrapS).toEqual(TextureWrap.REPEAT);
|
|
expect(s.wrapT).toEqual(TextureWrap.MIRRORED_REPEAT);
|
|
expect(s.minificationFilter).toEqual(TextureMinificationFilter.NEAREST);
|
|
expect(s.magnificationFilter).toEqual(TextureMagnificationFilter.NEAREST);
|
|
expect(s.maximumAnisotropy).toEqual(2.0);
|
|
});
|
|
|
|
it('can get width and height', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
source : blueOverRedImage,
|
|
pixelFormat : PixelFormat.RGBA
|
|
});
|
|
|
|
expect(texture.width).toEqual(1);
|
|
expect(texture.height).toEqual(2);
|
|
});
|
|
|
|
it('can get whether Y is flipped', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
source : blueOverRedImage,
|
|
pixelFormat : PixelFormat.RGBA,
|
|
flipY : true
|
|
});
|
|
|
|
expect(texture.flipY).toEqual(true);
|
|
});
|
|
|
|
it('can get the dimensions of a texture', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
width : 64,
|
|
height : 16
|
|
});
|
|
|
|
expect(texture.dimensions).toEqual(new Cartesian2(64, 16));
|
|
});
|
|
|
|
function expectTextureByteSize(width, height, pixelFormat, pixelDatatype, expectedSize) {
|
|
texture = new Texture({
|
|
context : context,
|
|
width : width,
|
|
height : height,
|
|
pixelFormat : pixelFormat,
|
|
pixelDatatype : pixelDatatype
|
|
});
|
|
expect(texture.sizeInBytes).toBe(expectedSize);
|
|
texture = texture && texture.destroy();
|
|
}
|
|
|
|
it('can get the size in bytes of a texture', function() {
|
|
// Depth textures
|
|
if (context.depthTexture) {
|
|
expectTextureByteSize(16, 16, PixelFormat.DEPTH_COMPONENT, PixelDatatype.UNSIGNED_SHORT, 256 * 2);
|
|
expectTextureByteSize(16, 16, PixelFormat.DEPTH_COMPONENT, PixelDatatype.UNSIGNED_INT, 256 * 4);
|
|
expectTextureByteSize(16, 16, PixelFormat.DEPTH_STENCIL, PixelDatatype.UNSIGNED_INT_24_8, 256 * 4);
|
|
}
|
|
|
|
// Uncompressed formats
|
|
expectTextureByteSize(16, 16, PixelFormat.ALPHA, PixelDatatype.UNSIGNED_BYTE, 256);
|
|
expectTextureByteSize(16, 16, PixelFormat.RGB, PixelDatatype.UNSIGNED_BYTE, 256 * 3);
|
|
expectTextureByteSize(16, 16, PixelFormat.RGBA, PixelDatatype.UNSIGNED_BYTE, 256 * 4);
|
|
expectTextureByteSize(16, 16, PixelFormat.LUMINANCE, PixelDatatype.UNSIGNED_BYTE, 256);
|
|
expectTextureByteSize(16, 16, PixelFormat.LUMINANCE_ALPHA, PixelDatatype.UNSIGNED_BYTE, 256 * 2);
|
|
});
|
|
|
|
it('can be destroyed', function() {
|
|
var t = new Texture({
|
|
context : context,
|
|
source : blueImage,
|
|
pixelFormat : PixelFormat.RGBA
|
|
});
|
|
|
|
expect(t.isDestroyed()).toEqual(false);
|
|
t.destroy();
|
|
expect(t.isDestroyed()).toEqual(true);
|
|
});
|
|
|
|
it('throws when creating a texture without a options', function() {
|
|
expect(function() {
|
|
texture = new Texture();
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when creating a texture without a source', function() {
|
|
expect(function() {
|
|
texture = new Texture({
|
|
context : context
|
|
});
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when creating a texture with width and no height', function() {
|
|
expect(function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
width : 16
|
|
});
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when creating a texture with height and no width', function() {
|
|
expect(function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
height : 16
|
|
});
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when creating a texture with zero width', function() {
|
|
expect(function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
width : 0,
|
|
height : 16
|
|
});
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when creating a texture with width larger than the maximum texture size', function() {
|
|
expect(function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
width : ContextLimits.maximumTextureSize + 1,
|
|
height : 16
|
|
});
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when creating a texture with zero height', function() {
|
|
expect(function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
width : 16,
|
|
height : 0
|
|
});
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when creating a texture with height larger than the maximum texture size', function() {
|
|
expect(function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
width : 16,
|
|
height : ContextLimits.maximumTextureSize + 1
|
|
});
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when creating a texture with an invalid pixel format', function() {
|
|
expect(function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
source : blueImage,
|
|
pixelFormat : 'invalid PixelFormat'
|
|
});
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when creating a texture with an invalid pixel datatype', function() {
|
|
expect(function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
source : blueImage,
|
|
pixelFormat : PixelFormat.RGBA,
|
|
pixelDatatype : 'invalid pixelDatatype'
|
|
});
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when creating if pixelFormat is DEPTH_COMPONENT and pixelDatatype is not UNSIGNED_SHORT or UNSIGNED_INT', function() {
|
|
expect(function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
pixelFormat : PixelFormat.DEPTH_COMPONENT,
|
|
pixelDatatype : PixelDatatype.UNSIGNED_BYTE
|
|
});
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when creating if pixelFormat is DEPTH_STENCIL and pixelDatatype is not UNSIGNED_INT_24_8', function() {
|
|
expect(function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
pixelFormat : PixelFormat.DEPTH_STENCIL,
|
|
pixelDatatype : PixelDatatype.UNSIGNED_BYTE
|
|
});
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when creating if pixelFormat is DEPTH_COMPONENT or DEPTH_STENCIL, and source is provided', function() {
|
|
expect(function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
source : blueImage,
|
|
pixelFormat : PixelFormat.DEPTH_COMPONENT,
|
|
pixelDatatype : PixelDatatype.UNSIGNED_SHORT
|
|
});
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when creating if pixelFormat is DEPTH_COMPONENT or DEPTH_STENCIL, and WEBGL_depth_texture is not supported', function() {
|
|
if (!context.depthTexture) {
|
|
expect(function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
width : 1,
|
|
height : 1,
|
|
pixelFormat : PixelFormat.DEPTH_COMPONENT,
|
|
pixelDatatype : PixelDatatype.UNSIGNED_SHORT
|
|
});
|
|
}).toThrowDeveloperError();
|
|
}
|
|
});
|
|
|
|
it('throws when creating if pixelDatatype is FLOAT, and OES_texture_float is not supported', function() {
|
|
if (!context.floatingPointTexture) {
|
|
expect(function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
width : 1,
|
|
height : 1,
|
|
pixelFormat : PixelFormat.RGBA,
|
|
pixelDatatype : PixelDatatype.FLOAT
|
|
});
|
|
}).toThrowDeveloperError();
|
|
}
|
|
});
|
|
|
|
it('throws when creating if pixelDatatype = HALF_FLOAT, and OES_texture_half_float is not supported', function() {
|
|
if (!context.halfFloatingPointTexture) {
|
|
expect(function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
width : 1,
|
|
height : 1,
|
|
pixelFormat : PixelDatatype.RGBA,
|
|
pixelDatatype : PixelDatatype.HALF_FLOAT
|
|
});
|
|
}).toThrowDeveloperError();
|
|
}
|
|
});
|
|
|
|
it('throws when creating compressed texture and the array buffer source is undefined', function() {
|
|
expect(function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
width : 4,
|
|
height : 4,
|
|
pixelFormat : PixelFormat.RGBA_DXT3
|
|
});
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when creating compressed texture when s3tc is unsupported', function() {
|
|
if (!context.s3tc) {
|
|
expect(function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
width :greenDXTImage.width,
|
|
height : greenDXTImage.height,
|
|
pixelFormat : greenDXTImage.internalFormat,
|
|
source : {
|
|
arrayBufferView : greenDXTImage.bufferView
|
|
}
|
|
});
|
|
}).toThrowDeveloperError();
|
|
}
|
|
});
|
|
|
|
it('throws when creating compressed texture when pvrtc is unsupported', function() {
|
|
if (!context.pvrtc) {
|
|
expect(function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
width :greenPVRImage.width,
|
|
height : greenPVRImage.height,
|
|
pixelFormat : greenPVRImage.internalFormat,
|
|
source : {
|
|
arrayBufferView : greenPVRImage.bufferView
|
|
}
|
|
});
|
|
}).toThrowDeveloperError();
|
|
}
|
|
});
|
|
|
|
it('throws when creating compressed texture when etc1 is unsupported', function() {
|
|
if (!context.etc1) {
|
|
expect(function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
width :greenETC1Image.width,
|
|
height : greenETC1Image.height,
|
|
pixelFormat : greenETC1Image.internalFormat,
|
|
source : {
|
|
arrayBufferView : greenETC1Image.bufferView
|
|
}
|
|
});
|
|
}).toThrowDeveloperError();
|
|
}
|
|
});
|
|
|
|
it('throws when creating compressed texture and the array buffer is not the right length', function() {
|
|
if (context.s3tc) {
|
|
expect(function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
width :greenDXTImage.width + 1,
|
|
height : greenDXTImage.height,
|
|
pixelFormat : greenDXTImage.internalFormat,
|
|
source : {
|
|
arrayBufferView : greenDXTImage.bufferView
|
|
}
|
|
});
|
|
}).toThrowDeveloperError();
|
|
}
|
|
});
|
|
|
|
it('throws when creating from the framebuffer with an invalid pixel format', function() {
|
|
expect(function() {
|
|
texture = Texture.fromFramebuffer({
|
|
context : context,
|
|
pixelFormat : 'invalid PixelFormat'
|
|
});
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when creating from the framebuffer if PixelFormat is DEPTH_COMPONENT or DEPTH_STENCIL', function() {
|
|
expect(function() {
|
|
texture = Texture.fromFramebuffer({
|
|
context : context,
|
|
pixelFormat : PixelFormat.DEPTH_COMPONENT
|
|
});
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when creating from the framebuffer with a negative framebufferXOffset', function() {
|
|
expect(function() {
|
|
texture = Texture.fromFramebuffer({
|
|
context : context,
|
|
pixelFormat : PixelFormat.RGB,
|
|
framebufferXOffset : -1
|
|
});
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when creating from the framebuffer with a negative framebufferYOffset', function() {
|
|
expect(function() {
|
|
texture = Texture.fromFramebuffer({
|
|
context : context,
|
|
pixelFormat : PixelFormat.RGB,
|
|
framebufferXOffset : 0,
|
|
framebufferYOffset : -1
|
|
});
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when creating from the framebuffer with a width greater than the canvas clientWidth', function() {
|
|
expect(function() {
|
|
texture = Texture.fromFramebuffer({
|
|
context : context,
|
|
pixelFormat : PixelFormat.RGB,
|
|
framebufferXOffset : 0,
|
|
framebufferYOffset : 0,
|
|
width : context.canvas.clientWidth + 1
|
|
});
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when creating from the framebuffer with a height greater than the canvas clientHeight', function() {
|
|
expect(function() {
|
|
texture = Texture.fromFramebuffer({
|
|
context : context,
|
|
pixelFormat : PixelFormat.RGB,
|
|
framebufferXOffset : 0,
|
|
framebufferYOffset : 0,
|
|
width : 1,
|
|
height : context.canvas.clientHeight + 1
|
|
});
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when copying to a texture from the framebuffer with a DEPTH_COMPONENT or DEPTH_STENCIL pixel format', function() {
|
|
if (context.depthTexture) {
|
|
texture = new Texture({
|
|
context : context,
|
|
width : 1,
|
|
height : 1,
|
|
pixelFormat : PixelFormat.DEPTH_COMPONENT,
|
|
pixelDatatype : PixelDatatype.UNSIGNED_SHORT
|
|
});
|
|
|
|
expect(function() {
|
|
texture.copyFromFramebuffer();
|
|
}).toThrowDeveloperError();
|
|
}
|
|
});
|
|
|
|
it('throws when copying to a texture from the framebuffer with a compressed pixel format', function() {
|
|
if (context.s3tc) {
|
|
texture = new Texture({
|
|
context : context,
|
|
width : greenDXTImage.width,
|
|
height : greenDXTImage.height,
|
|
pixelFormat : greenDXTImage.internalFormat,
|
|
source : {
|
|
arrayBufferView : greenDXTImage.bufferView
|
|
}
|
|
});
|
|
|
|
expect(function() {
|
|
texture.copyFromFramebuffer();
|
|
}).toThrowDeveloperError();
|
|
}
|
|
});
|
|
|
|
it('throws when copying to a texture from the framebuffer with a FLOAT pixel data type', function() {
|
|
if (context.floatingPointTexture) {
|
|
texture = new Texture({
|
|
context : context,
|
|
width : 1,
|
|
height : 1,
|
|
pixelFormat : PixelFormat.RGBA,
|
|
pixelDatatype : PixelDatatype.FLOAT
|
|
});
|
|
|
|
expect(function() {
|
|
texture.copyFromFramebuffer();
|
|
}).toThrowDeveloperError();
|
|
}
|
|
});
|
|
|
|
it('throws when copying to a texture from the framebuffer with a HALF_FLOAT pixel data type', function() {
|
|
if (context.halfFloatingPointTexture) {
|
|
texture = new Texture({
|
|
context : context,
|
|
width : 1,
|
|
height : 1,
|
|
pixelFormat : PixelFormat.RGBA,
|
|
pixelDatatype : PixelDatatype.HALF_FLOAT
|
|
});
|
|
|
|
expect(function() {
|
|
texture.copyFromFramebuffer();
|
|
}).toThrowDeveloperError();
|
|
}
|
|
});
|
|
|
|
it('throws when copying from the framebuffer with a negative xOffset', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
source : blueImage
|
|
});
|
|
|
|
expect(function() {
|
|
texture.copyFromFramebuffer(-1);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when copying from the framebuffer with a negative yOffset', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
source : blueImage
|
|
});
|
|
|
|
expect(function() {
|
|
texture.copyFromFramebuffer(0, -1);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when copying from the framebuffer with a negative framebufferXOffset', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
source : blueImage
|
|
});
|
|
|
|
expect(function() {
|
|
texture.copyFromFramebuffer(0, 0, -1);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when copying from the framebuffer with a negative framebufferYOffset', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
source : blueImage
|
|
});
|
|
|
|
expect(function() {
|
|
texture.copyFromFramebuffer(0, 0, 0, -1);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when copying from the framebuffer with a larger width', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
source : blueImage
|
|
});
|
|
|
|
expect(function() {
|
|
texture.copyFromFramebuffer(0, 0, 0, 0, texture.width + 1);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when copying from the framebuffer with a larger height', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
source : blueImage
|
|
});
|
|
|
|
expect(function() {
|
|
texture.copyFromFramebuffer(0, 0, 0, 0, 0, texture.height + 1);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when copying to a texture with a DEPTH_COMPONENT or DEPTH_STENCIL pixel format', function() {
|
|
if (context.depthTexture) {
|
|
texture = new Texture({
|
|
context : context,
|
|
width : 1,
|
|
height : 1,
|
|
pixelFormat : PixelFormat.DEPTH_COMPONENT,
|
|
pixelDatatype : PixelDatatype.UNSIGNED_SHORT
|
|
});
|
|
|
|
expect(function() {
|
|
texture.copyFrom({
|
|
arrayBufferView : new Uint16Array([0]),
|
|
width : 1,
|
|
height : 1
|
|
});
|
|
}).toThrowDeveloperError();
|
|
}
|
|
});
|
|
|
|
it('throws when copyFrom is not given a source', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
source : blueImage
|
|
});
|
|
|
|
expect(function() {
|
|
texture.copyFrom();
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when copyFrom is given a negative xOffset', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
source : blueImage
|
|
});
|
|
|
|
expect(function() {
|
|
texture.copyFrom(blueImage, -1);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when copyFrom is given a negative yOffset', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
source : blueImage
|
|
});
|
|
|
|
expect(function() {
|
|
texture.copyFrom(blueImage, 0, -1);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when copyFrom is given a source with larger width', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
source : blueImage
|
|
});
|
|
var image = new Image();
|
|
image.width = blueImage.width + 1;
|
|
|
|
expect(function() {
|
|
texture.copyFrom(image);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when copyFrom is given a source with larger height', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
source : blueImage
|
|
});
|
|
var image = new Image();
|
|
image.height = blueImage.height + 1;
|
|
|
|
expect(function() {
|
|
texture.copyFrom(image);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when copyFrom is given a source with a compressed pixel format', function() {
|
|
if (context.s3tc) {
|
|
texture = new Texture({
|
|
context : context,
|
|
width : greenDXTImage.width,
|
|
height : greenDXTImage.height,
|
|
pixelFormat : greenDXTImage.internalFormat,
|
|
source : {
|
|
arrayBufferView : greenDXTImage.bufferView
|
|
}
|
|
});
|
|
|
|
var image = new Image();
|
|
expect(function() {
|
|
texture.copyFrom(image);
|
|
}).toThrowDeveloperError();
|
|
}
|
|
});
|
|
|
|
it('throws when generating mipmaps with a DEPTH_COMPONENT or DEPTH_STENCIL pixel format', function() {
|
|
if (context.depthTexture) {
|
|
texture = new Texture({
|
|
context : context,
|
|
width : 1,
|
|
height : 1,
|
|
pixelFormat : PixelFormat.DEPTH_COMPONENT,
|
|
pixelDatatype : PixelDatatype.UNSIGNED_SHORT
|
|
});
|
|
|
|
expect(function() {
|
|
texture.generateMipmap();
|
|
}).toThrowDeveloperError();
|
|
}
|
|
});
|
|
|
|
it('throws when generating mipmaps with a compressed pixel format', function() {
|
|
if (context.s3tc) {
|
|
texture = new Texture({
|
|
context : context,
|
|
width : greenDXTImage.width,
|
|
height : greenDXTImage.height,
|
|
pixelFormat : greenDXTImage.internalFormat,
|
|
source : {
|
|
arrayBufferView : greenDXTImage.bufferView
|
|
}
|
|
});
|
|
|
|
expect(function() {
|
|
texture.generateMipmap();
|
|
}).toThrowDeveloperError();
|
|
}
|
|
});
|
|
|
|
it('throws when generating mipmaps with a non-power of two width', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
width : 3,
|
|
height : 2
|
|
});
|
|
|
|
expect(function() {
|
|
texture.generateMipmap();
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when generating mipmaps with a non-power of two height', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
width : 2,
|
|
height : 3
|
|
});
|
|
|
|
expect(function() {
|
|
texture.generateMipmap();
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when generating mipmaps with an invalid hint', function() {
|
|
texture = new Texture({
|
|
context : context,
|
|
source : blueImage
|
|
});
|
|
|
|
expect(function() {
|
|
texture.generateMipmap('invalid hint');
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when destroy is called after destroying', function() {
|
|
var t = new Texture({
|
|
context : context,
|
|
source : blueImage,
|
|
pixelFormat : PixelFormat.RGBA
|
|
});
|
|
|
|
t.destroy();
|
|
|
|
expect(function() {
|
|
t.destroy();
|
|
}).toThrowDeveloperError();
|
|
});
|
|
}, 'WebGL');
|