internal static void Prefix(TransformWrapper __instance, IVisitor visitor)
{
if (!(visitor is Serializers.Serializer) && !(visitor is Serializers.Deserializer))
{
Transform ObjectTransform = __instance.tComponent_;
if (!ObjectTransform.IsRoot())
{
visitor.VisitAction("Inspect Parent", () =>
{
var Editor = G.Sys.LevelEditor_;
var Selection = Editor.SelectedObjects_;
if (Selection.Count == 1)
{
EditorUtil.Inspect(ObjectTransform.parent.gameObject);
}
else
{
MessageBox.Create("You must select only 1 object to use this tool.", "ERROR")
.SetButtons(MessageButtons.Ok)
.Show();
}
}, null);
}
}
}
public override void WriteJson(JsonWriter writer, Transform value, JsonSerializer serializer)
{
var transformWrapper = new TransformWrapper(value);
var wrapperJson = JsonUtility.ToJson(transformWrapper);
writer.WriteValue(wrapperJson);
}
public void LoadWrapper(TransformWrapper wrapper)
{
profile = wrapper.profile;
modifiers = wrapper.modifiers;
rollPosModifier = wrapper.rollPosModifier;
pitchPosModifier = wrapper.pitchPosModifier;
useTransformRotation = wrapper.useTransformRotation;
rollAmpFactor = wrapper.rollAmpFactor;
}
public void setWrapper(ref TransformWrapper wrapper)
{
wrapper.rollAmpFactor = rollAmpFactor;
wrapper.profile = profile;
wrapper.modifiers = modifiers;
wrapper.pitchPosModifier = pitchPosModifier;
wrapper.rollPosModifier = rollPosModifier;
wrapper.useTransformRotation = useTransformRotation;
}
public void LoadWrapper(TransformWrapper wrapper)
{
profile = wrapper.profile;
modifiers = wrapper.modifiers;
rollPosModifier = wrapper.rollPosModifier;
pitchPosModifier = wrapper.pitchPosModifier;
useTransformRotation = wrapper.useTransformRotation;
rollAmpFactor = wrapper.rollAmpFactor;
}
public void setWrapper(ref TransformWrapper wrapper)
{
wrapper.rollAmpFactor = rollAmpFactor;
wrapper.profile = profile;
wrapper.modifiers = modifiers;
wrapper.pitchPosModifier = pitchPosModifier;
wrapper.rollPosModifier = rollPosModifier;
wrapper.useTransformRotation = useTransformRotation;
}
public object Call(Interpreter interpreter, Token token, List <object> arguments)
{
if (!(arguments[0] is TransformWrapper))
{
throw new ErrorHandler.RuntimeError(token, "First argument must be a unity transform");
}
TransformWrapper other = (TransformWrapper)arguments[0];
return(self.self.IsChildOf(other.self));
}
void Awake()
{
if (Instance == null)
{
Instance = this;
}
else
{
DestroyImmediate(this);
}
}
public PredictionEngineExample(string modelName)
{
_env = EnvHelper.NewTestEnvironment();
var view = DataViewConstructionUtils.CreateFromEnumerable(_env, new FloatVectorInput[] { });
var pipe = DataViewConstructionUtils.LoadPipeWithPredictor(_env, File.OpenRead(modelName),
new EmptyDataView(_env, view.Schema));
var transformer = new TransformWrapper(_env, pipe);
_predictor = _env.CreatePredictionEngine <FloatVectorInput, FloatOutput>(transformer);
}
private static Func <Schema, IRowToRowMapper> StreamChecker(IHostEnvironment env, Stream modelStream)
{
env.CheckValue(modelStream, nameof(modelStream));
return(schema =>
{
var pipe = DataViewConstructionUtils.LoadPipeWithPredictor(env, modelStream, new EmptyDataView(env, schema));
var transformer = new TransformWrapper(env, pipe);
env.CheckParam(transformer.IsRowToRowMapper, nameof(transformer), "Must be a row to row mapper");
return transformer.GetRowToRowMapper(schema);
});
}
public void Initialize(Sprite characterSprite, string speechMessage, Color backgroundColor, TransformWrapper newParent)
{
this.characterImage.sprite = characterSprite;
this.speechText.text = speechMessage;
this.background.color = backgroundColor;
transformWrapper = new TransformWrapper(transform);
transformWrapper.SetParent(newParent);
SetGameObjectActive(false);
}
// initialize a roll joint data for the given joint as parent
private void JoinRollJoint(string rollJointName, Omek.JointID parentJointID)
{
TransformWrapper tw = m_hierarchyList.Find((a) => { return(a.m_jointID == parentJointID); });
RollJointWrapper rjw = m_rollJointsList.Find((a) => { return(a.m_name == rollJointName); });
tw.m_rollJoint = rjw;
rjw.m_parentWrapper = tw;
if (tw.m_transform != null)
{
rjw.m_originalParentRotation = tw.m_transform.localRotation;
rjw.m_inverseOriginalParentRotation = Quaternion.Inverse(rjw.m_originalParentRotation);
}
}
public void MakeProtectionEvidentOnSelectedIfNeeded(bool attackerIgnoresBlock)
{
int selectedIndex = GetSelectedIndex();
Card cardInFrontOfTarget = GetCardInFrontOf(selectedIndex);
bool attackWillBeBlocked = cardInFrontOfTarget != null && cardInFrontOfTarget.HasBlockSkill();
if (IsThereACardInFrontOf(selectedIndex) && !attackerIgnoresBlock && !attackWillBeBlocked)
{
TransformWrapper protectionTransformWrapper =
new TransformWrapper(protectionVFXtoEachCard[selectedIndex].transform);
StartCoroutine(MakeEvident(protectionTransformWrapper));
cards[selectedIndex].MakeProtectionEvident();
}
}
private void SetJointActiveForChildren(Transform trans, bool isActive)
{
TransformWrapper tw = m_hierarchyList.Find((a) => { return(a.m_transform == trans); });
if (tw != null)
{
tw.m_active = isActive;
}
RollJointWrapper rjw = m_rollJointsList.Find((a) => { return(a.m_transform == trans); });
if (rjw != null)
{
rjw.m_active = isActive;
}
foreach (Transform child in trans)
{
SetJointActiveForChildren(child, isActive);
}
}
public object Call(Interpreter interpreter, Token token, List <object> arguments)
{
if (arguments[0] == null)
{
self.self.parent = null;
return(null);
}
if (!(arguments[0] is TransformWrapper))
{
throw new ErrorHandler.RuntimeError(token, "First argument must be a unity transform");
}
TransformWrapper other = (TransformWrapper)arguments[0];
self.self.SetParent(other.self, (bool)arguments[1]);
self.parentWrapper = other;
return(null);
}
private IEnumerator MakeEvident(TransformWrapper objectToDetach)
{
Vector3 originalScale = objectToDetach.LocalScale;
Vector3 targetScale = originalScale + new Vector3(increaseScaleValueInProtectionAnimation,
increaseScaleValueInProtectionAnimation, 0.0f);
while (objectToDetach.LocalScale.x < targetScale.x)
{
float t = TimeFacade.DeltaTime * increaseScaleSpeedMultiplier;
objectToDetach.LocalScale += new Vector3(t, t, t);
yield return(null);
}
while (objectToDetach.LocalScale.x > originalScale.x)
{
float t = TimeFacade.DeltaTime * increaseScaleSpeedMultiplier;
objectToDetach.LocalScale -= new Vector3(t, t, t);
yield return(null);
}
objectToDetach.LocalScale = originalScale;
}
public IsChildOf(TransformWrapper self)
{
this.self = self;
}
void loadActiveProfile()
{
wrapper = this.gameObject.AddComponent<TransformWrapper>();
serializer.setWrapper(ref wrapper);
}
void loadActiveProfile()
{
wrapper = this.gameObject.AddComponent <TransformWrapper>();
serializer.setWrapper(ref wrapper);
}
public GetSiblingIndex(TransformWrapper self)
{
this.self = self;
}
public GetChildCount(TransformWrapper self)
{
this.self = self;
}
public SetParent(TransformWrapper self)
{
this.self = self;
}
public SimulatorSerialization(TransformWrapper wrapper)
{
LoadWrapper(wrapper);
}
public SimulatorSerialization(TransformWrapper wrapper)
{
LoadWrapper(wrapper);
}
