public void Execute(PhysxScene scene)
{
if (_newShape == null)
{
if (_parent.Disposed || _child.Disposed) return;
_child.Parent = _parent;
//we need to remesh the prim and then free the old shapes
_child.BeginDelayCommands(this);
scene.MeshingStageImpl.QueueForMeshing(_child.SOPName, _child.Shape, _child.Size,
Meshing.MeshingStage.SCULPT_MESH_LOD, _parent.IsPhysical, null, false,
delegate(PhysicsShape meshedShape)
{
_newShape = meshedShape;
scene.QueueCommand(this);
}
);
}
else
{
_parent.LinkPrimAsChildSync(_newShape, _child, _localPos, _localRot, false);
_child.EndDelayCommands();
}
}
public MasslessItem(Texture2D t, PhysicsShape shape, Vector2 position, World w)
: base(position, w, t.Width, t.Height)
{
texture = t;
body.BodyType = BodyType.Static;
body.Position = position;
switch (shape)
{
case PhysicsShape.Rectangle:
fixture = FixtureFactory.CreateRectangle(
texture.Width,
texture.Height,
0.0f,
Vector2.Zero,
body);
break;
}
//fixture.CollisionFilter.IgnoreCollisionWith();
fixture.OnCollision += new OnCollisionEventHandler(this.OnCollision);
w.AddBody(body);
//drawOrigin = new Vector2(texture.Width / 2, texture.Height / 2);
//drawRectangle = new Rectangle(0, 0, texture.Width, texture.Height);
}
public void Execute(PhysxScene scene)
{
if (_newShape == null)
{
if (_parent.Disposed || _child.Disposed)
{
return;
}
_child.Parent = _parent;
//we need to remesh the prim and then free the old shapes
_child.BeginDelayCommands(this);
scene.MeshingStageImpl.QueueForMeshing(_child.SOPName, _child.Shape, _child.Size,
Meshing.MeshingStage.SCULPT_MESH_LOD, _parent.IsPhysical, null, false,
delegate(PhysicsShape meshedShape)
{
_newShape = meshedShape;
scene.QueueCommand(this);
}
);
}
else
{
_parent.LinkPrimAsChildSync(_newShape, _child, _localPos, _localRot, false);
_child.EndDelayCommands();
}
}
public void Write(AssetWriter writer)
{
Sprites.Write(writer);
if (SpriteMetaData.HasOutline(writer.Version))
{
Outline.Write(writer);
}
if (SpriteMetaData.HasPhysicsShape(writer.Version))
{
PhysicsShape.Write(writer);
}
if (SpriteMetaData.HasBones(writer.Version))
{
Bones.Write(writer);
writer.Write(SpriteID);
}
if (SpriteMetaData.HasInternalID(writer.Version))
{
writer.Write(InternalID);
}
if (SpriteMetaData.HasBones(writer.Version))
{
Vertices.Write(writer);
Indices.Write(writer);
Edges.Write(writer);
writer.AlignStream();
Weights.Write(writer);
writer.AlignStream();
}
if (HasSecondaryTextures(writer.Version))
{
SecondaryTextures.Write(writer);
}
}
private void Awake()
{
_collider = GetComponent <Collider>();
_collider.isTrigger = true;
_boxCollider = null;
_sphereCollider = null;
_capsuleCollider = null;
switch (_collider)
{
case BoxCollider box:
_boxCollider = box;
_shape = PhysicsShape.Box;
break;
case SphereCollider sphere:
_sphereCollider = sphere;
_shape = PhysicsShape.Sphere;
break;
case CapsuleCollider capsule:
_capsuleCollider = capsule;
_shape = PhysicsShape.Capsule;
break;
default:
_shape = PhysicsShape.Invalid;
break;
}
}
/// <summary>
/// function checks if any collision occured and implements all calculations.
/// </summary>
/// <param name="shape"></param>
internal void CollisionEffect(PhysicsShape shape)
{
if (IsCollideWithBottomBorder(shape, ScreenHeight))
{
Point point = shape.BottomVertex;
point.Y = ScreenHeight;
shape.BottomVertex = point;
SetVelocityBorderHit(shape, false);
}
if (IsCollideWithLeftBorder(shape, 0))
{
Point point = shape.LeftVertex;
point.X = 1;
shape.LeftVertex = point;
SetVelocityBorderHit(shape, true);
}
if (IsCollideWithRightBorder(shape, ScreenWidth))
{
Point point = shape.RightVertex;
point.X = ScreenWidth - 1;
shape.RightVertex = point;
SetVelocityBorderHit(shape, true);
}
}
public MasslessItem(Texture2D t, PhysicsShape shape, Vector2 position, World w)
: base(position, w, t.Width, t.Height)
{
texture = t;
body.BodyType = BodyType.Static;
body.Position = position;
switch (shape)
{
case PhysicsShape.Rectangle:
fixture = FixtureFactory.CreateRectangle(
texture.Width,
texture.Height,
0.0f,
Vector2.Zero,
body);
break;
}
//fixture.CollisionFilter.IgnoreCollisionWith();
fixture.OnCollision += new OnCollisionEventHandler(this.OnCollision);
w.AddBody(body);
//drawOrigin = new Vector2(texture.Width / 2, texture.Height / 2);
//drawRectangle = new Rectangle(0, 0, texture.Width, texture.Height);
}
void _shapeCache_OnShapeNeedsFreeing(PhysicsShape shape)
{
if (OnShapeNeedsFreeing != null)
{
OnShapeNeedsFreeing(shape);
}
}
// CONSTRUCTORS ----------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="Crystallography.WildCardCrystallonEntity"/> class.
/// </summary>
/// <param name='pScene'>
/// The Parent Scene.
/// </param>
/// <param name='pGamePhysics'>
/// Instance of <c>GamePhysics</c>
/// </param>
/// <param name='pTextureInfo'>
/// <see cref="Sce.PlayStation.HighLevel.GameEngine2D.Base.TextureInfo"/>
/// </param>
/// <param name='pTileIndex2D'>
/// <see cref="Sce.PlayStation.HighLevel.GameEngine2D.Base.Vector2i"/>
/// </param>
/// <param name='pShape'>
/// <see cref="Sce.PlayStation.HighLevel.Physics2D.PhysicsShape"/>
/// </param>
public WildCardCrystallonEntity(Scene pScene, GamePhysics pGamePhysics, int pId, PhysicsShape pShape)
: base(pScene, pGamePhysics, pId,
// pTextureInfo, pTileIndex2D,
pShape)
{
Wild = true;
Flash ();
}
public void AddObject(GameObject gameObject, float mass, PhysicsShape physicsShape)
{
RigidBodyControl rbc = new RigidBodyControl(mass, physicsShape);
gameObject.AddController(rbc);
world.AddBody(rbc.Body);
rbc.Body.EnableDebugDraw = true;
rbc.Body.DebugDraw(debugDraw);
}
public EntityType(Trajectory t, Drawable draw, PhysicsShape physS, EntityClass pc, BulletEmitter e = null, GraphicsStyle g = null)
{
traj = t;
this.draw = draw;
this.bounds = physS;
this.myClass = pc;
emitter = e;
gs = g;
}
public void AddObject(GameObject gameObject, float mass, PhysicsShape physicsShape)
{
RigidBodyControl rbc = new RigidBodyControl(mass, physicsShape);
gameObject.AddController(rbc);
world.AddBody(rbc.Body);
rbc.Body.EnableDebugDraw = true;
rbc.Body.DebugDraw(debugDraw);
}
public YAMLNode ExportYAML(IExportContainer container)
{
YAMLMappingNode node = new YAMLMappingNode();
node.AddSerializedVersion(GetSerializedVersion(container.Version));
node.Add("sprites", Sprites.ExportYAML(container));
node.Add("outline", Outline.ExportYAML(container));
node.Add("physicsShape", PhysicsShape.ExportYAML(container));
return(node);
}
public BulletStyle MakeStyle(string s, PhysicsShape p, GraphicsStyle sty)
{
BulletStyle ans = (t, path, pc) =>
{
return(new Bullet(t, path, p.MakeDrawable(sty), p, pc, null));
};
savedStyles[s] = ans;
return(ans);
}
private void GenerateBasicShapeAndComplete(MeshingStage meshingStage, ulong meshHash)
{
Tuple <PhysX.Geometry, ShapeType> result = meshingStage.GenerateBasicPhysXShape(Shape);
PhysicsShape phyShape = new PhysicsShape(result.Item1, result.Item2, meshHash);
//basic shapes are not cached
//we are done here, call back to caller
this.CompletedDelegate(phyShape);
}
public BulletStyle MakeStyle(string s, Drawable d, PhysicsShape ps)
{
BulletStyle ans = (t, path, pc) =>
{
return(new Bullet(t, path, d, ps, pc, null));
};
savedStyles[s] = ans;
return(ans);
}
public EntityType ChangeShape(PhysicsShape sh, bool clone = false)
{
EntityType ans = this;
if (clone)
{
ans = new EntityType(this);
}
ans.Shape = sh;
return(ans);
}
internal static Vec3 CalculateCenterOfMass(PhysicsShape body)
{
if ((NativeObject)body == (NativeObject)null)
{
return(Vec3.Zero);
}
Vec3 zero = Vec3.Zero;
float num1 = 0.0f;
int num2 = body.CapsuleCount();
for (int index = 0; index < num2; ++index)
{
CapsuleData data = new CapsuleData();
body.GetCapsule(ref data, index);
Vec3 vec3 = (data.P1 + data.P2) * 0.5f;
float num3 = data.P1.Distance(data.P2);
float num4 = (float)((double)data.Radius * (double)data.Radius * 3.14159274101257 * (1.33333337306976 * (double)data.Radius + (double)num3));
num1 += num4;
zero += vec3 * num4;
}
int num5 = body.SphereCount();
for (int index = 0; index < num5; ++index)
{
SphereData data = new SphereData();
body.GetSphere(ref data, index);
float num3 = 4.18879f * data.Radius * data.Radius * data.Radius;
num1 += num3;
zero += data.Origin * num3;
}
Vec3 vec3_1;
if ((double)num1 > 0.0)
{
vec3_1 = zero / num1;
if ((double)Math.Abs(vec3_1.x) < 0.00999999977648258)
{
vec3_1.x = 0.0f;
}
if ((double)Math.Abs(vec3_1.y) < 0.00999999977648258)
{
vec3_1.y = 0.0f;
}
if ((double)Math.Abs(vec3_1.z) < 0.00999999977648258)
{
vec3_1.z = 0.0f;
}
}
else
{
vec3_1 = Vec3.Zero;
}
return(vec3_1);
}
private static PhysicsShape CreatePhysicsShapeFromTrimeshAndCache(MeshingStage meshingStage, ulong meshHash, PhysX.TriangleMeshGeometry triMesh)
{
PhysicsShape phyShape;
phyShape = new PhysicsShape(triMesh, ShapeType.TriMesh, meshHash);
phyShape.AddRef();
//complex shapes are cached
meshingStage.CacheShape(meshHash, phyShape, ShapeType.TriMesh);
return(phyShape);
}
// CONSTRUCTORS ----------------------------------------------------------
public NodeCrystallonEntity(Scene pScene, GamePhysics pGamePhysics, PhysicsShape pShape = null)
: base(pScene, pGamePhysics)
{
_node = new Node();
if (pShape != null) {
_body = _physics.RegisterPhysicsBody(pShape, 0.1f, 0.01f, _node.Position);
} else {
_body = null;
}
Scheduler.Instance.Schedule(_node, Update, 0, false, 0);
}
private static PhysicsShape CreatePhysicsShapeFromConvexSetAndCache(MeshingStage meshingStage, ulong meshHash, List <PhysX.ConvexMeshGeometry> convexes)
{
PhysicsShape phyShape;
phyShape = new PhysicsShape(convexes, meshHash);
phyShape.Complexity = convexes.Count;
phyShape.AddRef();
//complex shapes are cached
meshingStage.CacheShape(meshHash, phyShape, ShapeType.DecomposedConvexHulls);
return(phyShape);
}
// CONSTRUCTORS --------------------------------------------------------------------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="Crystallography.CardCrystallonEntity"/> class.
/// </summary>
/// <param name='pScene'>
/// The Parent Scene.
/// </param>
/// <param name='pGamePhysics'>
/// Instance of <c>GamePhysics</c>
/// </param>
/// <param name='pTextureInfo'>
/// <see cref="Sce.PlayStation.HighLevel.GameEngine2D.Base.TextureInfo"/>
/// </param>
/// <param name='pTileIndex2D'>
/// <see cref="Sce.PlayStation.HighLevel.GameEngine2D.Base.Vector2i"/>
/// </param>
/// <param name='pShape'>
/// <see cref="Sce.PlayStation.HighLevel.Physics2D.PhysicsShape"/>
/// </param>
public CardCrystallonEntity(Scene pScene, GamePhysics pGamePhysics, int pId, PhysicsShape pShape)
: base(pScene, pGamePhysics, pShape)
{
id = pId;
_anim = null;
GlowSprite = null;
Scored = false;
// _sprite.Scale*=CARD_SCALAR;
_sprite.Position = new Vector2(-Width/2, -Height/2);
_keepOnScreenTimer = -1.0f;
setVelocity(DEFAULT_SPEED, GameScene.Random.NextAngle());
}
private static PhysicsShape CreatePhysicsShapeFromSingleConvexAndCache(MeshingStage meshingStage, ulong meshHash, PhysX.ConvexMeshGeometry convex)
{
PhysicsShape phyShape;
phyShape = new PhysicsShape(new List <PhysX.ConvexMeshGeometry> {
convex
}, meshHash, true);
phyShape.AddRef();
//complex shapes are cached
meshingStage.CacheShape(meshHash, phyShape, ShapeType.SingleConvex);
return(phyShape);
}
// CONSTRUCTOR -----------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="Crystallography.GroupCrystallonEntity"/> class.
/// </summary>
/// <param name='pScene'>
/// Instance of the parent scene.
/// </param>
/// <param name='pGamePhysics'>
/// Instance of <c>GamePhysics</c>
/// </param>
/// <param name='pShape'>
/// <see cref="Sce.PlayStation.HighLevel.Physics2D.PhysicsShape"/>
/// </param>
/// <param name='pMaxMembers'>
/// <c>int</c> Maximum allowed population. Probs 3. 0 = no limit.
/// </param>
public GroupCrystallonEntity(Scene pScene, GamePhysics pGamePhysics, PhysicsShape pShape = null,
int pMaxMembers=0, bool pComplete = false)
: base(pScene, pGamePhysics, pShape)
{
_maxMembers = pMaxMembers;
_numMembers = 0;
members = new AbstractCrystallonEntity[_maxMembers];
_pucks = new Node[_maxMembers];
for (int i=0; i < _maxMembers; i++) {
AddPuck(i);
}
complete = pComplete;
}
private void SetVelocityBorderHit(PhysicsShape shape, bool isCollideWithX)
{
if (isCollideWithX)
{
shape.Velocity.X *= (float)1 - Friction;
shape.Velocity.X *= -1;
}
else
{
shape.Velocity.y *= (float)1 - Friction;
shape.Velocity.y *= -1;
}
}
internal void UnrefShape(PhysicsShape shape, bool dynamic)
{
lock (_meshWaitingQueue)
{
_meshWaitingQueue.Enqueue(new UnrefShapeItem
{
Shape = shape,
Dynamic = dynamic
});
Monitor.Pulse(_meshWaitingQueue);
}
}
internal void EntitiyCollision(List <PhysicsShape> entities, PhysicsShape checkedShape)
{
foreach (var s in entities)
{
if (!s.Equals(checkedShape))
{
if (checkedShape is PhysicsCircle && s is PhysicsCircle)
{
CircleCollision((PhysicsCircle)checkedShape, (PhysicsCircle)s);
}
}
}
}
public PrepChildPrimAndLinkCmd(PhysxPrim parent, PhysxPrim child, OpenMetaverse.Vector3 localPos,
OpenMetaverse.Quaternion localRot)
{
Util.ThrowIfNull(parent, "parent");
Util.ThrowIfNull(child, "child");
_parent = parent;
_child = child;
_localPos = localPos;
_localRot = localRot;
_newShape = null;
_affectedPrims = new List<PhysxPrim> { parent, child };
_affectedPrims.AddRange(child.ChildShapes.Keys);
}
public override PhysicsBody CreateBody(PhysicsShape shape, Vector3D initialPosition, float mass,
float restitution)
{
PhysicsBody body = new JitterBody(this, shape, initialPosition, mass, restitution);
bodies.Add(body);
if (float.IsNaN(body.Position.X) || float.IsNaN(body.AngularVelocity.X) ||
float.IsNaN(body.BoundingBox.Min.X) || float.IsNaN(body.BoundingBox.Max.X) ||
float.IsNaN(body.GetOrientation().X))
{
throw new PhysicsBodyIsNotSetUpProperlyMakeSurePositionVelocityAndBoundingBoxAreSet(body);
}
return(body);
}
static public BlockMissionObject DrawFBXMeshMissionObjectAt(Mission mission, Vec3 pos, string filename)
{
// if (prefab == null)
GameEntity prefab = GameEntity.CreateEmpty(mission.Scene, false);
prefab.EntityFlags |= EntityFlags.DontSaveToScene;
//prefab.AddMesh(Mesh.GetFromResource("order_arrow_a"), true);
// prefab.SetVisibilityExcludeParents(true);
if (MeshListByFileName.ContainsKey(filename) == false)
{
MeshListByFileName.Add(filename, CreateMesh(filename));
}
foreach (var mesh in MeshListByFileName[filename])
{
prefab.AddMesh(mesh, false);
}
prefab.RecomputeBoundingBox();
PhysicsShape shape = prefab.GetBodyShape();
// shape.
prefab.AddPhysics(1000, new Vec3(0, 0, 0), null, new Vec3(), new Vec3(), PhysicsMaterial.GetFromIndex(0), false, 0);
GameEntity blockEntity = prefab;
MatrixFrame identity2 = MatrixFrame.Identity;
identity2.origin = pos;
identity2.origin.x += 7.5f;
identity2.origin.z = 7.5f;
identity2.rotation.ApplyScaleLocal(1f);
MatrixFrame frame2 = identity2;
blockEntity.SetFrame(ref frame2);
blockEntity.SetVisibilityExcludeParents(true);
blockEntity.SetAlpha(1f);
blockEntity.CreateAndAddScriptComponent("BlockMissionObject");
BlockMissionObject missionObject = blockEntity.GetFirstScriptOfType <BlockMissionObject>();
mission.AddActiveMissionObject(missionObject);
return(missionObject);
}
public YAMLNode ExportYAML(IExportContainer container)
{
YAMLMappingNode node = new YAMLMappingNode();
node.AddSerializedVersion(GetSerializedVersion(container.Version));
node.Add("name", Name);
node.Add("rect", Rect.ExportYAML(container));
node.Add("alignment", (int)Alignment);
node.Add("pivot", Pivot.ExportYAML(container));
node.Add("border", Border.ExportYAML(container));
node.Add("outline", Outline.ExportYAML(container));
node.Add("physicsShape", PhysicsShape.ExportYAML(container));
node.Add("tessellationDetail", TessellationDetail);
return(node);
}
public Entity(double cTime, Particle pos, Drawable draw, PhysicsShape physS, EntityClass pc, BulletEmitter e = null, GraphicsStyle g = null)
{
this.pc = pc;
ps = physS ?? new Point(pos.Dimension);
CreationTime = cTime;
creation = new GameEvent(cTime, this.Create, this.RewindCreate, this.UndoCreate);
this.pos = pos;
d = draw;
this.e = e;
gs = g;
if (pos != null)
{
this.Time = CreationTime;
}
}
public bool TryGetShape(ulong shapeHash, out PhysicsShape shape)
{
if (this.TryGetActiveShape(shapeHash, out shape))
{
return(true);
}
if (this.TryGetInactiveShape(shapeHash, out shape))
{
this.ReactivateShape(shapeHash, shape);
return(true);
}
shape = null;
return(false);
}
public JitterBody(JitterPhysics physicsManager, PhysicsShape shape, Vector3D initialPosition,
float mass, float restitution)
: base(shape)
{
CreateShape();
RotationMatrix = Matrix.Identity;
jitterBody = new RigidBody(jitterShape)
{
IsStatic = false,
Mass = mass,
Material = { Restitution = restitution },
Position = JitterDatatypesMapping.Convert(ref initialPosition),
Tag = this
};
physicsManager.jitterWorld.AddBody(jitterBody);
}
public PrepChildPrimAndLinkCmd(PhysxPrim parent, PhysxPrim child, OpenMetaverse.Vector3 localPos,
OpenMetaverse.Quaternion localRot)
{
Util.ThrowIfNull(parent, "parent");
Util.ThrowIfNull(child, "child");
_parent = parent;
_child = child;
_localPos = localPos;
_localRot = localRot;
_newShape = null;
_affectedPrims = new List <PhysxPrim> {
parent, child
};
_affectedPrims.AddRange(child.ChildShapes.Keys);
}
public JitterBody(JitterPhysics physicsManager, PhysicsShape shape, Vector3D initialPosition,
float mass, float restitution)
: base(shape)
{
CreateShape();
RotationMatrix = Matrix.Identity;
jitterBody = new RigidBody(jitterShape)
{
IsStatic = false,
Mass = mass,
Material = { Restitution = restitution },
Position = JitterDatatypesMapping.Convert(ref initialPosition),
Tag = this
};
physicsManager.jitterWorld.AddBody(jitterBody);
}
// CONSTRUCTORS----------------------------------------------------------------------------
public SpriteTileCrystallonEntity( Scene pScene, GamePhysics pGamePhysics, PhysicsShape pShape = null)
: base(pScene, pGamePhysics, pShape)
{
// SPRITE STUFF
_orientationIndex = 0;
_patternIndex = 0;
// _sprite = new SpriteTile(pTextureInfo);
_sprite = new SpriteTile();
// _sprite.Scale = _sprite.CalcSizeInPixels();
_node.AddChild(_sprite);
// PHYSICS STUFF
// if (pShape != null) {
// _body = _physics.RegisterPhysicsBody(pShape, 0.1f, 0.01f, _sprite.Position);
// } else {
// _body = null;
// }
// Scheduler.Instance.Schedule(_sprite, Update, 0.0f, false);
}
public YAMLNode ExportYAML(IExportContainer container)
{
YAMLMappingNode node = new YAMLMappingNode();
node.AddSerializedVersion(ToSerializedVersion(container.ExportVersion));
node.Add(NameName, Name);
node.Add(RectName, Rect.ExportYAML(container));
node.Add(AlignmentName, (int)Alignment);
node.Add(PivotName, Pivot.ExportYAML(container));
if (HasBorder(container.ExportVersion))
{
node.Add(BorderName, Border.ExportYAML(container));
}
if (HasOutline(container.ExportVersion))
{
node.Add(OutlineName, Outline.ExportYAML(container));
}
if (HasPhysicsShape(container.ExportVersion))
{
node.Add(PhysicsShapeName, PhysicsShape.ExportYAML(container));
}
if (HasTessellationDetail(container.ExportVersion))
{
node.Add(TessellationDetailName, TessellationDetail);
}
if (HasBones(container.ExportVersion))
{
node.Add(BonesName, Bones.ExportYAML(container));
node.Add(SpriteIDName, SpriteID);
}
if (HasInternalID(container.ExportVersion))
{
node.Add(InternalIDName, InternalID);
}
if (HasBones(container.ExportVersion))
{
node.Add(VerticesName, Vertices.ExportYAML(container));
node.Add(IndicesName, Indices.ExportYAML(true));
node.Add(EdgesName, Edges.ExportYAML(container));
node.Add(WeightsName, Weights.ExportYAML(container));
}
return(node);
}
public void Execute(PhysxScene scene)
{
if (_newPrimaryShape == null)
{
if (_actor.Disposed)
{
return;
}
_actor.BeginDelayCommands(this);
Meshing.RemeshActorWorker worker = new Meshing.RemeshActorWorker(scene, _actor, _vdActive || _actor.IsPhysical,
(PhysicsShape rootShape, Dictionary <PhysxPrim, RelatedShapes> childShapes) =>
{
_newPrimaryShape = rootShape;
_newChildShapes = childShapes;
scene.QueueCommand(this);
});
worker.Remesh();
}
else
{
try
{
if (_actor.IsPhysical)
{
if (!_actor.DynamicsPrecheck(_newPrimaryShape, _newChildShapes))
{
return;
}
}
_actor.RebuildPhysxActorWithNewShape(_newPrimaryShape, _newChildShapes, _vdActive ? false : _actor.IsPhysical, false);
_actor.SetVolumeDetectSync(_vdActive);
}
finally
{
_actor.EndDelayCommands();
}
}
}
public void Write(AssetWriter writer)
{
writer.Write(Name);
Rect.Write(writer);
writer.Write((int)Alignment);
Pivot.Write(writer);
if (HasBorder(writer.Version))
{
Border.Write(writer);
}
if (HasOutline(writer.Version))
{
Outline.Write(writer);
}
if (HasPhysicsShape(writer.Version))
{
PhysicsShape.Write(writer);
}
if (HasTessellationDetail(writer.Version))
{
writer.Write(TessellationDetail);
}
if (HasBones(writer.Version))
{
Bones.Write(writer);
writer.Write(SpriteID);
}
if (HasInternalID(writer.Version))
{
writer.Write(InternalID);
}
if (HasBones(writer.Version))
{
Vertices.Write(writer);
Indices.Write(writer);
Edges.Write(writer);
writer.AlignStream();
Weights.Write(writer);
writer.AlignStream();
}
}
private void CheckAndDispose(PhysicsShape item, bool dynamic)
{
//we want to dispose this object, but ONLY if no one else has a reference to it
//that includes the opposite inactive list
if (item.HasRefs)
{
return;
}
//we can dispose
if (this.OnShapeNeedsFreeing != null)
{
this.OnShapeNeedsFreeing(item);
}
else
{
//this will happen during shutdown, where we dont want to defer the deletes to the physics thread
//since it is stopped
item.Dispose();
}
}
public void Execute(PhysxScene scene)
{
if (_newPrimaryShape == null)
{
if (_actor.Disposed) return;
_actor.BeginDelayCommands(this);
Meshing.RemeshActorWorker worker = new Meshing.RemeshActorWorker(scene, _actor, _isPhysical,
(PhysicsShape rootShape, Dictionary<PhysxPrim, RelatedShapes> childShapes) =>
{
_newPrimaryShape = rootShape;
_newChildShapes = childShapes;
scene.QueueCommand(this);
});
worker.Remesh();
}
else
{
try
{
if (_isPhysical)
{
if (!_actor.DynamicsPrecheck(_newPrimaryShape, _newChildShapes))
{
return;
}
}
_actor.RebuildPhysxActorWithNewShape(_newPrimaryShape, _newChildShapes, _isPhysical, false);
}
finally
{
_actor.EndDelayCommands();
}
}
}
public PhysicalSpriteUV(TextureInfo textureInfo, PhysicsScene physicsScene, bool circle = false)
: base(textureInfo)
{
// Texture Setup
Quad.S = TextureInfo.TextureSizef;
Pivot = new Vector2(TextureInfo.Texture.Width / 2f, TextureInfo.Texture.Height / 2f );
// Physics Setup (get the indicies we will be using
PhysicsScene = physicsScene;
ShapeIndex = PhysicsScene.NumShape;
BodyIndex = PhysicsScene.NumBody;
JointIndex = -1;
// Create shapes (will want to let the programmer pass in things like friction and rotation at some point, AND SPECIFY CIRCLE OR SQUARE SHAPE)
PhysicsShape shape;
if(!circle)
{
shape = new PhysicsShape(new Vector2(textureInfo.Texture.Width/2, textureInfo.Texture.Height/2));
}
else
{
shape = new PhysicsShape(textureInfo.Texture.Width/2);
}
// Why 100?
PhysicsBody body = new PhysicsBody(shape, 100);
body.ShapeIndex = (uint)ShapeIndex;
PhysicsScene.sceneShapes[ShapeIndex] = shape;
PhysicsScene.sceneBodies[BodyIndex] = body;
//PhysicsScene.sceneBodies[BodyIndex].Rotation = 0.1f;
//PhysicsScene.sceneBodies[BodyIndex].AirFriction = 0.01f;
PhysicsScene.NumShape++;
PhysicsScene.NumBody++;
}
void _shapeCache_OnShapeNeedsFreeing(PhysicsShape shape)
{
if (OnShapeNeedsFreeing != null)
{
OnShapeNeedsFreeing(shape);
}
}
internal void UnrefShape(PhysicsShape shape, bool dynamic)
{
lock (_meshWaitingQueue)
{
_meshWaitingQueue.Enqueue(new UnrefShapeItem
{
Shape = shape,
Dynamic = dynamic
});
Monitor.Pulse(_meshWaitingQueue);
}
}
public void Execute(PhysxScene scene)
{
bool isPhysical = (_flags & PhysicsScene.AddPrimShapeFlags.Physical) != 0;
if (_rootHasVdSet)
{
isPhysical = false;
}
if (_newPrimaryShape == null)
{
bool first = true;
foreach (BulkShapeData shape in _shapes)
{
BulkShapeData thisShape = shape;
if (first)
{
_primaryShapeData = thisShape;
PhysicsProperties properties = PhysicsProperties.DeserializeOrCreateNew(scene, shape.Material, shape.PhysicsProperties);
_rootHasVdSet = properties.VolumeDetectActive;
if (_rootHasVdSet)
{
isPhysical = false;
}
scene.MeshingStageImpl.QueueForMeshing(String.Empty, shape.Pbs, shape.Size, Meshing.MeshingStage.SCULPT_MESH_LOD,
isPhysical || _rootHasVdSet, shape.SerializedShapes,
(_flags & PhysxScene.AddPrimShapeFlags.FromCrossing) == PhysicsScene.AddPrimShapeFlags.FromCrossing,
delegate(PhysicsShape meshedShape)
{
_newPrimaryShape = meshedShape;
_meshedShapes.Add(thisShape, meshedShape);
if (++_meshedSoFar == _totalNumShapes)
{
scene.QueueCommand(this);
}
}
);
first = false;
}
else
{
scene.MeshingStageImpl.QueueForMeshing(String.Empty, shape.Pbs, shape.Size, Meshing.MeshingStage.SCULPT_MESH_LOD,
isPhysical || _rootHasVdSet, shape.SerializedShapes,
(_flags & PhysxScene.AddPrimShapeFlags.FromCrossing) == PhysicsScene.AddPrimShapeFlags.FromCrossing,
delegate(PhysicsShape meshedShape)
{
_meshedShapes.Add(thisShape, meshedShape);
if (++_meshedSoFar == _totalNumShapes)
{
scene.QueueCommand(this);
}
}
);
}
}
}
else
{
OpenMetaverse.Vector3 rootVelocity = OpenMetaverse.Vector3.Zero;
OpenMetaverse.Vector3 rootAngularVelocity = OpenMetaverse.Vector3.Zero;
//we have all the shapes for the parent and all children, time to construct the group
bool first = true;
PhysxPrim rootPrim = null;
CollisionGroupFlag collisionGroup = (_flags & PhysicsScene.AddPrimShapeFlags.Phantom) == 0 ? CollisionGroupFlag.Normal : CollisionGroupFlag.PhysicalPhantom;
foreach (BulkShapeData shape in _shapes)
{
if (first)
{
bool kinematicStatic;
PhysicsProperties properties = PhysicsProperties.DeserializeOrCreateNew(scene, shape.Material, shape.PhysicsProperties);
PhysX.RigidActor actor = PhysxActorFactory.CreateProperInitialActor(_newPrimaryShape, scene, shape.Position, shape.Rotation, _flags, out kinematicStatic,
properties.PhysxMaterial);
rootPrim = new PhysxPrim(scene, shape.Pbs, shape.Position, shape.Rotation, _newPrimaryShape, actor,
isPhysical, properties, collisionGroup);
scene.AddPrimSync(rootPrim, isPhysical, kinematicStatic);
shape.OutActor = rootPrim;
rootVelocity = shape.Velocity;
rootAngularVelocity = shape.AngularVelocity;
first = false;
}
else
{
PhysicsShape phyShape = _meshedShapes[shape];
PhysicsProperties properties = PhysicsProperties.DeserializeOrCreateNew(scene, shape.Material, shape.PhysicsProperties);
PhysxPrim childPrim = new PhysxPrim(rootPrim, scene, shape.Pbs, shape.Position, shape.Rotation, phyShape,
null, isPhysical, properties, collisionGroup);
rootPrim.LinkPrimAsChildSync(phyShape, childPrim, shape.Position, shape.Rotation, true);
shape.OutActor = childPrim;
}
}
rootPrim.UpdateMassAndInertia();
if (_rootHasVdSet)
{
rootPrim.SetVolumeDetectSync(_rootHasVdSet);
}
if ((_flags & PhysicsScene.AddPrimShapeFlags.StartSuspended) != 0)
{
rootPrim.SuspendPhysicsSync(_primaryShapeData.ObjectReceivedOn);
}
rootPrim.DynamicsPostcheck();
rootPrim.SetInitialVelocities(rootVelocity, rootAngularVelocity);
if ((_flags & PhysicsScene.AddPrimShapeFlags.Interpolate) != 0)
{
rootPrim.SuspendPhysicsSync(_primaryShapeData.ObjectReceivedOn);
rootPrim.ResumePhysicsSync(true);
}
FinishedEvent.Set();
}
}
// METHODS ------------------------------------------------------------------------------------------------
// public PhysicsBody addCardPhysics(Vector2 position) {
// this.SceneBodies[this.NumBody] = new PhysicsBody(SceneShapes[0],0.1f);
// this.SceneBodies[this.NumBody].ShapeIndex = 0;
// this.sceneBodies[this.NumBody].ColFriction = 0.01f;
// this.SceneBodies[this.NumBody].Position = position / PtoM;
// this.NumBody++;
// return SceneBodies[this.NumBody-1];
// }
public void RegisterPhysicsShape( PhysicsShape pShape )
{
this.SceneShapes[numShape] = new PhysicsShape( pShape );
this.NumShape++;
}
public PhysicsBody RegisterPhysicsBody(PhysicsShape pShape, float pMass, float pColFriction, Vector2 pPosition)
{
// if (!Array.Exists<PhysicsShape>(SceneShapes, pShape)) {
int i = NumShape-1;
while(i>=0) {
if(SceneShapes[i] == pShape) {
break;
}
i--;
}
if( i == -1) { // REQUESTED SceneShape COULD NOT BE FOUND IN REGISTRY, SO REGISTER IT
RegisterPhysicsShape( pShape );
i = NumShape-1;
}
this.SceneBodies[this.NumBody] = new PhysicsBody( pShape, pMass );
this.SceneBodies[this.NumBody].ShapeIndex = (uint)i;
this.SceneBodies[this.NumBody].ColFriction = pColFriction;
this.SceneBodies[this.NumBody].Position = pPosition / PtoM;
this.NumBody++;
return SceneBodies[this.NumBody-1];
}
internal bool TryGetCachedShape(ulong meshHash, OpenSim.Framework.PrimitiveBaseShape shape, bool isDynamic, out PhysicsShape phyShape)
{
ShapeCache cache = FindCorrespondingCache(ShapeDeterminer.FindBestShape(shape, isDynamic));
if (cache != null)
{
return cache.TryGetShape(meshHash, out phyShape);
}
phyShape = null;
return false;
}
private static PhysicsShape CreatePhysicsShapeFromConvexSetAndCache(MeshingStage meshingStage, ulong meshHash, List<PhysX.ConvexMeshGeometry> convexes)
{
PhysicsShape phyShape;
phyShape = new PhysicsShape(convexes, meshHash);
phyShape.Complexity = convexes.Count;
phyShape.AddRef();
//complex shapes are cached
meshingStage.CacheShape(meshHash, phyShape, ShapeType.DecomposedConvexHulls);
return phyShape;
}
private void GenerateTrimeshAndComplete(MeshingStage meshingStage, ulong meshHash)
{
PhysicsShape phyShape;
PhysX.TriangleMeshGeometry triMesh = meshingStage.GeneratePhysXTrimeshShape(PrimName, Shape, Size, MeshingStage.SCULPT_MESH_LOD, IsDynamic);
if (triMesh == null)
{
//meshing or one of its prereq steps failed, generate a bounding box
PhysX.Geometry geom = meshingStage.GeneratePhysXBoxShape(Shape);
//basic shapes are not cached
phyShape = new PhysicsShape(geom, ShapeType.PrimitiveBox, meshHash);
}
else
{
phyShape = CreatePhysicsShapeFromTrimeshAndCache(meshingStage, meshHash, triMesh);
}
//we are done here, call back to caller
this.CompletedDelegate(phyShape);
}
public void Execute(PhysxScene scene)
{
if (Shape == null)
{
PhysicsProperties properties = PhysicsProperties.DeserializeOrCreateNew(scene, _material, _serializedPhysicsProperties);
_hasVdSet = properties.VolumeDetectActive;
scene.MeshingStageImpl.QueueForMeshing(_primName, _pbs, _size, _lod,
(_flags & PhysicsScene.AddPrimShapeFlags.Physical) != 0 || _hasVdSet,
_serializedPhysicsShapes,
(_flags & PhysxScene.AddPrimShapeFlags.FromCrossing) == PhysicsScene.AddPrimShapeFlags.FromCrossing,
delegate(PhysicsShape meshedShape)
{
Shape = meshedShape;
scene.QueueCommand(this);
}
);
}
else
{
bool isPhysical = (_flags & PhysicsScene.AddPrimShapeFlags.Physical) != 0;
if (_hasVdSet)
{
isPhysical = false;
}
CollisionGroupFlag collisionGroup = (_flags & PhysicsScene.AddPrimShapeFlags.Phantom) == 0 ? CollisionGroupFlag.Normal : CollisionGroupFlag.PhysicalPhantom;
if (_parent == null)
{
bool kinematicStatic;
PhysicsProperties properties = PhysicsProperties.DeserializeOrCreateNew(scene, _material, _serializedPhysicsProperties);
Actor = PhysxActorFactory.CreateProperInitialActor(Shape, scene, _position, _rotation, _flags, out kinematicStatic, properties.PhysxMaterial);
FinalPrim = new PhysxPrim(scene, _pbs, _position, _rotation, Shape, Actor, isPhysical, properties, collisionGroup);
scene.AddPrimSync(FinalPrim, isPhysical, kinematicStatic);
}
else
{
PhysicsProperties properties = PhysicsProperties.DeserializeOrCreateNew(scene, _material, _serializedPhysicsProperties);
FinalPrim = new PhysxPrim(_parent, scene, _pbs, _position, _rotation, Shape, null, isPhysical, properties, collisionGroup);
_parent.LinkPrimAsChildSync(Shape, FinalPrim, _position, _rotation, false);
}
if (_hasVdSet)
{
FinalPrim.SetVolumeDetectSync(true);
}
if ((_flags & PhysicsScene.AddPrimShapeFlags.StartSuspended) != 0)
{
FinalPrim.SuspendPhysicsSync(_interpolateTime);
}
FinalPrim.DynamicsPostcheck();
FinalPrim.SetInitialVelocities(_velocity, _angularVelocity);
if ((_flags & PhysicsScene.AddPrimShapeFlags.Interpolate) != 0)
{
FinalPrim.SuspendPhysicsSync(_interpolateTime);
FinalPrim.ResumePhysicsSync(true);
}
this.FinshedEvent.Set();
}
}
public SetPhysicalityCmd(PhysxPrim actor, bool isPhysical)
{
_isPhysical = isPhysical;
_actor = actor;
_newPrimaryShape = null;
}
private static PhysicsShape CreatePhysicsShapeFromTrimeshAndCache(MeshingStage meshingStage, ulong meshHash, PhysX.TriangleMeshGeometry triMesh)
{
PhysicsShape phyShape;
phyShape = new PhysicsShape(triMesh, ShapeType.TriMesh, meshHash);
phyShape.AddRef();
//complex shapes are cached
meshingStage.CacheShape(meshHash, phyShape, ShapeType.TriMesh);
return phyShape;
}
internal void UncacheShape(ulong meshHash, PhysicsShape shape, ShapeType shapeType)
{
ShapeCache cache = FindCorrespondingCache(shapeType);
cache.RemoveShape(meshHash, shape);
}
private void GenerateBasicShapeAndComplete(MeshingStage meshingStage, ulong meshHash)
{
Tuple<PhysX.Geometry, ShapeType> result = meshingStage.GenerateBasicPhysXShape(Shape);
PhysicsShape phyShape = new PhysicsShape(result.Item1, result.Item2, meshHash);
//basic shapes are not cached
//we are done here, call back to caller
this.CompletedDelegate(phyShape);
}
private static PhysicsShape CreatePhysicsShapeFromSingleConvexAndCache(MeshingStage meshingStage, ulong meshHash, PhysX.ConvexMeshGeometry convex)
{
PhysicsShape phyShape;
phyShape = new PhysicsShape(new List<PhysX.ConvexMeshGeometry> { convex }, meshHash, true);
phyShape.AddRef();
//complex shapes are cached
meshingStage.CacheShape(meshHash, phyShape, ShapeType.SingleConvex);
return phyShape;
}
internal void CacheShape(ulong meshHash, PhysicsShape phyShape, ShapeType bestFitShape)
{
ShapeCache cache = FindCorrespondingCache(bestFitShape);
cache.AddShape(meshHash, phyShape);
}
// CONSTRUCTORS --------------------------------------------------------
public CubeCrystallonEntity(Scene pScene, GamePhysics pGamePhysics, PhysicsShape pShape = null )
: base(pScene, pGamePhysics, pShape, 3, true)
{
// setVelocity(DEFAULT_SPEED, GameScene.Random.NextAngle());
}
private void GenerateConvexSetAndComplete(MeshingStage meshingStage, ulong meshHash)
{
PhysicsShape phyShape;
//we need to mesh this object into convex hulls appropriate for dynamic objects
List<PhysX.ConvexMeshGeometry> convexes = meshingStage.GenerateComplexPhysXShape(meshHash, PrimName, Shape, Size, MeshingStage.SCULPT_MESH_LOD, IsDynamic);
if (convexes == null)
{
//meshing or one of its prereq steps failed, generate a bounding box
PhysX.Geometry geom = meshingStage.GeneratePhysXBoxShape(Shape);
//basic shapes are not cached
phyShape = new PhysicsShape(geom, ShapeType.PrimitiveBox, meshHash);
}
else
{
phyShape = CreatePhysicsShapeFromConvexSetAndCache(meshingStage, meshHash, convexes);
}
//we are done here, call back to caller
this.CompletedDelegate(phyShape);
}
