|
@@ -45,12 +45,12 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
var prevrectx1 = Infinity, prevrecty1 = Infinity;
|
|
var prevrectx1 = Infinity, prevrecty1 = Infinity;
|
|
var prevrectx2 = 0, prevrecty2 = 0;
|
|
var prevrectx2 = 0, prevrecty2 = 0;
|
|
|
|
|
|
- var projector = new THREE.Projector();
|
|
|
|
|
|
+ var renderer = new THREE.Renderer();
|
|
|
|
|
|
var vector1 = new THREE.Vector3();
|
|
var vector1 = new THREE.Vector3();
|
|
var vector2 = new THREE.Vector3();
|
|
var vector2 = new THREE.Vector3();
|
|
var vector3 = new THREE.Vector3();
|
|
var vector3 = new THREE.Vector3();
|
|
-
|
|
|
|
|
|
+
|
|
var texCoord1 = new THREE.Vector2();
|
|
var texCoord1 = new THREE.Vector2();
|
|
var texCoord2 = new THREE.Vector2();
|
|
var texCoord2 = new THREE.Vector2();
|
|
var texCoord3 = new THREE.Vector2();
|
|
var texCoord3 = new THREE.Vector2();
|
|
@@ -82,11 +82,11 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
viewportXScale = fixScale * canvasWidth / 2;
|
|
viewportXScale = fixScale * canvasWidth / 2;
|
|
viewportYScale = -fixScale * canvasHeight / 2;
|
|
viewportYScale = -fixScale * canvasHeight / 2;
|
|
viewportZScale = maxZVal / 2;
|
|
viewportZScale = maxZVal / 2;
|
|
-
|
|
|
|
|
|
+
|
|
viewportXOffs = fixScale * canvasWidth / 2 + 0.5;
|
|
viewportXOffs = fixScale * canvasWidth / 2 + 0.5;
|
|
viewportYOffs = fixScale * canvasHeight / 2 + 0.5;
|
|
viewportYOffs = fixScale * canvasHeight / 2 + 0.5;
|
|
viewportZOffs = maxZVal / 2 + 0.5;
|
|
viewportZOffs = maxZVal / 2 + 0.5;
|
|
-
|
|
|
|
|
|
+
|
|
canvas.width = canvasWidth;
|
|
canvas.width = canvasWidth;
|
|
canvas.height = canvasHeight;
|
|
canvas.height = canvasHeight;
|
|
|
|
|
|
@@ -140,7 +140,7 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
|
|
|
|
if ( this.autoClear === true ) this.clear();
|
|
if ( this.autoClear === true ) this.clear();
|
|
|
|
|
|
- var renderData = projector.projectScene( scene, camera, false, false );
|
|
|
|
|
|
+ var renderData = renderer.projectScene( scene, camera, false, false );
|
|
var elements = renderData.elements;
|
|
var elements = renderData.elements;
|
|
|
|
|
|
for ( var e = 0, el = elements.length; e < el; e ++ ) {
|
|
for ( var e = 0, el = elements.length; e < el; e ++ ) {
|
|
@@ -150,9 +150,9 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
var shader = getMaterialShader( material );
|
|
var shader = getMaterialShader( material );
|
|
|
|
|
|
if ( element instanceof THREE.RenderableFace ) {
|
|
if ( element instanceof THREE.RenderableFace ) {
|
|
-
|
|
|
|
|
|
+
|
|
if ( !element.uvs ) {
|
|
if ( !element.uvs ) {
|
|
-
|
|
|
|
|
|
+
|
|
drawTriangle(
|
|
drawTriangle(
|
|
element.v1.positionScreen,
|
|
element.v1.positionScreen,
|
|
element.v2.positionScreen,
|
|
element.v2.positionScreen,
|
|
@@ -161,16 +161,16 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
shader, element, material
|
|
shader, element, material
|
|
);
|
|
);
|
|
} else {
|
|
} else {
|
|
-
|
|
|
|
|
|
+
|
|
drawTriangle(
|
|
drawTriangle(
|
|
element.v1.positionScreen,
|
|
element.v1.positionScreen,
|
|
element.v2.positionScreen,
|
|
element.v2.positionScreen,
|
|
element.v3.positionScreen,
|
|
element.v3.positionScreen,
|
|
element.uvs[0], element.uvs[1], element.uvs[2],
|
|
element.uvs[0], element.uvs[1], element.uvs[2],
|
|
shader, element, material
|
|
shader, element, material
|
|
- );
|
|
|
|
|
|
+ );
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
|
|
|
|
} else if ( element instanceof THREE.RenderableSprite ) {
|
|
} else if ( element instanceof THREE.RenderableSprite ) {
|
|
|
|
|
|
@@ -188,13 +188,13 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
vector3.copy( element );
|
|
vector3.copy( element );
|
|
vector3.x += scaleX;
|
|
vector3.x += scaleX;
|
|
vector3.y += scaleY;
|
|
vector3.y += scaleY;
|
|
-
|
|
|
|
|
|
+
|
|
if ( material.map ) {
|
|
if ( material.map ) {
|
|
|
|
|
|
texCoord1.set( 0, 1 );
|
|
texCoord1.set( 0, 1 );
|
|
texCoord2.set( 0, 0 );
|
|
texCoord2.set( 0, 0 );
|
|
texCoord3.set( 1, 1 );
|
|
texCoord3.set( 1, 1 );
|
|
-
|
|
|
|
|
|
+
|
|
drawTriangle(
|
|
drawTriangle(
|
|
vector1, vector2, vector3,
|
|
vector1, vector2, vector3,
|
|
texCoord1, texCoord2, texCoord3,
|
|
texCoord1, texCoord2, texCoord3,
|
|
@@ -202,14 +202,14 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
);
|
|
);
|
|
|
|
|
|
} else {
|
|
} else {
|
|
-
|
|
|
|
|
|
+
|
|
drawTriangle(
|
|
drawTriangle(
|
|
vector1, vector2, vector3,
|
|
vector1, vector2, vector3,
|
|
null, null, null,
|
|
null, null, null,
|
|
shader, element, material
|
|
shader, element, material
|
|
);
|
|
);
|
|
|
|
|
|
- }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
vector1.copy( element );
|
|
vector1.copy( element );
|
|
vector1.x += scaleX;
|
|
vector1.x += scaleX;
|
|
@@ -222,7 +222,7 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
vector3.copy( element );
|
|
vector3.copy( element );
|
|
vector3.x += scaleX;
|
|
vector3.x += scaleX;
|
|
vector3.y -= scaleY;
|
|
vector3.y -= scaleY;
|
|
-
|
|
|
|
|
|
+
|
|
if ( material.map ) {
|
|
if ( material.map ) {
|
|
|
|
|
|
texCoord1.set( 1, 1 );
|
|
texCoord1.set( 1, 1 );
|
|
@@ -236,14 +236,14 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
);
|
|
);
|
|
|
|
|
|
} else {
|
|
} else {
|
|
-
|
|
|
|
|
|
+
|
|
drawTriangle(
|
|
drawTriangle(
|
|
vector1, vector2, vector3,
|
|
vector1, vector2, vector3,
|
|
null, null, null,
|
|
null, null, null,
|
|
shader, element, material
|
|
shader, element, material
|
|
);
|
|
);
|
|
|
|
|
|
- }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
@@ -286,11 +286,11 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
var size = canvasWidth * canvasHeight * 4;
|
|
var size = canvasWidth * canvasHeight * 4;
|
|
|
|
|
|
for ( var i = 0; i < size; i+=4 ) {
|
|
for ( var i = 0; i < size; i+=4 ) {
|
|
-
|
|
|
|
|
|
+
|
|
data[ i ] = clearColor.r * 255 | 0;
|
|
data[ i ] = clearColor.r * 255 | 0;
|
|
data[ i+1 ] = clearColor.g * 255 | 0;
|
|
data[ i+1 ] = clearColor.g * 255 | 0;
|
|
data[ i+2 ] = clearColor.b * 255 | 0;
|
|
data[ i+2 ] = clearColor.b * 255 | 0;
|
|
- data[ i+3 ] = 255;
|
|
|
|
|
|
+ data[ i+3 ] = 255;
|
|
}
|
|
}
|
|
|
|
|
|
context.fillStyle = clearColor.getStyle();
|
|
context.fillStyle = clearColor.getStyle();
|
|
@@ -302,9 +302,9 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
var diffuseG = material.ambient.g + material.color.g * 255;
|
|
var diffuseG = material.ambient.g + material.color.g * 255;
|
|
var diffuseB = material.ambient.b + material.color.b * 255;
|
|
var diffuseB = material.ambient.b + material.color.b * 255;
|
|
var palette = new Uint8Array(256*3);
|
|
var palette = new Uint8Array(256*3);
|
|
-
|
|
|
|
|
|
+
|
|
if ( bSimulateSpecular ) {
|
|
if ( bSimulateSpecular ) {
|
|
-
|
|
|
|
|
|
+
|
|
var i = 0, j = 0;
|
|
var i = 0, j = 0;
|
|
while(i < 204) {
|
|
while(i < 204) {
|
|
var r = i * diffuseR / 204;
|
|
var r = i * diffuseR / 204;
|
|
@@ -333,15 +333,15 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
g = 255;
|
|
g = 255;
|
|
if(b > 255)
|
|
if(b > 255)
|
|
b = 255;
|
|
b = 255;
|
|
-
|
|
|
|
|
|
+
|
|
palette[j++] = r;
|
|
palette[j++] = r;
|
|
palette[j++] = g;
|
|
palette[j++] = g;
|
|
palette[j++] = b;
|
|
palette[j++] = b;
|
|
++i;
|
|
++i;
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
} else {
|
|
} else {
|
|
-
|
|
|
|
|
|
+
|
|
var i = 0, j = 0;
|
|
var i = 0, j = 0;
|
|
while(i < 256) {
|
|
while(i < 256) {
|
|
var r = i * diffuseR / 255;
|
|
var r = i * diffuseR / 255;
|
|
@@ -359,14 +359,14 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
palette[j++] = b;
|
|
palette[j++] = b;
|
|
++i;
|
|
++i;
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
return palette;
|
|
return palette;
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
function basicMaterialShader( buffer, depthBuf, offset, depth, u, v, n, face, material ) {
|
|
function basicMaterialShader( buffer, depthBuf, offset, depth, u, v, n, face, material ) {
|
|
-
|
|
|
|
|
|
+
|
|
var colorOffset = offset * 4;
|
|
var colorOffset = offset * 4;
|
|
|
|
|
|
if ( material.needsUpdate && !material.texture.data ) {
|
|
if ( material.needsUpdate && !material.texture.data ) {
|
|
@@ -381,7 +381,7 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
var tbound = tdim - 1;
|
|
var tbound = tdim - 1;
|
|
var tdata = material.texture.data;
|
|
var tdata = material.texture.data;
|
|
var tIndex = (((v * tdim) & tbound) * tdim + ((u * tdim) & tbound)) * 4;
|
|
var tIndex = (((v * tdim) & tbound) * tdim + ((u * tdim) & tbound)) * 4;
|
|
-
|
|
|
|
|
|
+
|
|
if ( !isTransparent ) {
|
|
if ( !isTransparent ) {
|
|
buffer[ colorOffset ] = tdata[tIndex];
|
|
buffer[ colorOffset ] = tdata[tIndex];
|
|
buffer[ colorOffset + 1 ] = tdata[tIndex+1];
|
|
buffer[ colorOffset + 1 ] = tdata[tIndex+1];
|
|
@@ -389,25 +389,25 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
buffer[ colorOffset + 3 ] = material.opacity * 255;
|
|
buffer[ colorOffset + 3 ] = material.opacity * 255;
|
|
depthBuf[ offset ] = depth;
|
|
depthBuf[ offset ] = depth;
|
|
}
|
|
}
|
|
- else {
|
|
|
|
|
|
+ else {
|
|
var opaci = tdata[tIndex+3] * material.opacity;
|
|
var opaci = tdata[tIndex+3] * material.opacity;
|
|
var texel = (tdata[tIndex] << 16) + (tdata[tIndex+1] << 8) + tdata[tIndex+2];
|
|
var texel = (tdata[tIndex] << 16) + (tdata[tIndex+1] << 8) + tdata[tIndex+2];
|
|
if(opaci < 250) {
|
|
if(opaci < 250) {
|
|
var backColor = (buffer[colorOffset] << 16) + (buffer[colorOffset + 1] << 8) + buffer[colorOffset + 2];
|
|
var backColor = (buffer[colorOffset] << 16) + (buffer[colorOffset + 1] << 8) + buffer[colorOffset + 2];
|
|
- texel = texel * opaci + backColor * (1-opaci);
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
|
|
+ texel = texel * opaci + backColor * (1-opaci);
|
|
|
|
+ }
|
|
|
|
+
|
|
buffer[ colorOffset ] = (texel & 0xff0000) >> 16;
|
|
buffer[ colorOffset ] = (texel & 0xff0000) >> 16;
|
|
buffer[ colorOffset + 1 ] = (texel & 0xff00) >> 8;
|
|
buffer[ colorOffset + 1 ] = (texel & 0xff00) >> 8;
|
|
buffer[ colorOffset + 2 ] = texel & 0xff;
|
|
buffer[ colorOffset + 2 ] = texel & 0xff;
|
|
buffer[ colorOffset + 3 ] = material.opacity * 255;
|
|
buffer[ colorOffset + 3 ] = material.opacity * 255;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
function lightingMaterialShader( buffer, depthBuf, offset, depth, u, v, n, face, material ) {
|
|
function lightingMaterialShader( buffer, depthBuf, offset, depth, u, v, n, face, material ) {
|
|
-
|
|
|
|
|
|
+
|
|
var colorOffset = offset * 4;
|
|
var colorOffset = offset * 4;
|
|
-
|
|
|
|
|
|
+
|
|
if ( material.map.needsUpdate && !material.texture.data ) {
|
|
if ( material.map.needsUpdate && !material.texture.data ) {
|
|
material.texture.CreateFromImage( material.map.image );
|
|
material.texture.CreateFromImage( material.map.image );
|
|
}
|
|
}
|
|
@@ -421,51 +421,51 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
var tbound = tdim - 1;
|
|
var tbound = tdim - 1;
|
|
var tdata = material.texture.data;
|
|
var tdata = material.texture.data;
|
|
var tIndex = (((v * tdim) & tbound) * tdim + ((u * tdim) & tbound)) * 4;
|
|
var tIndex = (((v * tdim) & tbound) * tdim + ((u * tdim) & tbound)) * 4;
|
|
-
|
|
|
|
|
|
+
|
|
if ( !isTransparent ) {
|
|
if ( !isTransparent ) {
|
|
buffer[ colorOffset ] = (material.palette[cIndex] * tdata[tIndex]) >> 8;
|
|
buffer[ colorOffset ] = (material.palette[cIndex] * tdata[tIndex]) >> 8;
|
|
buffer[ colorOffset + 1 ] = (material.palette[cIndex+1] * tdata[tIndex+1]) >> 8;
|
|
buffer[ colorOffset + 1 ] = (material.palette[cIndex+1] * tdata[tIndex+1]) >> 8;
|
|
buffer[ colorOffset + 2 ] = (material.palette[cIndex+2] * tdata[tIndex+2]) >> 8;
|
|
buffer[ colorOffset + 2 ] = (material.palette[cIndex+2] * tdata[tIndex+2]) >> 8;
|
|
- buffer[ colorOffset + 3 ] = material.opacity * 255;
|
|
|
|
|
|
+ buffer[ colorOffset + 3 ] = material.opacity * 255;
|
|
depthBuf[ offset ] = depth;
|
|
depthBuf[ offset ] = depth;
|
|
- } else {
|
|
|
|
|
|
+ } else {
|
|
var opaci = tdata[tIndex+3] * material.opacity;
|
|
var opaci = tdata[tIndex+3] * material.opacity;
|
|
- var foreColor = ((material.palette[cIndex] * tdata[tIndex]) << 16)
|
|
|
|
|
|
+ var foreColor = ((material.palette[cIndex] * tdata[tIndex]) << 16)
|
|
+ ((material.palette[cIndex+1] * tdata[tIndex+1]) << 8 )
|
|
+ ((material.palette[cIndex+1] * tdata[tIndex+1]) << 8 )
|
|
+ (material.palette[cIndex+2] * tdata[tIndex+2]);
|
|
+ (material.palette[cIndex+2] * tdata[tIndex+2]);
|
|
-
|
|
|
|
|
|
+
|
|
if(opaci < 250) {
|
|
if(opaci < 250) {
|
|
var backColor = buffer[ colorOffset ] << 24 + buffer[ colorOffset + 1 ] << 16 + buffer[ colorOffset + 2 ] << 8;
|
|
var backColor = buffer[ colorOffset ] << 24 + buffer[ colorOffset + 1 ] << 16 + buffer[ colorOffset + 2 ] << 8;
|
|
- foreColor = foreColor * opaci + backColor * (1-opaci);
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
|
|
+ foreColor = foreColor * opaci + backColor * (1-opaci);
|
|
|
|
+ }
|
|
|
|
+
|
|
buffer[ colorOffset ] = (foreColor & 0xff0000) >> 16;
|
|
buffer[ colorOffset ] = (foreColor & 0xff0000) >> 16;
|
|
buffer[ colorOffset + 1 ] = (foreColor & 0xff00) >> 8;
|
|
buffer[ colorOffset + 1 ] = (foreColor & 0xff00) >> 8;
|
|
buffer[ colorOffset + 2 ] = (foreColor & 0xff);
|
|
buffer[ colorOffset + 2 ] = (foreColor & 0xff);
|
|
buffer[ colorOffset + 3 ] = material.opacity * 255;
|
|
buffer[ colorOffset + 3 ] = material.opacity * 255;
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
function getMaterialShader( material ) {
|
|
function getMaterialShader( material ) {
|
|
|
|
|
|
var id = material.id;
|
|
var id = material.id;
|
|
var shader = shaders[ id ];
|
|
var shader = shaders[ id ];
|
|
|
|
|
|
if ( shaders[ id ] === undefined ) {
|
|
if ( shaders[ id ] === undefined ) {
|
|
-
|
|
|
|
|
|
+
|
|
if ( material instanceof THREE.MeshBasicMaterial ||
|
|
if ( material instanceof THREE.MeshBasicMaterial ||
|
|
material instanceof THREE.MeshLambertMaterial ||
|
|
material instanceof THREE.MeshLambertMaterial ||
|
|
material instanceof THREE.MeshPhongMaterial ||
|
|
material instanceof THREE.MeshPhongMaterial ||
|
|
material instanceof THREE.SpriteMaterial ) {
|
|
material instanceof THREE.SpriteMaterial ) {
|
|
|
|
|
|
- if ( material instanceof THREE.MeshLambertMaterial ) {
|
|
|
|
|
|
+ if ( material instanceof THREE.MeshLambertMaterial ) {
|
|
// Generate color palette
|
|
// Generate color palette
|
|
if ( !material.palette ) {
|
|
if ( !material.palette ) {
|
|
material.palette = getPalette( material, false );
|
|
material.palette = getPalette( material, false );
|
|
}
|
|
}
|
|
-
|
|
|
|
- } else if ( material instanceof THREE.MeshPhongMaterial ) {
|
|
|
|
|
|
+
|
|
|
|
+ } else if ( material instanceof THREE.MeshPhongMaterial ) {
|
|
// Generate color palette
|
|
// Generate color palette
|
|
if ( !material.palette ) {
|
|
if ( !material.palette ) {
|
|
material.palette = getPalette( material, true );
|
|
material.palette = getPalette( material, true );
|
|
@@ -473,24 +473,24 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
}
|
|
}
|
|
|
|
|
|
var string;
|
|
var string;
|
|
-
|
|
|
|
|
|
+
|
|
if ( material.map ) {
|
|
if ( material.map ) {
|
|
-
|
|
|
|
|
|
+
|
|
var texture = new THREE.SoftwareRenderer.Texture();
|
|
var texture = new THREE.SoftwareRenderer.Texture();
|
|
- material.texture = texture;
|
|
|
|
-
|
|
|
|
- if ( material instanceof THREE.MeshBasicMaterial
|
|
|
|
- || material instanceof THREE.SpriteMaterial ) {
|
|
|
|
-
|
|
|
|
|
|
+ material.texture = texture;
|
|
|
|
+
|
|
|
|
+ if ( material instanceof THREE.MeshBasicMaterial
|
|
|
|
+ || material instanceof THREE.SpriteMaterial ) {
|
|
|
|
+
|
|
shader = basicMaterialShader;
|
|
shader = basicMaterialShader;
|
|
} else {
|
|
} else {
|
|
-
|
|
|
|
|
|
+
|
|
shader = lightingMaterialShader;
|
|
shader = lightingMaterialShader;
|
|
}
|
|
}
|
|
-
|
|
|
|
-
|
|
|
|
|
|
+
|
|
|
|
+
|
|
} else {
|
|
} else {
|
|
-
|
|
|
|
|
|
+
|
|
if ( material.vertexColors === THREE.FaceColors ) {
|
|
if ( material.vertexColors === THREE.FaceColors ) {
|
|
|
|
|
|
string = [
|
|
string = [
|
|
@@ -514,9 +514,9 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
].join('\n');
|
|
].join('\n');
|
|
|
|
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
shader = new Function( 'buffer, depthBuf, offset, depth, u, v, n, face, material', string );
|
|
shader = new Function( 'buffer, depthBuf, offset, depth, u, v, n, face, material', string );
|
|
- }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
} else {
|
|
} else {
|
|
|
|
|
|
@@ -589,37 +589,37 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
var z1 = (v1.z * viewportZScale + viewportZOffs) | 0;
|
|
var z1 = (v1.z * viewportZScale + viewportZOffs) | 0;
|
|
var z2 = (v2.z * viewportZScale + viewportZOffs) | 0;
|
|
var z2 = (v2.z * viewportZScale + viewportZOffs) | 0;
|
|
var z3 = (v3.z * viewportZScale + viewportZOffs) | 0;
|
|
var z3 = (v3.z * viewportZScale + viewportZOffs) | 0;
|
|
-
|
|
|
|
|
|
+
|
|
// UV values
|
|
// UV values
|
|
var bHasUV = false;
|
|
var bHasUV = false;
|
|
var tu1, tv1, tu2, tv2, tu3, tv3;
|
|
var tu1, tv1, tu2, tv2, tu3, tv3;
|
|
-
|
|
|
|
|
|
+
|
|
if ( uv1 && uv2 && uv3 ) {
|
|
if ( uv1 && uv2 && uv3 ) {
|
|
bHasUV = true;
|
|
bHasUV = true;
|
|
-
|
|
|
|
- tu1 = uv1.x;
|
|
|
|
- tv1 = 1-uv1.y;
|
|
|
|
- tu2 = uv2.x;
|
|
|
|
- tv2 = 1-uv2.y;
|
|
|
|
- tu3 = uv3.x;
|
|
|
|
- tv3 = 1-uv3.y;
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
|
|
+
|
|
|
|
+ tu1 = uv1.x;
|
|
|
|
+ tv1 = 1-uv1.y;
|
|
|
|
+ tu2 = uv2.x;
|
|
|
|
+ tv2 = 1-uv2.y;
|
|
|
|
+ tu3 = uv3.x;
|
|
|
|
+ tv3 = 1-uv3.y;
|
|
|
|
+ }
|
|
|
|
+
|
|
// Normal values
|
|
// Normal values
|
|
var bHasNormal = false;
|
|
var bHasNormal = false;
|
|
var n1, n2, n3, nz1, nz2, nz3;
|
|
var n1, n2, n3, nz1, nz2, nz3;
|
|
-
|
|
|
|
- if ( face.vertexNormalsModel ) {
|
|
|
|
|
|
+
|
|
|
|
+ if ( face.vertexNormalsModel ) {
|
|
bHasNormal = true;
|
|
bHasNormal = true;
|
|
-
|
|
|
|
|
|
+
|
|
n1 = face.vertexNormalsModel[0];
|
|
n1 = face.vertexNormalsModel[0];
|
|
n2 = face.vertexNormalsModel[1];
|
|
n2 = face.vertexNormalsModel[1];
|
|
- n3 = face.vertexNormalsModel[2];
|
|
|
|
|
|
+ n3 = face.vertexNormalsModel[2];
|
|
nz1 = n1.z * 255;
|
|
nz1 = n1.z * 255;
|
|
nz2 = n2.z * 255;
|
|
nz2 = n2.z * 255;
|
|
nz3 = n3.z * 255;
|
|
nz3 = n3.z * 255;
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
// Deltas
|
|
// Deltas
|
|
|
|
|
|
var dx12 = x1 - x2, dy12 = y2 - y1;
|
|
var dx12 = x1 - x2, dy12 = y2 - y1;
|
|
@@ -684,7 +684,7 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
var fixscale = (1 << subpixelBits);
|
|
var fixscale = (1 << subpixelBits);
|
|
dzdx = (dzdx * fixscale) | 0;
|
|
dzdx = (dzdx * fixscale) | 0;
|
|
dzdy = (dzdy * fixscale) | 0;
|
|
dzdy = (dzdy * fixscale) | 0;
|
|
-
|
|
|
|
|
|
+
|
|
var dtvdx, dtvdy, cbtu, cbtv;
|
|
var dtvdx, dtvdy, cbtu, cbtv;
|
|
if ( bHasUV ) {
|
|
if ( bHasUV ) {
|
|
// UV interpolation setup
|
|
// UV interpolation setup
|
|
@@ -693,34 +693,34 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
var dtudy = (invDet * (dtu12*dx31 - dx12*dtu31)); // dtu per one subpixel step in y
|
|
var dtudy = (invDet * (dtu12*dx31 - dx12*dtu31)); // dtu per one subpixel step in y
|
|
var dtv12 = tv1 - tv2, dtv31 = tv3 - tv1;
|
|
var dtv12 = tv1 - tv2, dtv31 = tv3 - tv1;
|
|
dtvdx = (invDet * (dtv12*dy31 - dtv31*dy12)); // dtv per one subpixel step in x
|
|
dtvdx = (invDet * (dtv12*dy31 - dtv31*dy12)); // dtv per one subpixel step in x
|
|
- dtvdy = (invDet * (dtv12*dx31 - dx12*dtv31)); // dtv per one subpixel step in y
|
|
|
|
-
|
|
|
|
|
|
+ dtvdy = (invDet * (dtv12*dx31 - dx12*dtv31)); // dtv per one subpixel step in y
|
|
|
|
+
|
|
// UV at top/left corner of rast area
|
|
// UV at top/left corner of rast area
|
|
cbtu = ( tu1 + (minXfixscale - x1) * dtudx + (minYfixscale - y1) * dtudy );
|
|
cbtu = ( tu1 + (minXfixscale - x1) * dtudx + (minYfixscale - y1) * dtudy );
|
|
cbtv = ( tv1 + (minXfixscale - x1) * dtvdx + (minYfixscale - y1) * dtvdy );
|
|
cbtv = ( tv1 + (minXfixscale - x1) * dtvdx + (minYfixscale - y1) * dtvdy );
|
|
-
|
|
|
|
- // UV pixel steps
|
|
|
|
|
|
+
|
|
|
|
+ // UV pixel steps
|
|
dtudx = dtudx * fixscale;
|
|
dtudx = dtudx * fixscale;
|
|
- dtudy = dtudy * fixscale;
|
|
|
|
|
|
+ dtudy = dtudy * fixscale;
|
|
dtvdx = dtvdx * fixscale;
|
|
dtvdx = dtvdx * fixscale;
|
|
dtvdy = dtvdy * fixscale;
|
|
dtvdy = dtvdy * fixscale;
|
|
- }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
var dnxdx, dnzdy, cbnz;
|
|
var dnxdx, dnzdy, cbnz;
|
|
if ( bHasNormal ) {
|
|
if ( bHasNormal ) {
|
|
- // Normal interpolation setup
|
|
|
|
|
|
+ // Normal interpolation setup
|
|
var dnz12 = nz1 - nz2, dnz31 = nz3 - nz1;
|
|
var dnz12 = nz1 - nz2, dnz31 = nz3 - nz1;
|
|
var dnzdx = (invDet * (dnz12*dy31 - dnz31*dy12)); // dnz per one subpixel step in x
|
|
var dnzdx = (invDet * (dnz12*dy31 - dnz31*dy12)); // dnz per one subpixel step in x
|
|
var dnzdy = (invDet * (dnz12*dx31 - dx12*dnz31)); // dnz per one subpixel step in y
|
|
var dnzdy = (invDet * (dnz12*dx31 - dx12*dnz31)); // dnz per one subpixel step in y
|
|
-
|
|
|
|
- // Normal at top/left corner of rast area
|
|
|
|
|
|
+
|
|
|
|
+ // Normal at top/left corner of rast area
|
|
cbnz = ( nz1 + (minXfixscale - x1) * dnzdx + (minYfixscale - y1) * dnzdy );
|
|
cbnz = ( nz1 + (minXfixscale - x1) * dnzdx + (minYfixscale - y1) * dnzdy );
|
|
|
|
|
|
// Normal pixel steps
|
|
// Normal pixel steps
|
|
dnzdx = (dnzdx * fixscale);
|
|
dnzdx = (dnzdx * fixscale);
|
|
dnzdy = (dnzdy * fixscale);
|
|
dnzdy = (dnzdy * fixscale);
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
// Set up min/max corners
|
|
// Set up min/max corners
|
|
var qm1 = q - 1; // for convenience
|
|
var qm1 = q - 1; // for convenience
|
|
var nmin1 = 0, nmax1 = 0;
|
|
var nmin1 = 0, nmax1 = 0;
|
|
@@ -749,18 +749,18 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
var e2x = qstep * dy23;
|
|
var e2x = qstep * dy23;
|
|
var e3x = qstep * dy31;
|
|
var e3x = qstep * dy31;
|
|
var ezx = qstep * dzdx;
|
|
var ezx = qstep * dzdx;
|
|
-
|
|
|
|
- var etux, etvx;
|
|
|
|
|
|
+
|
|
|
|
+ var etux, etvx;
|
|
if ( bHasUV ) {
|
|
if ( bHasUV ) {
|
|
etux = qstep * dtudx;
|
|
etux = qstep * dtudx;
|
|
etvx = qstep * dtvdx;
|
|
etvx = qstep * dtvdx;
|
|
}
|
|
}
|
|
|
|
|
|
- var enzx;
|
|
|
|
|
|
+ var enzx;
|
|
if ( bHasNormal ) {
|
|
if ( bHasNormal ) {
|
|
enzx = qstep * dnzdx;
|
|
enzx = qstep * dnzdx;
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
var x0 = minx;
|
|
var x0 = minx;
|
|
|
|
|
|
for ( var y0 = miny; y0 < maxy; y0 += q ) {
|
|
for ( var y0 = miny; y0 < maxy; y0 += q ) {
|
|
@@ -773,16 +773,16 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
cb2 += e2x;
|
|
cb2 += e2x;
|
|
cb3 += e3x;
|
|
cb3 += e3x;
|
|
cbz += ezx;
|
|
cbz += ezx;
|
|
-
|
|
|
|
|
|
+
|
|
if ( bHasUV ) {
|
|
if ( bHasUV ) {
|
|
cbtu += etux;
|
|
cbtu += etux;
|
|
cbtv += etvx;
|
|
cbtv += etvx;
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
if ( bHasNormal ) {
|
|
if ( bHasNormal ) {
|
|
cbnz += enzx;
|
|
cbnz += enzx;
|
|
- }
|
|
|
|
-
|
|
|
|
|
|
+ }
|
|
|
|
+
|
|
}
|
|
}
|
|
|
|
|
|
// Okay, we're now in a block we know is outside. Reverse direction and go into main loop.
|
|
// Okay, we're now in a block we know is outside. Reverse direction and go into main loop.
|
|
@@ -791,15 +791,15 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
e2x = -e2x;
|
|
e2x = -e2x;
|
|
e3x = -e3x;
|
|
e3x = -e3x;
|
|
ezx = -ezx;
|
|
ezx = -ezx;
|
|
-
|
|
|
|
- if ( bHasUV ) {
|
|
|
|
|
|
+
|
|
|
|
+ if ( bHasUV ) {
|
|
etux = -etux;
|
|
etux = -etux;
|
|
etvx = -etvx;
|
|
etvx = -etvx;
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
if ( bHasNormal ) {
|
|
if ( bHasNormal ) {
|
|
enzx = -enzx;
|
|
enzx = -enzx;
|
|
- }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
while ( 1 ) {
|
|
while ( 1 ) {
|
|
|
|
|
|
@@ -809,15 +809,15 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
cb2 += e2x;
|
|
cb2 += e2x;
|
|
cb3 += e3x;
|
|
cb3 += e3x;
|
|
cbz += ezx;
|
|
cbz += ezx;
|
|
-
|
|
|
|
|
|
+
|
|
if ( bHasUV ) {
|
|
if ( bHasUV ) {
|
|
cbtu += etux;
|
|
cbtu += etux;
|
|
cbtv += etvx;
|
|
cbtv += etvx;
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
if ( bHasNormal ) {
|
|
if ( bHasNormal ) {
|
|
cbnz += enzx;
|
|
cbnz += enzx;
|
|
- }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
// We're done with this block line when at least one edge completely out
|
|
// We're done with this block line when at least one edge completely out
|
|
// If an edge function is too small and decreasing in the current traversal
|
|
// If an edge function is too small and decreasing in the current traversal
|
|
@@ -843,7 +843,7 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
|
|
|
|
// Offset at top-left corner
|
|
// Offset at top-left corner
|
|
var offset = x0 + y0 * canvasWidth;
|
|
var offset = x0 + y0 * canvasWidth;
|
|
-
|
|
|
|
|
|
+
|
|
// Accept whole block when fully covered
|
|
// Accept whole block when fully covered
|
|
if ( cb1 >= nmin1 && cb2 >= nmin2 && cb3 >= nmin3 ) {
|
|
if ( cb1 >= nmin1 && cb2 >= nmin2 && cb3 >= nmin3 ) {
|
|
|
|
|
|
@@ -853,58 +853,58 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
var cy1 = cb1;
|
|
var cy1 = cb1;
|
|
var cy2 = cb2;
|
|
var cy2 = cb2;
|
|
var cyz = cbz;
|
|
var cyz = cbz;
|
|
-
|
|
|
|
- var cytu, cytv;
|
|
|
|
|
|
+
|
|
|
|
+ var cytu, cytv;
|
|
if ( bHasUV ) {
|
|
if ( bHasUV ) {
|
|
cytu = cbtu;
|
|
cytu = cbtu;
|
|
cytv = cbtv;
|
|
cytv = cbtv;
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
var cynz;
|
|
var cynz;
|
|
if ( bHasNormal ) {
|
|
if ( bHasNormal ) {
|
|
cynz = cbnz;
|
|
cynz = cbnz;
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
|
|
|
|
for ( var iy = 0; iy < q; iy ++ ) {
|
|
for ( var iy = 0; iy < q; iy ++ ) {
|
|
|
|
|
|
var cx1 = cy1;
|
|
var cx1 = cy1;
|
|
var cx2 = cy2;
|
|
var cx2 = cy2;
|
|
var cxz = cyz;
|
|
var cxz = cyz;
|
|
-
|
|
|
|
|
|
+
|
|
var cxtu;
|
|
var cxtu;
|
|
- var cxtv;
|
|
|
|
|
|
+ var cxtv;
|
|
if ( bHasUV ) {
|
|
if ( bHasUV ) {
|
|
cxtu = cytu;
|
|
cxtu = cytu;
|
|
cxtv = cytv;
|
|
cxtv = cytv;
|
|
}
|
|
}
|
|
-
|
|
|
|
- var cxnz;
|
|
|
|
|
|
+
|
|
|
|
+ var cxnz;
|
|
if ( bHasNormal ) {
|
|
if ( bHasNormal ) {
|
|
- cxnz = cynz;
|
|
|
|
- }
|
|
|
|
|
|
+ cxnz = cynz;
|
|
|
|
+ }
|
|
|
|
|
|
for ( var ix = 0; ix < q; ix ++ ) {
|
|
for ( var ix = 0; ix < q; ix ++ ) {
|
|
|
|
|
|
var z = cxz;
|
|
var z = cxz;
|
|
-
|
|
|
|
- if ( z < zbuffer[ offset ] ) {
|
|
|
|
- shader( data, zbuffer, offset, z, cxtu, cxtv, cxnz, face, material );
|
|
|
|
|
|
+
|
|
|
|
+ if ( z < zbuffer[ offset ] ) {
|
|
|
|
+ shader( data, zbuffer, offset, z, cxtu, cxtv, cxnz, face, material );
|
|
}
|
|
}
|
|
|
|
|
|
cx1 += dy12;
|
|
cx1 += dy12;
|
|
cx2 += dy23;
|
|
cx2 += dy23;
|
|
cxz += dzdx;
|
|
cxz += dzdx;
|
|
-
|
|
|
|
|
|
+
|
|
if ( bHasUV ) {
|
|
if ( bHasUV ) {
|
|
cxtu += dtudx;
|
|
cxtu += dtudx;
|
|
cxtv += dtvdx;
|
|
cxtv += dtvdx;
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
if ( bHasNormal ) {
|
|
if ( bHasNormal ) {
|
|
cxnz += dnzdx;
|
|
cxnz += dnzdx;
|
|
- }
|
|
|
|
-
|
|
|
|
|
|
+ }
|
|
|
|
+
|
|
offset++;
|
|
offset++;
|
|
|
|
|
|
}
|
|
}
|
|
@@ -912,16 +912,16 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
cy1 += dx12;
|
|
cy1 += dx12;
|
|
cy2 += dx23;
|
|
cy2 += dx23;
|
|
cyz += dzdy;
|
|
cyz += dzdy;
|
|
-
|
|
|
|
|
|
+
|
|
if ( bHasUV ) {
|
|
if ( bHasUV ) {
|
|
cytu += dtudy;
|
|
cytu += dtudy;
|
|
cytv += dtvdy;
|
|
cytv += dtvdy;
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
if ( bHasNormal ) {
|
|
if ( bHasNormal ) {
|
|
cynz += dnzdy;
|
|
cynz += dnzdy;
|
|
- }
|
|
|
|
-
|
|
|
|
|
|
+ }
|
|
|
|
+
|
|
offset += linestep;
|
|
offset += linestep;
|
|
|
|
|
|
}
|
|
}
|
|
@@ -932,17 +932,17 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
var cy2 = cb2;
|
|
var cy2 = cb2;
|
|
var cy3 = cb3;
|
|
var cy3 = cb3;
|
|
var cyz = cbz;
|
|
var cyz = cbz;
|
|
-
|
|
|
|
|
|
+
|
|
var cytu, cytv;
|
|
var cytu, cytv;
|
|
if ( bHasUV ) {
|
|
if ( bHasUV ) {
|
|
cytu = cbtu;
|
|
cytu = cbtu;
|
|
cytv = cbtv;
|
|
cytv = cbtv;
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
var cynz;
|
|
var cynz;
|
|
if ( bHasNormal ) {
|
|
if ( bHasNormal ) {
|
|
cynz = cbnz;
|
|
cynz = cbnz;
|
|
- }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
for ( var iy = 0; iy < q; iy ++ ) {
|
|
for ( var iy = 0; iy < q; iy ++ ) {
|
|
|
|
|
|
@@ -950,26 +950,26 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
var cx2 = cy2;
|
|
var cx2 = cy2;
|
|
var cx3 = cy3;
|
|
var cx3 = cy3;
|
|
var cxz = cyz;
|
|
var cxz = cyz;
|
|
-
|
|
|
|
|
|
+
|
|
var cxtu;
|
|
var cxtu;
|
|
- var cxtv;
|
|
|
|
|
|
+ var cxtv;
|
|
if ( bHasUV ) {
|
|
if ( bHasUV ) {
|
|
cxtu = cytu;
|
|
cxtu = cytu;
|
|
cxtv = cytv;
|
|
cxtv = cytv;
|
|
}
|
|
}
|
|
-
|
|
|
|
- var cxnz;
|
|
|
|
|
|
+
|
|
|
|
+ var cxnz;
|
|
if ( bHasNormal ) {
|
|
if ( bHasNormal ) {
|
|
- cxnz = cynz;
|
|
|
|
- }
|
|
|
|
|
|
+ cxnz = cynz;
|
|
|
|
+ }
|
|
|
|
|
|
for ( var ix = 0; ix < q; ix ++ ) {
|
|
for ( var ix = 0; ix < q; ix ++ ) {
|
|
|
|
|
|
if ( ( cx1 | cx2 | cx3 ) >= 0 ) {
|
|
if ( ( cx1 | cx2 | cx3 ) >= 0 ) {
|
|
|
|
|
|
- var z = cxz;
|
|
|
|
|
|
+ var z = cxz;
|
|
|
|
|
|
- if ( z < zbuffer[ offset ] ) {
|
|
|
|
|
|
+ if ( z < zbuffer[ offset ] ) {
|
|
shader( data, zbuffer, offset, z, cxtu, cxtv, cxnz, face, material );
|
|
shader( data, zbuffer, offset, z, cxtu, cxtv, cxnz, face, material );
|
|
}
|
|
}
|
|
|
|
|
|
@@ -979,16 +979,16 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
cx2 += dy23;
|
|
cx2 += dy23;
|
|
cx3 += dy31;
|
|
cx3 += dy31;
|
|
cxz += dzdx;
|
|
cxz += dzdx;
|
|
-
|
|
|
|
|
|
+
|
|
if ( bHasUV ) {
|
|
if ( bHasUV ) {
|
|
cxtu += dtudx;
|
|
cxtu += dtudx;
|
|
cxtv += dtvdx;
|
|
cxtv += dtvdx;
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
if ( bHasNormal ) {
|
|
if ( bHasNormal ) {
|
|
cxnz += dnzdx;
|
|
cxnz += dnzdx;
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
offset++;
|
|
offset++;
|
|
|
|
|
|
}
|
|
}
|
|
@@ -997,16 +997,16 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
cy2 += dx23;
|
|
cy2 += dx23;
|
|
cy3 += dx31;
|
|
cy3 += dx31;
|
|
cyz += dzdy;
|
|
cyz += dzdy;
|
|
-
|
|
|
|
|
|
+
|
|
if ( bHasUV ) {
|
|
if ( bHasUV ) {
|
|
cytu += dtudy;
|
|
cytu += dtudy;
|
|
cytv += dtvdy;
|
|
cytv += dtvdy;
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
if ( bHasNormal ) {
|
|
if ( bHasNormal ) {
|
|
cynz += dnzdy;
|
|
cynz += dnzdy;
|
|
- }
|
|
|
|
-
|
|
|
|
|
|
+ }
|
|
|
|
+
|
|
offset += linestep;
|
|
offset += linestep;
|
|
|
|
|
|
}
|
|
}
|
|
@@ -1020,16 +1020,16 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
cb2 += q*dx23;
|
|
cb2 += q*dx23;
|
|
cb3 += q*dx31;
|
|
cb3 += q*dx31;
|
|
cbz += q*dzdy;
|
|
cbz += q*dzdy;
|
|
-
|
|
|
|
|
|
+
|
|
if ( bHasUV ) {
|
|
if ( bHasUV ) {
|
|
cbtu += q*dtudy;
|
|
cbtu += q*dtudy;
|
|
cbtv += q*dtvdy;
|
|
cbtv += q*dtvdy;
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
if ( bHasNormal ) {
|
|
if ( bHasNormal ) {
|
|
cbnz += q*dnzdy;
|
|
cbnz += q*dnzdy;
|
|
- }
|
|
|
|
-
|
|
|
|
|
|
+ }
|
|
|
|
+
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
@@ -1088,12 +1088,12 @@ THREE.SoftwareRenderer = function ( parameters ) {
|
|
|
|
|
|
THREE.SoftwareRenderer.Texture = function() {
|
|
THREE.SoftwareRenderer.Texture = function() {
|
|
var canvas = null;
|
|
var canvas = null;
|
|
-
|
|
|
|
|
|
+
|
|
this.CreateFromImage = function( image ) {
|
|
this.CreateFromImage = function( image ) {
|
|
-
|
|
|
|
|
|
+
|
|
if( !image || image.width <=0 || image.height <=0 )
|
|
if( !image || image.width <=0 || image.height <=0 )
|
|
return;
|
|
return;
|
|
-
|
|
|
|
|
|
+
|
|
var isCanvasClean = false;
|
|
var isCanvasClean = false;
|
|
var canvas = THREE.SoftwareRenderer.Texture.canvas;
|
|
var canvas = THREE.SoftwareRenderer.Texture.canvas;
|
|
if ( !canvas ) {
|
|
if ( !canvas ) {
|