I'm having a bit of trouble setting the background of a three.js scene to be transparent. This scene was created with the editor (which is really snazzy, by the way), and exported.
I've set alpha: true on the WebGLRenderer and I've added the alpha value at the end of the setClearColor call, but still, no transparency.
I've tried setting the scene.background = new THREE.Color(0x000000,0), but Color doesn't work with alpha as I expected and this seems to be read as a 2 of three parts of an rgb style color declaration.
Is there something I'm missing? Should I not use the Editor to create a scene?
Here is the full app.js code as exported by the editor and tweaked by me:
/**
* @author mrdoob / http://mrdoob.com/
*/
var APP = {
Player: function () {
var scope = this;
var loader = new THREE.ObjectLoader();
var camera, scene, renderer;
var controls, effect, cameraVR, isVR;
var events = {};
this.dom = document.createElement( 'div' );
this.width = 500;
this.height = 500;
this.load = function ( json ) {
isVR = json.project.vr;
renderer = new THREE.WebGLRenderer( {
antialias: true,
alpha: true,
} );
renderer.setClearColor( 0x000000, 0 );
renderer.setPixelRatio( window.devicePixelRatio );
if ( json.project.gammaInput ) renderer.gammaInput = true;
if ( json.project.gammaOutput ) renderer.gammaOutput = true;
if ( json.project.shadows ) {
renderer.shadowMap.enabled = true;
// renderer.shadowMap.type = THREE.PCFSoftShadowMap;
}
this.dom.appendChild( renderer.domElement );
this.setScene( loader.parse( json.scene ) );
this.setCamera( loader.parse( json.camera ) );
events = {
init: [],
start: [],
stop: [],
keydown: [],
keyup: [],
mousedown: [],
mouseup: [],
mousemove: [],
touchstart: [],
touchend: [],
touchmove: [],
update: []
};
var scriptWrapParams = 'player,renderer,scene,camera';
var scriptWrapResultObj = {};
for ( var eventKey in events ) {
scriptWrapParams += ',' + eventKey;
scriptWrapResultObj[ eventKey ] = eventKey;
}
var scriptWrapResult = JSON.stringify( scriptWrapResultObj ).replace( /\"/g, '' );
for ( var uuid in json.scripts ) {
var object = scene.getObjectByProperty( 'uuid', uuid, true );
if ( object === undefined ) {
console.warn( 'APP.Player: Script without object.', uuid );
continue;
}
var scripts = json.scripts[ uuid ];
for ( var i = 0; i < scripts.length; i ++ ) {
var script = scripts[ i ];
var functions = ( new Function( scriptWrapParams, script.source + '\nreturn ' + scriptWrapResult + ';' ).bind( object ) )( this, renderer, scene, camera );
for ( var name in functions ) {
if ( functions[ name ] === undefined ) continue;
if ( events[ name ] === undefined ) {
console.warn( 'APP.Player: Event type not supported (', name, ')' );
continue;
}
events[ name ].push( functions[ name ].bind( object ) );
}
}
}
dispatch( events.init, arguments );
};
this.setCamera = function ( value ) {
camera = value;
camera.aspect = this.width / this.height;
camera.updateProjectionMatrix();
if ( isVR === true ) {
cameraVR = new THREE.PerspectiveCamera();
cameraVR.projectionMatrix = camera.projectionMatrix;
camera.add( cameraVR );
controls = new THREE.VRControls( cameraVR );
effect = new THREE.VREffect( renderer );
if ( WEBVR.isAvailable() === true ) {
this.dom.appendChild( WEBVR.getButton( effect ) );
}
if ( WEBVR.isLatestAvailable() === false ) {
this.dom.appendChild( WEBVR.getMessage() );
}
}
};
this.setScene = function ( value ) {
scene = value;
// scene.background = new THREE.Color(0x000000); // Color can't be alpha? boo.
};
this.setSize = function ( width, height ) {
this.width = width;
this.height = height;
if ( camera ) {
camera.aspect = this.width / this.height;
camera.updateProjectionMatrix();
}
if ( renderer ) {
renderer.setSize( width, height );
}
};
function dispatch( array, event ) {
for ( var i = 0, l = array.length; i < l; i ++ ) {
array[ i ]( event );
}
}
var prevTime, request;
function animate( time ) {
request = requestAnimationFrame( animate );
try {
dispatch( events.update, { time: time, delta: time - prevTime } );
} catch ( e ) {
console.error( ( e.message || e ), ( e.stack || "" ) );
}
if ( isVR === true ) {
camera.updateMatrixWorld();
controls.update();
effect.render( scene, cameraVR );
} else {
renderer.render( scene, camera );
}
prevTime = time;
}
this.play = function () {
document.addEventListener( 'keydown', onDocumentKeyDown );
document.addEventListener( 'keyup', onDocumentKeyUp );
document.addEventListener( 'mousedown', onDocumentMouseDown );
document.addEventListener( 'mouseup', onDocumentMouseUp );
document.addEventListener( 'mousemove', onDocumentMouseMove );
document.addEventListener( 'touchstart', onDocumentTouchStart );
document.addEventListener( 'touchend', onDocumentTouchEnd );
document.addEventListener( 'touchmove', onDocumentTouchMove );
dispatch( events.start, arguments );
request = requestAnimationFrame( animate );
prevTime = performance.now();
};
this.stop = function () {
document.removeEventListener( 'keydown', onDocumentKeyDown );
document.removeEventListener( 'keyup', onDocumentKeyUp );
document.removeEventListener( 'mousedown', onDocumentMouseDown );
document.removeEventListener( 'mouseup', onDocumentMouseUp );
document.removeEventListener( 'mousemove', onDocumentMouseMove );
document.removeEventListener( 'touchstart', onDocumentTouchStart );
document.removeEventListener( 'touchend', onDocumentTouchEnd );
document.removeEventListener( 'touchmove', onDocumentTouchMove );
dispatch( events.stop, arguments );
cancelAnimationFrame( request );
};
this.dispose = function () {
while ( this.dom.children.length ) {
this.dom.removeChild( this.dom.firstChild );
}
renderer.dispose();
camera = undefined;
scene = undefined;
renderer = undefined;
};
//
function onDocumentKeyDown( event ) {
dispatch( events.keydown, event );
}
function onDocumentKeyUp( event ) {
dispatch( events.keyup, event );
}
function onDocumentMouseDown( event ) {
dispatch( events.mousedown, event );
}
function onDocumentMouseUp( event ) {
dispatch( events.mouseup, event );
}
function onDocumentMouseMove( event ) {
dispatch( events.mousemove, event );
}
function onDocumentTouchStart( event ) {
dispatch( events.touchstart, event );
}
function onDocumentTouchEnd( event ) {
dispatch( events.touchend, event );
}
function onDocumentTouchMove( event ) {
dispatch( events.touchmove, event );
}
}
};