Home | History | Annotate | Download | only in collision 
      1 /* ----------------------------------------------------------------------------
      2  * This file was automatically generated by SWIG (http://www.swig.org).
      3  * Version 3.0.8
      4  *
      5  * Do not make changes to this file unless you know what you are doing--modify
      6  * the SWIG interface file instead.
      7  * ----------------------------------------------------------------------------- */
      8 
      9 package com.badlogic.gdx.physics.bullet.collision;
     10 
     11 import com.badlogic.gdx.physics.bullet.BulletBase;
     12 import com.badlogic.gdx.physics.bullet.linearmath.*;
     13 import com.badlogic.gdx.math.Vector3;
     14 import com.badlogic.gdx.math.Quaternion;
     15 import com.badlogic.gdx.math.Matrix3;
     16 import com.badlogic.gdx.math.Matrix4;
     17 
     18 public class btDbvt extends BulletBase {
     19 	private long swigCPtr;
     20 
     21 	protected btDbvt(final String className, long cPtr, boolean cMemoryOwn) {
     22 		super(className, cPtr, cMemoryOwn);
     23 		swigCPtr = cPtr;
     24 	}
     25 
     26 	/** Construct a new btDbvt, normally you should not need this constructor it's intended for low-level usage. */
     27 	public btDbvt(long cPtr, boolean cMemoryOwn) {
     28 		this("btDbvt", cPtr, cMemoryOwn);
     29 		construct();
     30 	}
     31 
     32 	@Override
     33 	protected void reset(long cPtr, boolean cMemoryOwn) {
     34 		if (!destroyed)
     35 			destroy();
     36 		super.reset(swigCPtr = cPtr, cMemoryOwn);
     37 	}
     38 
     39 	public static long getCPtr(btDbvt obj) {
     40 		return (obj == null) ? 0 : obj.swigCPtr;
     41 	}
     42 
     43 	@Override
     44 	protected void finalize() throws Throwable {
     45 		if (!destroyed)
     46 			destroy();
     47 		super.finalize();
     48 	}
     49 
     50   @Override protected synchronized void delete() {
     51 		if (swigCPtr != 0) {
     52 			if (swigCMemOwn) {
     53 				swigCMemOwn = false;
     54 				CollisionJNI.delete_btDbvt(swigCPtr);
     55 			}
     56 			swigCPtr = 0;
     57 		}
     58 		super.delete();
     59 	}
     60 
     61   static public class sStkNN extends BulletBase {
     62   	private long swigCPtr;
     63 
     64   	protected sStkNN(final String className, long cPtr, boolean cMemoryOwn) {
     65   		super(className, cPtr, cMemoryOwn);
     66   		swigCPtr = cPtr;
     67   	}
     68 
     69   	/** Construct a new sStkNN, normally you should not need this constructor it's intended for low-level usage. */
     70   	public sStkNN(long cPtr, boolean cMemoryOwn) {
     71   		this("sStkNN", cPtr, cMemoryOwn);
     72   		construct();
     73   	}
     74 
     75   	@Override
     76   	protected void reset(long cPtr, boolean cMemoryOwn) {
     77   		if (!destroyed)
     78   			destroy();
     79   		super.reset(swigCPtr = cPtr, cMemoryOwn);
     80   	}
     81 
     82   	public static long getCPtr(sStkNN obj) {
     83   		return (obj == null) ? 0 : obj.swigCPtr;
     84   	}
     85 
     86   	@Override
     87   	protected void finalize() throws Throwable {
     88   		if (!destroyed)
     89   			destroy();
     90   		super.finalize();
     91   	}
     92 
     93     @Override protected synchronized void delete() {
     94   		if (swigCPtr != 0) {
     95   			if (swigCMemOwn) {
     96   				swigCMemOwn = false;
     97   				CollisionJNI.delete_btDbvt_sStkNN(swigCPtr);
     98   			}
     99   			swigCPtr = 0;
    100   		}
    101   		super.delete();
    102   	}
    103 
    104     public void setA(btDbvtNode value) {
    105       CollisionJNI.btDbvt_sStkNN_a_set(swigCPtr, this, btDbvtNode.getCPtr(value), value);
    106     }
    107 
    108     public btDbvtNode getA() {
    109   	return btDbvtNode.internalTemp(CollisionJNI.btDbvt_sStkNN_a_get(swigCPtr, this), false);
    110   }
    111 
    112     public void setB(btDbvtNode value) {
    113       CollisionJNI.btDbvt_sStkNN_b_set(swigCPtr, this, btDbvtNode.getCPtr(value), value);
    114     }
    115 
    116     public btDbvtNode getB() {
    117   	return btDbvtNode.internalTemp(CollisionJNI.btDbvt_sStkNN_b_get(swigCPtr, this), false);
    118   }
    119 
    120     public sStkNN() {
    121       this(CollisionJNI.new_btDbvt_sStkNN__SWIG_0(), true);
    122     }
    123 
    124     public sStkNN(btDbvtNode na, btDbvtNode nb) {
    125       this(CollisionJNI.new_btDbvt_sStkNN__SWIG_1(btDbvtNode.getCPtr(na), na, btDbvtNode.getCPtr(nb), nb), true);
    126     }
    127 
    128   }
    129 
    130   static public class sStkNP extends BulletBase {
    131   	private long swigCPtr;
    132 
    133   	protected sStkNP(final String className, long cPtr, boolean cMemoryOwn) {
    134   		super(className, cPtr, cMemoryOwn);
    135   		swigCPtr = cPtr;
    136   	}
    137 
    138   	/** Construct a new sStkNP, normally you should not need this constructor it's intended for low-level usage. */
    139   	public sStkNP(long cPtr, boolean cMemoryOwn) {
    140   		this("sStkNP", cPtr, cMemoryOwn);
    141   		construct();
    142   	}
    143 
    144   	@Override
    145   	protected void reset(long cPtr, boolean cMemoryOwn) {
    146   		if (!destroyed)
    147   			destroy();
    148   		super.reset(swigCPtr = cPtr, cMemoryOwn);
    149   	}
    150 
    151   	public static long getCPtr(sStkNP obj) {
    152   		return (obj == null) ? 0 : obj.swigCPtr;
    153   	}
    154 
    155   	@Override
    156   	protected void finalize() throws Throwable {
    157   		if (!destroyed)
    158   			destroy();
    159   		super.finalize();
    160   	}
    161 
    162     @Override protected synchronized void delete() {
    163   		if (swigCPtr != 0) {
    164   			if (swigCMemOwn) {
    165   				swigCMemOwn = false;
    166   				CollisionJNI.delete_btDbvt_sStkNP(swigCPtr);
    167   			}
    168   			swigCPtr = 0;
    169   		}
    170   		super.delete();
    171   	}
    172 
    173     public void setNode(btDbvtNode value) {
    174       CollisionJNI.btDbvt_sStkNP_node_set(swigCPtr, this, btDbvtNode.getCPtr(value), value);
    175     }
    176 
    177     public btDbvtNode getNode() {
    178   	return btDbvtNode.internalTemp(CollisionJNI.btDbvt_sStkNP_node_get(swigCPtr, this), false);
    179   }
    180 
    181     public void setMask(int value) {
    182       CollisionJNI.btDbvt_sStkNP_mask_set(swigCPtr, this, value);
    183     }
    184 
    185     public int getMask() {
    186       return CollisionJNI.btDbvt_sStkNP_mask_get(swigCPtr, this);
    187     }
    188 
    189     public sStkNP(btDbvtNode n, long m) {
    190       this(CollisionJNI.new_btDbvt_sStkNP(btDbvtNode.getCPtr(n), n, m), true);
    191     }
    192 
    193   }
    194 
    195   static public class sStkNPS extends BulletBase {
    196   	private long swigCPtr;
    197 
    198   	protected sStkNPS(final String className, long cPtr, boolean cMemoryOwn) {
    199   		super(className, cPtr, cMemoryOwn);
    200   		swigCPtr = cPtr;
    201   	}
    202 
    203   	/** Construct a new sStkNPS, normally you should not need this constructor it's intended for low-level usage. */
    204   	public sStkNPS(long cPtr, boolean cMemoryOwn) {
    205   		this("sStkNPS", cPtr, cMemoryOwn);
    206   		construct();
    207   	}
    208 
    209   	@Override
    210   	protected void reset(long cPtr, boolean cMemoryOwn) {
    211   		if (!destroyed)
    212   			destroy();
    213   		super.reset(swigCPtr = cPtr, cMemoryOwn);
    214   	}
    215 
    216   	public static long getCPtr(sStkNPS obj) {
    217   		return (obj == null) ? 0 : obj.swigCPtr;
    218   	}
    219 
    220   	@Override
    221   	protected void finalize() throws Throwable {
    222   		if (!destroyed)
    223   			destroy();
    224   		super.finalize();
    225   	}
    226 
    227     @Override protected synchronized void delete() {
    228   		if (swigCPtr != 0) {
    229   			if (swigCMemOwn) {
    230   				swigCMemOwn = false;
    231   				CollisionJNI.delete_btDbvt_sStkNPS(swigCPtr);
    232   			}
    233   			swigCPtr = 0;
    234   		}
    235   		super.delete();
    236   	}
    237 
    238     public void setNode(btDbvtNode value) {
    239       CollisionJNI.btDbvt_sStkNPS_node_set(swigCPtr, this, btDbvtNode.getCPtr(value), value);
    240     }
    241 
    242     public btDbvtNode getNode() {
    243   	return btDbvtNode.internalTemp(CollisionJNI.btDbvt_sStkNPS_node_get(swigCPtr, this), false);
    244   }
    245 
    246     public void setMask(int value) {
    247       CollisionJNI.btDbvt_sStkNPS_mask_set(swigCPtr, this, value);
    248     }
    249 
    250     public int getMask() {
    251       return CollisionJNI.btDbvt_sStkNPS_mask_get(swigCPtr, this);
    252     }
    253 
    254     public void setValue(float value) {
    255       CollisionJNI.btDbvt_sStkNPS_value_set(swigCPtr, this, value);
    256     }
    257 
    258     public float getValue() {
    259       return CollisionJNI.btDbvt_sStkNPS_value_get(swigCPtr, this);
    260     }
    261 
    262     public sStkNPS() {
    263       this(CollisionJNI.new_btDbvt_sStkNPS__SWIG_0(), true);
    264     }
    265 
    266     public sStkNPS(btDbvtNode n, long m, float v) {
    267       this(CollisionJNI.new_btDbvt_sStkNPS__SWIG_1(btDbvtNode.getCPtr(n), n, m, v), true);
    268     }
    269 
    270   }
    271 
    272   static public class sStkCLN extends BulletBase {
    273   	private long swigCPtr;
    274 
    275   	protected sStkCLN(final String className, long cPtr, boolean cMemoryOwn) {
    276   		super(className, cPtr, cMemoryOwn);
    277   		swigCPtr = cPtr;
    278   	}
    279 
    280   	/** Construct a new sStkCLN, normally you should not need this constructor it's intended for low-level usage. */
    281   	public sStkCLN(long cPtr, boolean cMemoryOwn) {
    282   		this("sStkCLN", cPtr, cMemoryOwn);
    283   		construct();
    284   	}
    285 
    286   	@Override
    287   	protected void reset(long cPtr, boolean cMemoryOwn) {
    288   		if (!destroyed)
    289   			destroy();
    290   		super.reset(swigCPtr = cPtr, cMemoryOwn);
    291   	}
    292 
    293   	public static long getCPtr(sStkCLN obj) {
    294   		return (obj == null) ? 0 : obj.swigCPtr;
    295   	}
    296 
    297   	@Override
    298   	protected void finalize() throws Throwable {
    299   		if (!destroyed)
    300   			destroy();
    301   		super.finalize();
    302   	}
    303 
    304     @Override protected synchronized void delete() {
    305   		if (swigCPtr != 0) {
    306   			if (swigCMemOwn) {
    307   				swigCMemOwn = false;
    308   				CollisionJNI.delete_btDbvt_sStkCLN(swigCPtr);
    309   			}
    310   			swigCPtr = 0;
    311   		}
    312   		super.delete();
    313   	}
    314 
    315     public void setNode(btDbvtNode value) {
    316       CollisionJNI.btDbvt_sStkCLN_node_set(swigCPtr, this, btDbvtNode.getCPtr(value), value);
    317     }
    318 
    319     public btDbvtNode getNode() {
    320   	return btDbvtNode.internalTemp(CollisionJNI.btDbvt_sStkCLN_node_get(swigCPtr, this), false);
    321   }
    322 
    323     public void setParent(btDbvtNode value) {
    324       CollisionJNI.btDbvt_sStkCLN_parent_set(swigCPtr, this, btDbvtNode.getCPtr(value), value);
    325     }
    326 
    327     public btDbvtNode getParent() {
    328   	return btDbvtNode.internalTemp(CollisionJNI.btDbvt_sStkCLN_parent_get(swigCPtr, this), false);
    329   }
    330 
    331     public sStkCLN(btDbvtNode n, btDbvtNode p) {
    332       this(CollisionJNI.new_btDbvt_sStkCLN(btDbvtNode.getCPtr(n), n, btDbvtNode.getCPtr(p), p), true);
    333     }
    334 
    335   }
    336 
    337   static public class IWriter extends BulletBase {
    338   	private long swigCPtr;
    339 
    340   	protected IWriter(final String className, long cPtr, boolean cMemoryOwn) {
    341   		super(className, cPtr, cMemoryOwn);
    342   		swigCPtr = cPtr;
    343   	}
    344 
    345   	/** Construct a new IWriter, normally you should not need this constructor it's intended for low-level usage. */
    346   	public IWriter(long cPtr, boolean cMemoryOwn) {
    347   		this("IWriter", cPtr, cMemoryOwn);
    348   		construct();
    349   	}
    350 
    351   	@Override
    352   	protected void reset(long cPtr, boolean cMemoryOwn) {
    353   		if (!destroyed)
    354   			destroy();
    355   		super.reset(swigCPtr = cPtr, cMemoryOwn);
    356   	}
    357 
    358   	public static long getCPtr(IWriter obj) {
    359   		return (obj == null) ? 0 : obj.swigCPtr;
    360   	}
    361 
    362   	@Override
    363   	protected void finalize() throws Throwable {
    364   		if (!destroyed)
    365   			destroy();
    366   		super.finalize();
    367   	}
    368 
    369     @Override protected synchronized void delete() {
    370   		if (swigCPtr != 0) {
    371   			if (swigCMemOwn) {
    372   				swigCMemOwn = false;
    373   				CollisionJNI.delete_btDbvt_IWriter(swigCPtr);
    374   			}
    375   			swigCPtr = 0;
    376   		}
    377   		super.delete();
    378   	}
    379 
    380     public void Prepare(btDbvtNode root, int numnodes) {
    381       CollisionJNI.btDbvt_IWriter_Prepare(swigCPtr, this, btDbvtNode.getCPtr(root), root, numnodes);
    382     }
    383 
    384     public void WriteNode(btDbvtNode arg0, int index, int parent, int child0, int child1) {
    385       CollisionJNI.btDbvt_IWriter_WriteNode(swigCPtr, this, btDbvtNode.getCPtr(arg0), arg0, index, parent, child0, child1);
    386     }
    387 
    388     public void WriteLeaf(btDbvtNode arg0, int index, int parent) {
    389       CollisionJNI.btDbvt_IWriter_WriteLeaf(swigCPtr, this, btDbvtNode.getCPtr(arg0), arg0, index, parent);
    390     }
    391 
    392   }
    393 
    394   static public class IClone extends BulletBase {
    395   	private long swigCPtr;
    396 
    397   	protected IClone(final String className, long cPtr, boolean cMemoryOwn) {
    398   		super(className, cPtr, cMemoryOwn);
    399   		swigCPtr = cPtr;
    400   	}
    401 
    402   	/** Construct a new IClone, normally you should not need this constructor it's intended for low-level usage. */
    403   	public IClone(long cPtr, boolean cMemoryOwn) {
    404   		this("IClone", cPtr, cMemoryOwn);
    405   		construct();
    406   	}
    407 
    408   	@Override
    409   	protected void reset(long cPtr, boolean cMemoryOwn) {
    410   		if (!destroyed)
    411   			destroy();
    412   		super.reset(swigCPtr = cPtr, cMemoryOwn);
    413   	}
    414 
    415   	public static long getCPtr(IClone obj) {
    416   		return (obj == null) ? 0 : obj.swigCPtr;
    417   	}
    418 
    419   	@Override
    420   	protected void finalize() throws Throwable {
    421   		if (!destroyed)
    422   			destroy();
    423   		super.finalize();
    424   	}
    425 
    426     @Override protected synchronized void delete() {
    427   		if (swigCPtr != 0) {
    428   			if (swigCMemOwn) {
    429   				swigCMemOwn = false;
    430   				CollisionJNI.delete_btDbvt_IClone(swigCPtr);
    431   			}
    432   			swigCPtr = 0;
    433   		}
    434   		super.delete();
    435   	}
    436 
    437     public void CloneLeaf(btDbvtNode arg0) {
    438       CollisionJNI.btDbvt_IClone_CloneLeaf(swigCPtr, this, btDbvtNode.getCPtr(arg0), arg0);
    439     }
    440 
    441     public IClone() {
    442       this(CollisionJNI.new_btDbvt_IClone(), true);
    443     }
    444 
    445   }
    446 
    447   public void setRoot(btDbvtNode value) {
    448     CollisionJNI.btDbvt_root_set(swigCPtr, this, btDbvtNode.getCPtr(value), value);
    449   }
    450 
    451   public btDbvtNode getRoot() {
    452 	return btDbvtNode.internalTemp(CollisionJNI.btDbvt_root_get(swigCPtr, this), false);
    453 }
    454 
    455   public void setFree(btDbvtNode value) {
    456     CollisionJNI.btDbvt_free_set(swigCPtr, this, btDbvtNode.getCPtr(value), value);
    457   }
    458 
    459   public btDbvtNode getFree() {
    460 	return btDbvtNode.internalTemp(CollisionJNI.btDbvt_free_get(swigCPtr, this), false);
    461 }
    462 
    463   public void setLkhd(int value) {
    464     CollisionJNI.btDbvt_lkhd_set(swigCPtr, this, value);
    465   }
    466 
    467   public int getLkhd() {
    468     return CollisionJNI.btDbvt_lkhd_get(swigCPtr, this);
    469   }
    470 
    471   public void setLeaves(int value) {
    472     CollisionJNI.btDbvt_leaves_set(swigCPtr, this, value);
    473   }
    474 
    475   public int getLeaves() {
    476     return CollisionJNI.btDbvt_leaves_get(swigCPtr, this);
    477   }
    478 
    479   public void setOpath(long value) {
    480     CollisionJNI.btDbvt_opath_set(swigCPtr, this, value);
    481   }
    482 
    483   public long getOpath() {
    484     return CollisionJNI.btDbvt_opath_get(swigCPtr, this);
    485   }
    486 
    487   public void setStkStack(SWIGTYPE_p_btAlignedObjectArrayT_btDbvt__sStkNN_t value) {
    488     CollisionJNI.btDbvt_stkStack_set(swigCPtr, this, SWIGTYPE_p_btAlignedObjectArrayT_btDbvt__sStkNN_t.getCPtr(value));
    489   }
    490 
    491   public SWIGTYPE_p_btAlignedObjectArrayT_btDbvt__sStkNN_t getStkStack() {
    492     long cPtr = CollisionJNI.btDbvt_stkStack_get(swigCPtr, this);
    493     return (cPtr == 0) ? null : new SWIGTYPE_p_btAlignedObjectArrayT_btDbvt__sStkNN_t(cPtr, false);
    494   }
    495 
    496   public void setRayTestStack(SWIGTYPE_p_btAlignedObjectArrayT_btDbvtNode_const_p_t value) {
    497     CollisionJNI.btDbvt_rayTestStack_set(swigCPtr, this, SWIGTYPE_p_btAlignedObjectArrayT_btDbvtNode_const_p_t.getCPtr(value));
    498   }
    499 
    500   public SWIGTYPE_p_btAlignedObjectArrayT_btDbvtNode_const_p_t getRayTestStack() {
    501     long cPtr = CollisionJNI.btDbvt_rayTestStack_get(swigCPtr, this);
    502     return (cPtr == 0) ? null : new SWIGTYPE_p_btAlignedObjectArrayT_btDbvtNode_const_p_t(cPtr, false);
    503   }
    504 
    505   public btDbvt() {
    506     this(CollisionJNI.new_btDbvt(), true);
    507   }
    508 
    509   public void clear() {
    510     CollisionJNI.btDbvt_clear(swigCPtr, this);
    511   }
    512 
    513   public boolean empty() {
    514     return CollisionJNI.btDbvt_empty(swigCPtr, this);
    515   }
    516 
    517   public void optimizeBottomUp() {
    518     CollisionJNI.btDbvt_optimizeBottomUp(swigCPtr, this);
    519   }
    520 
    521   public void optimizeTopDown(int bu_treshold) {
    522     CollisionJNI.btDbvt_optimizeTopDown__SWIG_0(swigCPtr, this, bu_treshold);
    523   }
    524 
    525   public void optimizeTopDown() {
    526     CollisionJNI.btDbvt_optimizeTopDown__SWIG_1(swigCPtr, this);
    527   }
    528 
    529   public void optimizeIncremental(int passes) {
    530     CollisionJNI.btDbvt_optimizeIncremental(swigCPtr, this, passes);
    531   }
    532 
    533   public btDbvtNode insert(btDbvtAabbMm box, long data) {
    534 	return btDbvtNode.internalTemp(CollisionJNI.btDbvt_insert(swigCPtr, this, btDbvtAabbMm.getCPtr(box), box, data), false);
    535 }
    536 
    537   public void update(btDbvtNode leaf, int lookahead) {
    538     CollisionJNI.btDbvt_update__SWIG_0(swigCPtr, this, btDbvtNode.getCPtr(leaf), leaf, lookahead);
    539   }
    540 
    541   public void update(btDbvtNode leaf) {
    542     CollisionJNI.btDbvt_update__SWIG_1(swigCPtr, this, btDbvtNode.getCPtr(leaf), leaf);
    543   }
    544 
    545   public void update(btDbvtNode leaf, btDbvtAabbMm volume) {
    546     CollisionJNI.btDbvt_update__SWIG_2(swigCPtr, this, btDbvtNode.getCPtr(leaf), leaf, btDbvtAabbMm.getCPtr(volume), volume);
    547   }
    548 
    549   public boolean update(btDbvtNode leaf, btDbvtAabbMm volume, Vector3 velocity, float margin) {
    550     return CollisionJNI.btDbvt_update__SWIG_3(swigCPtr, this, btDbvtNode.getCPtr(leaf), leaf, btDbvtAabbMm.getCPtr(volume), volume, velocity, margin);
    551   }
    552 
    553   public boolean update(btDbvtNode leaf, btDbvtAabbMm volume, Vector3 velocity) {
    554     return CollisionJNI.btDbvt_update__SWIG_4(swigCPtr, this, btDbvtNode.getCPtr(leaf), leaf, btDbvtAabbMm.getCPtr(volume), volume, velocity);
    555   }
    556 
    557   public boolean update(btDbvtNode leaf, btDbvtAabbMm volume, float margin) {
    558     return CollisionJNI.btDbvt_update__SWIG_5(swigCPtr, this, btDbvtNode.getCPtr(leaf), leaf, btDbvtAabbMm.getCPtr(volume), volume, margin);
    559   }
    560 
    561   public void remove(btDbvtNode leaf) {
    562     CollisionJNI.btDbvt_remove(swigCPtr, this, btDbvtNode.getCPtr(leaf), leaf);
    563   }
    564 
    565   public void write(btDbvt.IWriter iwriter) {
    566     CollisionJNI.btDbvt_write(swigCPtr, this, btDbvt.IWriter.getCPtr(iwriter), iwriter);
    567   }
    568 
    569   public void clone(btDbvt dest, btDbvt.IClone iclone) {
    570     CollisionJNI.btDbvt_clone__SWIG_0(swigCPtr, this, btDbvt.getCPtr(dest), dest, btDbvt.IClone.getCPtr(iclone), iclone);
    571   }
    572 
    573   public void clone(btDbvt dest) {
    574     CollisionJNI.btDbvt_clone__SWIG_1(swigCPtr, this, btDbvt.getCPtr(dest), dest);
    575   }
    576 
    577   public static int maxdepth(btDbvtNode node) {
    578     return CollisionJNI.btDbvt_maxdepth(btDbvtNode.getCPtr(node), node);
    579   }
    580 
    581   public static int countLeaves(btDbvtNode node) {
    582     return CollisionJNI.btDbvt_countLeaves(btDbvtNode.getCPtr(node), node);
    583   }
    584 
    585   public static void extractLeaves(btDbvtNode node, SWIGTYPE_p_btAlignedObjectArrayT_btDbvtNode_const_p_t leaves) {
    586     CollisionJNI.btDbvt_extractLeaves(btDbvtNode.getCPtr(node), node, SWIGTYPE_p_btAlignedObjectArrayT_btDbvtNode_const_p_t.getCPtr(leaves));
    587   }
    588 
    589   public static void benchmark() {
    590     CollisionJNI.btDbvt_benchmark();
    591   }
    592 
    593   public static void enumNodes(btDbvtNode root, ICollide policy) {
    594     CollisionJNI.btDbvt_enumNodes(btDbvtNode.getCPtr(root), root, ICollide.getCPtr(policy), policy);
    595   }
    596 
    597   public static void enumLeaves(btDbvtNode root, ICollide policy) {
    598     CollisionJNI.btDbvt_enumLeaves(btDbvtNode.getCPtr(root), root, ICollide.getCPtr(policy), policy);
    599   }
    600 
    601   public void collideTT(btDbvtNode root0, btDbvtNode root1, ICollide policy) {
    602     CollisionJNI.btDbvt_collideTT(swigCPtr, this, btDbvtNode.getCPtr(root0), root0, btDbvtNode.getCPtr(root1), root1, ICollide.getCPtr(policy), policy);
    603   }
    604 
    605   public void collideTTpersistentStack(btDbvtNode root0, btDbvtNode root1, ICollide policy) {
    606     CollisionJNI.btDbvt_collideTTpersistentStack(swigCPtr, this, btDbvtNode.getCPtr(root0), root0, btDbvtNode.getCPtr(root1), root1, ICollide.getCPtr(policy), policy);
    607   }
    608 
    609   public void collideTV(btDbvtNode root, btDbvtAabbMm volume, ICollide policy) {
    610     CollisionJNI.btDbvt_collideTV(swigCPtr, this, btDbvtNode.getCPtr(root), root, btDbvtAabbMm.getCPtr(volume), volume, ICollide.getCPtr(policy), policy);
    611   }
    612 
    613   public static void rayTest(btDbvtNode root, Vector3 rayFrom, Vector3 rayTo, ICollide policy) {
    614     CollisionJNI.btDbvt_rayTest(btDbvtNode.getCPtr(root), root, rayFrom, rayTo, ICollide.getCPtr(policy), policy);
    615   }
    616 
    617   public void rayTestInternal(btDbvtNode root, Vector3 rayFrom, Vector3 rayTo, Vector3 rayDirectionInverse, long[] signs, float lambda_max, Vector3 aabbMin, Vector3 aabbMax, ICollide policy) {
    618     CollisionJNI.btDbvt_rayTestInternal(swigCPtr, this, btDbvtNode.getCPtr(root), root, rayFrom, rayTo, rayDirectionInverse, signs, lambda_max, aabbMin, aabbMax, ICollide.getCPtr(policy), policy);
    619   }
    620 
    621   public static void collideKDOP(btDbvtNode root, btVector3 normals, java.nio.FloatBuffer offsets, int count, ICollide policy) {
    622     assert offsets.isDirect() : "Buffer must be allocated direct.";
    623     {
    624       CollisionJNI.btDbvt_collideKDOP__SWIG_0(btDbvtNode.getCPtr(root), root, btVector3.getCPtr(normals), normals, offsets, count, ICollide.getCPtr(policy), policy);
    625     }
    626   }
    627 
    628   public static void collideOCL(btDbvtNode root, btVector3 normals, java.nio.FloatBuffer offsets, Vector3 sortaxis, int count, ICollide policy, boolean fullsort) {
    629     assert offsets.isDirect() : "Buffer must be allocated direct.";
    630     {
    631       CollisionJNI.btDbvt_collideOCL__SWIG_0(btDbvtNode.getCPtr(root), root, btVector3.getCPtr(normals), normals, offsets, sortaxis, count, ICollide.getCPtr(policy), policy, fullsort);
    632     }
    633   }
    634 
    635   public static void collideOCL(btDbvtNode root, btVector3 normals, java.nio.FloatBuffer offsets, Vector3 sortaxis, int count, ICollide policy) {
    636     assert offsets.isDirect() : "Buffer must be allocated direct.";
    637     {
    638       CollisionJNI.btDbvt_collideOCL__SWIG_1(btDbvtNode.getCPtr(root), root, btVector3.getCPtr(normals), normals, offsets, sortaxis, count, ICollide.getCPtr(policy), policy);
    639     }
    640   }
    641 
    642   public static void collideTU(btDbvtNode root, ICollide policy) {
    643     CollisionJNI.btDbvt_collideTU(btDbvtNode.getCPtr(root), root, ICollide.getCPtr(policy), policy);
    644   }
    645 
    646   public static int nearest(java.nio.IntBuffer i, btDbvt.sStkNPS a, float v, int l, int h) {
    647     assert i.isDirect() : "Buffer must be allocated direct.";
    648     {
    649       return CollisionJNI.btDbvt_nearest(i, btDbvt.sStkNPS.getCPtr(a), a, v, l, h);
    650     }
    651   }
    652 
    653   public static int allocate(SWIGTYPE_p_btAlignedObjectArrayT_int_t ifree, SWIGTYPE_p_btAlignedObjectArrayT_btDbvt__sStkNPS_t stock, btDbvt.sStkNPS value) {
    654     return CollisionJNI.btDbvt_allocate(SWIGTYPE_p_btAlignedObjectArrayT_int_t.getCPtr(ifree), SWIGTYPE_p_btAlignedObjectArrayT_btDbvt__sStkNPS_t.getCPtr(stock), btDbvt.sStkNPS.getCPtr(value), value);
    655   }
    656 
    657   public static void collideKDOP(btDbvtNode root, java.nio.FloatBuffer normals, java.nio.FloatBuffer offsets, int count, ICollide policy) {
    658     assert normals.isDirect() : "Buffer must be allocated direct.";
    659     assert offsets.isDirect() : "Buffer must be allocated direct.";
    660     {
    661       CollisionJNI.btDbvt_collideKDOP__SWIG_1(btDbvtNode.getCPtr(root), root, normals, offsets, count, ICollide.getCPtr(policy), policy);
    662     }
    663   }
    664 
    665   public static void collideOCL(btDbvtNode root, java.nio.FloatBuffer normals, java.nio.FloatBuffer offsets, Vector3 sortaxis, int count, ICollide policy, boolean fullsort) {
    666     assert normals.isDirect() : "Buffer must be allocated direct.";
    667     assert offsets.isDirect() : "Buffer must be allocated direct.";
    668     {
    669       CollisionJNI.btDbvt_collideOCL__SWIG_2(btDbvtNode.getCPtr(root), root, normals, offsets, sortaxis, count, ICollide.getCPtr(policy), policy, fullsort);
    670     }
    671   }
    672 
    673   public static void collideOCL(btDbvtNode root, java.nio.FloatBuffer normals, java.nio.FloatBuffer offsets, Vector3 sortaxis, int count, ICollide policy) {
    674     assert normals.isDirect() : "Buffer must be allocated direct.";
    675     assert offsets.isDirect() : "Buffer must be allocated direct.";
    676     {
    677       CollisionJNI.btDbvt_collideOCL__SWIG_3(btDbvtNode.getCPtr(root), root, normals, offsets, sortaxis, count, ICollide.getCPtr(policy), policy);
    678     }
    679   }
    680 
    681   public final static int SIMPLE_STACKSIZE = 64;
    682   public final static int DOUBLE_STACKSIZE = SIMPLE_STACKSIZE*2;
    683 
    684 }
    685