livecodingspace-app/support/client/lib/vwf/model/graphtool.js

"use strict";

define( [ "module", "vwf/model", "vwf/utility" ], function( module, model, utility ) {

    // Set up render order constants for use with renderTop
    // Transparent objects render back to front, so use small numbers
    var DEPTH_GRID = Number.MIN_SAFE_INTEGER + 3;
    var DEPTH_AXES = Number.MIN_SAFE_INTEGER + 2;
    var DEPTH_OBJECTS = Number.MIN_SAFE_INTEGER + 1;

    var self;

    return model.load( module, {

        // == Module Definition ====================================================================

        // -- initialize ---------------------------------------------------------------------------

        initialize: function() {
            self = this;
            this.state.graphs = {};
            this.state.objects = {};
            this.state.kernel = this.kernel.kernel.kernel;
        },

        // == Model API ============================================================================

        // -- creatingNode -------------------------------------------------------------------------

        creatingNode: function( nodeID, childID, childExtendsID, childImplementsIDs,
            childSource, childType, childIndex, childName, callback /* ( ready ) */ ) {

            var node = undefined;
            var kernel = this.state.kernel;
            var protos = getPrototypes.call( this, kernel, childExtendsID );

            if ( protos && isGraph( protos ) ) {

                node = this.state.graphs[ childID ] = getThreeJSModel().state.nodes[ childID ];

                node.graphProperties = {
                    "graphScale": undefined,
                    "gridInterval": undefined,
                    "gridLineInterval": undefined,
                    "gridLength": undefined,
                    "xAxisVisible": undefined,
                    "yAxisVisible": undefined,
                    "zAxisVisible": undefined,
                    "gridVisible": undefined,
                    "axisOpacity": undefined,
                    "gridOpacity": undefined,
                    "renderTop": undefined
                };

                node.initialized = false;

            } else if ( protos && isGraphObject( protos ) ) {

                var type = getObjectType( protos );

                node = this.state.objects[ childID ] = getThreeJSModel().state.nodes[ childID ];

                node.type = type;
                switch ( type ) {
                    case "line":
                        node.objectProperties = {
                            "axis": undefined,
                            "startValue": undefined,
                            "endValue": undefined,
                            "color": undefined,
                            "opacity": undefined,
                            "lineThickness": undefined,
                            "renderTop": undefined
                        };
                        break;
                    case "function":
                        node.objectProperties = {
                            "lineFunction": undefined,
                            "startValue": undefined,
                            "endValue": undefined,
                            "pointCount": undefined,
                            "color": undefined,
                            "opacity": undefined,
                            "lineThickness": undefined,
                            "renderTop": undefined
                        };
                        break;
                    case "plane":
                        node.objectProperties = {
                            "origin": undefined,
                            "normal": undefined,
                            "rotationAngle": undefined,
                            "size": undefined,
                            "color": undefined,
                            "opacity": undefined,
                            "doubleSided": undefined,
                            "renderTop": undefined
                        };
                        break;
                    case "group":
                        node.objectProperties = {
                            "groupVisible": undefined,
                            "graphObjects": undefined
                        };
                        break;
                }

                node.parentGraph = this.state.graphs[ node.parentID ];

                node.initialized = false;

            }
        },

        // -- initializingNode ---------------------------------------------------------------------

        initializingNode: function( nodeID, childID, childExtendsID, childImplementsIDs,
            childSource, childType, childIndex, childName ) {
            
            var node;

            if ( this.state.graphs[ childID ] ) {

                node = this.state.graphs[ childID ];
                createGraph( node );
                node.initialized = true;

            } else if ( this.state.objects[ childID ] ) {

                node = this.state.objects[ childID ];
                createObject( node );
                node.initialized = true;

            }
        },

        // -- deletingNode -------------------------------------------------------------------------

        deletingNode: function( nodeID ) {

            if( nodeID ) {
                var childNode = this.state.objects[ nodeID ];
                if( childNode ) {
                    var threeObject = childNode.threeObject;
                    if( threeObject && threeObject.parent )
                    {
                        threeObject.parent.remove( threeObject );
                    }
                    delete this.state.objects[ childNode ];
                }
            }

        },

        // -- addingChild --------------------------------------------------------------------------

        addingChild: function( nodeID, childID, childName ) {
        },

        // -- removingChild ------------------------------------------------------------------------

        removingChild: function( nodeID, childID ) {
        },

        // -- creatingProperty ---------------------------------------------------------------------

        creatingProperty: function( nodeID, propertyName, propertyValue ) {
            return this.initializingProperty( nodeID, propertyName, propertyValue );
        },

        // -- initializingProperty -----------------------------------------------------------------

        initializingProperty: function( nodeID, propertyName, propertyValue ) {
            var value = undefined;

            if ( propertyValue !== undefined ) {
                var node = this.state.objects[ nodeID ] || this.state.graphs[ nodeID ] ;
                if ( node !== undefined ) {
                    switch ( propertyName ) {
                        default:
                            value = this.settingProperty( nodeID, propertyName, propertyValue );                  
                            break;
                    }
                }
            }

            return value;
        },

        // TODO: deletingProperty

        // -- settingProperty ----------------------------------------------------------------------

        settingProperty: function( nodeID, propertyName, propertyValue ) {
            var node;

            if ( this.state.graphs[ nodeID ] ) {

                node = this.state.graphs[ nodeID ];

                if ( node.graphProperties.hasOwnProperty( propertyName ) ) {

                    node.graphProperties[ propertyName ] = propertyValue;

                    if ( node.initialized ) {

                        switch ( propertyName ) {
                            case "xAxisVisible":
                            case "yAxisVisible":
                            case "zAxisVisible":
                            case "gridVisible":
                                setGraphVisibility( node, true );
                                break;
                            case "graphScale":
                                redrawGraph( node );
                                redrawObjects( node.ID, this.state.objects );
                                break;
                            default:
                                redrawGraph( node );
                                break;
                        }

                    }

                }

            } else if ( this.state.objects[ nodeID ] ) {

                node = this.state.objects[ nodeID ];

                if ( node.objectProperties.hasOwnProperty( propertyName ) ) {

                    node.objectProperties[ propertyName ] = propertyValue;

                    if ( node.initialized ) {

                        redrawObject( node );

                    }

                }

            }
        },

        // -- gettingProperty ----------------------------------------------------------------------

        gettingProperty: function( nodeID, propertyName, propertyValue ) {
            var node = this.state.objects[ nodeID ];

            if ( node ) {
            }
        },

        // -- creatingMethod -----------------------------------------------------------------------

        creatingMethod: function( nodeID, methodName, methodParameters, methodBody ) {
        },

        // TODO: deletingMethod

        // -- callingMethod ------------------------------------------------------------------------

        callingMethod: function( nodeID, methodName, methodParameters, methodValue ) {
            var node;

            if ( this.state.graphs[ nodeID ] ) {
                node = this.state.graphs[ nodeID ];
                
                if ( methodName === "setGraphVisibility" ) {
                    var visible = methodParameters[0];
                    setGraphVisibility( node, visible );
                }

            } else if ( this.state.objects[ nodeID ] ) {
                node = this.state.objects[ nodeID ];

                if ( methodName === "setGroupItemProperty" ) {
                    var itemIndexList = methodParameters[ 0 ];
                    var itemPropertyName = methodParameters[ 1 ];
                    var itemPropertyValue = methodParameters[ 2 ];
                    for ( var i = 0; i < itemIndexList.length; i++ ) {
                        node.threeObject.children[ 0 ].children[ itemIndexList[ i ] ][ itemPropertyName ] = itemPropertyValue;
                    }
                }
            }
        },

        // -- creatingEvent ------------------------------------------------------------------------

        creatingEvent: function( nodeID, eventName, eventParameters ) {
        },

        // TODO: deletingEvent

        // -- firingEvent --------------------------------------------------------------------------

        firingEvent: function( nodeID, eventName, eventParameters ) {
        },

        // -- executing ----------------------------------------------------------------------------

        executing: function( nodeID, scriptText, scriptType ) {
        },

    } );

    function getThreeJSModel() {
        
        var threejs;

        threejs = vwf.models[ "vwf/model/threejs" ];

        while ( threejs.model ) {
            threejs = threejs.model;
        }

        return threejs;

    }
    
    function getPrototypes( kernel, extendsID ) {
        var prototypes = [];
        var id = extendsID;

        while ( id !== undefined ) {
            prototypes.push( id );
            id = kernel.prototype( id );
        }
                
        return prototypes;
    }

    function isGraph( prototypes ) {

        var foundGraph = false;

        if ( prototypes ) {
            for ( var i = 0; i < prototypes.length && !foundGraph; i++ ) {
                foundGraph = ( prototypes[i] == "http://vwf.example.com/graphtool/graph.vwf" );
            }
        }

        return foundGraph;
    }

    function isGraphObject( prototypes ) {

        var foundObject = false;

        if ( prototypes ) {
            for ( var i = 0; i < prototypes.length && !foundObject; i++ ) {
                foundObject = ( prototypes[i] == "http://vwf.example.com/graphtool/graphline.vwf" ) ||
                    ( prototypes[i] == "http://vwf.example.com/graphtool/graphlinefunction.vwf" ) ||
                    ( prototypes[i] == "http://vwf.example.com/graphtool/graphplane.vwf" ) ||
                    ( prototypes[i] == "http://vwf.example.com/graphtool/graphgroup.vwf" );
            }
        }

        return foundObject;
    }

    function getObjectType( prototypes ) {

        if ( prototypes ) {
            for ( var i = 0; i < prototypes.length; i++ ) {
                if ( prototypes[i] == "http://vwf.example.com/graphtool/graphline.vwf" ) {
                    return "line";
                } else if ( prototypes[i] == "http://vwf.example.com/graphtool/graphlinefunction.vwf" ) {
                    return "function";
                } else if ( prototypes[i] == "http://vwf.example.com/graphtool/graphplane.vwf" ) {
                    return "plane";
                } else if ( prototypes[i] == "http://vwf.example.com/graphtool/graphgroup.vwf" ) {
                    return "group";
                }
            }
        }

        return undefined;
    }

    function createGraph( node ) {

        var props = node.graphProperties;
        var graph = generateGraph( 
                props.graphScale,
                props.gridInterval,
                props.gridLineInterval,
                props.gridLength,
                props.xAxisVisible,
                props.yAxisVisible,
                props.zAxisVisible,
                props.gridVisible,
                props.axisOpacity,
                props.gridOpacity,
                props.renderTop
            );

        node.threeObject.add( graph );

    }

    function createObject( node ) {

        var graphScale = node.parentGraph.graphProperties.graphScale;
        var props = node.objectProperties;
        var obj = null;

        switch( node.type ) {

            case "line":
                obj = generateLine(
                    graphScale,
                    props.axis,
                    props.startValue,
                    props.endValue,
                    props.color,
                    props.opacity,
                    props.lineThickness,
                    props.renderTop
                );
                break;

            case "function":
                obj = generateLineFuction(
                    graphScale,
                    props.lineFunction,
                    props.startValue,
                    props.endValue,
                    props.pointCount,
                    props.color,
                    props.opacity,
                    props.lineThickness,
                    props.renderTop
                );
                break;

            case "plane":
                obj = generatePlane(
                    graphScale,
                    props.origin,
                    props.normal,
                    props.rotationAngle,
                    props.size,
                    props.color,
                    props.opacity,
                    props.doubleSided,
                    props.renderTop
                );
                break;
            case "group":
                obj = generateGroup(
                    graphScale,
                    props.groupVisible,
                    props.graphObjects
                );
                break;
        }

        obj.visible = node.threeObject.visible;
        node.threeObject.add( obj );

    }

    function redrawGraph( graph ) {
        var oldObj = graph.threeObject.getObjectByName( "graph" );
        graph.threeObject.remove( oldObj );
        if ( oldObj.children.length > 0 ) {
            disposeObject( oldObj );
        }
        createGraph( graph );
    }

    function redrawObjects( graphID, objects ) {
        for ( var objID in objects ) {
            var obj = objects[ objID ];
            if ( obj.parentID === graphID && obj.initialized ) {
                redrawObject( obj );
            }
        }
    }

    function redrawObject( obj ) {
        var oldObj = obj.threeObject.children[ 0 ];
        obj.threeObject.remove( oldObj );
        if ( oldObj.children.length > 0 ) {
            disposeObject( oldObj );
        }
        createObject( obj );
    }

    function disposeObject( obj ) {
        var child, i;
        for ( i = 0; i < obj.children.length; i++ ) {
            child = obj.children[ i ];
            if ( child.children.length > 0 ) {
                disposeObject( child );
            } else if ( child instanceof THREE.Mesh ) {
                if ( child.geometry ) {
                    child.geometry.dispose();
                }
                if ( child.material ) {
                    if ( child.material.map ) {
                        child.material.map.dispose();
                    }
                    child.material.dispose();
                }
            }
        }
    }

    function setGraphVisibility( node, value ) {
        
        var graph, xAxis, yAxis, zAxis, gridLines;
        graph = node.threeObject.getObjectByName( "graph" );

        if ( graph ) {
            xAxis = graph.getObjectByName( "xAxis" );
            yAxis = graph.getObjectByName( "yAxis" );
            zAxis = graph.getObjectByName( "zAxis" );
            gridLines = graph.getObjectByName( "gridLines" );

            if ( value ) {
                xAxis.visible = node.graphProperties.xAxisVisible;
                yAxis.visible = node.graphProperties.yAxisVisible;
                zAxis.visible = node.graphProperties.zAxisVisible;
                gridLines.visible = node.graphProperties.gridVisible;
                for ( var line in gridLines.children ) {
                    gridLines.children[ line ].visible = gridLines.visible;
                }
            } else {
                xAxis.visible = false;
                yAxis.visible = false;
                zAxis.visible = false;
                gridLines.visible = false;
                for ( var line in gridLines.children ) {
                    gridLines.children[ line ].visible = false;
                }
            }
        }
    }

    function generateGraph( graphScale, gridInterval, gridLineInterval, gridLength, xAxisVisible, 
                        yAxisVisible, zAxisVisible, gridVisible, axisOpacity, gridOpacity, renderTop ) {

        var xAxis, yAxis, zAxis, gridX, gridY, axisLine;
        var thickness = 0.1;
        var graph = new THREE.Object3D();
        var gridLines = new THREE.Object3D();
        graph.name = "graph";
        gridLines.name = "gridLines";

        xAxis = generateLine( graphScale, [ 1, 0, 0 ], -gridLength, gridLength, [ 255, 0, 0 ], axisOpacity, thickness, renderTop );
        xAxis.name = "xAxis";
        xAxis.visible = xAxisVisible;

        yAxis = generateLine( graphScale, [ 0, 1, 0 ], -gridLength, gridLength, [ 0, 0, 255 ], axisOpacity, thickness, renderTop );
        yAxis.name = "yAxis";
        yAxis.visible = yAxisVisible;

        zAxis = generateLine( graphScale, [ 0, 0, 1 ], -gridLength, gridLength, [ 0, 255, 0 ], axisOpacity, thickness, renderTop );
        zAxis.name = "zAxis";
        zAxis.visible = zAxisVisible;

        if ( renderTop ) {
            xAxis.renderDepth = yAxis.renderDepth = zAxis.renderDepth = DEPTH_AXES;
        }
        
        graph.add( xAxis );
        graph.add( yAxis );
        graph.add( zAxis );

        // Scale grid
        gridInterval *= graphScale;
        gridLineInterval *= graphScale;

        for ( var i = -gridLength * graphScale; i <= gridLength * graphScale; i += gridInterval ) {
            if ( i % gridLineInterval === 0 ) {
                thickness = 0.075;
            } else {
                thickness = 0.025;
            }

            gridX = generateLine( graphScale, [ 1, 0, 0 ], -gridLength, gridLength, [ 255, 255, 255 ], gridOpacity, thickness, renderTop );
            gridX.position.set( 0, i, 0 );
            gridX.visible = gridVisible;

            gridY = generateLine( graphScale, [ 0, 1, 0 ], -gridLength, gridLength, [ 255, 255, 255 ], gridOpacity, thickness, renderTop );
            gridY.position.set( i, 0, 0 );
            gridY.visible = gridVisible;

            if ( renderTop ) {
                gridX.renderDepth = gridY.renderDepth = DEPTH_GRID;
            }

            gridLines.add( gridX );
            gridLines.add( gridY );

        }

        graph.add( gridLines );

        return graph;
    }

    function generateLineFuction( graphScale, functionString, startValue, endValue, 
                            pointCount, color, opacity, thickness, renderTop ) {

        if ( !isValidFunction( functionString ) ) {
            return new THREE.Mesh();
        }

        var geometry = new THREE.Geometry();
        var point, direction;
        var points = new Array();
        var faces;
        var increment;
        var func = function( x, y, z ) {
            var fn = "var x = " + x + ", y = " + y + ", z = " + z + ";\n" 
                    + functionString + ";\n" 
                    + "[ x, y, z ];";
            var ar = eval( fn );
            x = ar[0] * graphScale;
            y = ar[1] * graphScale;
            z = ar[2] * graphScale;
            return new THREE.Vector3( x || 0, y || 0, z || 0 );
        }

        increment = Math.abs( endValue - startValue ) / pointCount;

        // Check for endvalue + ( increment / 2 ) to account for approximation errors
        for ( var i = startValue; i <= endValue + ( increment / 2 ); i += increment ) {
            point = func( i );
            direction = func( i + increment );
            direction.sub( func( i - increment ) );
            direction.normalize();
            if ( !isNaN( point.x ) && !isNaN( point.y ) && !isNaN( point.z ) ) {
                var planePoints = generateLineVertices( direction, point, thickness / 2 );
                for ( var j = 0; j < planePoints.length; j++ ) {
                    points.push( planePoints[j] );
                }
            }
        }

        geometry.vertices = points;

        for ( var i = 0; i < points.length; i++ ) {
            if ( points[i + 4] !== undefined ) {
                geometry.faces.push( new THREE.Face3( i, i + 4, i + 1 ) );
                geometry.faces.push( new THREE.Face3( i, i + 3, i + 4 ) );
            }
        }

        var last = points.length - 1;
        geometry.faces.push( new THREE.Face3( 0, 1, 2 ) );
        geometry.faces.push( new THREE.Face3( 0, 2, 3 ) );
        geometry.faces.push( new THREE.Face3( last, last - 1, last - 3 ) );
        geometry.faces.push( new THREE.Face3( last - 1, last - 2, last - 3 ) );

        var transparent = renderTop || opacity < 1;
        var vwfColor = new utility.color( color );
        color = vwfColor.getHex();
        var meshMaterial = new THREE.MeshBasicMaterial( 
                { "color": color, "transparent": transparent, "opacity": opacity, "depthTest": !renderTop } 
            );
        var mesh = new THREE.Mesh( geometry, meshMaterial );
        mesh.renderDepth = renderTop ? DEPTH_OBJECTS : null;

        return mesh;

    }

    function generateLine( graphScale, axis, startValue, endValue, color, opacity, thickness, renderTop ) {

        var geometry = new THREE.Geometry();
        startValue *= graphScale;
        endValue *= graphScale;
        var startPoint, endPoint, direction;
        var points = new Array();
        var planePoints, i;

        startPoint = new THREE.Vector3(
                axis[ 0 ] * startValue,
                axis[ 1 ] * startValue,
                axis[ 2 ] * startValue
            );
        endPoint = new THREE.Vector3(
                axis[ 0 ] * endValue,
                axis[ 1 ] * endValue,
                axis[ 2 ] * endValue
            );
        direction = endPoint.clone();
        direction.sub( startPoint.clone() );
        direction.normalize();

        planePoints = generateLineVertices( direction, startPoint, thickness / 2 );
        for ( i = 0; i < planePoints.length; i++ ) {
            points.push( planePoints[i] );
        }

        planePoints = generateLineVertices( direction, endPoint, thickness / 2 );
        for ( i = 0; i < planePoints.length; i++ ) {
            points.push( planePoints[i] );
        }

        geometry.vertices = points;

        for ( var i = 0; i < points.length; i++ ) {
            if ( points[i + 4] !== undefined ) {
                geometry.faces.push( new THREE.Face3( i, i + 4, i + 1 ) );
                geometry.faces.push( new THREE.Face3( i, i + 3, i + 4 ) );
            }
        }

        var last = points.length - 1;
        geometry.faces.push( new THREE.Face3( 0, 1, 2 ) );
        geometry.faces.push( new THREE.Face3( 0, 2, 3 ) );
        geometry.faces.push( new THREE.Face3( last, last - 1, last - 3 ) );
        geometry.faces.push( new THREE.Face3( last - 1, last - 2, last - 3 ) );

        var transparent = renderTop || opacity < 1;
        var vwfColor = new utility.color( color );
        color = vwfColor.getHex();
        var meshMaterial = new THREE.MeshBasicMaterial( 
                { "color": color, "transparent": transparent, "opacity": opacity, "depthTest": !renderTop } 
            );
        var mesh = new THREE.Mesh( geometry, meshMaterial );
        mesh.renderDepth = renderTop ? DEPTH_OBJECTS : null;

        return mesh;

    }

    function generatePlane( graphScale, origin, normal, rotationAngle, size, color, opacity, doubleSided, renderTop ) {

        var geometry = new THREE.Geometry();
        normal = new THREE.Vector3( normal[ 0 ], normal[ 1 ], normal[ 2 ] );
        origin = new THREE.Vector3( origin[ 0 ], origin[ 1 ], origin[ 2 ] );
        var points;
        size *= graphScale;
        origin.multiplyScalar( graphScale );

        points = generatePlaneVertices( normal, origin, size );
        geometry.vertices = points;

        geometry.faces.push( new THREE.Face3( 0, 1, 2 ) );
        geometry.faces.push( new THREE.Face3( 0, 2, 3 ) );

        var transparent = renderTop || opacity < 1;
        var vwfColor = new utility.color( color );
        color = vwfColor.getHex();
        var meshMaterial = new THREE.MeshBasicMaterial( 
                { "color": color, "transparent": transparent, "opacity": opacity, "depthTest": !renderTop } 
            );
        if ( doubleSided ) {
            meshMaterial.side = THREE.DoubleSide;
        }
        var mesh = new THREE.Mesh( geometry, meshMaterial );
        mesh.renderDepth = renderTop ? DEPTH_OBJECTS : null;

        return mesh;

    }

    function generateGroup( graphScale, groupVisible, graphObjects ) {

        var groupObject = new THREE.Object3D();

        for ( var i = 0; i < graphObjects.length; i++ ) {
            var type = Object.keys( graphObjects[ i ] )[ 0 ];
            var props = graphObjects[ i ][ type ];
            var obj;
            switch( type ) {

                case "line":
                    obj = generateLine(
                        graphScale,
                        props.axis,
                        props.startValue,
                        props.endValue,
                        props.color,
                        props.opacity,
                        props.lineThickness,
                        props.renderTop
                    );
                    break;

                case "function":
                    obj = generateLineFuction(
                        graphScale,
                        props.lineFunction,
                        props.startValue,
                        props.endValue,
                        props.pointCount,
                        props.color,
                        props.opacity,
                        props.lineThickness,
                        props.renderTop
                    );
                    break;

                case "plane":
                    obj = generatePlane(
                        graphScale,
                        props.origin,
                        props.normal,
                        props.rotationAngle,
                        props.size,
                        props.color,
                        props.opacity,
                        props.doubleSided,
                        props.renderTop
                    );
                    break;
                case "group":
                    obj = generateGroup(
                        graphScale,
                        props.groupVisible,
                        props.graphObjects
                    );
                    break;
            }

            obj.visible = groupVisible;
            groupObject.add( obj );
        }

        return groupObject;
    }

    function generateLineVertices( normal, origin, distance ) {

        var vertices = new Array();
        var up = new THREE.Vector3();
        var left = new THREE.Vector3();

        var rotAxis = new THREE.Vector3( 0, 0, 1 );
        var rotAngle, rotMat;

        if ( Math.abs( normal.z ) === 1 ) {
            rotAxis.x += 0.1;
            rotAxis.normalize();
        }

        rotAxis.crossVectors( normal, rotAxis );
        rotAxis.normalize();
        rotAngle = Math.acos( normal.dot( rotAxis ) );
        rotMat = createRotationMatrix( rotAxis, rotAngle );

        up.copy( normal );
        up.applyMatrix3( rotMat );
        up.normalize();
        left.crossVectors( up, normal );
        left.normalize();

        vertices.push( 
            new THREE.Vector3( 
                origin.x + ( up.x * distance ),
                origin.y + ( up.y * distance ),
                origin.z + ( up.z * distance )
            ) 
        );

        vertices.push( 
            new THREE.Vector3( 
                origin.x + ( left.x * distance ),
                origin.y + ( left.y * distance ),
                origin.z + ( left.z * distance )
            ) 
        );

        up.negate();
        left.negate();

        vertices.push( 
            new THREE.Vector3( 
                origin.x + ( up.x * distance ),
                origin.y + ( up.y * distance ),
                origin.z + ( up.z * distance )
            ) 
        );

        vertices.push( 
            new THREE.Vector3( 
                origin.x + ( left.x * distance ),
                origin.y + ( left.y * distance ),
                origin.z + ( left.z * distance )
            ) 
        );

        return vertices;

    }

    function generatePlaneVertices( normal, origin, distance ) {

        var vertices = new Array();
        var up = new THREE.Vector3();
        var left = new THREE.Vector3();

        var rotAxis = new THREE.Vector3( 0, 0, 1 );
        var rotAngle, rotMat;

        distance /= 2;

        if ( Math.abs( normal.z ) === 1 ) {
            rotAxis.x += 0.1;
            rotAxis.normalize();
        }

        rotAxis.crossVectors( normal, rotAxis );
        rotAxis.normalize();
        rotAngle = Math.acos( normal.dot( rotAxis ) );
        rotMat = createRotationMatrix( rotAxis, rotAngle );

        up.copy( normal );
        up.applyMatrix3( rotMat );
        up.normalize();
        left.crossVectors( up, normal );
        left.normalize();

        vertices.push( 
            new THREE.Vector3( 
                origin.x + ( up.x * distance ) + ( left.x * distance ),
                origin.y + ( up.y * distance ) + ( left.y * distance ),
                origin.z + ( up.z * distance ) + ( left.z * distance )
            ) 
        );

        vertices.push( 
            new THREE.Vector3( 
                origin.x + ( up.x * distance ) - ( left.x * distance ),
                origin.y + ( up.y * distance ) - ( left.y * distance ),
                origin.z + ( up.z * distance ) - ( left.z * distance )
            ) 
        );

        up.negate();
        left.negate();

        vertices.push( 
            new THREE.Vector3( 
                origin.x + ( up.x * distance ) + ( left.x * distance ),
                origin.y + ( up.y * distance ) + ( left.y * distance ),
                origin.z + ( up.z * distance ) + ( left.z * distance )
            ) 
        );

        vertices.push( 
            new THREE.Vector3( 
                origin.x + ( up.x * distance ) - ( left.x * distance ),
                origin.y + ( up.y * distance ) - ( left.y * distance ),
                origin.z + ( up.z * distance ) - ( left.z * distance )
            ) 
        );

        return vertices;

    }

    function createRotationMatrix( axis, angle ) {

        var mat;
        var c = Math.cos( angle );
        var d = 1 - c;
        var s = Math.sin( angle );

        mat = new THREE.Matrix3();

        mat.set(
            axis.x * axis.x * d + c,
            axis.x * axis.y * d + axis.z * s,
            axis.x * axis.z * d - axis.y * s,

            axis.x * axis.y * d - axis.z * s,
            axis.y * axis.y * d + c,
            axis.y * axis.z * d + axis.x * s,

            axis.x * axis.z * d + axis.y * s,
            axis.y * axis.z * d - axis.x * s,
            axis.z * axis.z * d + c
        );

        return mat;

    }

    function isValidFunction( functionString ) {
        return ( function( x, y, z ) {
            var fn = "var x = " + x + ", y = " + y + ", z = " + z + ";\n" 
                    + functionString + ";\n" 
                    + "[ x, y, z ];";
            try {
                var ar = eval( fn );
            } catch ( error ) {
                self.logger.errorx( "generateLineFuction", error.stack );
                return false;
            }
            return true;
        } )();
    }

} );