public HiddenEntityMetadata(Material material, ShaderResourceView texSrv, LevelGeometryEntity levelRepresentation, ConstantBufferBinding alphaMatColorBinding)
{
Material = material;
TexSRV = texSrv;
LevelRepresentation = levelRepresentation;
this.alphaMatColorBinding = alphaMatColorBinding;
}
public virtual void ResetEntity(LevelGeometryEntity levelGeometryEntity, Material overrideMaterial = null)
{
SceneLayer sl = GetRecommendedSceneLayer();
using (RenderingModule.RenderStateBarrier.AcquirePermit(withLock: instanceMutationLock)) {
Entity rep = GetEntityRepresentation(levelGeometryEntity);
rep.Dispose();
GeometryEntity entity;
if (levelGeometryEntity.IsStatic)
{
entity = new GeometryEntity {
Transform = levelGeometryEntity.InitialMovementStep.Transform
};
}
else
{
entity = new PresetMovementEntity(levelGeometryEntity.MovementSteps.ToArray(), levelGeometryEntity.AlternatingMovementDirection, levelGeometryEntity.InitialDelay)
{
Transform = levelGeometryEntity.InitialMovementStep.Transform
};
}
entity.SetModelInstance(sl, currentModelHandles[levelGeometryEntity.Geometry], overrideMaterial ?? currentMaterials[levelGeometryEntity.Material]);
currentGeometryEntities[levelGeometryEntity] = entity;
}
}
public void AddEntity(LevelGeometryEntity geometryEntity)
{
Assure.NotNull(geometryEntity);
lock (instanceMutationLock) {
this.levelGeometryEntities.Add(geometryEntity);
}
}
protected LevelGameObject(LevelDescription parentLevel, LevelGeometryEntity groundingGeometryEntity, Transform transform, bool useSimpleGrounding, int id)
{
this.ParentLevel = parentLevel;
groundingEntityID = groundingGeometryEntity == null ? null : (int?)groundingGeometryEntity.ID;
this.transform = transform;
this.useSimpleGrounding = useSimpleGrounding;
ID = id;
}
public virtual void DeleteEntity(LevelGeometryEntity geometryEntity)
{
Assure.NotNull(geometry);
lock (instanceMutationLock) {
Assure.True(this.levelGeometryEntities.Contains(geometryEntity));
this.levelGeometryEntities.Remove(geometryEntity);
}
}
public void ReplaceEntity(LevelGeometryEntity existing, LevelGeometryEntity replacement)
{
Assure.NotNull(existing);
Assure.NotNull(replacement);
lock (instanceMutationLock) {
Assure.True(this.levelGeometryEntities.Contains(existing));
levelGeometryEntities.Replace(existing, replacement);
}
}
public LevelGeometryEntity Clone(int id)
{
lock (instanceMutationLock) {
LevelGeometryEntity clone = new LevelGeometryEntity(ParentLevel, Tag + " Clone", Geometry, Material, id, InitialMovementStep.Clone());
for (int i = 1; i < movementSteps.Count; ++i)
{
clone.AddMovementStep(movementSteps[i].Clone());
}
clone.AlternatingMovementDirection = alternatingMovementDirection;
clone.InitialDelay = initialDelay;
clone.TexPan = texPan;
return(clone);
}
}
public override void DeleteEntity(LevelGeometryEntity geometryEntity)
{
lock (instanceMutationLock) {
var matchingLGOs = gameObjects.Where(lgo => lgo.GroundingGeometryEntity == geometryEntity);
foreach (LevelGameObject matchingLgO in matchingLGOs)
{
matchingLgO.GroundingGeometryEntity = null;
}
base.DeleteEntity(geometryEntity);
foreach (LevelGameObject matchingLgO in matchingLGOs)
{
ResetGameObject(matchingLgO);
}
}
}
public override void ResetEntity(LevelGeometryEntity levelGeometryEntity, Material overrideMaterial = null)
{
base.ResetEntity(levelGeometryEntity, overrideMaterial);
Entity rep = GetEntityRepresentation(levelGeometryEntity);
PhysicsShapeHandle physicsShape = activePhysicsShapes[levelGeometryEntity];
if (physicsShape == PhysicsShapeHandle.NULL)
{
return; // Some geometry is non-collidable (i.e. planes)
}
rep.SetPhysicsShape(physicsShape, Vector3.ZERO, LevelGeometry.GEOMETRY_MASS, forceIntransigence: true);
if (rep is PresetMovementEntity)
{
foreach (LevelGameObject levelGameObject in GameObjects.Where(go => go.GroundingGeometryEntity == levelGeometryEntity))
{
GroundableEntity goRep = GetGameObjectRepresentation(levelGameObject);
goRep.Ground((PresetMovementEntity)rep);
}
}
}
private DynamicLight(LevelDescription parentLevel, LevelGeometryEntity groundingGeometryEntity, Transform transform, bool useSimpleGrounding, int id) : base(parentLevel, groundingGeometryEntity, transform, useSimpleGrounding, id)
{
}
private IntroCameraAttracter(LevelDescription parentLevel, LevelGeometryEntity groundingGeometryEntity, Transform transform, bool useSimpleGrounding, int id) : base(parentLevel, groundingGeometryEntity, transform, useSimpleGrounding, id)
{
}
protected override void Tick(float deltaTimeSeconds)
{
base.Tick(deltaTimeSeconds);
if (Egg.IsDisposed || Camera.IsDisposed || GameCoordinator.CurrentGameState != GameCoordinator.OverallGameState.LevelPlaying)
{
return;
}
// Declare some variables that we'll use below
Vector3 eggPos = Egg.Transform.Translation;
Vector3 eggVelo = Egg.TrueVelocity;
Vector3 camPos = UnalteredCamPosition;
Vector3 camOrientation = UnalteredCamOrientation;
Vector3 boardDownDir = GameCoordinator.BoardDownDir;
Plane groundPlane = GameCoordinator.GroundPlane;
Quaternion boardTilt = GameCoordinator.CurrentGameboardTilt;
float flopsErrorMargin = MathUtils.FlopsErrorMargin;
Vector3 verticalEggPos = eggPos.ProjectedOnto(boardDownDir);
Vector3 horizontalEggPos = groundPlane.PointProjection(eggPos);
Vector3 verticalEggVelo = eggVelo.ProjectedOnto(boardDownDir);
Vector3 horizontalEggVelo = groundPlane.OrientationProjection(eggVelo);
Vector3 verticalCamPos = camPos.ProjectedOnto(boardDownDir);
Vector3 horizontalCamPos = groundPlane.PointProjection(camPos);
Vector3 horizontalCamOrientation = groundPlane.OrientationProjection(camOrientation);
Vector3 verticalCamOrientation = camOrientation.ProjectedOnto(boardDownDir);
Vector3 curUpDir = Camera.UpDirection;
Vector3 targetUpDir = -boardDownDir;
Camera.Position = UnalteredCamPosition;
// Find where the camera "wants" to be (only according to the egg velo)
Vector3 reverseEggVelo = horizontalEggVelo.LengthSquared > GameplayConstants.MIN_EGG_SPEED_FOR_VELO_BASED_CAM_SQ ? -horizontalEggVelo : -horizontalCamOrientation;
Vector3 targetPos = eggPos + reverseEggVelo.WithLength(cameraDistance);
// Add the height addition to the target pos
float verticalAddition =
verticalEggVelo.LengthSquared > horizontalEggVelo.LengthSquared &&
verticalEggVelo.LengthSquared > GameplayConstants.MIN_FALL_SPEED_FOR_FALLING_CAM_SQ
? cameraHeight + GameplayConstants.CAMERA_FALLING_HEIGHT_EXTRA
: cameraHeight;
targetPos += -boardDownDir.WithLength(verticalAddition);
// Calculate the rotation around the egg that the boom is making (in 3 dimensions!), and calculate the amount to rotate this frame
Vector3 eggToTarget = targetPos - eggPos;
eggToTarget *= boardTilt.Subrotation(GameplayConstants.CAM_BOARD_TILT_FACTOR);
Vector3 eggToCam = camPos - eggPos;
float eggToTargetLen = eggToTarget.Length;
Quaternion cameraRot = Quaternion.FromVectorTransition(eggToCam.ToUnit(), eggToTarget.ToUnit());
eggToTarget = eggToCam * cameraRot.Subrotation(Math.Min(GameplayConstants.CAM_MOVE_SPEED_ANGULAR * deltaTimeSeconds, 1f));
targetPos = eggPos + (eggToTargetLen > flopsErrorMargin ? eggToTarget.WithLength(eggToTargetLen) : Vector3.ZERO);
// Get the distance from the current pos to the target pos, calculate the amount to move closer this frame, and move the camera
Vector3 camToTarget = targetPos - camPos;
float movementDist =
(float)Math.Pow(camToTarget.LengthSquared, GameplayConstants.CAM_MOVE_SPEED_EXPONENT_LINEAR)
* deltaTimeSeconds;
if (camToTarget.LengthSquared > flopsErrorMargin)
{
Camera.Move(camToTarget.WithLength(Math.Min(movementDist, camToTarget.Length)));
}
// Calculate the rotation of orientation, and then rotate the camera according to the rotation speed
Vector3 newOrientation = (eggPos - camPos).ToUnit();
Quaternion orientRot = Quaternion.FromVectorTransition(camOrientation, newOrientation);
Vector3 newCamUp;
if (curUpDir == targetUpDir)
{
newCamUp = targetUpDir;
}
else
{
Quaternion curToTargetRot = Quaternion.FromVectorTransition(curUpDir, targetUpDir);
newCamUp = curUpDir * curToTargetRot.Subrotation(GameplayConstants.CAM_UP_SUBROT_PER_SEC * deltaTimeSeconds);
}
Camera.Orient(
camOrientation * orientRot.Subrotation(Math.Min(GameplayConstants.CAM_ORIENT_SPEED * deltaTimeSeconds, 1f)),
newCamUp
);
// Adjust camera orientation and position according to right-stick
float xDiff = camOrientAltXTarget - camOrientAltXActual;
float xDelta = xDiff * GameplayConstants.CAM_ORIENTATION_ADJUSTMENT_DELTA_FRAC_PER_SEC_X * deltaTimeSeconds;
if (Math.Abs(camOrientAltXTarget) < Math.Abs(camOrientAltXActual))
{
xDelta = xDiff * GameplayConstants.CAM_ORIENTATION_ADJUSTMENT_DELTA_FRAC_PER_SEC_X_STOPPING * deltaTimeSeconds;
}
else
{
xDelta = Math.Max(
Math.Abs(xDelta),
Math.Min(
GameplayConstants.CAM_ORIENTATION_ADJUSTMENT_DELTA_ABS_MIN_PER_SEC_X * deltaTimeSeconds,
Math.Abs(xDiff)
)
) * (xDiff < 0f ? -1f : 1f);
}
camOrientAltXActual = camOrientAltXActual + xDelta;
float yDiff = camOrientAltYTarget - camOrientAltYActual;
float yDelta = yDiff * GameplayConstants.CAM_ORIENTATION_ADJUSTMENT_DELTA_FRAC_PER_SEC_Y * deltaTimeSeconds;
if (Math.Abs(camOrientAltYTarget) < Math.Abs(camOrientAltYActual))
{
yDelta = yDiff * GameplayConstants.CAM_ORIENTATION_ADJUSTMENT_DELTA_FRAC_PER_SEC_Y_STOPPING * deltaTimeSeconds;
}
else
{
yDelta = Math.Max(
Math.Abs(yDelta),
Math.Min(
GameplayConstants.CAM_ORIENTATION_ADJUSTMENT_DELTA_ABS_MIN_PER_SEC_Y * deltaTimeSeconds,
Math.Abs(yDiff)
)
) * (yDiff < 0f ? -1f : 1f);
}
camOrientAltYActual = camOrientAltYActual + yDelta;
unalteredCamOrientation = Camera.Orientation;
Vector3 alteredOrientation = unalteredCamOrientation;
Quaternion forwardToUpRot = Quaternion
.FromVectorTransition(alteredOrientation, -boardDownDir)
.Subrotation(GameplayConstants.MAX_CAM_ORIENTATION_ADJUSTMENT_Y * camOrientAltYActual);
var verticalOrient = alteredOrientation * forwardToUpRot;
var angleToFloor = new Plane(-boardDownDir, eggPos).IncidentAngleWith(new Ray(camPos, verticalOrient)); // not sure why the 0.2f is needed but it is...
bool useVerticalOrient =
angleToFloor >= GameplayConstants.CAM_Y_ADJUSTMENT_HORIZONTAL_BUFFER_RADIANS_BOTTOM &&
angleToFloor <= MathUtils.PI_OVER_TWO - GameplayConstants.CAM_Y_ADJUSTMENT_HORIZONTAL_BUFFER_RADIANS_TOP &&
alteredOrientation.ProjectedOnto(-boardDownDir).ToUnit() != -boardDownDir;
Quaternion forwardToLeftRot = Quaternion
.FromAxialRotation(-boardDownDir, -MathUtils.PI_OVER_TWO)
.Subrotation(GameplayConstants.MAX_CAM_ORIENTATION_ADJUSTMENT_X * camOrientAltXActual);
alteredOrientation = (useVerticalOrient ? verticalOrient : unalteredCamOrientation) * forwardToLeftRot;
Camera.Orient(alteredOrientation, useVerticalOrient ? Camera.UpDirection * forwardToUpRot : Camera.UpDirection);
unalteredCamPosition = Camera.Position;
Vector3 alteredPosition = unalteredCamPosition.Value;
Vector3 downVec = boardDownDir;
Vector3 leftVec = groundPlane.OrientationProjection(unalteredCamOrientation).ToUnit() * Quaternion.FromAxialRotation(boardDownDir, -MathUtils.PI_OVER_TWO);
if (useVerticalOrient)
{
alteredPosition += downVec.WithLength(GameplayConstants.CAM_ADJUSTMENT_TRANSLATION_MAX_Y * camOrientAltYActual);
}
alteredPosition += leftVec.WithLength(GameplayConstants.CAM_ADJUSTMENT_TRANSLATION_MAX_X * camOrientAltXActual);
Camera.Position = alteredPosition;
unalteredCamPosition = alteredPosition;
unalteredCamOrientation = alteredOrientation;
// Finally, make any geometry entities that are obscuring the view of the egg transparent
var curLevel = GameCoordinator.CurrentlyLoadedLevel;
hiddenEntityAccountingSpace.Clear();
foreach (var key in hiddenEntities.Keys)
{
hiddenEntityAccountingSpace.Add(key);
}
EntityModule.RayTestAllLessGarbage(Ray.FromStartAndEndPoint(Camera.Position, eggPos), reusableRTCList);
foreach (RayTestCollision rtc in reusableRTCList)
{
var geomEntity = rtc.Entity as GeometryEntity;
if (geomEntity == null)
{
continue;
}
if (hiddenEntities.ContainsKey(geomEntity))
{
hiddenEntityAccountingSpace.Remove(geomEntity);
continue;
}
LevelGeometryEntity entityLevelRep = curLevel.GetLevelEntityRepresentation(geomEntity);
Material alphaMat = new Material(entityLevelRep.Material.Name + " + Alpha", AssetLocator.AlphaFragmentShader);
alphaMat.SetMaterialConstantValue(alphaMatColorBinding, new Vector4(
GameplayConstants.OBSCURING_GEOM_BRIGHTNESS,
GameplayConstants.OBSCURING_GEOM_BRIGHTNESS,
GameplayConstants.OBSCURING_GEOM_BRIGHTNESS,
GameplayConstants.OBSCURING_GEOM_MIN_ALPHA
));
ShaderResourceView texSRV = AssetLocator.LoadTexture(entityLevelRep.Material.TextureFileName).CreateView();
alphaMat.SetMaterialResource(alphaMatTextureBinding, texSRV);
hiddenEntities.Add(geomEntity, new HiddenEntityMetadata(
alphaMat, texSRV, entityLevelRep, alphaMatColorBinding
));
geomEntity.SetModelInstance(
AssetLocator.GameAlphaLayer,
curLevel.GetModelHandleForGeometry(entityLevelRep.Geometry),
alphaMat
);
}
foreach (KeyValuePair <GeometryEntity, HiddenEntityMetadata> kvp in hiddenEntities)
{
HiddenEntityMetadata metadata = kvp.Value;
if (hiddenEntityAccountingSpace.Contains(kvp.Key))
{
metadata.Alpha += GameplayConstants.OBSCURING_GEOM_ALPHA_REGAIN_SPEED * deltaTimeSeconds;
if (metadata.Alpha < GameplayConstants.OBSCURING_GEOM_MAX_ALPHA)
{
hiddenEntityAccountingSpace.Remove(kvp.Key);
}
}
else if (metadata.Alpha > GameplayConstants.OBSCURING_GEOM_MIN_ALPHA)
{
metadata.Alpha -= GameplayConstants.OBSCURING_GEOM_ALPHA_REGAIN_SPEED * deltaTimeSeconds;
}
}
foreach (GeometryEntity hiddenEntity in hiddenEntityAccountingSpace)
{
var hiddenEntityMetadata = hiddenEntities.Pop(hiddenEntity);
AssetLocator.UnloadTexture(hiddenEntityMetadata.LevelRepresentation.Material.TextureFileName);
hiddenEntityMetadata.TexSRV.Dispose();
hiddenEntityMetadata.Material.Dispose();
hiddenEntity.SetModelInstance(
AssetLocator.GameLayer,
curLevel.GetModelHandleForGeometry(hiddenEntityMetadata.LevelRepresentation.Geometry),
curLevel.GetLoadedMaterialForLevelMaterial(hiddenEntityMetadata.LevelRepresentation.Material)
);
}
}
private Shadowcaster(LevelDescription parentLevel, LevelGeometryEntity groundingGeometryEntity, Transform transform, bool useSimpleGrounding, int id) : base(parentLevel, groundingGeometryEntity, transform, useSimpleGrounding, id)
{
}
private FinishingBell(LevelDescription parentLevel, LevelGeometryEntity groundingGeometryEntity, Transform transform, bool useSimpleGrounding, int id) : base(parentLevel, groundingGeometryEntity, transform, useSimpleGrounding, id)
{
}
public GeometryEntity GetEntityRepresentation(LevelGeometryEntity le)
{
lock (instanceMutationLock) {
return(currentGeometryEntities.ValueOrDefault(le));
}
}