DS_Box.java

/* --------------------------------------------------------- *
 *    __________    D E L T A S C R I P T                    *
 *   (_________()                                            *
 *    /  ===   /   - A fast, dynamic scripting language      *
 *   |  ==    |    - Version 4.13.11.0                       *
 *   /  ===   /    - Developed by Adam R. Nelson             *
 *  |  =  =  |     - 2011-2013                               *
 *  /  ===   /     - Distributed under GNU LGPL v3           *
 * (________()     - http://github.com/ar-nelson/deltascript *
 *                                                           *
 * --------------------------------------------------------- */

package com.sector91.delta.script.objects.geom;

import com.sector91.delta.script.DScriptContext;
import com.sector91.delta.script.Operator;
import com.sector91.delta.script.annotations.DSDynamicField;
import com.sector91.delta.script.annotations.DSInaccessible;
import com.sector91.delta.script.annotations.DSName;
import com.sector91.delta.script.annotations.DSType;
import com.sector91.delta.script.objects.DS_Object;
import com.sector91.delta.script.objects.DS_Scalar;
import com.sector91.delta.script.objects.DS_Vector;
import com.sector91.geom.Box;
import com.sector91.geom.DimensionMismatchException;
import com.sector91.geom.Vector;
import com.sector91.geom.algorithms.Algorithms;

@DSType("Box")
public abstract class DS_Box extends    DS_AbstractShape
                             implements Box
{
    public static final String TYPE_NAME = "Box";
    
    @DSInaccessible
    public DS_Box(DeltaScriptGeometry geom)
    {super(geom);}
    
    @DSName("solidDimensions") @DSDynamicField
    public final int solidDimensions()
    {return dimensions();}

    @DSName({"boundingBox", "bbox"}) @DSDynamicField
    public DS_Box boundingBox()
    {return this;}

    public abstract DS_Vector origin();
    
    public abstract DS_Vector span();
    
    @DSName("center") @DSDynamicField
    public DS_Vector center()
    {return origin().add(span().div(2));}

    @DSName("curved") @DSDynamicField
    public final boolean curved()
    {return false;}

    @DSName("contains")
    public boolean contains(Vector pt)
    {
        DimensionMismatchException.check("contains", this, pt);
        return Algorithms.testBoxContains(this, pt);
    }
    
    @DSName("contains")
    public boolean contains(Box box)
    {
        DimensionMismatchException.check("contains", this, box);
        return Algorithms.testBoxContains(this, box);
    }

    @DSName("convex") @DSDynamicField
    public final boolean convex()
    {return true;}

    @DSName("compound") @DSDynamicField
    public final boolean compound()
    {return false;}
    
    @DSName("clamp")
    public DS_Vector clamp(Vector vec)
    {
        DimensionMismatchException.check("clamp", this, vec);
        final DS_Vector min = origin();
        final DS_Vector max = min.add(span());
        final float[] result = new float[vec.dimensions()];
        for (int i=0; i<result.length; i++)
            result[i] = Math.min(max.component(i),
                                 Math.max(min.component(i), vec.component(i)));
        return geom.vec(result);
    }

    @DSName("min")
    public float min(int dim)
    {return origin().component(dim);}

    @DSName("max")
    public float max(int dim)
    {return origin().add(span()).component(dim);}

    @DSName("diagonal") @DSDynamicField    
    public DS_Line diagonal()
    {return geom.line(origin(), origin().add(span()));}
    
    @DSName("empty") @DSDynamicField
    public final boolean empty()
    {return false;}
    
    @Override public DS_Vector random()
    {
        final DS_Vector o = origin(), s = span();
        final float[] result = new float[dimensions()];
        for (int i=0; i<dimensions(); i++)
            result[i] = o.component(i) + (float)(Math.random()*s.component(i));
        return geom.vec(result);
    }
    
    @Override public String toString()
    {
        final StringBuilder sb = new StringBuilder();
        final float[] span = span().floatArrayValue();
        sb.append(span[0]);
        for (int i=1; i<span.length; i++)
            sb.append(" by " + span[i]);
        sb.append(" at ");
        sb.append(origin());
        return standardToString(sb.toString());
    }
    
    @Override public DS_Object operator(Operator op, DS_Object other)
    {
        if (op == Operator.RANGE_STEP && other instanceof DS_Scalar)
        {
            float[] arr1 = new float[dimensions()+1],
                    arr2 = new float[dimensions()+1];
            System.arraycopy(origin().toArray(),0, arr1, 0, dimensions());
            System.arraycopy(span().toArray(),  0, arr2, 0, dimensions());
            arr2[dimensions()] = ((DS_Scalar)other).floatValue();
            final DeltaScriptGeometry geom =
                    DScriptContext.getContextGeometry();
            return geom.box(geom.vec(arr1), geom.vec(arr2));
        }
        return super.operator(op, other);
    }
}