// Callback for acceleration
// (ODE solver uses x" = F/m) applied to particle i.
// The positions and velocities are not necessarily
// m_akPosition and m_akVelocity since the ODE solver evaluates the
// impulse function at intermediate positions.
protected override float3 Acceleration(int i, Real fTime, float3[] akPosition, float3[] akVelocity)
{
// Compute spring forces on position X[i]. The positions are not
// necessarily m_akPosition since the RK4 solver in ParticleSystem
// evaluates the acceleration function at intermediate positions. The end
// points of the curve of masses must be handled separately since each
// has only one spring attached to it.
float3 kAcceleration = ExternalAcceleration(i, fTime, akPosition, akVelocity);
float3 kDiff, kForce;
Real fRatio;
if (i > 0)
{
int iM1 = i - 1;
kDiff = akPosition[iM1] - akPosition[i];
fRatio = m_afLength[iM1] / kDiff.Length;
kForce = m_afConstant[iM1] * (((Real)1.0) - fRatio) * kDiff;
kAcceleration += MassInverse[i] * kForce;
}
int iP1 = i + 1;
if (iP1 < NumParticles)
{
kDiff = akPosition[iP1] - akPosition[i];
fRatio = m_afLength[i] / kDiff.Length;
kForce = m_afConstant[i] * (((Real)1.0) - fRatio) * kDiff;
kAcceleration += MassInverse[i] * kForce;
}
return kAcceleration;
}
public Sheep(RenderContext rc, float3 position, float3 rotation, float3 scaleFactor, SceneRenderer sc, Game game)
: base(rc, position, rotation, scaleFactor, sc)
{
_distance = position.Length;
if (_distance > 60)
{
_score = 120;
}
if (_distance > 40)
{
_score = 80;
}
else
{
_score = 50;
}
Speed = (5 / _distance) * game.Level;
Radius = 4f;
_game = game;
Pos = position;
_alpha = (float)Math.Tan(Pos.z/Pos.x);
Tag = "Sheep";
_level = 1;
//zufällige Wellenbewegung
if (position.x % 2 == 0)
{
TheWave = SinWave;
}
else
{
TheWave = CosWave;
}
}
public float4x3(float3x3 R, float3 t)
{
M11 = R.M11; M12 = R.M12; M13 = R.M13;
M21 = R.M21; M22 = R.M22; M23 = R.M23;
M31 = R.M31; M32 = R.M32; M33 = R.M33;
M41 = t.x; M42 = t.y; M43 = t.z;
}
public float4x3(float3 r0, float3 r1, float3 r2, float3 r3)
{
M11 = r0.x; M12 = r0.y; M13 = r0.z;
M21 = r1.x; M22 = r1.y; M23 = r1.z;
M31 = r2.x; M32 = r2.y; M33 = r2.z;
M41 = r3.x; M42 = r3.y; M43 = r3.z;
}
public float4(float3 v, float _w)
{
x = v.x;
y = v.y;
z = v.z;
w = _w;
}
/// <summary>
/// Evaluates the distance to the closest distance field primitive in the field
/// </summary>
/// <param name="_Position"></param>
/// <returns></returns>
public float EvalDistance( float3 _Position )
{
float Distance = float.MaxValue;
foreach ( IDistanceFieldPrimitive P in m_Primitives )
Distance = Math.Min( Distance, P.Eval( _Position ) );
return Distance;
}
/// <summary>
/// Initializes a new instance of the <see cref="PointLight"/> class. Only the channel is needed. Other params
/// will be set to default value.
/// </summary>
/// <param name="channel">The memory space of the light(0 - 7).</param>
public PointLight(int channel)
{
_type = LightType.Point;
_position = new float3(0, 0, 0);
_diffuseColor = new float4(1, 1, 1, 1);
_channel = channel;
}
public float4x4(float3x3 R, float3 t)
{
M11 = R.M11; M12 = R.M12; M13 = R.M13; M14 = 0;
M21 = R.M21; M22 = R.M22; M23 = R.M23; M24 = 0;
M31 = R.M31; M32 = R.M32; M33 = R.M33; M34 = 0;
M41 = t.x; M42 = t.y; M43 = t.z; M44 = 1;
}
public float3 axis()
{
float3 a = new float3(x, y, z);
if (Math.Abs(angle()) < 0.0000001f)
return new float3(1f, 0f, 0f);
return a * (1 / (float)Math.Sin(angle() / 2.0f));
}
public void DrawLine(float3 start, float3 end, float width, Color startColor, Color endColor)
{
renderer.CurrentBatchRenderer = this;
if (nv + 6 > renderer.TempBufferSize)
Flush();
var delta = (end - start) / (end - start).XY.Length;
var corner = width / 2 * new float3(-delta.Y, delta.X, delta.Z);
startColor = Util.PremultiplyAlpha(startColor);
var sr = startColor.R / 255.0f;
var sg = startColor.G / 255.0f;
var sb = startColor.B / 255.0f;
var sa = startColor.A / 255.0f;
endColor = Util.PremultiplyAlpha(endColor);
var er = endColor.R / 255.0f;
var eg = endColor.G / 255.0f;
var eb = endColor.B / 255.0f;
var ea = endColor.A / 255.0f;
vertices[nv++] = new Vertex(start - corner + Offset, sr, sg, sb, sa, 0, 0);
vertices[nv++] = new Vertex(start + corner + Offset, sr, sg, sb, sa, 0, 0);
vertices[nv++] = new Vertex(end + corner + Offset, er, eg, eb, ea, 0, 0);
vertices[nv++] = new Vertex(end + corner + Offset, er, eg, eb, ea, 0, 0);
vertices[nv++] = new Vertex(end - corner + Offset, er, eg, eb, ea, 0, 0);
vertices[nv++] = new Vertex(start - corner + Offset, sr, sg, sb, sa, 0, 0);
}
public BoxShape AddBoxShape(float3 boxHalfExtents)
{
IBoxShapeImp iBoxShapeImp = _dwi.AddBoxShape(boxHalfExtents);
var retval = new BoxShape();
retval.BoxShapeImp = iBoxShapeImp;
iBoxShapeImp.UserObject = retval;
return retval;
}
/// <summary>
/// Lerp Function for Float3.
/// </summary>
public static float3 Float3Lerp(float3 val1, float3 val2, float time1, float time2)
{
float3 values = new float3();
values.x = val1.x + ((val2.x - val1.x) / time1) * time2;
values.y = val1.y + ((val2.y - val1.y) / time1) * time2;
values.z = val1.z + ((val2.z - val1.z) / time1) * time2;
return values;
}
/// <summary>
/// Initializes a new instance of the <see cref="SpotLight"/> class. Only the channel is needed.
/// </summary>
/// <param name="channel">The memory space of the light(0 - 7).</param>
public SpotLight( int channel)
{
_type = LightType.Spot;
_position = new float3(0,0,0);
_direction = new float3(0,-1,0);
_diffuseColor = new float4(1, 1, 1, 1);
_channel = channel;
}
public static void DrawTargetMarker(WorldRenderer wr, Color color, float3 location)
{
var iz = 1 / wr.Viewport.Zoom;
var offset = new float2(iz, iz);
var tl = location - offset;
var br = location + offset;
Game.Renderer.WorldRgbaColorRenderer.FillRect(tl, br, color);
}
// is called once a frame
public override void RenderAFrame()
{
RC.Clear(ClearFlags.Color | ClearFlags.Depth);
Point pt = Input.Instance.GetMousePos();
var mousePosWorld = new float3(pt.x - Width/2, Height/2 - pt.y, 0);
mousePosWorld = 2*CamDist/SquareScreenPxls*mousePosWorld;
var lineWidthFactor = 1.0f;
if (Input.Instance.IsButton(MouseButtons.Left))
{
lineWidthFactor = 3.0f;
_shaderEffect.SetEffectParam("uLineColor", new float4(1, 0.2f, 0.2f, 0.9f));
}
else
{
_shaderEffect.SetEffectParam("uLineColor", new float4(0, 0, 0, 1));
}
_shaderEffect.SetEffectParam("uLineWidth",
new float2(lineWidthFactor*LineWidth/_normWidth, lineWidthFactor*LineWidth/_normHeight));
var curMaxRotChange =
(float) (MaxRotChange*Math.Abs(Input.Instance.GetAxis(InputAxis.MouseX))*Time.Instance.DeltaTime);
float angleHorzDelta =
Math.Min(
Math.Max(RotationSpeed*-Input.Instance.GetAxis(InputAxis.MouseX) - _angleHorz, -curMaxRotChange),
curMaxRotChange);
_angleHorz = (float) Math.Max(-0.5f*Math.PI, Math.Min(_angleHorz + angleHorzDelta, 0.5f*Math.PI));
curMaxRotChange =
(float) (MaxRotChange*Math.Abs(Input.Instance.GetAxis(InputAxis.MouseY))*Time.Instance.DeltaTime);
float angleVertDelta =
Math.Min(
Math.Max(RotationSpeed*-Input.Instance.GetAxis(InputAxis.MouseY) - _angleVert, -curMaxRotChange),
curMaxRotChange);
_angleVert = (float) Math.Max(-0.7f*Math.PI, Math.Min(_angleVert + angleVertDelta, 0.2f*Math.PI));
/* float angleVertDelta =
Math.Min(Math.Max(_angleVert - RotationSpeed * -Input.Instance.GetAxis(InputAxis.MouseX), -_maxRotChange), _maxRotChange);
_angleVert += angleVertDelta;*/
var mtxRot = float4x4.CreateRotationY(_angleHorz)*float4x4.CreateRotationX(_angleVert);
var mtxCam = float4x4.LookAt(0, 0, CamDist, 0, 0, 0, 0, 1, 0);
var curDamp = (float) Math.Exp(-Damping*Time.Instance.DeltaTime);
_angleHorz *= curDamp;
_angleVert *= curDamp;
// first mesh
RC.ModelView = float4x4.CreateRotationX((float) (-0.3*Math.PI))*
new float4x4(HandScale, 0, 0, 0, 0, HandScale, 0, 0, 0, 0, HandScale, 0, 0, 0, 0, 1)*mtxRot*
float4x4.CreateTranslation(mousePosWorld)*mtxCam;
_shaderEffect.RenderMesh(_meshTea);
// swap buffers
Present();
}
/// <summary>
/// Creates a point light in the scene. Position, color, position, and channel is needed.
/// It is possible to set up to 8 lights in the scene.
/// </summary>
/// <param name="color">The color of the light.</param>
/// <param name="position">The position in the scene.</param>
/// <param name="channel">The memory space of the light.(0 - 7)</param>
public PointLight(float4 color, float3 position, int channel)
{
_position = position;
_diffuseColor = new float4(0.6f, 0.6f, 0.6f, 1);
_ambientColor = new float4(0.3f, 0.3f, 0.3f, 1);
_specularColor = new float4(0.1f, 0.1f, 0.1f, 1);
_type = LightType.Point;
_channel = channel;
}
public Quaternion(float3 v, float t)
{
v = float3.normalize(v);
w = (float)Math.Cos(t / 2.0f);
v = v * (float)Math.Sin(t / 2.0f);
x = v.x;
y = v.y;
z = v.z;
}
/// <summary>
/// Initializes a new instance of the <see cref="RenderPointLight" /> class. Position, color, type and channel are needed.
/// </summary>
/// <param name="position">The position of the light.</param>
/// <param name="diffuse">The diffuse light color.</param>
/// <param name="ambient">The ambient light color.</param>
/// <param name="specular">The specular light color.</param>
/// <param name="type">The light type.</param>
/// <param name="channel">The memory space of the light(0 - 7).</param>
public RenderPointLight(float3 position, float4 diffuse, float4 ambient, float4 specular, Light.LightType type, int channel)
{
_position = position;
_type = Light.LightType.Point;
_diffuseColor = diffuse;
_ambientColor = ambient;
_specularColor = specular;
_channel = channel;
}
private static PlaneTriResult getSidePlane(float3 p, float4 plane, float epsilon)
{
float d = DistToPt(p, plane);
if ((d + epsilon) > 0f)
return PlaneTriResult.PTR_FRONT; // it is 'in front' within the provided epsilon value.
return PlaneTriResult.PTR_BACK;
}
public Transformation()
{
fMatrix = float3x3.Identity;
fTranslate = float3.Zero;
fScale = new float3(1, 1, 1);
fIsIdentity = true;
fIsRSMatrix = true;
fIsUniformScale = true;
}
/// <summary>
/// Creates a directional light in the scene. Direction, color and position will get standart values.
/// Channel is needed. It is possible to set up to 8 lights in the scene.
/// </summary>
/// <param name="channel">The memory space of the light(0 - 7).</param>
public DirectionalLight( int channel)
{
_position = new float3(0,0,0);
_direction = new float3(0,-1,0);
_diffuseColor = new float4(0.6f, 0.6f, 0.6f, 1);
_ambientColor = new float4(0.3f, 0.3f, 0.3f, 1);
_specularColor = new float4(0.1f, 0.1f, 0.1f, 1);
_type = LightType.Directional;
_channel = channel;
}
/// <summary>
/// Creates a spot light in the scene. Position, color, position, and channel is needed.
/// It is possible to set up to 8 lights in the scene.
/// </summary>
/// <param name="direction">Direction of the light.</param>
/// <param name="diffuse">The diffuse light color.</param>
/// <param name="ambient">The ambient light color.</param>
/// <param name="specular">The specular light color.</param>
/// <param name="position">The lights position in the scene.</param>
/// <param name="channel">The memory space of the light.(0 - 7)</param>
public SpotLight(float3 direction, float4 diffuse, float4 ambient, float4 specular, float3 position, int channel)
{
_direction = direction;
_position = position;
_diffuseColor = diffuse;
_ambientColor = ambient;
_specularColor = specular;
_type = LightType.Spot;
_channel = channel;
}
public Tomato(RenderContext rc, float3 position, float3 rotation, float3 scaleFactor,SceneRenderer sc, RigidBody tomatoRigidBody, Game game, DynamicWorld world)
: base(rc, position, rotation, scaleFactor, sc)
{
TomatoRb = tomatoRigidBody;
Radius = 2f;
Tag = "Tomato";
timer = 2.0f;
_game = game;
_world = world;
}
public Transformation(Transformation aTrans)
{
fMatrix = aTrans.fMatrix;
fTranslate = aTrans.fTranslate;
fScale = aTrans.fScale;
fIsIdentity = aTrans.fIsIdentity;
fIsRSMatrix = aTrans.fIsRSMatrix;
fIsUniformScale = aTrans.fIsUniformScale;
}
public void Transform(float3 position, Quaternion orientation)
{
// Transforms the plane to the space defined by the
// given position/orientation
float3 newNormal = Quaternion.Inverse(orientation) * normal;
float3 origin = Quaternion.Inverse(orientation) * (-normal * dist - position);
normal = newNormal;
dist = -float3.dot(newNormal, origin);
}
public int getIndex(float3 vtx)
{
int idx;
if (mIndices.TryGetValue(vtx, out idx))
return idx;
idx = mVertices.Count;
mVertices.Add(vtx);
mIndices.Add(vtx, idx);
return idx;
}
public static float Test (float3 lookAt, float3 upDirection) {
float3.OrthoNormalize(ref lookAt, ref upDirection);
float w = upDirection.y + lookAt.z;
float w4Recip = 1.0f / (4.0f * w);
float x = (upDirection.z - lookAt.y) * w4Recip;
float y = lookAt.x * w4Recip;
float z = upDirection.x * w4Recip;
return w + x + y + z;
}
/// <summary>
/// Initializes a new instance of the <see cref="RenderSpotLight" /> class. Position, direction, color, type and channel.
/// </summary>
/// <param name="position">The position of the light.</param>
/// <param name="direction">The direction of the light.</param>
/// <param name="diffuse">The diffuse light color.</param>
/// <param name="ambient">The ambient light color.</param>
/// <param name="specular">The specular light color.</param>
/// <param name="angle">The angle of the spot light.</param>
/// <param name="type">The lighttype.</param>
/// <param name="channel">The memory space of the light(0 - 7).</param>
public RenderSpotLight(float3 position, float3 direction, float4 diffuse, float4 ambient, float4 specular, float angle, Light.LightType type, int channel)
{
_position = position;
_direction = direction;
_type = Light.LightType.Spot;
_diffuseColor = diffuse;
_ambientColor = ambient;
_specularColor = specular;
_channel = channel;
_angle = angle;
}
/// <summary>
/// Initializes a new instance of the <see cref="Transformation"/> class. No SceneEntity will be set.
/// </summary>
public Transformation()
{
_hasParent = false;
_transformMatrix = float4x4.Identity;
_globalMatrix = _transformMatrix;
_quaternion = Quaternion.Identity;
_globalQuaternion = Quaternion.Identity;
_globalScale = new float3(1,1,1);
_localScale = new float3(1,1,1);
_matrixDirty = false;
_quaternionDirty = false;
_eulerDirty = false;
}
private static void addTri(VertexPool vl, List<int> list, float3 p1, float3 p2, float3 p3)
{
int i1 = vl.getIndex(p1);
int i2 = vl.getIndex(p2);
int i3 = vl.getIndex(p3);
// do *not* process degenerate triangles!
if ( i1 != i2 && i1 != i3 && i2 != i3 )
{
list.Add(i1);
list.Add(i2);
list.Add(i3);
}
}
public void TestBoxColliderCreateInvalid()
{
float3 center = new float3(1.0f, 0.0f, 0.0f);
quaternion orientation = quaternion.AxisAngle(math.normalize(new float3(4.3f, 1.2f, 0.1f)), 1085.0f);
float3 size = new float3(1.0f, 2.0f, 3.0f);
float convexRadius = 0.45f;
// Invalid center, positive infinity
{
float3 invalidCenter = new float3(float.PositiveInfinity, 1.0f, 1.0f);
TestUtils.ThrowsException <System.ArgumentException>(
() => BoxCollider.Create(invalidCenter, orientation, size, convexRadius)
);
}
// Invalid center, positive infinity
{
float3 invalidCenter = new float3(float.NegativeInfinity, 1.0f, 1.0f);
TestUtils.ThrowsException <System.ArgumentException>(
() => BoxCollider.Create(invalidCenter, orientation, size, convexRadius)
);
}
// Invalid center, nan
{
float3 invalidCenter = new float3(float.NaN, 1.0f, 1.0f);
TestUtils.ThrowsException <System.ArgumentException>(
() => BoxCollider.Create(invalidCenter, orientation, size, convexRadius)
);
}
// Negative size
{
float3 invalidSize = new float3(-1.0f, 1.0f, 1.0f);
TestUtils.ThrowsException <System.ArgumentException>(
() => BoxCollider.Create(center, orientation, invalidSize, convexRadius)
);
}
// Invalid size, positive inf
{
float3 invalidSize = new float3(float.PositiveInfinity, 1.0f, 1.0f);
TestUtils.ThrowsException <System.ArgumentException>(
() => BoxCollider.Create(center, orientation, invalidSize, convexRadius)
);
}
// Invalid size, negative inf
{
float3 invalidSize = new float3(float.NegativeInfinity, 1.0f, 1.0f);
TestUtils.ThrowsException <System.ArgumentException>(
() => BoxCollider.Create(center, orientation, invalidSize, convexRadius)
);
}
// Invalid size, nan
{
float3 invalidSize = new float3(float.NaN, 1.0f, 1.0f);
TestUtils.ThrowsException <System.ArgumentException>(
() => BoxCollider.Create(center, orientation, invalidSize, convexRadius)
);
}
// Negative convex radius
{
float invalidConvexRadius = -0.0001f;
TestUtils.ThrowsException <System.ArgumentException>(
() => BoxCollider.Create(center, orientation, size, invalidConvexRadius)
);
}
// Invalid convex radius, +inf
{
float invalidConvexRadius = float.PositiveInfinity;
TestUtils.ThrowsException <System.ArgumentException>(
() => BoxCollider.Create(center, orientation, size, invalidConvexRadius)
);
}
// Invalid convex radius, -inf
{
float invalidConvexRadius = float.NegativeInfinity;
TestUtils.ThrowsException <System.ArgumentException>(
() => BoxCollider.Create(center, orientation, size, invalidConvexRadius)
);
}
// Invalid convex radius, nan
{
float invalidConvexRadius = float.NaN;
TestUtils.ThrowsException <System.ArgumentException>(
() => BoxCollider.Create(center, orientation, size, invalidConvexRadius)
);
}
}
public static float Det(float3 a, float3 b, float3 c) => math.dot(math.cross(a, b), c); // TODO: use math.determinant()?
public static float HorizontalMul(float3 v) => v.x * v.y * v.z;
public static int IndexOfMinComponent(float3 v) => v.x < v.y ? ((v.x < v.z) ? 0 : 2) : ((v.y < v.z) ? 1 : 2);
// RenderAFrame is called once a frame
public override void RenderAFrame()
{
// Clear the backbuffer
RC.Clear(ClearFlags.Color | ClearFlags.Depth);
UpdateVideos();
// Mouse and keyboard movement
if (Keyboard.LeftRightAxis != 0 || Keyboard.UpDownAxis != 0)
{
_keys = true;
}
if (Mouse.LeftButton)
{
_keys = false;
_angleVelHorz = -RotationSpeed * Mouse.XVel * DeltaTime * 0.0005f;
_angleVelVert = -RotationSpeed * Mouse.YVel * DeltaTime * 0.0005f;
}
else if (Touch.GetTouchActive(TouchPoints.Touchpoint_0))
{
_keys = false;
var touchVel = Touch.GetVelocity(TouchPoints.Touchpoint_0);
_angleVelHorz = -RotationSpeed * touchVel.x * DeltaTime * 0.0005f;
_angleVelVert = -RotationSpeed * touchVel.y * DeltaTime * 0.0005f;
}
else
{
if (_keys)
{
_angleVelHorz = -RotationSpeed * Keyboard.LeftRightAxis * DeltaTime;
_angleVelVert = -RotationSpeed * Keyboard.UpDownAxis * DeltaTime;
}
else
{
var curDamp = (float)System.Math.Exp(-Damping * DeltaTime);
_angleVelHorz *= curDamp;
_angleVelVert *= curDamp;
}
}
if (Input.Keyboard.IsKeyDown(KeyCodes.PageUp) == true)
{
_screen.SetHit(10);
}
if (Input.Keyboard.IsKeyDown(KeyCodes.PageDown) == true)
{
_screen.SetHit(-10);
}
_angleHorz += _angleVelHorz;
_angleVert += _angleVelVert;
// Create the camera matrix and set it as the current ModelView transformation
var mtxRot = float4x4.CreateRotationX(_angleVert) * float4x4.CreateRotationY(_angleHorz);
// 3d mode
var eyeF = new float3(0, 110, -1000);
var targetF = new float3(0, 110, 0);
var upF = new float3(0, 1, 0);
_stereoCam.Prepare(Stereo3DEye.Left);
for (var x = 0; x < 2; x++)
{
var lookAt = _stereoCam.LookAt3D(_stereoCam.CurrentEye, eyeF, targetF, upF);
var mtx = lookAt * mtxRot;
// var mtxCam = float4x4.LookAt(0, 20, -600, 0, 150, 0, 0, 1, 0);
RC.ModelView = mtx * float4x4.CreateTranslation(new float3(0, 0, 0));
// Render the scene loaded in Init()
//Render FUSEE Rocket
_sceneRenderer.Render(RC);
//Render ScreenS3D object
_screen.Render(_stereoCam, lookAt * mtx);
_stereoCam.Save();
if (x == 0)
{
_stereoCam.Prepare(Stereo3DEye.Right);
}
}
_stereoCam.Display();
#if GUI_SIMPLE
_guiHandler.RenderGUI();
#endif
// Swap buffers: Show the contents of the backbuffer (containing the currently rerndered farame) on the front buffer.
Present();
}
protected override void OnUpdate()
{
var uniqueTypes = new List <SpawnRandomInSphere>(10);
EntityManager.GetAllUniqueSharedComponentData(uniqueTypes);
int spawnInstanceCount = 0;
for (int sharedIndex = 0; sharedIndex != uniqueTypes.Count; sharedIndex++)
{
var spawner = uniqueTypes[sharedIndex];
m_MainGroup.SetFilter(spawner);
var entityCount = m_MainGroup.CalculateLength();
spawnInstanceCount += entityCount;
}
if (spawnInstanceCount == 0)
{
return;
}
var spawnInstances = new NativeArray <SpawnRandomInSphereInstance>(spawnInstanceCount, Allocator.Temp);
{
int spawnIndex = 0;
for (int sharedIndex = 0; sharedIndex != uniqueTypes.Count; sharedIndex++)
{
var spawner = uniqueTypes[sharedIndex];
m_MainGroup.SetFilter(spawner);
if (m_MainGroup.CalculateLength() == 0)
{
continue;
}
var entities = m_MainGroup.ToEntityArray(Allocator.TempJob);
var positions = m_MainGroup.ToComponentDataArray <Position>(Allocator.TempJob);
for (int entityIndex = 0; entityIndex < entities.Length; entityIndex++)
{
var spawnInstance = new SpawnRandomInSphereInstance();
spawnInstance.sourceEntity = entities[entityIndex];
spawnInstance.spawnerIndex = sharedIndex;
spawnInstance.position = positions[entityIndex].Value;
spawnInstances[spawnIndex] = spawnInstance;
spawnIndex++;
}
entities.Dispose();
positions.Dispose();
}
}
for (int spawnIndex = 0; spawnIndex < spawnInstances.Length; spawnIndex++)
{
int spawnerIndex = spawnInstances[spawnIndex].spawnerIndex;
var spawner = uniqueTypes[spawnerIndex];
int count = spawner.count;
var entities = new NativeArray <Entity>(count, Allocator.Temp);
var prefab = spawner.prefab;
float radius = spawner.radius;
var spawnPositions = new NativeArray <float3>(count, Allocator.Temp);
float3 center = spawnInstances[spawnIndex].position;
var sourceEntity = spawnInstances[spawnIndex].sourceEntity;
GeneratePoints.RandomPointsInSphere(center, radius, ref spawnPositions);
EntityManager.Instantiate(prefab, entities);
for (int i = 0; i < count; i++)
{
var position = new Position
{
Value = spawnPositions[i]
};
EntityManager.SetComponentData(entities[i], position);
}
EntityManager.RemoveComponent <SpawnRandomInSphere>(sourceEntity);
spawnPositions.Dispose();
entities.Dispose();
}
spawnInstances.Dispose();
}
public void PlaceItem()
{
float3 mousePos = GETMousePosition();
}
public static float dot(float3 left, float3 right)
{
return(left.x * right.x + left.y * right.y + left.z * right.z);
}
public matrix3x3(float3 col1, float3 col2, float3 col3)
{
m11 = col1.x; m12 = col2.x; m13 = col3.x;
m21 = col1.y; m22 = col2.y; m23 = col3.y;
m31 = col1.z; m32 = col2.z; m33 = col3.z;
}
public static float CalculateTime_Arc(float3 position, float3 target, float gravity, float arcHeight)
{
return(math.sqrt(-2 * arcHeight / gravity) + math.sqrt(2 * (target.y - position.y - arcHeight) / gravity));
}
public static unsafe void CheckSupport(CharacterControllerStepInput stepInput,
RigidTransform transform, float maxSlope, MaxHitsCollector <DistanceHit> distanceHitsCollector,
ref NativeArray <SurfaceConstraintInfo> constraints, out CharacterSupportState characterState)
{
// If no hits, proclaim unsupported state
if (distanceHitsCollector.NumHits == 0)
{
characterState = CharacterSupportState.Unsupported;
return;
}
// Downwards direction must be normalized
float3 downwardsDirection = -stepInput.Up;
Assert.IsTrue(Math.IsNormalized(downwardsDirection));
// Iterate over distance hits and create constraints from them
for (int i = 0; i < distanceHitsCollector.NumHits; i++)
{
DistanceHit hit = distanceHitsCollector.AllHits[i];
CreateConstraintFromHit(stepInput.World, float3.zero, stepInput.DeltaTime, hit.RigidBodyIndex, hit.ColliderKey,
hit.Position, hit.SurfaceNormal, hit.Distance, true, out SurfaceConstraintInfo constraint);
constraints[i] = constraint;
}
// Solve downwards (don't respect min delta time, try to solve full step)
float3 outVelocity = downwardsDirection;
float3 outPosition = transform.pos;
SimplexSolver.Solve(stepInput.World, stepInput.DeltaTime, stepInput.Up, distanceHitsCollector.NumHits,
ref constraints, ref outPosition, ref outVelocity, out float integratedTime, false);
// Check support state
{
if (math.lengthsq(downwardsDirection - outVelocity) < SimplexSolver.c_SimplexSolverEpsilon)
{
// If velocity hasn't changed significantly, declare unsupported state
characterState = CharacterSupportState.Unsupported;
}
else if (math.lengthsq(outVelocity) < SimplexSolver.c_SimplexSolverEpsilon)
{
// If velocity is very small, declare supported state
characterState = CharacterSupportState.Supported;
}
else
{
// Check if sliding or supported
outVelocity = math.normalize(outVelocity);
float slopeAngleSin = math.dot(outVelocity, downwardsDirection);
float slopeAngleCosSq = 1 - slopeAngleSin * slopeAngleSin;
float maxSlopeCosine = math.cos(maxSlope);
if (slopeAngleCosSq < maxSlopeCosine * maxSlopeCosine - SimplexSolver.c_SimplexSolverEpsilon)
{
characterState = CharacterSupportState.Sliding;
}
else
{
characterState = CharacterSupportState.Supported;
}
}
}
}
private static unsafe void CalculateAndStoreDeferredImpulses(
CharacterControllerStepInput stepInput, float characterMass, float3 linearVelocity, int numConstraints,
ref NativeArray <SurfaceConstraintInfo> constraints, ref BlockStream.Writer deferredImpulseWriter)
{
PhysicsWorld world = stepInput.World;
for (int i = 0; i < numConstraints; i++)
{
SurfaceConstraintInfo constraint = constraints[i];
int rigidBodyIndex = constraint.RigidBodyIndex;
if (rigidBodyIndex < 0 || rigidBodyIndex >= world.NumDynamicBodies)
{
// Invalid and static bodies should be skipped
continue;
}
RigidBody body = world.Bodies[rigidBodyIndex];
float3 pointRelVel = world.GetLinearVelocity(rigidBodyIndex, constraint.HitPosition);
pointRelVel -= linearVelocity;
float projectedVelocity = math.dot(pointRelVel, constraint.Plane.Normal);
// Required velocity change
float deltaVelocity = -projectedVelocity * stepInput.Damping;
float distance = constraint.Plane.Distance;
if (distance < 0.0f)
{
deltaVelocity += (distance / stepInput.DeltaTime) * stepInput.Tau;
}
// Calculate impulse
MotionVelocity mv = world.MotionVelocities[rigidBodyIndex];
float3 impulse = float3.zero;
if (deltaVelocity < 0.0f)
{
// Impulse magnitude
float impulseMagnitude = 0.0f;
{
float objectMassInv = GetInvMassAtPoint(constraint.HitPosition, constraint.Plane.Normal, body, mv);
impulseMagnitude = deltaVelocity / objectMassInv;
}
impulse = impulseMagnitude * constraint.Plane.Normal;
}
// Add gravity
{
// Effect of gravity on character velocity in the normal direction
float3 charVelDown = stepInput.Gravity * stepInput.DeltaTime;
float relVelN = math.dot(charVelDown, constraint.Plane.Normal);
// Subtract separation velocity if separating contact
{
bool isSeparatingContact = projectedVelocity < 0.0f;
float newRelVelN = relVelN - projectedVelocity;
relVelN = math.select(relVelN, newRelVelN, isSeparatingContact);
}
// If resulting velocity is negative, an impulse is applied to stop the character
// from falling into the body
{
float3 newImpulse = impulse;
newImpulse += relVelN * characterMass * constraint.Plane.Normal;
impulse = math.select(impulse, newImpulse, relVelN < 0.0f);
}
}
// Store impulse
deferredImpulseWriter.Write(
new DeferredCharacterControllerImpulse()
{
Entity = body.Entity,
Impulse = impulse,
Point = constraint.HitPosition
});
}
}
public void Execute(int index)
{
{
if (index % DynamicBoneBeta.MAX_TRANSFORM_LIMIT == 0)
{
return;
}
int headIndex = index / DynamicBoneBeta.MAX_TRANSFORM_LIMIT;
DynamicBoneBeta.HeadInfo curHeadInfo = ParticleHeadInfo[headIndex];
{
int singleId = index % DynamicBoneBeta.MAX_TRANSFORM_LIMIT;
if (singleId >= curHeadInfo.m_particleCount)
{
return;
}
int pIdx = curHeadInfo.m_jobDataOffset + (index % DynamicBoneBeta.MAX_TRANSFORM_LIMIT);
DynamicBoneBeta.Particle p = ParticleInfo[pIdx];
int p0Idx = curHeadInfo.m_jobDataOffset + p.m_ParentIndex;
DynamicBoneBeta.Particle p0 = ParticleInfo[p0Idx];
float3 ePos = p.worldPosition;
float3 ep0Pos = p0.worldPosition;
float erestLen = math.distance(ep0Pos, ePos);
float stiffness = Mathf.Lerp(1.0f, p.m_Stiffness, curHeadInfo.m_Weight);
if (stiffness > 0 || p.m_Elasticity > 0)
{
float4x4 em0 = float4x4.TRS(p0.tmpWorldPosition, p0.worldRotation, p.parentScale);
float3 erestPos = math.mul(em0, new float4(p.localPosition.xyz, 1)).xyz;
float3 ed = erestPos - p.tmpWorldPosition;
float3 eStepElasticity = ed * p.m_Elasticity;
p.tmpWorldPosition += eStepElasticity;
if (stiffness > 0)
{
float len = math.distance(erestPos, p.tmpWorldPosition);
float maxlen = erestLen * (1 - stiffness) * 2;
if (len > maxlen)
{
float3 max = ed * ((len - maxlen) / len);
p.tmpWorldPosition += max;
}
}
}
float3 edd = p0.tmpWorldPosition - p.tmpWorldPosition;
float eleng = math.distance(p0.tmpWorldPosition, p.tmpWorldPosition);
if (eleng > 0)
{
float3 tmp = edd * ((eleng - erestLen) / eleng);
p.tmpWorldPosition += tmp;
}
ParticleInfo[pIdx] = p;
}
}
}
public void DrawBuildingOverlay()
{
//Debug.Log("Drawing Select Overlay");
//float3 worldPos = getMousePosition(); //UtilsInput.GetMouseWorld3DPosition();
//get grid position
int2 gridPos = GridSystem.GETGridPosition(_placeBuildingPos);
//if (gridPos.Equals(placeBuildingGridPos))
// return; //currently this will prevent the first go though, so keep it out
placeBuildingGridPos = gridPos;
_placeBuildingPos = GridSystem.GETWorldPositionCellCenter(gridPos, 0, MapType.current);
_placeBuildingPos.z = zLevel;
_overlayContainer.transform.position = _placeBuildingPos;
//draw overlay
//Debug.Log($"Overlay Possitions: {gridPos}, {placeBuildingPos}");
Cell cell;
canPlaceBuilding = true;
bool canPlaceBuildingCell = true;
for (int x = 0; x < placeBuildingSo.size.x; x++)
{
for (int y = 0; y < placeBuildingSo.size.y; y++)
{
canPlaceBuildingCell = true;
//Debug.Log($"Finding Cell::: {x}, {y}, {placeBuildingGridPos}");
cell = GridSystem.GETCell(
new int2(x + placeBuildingGridPos.x, y + placeBuildingGridPos.y));
if (!cell.canBuild)
{
canPlaceBuilding = false;
canPlaceBuildingCell = false;
}
if (cell.IsDefault())
{
//Debug.Log("############################ No data found");
canPlaceBuilding = false;
canPlaceBuildingCell = false;
}
int index = x + (y * placeBuildingSo.size.x);
//Debug.Log($"INDE#S: {index}");
if (canPlaceBuildingCell)
{
_overlayCells[index].color = positiveColor;
}
else
{
_overlayCells[index].color = negativeColor;
}
}
}
ONCanBuildChanged?.Invoke(canPlaceBuilding);
if (buildButton != null)
{
buildButton.interactable = canPlaceBuilding;
}
//Debug.Log($"Can build: {canPlaceBuilding}");
}
public PlungerMeshBufferElement(float3 v)
{
Value = v;
}
//public GameObject buildingShadowPrefab;
//TESTING
/*
* public GridBuildingItem gridBuildingItem { get {
* return buildingComp.item;
* } }
*/
public void StartBuildSetup(BuildingDataSo buildingSo)
{
//Move to action button menu
menuManager.SetActivePanel(buildActionButtonMenuId);
//create our objects
_overlayContainer = new GameObject("Building Overlay Container");
GameObject go;
float2 cellSize = GridSystem.GETCellSize();
_overlayCells = new SpriteRenderer[buildingSo.size.x * buildingSo.size.y];
for (int x = 0; x < buildingSo.size.x; x++)
{
for (int y = 0; y < buildingSo.size.y; y++)
{
int index = x + (y * buildingSo.size.x);
_overlayCells[index] = Instantiate(overlayPrefab, _overlayContainer.transform)
.GetComponent <SpriteRenderer>();
_overlayCells[index].transform.position = new float3(
x * cellSize.x,
y * cellSize.y, 0);
}
}
placeBuilding = true;
placeBuildingSo = buildingSo;
//we go thourgh this process to snap to grid
_placeBuildingPos = GETMiddleScreenPosition();
placeBuildingGridPos = GridSystem.GETGridPosition(_placeBuildingPos);
_placeBuildingPos = GridSystem.GETWorldPosition(placeBuildingGridPos, 0, MapType.current);
_placeBuildingInitialPos = _placeBuildingPos;
_placeBuildingPos.z = zLevel;
_overlayContainer.transform.position = _placeBuildingPos;
/// get the middle closes cell pos.....
placeBuildingGridPos = GridSystem.GETGridPosition(_placeBuildingPos);
//BUILD ITEM
BuildingItem data = new BuildingItem
{
pos = placeBuildingGridPos,
typeId = buildingSo.typeId,
rotation = 0,
mapType = MapType.current,
stage = BuildingStage.placingStage
};
buildingComp = BuildingComp.PlaceBuilding(buildingSo, data, _overlayContainer.transform);
buildingComp.transform.localPosition = Vector3.zero; //buildingSO.placementOffset;
/*
* buildingPrefab = new GameObject(buildingSO.buildingName);
* buildingPrefab.transform.position = placeBuildingPos; // middle closest cell
* buildingComp = buildingPrefab.AddComponent<BuildingComp>();
* buildingComp.buildingSO = buildingSO;
*
* buildingComp.Init(data,buildingSO);
*/
//buildingShadowPrefab = Instantiate(buildingSO.clearPrefab);
//buildingShadowPrefab.transform.position = placeBuildingPos;
Debug.Log($"Started building process::: {_placeBuildingPos}");
DrawBuildingOverlay();
//buildingGridSize = buildingSize;
}
// Calculate the eigenvectors and eigenvalues of a symmetric 3x3 matrix
public static void DiagonalizeSymmetricApproximation(float3x3 a, out float3x3 eigenVectors, out float3 eigenValues)
{
float GetMatrixElement(float3x3 m, int row, int col)
{
switch (col)
{
case 0: return(m.c0[row]);
case 1: return(m.c1[row]);
case 2: return(m.c2[row]);
default: UnityEngine.Assertions.Assert.IsTrue(false); return(0.0f);
}
}
void SetMatrixElement(ref float3x3 m, int row, int col, float x)
{
switch (col)
{
case 0: m.c0[row] = x; break;
case 1: m.c1[row] = x; break;
case 2: m.c2[row] = x; break;
default: UnityEngine.Assertions.Assert.IsTrue(false); break;
}
}
eigenVectors = float3x3.identity;
float epsSq = 1e-14f * (math.lengthsq(a.c0) + math.lengthsq(a.c1) + math.lengthsq(a.c2));
const int maxIterations = 10;
for (int iteration = 0; iteration < maxIterations; iteration++)
{
// Find the row (p) and column (q) of the off-diagonal entry with greater magnitude
int p = 0, q = 1;
{
float maxEntry = math.abs(a.c1[0]);
float mag02 = math.abs(a.c2[0]);
float mag12 = math.abs(a.c2[1]);
if (mag02 > maxEntry)
{
maxEntry = mag02;
p = 0;
q = 2;
}
if (mag12 > maxEntry)
{
maxEntry = mag12;
p = 1;
q = 2;
}
// Terminate if it's small enough
if (maxEntry * maxEntry < epsSq)
{
break;
}
}
// Calculate jacobia rotation
float3x3 j = float3x3.identity;
{
float apq = GetMatrixElement(a, p, q);
float tau = (GetMatrixElement(a, q, q) - GetMatrixElement(a, p, p)) / (2.0f * apq);
float t = math.sqrt(1.0f + tau * tau);
if (tau > 0.0f)
{
t = 1.0f / (tau + t);
}
else
{
t = 1.0f / (tau - t);
}
float c = math.rsqrt(1.0f + t * t);
float s = t * c;
SetMatrixElement(ref j, p, p, c);
SetMatrixElement(ref j, q, q, c);
SetMatrixElement(ref j, p, q, s);
SetMatrixElement(ref j, q, p, -s);
}
// Rotate a
a = math.mul(math.transpose(j), math.mul(a, j));
eigenVectors = math.mul(eigenVectors, j);
}
eigenValues = new float3(a.c0.x, a.c1.y, a.c2.z);
}
private void Start()
{
Position = transform.position;
}
public static int IndexOfMaxComponent(float3 v) => v.x > v.y ? ((v.x > v.z) ? 0 : 2) : ((v.y > v.z) ? 1 : 2);
public static lineseg transform(lineseg prim, float3 position, Quaternion rotation)
{
prim.start = rotation * prim.start + (Vector3)position;
prim.end = rotation * prim.end + (Vector3)position;
return(prim);
}
public static float Dotxyz1(float4 lhs, float3 rhs) => math.dot(lhs, new float4(rhs, 1));
public VehicleComponent(uint id, int currentid, float speed, float3 direction, float segpos, float dir, float3 position, int lane, float hitDistAhead)
{
Value = new VehicleData(id, currentid, speed, direction, segpos, dir, position, lane, hitDistAhead);
}
internal void SetPosition(int gameobjectID, int poolID, float3 position)
{
_transformAccessArray[poolID][_instancesMap[poolID].sparse[gameobjectID]].position = position;
}
void UpdateMeshFromSplineGraph()
{
Mesh mesh = meshFilter.sharedMesh;
if (mesh == null)
{
mesh = new Mesh();
}
if (radialEdgeCount <= 0)
{
// TODO: Cleanup case when radialEdgeCount == 0 due to user still editing into inspector field.
// This should be handled with a delayed int field.
return;
}
var splineGraph = (splineGraphComponent != null)
? splineGraphComponent.GetSplineGraph()
: splineGraphManager.GetSplineGraph();
// First, go through and compute the number of vertex ring subdivisions required to represent the spline graph based on curvature.
Int16 vertexIsValidCount = splineGraph.ComputeVertexIsValidCount();
Int16 edgeIsValidCount = splineGraph.ComputeEdgeIsValidCount();
int[] edgeSubdivisionIndex = new int[splineGraph.edgePoolChildren.count];
int[] edgeSubdivisionCount = new int[splineGraph.edgePoolChildren.count];
int meshSubdivisionCountTotal = 0;
int meshRingCountTotal = 0;
for (Int16 edgeIndex = 0; edgeIndex < splineGraph.edgePoolChildren.count; ++edgeIndex)
{
DirectedEdge edge = splineGraph.edgePoolChildren.data[edgeIndex];
if (edge.IsValid() == 0)
{
continue;
}
float splineLength = splineGraph.payload.edgeLengths.data[edgeIndex];
int subdivisionCount = math.max(1, (int)math.floor(subdivisionsPerMeter * splineLength + 0.5f));
int ringCount = subdivisionCount + 1;
edgeSubdivisionIndex[edgeIndex] = meshSubdivisionCountTotal;
edgeSubdivisionCount[edgeIndex] = subdivisionCount;
meshSubdivisionCountTotal += subdivisionCount;
meshRingCountTotal += ringCount;
}
// TODO: Calculate counts.
int meshVertexCount = meshRingCountTotal * radialEdgeCount;
Vector3[] vertices = new Vector3[meshVertexCount];
Vector2[] uvs = new Vector2[meshVertexCount];
Vector3[] normals = new Vector3[meshVertexCount];
Color[] colors = new Color[meshVertexCount];
int[] triangles = new int[meshVertexCount * 6];
int meshVertexIndex = 0;
int meshTriangleIndex = 0;
for (Int16 edgeIndex = 0; edgeIndex < splineGraph.edgePoolChildren.count; ++edgeIndex)
{
DirectedEdge edge = splineGraph.edgePoolChildren.data[edgeIndex];
if (edge.IsValid() == 0)
{
continue;
}
Int16 vertexIndexChild = splineGraph.edgePoolChildren.data[edgeIndex].vertexIndex;
Int16 vertexIndexParent = splineGraph.edgePoolParents.data[edgeIndex].vertexIndex;
SplineMath.Spline spline = splineGraph.payload.edgeParentToChildSplines.data[edgeIndex];
float splineLength = splineGraph.payload.edgeLengths.data[edgeIndex];
quaternion rotationParent = splineGraph.payload.rotations.data[vertexIndexParent];
quaternion rotationChild = splineGraph.payload.rotations.data[vertexIndexChild];
SplineMath.Spline splineLeash = splineGraph.payload.edgeParentToChildSplinesLeashes.data[edgeIndex];
// Find neighboring edge (if it exists) for use in CSG style operation against current one to handle intersections in branching region.
DirectedVertex vertexParent = splineGraph.vertices.data[vertexIndexParent];
Debug.Assert(vertexParent.IsValid() == 1);
DirectedVertex vertexChild = splineGraph.vertices.data[vertexIndexChild];
Debug.Assert(vertexChild.IsValid() == 1);
int edgeSubdivisionCurrentCount = edgeSubdivisionCount[edgeIndex];
for (int s = 0; s <= edgeSubdivisionCurrentCount; ++s)
{
float t = (float)s / (float)edgeSubdivisionCurrentCount;
// Debug.Log("s = " + s + ", sCount = " + edgeSubdivisionCurrentCount + ", t = " + t);
float vNormalized = t;
if (s > 0)
{
// Compute the relative distance we have traveled between our current edge ring and previous.
SplineMath.ComputeSplitAtT(out SplineMath.Spline s00, out SplineMath.Spline s01, spline, t);
vNormalized = SplineMath.ComputeLengthEstimate(s00, 1e-5f) / splineLength;
}
float3 positionOnSpline = SplineMath.EvaluatePositionFromT(spline, t);
quaternion rotationOnSpline = SplineMath.EvaluateRotationWithRollFromT(spline, rotationParent, rotationChild, t);
// float2 leashMaxOS = math.lerp(leashParent, leashChild, t);
float2 leashMaxOS = SplineMath.EvaluatePositionFromT(splineLeash, t).xy;
// Generate radial ring of triangles
if (s < edgeSubdivisionCurrentCount)
{
for (int v = 0, vLen = radialEdgeCount; v < vLen; ++v)
{
triangles[meshTriangleIndex + v * 6 + 0] = meshVertexIndex + ((v + 0) % radialEdgeCount) + (0 * radialEdgeCount);
triangles[meshTriangleIndex + v * 6 + 1] = meshVertexIndex + ((v + 0) % radialEdgeCount) + (1 * radialEdgeCount);
triangles[meshTriangleIndex + v * 6 + 2] = meshVertexIndex + ((v + 1) % radialEdgeCount) + (1 * radialEdgeCount);
triangles[meshTriangleIndex + v * 6 + 3] = meshVertexIndex + ((v + 1) % radialEdgeCount) + (1 * radialEdgeCount);
triangles[meshTriangleIndex + v * 6 + 4] = meshVertexIndex + ((v + 1) % radialEdgeCount) + (0 * radialEdgeCount);
triangles[meshTriangleIndex + v * 6 + 5] = meshVertexIndex + ((v + 0) % radialEdgeCount) + (0 * radialEdgeCount);
}
meshTriangleIndex += radialEdgeCount * 6;
}
// Generate radial ring of vertices.
// bool ringIntersectsSibling = false;
for (int v = 0; v < radialEdgeCount; ++v)
{
float thetaNormalized = (float)v / (float)radialEdgeCount;
float theta = thetaNormalized * 2.0f * math.PI;
float2 vertexOffsetOS = new float2(
math.cos(theta),
math.sin(theta)
) * leashMaxOS;// * radius;
float3 vertexOffsetWS = math.mul(rotationOnSpline, new float3(vertexOffsetOS, 0.0f));
float3 vertexPositionWS = positionOnSpline + vertexOffsetWS;
float vertexIntersectionSignedDistanceMin = float.MaxValue;
{
for (Int16 edgeIndexSibling = vertexParent.childHead; edgeIndexSibling != -1; edgeIndexSibling = splineGraph.edgePoolChildren.data[edgeIndexSibling].next)
{
DirectedEdge edgeSibling = splineGraph.edgePoolChildren.data[edgeIndexSibling];
Debug.Assert(edgeSibling.IsValid() == 1);
if (edgeIndexSibling == edgeIndex)
{
// Ignore ourselves.
continue;
}
// Found our sibling edge. Only use the first one, as we only currently support CSG against a single branch.
Int16 siblingVertexIndexChild = edgeSibling.vertexIndex;
Debug.Assert(siblingVertexIndexChild != -1);
Int16 siblingVertexIndexParent = splineGraph.edgePoolParents.data[edgeIndexSibling].vertexIndex;
Debug.Assert(siblingVertexIndexParent != -1);
SplineMath.Spline splineSibling = splineGraph.payload.edgeParentToChildSplines.data[edgeIndexSibling];
SplineMath.Spline splineLeashSibling = splineGraph.payload.edgeParentToChildSplinesLeashes.data[edgeIndexSibling];
quaternion siblingRotationParent = splineGraph.payload.rotations.data[siblingVertexIndexParent];
quaternion siblingRotationChild = splineGraph.payload.rotations.data[siblingVertexIndexChild];
SplineMath.FindTFromClosestPointOnSpline(out float siblingClosestT, out float siblingClosestDistance, vertexPositionWS, splineSibling);
float3 siblingPositionOnSpline = SplineMath.EvaluatePositionFromT(splineSibling, siblingClosestT);
quaternion siblingRotationOnSpline = SplineMath.EvaluateRotationWithRollFromT(splineSibling, siblingRotationParent, siblingRotationChild, siblingClosestT);
float2 siblingLeashMaxOS = SplineMath.EvaluatePositionFromT(splineLeashSibling, siblingClosestT).xy;
float vertexIntersectionSignedDistance = math.length(math.mul(math.inverse(siblingRotationOnSpline), vertexPositionWS - siblingPositionOnSpline).xy / siblingLeashMaxOS) - 1.0f;
vertexIntersectionSignedDistanceMin = math.min(vertexIntersectionSignedDistanceMin, vertexIntersectionSignedDistance);
}
for (Int16 edgeIndexSibling = vertexChild.parentHead; edgeIndexSibling != -1; edgeIndexSibling = splineGraph.edgePoolParents.data[edgeIndexSibling].next)
{
DirectedEdge edgeSibling = splineGraph.edgePoolChildren.data[edgeIndexSibling];
Debug.Assert(edgeSibling.IsValid() == 1);
if (edgeIndexSibling == edgeIndex)
{
// Ignore ourselves.
continue;
}
// Found our sibling edge. Only use the first one, as we only currently support CSG against a single branch.
Int16 siblingVertexIndexParent = edgeSibling.vertexIndex;
Debug.Assert(siblingVertexIndexParent != -1);
Int16 siblingVertexIndexChild = splineGraph.edgePoolChildren.data[edgeIndexSibling].vertexIndex;
Debug.Assert(siblingVertexIndexChild != -1);
SplineMath.Spline splineSibling = splineGraph.payload.edgeParentToChildSplines.data[edgeIndexSibling];
SplineMath.Spline splineLeashSibling = splineGraph.payload.edgeParentToChildSplinesLeashes.data[edgeIndexSibling];
quaternion siblingRotationParent = splineGraph.payload.rotations.data[siblingVertexIndexParent];
quaternion siblingRotationChild = splineGraph.payload.rotations.data[siblingVertexIndexChild];
SplineMath.FindTFromClosestPointOnSpline(out float siblingClosestT, out float siblingClosestDistance, vertexPositionWS, splineSibling);
float3 siblingPositionOnSpline = SplineMath.EvaluatePositionFromT(splineSibling, siblingClosestT);
quaternion siblingRotationOnSpline = SplineMath.EvaluateRotationWithRollFromT(splineSibling, siblingRotationParent, siblingRotationChild, siblingClosestT);
float2 siblingLeashMaxOS = SplineMath.EvaluatePositionFromT(splineLeashSibling, siblingClosestT).xy;
float vertexIntersectionSignedDistance = math.length(math.mul(math.inverse(siblingRotationOnSpline), vertexPositionWS - siblingPositionOnSpline).xy / siblingLeashMaxOS) - 1.0f;
vertexIntersectionSignedDistanceMin = math.min(vertexIntersectionSignedDistanceMin, vertexIntersectionSignedDistance);
}
}
vertices[meshVertexIndex] = vertexPositionWS;
uvs[meshVertexIndex] = new float2(
thetaNormalized,
vNormalized * splineLength * uvScale // TODO: Gotta figure out propogation of UVs.
);
normals[meshVertexIndex] = math.normalize(vertexOffsetWS);
float vertexIntersectionDistanceFade = math.smoothstep(vertexIntersectionSignedDistanceFadeMin, vertexIntersectionSignedDistanceFadeMax, vertexIntersectionSignedDistanceMin);
colors[meshVertexIndex] = new Color(vertexIntersectionDistanceFade, vertexIntersectionDistanceFade, vertexIntersectionDistanceFade, vertexIntersectionDistanceFade);
++meshVertexIndex;
}
}
}
// Trim arrays to final size.
Vector3[] verticesTrimmed = new Vector3[meshVertexIndex];
Vector2[] uvsTrimmed = new Vector2[meshVertexIndex];
Vector3[] normalsTrimmed = new Vector3[meshVertexIndex];
Color[] colorsTrimmed = new Color[meshVertexIndex];
int[] trianglesTrimmed = new int[meshTriangleIndex];
Array.Copy(vertices, verticesTrimmed, meshVertexIndex);
Array.Copy(uvs, uvsTrimmed, meshVertexIndex);
Array.Copy(normals, normalsTrimmed, meshVertexIndex);
Array.Copy(colors, colorsTrimmed, meshVertexIndex);
Array.Copy(triangles, trianglesTrimmed, meshTriangleIndex);
// Finally assign back data (causes GC allocs).
mesh.Clear();
mesh.vertices = verticesTrimmed;
mesh.uv = uvsTrimmed;
mesh.normals = normalsTrimmed;
mesh.colors = colorsTrimmed;
mesh.triangles = trianglesTrimmed;
meshFilter.sharedMesh = mesh;
MeshCollider meshCollider = meshFilter.gameObject.GetComponent <MeshCollider>();
if (meshCollider != null)
{
meshCollider.sharedMesh = mesh;
}
}
public TileInfo(float3 screenPosition, byte variant)
{
ScreenPosition = screenPosition;
Variant = variant;
}
/// <summary>
/// Intersects a plane with a line
/// </summary>
/// <param name="planeOrigin">The origin of the plane</param>
/// <param name="planeNormal">The normal of the plane</param>
/// <param name="lineOrigin">The origin of the line</param>
/// <param name="lineDirection">The direction of the line</param>
/// <param name="intersectionPoint">The point where the line hit the plane (if any)</param>
/// <returns>The collision result</returns>
public static PlaneLineIntersectionResult PlaneLineIntersection(float3 planeOrigin, float3 planeNormal, float3 lineOrigin,
float3 lineDirection, out float3 intersectionPoint)
{
planeNormal = math.normalize(planeNormal);
lineDirection = math.normalize(lineDirection);
if (math.dot(planeNormal, lineDirection) == 0)
{
intersectionPoint = float3.zero;
return (planeOrigin - lineOrigin).Equals(float3.zero) ? PlaneLineIntersectionResult.ParallelInsidePlane : PlaneLineIntersectionResult.NoHit;
}
float d = math.dot(planeOrigin, -planeNormal);
float t = -(d + lineOrigin.z * planeNormal.z + lineOrigin.y * planeNormal.y + lineOrigin.x * planeNormal.x) / (lineDirection.z * planeNormal.z + lineDirection.y * planeNormal.y + lineDirection.x * planeNormal.x);
intersectionPoint = lineOrigin + t * lineDirection;
return PlaneLineIntersectionResult.OneHit;
}
private Entity SpawnCamera(int id, float3 spawnPosition, quaternion spawnRotation, Entity attachEntity, CameraData cameraData)
{
if (cameraData.isRenderTexture == 0)
{
if (Camera.main)
{
//Camera.main.gameObject.tag = "Untagged";
Camera.main.gameObject.SetActive(false);
if (canvas)
{
canvas.SetActive(false);
}
}
}
else
{
if (canvas)
{
canvas.SetActive(true);
}
}
//AudioManager.instance.SpawnMonsterSpawnSound(spawnPosition);
cameraDatas.Add(id, cameraData);
GameObject cameraObject = SpawnCameraGameObject(id, cameraData, spawnPosition, spawnRotation);
cameraObjects.Add(id, cameraObject);
var cameraEntity = AddECSComponents(cameraObject, id, attachEntity, cameraData);
Camera camera = cameraObject.GetComponent <Camera>();
if (World.EntityManager.Exists(attachEntity))
{
//Entity charaterEntity = characterSpawnSystem.characters[followID];
if (cameraData.cameraType == ((byte)CameraDataType.ThirdPerson))
{
Translation characterTranslation = World.EntityManager.GetComponentData <Translation>(attachEntity);
Rotation characterRotation = World.EntityManager.GetComponentData <Rotation>(attachEntity);
spawnPosition = characterTranslation.Value + new float3(0, cameraData.followCameraData.cameraAddition.y, 0);
spawnPosition += math.rotate(characterRotation.Value, new float3(0, 0, cameraData.followCameraData.cameraAddition.z));
Quaternion newRotation = new Quaternion(characterRotation.Value.value.x,
characterRotation.Value.value.y, characterRotation.Value.value.z, characterRotation.Value.value.w);
float3 newRotation2 = newRotation.eulerAngles;
newRotation2.x = cameraData.followCameraData.cameraRotation.x;
spawnRotation = Quaternion.Euler(newRotation2);
}
if (World.EntityManager.HasComponent <CameraLink>(attachEntity))
{
CameraLink cameraLink = World.EntityManager.GetComponentData <CameraLink>(attachEntity);
cameraLink.camera = cameraEntity;
cameraLink.fov = camera.fieldOfView;
World.EntityManager.SetComponentData(attachEntity, cameraLink);
}
}
else
{
World.EntityManager.AddComponentData(cameras[id], new CameraLink
{
camera = cameraEntity,
fov = camera.fieldOfView
});
}
// Setup camera object
if (cameraData.isRenderTexture == 1)
{
CreateRenderTexture(camera, cameraData, id);
}
else
{
Camera.SetupCurrent(camera);
camera.tag = "MainCamera";
}
Debug.Log("Spawned camera: " + id);
ResizeRenderTextures();
return(cameraEntity);
}
public static unsafe void CollideAndIntegrate(
CharacterControllerStepInput stepInput, float characterMass, bool affectBodies, Collider *collider,
MaxHitsCollector <DistanceHit> distanceHitsCollector, ref NativeArray <ColliderCastHit> castHits, ref NativeArray <SurfaceConstraintInfo> constraints,
ref RigidTransform transform, ref float3 linearVelocity, ref BlockStream.Writer deferredImpulseWriter)
{
// Copy parameters
float deltaTime = stepInput.DeltaTime;
float3 gravity = stepInput.Gravity;
float3 up = stepInput.Up;
PhysicsWorld world = stepInput.World;
float remainingTime = deltaTime;
float3 lastDisplacement = linearVelocity * remainingTime;
float3 newPosition = transform.pos;
quaternion orientation = transform.rot;
float3 newVelocity = linearVelocity;
float maxSlopeCos = math.cos(stepInput.MaxSlope);
// Iterate over hits and create constraints from them
int numDistanceConstraints = 0;
for (int hitIndex = 0; hitIndex < distanceHitsCollector.NumHits; hitIndex++)
{
DistanceHit hit = distanceHitsCollector.AllHits[hitIndex];
CreateConstraintFromHit(world, gravity, deltaTime, hit.RigidBodyIndex, hit.ColliderKey, hit.Position,
hit.SurfaceNormal, hit.Distance, false, out SurfaceConstraintInfo constraint);
// Check if max slope plane is required
float verticalComponent = math.dot(constraint.Plane.Normal, up);
bool shouldAddPlane = verticalComponent > SimplexSolver.c_SimplexSolverEpsilon && verticalComponent < maxSlopeCos;
if (shouldAddPlane)
{
AddMaxSlopeConstraint(up, ref constraint, ref constraints, ref numDistanceConstraints);
}
// Add original constraint to the list
constraints[numDistanceConstraints++] = constraint;
}
const float timeEpsilon = 0.000001f;
for (int i = 0; i < stepInput.MaxIterations && remainingTime > timeEpsilon; i++)
{
int numConstraints = numDistanceConstraints;
float3 gravityMovement = gravity * remainingTime * remainingTime * 0.5f;
// Then do a collider cast (but not in first iteration)
if (i > 0)
{
float3 displacement = lastDisplacement + gravityMovement;
MaxHitsCollector <ColliderCastHit> collector = new MaxHitsCollector <ColliderCastHit>(1.0f, ref castHits);
ColliderCastInput input = new ColliderCastInput()
{
Collider = collider,
Orientation = orientation,
Start = newPosition,
End = newPosition + displacement,
};
world.CastCollider(input, ref collector);
// Iterate over hits and create constraints from them
for (int hitIndex = 0; hitIndex < collector.NumHits; hitIndex++)
{
ColliderCastHit hit = collector.AllHits[hitIndex];
bool found = false;
for (int distanceHitIndex = 0; distanceHitIndex < distanceHitsCollector.NumHits; distanceHitIndex++)
{
DistanceHit dHit = distanceHitsCollector.AllHits[distanceHitIndex];
if (dHit.RigidBodyIndex == hit.RigidBodyIndex &&
dHit.ColliderKey.Equals(hit.ColliderKey))
{
found = true;
break;
}
}
// Skip duplicate hits
if (!found)
{
CreateConstraintFromHit(world, gravity, deltaTime, hit.RigidBodyIndex, hit.ColliderKey, hit.Position, hit.SurfaceNormal,
hit.Fraction * math.length(lastDisplacement), false, out SurfaceConstraintInfo constraint);
// Check if max slope plane is required
float verticalComponent = math.dot(constraint.Plane.Normal, up);
bool shouldAddPlane = verticalComponent > SimplexSolver.c_SimplexSolverEpsilon && verticalComponent < maxSlopeCos;
if (shouldAddPlane)
{
AddMaxSlopeConstraint(up, ref constraint, ref constraints, ref numConstraints);
}
// Add original constraint to the list
constraints[numConstraints++] = constraint;
}
}
}
// Solve
float3 prevVelocity = newVelocity;
float3 prevPosition = newPosition;
SimplexSolver.Solve(world, remainingTime, up, numConstraints, ref constraints, ref newPosition, ref newVelocity, out float integratedTime);
// Apply impulses to hit bodies
if (affectBodies)
{
CalculateAndStoreDeferredImpulses(stepInput, characterMass, prevVelocity, numConstraints, ref constraints, ref deferredImpulseWriter);
}
float3 newDisplacement = newPosition - prevPosition;
// Check if we can walk to the position simplex solver has suggested
MaxHitsCollector <ColliderCastHit> newCollector = new MaxHitsCollector <ColliderCastHit>(1.0f, ref castHits);
int newContactIndex = -1;
// If simplex solver moved the character we need to re-cast to make sure it can move to new position
if (math.lengthsq(newDisplacement) > SimplexSolver.c_SimplexSolverEpsilon)
{
float3 displacement = newDisplacement + gravityMovement;
ColliderCastInput input = new ColliderCastInput()
{
Collider = collider,
Orientation = orientation,
Start = prevPosition,
End = prevPosition + displacement
};
world.CastCollider(input, ref newCollector);
for (int hitIndex = 0; hitIndex < newCollector.NumHits; hitIndex++)
{
ColliderCastHit hit = newCollector.AllHits[hitIndex];
bool found = false;
for (int constraintIndex = 0; constraintIndex < numConstraints; constraintIndex++)
{
SurfaceConstraintInfo constraint = constraints[constraintIndex];
if (constraint.RigidBodyIndex == hit.RigidBodyIndex &&
constraint.ColliderKey.Equals(hit.ColliderKey))
{
found = true;
break;
}
}
if (!found)
{
newContactIndex = hitIndex;
break;
}
}
}
// Move character along the newDisplacement direction until it reaches this new contact
if (newContactIndex >= 0)
{
ColliderCastHit newContact = newCollector.AllHits[newContactIndex];
Assert.IsTrue(newContact.Fraction >= 0.0f && newContact.Fraction <= 1.0f);
integratedTime *= newContact.Fraction;
newPosition = prevPosition + newDisplacement * newContact.Fraction;
}
remainingTime -= integratedTime;
// Remember last displacement for next iteration
lastDisplacement = newVelocity * remainingTime;
}
// Write back position and velocity
transform.pos = newPosition;
linearVelocity = newVelocity;
}
public static void CalculateTangents(float3 normal, out float3 tangent, out float3 binormal)
{
tangent = math.normalizesafe(math.cross(normal, ClosestTangentAxis(normal)));
binormal = math.normalizesafe(math.cross(normal, tangent));
}
public VehicleData(uint id, int currentid, float speed, float3 forward, float segpos, float dir, float3 position, int lane, float hitDistAhead)
{
this.Id = id;
this.SegId = currentid;
this.Speed = speed;
this.Forward = forward;
this.CurrentSegPos = segpos;
this.Direction = dir;
this.Position = position;
this.Lane = lane;
this.HitDistAhead = hitDistAhead;
}
