public ConvexPointCloudShape() { m_localScaling = new IndexedVector3(1); m_shapeType = BroadphaseNativeTypes.CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE; m_unscaledPoints = null; m_numPoints = 0; }
protected virtual int SetAngularLimits(ConstraintInfo2 info, int row_offset, ref IndexedMatrix transA, ref IndexedMatrix transB, ref IndexedVector3 linVelA, ref IndexedVector3 linVelB, ref IndexedVector3 angVelA, ref IndexedVector3 angVelB) { Generic6DofConstraint d6constraint = this; int row = row_offset; //solve angular limits for (int i = 0; i < 3; i++) { if (d6constraint.GetRotationalLimitMotor(i).NeedApplyTorques()) { IndexedVector3 axis = d6constraint.GetAxis(i); int tempFlags = ((int)m_flags) >> ((i + 3) * BT_6DOF_FLAGS_AXIS_SHIFT); SixDofFlags flags = (SixDofFlags)tempFlags; if (0 == (flags & SixDofFlags.BT_6DOF_FLAGS_CFM_NORM)) { m_angularLimits[i].m_normalCFM = info.m_solverConstraints[0].m_cfm; } if (0 == (flags & SixDofFlags.BT_6DOF_FLAGS_CFM_STOP)) { m_angularLimits[i].m_stopCFM = info.m_solverConstraints[0].m_cfm; } if (0 == (flags & SixDofFlags.BT_6DOF_FLAGS_ERP_STOP)) { m_angularLimits[i].m_stopERP = info.erp; } row += GetLimitMotorInfo2(d6constraint.GetRotationalLimitMotor(i), ref transA, ref transB, ref linVelA, ref linVelB, ref angVelA, ref angVelB, info, row, ref axis, 1, false); } } return row; }
public BU_Simplex1to4(ref IndexedVector3 pt0,ref IndexedVector3 pt1,ref IndexedVector3 pt2) { m_shapeType = BroadphaseNativeTypes.TETRAHEDRAL_SHAPE_PROXYTYPE; AddVertex(ref pt0); AddVertex(ref pt1); AddVertex(ref pt2); }
public override IndexedVector3 LocalGetSupportingVertexWithoutMargin(ref IndexedVector3 vec0) { IndexedVector3 supVec = IndexedVector3.Zero; IndexedVector3 vec = vec0; float lenSqr = vec.LengthSquared(); if (lenSqr < 0.0001f) { vec = new IndexedVector3(1, 0, 0); } else { float rlen = (1.0f) / (float)Math.Sqrt(lenSqr); vec *= rlen; //vec.Normalize(); } LocalSupportVertexCallback supportCallback = new LocalSupportVertexCallback(ref vec); IndexedVector3 aabbMax = new IndexedVector3(float.MaxValue); IndexedVector3 aabbMin = -aabbMax; m_stridingMesh.InternalProcessAllTriangles(supportCallback,ref aabbMin,ref aabbMax); supVec = supportCallback.GetSupportVertexLocal(); return supVec; }
public virtual IndexedVector3 GetHalfExtentsWithMargin() { IndexedVector3 halfExtents = GetHalfExtentsWithoutMargin(); IndexedVector3 margin = new IndexedVector3(GetMargin()); halfExtents += margin; return halfExtents; }
//---------------------------------------------------------------------------------------------- public void SetupWorldObjects() { IndexedVector3 halfExtents = new IndexedVector3(10, 5, 10); CollisionShape groundShape = new BoxShape(ref halfExtents); IndexedVector3 world1Center = new IndexedVector3(-20, -5, 0); IndexedVector3 world2Center = new IndexedVector3(20, -5, 0); IndexedMatrix groundTransform1 = IndexedMatrix.CreateTranslation(world1Center); IndexedMatrix groundTransform2 = IndexedMatrix.CreateTranslation(world2Center); IndexedVector3 halfExtents2 = new IndexedVector3(0.5f); CollisionShape smallBoxShape = new BoxShape(ref halfExtents2); //IndexedMatrix groundTransform = IndexedMatrix.CreateTranslation(new IndexedVector3(0,-10,0)); float mass = 0f; LocalCreateRigidBodyMultiWorld(mass, ref groundTransform1, groundShape ,m_worlds[0]); LocalCreateRigidBodyMultiWorld(mass, ref groundTransform2, groundShape, m_worlds[1]); mass = 1f; for (int i = 0; i < 5; ++i) { IndexedVector3 offset = new IndexedVector3(0, halfExtents.Y + halfExtents2.Y + (2 * i), 0); IndexedMatrix boxTransform1 = IndexedMatrix.CreateTranslation(world1Center+offset); IndexedMatrix boxTransform2 = IndexedMatrix.CreateTranslation(world2Center + offset); LocalCreateRigidBodyMultiWorld(mass, ref boxTransform1, smallBoxShape, m_worlds[0]); LocalCreateRigidBodyMultiWorld(mass, ref boxTransform2, smallBoxShape, m_worlds[1]); } }
public void Reset() { m_relpos1CrossNormal = IndexedVector3.Zero; m_contactNormal = IndexedVector3.Zero; m_relpos2CrossNormal = IndexedVector3.Zero; m_angularComponentA = IndexedVector3.Zero; m_angularComponentB = IndexedVector3.Zero; m_appliedPushImpulse = 0f; m_appliedImpulse = 0f; m_friction = 0f; m_jacDiagABInv = 0f; m_numConsecutiveRowsPerKernel = 0; m_frictionIndex = 0; m_solverBodyA = null; m_companionIdA = 0; m_solverBodyB = null; m_companionIdB = 0; m_originalContactPoint = null; //m_originalContactPointConstraint = null; m_rhs = 0f; m_cfm = 0; m_lowerLimit = 0f; m_upperLimit = 0f; m_rhsPenetration = 0f; m_overrideNumSolverIterations = -1; }
///btActionInterface interface public virtual void DebugDraw(IDebugDraw debugDrawer) { for (int v=0;v<GetNumWheels();v++) { IndexedVector3 wheelColor = new IndexedVector3(0,1,1); if (GetWheelInfo(v).m_raycastInfo.m_isInContact) { wheelColor = new IndexedVector3(0,0,1); } else { wheelColor= new IndexedVector3(1,0,1); } IndexedVector3 wheelPosWS = GetWheelInfo(v).m_worldTransform._origin; IndexedMatrix temp = GetWheelInfo(v).m_worldTransform; IndexedVector3 axle = new IndexedVector3( GetWheelInfo(v).m_worldTransform._basis._el0[GetRightAxis()], GetWheelInfo(v).m_worldTransform._basis._el1[GetRightAxis()], GetWheelInfo(v).m_worldTransform._basis._el2[GetRightAxis()]); //debug wheels (cylinders) debugDrawer.DrawLine(wheelPosWS,wheelPosWS+axle,wheelColor); debugDrawer.DrawLine(wheelPosWS,GetWheelInfo(v).m_raycastInfo.m_contactPointWS,wheelColor); } }
public static bool Distance(ConvexShape shape0,ref IndexedMatrix wtrs0,ConvexShape shape1,ref IndexedMatrix wtrs1,ref IndexedVector3 guess,ref GjkEpaSolver2Results results) { using (GjkEpaSolver2MinkowskiDiff shape = BulletGlobals.GjkEpaSolver2MinkowskiDiffPool.Get()) using (GJK gjk = BulletGlobals.GJKPool.Get()) { Initialize(shape0, ref wtrs0, shape1, ref wtrs1, ref results, shape, false); gjk.Initialise(); GJKStatus gjk_status = gjk.Evaluate(shape, ref guess); if (gjk_status == GJKStatus.Valid) { IndexedVector3 w0 = IndexedVector3.Zero; IndexedVector3 w1 = IndexedVector3.Zero; for (uint i = 0; i < gjk.m_simplex.rank; ++i) { float p = gjk.m_simplex.p[i]; w0 += shape.Support(ref gjk.m_simplex.c[i].d, 0) * p; IndexedVector3 temp = -gjk.m_simplex.c[i].d; w1 += shape.Support(ref temp, 1) * p; } results.witnesses0 = wtrs0 * w0; results.witnesses1 = wtrs0 * w1; results.normal = w0 - w1; results.distance = results.normal.Length(); results.normal /= results.distance > GJK_MIN_DISTANCE ? results.distance : 1; return (true); } else { //GjkEpaSolver2Status results.status = (gjk_status == GJKStatus.Inside) ? GjkEpaSolver2Status.Penetrating : GjkEpaSolver2Status.GJK_Failed; return (false); } } }
public IndexedVector4(IndexedVector3 v,float w) { X = v.X; Y = v.Y; Z = v.Z; W = w; }
//notice that the vectors should be unit length public override void BatchedUnitVectorGetSupportingVertexWithoutMargin(IndexedVector3[] vectors, IndexedVector4[] supportVerticesOut, int numVectors) { for (int i=0;i<numVectors;i++) { supportVerticesOut[i] = IndexedVector4.Zero; } }
public void DrawArc(ref IndexedVector3 center, ref IndexedVector3 normal, ref IndexedVector3 axis, float radiusA, float radiusB, float minAngle, float maxAngle, ref IndexedVector3 color, bool drawSect, float stepDegrees) { IndexedVector3 vx = axis; IndexedVector3 vy = IndexedVector3.Cross(normal, axis); float step = stepDegrees * MathUtil.SIMD_RADS_PER_DEG; int nSteps = (int)((maxAngle - minAngle) / step); if (nSteps == 0) { nSteps = 1; } IndexedVector3 prev = center + radiusA * vx * (float)Math.Cos(minAngle) + radiusB * vy * (float)Math.Sin(minAngle); if (drawSect) { DrawLine(ref center, ref prev, ref color); } for (int i = 1; i <= nSteps; i++) { float angle = minAngle + (maxAngle - minAngle) * i / nSteps; IndexedVector3 next = center + radiusA * vx * (float)Math.Cos(angle) + radiusB * vy * (float)Math.Sin(angle); DrawLine(ref prev, ref next, ref color); prev = next; } if (drawSect) { DrawLine(ref center, ref prev, ref color); } }
public GjkEpaPenetrationDepthSolver() { } // for pool public virtual bool CalcPenDepth(ISimplexSolverInterface simplexSolver, ConvexShape convexA, ConvexShape convexB, ref IndexedMatrix transA, ref IndexedMatrix transB, ref IndexedVector3 v, ref IndexedVector3 wWitnessOnA, ref IndexedVector3 wWitnessOnB, IDebugDraw debugDraw) { //float radialmargin = 0f; IndexedVector3 guessVector = (transA._origin - transB._origin); GjkEpaSolver2Results results = new GjkEpaSolver2Results(); if (GjkEpaSolver2.Penetration(convexA, ref transA, convexB, ref transB, ref guessVector, ref results)) { // debugDraw->drawLine(results.witnesses[1],results.witnesses[1]+results.normal,btVector3(255,0,0)); //resultOut->addContactPoint(results.normal,results.witnesses[1],-results.depth); wWitnessOnA = results.witnesses0; wWitnessOnB = results.witnesses1; v = results.normal; return true; } else { if (GjkEpaSolver2.Distance(convexA, ref transA, convexB, ref transB, ref guessVector, ref results)) { wWitnessOnA = results.witnesses0; wWitnessOnB = results.witnesses1; v = results.normal; return false; } } return false; }
public void MergePoints(ref IndexedVector4 plane, float margin, IndexedVector3[] points, int point_count) { m_point_count = 0; m_penetration_depth = -1000.0f; int _k; for (_k = 0; _k < point_count; _k++) { float _dist = -ClipPolygon.DistancePointPlane(ref plane, ref points[_k]) + margin; if (_dist >= 0.0f) { if (_dist > m_penetration_depth) { m_penetration_depth = _dist; point_indices[0] = _k; m_point_count = 1; } else if ((_dist + MathUtil.SIMD_EPSILON) >= m_penetration_depth) { point_indices[m_point_count] = _k; m_point_count++; } } } for (_k = 0; _k < m_point_count; _k++) { m_points[_k] = points[point_indices[_k]]; } }
public static bool TestInternalObjects( ref IndexedMatrix trans0, ref IndexedMatrix trans1, ref IndexedVector3 delta_c, ref IndexedVector3 axis, ConvexPolyhedron convex0, ConvexPolyhedron convex1, float dmin) { float dp = delta_c.Dot(ref axis); IndexedVector3 localAxis0; InverseTransformPoint3x3(out localAxis0, ref axis,ref trans0); IndexedVector3 localAxis1; InverseTransformPoint3x3(out localAxis1, ref axis,ref trans1); IndexedVector3 p0; BoxSupport(ref convex0.m_extents, ref localAxis0, out p0); IndexedVector3 p1; BoxSupport(ref convex1.m_extents, ref localAxis1, out p1); float Radius0 = p0.X*localAxis0.X + p0.Y*localAxis0.Y + p0.Z*localAxis0.Z; float Radius1 = p1.X*localAxis1.X + p1.Y*localAxis1.Y + p1.Z*localAxis1.Z; float MinRadius = Radius0>convex0.m_radius ? Radius0 : convex0.m_radius; float MaxRadius = Radius1>convex1.m_radius ? Radius1 : convex1.m_radius; float MinMaxRadius = MaxRadius + MinRadius; float d0 = MinMaxRadius + dp; float d1 = MinMaxRadius - dp; float depth = d0<d1 ? d0:d1; if (depth > dmin) { return false; } return true; }
public override void InitializeDemo() { m_maxIterations = 10; SetCameraDistance(50f); //string filename = @"E:\users\man\bullet\xna-basic-output-1.txt"; //FileStream filestream = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.Read); //BulletGlobals.g_streamWriter = new StreamWriter(filestream); ///collision configuration contains default setup for memory, collision setup m_collisionConfiguration = new DefaultCollisionConfiguration(); ///use the default collision dispatcher. For parallel processing you can use a diffent dispatcher (see Extras/BulletMultiThreaded) m_dispatcher = new CollisionDispatcher(m_collisionConfiguration); m_broadphase = new DbvtBroadphase(); IOverlappingPairCache pairCache = null; //pairCache = new SortedOverlappingPairCache(); //m_broadphase = new SimpleBroadphase(1000, pairCache); ///the default constraint solver. For parallel processing you can use a different solver (see Extras/BulletMultiThreaded) SequentialImpulseConstraintSolver sol = new SequentialImpulseConstraintSolver(); m_constraintSolver = sol; m_dynamicsWorld = new DiscreteDynamicsWorld(m_dispatcher, m_broadphase, m_constraintSolver, m_collisionConfiguration); IndexedVector3 gravity = new IndexedVector3(0, -10, 0); m_dynamicsWorld.SetGravity(ref gravity); m_dynamicsWorld.SetForceUpdateAllAabbs(false); BuildLevelMap(); }
public StaticPlaneShape(ref IndexedVector3 planeNormal,float planeConstant) { m_shapeType = BroadphaseNativeTypes.STATIC_PLANE_PROXYTYPE; m_planeNormal = planeNormal; m_planeConstant = planeConstant; m_localScaling = IndexedVector3.Zero; }
public override void ProcessAllTriangles(ITriangleCallback callback, ref IndexedVector3 aabbMin, ref IndexedVector3 aabbMax) { IndexedVector3 halfExtents = (aabbMax - aabbMin) * .5f; float radius = halfExtents.Length(); IndexedVector3 center = (aabbMax + aabbMin) * 0.5f; //this is where the triangles are generated, given AABB and plane equation (normal/constant) IndexedVector3 tangentDir0; IndexedVector3 tangentDir1; //tangentDir0/tangentDir1 can be precalculated TransformUtil.PlaneSpace1(ref m_planeNormal, out tangentDir0, out tangentDir1); IndexedVector3 supVertex0 = IndexedVector3.Zero; IndexedVector3 supVertex1 = IndexedVector3.Zero; IndexedVector3 projectedCenter = center - (IndexedVector3.Dot(m_planeNormal,center) - m_planeConstant)*m_planeNormal; IndexedVector3[] triangle = new IndexedVector3[3]; triangle[0] = (projectedCenter + tangentDir0*radius + tangentDir1*radius); triangle[1] = (projectedCenter + tangentDir0 * radius - tangentDir1 * radius); triangle[2] = (projectedCenter - tangentDir0 * radius - tangentDir1 * radius); callback.ProcessTriangle(triangle,0,0); triangle[0] = projectedCenter - tangentDir0*radius - tangentDir1*radius; triangle[1] = projectedCenter - tangentDir0*radius + tangentDir1*radius; triangle[2] = projectedCenter + tangentDir0*radius + tangentDir1*radius; callback.ProcessTriangle(triangle,0,1); }
public override void InitializeDemo() { // std::cerr << "initializing...\n"; m_nearClip = 1f; m_farClip = 1000f; m_aspect = m_glutScreenWidth / m_glutScreenHeight; m_perspective = IndexedMatrix.CreatePerspectiveFieldOfView(MathHelper.ToRadians(40.0f), m_aspect, m_nearClip, m_farClip); // set up basic state m_upAxis = 1; // start with Y-axis as "up" m_type = PHY_ScalarType.PHY_FLOAT; m_model = eTerrainModel.eRadial;//eFractal; m_isDynamic = true; // set up the physics world m_collisionConfiguration = new DefaultCollisionConfiguration(); m_dispatcher = new CollisionDispatcher(m_collisionConfiguration); IndexedVector3 worldMin = new IndexedVector3(-1000,-1000,-1000); IndexedVector3 worldMax = new IndexedVector3(1000, 1000, 1000); //m_broadphase = new AxisSweep3Internal(ref worldMin,ref worldMax); m_broadphase = new AxisSweep3Internal(ref worldMin, ref worldMax, 0xfffe, 0xffff, 16384, null, false); m_constraintSolver = new SequentialImpulseConstraintSolver(); m_dynamicsWorld = new DiscreteDynamicsWorld(m_dispatcher,m_broadphase,m_constraintSolver,m_collisionConfiguration); // initialize axis- or type-dependent physics from here ClientResetScene(); }
public override IndexedVector3 LocalGetSupportingVertexWithoutMargin(ref IndexedVector3 vec) { IndexedVector3 supVec = IndexedVector3.Zero; float newDot,maxDot = float.MinValue; #if DEBUG if (BulletGlobals.g_streamWriter != null && BulletGlobals.debugConvexHull) { BulletGlobals.g_streamWriter.WriteLine("localGetSupportingVertexWithoutMargin"); MathUtil.PrintVector3(BulletGlobals.g_streamWriter, "vec", vec); for (int i = 0; i < m_unscaledPoints.Count; ++i) { MathUtil.PrintVector3(BulletGlobals.g_streamWriter, m_unscaledPoints[i]); } } #endif for (int i=0;i<m_unscaledPoints.Count;i++) { IndexedVector3 vtx = m_unscaledPoints[i] * m_localScaling; newDot = IndexedVector3.Dot(vec,vtx); if (newDot > maxDot) { maxDot = newDot; supVec = vtx; } } return supVec; }
public override void GetAabb(ref IndexedMatrix t,out IndexedVector3 aabbMin,out IndexedVector3 aabbMax) { float fmargin = GetMargin(); IndexedVector3 margin = new IndexedVector3(fmargin); aabbMin = t._origin - margin; aabbMax = t._origin + margin; }
public static IndexedVector3 GimGetPointInertia(ref IndexedVector3 point, float mass) { float x2 = point.X * point.X; float y2 = point.Y * point.Y; float z2 = point.Z * point.Z; return new IndexedVector3(mass * (y2 + z2), mass * (x2 + z2), mass * (x2 + y2)); }
public TriangleShape(ref IndexedVector3 p0,ref IndexedVector3 p1,ref IndexedVector3 p2) : base () { m_shapeType = BroadphaseNativeTypes.TRIANGLE_SHAPE_PROXYTYPE; m_vertices1[0] = p0; m_vertices1[1] = p1; m_vertices1[2] = p2; }
public void Initialize(ref IndexedVector3 p0,ref IndexedVector3 p1,ref IndexedVector3 p2) { m_shapeType = BroadphaseNativeTypes.TRIANGLE_SHAPE_PROXYTYPE; m_vertices1[0] = p0; m_vertices1[1] = p1; m_vertices1[2] = p2; }
public override void CalculateLocalInertia(float mass, out IndexedVector3 inertia) { ///this linear upscaling is not realistic, but we don't deal with large mass ratios... IndexedVector3 tmpInertia; m_childConvexShape.CalculateLocalInertia(mass, out tmpInertia); inertia = tmpInertia * m_uniformScalingFactor; }
public void Initialise(ref IndexedVector3 pointA, ref IndexedVector3 pointB, ref IndexedVector3 normal, float distance) { /* Don't initialize default values twice in C# */ m_lateralFrictionDir1 = IndexedVector3.Zero; m_lateralFrictionDir2 = IndexedVector3.Zero; m_lifeTime = 0; m_appliedImpulseLateral1 = 0f; m_appliedImpulseLateral2 = 0f; m_contactMotion1 = 0f; m_contactMotion2 = 0f; m_contactCFM1 = 0f; m_contactCFM2 = 0f; m_lateralFrictionInitialized = false; m_userPersistentData = null; m_appliedImpulse = 0f; m_partId0 = 0; m_partId1 = 0; m_index0 = 0; m_index1 = 0; m_combinedRestitution = 0f; m_combinedFriction = 0f; m_positionWorldOnA = IndexedVector3.Zero; m_positionWorldOnB = IndexedVector3.Zero; m_localPointA = pointA; m_localPointB = pointB; m_normalWorldOnB = normal; m_distance1 = distance; m_constraintRow[0].Reset(); m_constraintRow[1].Reset(); m_constraintRow[2].Reset(); }
public TriangleRaycastCallback() { } // for pool public TriangleRaycastCallback(ref IndexedVector3 from, ref IndexedVector3 to, EFlags flags) { m_from = from; m_to = to; m_flags = flags; m_hitFraction = 1f; }
public static void DebugDrawLine(ref IndexedVector3 from, ref IndexedVector3 to, ref IndexedVector3 color) { if (BulletGlobals.gDebugDraw != null) { BulletGlobals.gDebugDraw.DrawLine(ref from, ref to, ref color); } }
public virtual IndexedVector3 LocalGetSupportingVertex(ref IndexedVector3 vec) { IndexedVector3 supportVertex; IndexedMatrix ident = IndexedMatrix.Identity; SupportVertexCallback supportCallback = new SupportVertexCallback(ref vec,ref ident); IndexedVector3 aabbMax = MathUtil.MAX_VECTOR; IndexedVector3 aabbMin = MathUtil.MIN_VECTOR; // URGGHHH! if (m_inConstructor) { this.ProcessAllTrianglesCtor(supportCallback, ref aabbMin, ref aabbMax); } else { ProcessAllTriangles(supportCallback, ref aabbMin, ref aabbMax); } supportVertex = supportCallback.GetSupportVertexLocal(); supportCallback.Cleanup(); return supportVertex; }
public virtual void DrawSphere(float radius, ref IndexedMatrix transform, ref IndexedVector3 color) { IndexedVector3 start = transform._origin; IndexedVector3 xoffs = transform._basis * new IndexedVector3(radius, 0, 0); IndexedVector3 yoffs = transform._basis * new IndexedVector3(0, radius, 0); IndexedVector3 zoffs = transform._basis * new IndexedVector3(0, 0, radius); // XY DrawLine(start - xoffs, start + yoffs, color); DrawLine(start + yoffs, start + xoffs, color); DrawLine(start + xoffs, start - yoffs, color); DrawLine(start - yoffs, start - xoffs, color); // XZ DrawLine(start - xoffs, start + zoffs, color); DrawLine(start + zoffs, start + xoffs, color); DrawLine(start + xoffs, start - zoffs, color); DrawLine(start - zoffs, start - xoffs, color); // YZ DrawLine(start - yoffs, start + zoffs, color); DrawLine(start + zoffs, start + yoffs, color); DrawLine(start + yoffs, start - zoffs, color); DrawLine(start - zoffs, start - yoffs, color); }
/// protected initialization /** * Handles the work of constructors so that public constructors can be * backwards-compatible without a lot of copy/paste. */ protected void Initialize(int heightStickWidth, int heightStickLength, Object heightfieldData, float heightScale, float minHeight, float maxHeight, int upAxis, PHY_ScalarType hdt, bool flipQuadEdges) { // validation Debug.Assert(heightStickWidth > 1, "bad width"); Debug.Assert(heightStickLength > 1, "bad length"); Debug.Assert(heightfieldData != null, "null heightfield data"); // Debug.Assert(heightScale) -- do we care? Trust caller here Debug.Assert(minHeight <= maxHeight, "bad min/max height"); Debug.Assert(upAxis >= 0 && upAxis < 3, "bad upAxis--should be in range [0,2]"); Debug.Assert(hdt != PHY_ScalarType.PHY_UCHAR || hdt != PHY_ScalarType.PHY_FLOAT || hdt != PHY_ScalarType.PHY_SHORT, "Bad height data type enum"); // initialize member variables m_shapeType = BroadphaseNativeTypes.TERRAIN_SHAPE_PROXYTYPE; m_heightStickWidth = heightStickWidth; m_heightStickLength = heightStickLength; m_minHeight = minHeight; m_maxHeight = maxHeight; m_width = (heightStickWidth - 1); m_length = (heightStickLength - 1); m_heightScale = heightScale; // copy the data in m_heightFieldDataByte = heightfieldData as byte[]; m_heightFieldDataFloat = heightfieldData as float[]; m_heightDataType = hdt; m_flipQuadEdges = flipQuadEdges; m_useDiamondSubdivision = false; m_upAxis = upAxis; m_localScaling = new IndexedVector3(1f); // determine min/max axis-aligned bounding box (aabb) values switch (m_upAxis) { case 0: { m_localAabbMin = new IndexedVector3(m_minHeight, 0, 0); m_localAabbMax = new IndexedVector3(m_maxHeight, m_width, m_length); break; } case 1: { m_localAabbMin = new IndexedVector3(0, m_minHeight, 0); m_localAabbMax = new IndexedVector3(m_width, m_maxHeight, m_length); break; }; case 2: { m_localAabbMin = new IndexedVector3(0, 0, m_minHeight); m_localAabbMax = new IndexedVector3(m_width, m_length, m_maxHeight); break; } default: { //need to get valid m_upAxis Debug.Assert(false, "Bad m_upAxis"); break; } } // remember origin (defined as exact middle of aabb) m_localOrigin = 0.5f * (m_localAabbMin + m_localAabbMax); }