// requires matrix_vector_lib.js
// TODO we could make some libraryless way of checking dependencies and versions.


// global namespace object
var WireframeModel;


(function(){





// converts a point from three space to the canvas plane.
// Note: because of depth perspective, this conversion is not
// easy to define if the point lies behind the camera.
// There are two options:
// When drawing a line, another colinear point in front of the camera may be provided
// to help find an alternate point.
// if both points lie behind the camera or the colinear_point is not provided,
// this function will return null.
 
function project(canvas, xyz, view, colinear_point){
    if(!xyz) return null;  // point has been deleted or does not exist
    
	var view_transform = view.transform;
	var origin = view.origin;
	var zoom_scale = view.zoom_scale;
	var zoom_dist = view.zoom_dist;
	
	if(!zoom_scale) zoom_scale = 1;
	if(!zoom_dist) zoom_dist = 0;
	if(!origin) origin = [0,0,0];
	
	
    var w = canvas.width;
    var h = canvas.height;
    
    var scale = Math.min(w, h);
    
    var v = xyz.slice(0);
    if(origin) v = vector_minus(v, origin, v);
    
    var z = vector_dot(view_transform[2], v);
    
    if(z <= -zoom_dist){  // this point is on the wrong side of the viewer, find the closest point on the correct side if we can.
        if(!colinear_point) return null;
        
        var v2 = colinear_point.slice(0);
        if(origin) vector_minus(v2, origin, v2);
        
        var z2 = vector_dot(view_transform[2], v2);
        
        if(z2 < 0) return null;
        
        // get the coefficients for a complex combination.
        // t*z + (1-t)*z2 = 0.0002  -- z of new point is just barely infront of the camera.
        
        var t = (0.0002 - z2)/(z - z2);  // no division by zero, z is negative, z2 is positive
        
        vector_add(vector_scale(v, t, v),
                   vector_scale(v2, 1-t, v2),
                   v);
                   
        z = vector_dot(view_transform[2], v); }

        
    var scale2 = zoom_scale * scale / (zoom_dist + z);
    
    return [ scale2 * vector_dot(view_transform[0], v) + 0.5 * w,
             scale2 * vector_dot(view_transform[1], v) + 0.5 * h ]; }



//  Just like the project function above but for a set of points.
//  It's put into a loop a little better.
function project_all(canvas, points, point_projections, view){

	var view_transform = view.transform;
	var origin = view.origin;
	var zoom_scale = view.zoom_scale;
	var zoom_dist = view.zoom_dist;
	
	if(!zoom_scale) zoom_scale = 1;
	if(!zoom_dist) zoom_dist = 0;
	if(!origin) origin = [0,0,0];
	

    if(!point_projections) point_projections = [];
	point_projections.length = points.length;
    
    var w = canvas.width;
    var h = canvas.height;
	var w_2 = w/2;
	var h_2 = h/2;
    
    var scale = zoom_scale * Math.min(w, h);
	
	var v00 = view_transform[0][0];
	var v01 = view_transform[0][1];
	var v02 = view_transform[0][2];
	var v10 = view_transform[1][0];
	var v11 = view_transform[1][1];
	var v12 = view_transform[1][2];
	var v20 = view_transform[2][0];
	var v21 = view_transform[2][1];
	var v22 = view_transform[2][2];
	
    
	for(var i = 0; i < points.length; ++i){
		var pt = points[i];
		
		var x = pt[0];
		var y = pt[1];
		var z = pt[2];
		
		if(origin){
	         x -= origin[0];
			 y -= origin[1];
			 z -= origin[2]; }
		
		var depth = x*v20 + y*v21 + z*v22;
		var scale2 = scale / (zoom_dist + depth);
		
		if(!point_projections[i]) point_projections[i] = [0, 0];
		
		var point_projection = point_projections[i];
		
		point_projection[0] = scale2 * (x*v00 + y*v01 + z*v02) + w_2;
		point_projection[1] = scale2 * (x*v10 + y*v11 + z*v22) + h_2; }
	
	return point_projections; }




//  A wireframe model and all the controls needed to move the camera and draw.
//  despite the name, it may also include polygon surfaces.
function __WireframeModel(){

	var WFMObj = this;
	
	var view_origin = [0, 0, 0];
	var view_transform = [[1, 0, 0],
	                      [0, 1, 0],
						  [0, 0, 1]];



	var points = []; //global
	var point_projections = [];
	//var solo_points = {};
	var lines = [];
	var zoom_scale = 1;
	var zoom_dist = 1;
	
	// just because these actual objects is returned
	// doesn't mean you should modify it externally if you can help it.
	
	WFMObj.getPoints = function getPoints(){
		return points; }
		
	WFMObj.getPoint = function getPoint(index){
		return points[index].slice(0); }
	
	WFMObj.getLines = function getLines(){
		return lines; }
		
	WFMObj.getLine = function getLine(index){
		return lines[index].slice(0); }
	
	WFMObj.getViewTransform = function getViewTransform(){
		return view_transform; }
	
	
	
	WFMObj.addPoint = function addPoint(pt){

				throw "pt ref at index " + i + " of line was not an integer: " + ptindex; }
			
			if(ptindex < 0 || ptindex >= points.length){
				throw "pt ref at index " + i + " of line was not in bounds: " + ptindex; }}
		
		lines.push(line);
		return lines.length - 1; }

		
	WFMObj.draw = function draw(canvas){
		var ctx = canvas.getContext("2d");
		
		var view = {};
		view.transform = view_transform;
		view.origin = view_origin;
		view.zoom_scale = zoom_scale;
		view.zoom_dist = zoom_dist;
		
		project_all(canvas, points, point_projections, view);
		// project_all()
		
		for(var i = 0; i < point_projections.length; ++i){
			var point_projection = point_projections[i];
			if(point_projection) ctx.fillRect(point_projection[0] - 1, point_projection[1] - 1, 2, 2); }
	}
}

//  use constructor as global namespace object.
WireframeModel = __WireframeModel;


})();

    if(cameracentric) offset = matrix_mult(view_transform, [offset])[0];
    //alert("offset: " + offset);
    vector_add(origin, offset, origin); }
	
	
	
	
   

















































   

   
//  removes deleted points and lines
//  works with global objects.

function cleanupDeletedPoints(){