public static void GetBoundsPointers(int broadPhaseIndex, ref Tree tree, out Vector3 *minPointer, out Vector3 *maxPointer)
{
var leaf = tree.Leaves[broadPhaseIndex];
var nodeChild = (&tree.NodesPointer[leaf.NodeIndex].A) + leaf.ChildIndex;
minPointer = &nodeChild->Min;
maxPointer = &nodeChild->Max;
}
private extern static unsafe PhyControllerCollisionFlag SDK_PhyController_Move(NativePointer self, Vector3 *disp, float minDist, float elapsedTime, PhyFilterData *filterData, PhyQueryFlag filterFlags);
public void GetActiveBoundsPointers(int index, out Vector3 *minPointer, out Vector3 *maxPointer)
{
GetBoundsPointers(index, ref ActiveTree, out minPointer, out maxPointer);
}
public unsafe extern static Matrix *v3dxMatrixAffineTransformation(Matrix *pOut, float Scaling, Vector3 *pRotationCenter, Quaternion *pRotation, Vector3 *pTranslation);
public unsafe extern static void v3dxQuaternionToAxisAngle(Quaternion *pQ, Vector3 *pAxis, float *pAngle);
public unsafe extern static int v3dxComputeBoundingSphere(Vector3 *pFirstPosition, UInt32 NumVertices, UInt32 dwStride, Vector3 *pCenter, float *pRadius);
public unsafe extern static Vector3 *v3dxVec3TransformNormalArray(Vector3 *pOut, UInt32 OutStride, Vector3 *pV, UInt32 VStride, Matrix *pM, UInt32 n);
public static Vector3 Max(Vector3 v1, Vector3 *v2)
{
return(new Vector3(Math.Max(v1._x, v2->_x), Math.Max(v1._y, v2->_y), Math.Max(v1._z, v2->_z)));
}
public void Add(Vector3 *v)
{
_x += v->_x; _y += v->_y; _z += v->_z;
}
public void Multiply(Vector3 *v)
{
_x *= v->_x; _y *= v->_y; _z *= v->_z;
}
public float Dot(Vector3 *v)
{
return((_x * v->_x) + (_y * v->_y) + (_z * v->_z));
}
public void Sub(Vector3 *v)
{
_x -= v->_x; _y -= v->_y; _z -= v->_z;
}
/// <summary>
/// Return ray hit distance or infinity if no hit. Requires raw data to be set. Optionally return hit normal and hit uv coordinates at intersect point.
/// </summary>
public float GetHitDistance(Urho.Ray ray, Vector3 *outNormal = null, Vector2 *outUV = null)
{
Runtime.ValidateRefCounted(this);
return(Geometry_GetHitDistance(handle, ref ray, outNormal, outUV));
}
internal static extern float Geometry_GetHitDistance(IntPtr handle, ref Urho.Ray ray, Vector3 *outNormal, Vector2 *outUV);
public unsafe extern static Matrix *v3dxMatrixTransformationOrigin(Matrix *pOut, Vector3 *pScaling, Quaternion *pRotation, Vector3 *pTranslation);
private static unsafe void SetTransformVectorQuaternionPatch(IntPtr instance, Vector3 *vector, Quaternion *quat)
{
if ((*(int *)&vector->x & int.MaxValue) >= 2139095040)
{
vector->x = 0f;
}
if ((*(int *)&vector->y & int.MaxValue) >= 2139095040)
{
vector->y = 0f;
}
if ((*(int *)&vector->z & int.MaxValue) >= 2139095040)
{
vector->z = 0f;
}
if ((*(int *)&quat->x & int.MaxValue) >= 2139095040)
{
quat->x = 0f;
}
if ((*(int *)&quat->y & int.MaxValue) >= 2139095040)
{
quat->y = 0f;
}
if ((*(int *)&quat->z & int.MaxValue) >= 2139095040)
{
quat->z = 0f;
}
if ((*(int *)&quat->w & int.MaxValue) >= 2139095040)
{
quat->w = 1f;
}
ourOriginalTransformTwinSetter(instance, vector, quat);
}
public unsafe extern static Matrix *v3dxMatrixLookAtLH(Matrix *pOut, Vector3 *pCamera, Vector3 *pAt, Vector3 *pUp);
private extern static unsafe void SDK_PhySceneDesc_GetGravity(NativePointer self, Vector3 *gravity);
public unsafe extern static int v3dxIntersectTri(Vector3 *p0, Vector3 *p1, Vector3 *p2, Vector3 *pRayPos, Vector3 *pRayDir, float *pU, float *pV, float *pDist);
private extern static unsafe vBOOL SDK_PhyScene_RaycastWithFilter(NativePointer self, Vector3 *origin, Vector3 *unitDir, float maxDistance, PhyQueryFilterData *queryFilterData, GamePlay.SceneGraph.VHitResult *hitResult);
public unsafe extern static int v3dxMatrixDecompose(Vector3 *pOutScale, Quaternion *pOutRotation, Vector3 *pOutTranslation, Matrix *pM);
private extern static unsafe vBOOL SDK_PhyScene_SweepWithFilter(NativePointer self, CPhyShape.NativePointer shape, Vector3 *position, Vector3 *unitDir, float maxDistance, PhyQueryFilterData *queryFilterData, GamePlay.SceneGraph.VHitResult *hitResult);
public unsafe extern static Vector3 *v3dxPlaneIntersectLine(Vector3 *pOut, Plane *pP, Vector3 *pV1, Vector3 *pV2);
private extern static unsafe vBOOL SDK_PhyScene_OverlapWithFilter(NativePointer self, CPhyShape.NativePointer shape, Vector3 *position, Quaternion *rotation, PhyQueryFilterData *queryFilterData, GamePlay.SceneGraph.VHitResult *hitResult);
private extern unsafe static void SDK_PhyBoxControllerDesc_SetExtent(NativePointer self, Vector3 *v);
////!!!!temp
//bool OBBToFrustumIntersect2( Frustum frustum, Box box )
////bool OBBToFrustumIntersect2( Frustum frustum, Vector3[] points )
//{
// //!!!!slowly
// var points = box.ToPoints();
// foreach( var plane in frustum.Planes )
// {
// bool allClipped = true;
// foreach( var p in points )
// {
// if( plane.GetSide( p ) == Plane.Side.Negative )
// {
// allClipped = false;
// break;
// }
// }
// if( allClipped )
// return false;
// }
// return true;
//}
//!!!!temp
//bool OBBToFrustumIntersect( Frustum frustum, Box box )
//{
// // Do a SAT test along each frustum axis.
// // A frustum consists of six planes. Note that as near and far planes are parallel, we could optimize
// // one iteration away.
// var planes = frustum.Planes;
// for( int i = 0; i < planes.Length; i++ )
// {
// var planeNormal = planes[ i ].Normal;
// //var planeDistance = planes[ i ].Distance;
// var planeDistance = -planes[ i ].Distance;
// // Find the negative and positive far points of the OBB to the current frustum plane.
// var x = Vector3.Dot( box.Axis[ 0 ], planeNormal ) >= 0.0f ? box.Extents[ 0 ] : -box.Extents[ 0 ];
// var y = Vector3.Dot( box.Axis[ 1 ], planeNormal ) >= 0.0f ? box.Extents[ 1 ] : -box.Extents[ 1 ];
// var z = Vector3.Dot( box.Axis[ 2 ], planeNormal ) >= 0.0f ? box.Extents[ 2 ] : -box.Extents[ 2 ];
// // There are eight half-diagonal vectors on an OBB. (A half-diagonal is a vector from OBB center to one of its
// // corner vertices). Compute the half-diagonal vector that points most in the same direction than the plane normal.
// var diag = x * box.Axis[ 0 ] + y * box.Axis[ 1 ] + z * box.Axis[ 2 ];
// // nPoint is now the corner point of the OBB that lies "the most" inside the frustum,
// // its projection on the plane normal extends the most to the negative direction of that normal.
// var nPoint = box.Center - diag;
// // const float3 pPoint = obb.center + diag;
// if( Vector3.Dot( nPoint, planeNormal ) + planeDistance >= 0.0f )
// return false; // OBB outside frustum.
// // If we would like to check whether the OBB is fully inside the frustum, need to compute
// // Dot(pPoint, frustum.planes.normal) + frustum.planes.d. If it's < 0 for all planes, OBB is totally
// // inside the frustum and doesn't intersect any of the frustum planes.
// }
// return true; // OBB inside the frustum or part of the OBB intersects the frustum.
//}
//!!!!temp
//public static bool GetOrientedBoxIntersection( Frustum frustum, Box box )
//{
// //ref Bounds box, ref Vector3 right, ref Vector3 up, ref Vector3 forward
// var center = box.Center;
// var extents = box.Extents;
// //!!!!
// var right = box.Axis * Vector3.XAxis;
// var up = box.Axis * Vector3.YAxis;
// var forward = box.Axis * Vector3.ZAxis;
// //var forward = box.Axis * Vector3.XAxis;
// //var up = box.Axis * Vector3.ZAxis;
// //var right = box.Axis * Vector3.YAxis;
// var planes = frustum.Planes;
// for( int i = 0; i < planes.Length; i++ )
// {
// var planeNormal = planes[ i ].Normal;
// //!!!!
// var planeDistance = planes[ i ].Distance;
// //var planeDistance = -planes[ i ].Distance;
// var r =
// extents.X * Math.Abs( Vector3.Dot( planeNormal, right ) ) +
// extents.Y * Math.Abs( Vector3.Dot( planeNormal, up ) ) +
// extents.Z * Math.Abs( Vector3.Dot( planeNormal, forward ) );
// var s = planeNormal.X * center.X + planeNormal.Y * center.Y + planeNormal.Z * center.Z;
// if( s + r < -planeDistance )
// return false;
// }
// return true;
//}
///// <summary>
///// Fast culling. Not cull everything outside the frustum.
///// </summary>
///// <param name="bounds"></param>
///// <returns></returns>
//public bool IntersectsFast( ref Bounds bounds )
//{
// if( projection == ProjectionType.Perspective )
// {
// Vector3 center;
// bounds.GetCenter( out center );
// //Vec3 center = bounds.GetCenter();
// Vector3 extents;
// Vector3.Subtract( ref bounds.Maximum, ref center, out extents );
// //Vec3 extents = bounds.maximum - center;
// //Mat3 transposedAxis;
// //_axis.GetTranspose( out transposedAxis );
// //Mat3 transposedAxis = axis.GetTranspose();
// Vector3 localOrigin;
// Vector3 diff;
// Vector3.Subtract( ref center, ref origin, out diff );
// Matrix3.Multiply( ref diff, ref _axisTransposed, out localOrigin );
// //Vec3 localOrigin = ( center - origin ) * transposedAxis;
// return !CullLocalBox( localOrigin, extents, ref _axisTransposed );
// }
// else
// {
// Box box;
// GetOrthoBox( out box );
// return box.Intersects( ref bounds );
// }
//}
///// <summary>
///// Fast culling. Not cull everything outside the frustum.
///// </summary>
///// <param name="bounds"></param>
///// <returns></returns>
//public bool IntersectsFast( Bounds bounds )
//{
// return IntersectsFast( ref bounds );
//}
//!!!!Bugged.
///// <summary>
///// Fast culling. Not cull everything outside the frustum.
///// </summary>
///// <param name="box"></param>
///// <returns></returns>
//public bool IntersectsFast( ref Box box )
//{
// if( projection == ProjectionType.Perspective )
// {
// //Mat3 transposedAxis;
// //_axis.GetTranspose( out transposedAxis );
// //Mat3 transposedAxis = axis.GetTranspose();
// Vector3 localOrigin;
// Vector3 diff;
// Vector3.Subtract( ref box.Center, ref origin, out diff );
// Matrix3.Multiply( ref diff, ref _axisTransposed, out localOrigin );
// //Vec3 localOrigin = ( box.center - origin ) * transposedAxis;
// Matrix3 localAxis;
// Matrix3.Multiply( ref box.Axis, ref _axisTransposed, out localAxis );
// //Mat3 localAxis = box.axis * transposedAxis;
// return !CullLocalBox( localOrigin, box.Extents, ref localAxis );
// }
// else
// {
// Box frustumBox;
// GetOrthoBox( out frustumBox );
// return frustumBox.Intersects( ref box );
// }
//}
///// <summary>
///// Fast culling. Not cull everything outside the frustum.
///// </summary>
///// <param name="box"></param>
///// <returns></returns>
//public bool IntersectsFast( Box box )
//{
// return IntersectsFast( ref box );
//}
//bool CullLocalBox( Vector3 localOrigin, Vector3 extents, ref Matrix3 localAxis )
//{
// double d1, d2;
// Vector3 testOrigin;
// Matrix3 testAxis;
// // near plane
// d1 = nearDistance - localOrigin.X;
// d2 = Math.Abs( extents.X * localAxis.Item0.X ) +
// Math.Abs( extents.Y * localAxis.Item1.X ) +
// Math.Abs( extents.Z * localAxis.Item2.X );
// if( d1 - d2 > 0.0f )
// return true;
// // far plane
// d1 = localOrigin.X - farDistance;
// if( d1 - d2 > 0.0f )
// return true;
// testOrigin = localOrigin;
// testAxis = localAxis;
// if( testOrigin.Y < 0.0f )
// {
// testOrigin.Y = -testOrigin.Y;
// testAxis[ 0, 1 ] = -testAxis.Item0.Y;
// testAxis[ 1, 1 ] = -testAxis.Item1.Y;
// testAxis[ 2, 1 ] = -testAxis.Item2.Y;
// }
// // test left/right planes
// d1 = farDistance * testOrigin.Y - halfWidth * testOrigin.X;
// d2 = Math.Abs( extents.X * ( farDistance * testAxis.Item0.Y - halfWidth * testAxis.Item0.X ) ) +
// Math.Abs( extents.Y * ( farDistance * testAxis.Item1.Y - halfWidth * testAxis.Item1.X ) ) +
// Math.Abs( extents.Z * ( farDistance * testAxis.Item2.Y - halfWidth * testAxis.Item2.X ) );
// if( d1 - d2 > 0.0f )
// return true;
// if( testOrigin.Z < 0.0f )
// {
// testOrigin.Z = -testOrigin.Z;
// testAxis[ 0, 2 ] = -testAxis.Item0.Z;
// testAxis[ 1, 2 ] = -testAxis.Item1.Z;
// testAxis[ 2, 2 ] = -testAxis.Item2.Z;
// }
// // test up/down planes
// d1 = farDistance * testOrigin.Z - halfHeight * testOrigin.X;
// d2 = Math.Abs( extents.X * ( farDistance * testAxis.Item0.Z - halfHeight * testAxis.Item0.X ) ) +
// Math.Abs( extents.Y * ( farDistance * testAxis.Item1.Z - halfHeight * testAxis.Item1.X ) ) +
// Math.Abs( extents.Z * ( farDistance * testAxis.Item2.Z - halfHeight * testAxis.Item2.X ) );
// if( d1 - d2 > 0.0f )
// return true;
// return false;
//}
///// <summary>
///// Exact intersection test.
///// </summary>
///// <param name="bounds"></param>
///// <returns></returns>
//public bool Intersects( ref Bounds bounds )
//{
// if( projection == ProjectionType.Perspective )
// {
// unsafe
// {
// Vector3* indexPoints = stackalloc Vector3[ 8 ];
// Vector3* cornerVecs = stackalloc Vector3[ 4 ];
// Vector3 center;
// bounds.GetCenter( out center );
// //Vec3 center = bounds.GetCenter();
// Vector3 extents;
// Vector3.Subtract( ref bounds.Maximum, ref center, out extents );
// //Vec3 extents = bounds.Maximum - center;
// //Mat3 transposedAxis;
// //_axis.GetTranspose( out transposedAxis );
// //Mat3 transposedAxis = axis.GetTranspose();
// Vector3 localOrigin;
// Vector3 diff;
// Vector3.Subtract( ref center, ref origin, out diff );
// Matrix3.Multiply( ref diff, ref _axisTransposed, out localOrigin );
// //Vec3 localOrigin = ( center - origin ) * transposedAxis;
// if( CullLocalBox( localOrigin, extents, ref _axisTransposed ) )
// return false;
// ToIndexPointsAndCornerVecs( indexPoints, cornerVecs );
// if( BoundsCullLocalFrustum( ref bounds, this, indexPoints, cornerVecs ) )
// return false;
// Vector3 p;
// p = indexPoints[ 2 ]; indexPoints[ 2 ] = indexPoints[ 3 ]; indexPoints[ 3 ] = p;
// p = indexPoints[ 6 ]; indexPoints[ 6 ] = indexPoints[ 7 ]; indexPoints[ 7 ] = p;
// if( LocalFrustumIntersectsBounds( indexPoints, ref bounds ) )
// return true;
// Box box;
// box.Center = localOrigin;
// box.Extents = extents;
// box.Axis = _axisTransposed;
// box.ToPoints( indexPoints );
// //new Box( localOrigin, extents, transposedAxis ).ToPoints( indexPoints );
// if( LocalFrustumIntersectsFrustum( indexPoints, true ) )
// return true;
// }
// return false;
// }
// else
// {
// Box box;
// GetOrthoBox( out box );
// return box.Intersects( ref bounds );
// }
//}
///// <summary>
///// Exact intersection test.
///// </summary>
///// <param name="bounds"></param>
///// <returns></returns>
//public bool Intersects( Bounds bounds )
//{
// return Intersects( ref bounds );
//}
unsafe void ToIndexPointsAndCornerVecs(Vector3 *indexPoints, Vector3 *cornerVecs)
{
Vector3 scaled0, scaled1, scaled2;
scaled0.X = origin.X + _axis.Item0.X * nearDistance;
scaled0.Y = origin.Y + _axis.Item0.Y * nearDistance;
scaled0.Z = origin.Z + _axis.Item0.Z * nearDistance;
//scaled0 = origin + axis.mat0 * nearDistance;
Vector3.Multiply(ref _axis.Item1, halfWidth * nearDistance * invFarDistance, out scaled1);
//scaled1 = axis.mat1 * ( halfWidth * nearDistance * invFarDistance );
Vector3.Multiply(ref _axis.Item2, halfHeight * nearDistance * invFarDistance, out scaled2);
//scaled2 = axis.mat2 * ( halfHeight * nearDistance * invFarDistance );
//Mat3 scaled = new Mat3(
// origin + axis.mat0 * nearDistance,
// axis.mat1 * ( halfWidth * nearDistance * invFarDistance ),
// axis.mat2 * ( halfHeight * nearDistance * invFarDistance ) );
indexPoints[0] = new Vector3(
scaled0.X - scaled1.X - scaled2.X,
scaled0.Y - scaled1.Y - scaled2.Y,
scaled0.Z - scaled1.Z - scaled2.Z);
//indexPoints[ 0 ] = scaled0 - scaled1 - scaled2;
indexPoints[1] = new Vector3(
scaled0.X - scaled1.X + scaled2.X,
scaled0.Y - scaled1.Y + scaled2.Y,
scaled0.Z - scaled1.Z + scaled2.Z);
//indexPoints[ 1 ] = scaled0 - scaled1 + scaled2;
indexPoints[2] = new Vector3(
scaled0.X + scaled1.X - scaled2.X,
scaled0.Y + scaled1.Y - scaled2.Y,
scaled0.Z + scaled1.Z - scaled2.Z);
//indexPoints[ 2 ] = scaled0 + scaled1 - scaled2;
indexPoints[3] = new Vector3(
scaled0.X + scaled1.X + scaled2.X,
scaled0.Y + scaled1.Y + scaled2.Y,
scaled0.Z + scaled1.Z + scaled2.Z);
//indexPoints[ 3 ] = scaled0 + scaled1 + scaled2;
//indexPoints[ 0 ] = scaled0 - scaled1;
//indexPoints[ 2 ] = scaled0 + scaled1;
//indexPoints[ 1 ] = indexPoints[ 0 ] + scaled2;
//indexPoints[ 3 ] = indexPoints[ 2 ] + scaled2;
//indexPoints[ 0 ] -= scaled2;
//indexPoints[ 2 ] -= scaled2;
Vector3.Multiply(ref _axis.Item0, farDistance, out scaled0);
//scaled0 = axis.mat0 * farDistance;
Vector3.Multiply(ref _axis.Item1, halfWidth, out scaled1);
//scaled1 = axis.mat1 * halfWidth;
Vector3.Multiply(ref _axis.Item2, halfHeight, out scaled2);
//scaled2 = axis.mat2 * halfHeight;
cornerVecs[0] = new Vector3(
scaled0.X - scaled1.X - scaled2.X,
scaled0.Y - scaled1.Y - scaled2.Y,
scaled0.Z - scaled1.Z - scaled2.Z);
//cornerVecs[ 0 ] = scaled0 - scaled1 - scaled2;
cornerVecs[2] = new Vector3(
scaled0.X + scaled1.X - scaled2.X,
scaled0.Y + scaled1.Y - scaled2.Y,
scaled0.Z + scaled1.Z - scaled2.Z);
//cornerVecs[ 2 ] = scaled0 + scaled1 - scaled2;
cornerVecs[1] = new Vector3(
scaled0.X - scaled1.X + scaled2.X,
scaled0.Y - scaled1.Y + scaled2.Y,
scaled0.Z - scaled1.Z + scaled2.Z);
//cornerVecs[ 1 ] = scaled0 - scaled1 + scaled2;
cornerVecs[3] = new Vector3(
scaled0.X + scaled1.X + scaled2.X,
scaled0.Y + scaled1.Y + scaled2.Y,
scaled0.Z + scaled1.Z + scaled2.Z);
//cornerVecs[ 3 ] = scaled0 + scaled1 + scaled2;
//cornerVecs[ 0 ] = scaled0 - scaled1;
//cornerVecs[ 2 ] = scaled0 + scaled1;
//cornerVecs[ 1 ] = cornerVecs[ 0 ] + scaled2;
//cornerVecs[ 3 ] = cornerVecs[ 2 ] + scaled2;
//cornerVecs[ 0 ] -= scaled2;
//cornerVecs[ 2 ] -= scaled2;
Vector3.Add(ref cornerVecs[0], ref origin, out indexPoints[4]);
//indexPoints[ 4 ] = cornerVecs[ 0 ] + origin;
Vector3.Add(ref cornerVecs[1], ref origin, out indexPoints[5]);
//indexPoints[ 5 ] = cornerVecs[ 1 ] + origin;
Vector3.Add(ref cornerVecs[2], ref origin, out indexPoints[6]);
//indexPoints[ 6 ] = cornerVecs[ 2 ] + origin;
Vector3.Add(ref cornerVecs[3], ref origin, out indexPoints[7]);
//indexPoints[ 7 ] = cornerVecs[ 3 ] + origin;
}
private extern static unsafe void SDK_PhyController_SetFootPosition(NativePointer self, Vector3 *position);
static unsafe bool BoundsCullLocalFrustum(ref Bounds bounds, Frustum localFrustum, Vector3 *indexPoints, Vector3 *cornerVecs)
{
int index;
double dx, dy, dz;
dy = -localFrustum._axis.Item1.X;
dz = -localFrustum._axis.Item2.X;
index = (FLOATSIGNBITSET(dy) << 1) | FLOATSIGNBITSET(dz);
dx = -cornerVecs[index].X;
index |= (FLOATSIGNBITSET(dx) << 2);
if (indexPoints[index].X < bounds.Minimum.X)
{
return(true);
}
dy = localFrustum._axis.Item1.X;
dz = localFrustum._axis.Item2.X;
index = (FLOATSIGNBITSET(dy) << 1) | FLOATSIGNBITSET(dz);
dx = cornerVecs[index].X;
index |= (FLOATSIGNBITSET(dx) << 2);
if (indexPoints[index].X > bounds.Maximum.X)
{
return(true);
}
dy = -localFrustum._axis.Item1.Y;
dz = -localFrustum._axis.Item2.Y;
index = (FLOATSIGNBITSET(dy) << 1) | FLOATSIGNBITSET(dz);
dx = -cornerVecs[index].Y;
index |= (FLOATSIGNBITSET(dx) << 2);
if (indexPoints[index].Y < bounds.Minimum.Y)
{
return(true);
}
dy = localFrustum._axis.Item1.Y;
dz = localFrustum._axis.Item2.Y;
index = (FLOATSIGNBITSET(dy) << 1) | FLOATSIGNBITSET(dz);
dx = cornerVecs[index].Y;
index |= (FLOATSIGNBITSET(dx) << 2);
if (indexPoints[index].Y > bounds.Maximum.Y)
{
return(true);
}
dy = -localFrustum._axis.Item1.Z;
dz = -localFrustum._axis.Item2.Z;
index = (FLOATSIGNBITSET(dy) << 1) | FLOATSIGNBITSET(dz);
dx = -cornerVecs[index].Z;
index |= (FLOATSIGNBITSET(dx) << 2);
if (indexPoints[index].Z < bounds.Minimum.Z)
{
return(true);
}
dy = localFrustum._axis.Item1.Z;
dz = localFrustum._axis.Item2.Z;
index = (FLOATSIGNBITSET(dy) << 1) | FLOATSIGNBITSET(dz);
dx = cornerVecs[index].Z;
index |= (FLOATSIGNBITSET(dx) << 2);
if (indexPoints[index].Z > bounds.Maximum.Z)
{
return(true);
}
return(false);
}
public void GetStaticBoundsPointers(int index, out Vector3 *minPointer, out Vector3 *maxPointer)
{
GetBoundsPointers(index, ref StaticTree, out minPointer, out maxPointer);
}
private void RandomizeObject(SuperObject *superObject)
{
Perso *perso = (Perso *)superObject->engineObjectPtr;
Brain *brain = perso->brain;
if (brain == null)
{
return;
}
DsgMem *dsgMem = brain->mind->dsgMem;
if (dsgMem == null)
{
return;
}
DsgVar *dsgVars = *dsgMem->dsgVar;
for (int i = 0; i < dsgVars->dsgVarInfosLength; i++)
{
if (random.NextDouble() > randomizeChance)
{
continue;
}
DsgVarInfo info = dsgVars->dsgVarInfos[i];
DsgVarType type = info.type;
byte *buffer = dsgMem->memoryBufferCurrent;
int ptr = (int)buffer + info.offsetInBuffer;
switch (type)
{
case DsgVarType.Boolean:
*(bool *)ptr = random.Next(0, 2) == 0;
break;
case DsgVarType.Byte:
*(sbyte *)ptr = (sbyte)random.Next(-127, 128);
break;
case DsgVarType.UByte:
*(byte *)ptr = (byte)random.Next(0, 256);
break;
case DsgVarType.Short:
*(short *)ptr = (short)random.Next();
break;
case DsgVarType.UShort:
*(ushort *)ptr = (ushort)random.Next();
break;
case DsgVarType.Int:
*(int *)ptr = random.Next();
break;
case DsgVarType.UInt:
*(uint *)ptr = (uint)random.Next();
break;
case DsgVarType.Float:
*(float *)ptr += random.RandomFloat(-10f, 10f);
break;
case DsgVarType.Vector:
Vector3 *vector = (Vector3 *)ptr;
vector->X += random.RandomFloat(-10f, 10f);
vector->Y += random.RandomFloat(-10f, 10f);
vector->Z += random.RandomFloat(-10f, 10f);
break;
case DsgVarType.IntegerArray:
int *array = brain->mind->GetDsgVar <int>(i, buffer, out byte size);
for (int j = 0; j < size; j++)
{
array[j] = random.Next();
}
break;
}
}
}