   Opcode (Collision Lib) NbTris are not where the docs and demos state? Any example plz
  In the opcode docs it states this,// 1) Initialize the creation structurOPCODECREATE OPCC; // Surface data OPCC.NbTris  = ...; OPCC.NbVerts  = ...; OPCC.Tris  = ...; OPCC.Verts  = ...; is the definition for the OPCODECREATE structure.And to further back this up, in an example engine that uses opcode v1.2(The version I too use) it has the following code, OPCODECREATE OPCC;    OPCC.NbTris = numberTriangles;  OPCC.NbVerts = numberVertices;  OPCC.Rules = SPLIT_COMPLETE | SPLIT_SPLATTERPOINTS | SPLIT_GEOMCENTER;  OPCC.NoLeaf = true;  OPCC.Quantized = true;  OPCC.Tris = triangles;Which again references variables called NbTris and NbVerts within the opcodeCreate structure.Yet, and here the plot thickens, when trying to compile code that references it,#include <iostream>#include <Opcode.h>//#include <OPC_Model.h>using namespace Opcode;int main(){printf("Test");Opcode::InitOpcode();Log("Testing");    Model sample;    OPCODECREATE opc;    opc.NbVerts = 5;return 0;}I'm the told the reference NbVerts does not exist.And to back that up, here is the definition for the structure,struct OPCODE_API OPCODECREATE{//! ConstructorOPCODECREATE();MeshInterface*mIMesh;//!< Mesh interface (access to triangles & vertices) (*)BuildSettingsmSettings;//!< Builder's settingsboolmNoLeaf;//!< true => discard leaf nodes (else use a normal tree)boolmQuantized;//!< true => quantize the tree (else use a normal tree)#ifdef __MESHMERIZER_H__boolmCollisionHull;//!< true => use convex hull + GJK#endif // __MESHMERIZER_H__boolmKeepOriginal;//!< true => keep a copy of the original tree (debug purpose)boolmCanRemap;//!< true => allows OPCODE to reorganize client arrays// (*) This pointer is saved internally and used by OPCODE until collision structures are released,// so beware of the object's lifetime.};enum ModelFlag{OPC_QUANTIZED= (1<<0),//!< Compressed/uncompressed treeOPC_NO_LEAF= (1<<1),//!< Leaf/NoLeaf treeOPC_SINGLE_NODE= (1<<2)//!< Special case for 1-node models};class OPCODE_API BaseModel{public:// Constructor/DestructorBaseModel();virtual~BaseModel();////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////** *Builds a collision model. *\paramcreate[in] model creation structure *\returntrue if success *////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////virtualboolBuild(const OPCODECREATE& create)= 0;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////** *Gets the number of bytes used by the tree. *\returnamount of bytes used *////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////virtualudwordGetUsedBytes()const= 0;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////** *Refits the collision model. This can be used to handle dynamic meshes. Usage is: *1. modify your mesh vertices (keep the topology constant!) *2. refit the tree (call this method) *\returntrue if success *////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////virtualboolRefit();////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////** *Gets the source tree. *\returngeneric tree *////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////inline_constAABBTree*GetSourceTree()const{ return mSource;}////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////** *Gets the tree. *\returnthe collision tree *////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////inline_constAABBOptimizedTree*GetTree()const{ return mTree;}////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////** *Gets the tree. *\returnthe collision tree *////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////inline_AABBOptimizedTree*GetTree(){ return mTree;}////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////** *Gets the number of nodes in the tree. *Should be 2*N-1 for normal trees and N-1 for optimized ones. *\returnnumber of nodes *////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////inline_udwordGetNbNodes()const{ return mTree->GetNbNodes();}////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////** *Checks whether the tree has leaf nodes or not. *\returntrue if the tree has leaf nodes (normal tree), else false (optimized tree) *////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////inline_BOOLHasLeafNodes()const{ return !(mModelCode & OPC_NO_LEAF);}////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////** *Checks whether the tree is quantized or not. *\returntrue if the tree is quantized *////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////inline_BOOLIsQuantized()const{ return mModelCode & OPC_QUANTIZED;}////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////** *Checks whether the model has a single node or not. This special case must be handled separately. *\returntrue if the model has only 1 node *////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////inline_BOOLHasSingleNode()const{ return mModelCode & OPC_SINGLE_NODE;}////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////** *Gets the model's code. *\returnmodel's code *////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////inline_udwordGetModelCode()const{ return mModelCode;}////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////** *Gets the mesh interface. *\returnmesh interface *////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////inline_constMeshInterface*GetMeshInterface()const{ return mIMesh;}////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////** *Sets the mesh interface. *\paramimesh[in] mesh interface *////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////inline_voidSetMeshInterface(const MeshInterface* imesh){ mIMesh = imesh;}protected:constMeshInterface*mIMesh;//!< User-defined mesh interfaceudwordmModelCode;//!< Model code = combination of ModelFlag(s)AABBTree*mSource;//!< Original source treeAABBOptimizedTree*mTree;//!< Optimized tree owned by the model// Internal methodsvoidReleaseBase();boolCreateTree(bool no_leaf, bool quantized);};No mention of nbverts. Yet, the meshinterface class has variables called mNbverts and tris.So this all raises a few questions,If indeed opcode has been changed to move these vars into the meshinterface class, how comes the demo code above references them in the OPCODECREATE structure instead?If it has changed, why do the latest docs not reflect the changes?Please, any light anyone can shed on this would greatly be appreciated, I'm having zero luck finding any opcode examples/tutorials beyond the one above which is part of a 3d engine so not easy to isolate and test.   