public override void CalcBounds()
{
bounds.Center = Vector3.zero;
bounds.Size = Size;
var minY = -Size.y / 2;
var maxY = Size.y / 2;
var minX = float.MaxValue;
var maxX = float.MinValue;
var minZ = float.MaxValue;
var maxZ = float.MinValue;
var points = new Vector3[]
{
new Vector3(Size.x / 2, 0, Size.z / 2),
new Vector3(-Size.x / 2, 0, -Size.z / 2),
new Vector3(-Size.x / 2, 0, Size.z / 2),
new Vector3(Size.x / 2, 0, -Size.z / 2)
};
for (int i = 0; i < points.Length; i++)
{
points[i] = Quaternion * points[i];
minX = Mathf.Min(minX, points[i].x);
maxX = Mathf.Max(maxX, points[i].x);
minZ = Mathf.Min(minZ, points[i].z);
maxZ = Mathf.Max(maxZ, points[i].z);
}
bounds.Min = new Vector3(minX, minY, minZ);
bounds.Max = new Vector3(maxX, maxY, maxZ);
bounds.Center = Position;
}
public void Validate()
{
if (surfaceDefinition == null)
{
surfaceDefinition = new ChiselSurfaceDefinition();
}
stepHeight = Mathf.Max(kMinStepHeight, stepHeight);
innerDiameter = Mathf.Min(outerDiameter - kMinStairsDepth, innerDiameter);
innerDiameter = Mathf.Max(kMinInnerDiameter, innerDiameter);
outerDiameter = Mathf.Max(innerDiameter + kMinStairsDepth, outerDiameter);
outerDiameter = Mathf.Max(kMinOuterDiameter, outerDiameter);
height = Mathf.Max(stepHeight, Mathf.Abs(height)) * (height < 0 ? -1 : 1);
treadHeight = Mathf.Max(0, treadHeight);
nosingDepth = Mathf.Max(0, nosingDepth);
nosingWidth = Mathf.Max(0, nosingWidth);
riserDepth = Mathf.Max(kMinRiserDepth, riserDepth);
rotation = Mathf.Max(kMinRotation, Mathf.Abs(rotation)) * (rotation < 0 ? -1 : 1);
innerSegments = Mathf.Max(kMinSegments, innerSegments);
outerSegments = Mathf.Max(kMinSegments, outerSegments);
surfaceDefinition.EnsureSize(8);
}
public void Validate()
{
tubeWidth = Mathf.Max(tubeWidth, kMinTubeDiameter);
tubeHeight = Mathf.Max(tubeHeight, kMinTubeDiameter);
outerDiameter = Mathf.Max(outerDiameter, tubeWidth * 2);
horizontalSegments = Mathf.Max(horizontalSegments, 3);
verticalSegments = Mathf.Max(verticalSegments, 3);
totalAngle = Mathf.Clamp(totalAngle, 1, 360); // TODO: constants
if (surfaceAssets == null ||
surfaceAssets.Length != 6)
{
var defaultRenderMaterial = CSGMaterialManager.DefaultWallMaterial;
var defaultPhysicsMaterial = CSGMaterialManager.DefaultPhysicsMaterial;
surfaceAssets = new CSGSurfaceAsset[6]
{
CSGSurfaceAsset.CreateInstance(defaultRenderMaterial, defaultPhysicsMaterial),
CSGSurfaceAsset.CreateInstance(defaultRenderMaterial, defaultPhysicsMaterial),
CSGSurfaceAsset.CreateInstance(defaultRenderMaterial, defaultPhysicsMaterial),
CSGSurfaceAsset.CreateInstance(defaultRenderMaterial, defaultPhysicsMaterial),
CSGSurfaceAsset.CreateInstance(defaultRenderMaterial, defaultPhysicsMaterial),
CSGSurfaceAsset.CreateInstance(defaultRenderMaterial, defaultPhysicsMaterial)
};
}
if (surfaceDescriptions == null ||
surfaceDescriptions.Length != 6)
{
// TODO: make this independent on plane position somehow
var surfaceFlags = CSGDefaults.SurfaceFlags;
surfaceDescriptions = new SurfaceDescription[6]
{
new SurfaceDescription {
UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0
},
new SurfaceDescription {
UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0
},
new SurfaceDescription {
UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0
},
new SurfaceDescription {
UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0
},
new SurfaceDescription {
UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0
},
new SurfaceDescription {
UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0
}
};
}
}
public void Validate()
{
if (surfaceDefinition == null)
{
surfaceDefinition = new ChiselSurfaceDefinition();
}
if (surfaceDefinition.EnsureSize((int)SurfaceSides.TotalSides))
{
var defaultRenderMaterial = ChiselMaterialManager.DefaultWallMaterial;
var defaultPhysicsMaterial = ChiselMaterialManager.DefaultPhysicsMaterial;
surfaceDefinition.surfaces[(int)SurfaceSides.Top].brushMaterial = ChiselBrushMaterial.CreateInstance(ChiselMaterialManager.DefaultFloorMaterial, defaultPhysicsMaterial);
surfaceDefinition.surfaces[(int)SurfaceSides.Bottom].brushMaterial = ChiselBrushMaterial.CreateInstance(ChiselMaterialManager.DefaultFloorMaterial, defaultPhysicsMaterial);
surfaceDefinition.surfaces[(int)SurfaceSides.Left].brushMaterial = ChiselBrushMaterial.CreateInstance(ChiselMaterialManager.DefaultWallMaterial, defaultPhysicsMaterial);
surfaceDefinition.surfaces[(int)SurfaceSides.Right].brushMaterial = ChiselBrushMaterial.CreateInstance(ChiselMaterialManager.DefaultWallMaterial, defaultPhysicsMaterial);
surfaceDefinition.surfaces[(int)SurfaceSides.Front].brushMaterial = ChiselBrushMaterial.CreateInstance(ChiselMaterialManager.DefaultWallMaterial, defaultPhysicsMaterial);
surfaceDefinition.surfaces[(int)SurfaceSides.Back].brushMaterial = ChiselBrushMaterial.CreateInstance(ChiselMaterialManager.DefaultWallMaterial, defaultPhysicsMaterial);
surfaceDefinition.surfaces[(int)SurfaceSides.Tread].brushMaterial = ChiselBrushMaterial.CreateInstance(ChiselMaterialManager.DefaultTreadMaterial, defaultPhysicsMaterial);
surfaceDefinition.surfaces[(int)SurfaceSides.Step].brushMaterial = ChiselBrushMaterial.CreateInstance(ChiselMaterialManager.DefaultStepMaterial, defaultPhysicsMaterial);
for (int i = 0; i < surfaceDefinition.surfaces.Length; i++)
{
if (surfaceDefinition.surfaces[i].brushMaterial == null)
{
surfaceDefinition.surfaces[i].brushMaterial = ChiselBrushMaterial.CreateInstance(defaultRenderMaterial, defaultPhysicsMaterial);
}
}
}
stepHeight = Mathf.Max(kMinStepHeight, stepHeight);
stepDepth = Mathf.Clamp(stepDepth, kMinStepDepth, absDepth);
treadHeight = Mathf.Max(0, treadHeight);
nosingDepth = Mathf.Max(0, nosingDepth);
nosingWidth = Mathf.Max(0, nosingWidth);
width = Mathf.Max(kMinWidth, absWidth) * (width < 0 ? -1 : 1);
depth = Mathf.Max(stepDepth, absDepth) * (depth < 0 ? -1 : 1);
riserDepth = Mathf.Max(kMinRiserDepth, riserDepth);
sideDepth = Mathf.Max(0, sideDepth);
sideWidth = Mathf.Max(kMinSideWidth, sideWidth);
sideHeight = Mathf.Max(0, sideHeight);
var realHeight = Mathf.Max(stepHeight, absHeight);
var maxPlateauHeight = realHeight - stepHeight;
plateauHeight = Mathf.Clamp(plateauHeight, 0, maxPlateauHeight);
var totalSteps = Mathf.Max(1, Mathf.FloorToInt((realHeight - plateauHeight + kStepSmudgeValue) / stepHeight));
var totalStepHeight = totalSteps * stepHeight;
plateauHeight = Mathf.Max(0, realHeight - totalStepHeight);
stepDepth = Mathf.Clamp(stepDepth, kMinStepDepth, absDepth / totalSteps);
}
public void Validate()
{
diameterXYZ.x = Mathf.Max(kMinDiameter, Mathf.Abs(diameterXYZ.x));
diameterXYZ.y = Mathf.Max(0, Mathf.Abs(diameterXYZ.y)) * (diameterXYZ.y < 0 ? -1 : 1);
diameterXYZ.z = Mathf.Max(kMinDiameter, Mathf.Abs(diameterXYZ.z));
horizontalSegments = Mathf.Max(horizontalSegments, 3);
verticalSegments = Mathf.Max(verticalSegments, 1);
if (surfaceAssets == null ||
surfaceAssets.Length != 6)
{
var defaultRenderMaterial = CSGMaterialManager.DefaultWallMaterial;
var defaultPhysicsMaterial = CSGMaterialManager.DefaultPhysicsMaterial;
surfaceAssets = new CSGSurfaceAsset[6]
{
CSGSurfaceAsset.CreateInstance(defaultRenderMaterial, defaultPhysicsMaterial),
CSGSurfaceAsset.CreateInstance(defaultRenderMaterial, defaultPhysicsMaterial),
CSGSurfaceAsset.CreateInstance(defaultRenderMaterial, defaultPhysicsMaterial),
CSGSurfaceAsset.CreateInstance(defaultRenderMaterial, defaultPhysicsMaterial),
CSGSurfaceAsset.CreateInstance(defaultRenderMaterial, defaultPhysicsMaterial),
CSGSurfaceAsset.CreateInstance(defaultRenderMaterial, defaultPhysicsMaterial)
};
}
if (surfaceDescriptions == null ||
surfaceDescriptions.Length != 6)
{
// TODO: make this independent on plane position somehow
var surfaceFlags = CSGDefaults.SurfaceFlags;
surfaceDescriptions = new SurfaceDescription[6]
{
new SurfaceDescription {
UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0
},
new SurfaceDescription {
UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0
},
new SurfaceDescription {
UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0
},
new SurfaceDescription {
UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0
},
new SurfaceDescription {
UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0
},
new SurfaceDescription {
UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0
}
};
}
}
public void Validate()
{
stepHeight = Mathf.Max(kMinStepHeight, stepHeight);
innerDiameter = Mathf.Min(outerDiameter - kMinStairsDepth, innerDiameter);
innerDiameter = Mathf.Max(kMinInnerDiameter, innerDiameter);
outerDiameter = Mathf.Max(innerDiameter + kMinStairsDepth, outerDiameter);
outerDiameter = Mathf.Max(kMinOuterDiameter, outerDiameter);
height = Mathf.Max(stepHeight, Mathf.Abs(height)) * (height < 0 ? -1 : 1);
treadHeight = Mathf.Max(0, treadHeight);
nosingDepth = Mathf.Max(0, nosingDepth);
nosingWidth = Mathf.Max(0, nosingWidth);
riserDepth = Mathf.Max(kMinRiserDepth, riserDepth);
rotation = Mathf.Max(kMinRotation, Mathf.Abs(rotation)) * (rotation < 0 ? -1 : 1);
innerSegments = Mathf.Max(kMinSegments, innerSegments);
outerSegments = Mathf.Max(kMinSegments, outerSegments);
if (surfaceAssets == null ||
surfaceAssets.Length != 6)
{
var defaultRenderMaterial = CSGMaterialManager.DefaultWallMaterial;
var defaultPhysicsMaterial = CSGMaterialManager.DefaultPhysicsMaterial;
surfaceAssets = new CSGSurfaceAsset[6];
for (int i = 0; i < 6; i++) // Note: sides share same material
{
surfaceAssets[i] = CSGSurfaceAsset.CreateInstance(defaultRenderMaterial, defaultPhysicsMaterial);
}
}
if (surfaceDescriptions == null ||
surfaceDescriptions.Length != 6)
{
var surfaceFlags = CSGDefaults.SurfaceFlags;
surfaceDescriptions = new SurfaceDescription[6];
for (int i = 0; i < 6; i++)
{
surfaceDescriptions[i] = new SurfaceDescription {
surfaceFlags = surfaceFlags, UV0 = UVMatrix.centered, smoothingGroup = bottomSmoothingGroup
};
}
}
else
{
for (int i = 0; i < 6; i++)
{
surfaceDescriptions[i].smoothingGroup = bottomSmoothingGroup;
}
}
}
public void Validate()
{
curveSegments = Mathf.Max(curveSegments, 2);
revolveSegments = Mathf.Max(revolveSegments, 1);
totalAngle = Mathf.Clamp(totalAngle, 1, 360); // TODO: constants
if (surfaceAssets == null ||
surfaceAssets.Length != 6)
{
var defaultRenderMaterial = CSGMaterialManager.DefaultWallMaterial;
var defaultPhysicsMaterial = CSGMaterialManager.DefaultPhysicsMaterial;
surfaceAssets = new CSGSurfaceAsset[6]
{
CSGSurfaceAsset.CreateInstance(defaultRenderMaterial, defaultPhysicsMaterial),
CSGSurfaceAsset.CreateInstance(defaultRenderMaterial, defaultPhysicsMaterial),
CSGSurfaceAsset.CreateInstance(defaultRenderMaterial, defaultPhysicsMaterial),
CSGSurfaceAsset.CreateInstance(defaultRenderMaterial, defaultPhysicsMaterial),
CSGSurfaceAsset.CreateInstance(defaultRenderMaterial, defaultPhysicsMaterial),
CSGSurfaceAsset.CreateInstance(defaultRenderMaterial, defaultPhysicsMaterial)
};
}
if (surfaceDescriptions == null ||
surfaceDescriptions.Length != 6)
{
// TODO: make this independent on plane position somehow
var surfaceFlags = CSGDefaults.SurfaceFlags;
surfaceDescriptions = new SurfaceDescription[6]
{
new SurfaceDescription {
UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0
},
new SurfaceDescription {
UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0
},
new SurfaceDescription {
UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0
},
new SurfaceDescription {
UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0
},
new SurfaceDescription {
UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0
},
new SurfaceDescription {
UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0
}
};
}
}
public void Validate()
{
if (surfaceDefinition == null)
{
surfaceDefinition = new ChiselSurfaceDefinition();
}
curveSegments = Mathf.Max(curveSegments, 2);
revolveSegments = Mathf.Max(revolveSegments, 1);
totalAngle = Mathf.Clamp(totalAngle, 1, 360); // TODO: constants
surfaceDefinition.EnsureSize(6);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="crowdAgentConfig">
/// The default agent configuration for all agents in the group.
/// </param>
/// <param name="maxPathSize">The default maximum path size. [Limit: >= 1]</param>
/// <param name="maxStraightPathSize">
/// The default maximum straight path size. [Limit: >= 1]
/// </param>
/// <param name="maxPoolCorridors">
/// The maximum number of corridors to allowed in the corridor pool. [Limit: >= 0]
/// </param>
/// <param name="maxPoolPaths">
/// The maximum number of paths to allow in the path pool. [Limit: >= 0]
/// </param>
public NavAgentGroup(CrowdAgentParams crowdAgentConfig
, int maxPathSize, int maxStraightPathSize, int maxPoolCorridors, int maxPoolPaths)
{
mMaxStraightPathSize = Mathf.Max(1, maxStraightPathSize);
mMaxPathSize = Mathf.Max(1, maxPathSize);
this.crowdAgentConfig = crowdAgentConfig;
this.pathBuffer = new uint[maxPathSize];
mMaxCorridors = Mathf.Max(0, maxPoolCorridors);
mCorridors = new Stack <PathCorridor>(mMaxCorridors);
mMaxPaths = Mathf.Max(0, maxPoolPaths);
mPaths = new Stack <NavPath>(mMaxPaths);
}
public static float Clamp(float x, float limit1, float limit2)
{
float max = Mathf.Max(limit1, limit2);
float min = Mathf.Min(limit1, limit2);
if (x < min)
{
return(min);
}
if (x > max)
{
return(max);
}
return(x);
}
public void Validate()
{
if (surfaceDefinition == null)
{
surfaceDefinition = new ChiselSurfaceDefinition();
}
diameterXYZ.x = Mathf.Max(kMinDiameter, Mathf.Abs(diameterXYZ.x));
diameterXYZ.y = Mathf.Max(0, Mathf.Abs(diameterXYZ.y)) * (diameterXYZ.y < 0 ? -1 : 1);
diameterXYZ.z = Mathf.Max(kMinDiameter, Mathf.Abs(diameterXYZ.z));
horizontalSegments = Mathf.Max(horizontalSegments, 3);
verticalSegments = Mathf.Max(verticalSegments, 1);
surfaceDefinition.EnsureSize(6);
}
private void PositionalCorrection(XContact contact)
{
var a = contact.src;
var b = contact.dst;
var tm = a.rigidbody.InverseMass + b.rigidbody.InverseMass;
if (tm == 0)
{
return;
}
float percent = 0.2f;
float slop = 0.01f;
Vector3 correction = Mathf.Max(contact.penetration - slop, 0) / tm * percent * contact.normal;
a.Position = a.rigidbody.position -= a.rigidbody.InverseMass * correction;
b.Position = b.rigidbody.position += b.rigidbody.InverseMass * correction;
}
// TODO: remove all stairs specific parameters
static void GenerateTopRamp(CSGBrushSubMesh[] subMeshes, int startIndex, int stepCount, Vector3 min, Vector3 max, Vector3 extrusion, float sideHeight, float extraDepth, float maxDepth, StairsRiserType riserType, CSGLinearStairsDefinition definition, CSGSurfaceAsset[] surfaceAssets, SurfaceDescription[] surfaceDescriptions)
{
//var diffY = (max.y - min.y);
//var diffZ = (max.z - min.z);
//var aspect = diffY / diffZ;
var diagonalHeight = sideHeight + definition.treadHeight; //Mathf.Max(sideHeight + definition.treadHeight, (aspect * (riserDepth)));// + definition.nosingDepth)) + definition.treadHeight;
for (int i = 0, j = startIndex; i < stepCount; i++, j++)
{
var topY = max.y + diagonalHeight;
var bottomY = min.y;
var middleY = (bottomY + diagonalHeight); // - (lastStep ? (riserDepth * aspect) : 0);
var rightZ = Mathf.Max(maxDepth, max.z); // + (lastStep ? riserDepth : 0);
var leftZ = Mathf.Max(maxDepth, min.z);
// topY leftZ
// 0 4
// *--*
// | \
// | \
// lefterZ | \ 3
// | *
// | | rightZ
// *------*
// 1 2
// bottomY
var lefterZ = (i == 0 || (riserType == StairsRiserType.FillDown)) ? maxDepth : Mathf.Max(maxDepth, leftZ - extraDepth);
var vertices = new[] {
new Vector3(min.x, topY, lefterZ), // 0
new Vector3(min.x, bottomY, lefterZ), // 1
new Vector3(min.x, bottomY, rightZ), // 2
new Vector3(min.x, middleY, rightZ), // 3
new Vector3(min.x, topY, leftZ), // 4
};
CreateExtrudedSubMesh(subMeshes[j + 0], vertices, extrusion,
new int[] { 0, 1, 2, 3, 3, 3, 3 }, // TODO: fix this
new int[] { 0, 1, 2, 2, 2, 2, 2 }, // TODO: fix this
surfaceAssets, surfaceDescriptions);
min.z += definition.stepDepth;
max.z += definition.stepDepth;
min.y -= definition.stepHeight;
max.y -= definition.stepHeight;
}
}
public void Validate()
{
topLength = Mathf.Max(topLength, 0);
bottomLength = Mathf.Max(bottomLength, 0);
length = Mathf.Max(Mathf.Abs(length), (haveRoundedTop ? topLength : 0) + (haveRoundedBottom ? bottomLength : 0));
length = Mathf.Max(Mathf.Abs(length), kMinLength);
height = Mathf.Max(Mathf.Abs(height), kMinHeight);
diameter = Mathf.Max(Mathf.Abs(diameter), kMinDiameter);
topSides = Mathf.Max(topSides, 1);
bottomSides = Mathf.Max(bottomSides, 1);
var sides = 2 + Mathf.Max(topSides, 1) + Mathf.Max(bottomSides, 1);
int kMinSurfaceAssets = 2 + sides;
if (surfaceAssets == null ||
surfaceAssets.Length != kMinSurfaceAssets)
{
var defaultRenderMaterial = CSGMaterialManager.DefaultWallMaterial;
var defaultPhysicsMaterial = CSGMaterialManager.DefaultPhysicsMaterial;
surfaceAssets = new CSGSurfaceAsset[kMinSurfaceAssets];
for (int a = 0; a < kMinSurfaceAssets; a++)
{
surfaceAssets[a] = CSGSurfaceAsset.CreateInstance(defaultRenderMaterial, defaultPhysicsMaterial);
}
}
int kMinSurfaceDescriptions = 2 + sides;
if (surfaceDescriptions == null ||
surfaceDescriptions.Length != kMinSurfaceDescriptions)
{
// TODO: make this independent on plane position somehow
var surfaceFlags = CSGDefaults.SurfaceFlags;
surfaceDescriptions = new SurfaceDescription[kMinSurfaceDescriptions];
for (int s = 0; s < kMinSurfaceDescriptions; s++)
{
surfaceDescriptions[s] = new SurfaceDescription {
UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0
}
}
;
}
}
}
private static bool ProjectOverlapTest(Vector3 axis, Vector3[] srcPoints, Vector3[] dstPoints, out float overlap)
{
float srcMin = float.MaxValue;
float dstMin = float.MaxValue;
float srcMax = float.MinValue;
float dstMax = float.MinValue;
for (int i = 0; i < srcPoints.Length; i++)
{
var p = Vector3.Dot(axis, srcPoints[i]);
if (p < srcMin)
{
srcMin = p;
}
if (p > srcMax)
{
srcMax = p;
}
}
for (int i = 0; i < dstPoints.Length; i++)
{
var p = Vector3.Dot(axis, dstPoints[i]);
if (p < dstMin)
{
dstMin = p;
}
if (p > dstMax)
{
dstMax = p;
}
}
if (srcMax < dstMin || srcMin > dstMax)
{
overlap = 0;
return(false);
}
overlap = Mathf.Min(srcMax, dstMax) - Mathf.Max(srcMin, dstMin);
if ((srcMax > dstMax && srcMin < dstMin) || (srcMax < dstMax && srcMin > dstMin))
{
var min = Mathf.Abs(srcMin - dstMin);
var max = Mathf.Abs(srcMax - dstMax);
overlap += Mathf.Min(min, max);
}
return(true);
}
public void Validate()
{
topHeight = Mathf.Max(topHeight, 0);
bottomHeight = Mathf.Max(bottomHeight, 0);
height = Mathf.Max(topHeight + bottomHeight, Mathf.Abs(height)) * (height < 0 ? -1 : 1);
diameterX = Mathf.Max(Mathf.Abs(diameterX), kMinDiameter);
diameterZ = Mathf.Max(Mathf.Abs(diameterZ), kMinDiameter);
topSegments = Mathf.Max(topSegments, 0);
bottomSegments = Mathf.Max(bottomSegments, 0);
sides = Mathf.Max(sides, 3);
var minSurfaceAssets = 2 + sides;
if (surfaceAssets == null ||
surfaceAssets.Length != minSurfaceAssets)
{
var defaultRenderMaterial = CSGMaterialManager.DefaultWallMaterial;
var defaultPhysicsMaterial = CSGMaterialManager.DefaultPhysicsMaterial;
surfaceAssets = new CSGSurfaceAsset[minSurfaceAssets];
for (int a = 0; a < minSurfaceAssets; a++)
{
surfaceAssets[a] = CSGSurfaceAsset.CreateInstance(defaultRenderMaterial, defaultPhysicsMaterial);
}
}
var minSurfaceDescriptions = 2 + sides;
if (surfaceDescriptions == null ||
surfaceDescriptions.Length != minSurfaceDescriptions)
{
// TODO: make this independent on plane position somehow
var surfaceFlags = CSGDefaults.SurfaceFlags;
surfaceDescriptions = new SurfaceDescription[minSurfaceDescriptions];
for (int s = 0; s < minSurfaceDescriptions; s++)
{
surfaceDescriptions[s] = new SurfaceDescription {
UV0 = UVMatrix.centered, surfaceFlags = surfaceFlags, smoothingGroup = 0
}
}
;
}
}
}
public void Validate()
{
if (surfaceDefinition == null)
{
surfaceDefinition = new ChiselSurfaceDefinition();
}
tubeWidth = Mathf.Max(tubeWidth, kMinTubeDiameter);
tubeHeight = Mathf.Max(tubeHeight, kMinTubeDiameter);
outerDiameter = Mathf.Max(outerDiameter, tubeWidth * 2);
horizontalSegments = Mathf.Max(horizontalSegments, 3);
verticalSegments = Mathf.Max(verticalSegments, 3);
totalAngle = Mathf.Clamp(totalAngle, 1, 360); // TODO: constants
surfaceDefinition.EnsureSize(6);
}
public static Frustum GetCameraSubFrustum(Camera camera, Rect rect)
{
var oldMatrix = UnityEditor.Handles.matrix;
UnityEditor.Handles.matrix = Matrix4x4.identity;
var min_x = Mathf.Min(rect.xMin, rect.xMax);
var max_x = Mathf.Max(rect.xMin, rect.xMax);
var min_y = Mathf.Min(rect.yMin, rect.yMax);
var max_y = Mathf.Max(rect.yMin, rect.yMax);
var o0 = new Vector2(min_x, min_y);
var o1 = new Vector2(max_x, min_y);
var o2 = new Vector2(max_x, max_y);
var o3 = new Vector2(min_x, max_y);
var r0 = HandleUtility.GUIPointToWorldRay(o0);
var r1 = HandleUtility.GUIPointToWorldRay(o1);
var r2 = HandleUtility.GUIPointToWorldRay(o2);
var r3 = HandleUtility.GUIPointToWorldRay(o3);
UnityEditor.Handles.matrix = oldMatrix;
var n0 = r0.origin;
var n1 = r1.origin;
var n2 = r2.origin;
var n3 = r3.origin;
var far = camera.farClipPlane;
var f0 = n0 + (r0.direction * far);
var f1 = n1 + (r1.direction * far);
var f2 = n2 + (r2.direction * far);
var f3 = n3 + (r3.direction * far);
var frustum = new Frustum();
frustum.Planes[0] = new Plane(n2, n1, f1); // right +
frustum.Planes[1] = new Plane(f3, f0, n0); // left -
frustum.Planes[2] = new Plane(n1, n0, f0); // top -
frustum.Planes[3] = new Plane(n3, n2, f2); // bottom +
frustum.Planes[4] = new Plane(n0, n1, n2); // near -
frustum.Planes[5] = new Plane(f2, f1, f0); // far +
return(frustum);
}
// TODO: remove all stairs specific parameters
static void GenerateBottomRamp(CSGBrushSubMesh[] subMeshes, int startIndex, int stepCount, Vector3 min, Vector3 max, Vector3 extrusion, StairsRiserType riserType, float riserDepth, float extraDepth, float maxDepth, CSGLinearStairsDefinition definition, CSGSurfaceAsset[] surfaceAssets, SurfaceDescription[] surfaceDescriptions)
{
for (int i = 0, j = startIndex; i < stepCount; i++, j++)
{
Vector3[] vertices;
var z0 = Mathf.Max(maxDepth, min.z - extraDepth);
var z1 = Mathf.Max(maxDepth, max.z - extraDepth);
var z2 = Mathf.Max(maxDepth, min.z + riserDepth);/*
* if (z2 < z1)
* {
* var t = z1; z1 = z2; z2 = t;
* z1 = Mathf.Max(maxDepth, min.z - extraDepth + definition.stepDepth);
* z2 = Mathf.Max(maxDepth, max.z);
* }*/
if (i != stepCount - 1)
{
vertices = new[] {
new Vector3(min.x, max.y, z2), // 0
new Vector3(min.x, max.y, z0), // 1
new Vector3(min.x, min.y, z1), // 2
new Vector3(min.x, min.y, z2), // 3
};
}
else
{
vertices = new[] {
new Vector3(min.x, max.y, z2), // 0
new Vector3(min.x, max.y, z0), // 1
new Vector3(min.x, min.y + definition.treadHeight, z1), // 2
new Vector3(min.x, min.y + definition.treadHeight, z2), // 3
};
}
CreateExtrudedSubMesh(subMeshes[j], vertices, extrusion,
new int[] { 0, 1, 2, 3, 3, 3 }, // TODO: fix this
new int[] { 0, 1, 2, 2, 2, 2 }, // TODO: fix this
surfaceAssets, surfaceDescriptions);
min.z += definition.stepDepth;
max.z += definition.stepDepth;
min.y -= definition.stepHeight;
max.y -= definition.stepHeight;
}
}
public void Validate()
{
if (surfaceDefinition == null)
{
surfaceDefinition = new ChiselSurfaceDefinition();
}
topHeight = Mathf.Max(topHeight, 0);
bottomHeight = Mathf.Max(bottomHeight, 0);
height = Mathf.Max(topHeight + bottomHeight, Mathf.Abs(height)) * (height < 0 ? -1 : 1);
diameterX = Mathf.Max(Mathf.Abs(diameterX), kMinDiameter);
diameterZ = Mathf.Max(Mathf.Abs(diameterZ), kMinDiameter);
topSegments = Mathf.Max(topSegments, 0);
bottomSegments = Mathf.Max(bottomSegments, 0);
sides = Mathf.Max(sides, 3);
surfaceDefinition.EnsureSize(2 + sides);
}
/// <summary>
/// Calculates a value from two given values based on the desired calculation method.
/// </summary>
/// <param name="lhs">The first value.</param>
/// <param name="rhs">The second value.</param>
/// <param name="calculation">How the final value should be calculated.</param>
public static float Calculate(float lhs, float rhs, PhysicsMaterialCombine calculation)
{
switch (calculation)
{
case PhysicsMaterialCombine.Average:
return((lhs + rhs) / 2f);
case PhysicsMaterialCombine.Multiply:
return(lhs * rhs);
case PhysicsMaterialCombine.Maximum:
return(Mathf.Max(lhs, rhs));
case PhysicsMaterialCombine.Minimum:
return(Mathf.Min(lhs, rhs));
default:
throw new System.NotImplementedException();
}
}
public static Rect PointsToRect(Vector2 start, Vector2 end)
{
start.x = Mathf.Max(start.x, 0);
start.y = Mathf.Max(start.y, 0);
end.x = Mathf.Max(end.x, 0);
end.y = Mathf.Max(end.y, 0);
Rect r = new Rect(start.x, start.y, end.x - start.x, end.y - start.y);
if (r.width < 0)
{
r.x += r.width;
r.width = -r.width;
}
if (r.height < 0)
{
r.y += r.height;
r.height = -r.height;
}
return(r);
}
public static bool Intersect(CubeXCollider src, CubeXCollider dst, out XContact?contact)
{
Vector3 normal;
float penetration;
if (!SATTest(src, dst, out normal, out penetration))
{
contact = null;
return(false);
}
var srcExtents = src.Size * 0.5f;
var dstExtents = dst.Size * 0.5f;
var srcMinY = src.Position.y - srcExtents.y;
var srcMaxY = src.Position.y + srcExtents.y;
var dstMinY = dst.Position.y - dstExtents.y;
var dstMaxY = dst.Position.y + dstExtents.y;
var overlapY = Mathf.Min(srcMaxY, dstMaxY) - Mathf.Max(srcMinY, dstMinY);
if ((srcMaxY > dstMaxY && srcMinY < dstMinY) || (srcMaxY < dstMaxY && srcMinY > dstMinY))
{
var min = Mathf.Abs(srcMinY - dstMinY);
var max = Mathf.Abs(srcMaxY - dstMaxY);
overlapY += Mathf.Min(min, max);
}
if (overlapY < penetration)
{
penetration = overlapY;
normal = Vector3.up;
}
if (Vector3.Dot(normal, dst.Position - src.Position) < 0)
{
normal = -normal;
}
contact = new XContact(src, dst, normal, penetration);
return(true);
}
static void DrawOutline(IChiselHandleRenderer renderer, ChiselStadiumDefinition definition, Vector3[] vertices, LineMode lineMode)
{
var sides = definition.sides;
var topSides = Mathf.Max(definition.topSides, 1) + 1;
var bottomSides = Mathf.Max(definition.bottomSides, 1) + 1;
var haveRoundedTop = definition.haveRoundedTop;
var haveRoundedBottom = definition.haveRoundedBottom;
var haveCenter = definition.haveCenter;
//renderer.DrawLineLoop(vertices, 0, sides, lineMode: lineMode, thickness: kCapLineThickness);
//renderer.DrawLineLoop(vertices, sides, sides, lineMode: lineMode, thickness: kCapLineThickness);
var firstTopSide = definition.firstTopSide;
var lastTopSide = definition.lastTopSide;
for (int k = firstTopSide; k <= lastTopSide; k++)
{
var sideLine = !haveRoundedTop || (k == firstTopSide) || (k == lastTopSide);
var thickness = (sideLine ? kSideLineThickness : kVertLineThickness);
var dashSize = (sideLine ? 0 : kLineDash);
renderer.DrawLine(vertices[k], vertices[sides + k], lineMode: lineMode, thickness: thickness, dashSize: dashSize);
}
var firstBottomSide = definition.firstBottomSide;
var lastBottomSide = definition.lastBottomSide;
for (int k = firstBottomSide; k <= lastBottomSide; k++)
{
var sideLine = haveCenter && (!haveRoundedBottom || (k == firstBottomSide) || (k == lastBottomSide));
var thickness = (sideLine ? kSideLineThickness : kVertLineThickness);
var dashSize = (sideLine ? 0 : kLineDash);
renderer.DrawLine(vertices[k], vertices[sides + k], lineMode: lineMode, thickness: thickness, dashSize: dashSize);
}
//renderer.DrawLine(vertices[firstBottomSide], vertices[lastBottomSide], lineMode: lineMode, thickness: kVertLineThickness);
//renderer.DrawLine(vertices[firstTopSide ], vertices[lastTopSide ], lineMode: lineMode, thickness: kVertLineThickness);
//renderer.DrawLine(vertices[sides + firstBottomSide], vertices[sides + lastBottomSide], lineMode: lineMode, thickness: kVertLineThickness);
//renderer.DrawLine(vertices[sides + firstTopSide ], vertices[sides + lastTopSide ], lineMode: lineMode, thickness: kVertLineThickness);
}
public void Validate()
{
if (surfaceDefinition == null)
{
surfaceDefinition = new ChiselSurfaceDefinition();
}
topLength = Mathf.Max(topLength, 0);
bottomLength = Mathf.Max(bottomLength, 0);
length = Mathf.Max(Mathf.Abs(length), (haveRoundedTop ? topLength : 0) + (haveRoundedBottom ? bottomLength : 0));
length = Mathf.Max(Mathf.Abs(length), kMinLength);
height = Mathf.Max(Mathf.Abs(height), kMinHeight);
diameter = Mathf.Max(Mathf.Abs(diameter), kMinDiameter);
topSides = Mathf.Max(topSides, 1);
bottomSides = Mathf.Max(bottomSides, 1);
var sides = 2 + Mathf.Max(topSides, 1) + Mathf.Max(bottomSides, 1);
surfaceDefinition.EnsureSize(2 + sides);
}
static void DrawOutline(IChiselHandleRenderer renderer, ChiselHemisphereDefinition definition, Vector3[] vertices, LineMode lineMode)
{
var sides = definition.horizontalSegments;
var topSegments = Mathf.Max(definition.verticalSegments, 0);
var bottomCap = false;
var topCap = (topSegments != 0);
var extraVertices = ((topCap) ? 1 : 0) + ((bottomCap) ? 1 : 0);
var bottomVertex = 0;
//var topVertex = (bottomCap) ? 1 : 0;
var rings = (vertices.Length - extraVertices) / sides;
var bottomRing = 0;
var prevColor = renderer.color;
var color = prevColor;
color.a *= 0.6f;
for (int i = 0, j = extraVertices; i < rings; i++, j += sides)
{
renderer.color = ((i == bottomRing) ? prevColor : color);
renderer.DrawLineLoop(vertices, j, sides, lineMode: lineMode, thickness: ((i == bottomRing) ? kCapLineThickness : kHorzLineThickness), dashSize: ((i == bottomRing) ? 0 : kLineDash));
}
renderer.color = color;
for (int k = 0; k < sides; k++)
{
for (int i = 0, j = extraVertices; i < rings - 1; i++, j += sides)
{
renderer.DrawLine(vertices[j + k], vertices[j + k + sides], lineMode: lineMode, thickness: kVertLineThickness);
}
if (topCap)
{
renderer.DrawLine(vertices[bottomVertex], vertices[extraVertices + k + ((rings - 1) * sides)], lineMode: lineMode, thickness: kVertLineThickness);
}
}
renderer.color = prevColor;
}
public void Validate()
{
if (surfaceDefinition == null)
{
surfaceDefinition = new ChiselSurfaceDefinition();
}
topDiameterX = Mathf.Abs(topDiameterX);
topDiameterZ = Mathf.Abs(topDiameterZ);
bottomDiameterX = Mathf.Abs(bottomDiameterX);
bottomDiameterZ = Mathf.Abs(bottomDiameterZ);
sides = Mathf.Max(3, sides);
if (surfaceDefinition.EnsureSize(2 + sides))
{
// Top plane
surfaceDefinition.surfaces[0].surfaceDescription.UV0 = UVMatrix.centered;
// Bottom plane
surfaceDefinition.surfaces[1].surfaceDescription.UV0 = UVMatrix.centered;
float radius = topDiameterX * 0.5f;
float angle = (360.0f / sides);
float sideLength = (2 * Mathf.Sin((angle / 2.0f) * Mathf.Deg2Rad)) * radius;
// Side planes
for (int i = 2; i < 2 + sides; i++)
{
var uv0 = UVMatrix.identity;
uv0.U.w = ((i - 2) + 0.5f) * sideLength;
// TODO: align with bottom
//uv0.V.w = 0.5f;
surfaceDefinition.surfaces[i].surfaceDescription.UV0 = uv0;
surfaceDefinition.surfaces[i].surfaceDescription.smoothingGroup = smoothingGroup;
}
}
}
// 너무 큰 이미지를 작은 이미지로 줄이면서 PNG 파일이 아니면 PNG로 바꾼다.
static string ExecuteResizeAndSaveAsPng(string sourceFileName, int threshold)
{
Logger.WriteLine($"Running {nameof(ExecuteResizeAndSaveAsPng)}");
using var image = Image.Load <Rgba32>(sourceFileName);
// 정사각형이 아니라면 우선 큰 변 기준으로 정사각형으로 만든다. (여백 추가)
if (image.Width != image.Height)
{
var maxSide = Math.Max(image.Width, image.Height);
var options = new ResizeOptions
{
Size = new Size(maxSide, maxSide),
Mode = ResizeMode.BoxPad,
Sampler = new NearestNeighborResampler()
};
image.Mutate(x => x.Resize(options));
}
if (image.Width > threshold)
{
var options = new ResizeOptions
{
Size = new Size(threshold, threshold),
Mode = ResizeMode.BoxPad
};
image.Mutate(x => x.Resize(options));
}
var targetFileName = AppendToFileName(sourceFileName, "", ".png", outputNewFileName);
image.Save(targetFileName, new PngEncoder());
return(targetFileName);
}
public static float CalcInnerDiameter(float outerDiameter, float tubeWidth)
{
var innerDiameter = outerDiameter - (tubeWidth * 2);
return(Mathf.Max(0, innerDiameter));
}
public static float CalcTubeWidth(float outerDiameter, float innerDiameter)
{
var tubeWidth = (outerDiameter - innerDiameter) * 0.5f;
return(Mathf.Max(kMinTubeDiameter, tubeWidth));
}
