public override void UpdateLayoutHierarchy()
{
if (mChildren != null)
{
for (int i = 0; i < mChildren.Length; i++)
{
if (mChildren[i] != null)
{
mChildren[i].SetLayoutParent(null);
}
}
}
List <UILayoutBase> children = new List <UILayoutBase>();
for (int i = 0; i < MyTransform.childCount; i++)
{
UILayoutBase child = MyTransform.GetChild(i).GetComponent <UILayoutBase>();
if (child == null)
{
continue;
}
children.Add(child);
child.SetLayoutParent(this);
child.UpdateLayoutHierarchy();
}
mChildren = children.ToArray();
}
void StartTransitionTo(MyTransform target)
{
initialTransform = new MyTransform(transform);
targetTransform = target;
progress = 0;
isCameraTransitioning = true;
}
private void Update()
{
if (!targetTransform)
{
return;
}
switch (option)
{
case Options.Standard:
MyTransform.LookAt(targetTransform);
break;
case Options.YAxisOnly:
var v = targetTransform.position - MyTransform.position;
v.x = v.z = 0.0f;
MyTransform.LookAt(targetTransform.transform.position - v);
break;
case Options.RotWithSlerp:
RotateWithSlerp();
break;
case Options.RotThreshold:
RotateWithinThreshold();
break;
case Options.RotWithSDA:
RotateWithSDA();
break;
}
}
void Update()
{
if (Input.GetMouseButtonDown(0))
{
//mode =! mode;
}
if (Input.GetMouseButtonDown(0))
{
// Entityセット用のデータ作成
MyTransform trans = new MyTransform();
CharaData chara = new CharaData();
for (int i = 0; i < clickInstance; ++i)
{
// Entityの作成
var entity = manager.CreateEntity(charaArch);
//座標セット
float x = -InitPosXParam + i * 2 * InitPosXParam / clickInstance;
trans.position = new Vector3(x, 0.5f, -InitPosZParam);
// キャラクターのデータセット
chara.time = Random.Range(0.0f, 3.0f); // 少し揺れ幅を持たせます
chara.velocity = new Vector3(0.0f, 0.0f, 3.0f);
// 生成したEntitiyにデータセット
manager.SetComponentData(entity, trans);
manager.SetComponentData(entity, chara);
}
}
// デバッグ情報更新
DebugUI.SetCharaNum(charaSystem.CharaNum);
charaSystem.Update();
}
// Use this for initialization
void Start()
{
#if UNITY_WSA
RegistResolver();
#endif
//初期位置を記録する
startTrans = new MyTransform();
startTrans.SetData(Recorder.transform, 0);
myTransforms = new List <MyTransform>();
#if ENABLE_DOTNET
Debug.Log(".net");
#endif
#if ENABLE_IL2CPP
Debug.Log("IL2CPP");
#endif
#if WINDOWS_UWP
// UWP上での動作の場合、LocalAppData/AppName/LocalStateフォルダを参照する
saveFileName = System.IO.Path.Combine(Windows.Storage.ApplicationData.Current.LocalFolder.Path, saveFileName);
#else
// Unity上での動作の場合、Assets/StreamingAssetsフォルダを参照する
saveFileName = System.IO.Path.Combine(UnityEngine.Application.streamingAssetsPath, saveFileName);
#endif
// TestObjList();
}
// Update is called once per frame
void Update()
{
float time = Time.realtimeSinceStartup - timeFromStart;
if (isRecording)
{
MyTransform t = new MyTransform();
t.SetData(Recorder.transform, time);
myTransforms.Add(t);
counter++;
}
else if (isPlaying)
{
//最後まで再生したらループする
if (counter >= myTransforms.Count)
{
StartPlay();
}
else
{
var playTransform = myTransforms[counter];
if (time > playTransform.Time)
{
Player.transform.position = playTransform.Pos;
Player.transform.rotation = playTransform.Rot;
Player.transform.localScale = playTransform.Scale;
counter++;
}
}
}
}
private IEnumerator LerpCoroutine(RectTransform rectTransform, MyTransform myTransform)
{
var sourcePos = rectTransform.position;
var sourceRot = rectTransform.localRotation;
var sourceScale = rectTransform.localScale;
var targetPos = new Vector3(myTransform.x * translateCoeff, myTransform.y * translateCoeff, 0);
var targetRot = Quaternion.Euler(0, 0, myTransform.rotation * rotateCoeff);
var targetScale = Vector3.one * myTransform.scale * scaleCoeff;
const float duration = 0.25f;
for (float f = 0; f < duration; f += Time.deltaTime)
{
float t = LerpCurve.Evaluate(f / duration);
rectTransform.position = Vector3.Lerp(sourcePos, targetPos, t);
rectTransform.localRotation = Quaternion.Slerp(sourceRot, targetRot, t);
rectTransform.localScale = Vector3.Lerp(sourceScale, targetScale, t);
yield return(null);
}
rectTransform.position = targetPos;
rectTransform.localRotation = targetRot;
rectTransform.localScale = targetScale;
UpdateSizeTexts();
}
public void Move(Point movement)
{
var delta = new PointF(
movement.X * Speed.X * (float)Timer.DeltaTime,
movement.Y * Speed.Y * (float)Timer.DeltaTime);
if (movement.X > 0)
{
MyTransform.rotation = 90;
}
else if (movement.X < 0)
{
MyTransform.rotation = -90;
}
else if (movement.Y > 0)
{
MyTransform.rotation = 180;
}
else if (movement.Y < 0)
{
MyTransform.rotation = 0;
}
lastMovement = movement;
MyTransform.Translate(delta);
}
void LookAtCenter()
{
float y = -75;
MyTransform.LookAt(new Vector3(0, y, 0), Vector3.up);
MyTransform.SetLocalEulerAnglesX(MyTransform.localEulerAngles.x - 90f);
}
public static Dictionary <string, MyTransform> ReaderXml(string path)
{
Dictionary <string, MyTransform> itemstransform = new Dictionary <string, MyTransform>();
XmlDocument xmldoc = new XmlDocument();
xmldoc.Load(path);
XmlNode xn = xmldoc.SelectSingleNode("RobotPro");
for (int i = xn.ChildNodes.Count - 1; i >= 0; i--)
{
MyTransform my = new MyTransform();
string str = xn.ChildNodes[i].Attributes["name"].Value;
my.name = str;
my.id = int.Parse(xn.ChildNodes[i].Attributes["id"].Value);
my.info = xn.ChildNodes[i].Attributes["info"].Value;
XmlNodeList list = xn.ChildNodes[i].ChildNodes;
for (int j = 0; j < list.Count; j++)
{
string[] single = list[j].InnerText.Split('/');
string[] pos = single[0].Split(',');
string[] rot = single[1].Split(',');
Vector3 p = Vector3.zero;
p.x = float.Parse(pos[0]);
p.y = float.Parse(pos[1]);
p.z = float.Parse(pos[2]);
Vector3 r = Vector3.zero;
r.x = float.Parse(rot[0]);
r.y = float.Parse(rot[1]);
r.z = float.Parse(rot[2]);
switch (list[j].Attributes["name"].Value)
{
case "Spown":
my.Spownpos = p;
my.Spownrot = r;
break;
case "SlowDown":
my.SlowDownpos = p;
my.SlowDownrot = r;
break;
case "Target":
my.Targetpos = p;
my.Targetrot = r;
break;
case "Camera":
my.Camerapos = p;
my.Camerarot = r;
break;
default:
break;
}
}
itemstransform.Add(str, my);
}
return(itemstransform);
}
/// <summary>
/// 初始化Buffer
/// </summary>
void IniBuffer()
{
BufferDic = new Dictionary <int, List <BufferEntity> >();
PermanentBufferList = new List <PermanentBufferEntity>();
Trans_BufferList = MyTransform.FindChild("BufferList");
Prefab_BufferEntity = Resources.Load <GameObject>("GameObjects/FightScene/Chara/BufferDumy");
Prefab_PermanentBufferEntity = Resources.Load <GameObject>("GameObjects/FightScene/Chara/PermanentBufferDumy");
}
public virtual void DebugDraw()
{
MyTransform gridTransform = new MyTransform(m_blockA.Block.CubeGrid.WorldMatrix);
var worldCenterA = MyTransform.Transform(ref m_blockA.Transform.Position, ref gridTransform);
var worldCenterB = MyTransform.Transform(ref m_blockB.Transform.Position, ref gridTransform);
VRageRender.MyRenderProxy.DebugDrawLine3D(worldCenterA, worldCenterB, m_debugLineColor, m_debugLineColor, false);
}
void LoadPlayerTransform()
{
GameObject player = GameObject.Find("郭靖");
MyTransform myTransform = GameObject.Find("GM").GetComponent <GlobeManager>().GetPlayer("郭靖").M_BasicProperty.M_Transform;
player.transform.position = new Vector3(myTransform.Pos_x, myTransform.Pos_y, myTransform.Pos_z);
player.transform.rotation = Quaternion.Euler(myTransform.R_x, myTransform.R_y, myTransform.R_z);
player.transform.localScale = new Vector3(myTransform.S_x, myTransform.S_y, myTransform.S_z);
}
/// <summary>
/// 設定腳色Model
/// </summary>
void IniMotion()
{
//腳色動畫
Ani_Chara = MyTransform.FindChild("Model").GetComponent <Animator>();
//腳色圖像
SR_Chara = MyTransform.FindChild("Model").FindChild("sprite").GetComponent <SpriteRenderer>();
//初始化施法位置與縮放
IniSpellPosAndScale();
}
void Update()
{
// funcky texture thing
Renderer.sharedMaterial.mainTextureOffset = new Vector2(Mathf.PerlinNoise(materialOffset, 0), 0f);
materialOffset += 0.001f;
// update sea y position baseed on sea level and tide
MyTransform.SetLocalPositionY(Level);
}
IEnumerator CoSpin()
{
float a = 0f;
while (gameObject.activeSelf)
{
MyTransform.SetLocalEulerAnglesY(a);
a += spinSpeed * Time.deltaTime;
yield return(null);
}
}
private void AnimateMove(Vector3 move)
{
if (!_animator)
{
return;
}
Vector3 tempMovement = MyTransform.InverseTransformDirection(move);
_animator.SetFloat("hor", tempMovement.x);
_animator.SetFloat("vert", tempMovement.z);
}
public static MyTransform operator *(MyTransform parent, MyTransform child)
{
MyTransform result = new MyTransform();
MyTransform combined = parent;
// swap this for matrix math
result.LocalPosition = (combined.LocalRotation * child.LocalPosition) + combined.LocalPosition;
result.LocalRotation = combined.LocalRotation * child.LocalRotation;
return result;
}
void LerpTransform(MyTransform initialTransform, MyTransform targetTransform, float speed)
{
progress += 1 / speed * GlobalTimer.Instance.NonAcceleratedTime;
transform.position = Vector3.Lerp(initialTransform.position, targetTransform.position, progress);
transform.rotation = Quaternion.Lerp(initialTransform.rotation, targetTransform.rotation, progress);
if (progress >= 1f)
{
SetCameraTransorm(targetTransform);
isCameraTransitioning = false;
}
}
/// <summary>
/// Zooms the Camera To the selected Planet
/// </summary>
void ZoomToPlanet()
{
Vector3 directionTowardsPlayer = (transform.position - SelectedPlanet.transform.position).normalized;
Vector3 newPosition = SelectedPlanet.transform.position + directionTowardsPlayer * SelectedPlanet.GetDistance();
Quaternion lookAtRotation = Quaternion.LookRotation((SelectedPlanet.transform.position - transform.position).normalized);
//Struct info about target transform
MyTransform targetTransform = new MyTransform(newPosition, lookAtRotation, new Vector3(1, 1, 1));
StartTransitionTo(targetTransform);
}
public virtual void Bind(BlockState blockA, BlockState blockB)
{
m_blockA = blockA;
m_blockB = blockB;
Vector3D centerA, centerB;
blockA.Block.ComputeScaledCenter(out centerA);
blockB.Block.ComputeScaledCenter(out centerB);
Vector3 pivot = (centerA + centerB) * 0.5f;
m_pivotA = new MyTransform(pivot - centerA);
m_pivotB = new MyTransform(pivot - centerB);
}
//will assign materials
public void StartMaterial()
{
if (MyTransform != null)
{
//get the materials from MyTransform and then assign the first one...
mats = MyTransform.GetComponent <Renderer>().materials;
myTransformOriginalName = MyTransform.name;
MyTransform.name = transform.name;
//this WAS A 6 HOURS BUG ... WAS REFERENCING THEN AT THE BEGGINING THATS
//WHY WOULD LOOK ABRUPT IN THE FADE
//mats[0] = materiales[0];
}
}
public void addItem(GameObject g)
{
if (state != 0)
{
return;
}
items.Add(g);
MyTransform myt = new MyTransform();
myt.rotation = g.transform.rotation;
myt.position = g.transform.position;
myt.scale = g.transform.localScale;
itemsStartPoint.Add(myt);
}
/// <summary>
/// Moves the player in the world once clicked.
/// </summary>
void Update()
{
var speedToSet = Mathf.Abs(PlayerSpeed.x);
if (_moving)
{
MyTransform.Translate(PlayerSpeed * SceneManager.Instance.DeltaTime, Space.World);
}
else
{
speedToSet = 0f;
}
PlayerAnimation.Speed = speedToSet;
}
private void UpdateFacing()
{
switch (faceObject)
{
case FacingType.None:
break;
case FacingType.Toward:
MyTransform.LookAt(orbitObject);
break;
case FacingType.Away:
MyTransform.LookAt(Position + Position.GetDir_AwayFrom(orbitObject.position));
break;
}
}
private void ResizeToFit()
{
if (mChildren == null || mChildren.Length == 0)
{
return;
}
// <TODO> This code should take Axis into account
float highest = 0;
float lowest = float.MaxValue;
for (int i = 0; i < mChildren.Length; i++)
{
if (mChildren[i] == null)
{
continue;
}
Rect rect = mChildren[i].MyTransform.rect;
float pos = mAxis == RectTransform.Axis.Vertical
? mChildren[i].MyTransform.anchoredPosition.y
: mChildren[i].MyTransform.anchoredPosition.x;
float min = pos + (mAxis == RectTransform.Axis.Vertical ? rect.yMin : rect.xMin);
float max = pos + (mAxis == RectTransform.Axis.Vertical ? rect.yMax : rect.xMax);
if (min < lowest)
{
lowest = min;
}
if (max > highest)
{
highest = max;
}
}
float size = highest - lowest;
size += mPaddingHigh;
//Debug.Log("Highest: " + highest + ", lowest: " + lowest + ", size: " + size);
MyTransform.SetSizeWithCurrentAnchors(mAxis, size);
}
/**
* 存储人物位置
* */
private void SavePlayerTransform()
{
MyTransform myTransform = GameObject.Find("GM").GetComponent <GlobeManager>().GetPlayer("郭靖").M_BasicProperty.M_Transform;
GameObject player = GameObject.Find("郭靖");
myTransform.Pos_x = player.GetComponent <Transform>().position.x;
myTransform.Pos_y = player.GetComponent <Transform>().position.y;
myTransform.Pos_z = player.GetComponent <Transform>().position.z;
myTransform.R_x = player.GetComponent <Transform>().localEulerAngles.x;
myTransform.R_y = player.GetComponent <Transform>().localEulerAngles.y;
myTransform.R_z = player.GetComponent <Transform>().localEulerAngles.z;
myTransform.S_x = player.GetComponent <Transform>().localScale.x;
myTransform.S_y = player.GetComponent <Transform>().localScale.x;
myTransform.S_z = player.GetComponent <Transform>().localScale.x;
}
// Update is called once per frame
public override void Update()
{
if (MyGameObject.activeSelf == true)
{
FlyTime += Time.deltaTime;
MyTransform.Translate(Direction * Vx * Time.deltaTime);
//v*t
MyTransform.Translate(Vector3.up * G * FlyTime * Time.deltaTime);
//t*(0+at)
if (this.MyTransform.position.y < -5f)
{
this.destroy = true;
this.enable = false;
this.Callback.SSActionEvent(this);
}
}
}
// ###########################
protected override void AddCollider()
{
Transform child = MyTransform.GetChild(0);
if (child != null)
{
CapsuleCollider col = MyGameObject.AddComponent <CapsuleCollider>();
Vector3 toChild = child.position - MyTransform.position;
int dirIndex = Utils.GetDirectionIndex(MyTransform, toChild.normalized);
float distanceToChild = toChild.magnitude / MyTransform.lossyScale[dirIndex];
col.center = CalculateCentre(dirIndex, distanceToChild);
col.direction = dirIndex;
col.radius = distanceToChild * 0.2f;
col.height = distanceToChild;
}
}
void Update()
{
if (LocomotionActive)
{
MyTransform.Translate(Locomotion * SceneManager.Instance.DeltaTime, Space.World);
}
if (_inRotation)
{
_rotationTimer += SceneManager.Instance.DeltaTime;
Rb.rotation = Mathf.Lerp(_startRotation, _rotationTarget, Mathf.Min(_rotationTimer / _rotationEndTime));
if (_rotationTimer >= _rotationEndTime)
{
_inRotation = false;
}
}
}
void ZoomToRegion(RaycastHit hitResult)
{
var continentDirection = hitResult.transform.GetComponent <ContinentDirection>();
Vector3 directionVector = hitResult.normal;
if (continentDirection != null)
{
directionVector = continentDirection.getWorldDirection().normalized;
}
Vector3 position = SelectedPlanet.transform.position + directionVector * SelectedPlanet.GetDistance();
Quaternion lookAtRotation = Quaternion.LookRotation((SelectedPlanet.transform.position - position).normalized);
MyTransform targetTransform = new MyTransform(position, lookAtRotation, new Vector3(1, 1, 1));
StartTransitionTo(targetTransform);
}
public void UpdateTransform(MyTransform t)
{
// allow any node to be moved
myTransform = InitialTransform;
t = t * myTransform;
if (!isRoot)
{
transform.position = t.LocalPosition;
transform.rotation = t.LocalRotation;
}
foreach (ParentTransform child in children)
{
ParentTransform childParentTransform = child.GetComponent<ParentTransform>();
if (childParentTransform != null)
{
childParentTransform.UpdateTransform(t);
}
}
}
void Start()
{
InitialTransform = new MyTransform(transform);
}
