private void CmdUpdateServerState(InputState[] states)
{
for (int i = 0; i < states.Length; i++)
{
if (states[i].state <= lastClientState)
{
continue;
}
lastClientState = states[i].state;
if (!isLocalPlayer)
{
PerformMovement(states[i]);
}
}
TransformState state = new TransformState()
{
state = lastClientState,
position = transform.position,
};
serverState = state;
if (isLocalPlayer)
{
PerformReconciliation(state);
}
}
void Update()
{
//State Change input keys
if (Input.GetKeyDown(KeyCode.R))
{
state = TransformState.Rotation;
}
if (Input.GetKeyDown(KeyCode.T))
{
state = TransformState.Translation;
}
if (Input.GetKeyDown(KeyCode.Y))
{
state = TransformState.Scale;
}
if (objectSelected != null) //Check Whether an object is currently selected
{
Vector2 arrowInput = new Vector2(Input.GetAxisRaw("Horizontal"), Input.GetAxisRaw("Vertical")); //Arrow Keys Vector
if (arrowInput != Vector2.zero) //If a button is currently pressed, vector won't equal 0
{
if (isArrowKeyDown == false) //Bool to only get input on key down
{
objectSelected.GetComponent <TranslateObject>().StepInput(arrowInput * stepMod); //Call objects translation function, passing in input vector and step modifier
isArrowKeyDown = true; //Set key down to true
}
}
else
{
isArrowKeyDown = false;
} //If Vector is zero, set key down to false
}
}
public void SetPosition(Vector3 worldPos, bool notify = true, bool keepRotation = false)
{
Poke();
Vector2 pos = worldPos; //Cut z-axis
serverState.MatrixId = MatrixManager.AtPoint(Vector3Int.RoundToInt(worldPos)).Id;
// serverState.Speed = speed;
serverState.WorldPosition = pos;
if (!keepRotation)
{
serverState.Rotation = 0;
}
if (notify)
{
NotifyPlayers();
}
//Don't lerp (instantly change pos) if active state was changed
if (serverState.Speed > 0)
{
var preservedLerpPos = serverLerpState.WorldPosition;
serverLerpState.MatrixId = serverState.MatrixId;
serverLerpState.WorldPosition = preservedLerpPos;
}
else
{
serverLerpState = serverState;
}
}
/// Called from TransformStateMessage, applies state received from server to client
public void UpdateClientState(TransformState newState)
{
clientState = newState;
OnUpdateRecieved().Invoke(Vector3Int.RoundToInt(newState.WorldPosition));
//Ignore "Follow Updates" if you're pulling it
if (newState.Active &&
newState.IsFollowUpdate &&
pushPull && pushPull.IsPulledByClient(PlayerManager.LocalPlayerScript?.pushPull))
{
return;
}
//Don't lerp (instantly change pos) if active state was changed
if (predictedState.Active != newState.Active /*|| newState.Speed == 0*/)
{
transform.position = newState.WorldPosition;
}
predictedState = newState;
UpdateActiveStatusClient();
//sync rotation if not spinning
if (predictedState.SpinFactor != 0)
{
return;
}
transform.localRotation = Quaternion.Euler(0, 0, predictedState.SpinRotation);;
}
/// <summary>
/// Create the corresponding <see cref="LightsState.Light"/> for this object.
/// </summary>
/// <returns>
/// It returns the <see cref="LightsState.Light"/> equivalent to this SceneObjectLight.
/// </returns>
public override LightsState.Light ToLight(GraphicsContext ctx, SceneGraphContext sceneCtx)
{
TransformState transformState = (TransformState)sceneCtx.GraphicsStateStack.Current[TransformState.StateSetIndex];
LightsState.LightSpot light = new LightsState.LightSpot();
SetLightParameters(sceneCtx, light);
Matrix4x4f worldModel = transformState.ModelView;
Matrix3x3f normalMatrix = new Matrix3x3f(worldModel, 3, 3).Inverse.Transposed;
light.Direction = (normalMatrix * (Vertex3f)Direction).Normalized;
light.Position = (Vertex3f)(worldModel * Vertex3f.Zero);
light.AttenuationFactors = AttenuationFactors;
light.FallOff = new Vertex2f((float)Math.Cos(Angle.ToRadians(FalloffAngle)), FalloffExponent);
// Shadow mapping
if (_ShadowMap != null)
{
// Determined later: light.ShadowMapIndex
light.ShadowMapMvp = _ShadowViewMatrix;
light.ShadowMap2D = _ShadowMap;
}
else
{
light.ShadowMapIndex = -1;
light.ShadowMap2D = null;
}
return(light);
}
/// <summary>
/// Get geometries related to this object.
/// </summary>
/// <param name="ctx"></param>
/// <param name="ctxScene"></param>
/// <returns></returns>
internal override IEnumerable <SceneObjectBatch> GetGeometries(GraphicsContext ctx, SceneGraphContext ctxScene)
{
List <SceneObjectBatch> geometries = new List <SceneObjectBatch>();
GraphicsStateSet sceneGeometryState = ctxScene.GraphicsStateStack.Current.Push();
TransformState sceneGeometryModel = (TransformState)sceneGeometryState[TransformState.StateSetIndex];
if ((ctxScene.Scene.SceneFlags & SceneGraphFlags.CullingViewFrustum) != 0)
{
// View-frustum culling
geometries.AddRange(GetGeometriesViewFrustum(ctxScene));
}
else
{
// All geometries
geometries.AddRange(GetGeometries(sceneGeometryState));
}
// Bounding volumes
if ((ctxScene.Scene.SceneFlags & SceneGraphFlags.BoundingVolumes) != 0)
{
if ((ctxScene.Scene.SceneFlags & SceneGraphFlags.CullingViewFrustum) != 0)
{
// View-frustum culling
geometries.AddRange(GetBoundingVolumes(ctxScene));
}
}
return(geometries);
}
public void PushStateToBuffer(float timestamp, Vector2 position, float rotation)
{
if (stateSyncMode == StateSyncMode.None)
{
transform.Position = position;
transform.Rotation = rotation;
}
else
{
transformStateBuffer[0] = new TransformState(timestamp, position, rotation);
transformStateBufferLength = Math.Min(transformStateBufferLength + 1, maxTransformStateBufferLength);
// Really check for incorrect state timestamps every time a new state is pushed to the buffer?
var incorrectStateTimestampsCount = 0;
for (int i = 0; i < transformStateBufferLength - 1; i++)
{
if (transformStateBuffer[i].timestamp < transformStateBuffer[i + 1].timestamp)
{
incorrectStateTimestampsCount++;
}
}
if (incorrectStateTimestampsCount > 1)
{
Debug.Log("At least two states have incorrect timestamps, reshuffling...");
transformStateBuffer.OrderBy(ts => ts.timestamp); // Really reshuffle the states like this, or opposite?
}
}
}
public static GameEntity CreatePlayer(this GameContext game,
int playerId,
TransformState transformState
)
{
return(game.CreatePlayer(playerId, transformState, RigidbodyState.rest));
}
private void Start()
{
m_StartButton.onClick.AddListener(Clicked_StartButton);
m_OriginalState = TransformState.WorldState();
m_OriginalState.Refresh(m_Object, TransformProperties.Position);
}
//TODO: Replace this with something better
internal FishSave ToSave()
{
position = new TransformState(transform.position, transform.rotation);
return(new FishSave()
{
ActionCounter = this.ActionCounter,
Age = this.Age,
FishName = this.FishName,
Hunger = this.Hunger,
HungerMultiplier = this.HungerMultiplier,
IsAlive = this.IsAlive,
MaximumTimeBetweenActions = this.MaximumTimeBetweenActions,
MaxScale = this.MaxScale,
MoveSpeed = this.MoveSpeed,
MoveTarget = this.MoveTarget,
NeedsToPoop = this.NeedsToPoop,
PerformingAction = this.PerformingAction,
PitchSpeed = this.PitchSpeed,
position = this.position,
ScaleIncreaseMax = this.ScaleIncreaseMax,
ScaleIncreaseMin = this.ScaleIncreaseMin,
Sickness = this.Sickness,
SicknessMultiplier = this.SicknessMultiplier,
Stress = this.Stress,
StressMultiplier = this.StressMultiplier,
TurnSpeed = this.TurnSpeed
});
}
public void Update()
{
float dt = max(1 / 120.0f, DeltaTime);
for (int i = 0; i < Transforms.Length; ++i)
{
TransformState state = States[i];
float3 targetPos = Transforms[i].localPosition;
quaternion targetRot = Transforms[i].localRotation;
float tf = max(0.0001f, state.EndTime - CurrTime);
float3 pos = InertializeMagnitude(state.PrevPosition, state.Position, targetPos, dt, tf, dt);
quaternion rot = InertializeMagnitude(state.PrevRotation, state.Rotation, targetRot, dt, tf, dt);
state.PrevPosition = state.Position;
state.PrevRotation = state.Rotation;
state.Position = pos;
state.Rotation = rot;
States[i] = state;
Transforms[i].localPosition = pos;
Transforms[i].localRotation = rot;
}
}
internal override IEnumerable <SceneObjectBatch> GetGeometries(GraphicsContext ctx, SceneGraphContext ctxScene)
{
if ((ctxScene.Scene.SceneFlags & SceneGraphFlags.BoundingVolumes) != 0)
{
GraphicsStateSet boundingVolumeState = ctxScene.GraphicsStateStack.Current.Push();
// Transform
TransformState boundingVolumeModel = (TransformState)boundingVolumeState[TransformState.StateSetIndex];
float lightVolumeDepth = 100.0f;
float lightVolumeSize = lightVolumeDepth * (float)Math.Tan(Angle.ToRadians(FalloffAngle));
boundingVolumeModel.ModelViewProjection =
(boundingVolumeModel.ModelViewProjection * LightMatrix) *
Matrix4x4f.Translated(0.0f, 0.0f, lightVolumeDepth) *
Matrix4x4f.Scaled(lightVolumeSize, lightVolumeSize, lightVolumeDepth);
// Uniform color
ShaderUniformState uniformState = new ShaderUniformState("UniformState");
uniformState.SetUniformState("glo_UniformColor", new ColorRGBAF(1.0f, 1.0f, 0.0f, 0.5f));
boundingVolumeState.DefineState(uniformState);
// Alpha blending
boundingVolumeState.DefineState(BlendState.AlphaBlending);
yield return(new SceneObjectBatch(
_BoundingVolumeArrays,
boundingVolumeState,
_BoundingVolumeProgram
));
}
yield break;
}
/// Called from TransformStateMessage, applies state received from server to client
public void UpdateClientState(TransformState newState)
{
//Don't lerp (instantly change pos) if active state was changed
if (clientState.Active != newState.Active /*|| newState.Speed == 0*/)
{
transform.position = newState.WorldPosition;
}
clientState = newState;
UpdateActiveStatus();
//sync rotation if not spinning
if (clientState.SpinFactor != 0)
{
return;
}
var rotation = Quaternion.Euler(0, 0, clientState.Rotation);
if (clientState.IsLocalRotation)
{
transform.localRotation = rotation;
}
else
{
transform.rotation = rotation;
}
}
static void Main(string[] args)
{
var host = "localhost";
var port = 9999;
Console.WriteLine($"This is an example TCP Client. Press any key to connect to tcp://{host}:{port}");
var client = new TCPClient(host, port);
client.OnMessage += OnReceive;
client.Open();
string input;
while ((input = Console.ReadLine()).ToLower() != "quit")
{
if (input.ToLower() == "state")
{
var state = new TransformState();
state.tick = simulatedTick++;
client.Send(Packet.Create(CommandEnum.StateUpdate, state.ToBytes()));
}
if (input.ToLower() == "deltastate")
{
var deltaState = new TransformDeltaState();
deltaState.startStateTick = simulatedTick - 1;
deltaState.endStateTick = simulatedTick++;
client.Send(Packet.Create(CommandEnum.DeltaStateUpdate, deltaState.ToBytes()));
}
}
client.Close();
}
/// <summary>
/// Record this transforms state to the current recording in the VCR
/// </summary>
void RecordTransformState()
{
TransformState currentState = new TransformState(transform);
string stateString = JsonUtility.ToJson(currentState);
recorderToSyncTo.SaveProperty(RecordingTagPrefix, stateString);
}
public void DisappearFromWorldServer()
{
OnPullInterrupt().Invoke();
serverState = TransformState.HiddenState;
serverLerpState = TransformState.HiddenState;
NotifyPlayers();
}
void FollowFloor()
{
//If we are detecting a floor transform
if (state.floor != null)
{
//If it is a different floor from the last one
if (state.floorState.transform == null || state.floorState.transform != state.floor)
{
state.floorState = TransformState.From(state.floor);
}
//Follow the floor transform if grounded
else if (Grounded)
{
//Follow position
transform.position += state.floor.position - state.floorState.position;
//Move(state.floor.position - state.floorState.position);
//Follow rotation
Quaternion dif = Quaternion.FromToRotation(state.floorState.forward, state.floor.forward);
transform.rotation = dif * transform.rotation;
Vector3 delta = transform.position - state.floor.position;
delta = dif * delta; transform.position = state.floor.position + delta;
//state.floorState = TransformState.From(state.floor);
}
state.floorState = TransformState.From(state.floor);
}
else
{
state.floorState = TransformState.Empty();
}
}
public MatrixStack(int capacity, Device device, TransformState matrixType)
{
stack = new Matrix4[capacity];
stack[0] = Matrix4.Identity;
this.device = device;
this.matrixType = matrixType;
}
public void ReplaceTransform(TransformState newState)
{
var index = GameComponentsLookup.Transform;
var component = CreateComponent <TransformComponent>(index);
component.state = newState;
ReplaceComponent(index, component);
}
public static TransformState Lerp(TransformState a, TransformState b, float t)
{
var lerped = new TransformState();
lerped.Position = Vector2.Lerp(a.Position, b.Position, t);
lerped.Rotation = Mathf.Lerp(a.Rotation, b.Rotation, t);
return(lerped);
}
private void OverrideTransforms()
{
// Continuously reset the orientation of the geometry and run it all from here;
// only thing that changes is the Y orientation of the platform, and the X orientation of the barrelPivot
if (root == null)
{
transform.localRotation = Quaternion.identity;
root = new TransformState(transform);
}
if (platform == null)
{
platform = new TransformState(transform.Find("Platform"));
}
if (leftWall == null)
{
leftWall = new TransformState(platform.Find("LeftWall"));
}
if (rightWall == null)
{
rightWall = new TransformState(platform.Find("RightWall"));
}
if (barrelPivot == null)
{
transform.Find("BarrelPivot").rotation = Quaternion.identity;
barrelPivot = new TransformState(transform.Find("BarrelPivot"));
}
if (barrel == null)
{
barrel = new TransformState(barrelPivot.Find("Barrel"));
}
if (mouth == null)
{
mouth = new TransformState(barrelPivot.Find("Mouth"));
}
root.Restore();
platform.Restore();
leftWall.Restore();
rightWall.Restore();
barrelPivot.Restore();
barrel.Restore();
mouth.Restore();
barrelPivot.originalTransform.Rotate(Vector3.right, barrelElevation);
if (platformRotation < -360)
{
platformRotation += 720;
}
if (platformRotation > 360)
{
platformRotation -= 720;
}
transform.Rotate(Vector3.up, platformRotation);
}
//IEnumerator ground01()
//{
// if (a == 0)
// {
// transform.Translate(new Vector2(0.2f, 0));
// yield return new WaitForSeconds(movetimes);
// a++;
// }
// else
// {
// transform.Translate(new Vector2(-0.2f, 0));
// yield return new WaitForSeconds(movetimes);
// a = 0;
// }
//}
private void OnCollisionEnter2D(Collision2D collision)
{
if (collision.gameObject.name.Equals("Player"))
{
stayground = true;
state = collision.gameObject.GetComponent <TransformState>();
collision.gameObject.transform.SetParent(gameObject.transform);
}
}
public void Initiate()
{
_states = new Dictionary <int, TransformState>();
foreach (var node in Nodes)
{
_states.Add(node.GetInstanceID(), TransformState.Create(node.transform));
}
_renderers = GetComponentsInChildren <MeshRenderer>();
}
private static void OnReceiveMessage(object sender, Message <Socket> e)
{
var bytes = new ByteQueue(e.bytes);
var command = (CommandEnum)bytes.GetByte();
if (command == CommandEnum.Input)
{
// Receive Input:
}
if (command == CommandEnum.StateUpdate)
{
var state = new TransformState();
state.FromBytes(bytes);
Console.WriteLine($"TCPClient {e.client.Handle}: {state}");
var existingState = stateHistory.GetState(state.tick);
if (existingState != null)
{
existingState.Clear();
existingState.entities.AddRange(state.entities);
}
else
{
stateHistory.Add(state);
foreach (var client in clients)
{
server.Send(client, Packet.Create(CommandEnum.StateUpdate, state.ToBytes()));
}
}
}
if (command == CommandEnum.DeltaStateUpdate)
{
var deltaState = new TransformDeltaState();
deltaState.FromBytes(bytes);
Console.WriteLine($"TCPClient {e.client.Handle}: {deltaState}");
var startState = stateHistory.GetState(deltaState.startStateTick);
if (startState != null)
{
var endState = (TransformState)deltaState.GenerateEndState(startState);
Console.WriteLine($"End State Generated: {endState}");
var existingState = stateHistory.GetState(endState.tick);
if (existingState != null)
{
existingState.Clear();
existingState.entities.AddRange(endState.entities);
}
else
{
stateHistory.Add(endState);
foreach (var client in clients)
{
server.Send(client, Packet.Create(CommandEnum.StateUpdate, endState.ToBytes()));
}
}
}
}
}
public void LerpTowards(TransformState target, float positionLerpPct, float rotationLerpPct)
{
yaw = Mathf.Lerp(yaw, target.yaw, rotationLerpPct);
pitch = Mathf.Lerp(pitch, target.pitch, rotationLerpPct);
roll = Mathf.Lerp(roll, target.roll, rotationLerpPct);
x = Mathf.Lerp(x, target.x, positionLerpPct);
y = Mathf.Lerp(y, target.y, positionLerpPct);
z = Mathf.Lerp(z, target.z, positionLerpPct);
}
private bool GetTransformsToLerp(float renderingTime, out TransformState first, out TransformState second)
{
first = transformUpdates.FindLast(t => t.ms < renderingTime);
second = transformUpdates.Find(t => t.ms >= renderingTime);
if (first == null || second == null)
{
return(false);
}
return(true);
}
TransformState GettransformState()
{
var data = new TransformState(
new Vector3D(-10, 2, 0),
Quaternion.Euler(0f, -30f, 0f),
Vector3D.one
);
return(data);
}
void Start()
{
checkpoints = GameObject.FindGameObjectsWithTag("Checkpoint");
TransformState startState = new TransformState(transform.position, transform.rotation);
InitializeTransformHistory(startState);
lastPosition = transform.position;
}
public void UpdateClientState(TransformState newState)
{
//Don't lerp (instantly change pos) if active state was changed
if (transformState.Active != newState.Active /*|| newState.Speed == 0*/)
{
transform.localPosition = newState.localPos;
}
transformState = newState;
updateActiveStatus();
}
private void OnServerStateChanged(TransformState state)
{
if (isLocalPlayer)
{
PerformReconciliation(state);
}
else
{
transform.position = state.position;
}
}
void CreatePlayerWith(int playerId)
{
// TEMP Creates each new player at this hardcoded location.
// Need some kind of spawn location set on the server.
// Also need to keep track of players whose clients disconnected and then connected again.
// So that the new player entity gets created where it left off, and not at the spawn.
var position = new Vector3D(0, 1, -1);
var transformState = new TransformState(position);
game.CreatePlayer(playerId, transformState);
}
public static float GetRealDamage(SpellSlot slot, Obj_AI_Base target, TransformState state = TransformState.AUTOMATIC)
{
// Helpers
var spellLevel = player.Spellbook.GetSpell(slot).Level;
var damageType = Damage.DamageType.Physical;
float damage = 0;
float extraDamage = 0;
// Validate spell level
if (spellLevel == 0)
return 0;
spellLevel--;
switch (slot)
{
case SpellSlot.Q:
if (state == TransformState.MINI || state == TransformState.AUTOMATIC && player.IsMiniGnar())
{
// Throws a boomerang that deals 5/35/65/95/125 (+1.15) physical damage and slows enemies by 15/20/25/30/35% for 2 seconds.
// The boomerang returns towards Gnar after hitting an enemy, dealing 50% damage to subsequent targets. Each enemy can only be hit once.
damage = new[] { 5, 35, 65, 95, 125 }[spellLevel] + 1.15f * player.TotalAttackDamage();
}
else if (state == TransformState.MEGA || state == TransformState.AUTOMATIC && player.IsMegaGnar())
{
// Throws a boulder that stops when it hits an enemy, slowing all nearby enemies and dealing 5/45/85/125/165 (+1.2) physical damage.
damage = new[] { 5, 45, 85, 125, 165 }[spellLevel] + 1.2f * (player.BaseAttackDamage + player.FlatPhysicalDamageMod);
}
break;
case SpellSlot.W:
if (state == TransformState.MINI || state == TransformState.AUTOMATIC && player.IsMiniGnar())
{
// Every 3rd attack or spell on the same target deals an additional 10/20/30/40/50 (+1) + 6/8/10/12/14% of the target's max Health as magic damage
// and grants Gnar undefined% Movement Speed that decays over 3 seconds (max 100/150/200/250/300 damage vs. monsters).
var buff = target.Buffs.FirstOrDefault(b => b.IsActive && Game.Time < b.EndTime && b.DisplayName == "GnarWProc" && b.Caster.NetworkId == player.NetworkId);
if (buff != null && buff.Count == 2)
{
damageType = Damage.DamageType.Magical;
damage = new[] { 10, 20, 30, 40, 50 }[spellLevel] + player.TotalMagicalDamage() + new[] { 0.06f, 0.08f, 0.1f, 0.12f, 0.14f }[spellLevel] * target.MaxHealth;
// Special case for minions
if (target is Obj_AI_Minion)
{
var maxDamage = new[] { 100, 150, 200, 250, 300 }[spellLevel];
if (player.CalcDamage(target, damageType, damage) > maxDamage)
{
damageType = Damage.DamageType.True;
damage = maxDamage;
}
}
}
}
else if (state == TransformState.MEGA || state == TransformState.AUTOMATIC && player.IsMegaGnar())
{
// Stuns enemies in an area for 1.25 seconds, dealing 25/45/65/85/105 (+1) physical damage.
damage = new[] { 25, 45, 65, 85, 105 }[spellLevel] + (player.BaseAttackDamage + player.FlatPhysicalDamageMod);
}
break;
case SpellSlot.E:
if (state == TransformState.MINI || state == TransformState.AUTOMATIC && player.IsMiniGnar())
{
// Leaps to a location, gaining 20/30/40/50/60% Attack Speed for 3 seconds. If Gnar lands on a unit he will bounce off it, traveling further.
// Deals 20/60/100/140/180 (+undefined) [6% of Gnar's Max Health] physical damage and slows briefly if the unit landed on was an enemy.
damage = new[] { 20, 60, 100, 140, 180 }[spellLevel] + 0.06f * player.MaxHealth;
}
else if (state == TransformState.MEGA || state == TransformState.AUTOMATIC && player.IsMegaGnar())
{
// Leaps to a location and deals 20/60/100/140/180 (+undefined) [6% of Gnar's Max Health] physical damage to all nearby enemies on landing.
// Enemies Gnar lands directly on top of are slowed briefly.
damage = new[] { 20, 60, 100, 140, 180 }[spellLevel] + 0.06f * player.MaxHealth;
}
break;
case SpellSlot.R:
if (state == TransformState.MEGA || state == TransformState.AUTOMATIC && player.IsMegaGnar())
{
// Knocks all nearby enemies in the specified direction, dealing 200/300/400 (+0.2) (+0.5) physical damage and slowing them by 45% for 1.25/1.5/1.75 seconds.
// Any enemy that hits a wall takes 150% damage and is stunned instead of slowed.
damage = new[] { 200, 300, 400 }[spellLevel] + 0.2f * player.TotalAttackDamage();
extraDamage = (float)player.CalcDamage(target, Damage.DamageType.Magical, player.BaseAbilityDamage + player.FlatMagicDamageMod);
}
break;
}
// No damage set
if (damage == 0 && extraDamage == 0)
return 0;
// Calculate damage on target and return (-20 to make it actually more accurate Kappa)
return (float)player.CalcDamage(target, damageType, damage) + extraDamage - 20;
}
private Result GetTransform(IntPtr devicePointer, TransformState transformState, out IntPtr matrix)
{
throw new NotImplementedException();
}
public void setTransformState(TransformState state)
{
mState = state;
switch (mState)
{
case TransformState.TRANS_NONE:
mCurrentTransformer = null; break;
case TransformState.TRANS_MOVE:
mCurrentTransformer = mMover; break;
case TransformState.TRANS_ROTATE:
mCurrentTransformer = mRotater; break;
case TransformState.TRANS_SCALE:
mCurrentTransformer = mScaler; break;
}
if(mCurrentTransformer != null)
mCurrentTransformer.ParentController = this;
}
public State GetStateByName(string stateName)
{
// if ( stateName.Equals(Global.NOW_STATE))
// {
// return GetStateByName(machine.GetTempState().GetName());
// }
DataRow row = machine.GetMainRow(stateName);
State state;
if ( isFull(row,Global.TRANS_TO_COLUMN_NAME) )
{
state = new TransformState();
state.Init(row, stateName , machine);
return state;
}
else if ( isFull(row,Global.AUTO_NEXT_COLUMN_NAME))
{
if ( isFull(row,Global.DELAY_TIME_COLUMN_NAME) )
{
state = new NextTimeState();
state.Init(row, stateName , machine);
return state;
}else
{
state = new NextState();
state.Init(row,stateName,machine);
return state;
}
}
state = new State();
state.Init(row, stateName , machine);
return state;
}
public static void SetTransform(TransformState state, Matrix matrix)
{
switch (state)
{
case TransformState.Projection: MainEffect.Projection = matrix; break;
case TransformState.View: MainEffect.View = matrix; break;
case TransformState.World: MainEffect.World = matrix; break;
}
}
/// <summary>
/// Gets an object that will restore to the current transform state when disposed.
/// </summary>
/// <remarks>
/// This saves the current transform state that can be changed by any of the transform calls.
///
/// This is useful when calling into untrusted code that can leave the transform unbalanced.
/// It also ensures that RestoreTransform() requires a matching SaveTransform(), until the return value is disposed.
/// Disposing the return value guarantees that the transform state is restored to when this method was called.
/// </remarks>
/// <example>
/// This example shows how you can reliably restore state in a code block:
/// <code>
/// using (graphics.SaveTransformState())
/// {
/// // ...
///
/// graphics.SaveTransform();
/// graphics.MultiplyTransform(...);
///
/// // ... other messy drawing code that doesn't call RestoreTransform()
/// }
/// </code>
/// </example>
public IDisposable SaveTransformState()
{
Handler.SaveTransform();
var state = new TransformState { Graphics = this, MinTransformState = minTransformState, State = currentTransformState };
minTransformState = ++currentTransformState;
return state;
}
public void SetTransform(TransformState state, ref Matrix4 matrixRef)
{
int res;
fixed (void* matrixRef_ = &matrixRef)
res = Interop.Calli(comPointer, (int)state, (IntPtr)matrixRef_,(*(IntPtr**)comPointer)[44]);
if( res < 0 ) { throw new SharpDXException( res ); }
}
public void SetTransform(TransformState state, SlimDX.Matrix value)
{
device.SetTransform(state, value);
}
