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); }