public void CancelEvents(EngineValue _engineValue) { for (int i = 0; i < valueEvents.Length; i++) { valueEvents[i].CancelEvent(_engineValue); } }
public static ListValue PartList(this IShipconstruct vessel, string partType, SharedObjects sharedObj) { var list = new ListValue(); var partList = vessel.Parts.ToList(); switch (partType.ToUpper()) { case "RESOURCES": list = ResourceValue.PartsToList(partList); break; case "PARTS": list = PartValue.PartsToList(partList, sharedObj); break; case "ENGINES": list = EngineValue.PartsToList(partList, sharedObj); break; case "SENSORS": list = SensorValue.PartsToList(partList, sharedObj); break; case "ELEMENTS": list = ElementValue.PartsToList(partList); break; case "DOCKINGPORTS": list = DockingPortValue.PartsToList(partList, sharedObj); break; } return(list); }
public MaterialEngineParameter(MaterialEngineParameter engineParam) { _effectParameter = engineParam.EffectParameter; _isSemantic = engineParam.IsSemantic; _engineValue = engineParam.EngineValue; _name = engineParam.Name; }
public MaterialEngineParameter(IEffectParameter parameter, String name, bool isSemantic, EngineValue value) { _effectParameter = parameter; _isSemantic = isSemantic; _name = name; _engineValue = value; }
public MaterialEngineParameter(MaterialEngineParameter engineParam, String name, IEffectParameter replacement) { _effectParameter = replacement; _isSemantic = engineParam.IsSemantic; _engineValue = engineParam.EngineValue; _name = name; }
/// <summary> /// Convenience method for retrieving the float value corresponding to the specified engine value. /// </summary> /// <param name="valueEnum">EngineValue enum</param> /// <param name="value">float value to store result</param> /// <exception cref="System.InvalidOperationException">Thrown if the engine value specified does not correspond to a float value.</exception> public void GetValue(EngineValue valueEnum, out float value) { switch (valueEnum) { case EngineValue.AspectRatio: value = this.AspectRatio; break; case EngineValue.Time: value = this.Time; break; case EngineValue.TimePerFrame: value = this.TimePerFrame; break; case EngineValue.FrameRate: value = this.FrameRate; break; case EngineValue.RandomFloat: value = this.RandomFloat; break; default: throw new InvalidOperationException("Engine value is not a float!"); } }
public void SetEngineParameter(String paramName, bool isSemantic, EngineValue engineValue) { if (IsValid) { IEffectParameter param = null; if (isSemantic) { param = _effect.Parameters.GetParameterBySemantic(paramName); } else { param = _effect.Parameters[paramName]; } //Doesn't exist, don't create an entry if (param == null) { return; } MaterialEngineParameter engineParam = new MaterialEngineParameter(param, paramName, isSemantic, engineValue); _cachedEngineParameters[paramName] = engineParam; } else { throw new ArgumentNullException("Material does not have a valid effect loaded, cannot set engine parameter. Call LoadEffect() first."); } }
protected override void LoadDefaultData() { base.LoadDefaultData(); //get ammo value from container ammoValue = engineValueContainer.GetEngineValue (Data.engineValueSelections[Data.ammoSelection].valueSelection.valueData.ID); }
public virtual void SyncEngineValue(EngineValue _engineValue) { SetMinMaxValue(_engineValue.Data.FloatMinValue, _engineValue.Data.FloatMaxValue); SetCurValue(_engineValue.Value); connectedValue = _engineValue; connectedValue.valueChanged += SetCurValue; connectedValue.minMaxChanged += SetMinMaxValue; }
public virtual void SyncEngineValue(EngineValue _engineValue, UILayoutMaster _master, int _ind) { var val = GetEngineValueUI(_master, _ind); if (val) { val.SyncEngineValue(_engineValue); } }
public virtual EngineValue CreateEngineValue() { var val = new EngineValue { MinValue = MinValue, MaxValue = MaxValue, Value = Value }; return(val); }
/// <summary> /// Convenience method for retrieving the int value corresponding to the specified engine value. /// </summary> /// <param name="valueEnum">EngineValue enum</param> /// <param name="value">int value to store result</param> /// <exception cref="System.InvalidOperationException">Thrown if the engine value specified does not correspond to an int value.</exception> public void GetValue(EngineValue valueEnum, out int value) { switch (valueEnum) { case EngineValue.RandomInt: value = this.RandomInt; break; default: throw new InvalidOperationException("Engine value is not an int!"); } }
/// <summary> /// Convenience method for retrieving the Vector4 value corresponding to the specified engine value. /// </summary> /// <param name="valueEnum">EngineValue enum</param> /// <param name="value">fVector4 value to store result</param> /// <exception cref="System.InvalidOperationException">Thrown if the engine value specified does not correspond to a Vector4 value.</exception> public void GetValue(EngineValue valueEnum, out Vector4 value) { switch (valueEnum) { case EngineValue.Viewport: value = this.Viewport; break; default: throw new InvalidOperationException("Engine value is not a Vector4!"); } }
/// <summary> /// Convenience method for retrieving the Matrix value corresponding to the specified engine value. /// </summary> /// <param name="valueEnum">EngineValue enum</param> /// <param name="value">Matrix value to store result</param> /// <exception cref="System.InvalidOperationException">Thrown if the engine value specified does not correspond to a Matrix value.</exception> public void GetValue(EngineValue valueEnum, out Matrix value) { switch (valueEnum) { case EngineValue.WorldMatrix: value = this.WorldMatrix; break; case EngineValue.WorldMatrixInverse: value = this.WorldMatrixInverse; break; case EngineValue.WorldInverseTranspose: value = this.WorldInverseTranspose; break; case EngineValue.ViewMatrix: value = this.ViewMatrix; break; case EngineValue.ViewMatrixInverse: value = this.ViewMatrixInverse; break; case EngineValue.ProjectionMatrix: value = this.ProjectionMatrix; break; case EngineValue.ProjectionMatrixInverse: value = this.ProjectionMatrixInverse; break; case EngineValue.WorldViewMatrix: value = this.WorldViewMatrix; break; case EngineValue.ViewProjectionMatrix: value = this.ViewProjectionMatrix; break; case EngineValue.WorldViewProjection: value = this.WorldViewProjection; break; default: throw new InvalidOperationException("Engine value is not a Matrix!"); } }
/// <summary> /// Convenience method for retrieving the Vector2 value corresponding to the specified engine value. /// </summary> /// <param name="valueEnum">EngineValue enum</param> /// <param name="value">Vector2 value to store result</param> /// <exception cref="System.InvalidOperationException">Thrown if the engine value specified does not correspond to a Vector2 value.</exception> public void GetValue(EngineValue valueEnum, out Vector2 value) { switch (valueEnum) { case EngineValue.Resolution: value = this.Resolution; break; case EngineValue.FrustumNearFar: value = this.FrustumNearFar; break; default: throw new InvalidOperationException("Engine value is not a Vector2!"); } }
private kList GetEngineList(SharedObjects shared) { var list = new kList(); list.AddColumn("ID", 12, ColumnAlignment.Left); list.AddColumn("Stage", 8, ColumnAlignment.Left); list.AddColumn("Name", 28, ColumnAlignment.Left); ListValue partList = EngineValue.PartsToList(shared.Vessel.Parts, shared); foreach (Structure structure in partList) { var part = (PartValue)structure; list.AddItem(part.Part.uid(), part.Part.inverseStage, part.Part.partInfo.name); } return(list); }
private ScalarValue GetIgnitionChance(EngineValue engine) { TestFlightCore.TestFlightCore coreMod = GetCoreModule(engine); if (coreMod != null) { foreach (var module in engine.Part.Modules) { var relMod = module as TestFlightFailure_IgnitionFail; if (relMod != null) { double ignitionChance = relMod.baseIgnitionChance.Evaluate(coreMod.GetInitialFlightData()); if (ignitionChance > 0) { return(ignitionChance); } } } } return(-1f); }
/// <summary> /// Convenience method for retrieving the Vector3 value corresponding to the specified engine value. /// </summary> /// <param name="valueEnum">EngineValue enum</param> /// <param name="value">Vector3 value to store result</param> /// <exception cref="System.InvalidOperationException">Thrown if the engine value specified does not correspond to a Vector3 value.</exception> public void GetValue(EngineValue valueEnum, out Vector3 value) { switch (valueEnum) { case EngineValue.CameraDirection: value = this.CameraDirection; break; case EngineValue.CameraRight: value = this.CameraRight; break; case EngineValue.CameraPosition: value = this.CameraPosition; break; case EngineValue.CameraUp: value = this.CameraUp; break; default: throw new InvalidOperationException("Engine value is not a Vector3!"); } }
public void SetEngineParameter(String paramName, EngineValue engineValue) { SetEngineParameter(paramName, false, engineValue); }
private void ConstructPart(global::Part part, PartValue parent, DecouplerValue decoupler) { if (part.State == PartStates.DEAD || part.transform == null) { return; } PartValue self = null; foreach (var module in part.Modules) { var engine = module as IEngineStatus; if (engine != null) { self = new EngineValue(Shared, part, parent, decoupler); break; } if (module is IStageSeparator) { var dock = module as ModuleDockingNode; if (dock != null) { var port = new DockingPortValue(Shared, part, parent, decoupler, dock); self = port; dockingPorts.Add(port); if (!module.StagingEnabled()) { break; } decoupler = port; decouplers.Add(decoupler); } else { // ignore anything with staging disabled and continue the search // this can e.g. be heat shield or some sensor with integrated decoupler if (!module.StagingEnabled()) { continue; } if (module is LaunchClamp) { self = decoupler = new LaunchClampValue(Shared, part, parent, decoupler); } else if (module is ModuleDecouple || module is ModuleAnchoredDecoupler) { self = decoupler = new DecouplerValue(Shared, part, parent, decoupler); } else // ModuleServiceModule ? { continue; // rather continue the search } decouplers.Add(decoupler); } // ignore leftover decouplers if (decoupler == null || decoupler.Part.inverseStage >= StageManager.CurrentStage) { break; } // check if we just created closer decoupler (see StageValues.CreatePartSet) if (nextDecoupler == null || decoupler.Part.inverseStage > nextDecoupler.Part.inverseStage) { nextDecoupler = decoupler; } break; } var sensor = module as ModuleEnviroSensor; if (sensor != null) { self = new SensorValue(Shared, part, parent, decoupler, sensor); break; } } if (self == null) { self = new PartValue(Shared, part, parent, decoupler); } if (rootPart == null) { rootPart = self; } partCache[part] = self; allParts.Add(self); foreach (var child in part.children) { ConstructPart(child, self, decoupler); } self.Children.IsReadOnly = true; }
public void SyncEvent(EngineValue _engineValue) { _engineValue.valueChanged += CheckEvent; }
public void CancelEvent(EngineValue _engineValue) { _engineValue.valueChanged -= CheckEvent; }
private void ConstructPart(global::Part part, PartValue parent, DecouplerValue decoupler) { if (part.State == PartStates.DEAD || part.transform == null) { return; } // Modules can be in any order, so to enforce some sort of priority for parts which are multiple types, // gather all potential modules and then select from those valid. IEngineStatus engine = null; ModuleRCS rcs = null; PartValue separator = null; ModuleEnviroSensor sensor = null; foreach (var module in part.Modules) { if (module is IEngineStatus) { engine = module as IEngineStatus; } else if (module is ModuleRCS) { rcs = module as ModuleRCS; } else if (module is IStageSeparator) { var dock = module as ModuleDockingNode; if (dock != null) { var port = new DockingPortValue(Shared, part, parent, decoupler, dock); separator = port; dockingPorts.Add(port); if (!module.StagingEnabled()) { continue; } decoupler = port; decouplers.Add(decoupler); } // ignore anything with staging disabled and continue the search // this can e.g. be heat shield or some sensor with integrated decoupler else { if (!module.StagingEnabled()) { continue; } if (module is LaunchClamp) { separator = decoupler = new LaunchClampValue(Shared, part, parent, decoupler); } else if (module is ModuleDecouple || module is ModuleAnchoredDecoupler) { separator = decoupler = new DecouplerValue(Shared, part, parent, decoupler); } else // ModuleServiceModule ? { continue; // rather continue the search } decouplers.Add(decoupler); } // ignore leftover decouplers if (decoupler == null || decoupler.Part.inverseStage >= StageManager.CurrentStage) { continue; } // check if we just created closer decoupler (see StageValues.CreatePartSet) if (nextDecoupler == null || decoupler.Part.inverseStage > nextDecoupler.Part.inverseStage) { nextDecoupler = decoupler; } } else if (module is ModuleEnviroSensor) { sensor = module as ModuleEnviroSensor; } } // Select part value in priority order PartValue self; if (engine != null) { self = new EngineValue(Shared, part, parent, decoupler); } else if (rcs != null) { self = new RCSValue(Shared, part, parent, decoupler, rcs); } else if (separator != null) { self = separator; } else if (sensor != null) { self = new SensorValue(Shared, part, parent, decoupler, sensor); } else { self = new PartValue(Shared, part, parent, decoupler); } if (rootPart == null) { rootPart = self; } partCache[part] = self; allParts.Add(self); foreach (var child in part.children) { ConstructPart(child, self, decoupler); } self.Children.IsReadOnly = true; }