public void UpdateTouch(Vector2 touchPosition) {
position = touchPosition;
position.Scale(new Vector2(1f / (float)Screen.currentResolution.width, 1f / (float)Screen.currentResolution.height));
position.y = 1 - position.y;
position.Scale(new Vector2((float)Screen.width, (float)Screen.height));
phase = TouchPhase.Moved;
updated = true;
}
void initBranches()
{
for (int i = 1; i < bonesBody.transform.childCount -1; i++)
{
var slope = new Vector2(Random.Range(10, 20), Random.Range(20, 30));
if (Random.Range(0, 2) == 0) slope.Scale(new Vector2(-1, 1));
if (Random.Range(0, 2) == 0) slope.Scale(new Vector2(1, -1));
initBranchShort(bonesBranch, bonesBody.transform.GetChild(i), levelHeight * Random.Range(.5f, .7f), 5, slope, 60);
initBranchShort(bonesBranch, bonesBody.transform.GetChild(i), levelHeight * Random.Range(.2f, .5f), 3, slope);
}
}
void Init()
{
currentPosition = Step;
currentPosition.Scale (StartPosition);
itsTransform.anchorMin = currentPosition;
itsTransform.anchorMax = currentPosition + Step;
}
public void Mover(float horizontal, float vertical, ForceMode2D mode)
{
direcao = new Vector2(horizontal * (-1), vertical * (-1));
direcao.Normalize();
direcao.Scale(new Vector2(200, 200));
// impulsionando o objeto pra direcao oposta
gosma.GetComponent<Rigidbody2D>().AddForce(direcao, mode);
}
void Update()
{
Vector3 userPosition = MapBounds.ClosestPointOnBounds(_head.transform.position);
Vector3 userForward = _head.transform.forward;
var scale = new Vector2(1f / MapBounds.bounds.size.x, 1f / MapBounds.bounds.size.z);
userPosition = userPosition - (MapBounds.bounds.center - MapBounds.bounds.size / 2);
var cursorPosition = new Vector2(userPosition.x, userPosition.z);
cursorPosition.Scale(scale);
cursorPosition.Scale(MapPanel.rect.size);
cursorPosition -= MapPanel.rect.size / 2;
CursorImage.rectTransform.localPosition = cursorPosition;
Quaternion quaternion = Quaternion.FromToRotation(userForward, MapBounds.transform.forward);
CursorImage.rectTransform.localRotation = Quaternion.Euler(0, 0, quaternion.eulerAngles.y);
if (MapBounds.bounds.Contains(User.transform.position))
{
for (int i = 0; i < FloorsHeight.Length; i++)
if (User.transform.position.y > FloorsHeight[i])
{
FloorText.text = FloorsLabels[i];
for (int j = 0; j < FloorsMaps.Length; j++)
FloorsMaps[j].gameObject.SetActive(j == i);
break;
}
}
else
FloorText.text = "";
if (AutoNavigationManager.Enabled && !AutoNavigationManager.IsMoving && AutoNavigationManager.TargetedKeyPoint != null)
{
DestinationText.gameObject.SetActive(true);
AutoNavText.gameObject.SetActive(true);
DestinationText.text = string.Format("Cible : {0}", AutoNavigationManager.TargetedKeyPoint.pointName);
}
else
{
DestinationText.gameObject.SetActive(false);
AutoNavText.gameObject.SetActive(false);
}
}
// Use this for initialization
void Start()
{
// This is invalid if we have fewer than two locatinos.
if (locations.Count >= 2)
{
this.transform.position = locations[0];
movementVector = (locations[1] - locations[0]).normalized;
movementVector.Scale(new Vector2(speed, speed));
}
}
public void GerarMassaPerdida(Vector2 direction, Vector3 position)
{
//Debug.Log("Instanciou");
aux = (GameObject) Instantiate(massaPerdida);
direction.Normalize();
direction.Scale(new Vector2(5000, 5000));
aux.transform.position = position;
aux.GetComponent<Rigidbody2D>().AddForce(direction, ForceMode2D.Force);
aux.transform.SetParent (gosma.transform);
}
public void GerarMassaPerdida(Vector2 direction, Vector3 position)
{
//Debug.Log("Instanciou");
MassaPerdidaObj = (GameObject) Instantiate(massaPerdida);
direction.Normalize();
direction.Scale(new Vector2(ForcaImpulso, ForcaImpulso));
MassaPerdidaObj.transform.position = position;
MassaPerdidaObj.GetComponent<Rigidbody2D>().AddForce(direction, ForceMode2D.Impulse);
// // Modified By JMG RemoverMassaGosma();
}
public void positionCollider()
{
var gridDimensions = new Vector2 ((float)size * 2.1f, (float)size * 2.1f);
gridDimensions.Scale ( cellPrefab.Dimensions);
Vector3 coliderSize = new Vector3(gridDimensions.x, 0.5f, gridDimensions.y);
this.GetComponent<BoxCollider> ().size = coliderSize;
}
public static Vector2 getSpawnPointOutsideScreen()
{
float radians = Random.value * 2 * Mathf.PI;
float x = Mathf.Sin(radians);
float y = Mathf.Cos(radians);
Vector2 vector = new Vector2(x,y);
vector.Normalize();
float distanceOut = Main.BOARD_RADIUS + RADIUS;
vector.Scale(new Vector2(distanceOut,distanceOut));
vector = Main.BOARD_CENTER + vector;
return vector;
}
public static Vector2 getOpposingPoint(Vector2 point, float withinRadians)
{
Vector2 centerMinusStart = Main.BOARD_CENTER - point;
float radians = (Vector2.Angle(Vector2.up, centerMinusStart) / 180) * Mathf.PI;
if (centerMinusStart.x < 0) {
radians = (2f * Mathf.PI) - radians;
}
radians += (withinRadians * Random.value) - (withinRadians / 2);
Vector2 vector = new Vector2(Mathf.Sin(radians), Mathf.Cos(radians));
vector.Normalize();
float distanceOut = Main.BOARD_RADIUS + RADIUS;
vector.Scale(new Vector2(distanceOut,distanceOut));
return Main.BOARD_CENTER + vector;
}
void FireBullet(Vector2 direction)
{
//the direction values are all 1 or 0 this converts 1's into the bullet speed
direction.Scale(new Vector2(_bulletSpeed,_bulletSpeed));
//Create the bullet slightly away from the player
Vector3 bulletPosition = gameObject.transform.position;
bulletPosition.x += direction.x * 0.1f;
bulletPosition.y += direction.y * 0.1f;
GameObject bulletInstance = Instantiate(_bulletPrefab,bulletPosition, Quaternion.identity) as GameObject;
//set the bullets speed and damage
bulletInstance.GetComponent<BulletScript>().Setup(direction,_bulletDamage);
//set the fire delay
_canFire = false;
_fireDelayCounter = _fireDelay;
}
Vector2 applyForcePlayer(float x1, float y1, float playerX, float playerY, Vector2 currentForceVector)
{
float deltaX = playerX-x1;
float deltaY = playerY-y1;
float distance = getDistance(x1,y1, playerX, playerY);
float repulsion = playerScalar*(speed/100.0f)/Mathf.Pow(distance, 2);
Vector2 unitVector = new Vector2(deltaX, deltaY).normalized;
unitVector.Scale(new Vector2(repulsion, repulsion));
Vector2 forceVector = unitVector;
currentForceVector = new Vector2(currentForceVector.x+forceVector.x, currentForceVector.y + forceVector.y);
return currentForceVector;
}
void RecalculateBounds() {
bounds = new Bounds();
bool boundsSet = false;
UISprite[] sprites = GetComponentsInChildren<UISprite>();
foreach (UISprite sprite in sprites) {
var size = new Vector2(sprite.width, sprite.height);
size.Scale(sprite.cachedTransform.localScale);
if (!boundsSet) {
bounds = new Bounds(size / 2, size);
boundsSet = true;
} else {
bounds.Encapsulate(size);
}
}
}
void OnGUI()
{
var wrappedAmount = amount - Mathf.Floor(amount);
Vector2 screenPos;
if (anchorToScreen)
{
var counterAlignmentOffset = new Vector2(alignment.x < .5f ? 0 : -size, alignment.y < .5f ? size : 0);
screenPos = new Vector2(Screen.width, Screen.height);
screenPos.Scale(alignment);
screenPos += counterAlignmentOffset;
}
else
{
screenPos = MathUtil.GetBasePointWithAlignment(gameObject, alignment);
// TODO: Find out why WorldToScreenPoint gets the Y
// coordinate inverted.
screenPos.y = Screen.height - screenPos.y;
}
var clockRect = new Rect(screenPos.x - (size - size * alignment.x),
screenPos.y - (size - size * alignment.y),
size,
size);
if (wrappedAmount < .5f)
{
DrawRotatedTexture(clockRect, right, 0);
DrawRotatedTexture(clockRect, rightBackground, wrappedAmount);
DrawRotatedTexture(clockRect, rightBackground, .5f);
}
else if (wrappedAmount >= .5f)
{
DrawRotatedTexture(clockRect, right, .5f);
DrawRotatedTexture(clockRect, rightBackground, wrappedAmount);
DrawRotatedTexture(clockRect, right, 0);
}
if (overlay != null)
{
DrawRotatedTexture(clockRect, overlay, 0);
}
}
public void Mover(float horizontal, float vertical, ForceMode2D mode)
{
direcao = new Vector2(-horizontal, -vertical);
direcao.Normalize();
direcao.Scale(new Vector2(ForcaImpulso, ForcaImpulso));
// impulsionando o objeto pra direcao oposta
for(int i = 0; i < RefPoints.transform.childCount; i++)
{
//GameController.GetComponent<Crescer>().MassAddUp(gosma,movimentPorcentReduction);
RefPoints.transform.GetChild(i).GetComponent<Rigidbody2D>().AddForce(direcao, ForceMode2D.Impulse);
}
//
/*for(int i = 1; i < RefPoints.transform.childCount; i++)
{
Physics2D.IgnoreCollision(RefPoints.transform.GetChild(i).GetComponent<CircleCollider2D>(), LostMass.GetComponent<CircleCollider2D>());
}*/
//RefPoints.GetComponentInChildren<Rigidbody2D>().AddForce(direcao, ForceMode2D.Impulse);
//gosma.GetComponent<UnityJellySprite>().AddForce(direcao);
}
public void Process(IplImage frame)
{
if (UpdateColorsEachFrame)
{
_cvScalarFrom = UnityCvUtils.ColorToBGRScalar(ThreshFromColor);
_cvScalarTo = UnityCvUtils.ColorToBGRScalar(ThreshToColor);
}
var imgThresh = GetThresholdedImage(frame, _cvScalarFrom, _cvScalarTo);
CvMoments moments;
Cv.Moments(imgThresh, out moments, true);
var moment10 = Cv.GetSpatialMoment(moments, 1, 0);
var moment01 = Cv.GetSpatialMoment(moments, 0, 1);
var area = Cv.GetSpatialMoment(moments, 0, 0);
ColorPosition = new Vector2((float)(moment10 / area), (float)(moment01 / area));
ColorPosition.Scale(new Vector2((float)Screen.width / frame.Width,
(float)Screen.height / frame.Height));
ColorPosition -= new Vector2(Screen.width, Screen.height) * .5f;
Cv.ReleaseImage(imgThresh);
}
public void generateGrid() {
tileSize = new Vector2(gameObject.GetComponent<BoxCollider2D>().size.x / width, gameObject.GetComponent<BoxCollider2D>().size.y / height);
tileSize.Scale(transform.localScale);
mapTile = new Tile[width, height];
for(int x=0; x<width; x++){
for(int y=0; y<height; y++){
Tile tile = new Tile();
mapTile[x,y] = tile;
tile.passable = true;
tile.x = x;
tile.y = y;
tile.cost = -1;
Vector2 pos = GetPositionFromTile(tile);
Collider2D[] colliders = Physics2D.OverlapAreaAll(pos - tileSize / 2, pos + tileSize / 2);
foreach(Collider2D collider in colliders){
if(collider.tag == "Obstacle"){
tile.passable = false;
break;
}
}
}
}
foreach(Tile tile in mapTile){
for(int x = -1; x<=1; x++){
for(int y = -1; y<=1; y++){
if(!(x == 0 && y == 0)){
if(tile.x+x>=0 && tile.x+x<width && tile.y+y>=0 && tile.y+y<height){
if(mapTile[tile.x+x, tile.y+y].passable){
tile.neighbors.Add(mapTile[tile.x+x, tile.y+y]);
}
}
}
}
}
}
}
void LateUpdate()
{
Vector3 cameraPosition = Camera.main.transform.position;
transform.position = new Vector3(cameraPosition.x, 0, cameraPosition.z);
var gridChild = transform.FindChild("GroundGrid");
Vector2 scaleXZ = new Vector2(transform.localScale.x * gridChild.localScale.x,
transform.localScale.z * gridChild.localScale.z);
scaleXZ *= 10;
var ts = gridChild.renderer.material.GetTextureScale("_MainTex");
scaleXZ.Scale(new Vector2(1 / ts.x, 1 / ts.y));
Vector2 positionXZ = new Vector2(cameraPosition.x, cameraPosition.z);
//float additionalScale = cameraPosition.y;
//transform.FindChild("GroundMask").localScale = new Vector3(32 + additionalScale, 32 + additionalScale, 32 + additionalScale);
//transform.FindChild("GroundMask").localPosition = new Vector3(0, 1, 125 + additionalScale * 10);
positionXZ = Vector2.Scale(positionXZ, new Vector2(1 / scaleXZ.x, 1 / scaleXZ.y));
gridChild.renderer.material.SetTextureOffset("_MainTex", positionXZ);
}
private void DisplayCollider()
{
Event e = Event.current;
if (tileSet.selected_tileSetBrushId != TileSetConst.TileSetBrushId_Default)
{
EditorGUILayout.LabelField("tileSetBrush不能被编辑", EditorStyles.boldLabel);
return;
}
bool is_multi_selection = tileSet.tileSelection != null;
bool is_save_changes = false;
Tile selected_tile = is_multi_selection
? tileSet.tile_list[TileSetUtil.GetTileIdFromTileData(tileSet.tileSelection.selection_tileData_list[0])]
: tileSet.selected_tile;
if (e.type == EventType.MouseDown)
{
is_dragging = true;
if (selected_tile.tileColliderData.vertices != null)
{
saved_vertexs = new Vector2[selected_tile.tileColliderData.vertices.Length];
selected_tile.tileColliderData.vertices.CopyTo(saved_vertexs, 0);
}
}
else if (e.type == EventType.MouseUp)
{
is_dragging = false;
}
//background_color
tileSet.background_color = EditorGUILayout.ColorField(tileSet.background_color);
if (pre_background_color != tileSet.background_color || GUIStyleConst.Scroll_Style.normal.background == null)
{
pre_background_color = tileSet.background_color;
if (GUIStyleConst.Scroll_Style.normal.background == null)
{
GUIStyleConst.Scroll_Style.normal.background = new Texture2D(1, 1)
{
hideFlags = HideFlags.DontSave
}
}
;
GUIStyleConst.Scroll_Style.normal.background.SetPixel(0, 0, tileSet.background_color);
GUIStyleConst.Scroll_Style.normal.background.Apply();
}
float aspect_ratio = tileSet.tile_pixel_size.x / tileSet.tile_pixel_size.y; //比例
float padding = 2; // pixel size of the border around the tile
//画tile图
//包围tile_rect的rect
Rect tile_parent_rect = GUILayoutUtility.GetRect(1, 1, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true));
using (new GUIBeginGroupScope(tile_parent_rect, GUIStyleConst.Scroll_Style))
{
if (e.type == EventType.Repaint)
{
float tile_pixel_size = tile_parent_rect.width / (tileSet.tile_pixel_size.x + 2 * padding);//2*padding是因为padding有左边和右边
mouse_pos = e.mousePosition;
tile_rect = new Rect(padding * tile_pixel_size, padding * tile_pixel_size,
tile_parent_rect.width - 2 * padding * tile_pixel_size,
(tile_parent_rect.width / aspect_ratio) - 2 * padding * tile_pixel_size);
tile_rect.height = Mathf.Min(tile_rect.height, tile_parent_rect.height - 2 * padding * tile_pixel_size);
tile_rect.width = (tile_rect.height * aspect_ratio);
}
using (new GUIColorScope(new Color(1f, 1f, 1f, 0.1f)))
{
GUI.DrawTexture(tile_rect, EditorGUIUtility.whiteTexture);
}
if (is_multi_selection)
{
foreach (uint tileData in tileSet.tileSelection.selection_tileData_list)
{
int tileId = TileSetUtil.GetTileIdFromTileData(tileData);
Tile tile = tileSet.GetTile(tileId);
if (tile != null)
{
GUI.color = new Color(1f, 1f, 1f, 1f / tileSet.tileSelection.selection_tileData_list.Count);
GUI.DrawTextureWithTexCoords(tile_rect, tileSet.atlas_texture, tile.uv);
}
}
GUI.color = Color.white;
}
else
{
GUI.DrawTextureWithTexCoords(tile_rect, tileSet.atlas_texture, selected_tile.uv);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Color saved_handle_color = Handles.color;
if (selected_tile.tileColliderData.type != TileColliderType.None)
{
Vector2[] collider_vertices = selected_tile.tileColliderData.type == TileColliderType.Full ? TileConst.Full_Collider_Tile_Vertices : selected_tile.tileColliderData.vertices;
if (collider_vertices == null || collider_vertices.Length == 0)
{
collider_vertices = selected_tile.tileColliderData.vertices = new Vector2[TileConst.Full_Collider_Tile_Vertices.Length];
Array.Copy(TileConst.Full_Collider_Tile_Vertices, collider_vertices, TileConst.Full_Collider_Tile_Vertices.Length);
EditorUtility.SetDirty(tileSet);
}
// 将vertice的xy限制在[0,1]之间
for (int i = 0; i < collider_vertices.Length; ++i)
{
Vector2 collider_vertice = collider_vertices[i];
collider_vertice = collider_vertice.Snap2(tileSet.tile_pixel_size).ConvertElement(v => Mathf.Clamp01(v));
collider_vertices[i] = collider_vertice;
}
// 画边 draw edges
Vector3[] poly_edges = new Vector3[collider_vertices.Length + 1];
for (int i = 0; i < collider_vertices.Length; ++i)
{
Vector2 collider_vertice = collider_vertices[i];
collider_vertice.x = tile_rect.x + tile_rect.width * collider_vertice.x;
collider_vertice.y = tile_rect.yMax - tile_rect.height * collider_vertice.y;
Vector2 collider_vertice_next = collider_vertices[(i + 1) % collider_vertices.Length];
collider_vertice_next.x = tile_rect.x + tile_rect.width * collider_vertice_next.x;
collider_vertice_next.y = tile_rect.yMax - tile_rect.height * collider_vertice_next.y;
poly_edges[i] = collider_vertice;
poly_edges[i + 1] = collider_vertice_next;
//画边
Handles.color = Color.green;
Handles.DrawLine(collider_vertice, collider_vertice_next);
//画边上的法线 Draw normals
Handles.color = Color.white;
Vector3 normal_pos = (collider_vertice + collider_vertice_next) / 2f;
Handles.DrawLine(normal_pos, normal_pos + Vector3.Cross(collider_vertice_next - collider_vertice, Vector3.forward).normalized *tile_rect.yMin);
Handles.color = saved_handle_color;
}
float pixel_size = tile_rect.width / tileSet.tile_pixel_size.x;
if (selected_tile.tileColliderData.type == TileColliderType.Polygon)
{
bool is_adding_vertex_on = !is_dragging && e.shift && active_vertex_index == -1;
bool is_removing_vertex_on = !is_dragging && ((Application.platform == RuntimePlatform.OSXEditor) ? e.command : e.control) && collider_vertices.Length > 3;
//删除顶点
if (is_removing_vertex_on && active_vertex_index != -1 && e.type == EventType.MouseUp)
{
selected_tile.tileColliderData.vertices = new Vector2[collider_vertices.Length - 1];
for (int i = 0, j = 0; i < collider_vertices.Length; ++i)
{
if (i == active_vertex_index)
{
continue;
}
selected_tile.tileColliderData.vertices[j] = collider_vertices[i];
++j;
}
collider_vertices = selected_tile.tileColliderData.vertices;
active_vertex_index = -1;
}
float min_distance = float.MaxValue;
if (!is_dragging)
{
active_vertex_index = -1;
}
for (int i = 0; i < collider_vertices.Length; ++i)
{
Vector2 collider_vertice = collider_vertices[i];
collider_vertice.x = tile_rect.x + tile_rect.width * collider_vertice.x;
collider_vertice.y = tile_rect.yMax - tile_rect.height * collider_vertice.y;
if (is_dragging)
{
if (i == active_vertex_index)
{
collider_vertice = mouse_pos;
collider_vertice -= tile_rect.position;
collider_vertice.x = Mathf.Clamp(Mathf.Round(collider_vertice.x / pixel_size) * pixel_size, 0, tile_rect.width);
collider_vertice.y = Mathf.Clamp(Mathf.Round(collider_vertice.y / pixel_size) * pixel_size, 0, tile_rect.height);
collider_vertice += tile_rect.position;
collider_vertices[i].x = Mathf.Clamp01((collider_vertice.x - tile_rect.x) / tile_rect.width);
collider_vertices[i].y = Mathf.Clamp01((collider_vertice.y - tile_rect.yMax) / -tile_rect.height);
}
}
else
{
float distance = Vector2.Distance(mouse_pos, collider_vertice);
//distance < GUIStyleConst.Collider_Vertex_Handle_Style.normal.background.width是为了限定少于多少距离（该顶点与mouse_pos的距离）的时候才选中该顶点
if (distance <= min_distance && distance < GUIStyleConst.Collider_Vertex_Handle_Style.normal.background.width)
{
min_distance = distance;
active_vertex_index = i;
}
}
//画顶点
if (e.type == EventType.Repaint)
{
//画左上角的坐标
if (i == active_vertex_index)
{
GUIStyleConst.VertexCoord_Style.fontSize = (int)(Mathf.Min(12f, tile_rect.yMin / 2f));
GUI.Label(new Rect(0, 0, tile_rect.width, tile_rect.yMin), Vector2.Scale(collider_vertices[i], tileSet.tile_pixel_size).ToString(), GUIStyleConst.VertexCoord_Style);
}
GUI.color = active_vertex_index == i ? (is_removing_vertex_on ? Color.red : Color.cyan) : new Color(0.7f, 0.7f, 0.7f, 0.8f);
GUIStyleConst.Collider_Vertex_Handle_Style.Draw(new Rect(collider_vertice.x - GUIStyleConst.Collider_Vertex_Handle_Style.normal.background.width / 2, collider_vertice.y - GUIStyleConst.Collider_Vertex_Handle_Style.normal.background.height / 2, 1, 1), i.ToString(), false, false, false, false);
GUI.color = Color.white;
}
}
//添加顶点
if (is_adding_vertex_on)
{
//线段index
int segment_index;
Vector2 new_vertex_pos = ClosestPointToPolyLine(poly_edges, out segment_index);
if (e.type == EventType.MouseUp)
{
selected_tile.tileColliderData.vertices = new Vector2[collider_vertices.Length + 1];
segment_index = (segment_index + 1) % selected_tile.tileColliderData.vertices.Length;
for (int i = 0, j = 0; i < selected_tile.tileColliderData.vertices.Length; ++i)
{
if (segment_index == i)
{
new_vertex_pos.x = Mathf.Clamp(Mathf.Round(new_vertex_pos.x / pixel_size) * pixel_size, tile_rect.x, tile_rect.xMax);
new_vertex_pos.y = Mathf.Clamp(Mathf.Round(new_vertex_pos.y / pixel_size) * pixel_size, tile_rect.y, tile_rect.yMax);
selected_tile.tileColliderData.vertices[i].x = Mathf.Clamp01((new_vertex_pos.x - tile_rect.x) / tile_rect.width);
selected_tile.tileColliderData.vertices[i].y = Mathf.Clamp01((new_vertex_pos.y - tile_rect.yMax) / -tile_rect.height);
}
else
{
selected_tile.tileColliderData.vertices[i] = collider_vertices[j];
++j;
}
}
collider_vertices = selected_tile.tileColliderData.vertices;
active_vertex_index = -1;
}
else if (e.type == EventType.Repaint)
{
//添加顶点中移动鼠标，透明动态显示当前将要新增顶点的位置
GUI.color = new Color(0.7f, 0.7f, 0.7f, 0.8f);
GUIStyleConst.Collider_Vertex_Handle_Style.Draw(new Rect(new_vertex_pos.x - GUIStyleConst.Collider_Vertex_Handle_Style.normal.background.width / 2, new_vertex_pos.y - GUIStyleConst.Collider_Vertex_Handle_Style.normal.background.height / 2, 1, 1), segment_index.ToString(), false, false, false, false);
GUI.color = Color.white;
}
}
}
if (e.type == EventType.MouseUp)
{
is_save_changes = true;
//remove duplicated vertex
selected_tile.tileColliderData.vertices = selected_tile.tileColliderData.vertices.Distinct().ToArray();
if (selected_tile.tileColliderData.vertices.Length <= 2)
{
selected_tile.tileColliderData.vertices = saved_vertexs;
}
//snap vertex positions
selected_tile.tileColliderData.SnapVertices(tileSet);
}
}
}
if (GUILayout.Button("反转法线"))
{
selected_tile.tileColliderData.vertices.Reverse();
}
EditorGUILayout.Space();
string helpInfo =
" - 移动:点击图中的顶点并移动它的位置" + "\n" +
" - 添加:按住Shift并点击鼠标进行添加顶点" + "\n" +
" - 删除:按住Ctrl并且点击顶点进行删除顶点 (should be more than 3)";
EditorGUILayout.HelpBox(helpInfo, MessageType.Info);
// Collider Settings
float saved_label_width = EditorGUIUtility.labelWidth;
EditorGUIUtility.labelWidth = 40;
if (is_multi_selection)
{
EditorGUILayout.LabelField("* Multi-selection Edition", EditorStyles.boldLabel);
}
using (new EditorGUILayoutBeginHorizontalScope(GUILayout.MinWidth(140)))
{
EditorGUILayout.LabelField("Collider Data", EditorStyles.boldLabel);
if (GUILayout.Button("Copy", GUILayout.Width(50)))
{
copied_colliderData = selected_tile.tileColliderData.Clone();
}
if (GUILayout.Button("Paste", GUILayout.Width(50)))
{
selected_tile.tileColliderData = copied_colliderData.Clone();
is_save_changes = true;
}
}
EditorGUILayout.Space();
using (var check = new EditorGUIBeginChangeCheckScope())
{
EditorGUIUtility.labelWidth = 100;
EditorGUILayout.LabelField("Collider Type:", EditorStyles.boldLabel);
using (new EditorGUIIndentLevelScope(2))
{
string[] tile_collider_names = Enum.GetNames(typeof(TileColliderType));
selected_tile.tileColliderData.type = (TileColliderType)GUILayout.Toolbar((int)selected_tile.tileColliderData.type, tile_collider_names);
}
EditorGUIUtility.labelWidth = saved_label_width;
is_save_changes |= check.IsChanged;
}
//Save changes
if (is_save_changes)
{
if (is_multi_selection)
{
for (int i = 0; i < tileSet.tileSelection.selection_tileData_list.Count; ++i)
{
tileSet.tile_list[TileSetUtil.GetTileIdFromTileData(tileSet.tileSelection.selection_tileData_list[i])].tileColliderData = selected_tile.tileColliderData.Clone();
}
}
EditorUtility.SetDirty(tileSet);
//Refresh selected tileMap
TileMap selected_tileMap = Selection.activeGameObject ? Selection.activeGameObject.GetComponent <TileMap>() : null;
if (selected_tileMap)
{
selected_tileMap.Refresh(false, true);
}
}
}
//获取polyline（vertices组成的线段）线段上的离当前mouse poistion最近的点
//Get the point on a polyline (in 3D space) which is closest to the current mouse position
Vector3 ClosestPointToPolyLine(Vector3[] vertices, out int closest_segment_index)
{
float min_distance = float.MaxValue;
closest_segment_index = 0;
for (int i = 0; i < vertices.Length - 1; ++i)
{
float distance = HandleUtility.DistanceToLine(vertices[i], vertices[i + 1]);
if (distance < min_distance)
{
min_distance = distance;
closest_segment_index = i;
}
}
return(HandleUtility.ClosestPointToPolyLine(vertices));
}
}
static bool PostProcessSpriteMeshData(ISpriteEditorDataProvider spriteDataProvider, Sprite[] sprites)
{
var spriteMeshDataProvider = spriteDataProvider.GetDataProvider <ISpriteMeshDataProvider>();
var boneDataProvider = spriteDataProvider.GetDataProvider <ISpriteBoneDataProvider>();
var textureDataProvider = spriteDataProvider.GetDataProvider <ITextureDataProvider>();
if (sprites == null || sprites.Length == 0 || spriteMeshDataProvider == null || textureDataProvider == null)
{
return(false);
}
bool dataChanged = false;
float definitionScale = CalculateDefinitionScale(textureDataProvider);
foreach (var sprite in sprites)
{
var guid = sprite.GetSpriteID();
var spriteRect = spriteDataProvider.GetSpriteRects().First(s => { return(s.spriteID == guid); });
var spriteBone = boneDataProvider.GetBones(guid);
var hasBones = spriteBone != null && spriteBone.Count > 0;
var hasInvalidWeights = false;
var vertices = spriteMeshDataProvider.GetVertices(guid);
var indices = spriteMeshDataProvider.GetIndices(guid);
if (vertices.Length > 2 && indices.Length > 2)
{
var vertexArray = new NativeArray <Vector3>(vertices.Length, Allocator.Temp);
var boneWeightArray = new NativeArray <BoneWeight>(vertices.Length, Allocator.Temp);
for (int i = 0; i < vertices.Length; ++i)
{
var boneWeight = vertices[i].boneWeight;
vertexArray[i] = (Vector3)(vertices[i].position - Vector2.Scale(spriteRect.rect.size, spriteRect.pivot)) * definitionScale / sprite.pixelsPerUnit;
boneWeightArray[i] = boneWeight;
if (hasBones && !hasInvalidWeights)
{
var sum = boneWeight.weight0 + boneWeight.weight1 + boneWeight.weight2 + boneWeight.weight3;
hasInvalidWeights = sum < 0.999f;
}
}
var indicesArray = new NativeArray <ushort>(indices.Length, Allocator.Temp);
for (int i = 0; i < indices.Length; ++i)
{
indicesArray[i] = (ushort)indices[i];
}
sprite.SetVertexCount(vertices.Length);
sprite.SetVertexAttribute <Vector3>(VertexAttribute.Position, vertexArray);
sprite.SetIndices(indicesArray);
sprite.SetBoneWeights(boneWeightArray);
vertexArray.Dispose();
boneWeightArray.Dispose();
indicesArray.Dispose();
dataChanged = true;
if (hasBones && hasInvalidWeights)
{
Debug.LogWarning("Sprite \"" + spriteRect.name + "\" contains bone weights which sum zero or are not normalized. To avoid visual artifacts please consider fixing them.");
}
}
}
return(dataChanged);
}
/// <summary>
/// Scales the position around the pivot with scale
/// </summary>
public static Vector2 Scale(Vector2 pos, Vector2 pivot, Vector2 scale)
{
return(Vector2.Scale(pos - pivot, scale) + pivot);
}
private static void ExportTerrianToObj(TerrainData terrain, Vector3 terrainPos,
ref StreamWriter writer, ref int vertexOffset, bool autoCut)
{
int tw = terrain.heightmapWidth;
int th = terrain.heightmapHeight;
Vector3 meshScale = terrain.size;
meshScale = new Vector3(meshScale.x / (tw - 1), meshScale.y, meshScale.z / (th - 1));
Vector2 uvScale = new Vector2(1.0f / (tw - 1), 1.0f / (th - 1));
Vector2 terrainBoundLB, terrainBoundRT;
if (autoCut)
{
terrainBoundLB = GetTerrainBoundPos(new Vector3(autoCutMinX, 0, autoCutMinY), terrain, terrainPos);
terrainBoundRT = GetTerrainBoundPos(new Vector3(autoCutMaxX, 0, autoCutMaxY), terrain, terrainPos);
}
else
{
terrainBoundLB = GetTerrainBoundPos(CUT_LB_OBJ_PATH, terrain, terrainPos);
terrainBoundRT = GetTerrainBoundPos(CUT_RT_OBJ_PATH, terrain, terrainPos);
}
int bw = (int)(terrainBoundRT.x - terrainBoundLB.x);
int bh = (int)(terrainBoundRT.y - terrainBoundLB.y);
int w = bh != 0 && bh < th ? bh : th;
int h = bw != 0 && bw < tw ? bw : tw;
int startX = (int)terrainBoundLB.y;
int startY = (int)terrainBoundLB.x;
if (startX < 0)
{
startX = 0;
}
if (startY < 0)
{
startY = 0;
}
Debug.Log(string.Format("Terrian:tw={0},th={1},sw={2},sh={3},startX={4},startY={5}",
tw, th, bw, bh, startX, startY));
float[,] tData = terrain.GetHeights(0, 0, tw, th);
Vector3[] tVertices = new Vector3[w * h];
Vector2[] tUV = new Vector2[w * h];
int[] tPolys = new int[(w - 1) * (h - 1) * 6];
for (int y = 0; y < h; y++)
{
for (int x = 0; x < w; x++)
{
Vector3 pos = new Vector3(-(startY + y), tData[startX + x, startY + y], (startX + x));
tVertices[y * w + x] = Vector3.Scale(meshScale, pos) + terrainPos;
tUV[y * w + x] = Vector2.Scale(new Vector2(x, y), uvScale);
}
}
int index = 0;
for (int y = 0; y < h - 1; y++)
{
for (int x = 0; x < w - 1; x++)
{
tPolys[index++] = (y * w) + x;
tPolys[index++] = ((y + 1) * w) + x;
tPolys[index++] = (y * w) + x + 1;
tPolys[index++] = ((y + 1) * w) + x;
tPolys[index++] = ((y + 1) * w) + x + 1;
tPolys[index++] = (y * w) + x + 1;
}
}
count = counter = 0;
progressUpdateInterval = 10000;
totalCount = (tVertices.Length + tUV.Length + tPolys.Length / 3) / progressUpdateInterval;
string title = "export Terrain to .obj ...";
for (int i = 0; i < tVertices.Length; i++)
{
UpdateProgress(title);
StringBuilder sb = new StringBuilder(22);
sb.AppendFormat("v {0} {1} {2}\n", tVertices[i].x, tVertices[i].y, tVertices[i].z);
writer.Write(sb.ToString());
}
for (int i = 0; i < tUV.Length; i++)
{
UpdateProgress(title);
StringBuilder sb = new StringBuilder(20);
sb.AppendFormat("vt {0} {1}\n", tUV[i].x, tUV[i].y);
writer.Write(sb.ToString());
}
for (int i = 0; i < tPolys.Length; i += 3)
{
UpdateProgress(title);
int x = tPolys[i] + 1 + vertexOffset;;
int y = tPolys[i + 1] + 1 + vertexOffset;
int z = tPolys[i + 2] + 1 + vertexOffset;
StringBuilder sb = new StringBuilder(30);
sb.AppendFormat("f {0} {1} {2}\n", x, y, z);
writer.Write(sb.ToString());
}
vertexOffset += tVertices.Length;
}
// FixedUpdate is used for physics related tasks to maintain accuracy.
void FixedUpdate()
{
// Debug movement controls.
#region DebugMovement
//if (Input.GetKey(KeyCode.W))
//{
// this.transform.position += new Vector3(0, 0.1f,0);
//}
//if (Input.GetKey(KeyCode.D))
//{
// this.transform.position += new Vector3(0.1f, 0, 0);
//}
//if (Input.GetKey(KeyCode.S))
//{
// this.transform.position += new Vector3(0, -0.1f, 0);
//}
//if (Input.GetKey(KeyCode.A))
//{
// this.transform.position += new Vector3(-0.1f, 0, 0);
//}
#endregion
// Code handling the firing of web.
#region FiringWeb
switch (fireState)
{
// Firing Case
case 1:
// Once every 20 frames...
if (pointCounter == 0)
{
// Create a new node to interact with
currentNode = Instantiate(webPoint, this.transform.position, new Quaternion(0, 0, 0, 0)) as Rigidbody2D;
currentNode.tag = "Node";
numNodes++;
// Tell it the next node in the chain.
currentNode.GetComponent<WebNode>().nextNode = prevNode.GetComponent<WebNode>();
// If there is a next node in the chain, inform that next node about the new one.
if (prevNode != null)
{
prevNode.GetComponent<WebNode>().prevNode = currentNode.GetComponent<WebNode>();
}
// Tell the next node in the chain to have a spring between it and the new node.
prevNode.GetComponent<SpringJoint2D>().connectedBody = currentNode.rigidbody2D;
// Fire the previous node
prevNode.GetComponent<WebNode>().Activate();
// Get the worldspace position of the mouse
Vector3 mousePoint = Camera.main.ScreenToWorldPoint(Input.mousePosition);
Vector2 fireDirection = new Vector2(mousePoint.x - this.transform.position.x, mousePoint.y - this.transform.position.y);
// Fire it with arbitrary force.
fireDirection.Normalize();
fireDirection.Scale(new Vector2(2200,2200));
prevNode.rigidbody2D.AddForce(fireDirection );
// Move the nodes along the chain
prevNode = currentNode;
currentNode = null;
}
// Increase the timer until the next fire.
pointCounter++;
// Arbitrary reset point
if (pointCounter >= 10)
{
pointCounter = 0;
}
break;
// Holding Case
case 2:
// If the next node is too close to the previous node while being held, then suck it in.
if (prevNode.GetComponent<WebNode>().nextNode != null && (prevNode.GetComponent<WebNode>().nextNode.rigidbody2D.position - prevNode.position).magnitude < 0.9f)
{
// Create a temporary node to allow access to the next rigidbody.
Rigidbody2D temp = prevNode.GetComponent<WebNode>().nextNode.rigidbody2D;
// Remove references to the prevNode
temp.GetComponent<SpringJoint2D>().connectedBody = null;
temp.GetComponent<SpringJoint2D>().enabled = false;
// Destroy it, and set PrevNode = to the temporary node.
Destroy(prevNode.gameObject);
numNodes--;
prevNode = temp;
prevNode.rigidbody2D.isKinematic = true;
prevNode.rigidbody2D.GetComponent<WebNode>().prevNode = null;
}
break;
// Reset Case
case 3:
// Reset all parts into their base sections.
pointCounter = 0;
currentNode = null;
prevNode.GetComponent<WebNode>().firstNode = true;
prevNode.GetComponent<WebNode>().numNodes = numNodes;
prevNode = null;
fireState = 0;
numNodes = 0;
break;
}
#endregion
// Player node attacher management.
if (prevNode == null || prevNode.GetComponent<WebNode>().nextNode == null)
{
this.GetComponentInParent<SpringJoint2D>().enabled = false;
}
else
{
this.GetComponentInParent<SpringJoint2D>().connectedBody = prevNode.GetComponent<WebNode>().nextNode.rigidbody2D;
this.GetComponentInParent<SpringJoint2D>().enabled = true;
}
}
// Update is called once per frame
void FixedUpdate()
{
// Movement is invalid with fewer than two locations.
if (locations.Count < 2)
{
return;
}
// See if we're heading forward or backwards
if (direction)
{
// Have we gone too far?
if ((((Vector2)this.transform.position - locations[prevNode]).magnitude - (locations[prevNode + 1] - locations[prevNode]).magnitude) >= 0)
{
// Go back if we're too far.
this.transform.position = locations[prevNode + 1];
// advance the track
prevNode++;
// See if we're at an end of the track
if (prevNode == locations.Count - 1)
{
// If we are then ping us if we ping, or loop otherwise
if (ping)
{
direction = false;
movementVector = (locations[prevNode - 1] - locations[prevNode]).normalized;
movementVector.Scale(new Vector2(speed, speed));
}
else
{
prevNode = 0;
this.transform.position = locations[0];
movementVector = (locations[prevNode + 1] - locations[prevNode]).normalized;
movementVector.Scale(new Vector2(speed, speed));
}
}
// Not at the end of the track? Keep moving!
else
{
movementVector = (locations[prevNode + 1] - locations[prevNode]).normalized;
movementVector.Scale(new Vector2(speed, speed));
}
}
}
// Heading in the opposite direction.
else
{
// Have we gone too far?
if ((((Vector2)this.transform.position - locations[prevNode]).magnitude - (locations[prevNode - 1] - locations[prevNode]).magnitude) >= 0)
{
// Move back if we're too far
this.transform.position = locations[prevNode - 1];
// Advance the track
prevNode--;
// Are we at the beginning of the track?
if(prevNode == 0)
{
direction = true;
movementVector = (locations[prevNode + 1] - locations[prevNode]).normalized;
movementVector.Scale(new Vector2(speed, speed));
}
}
// Keep moving
else
{
movementVector = (locations[prevNode - 1] - locations[prevNode]).normalized;
movementVector.Scale(new Vector2(speed, speed));
}
}
// Apply the movement
this.transform.position += (Vector3)movementVector;
}
public GlobeFace(int index, float radsToRotate,
Vector3 p1, Vector3 p2, Vector3 p3,
Vector2 u1, Vector2 u2, Vector2 u3,
int n1, int n2, int n3)
{
this.index = index;
if (allFaces == null)
{
throw new System.Exception("Face Array must be initialized before constructing faces!");
}
if (index < 0 || index >= allFaces.Length)
{
throw new System.IndexOutOfRangeException(string.Format("Index {0} is out of range of face array of size {1}", index, allFaces.Length));
}
if (allFaces[index] != null)
{
Debug.LogWarningFormat("Face at index {0} is not null. We'll continue, but this is probably a bad sign.");
}
allFaces[index] = this;
cornerVertices = new Vector3[] { p1, p2, p3 };
float radsPerX = 2f * Mathf.PI / 5f;
for (int v = 0; v < cornerVertices.Length; v++)
{
if (Mathf.Abs(cornerVertices[v].y) < 1f)
{
float radsAround = (cornerVertices[v].x) * radsPerX + radsToRotate;
cornerVertices[v] = new Vector3(Mathf.Cos(radsAround), cornerVertices[v].y, Mathf.Sin(radsAround));
}
}
Vector2 mapCoordSizeTotal = new Vector2(5f + Mathf.Sin(Mathf.PI / 6f), 3f * Mathf.Sin(Mathf.PI / 3f));
Vector2 uvSizeMult = new Vector2(1f / mapCoordSizeTotal.x, 2f / mapCoordSizeTotal.x);
cornerUV = new Vector2[] { Vector2.Scale(u1, uvSizeMult), Vector2.Scale(u2, uvSizeMult), Vector2.Scale(u3, uvSizeMult) };
neighborIndices = new int[] { n1, n2, n3 };
}
public static Vector2 Scaled(this Vector2 v, Vector2 scale)
{
v.Scale(scale);
return(v);
}
//////////////////////////////////////////////////////////////////////////
public static void GetAbsoluteAnchors(RectTransform t, out Vector2 anchorMin, out Vector2 anchorMax, out Vector2 centerPos, bool stopAtScrollView = false)
{
centerPos = t.TransformPoint(0.5f, 0.5f, 0.0f);
// TODO: Take care of offsets
anchorMin = t.anchorMin;
anchorMax = t.anchorMax;
// TODO: Abstract this into a GUI system independent function that will get the position and min/max corner points of the UI element frame.
// TODO: Transform points into world coordinate system, and afterwards transform it back into local space of the object with the
// Accessiblity_Container component.
// TOOD: If stopAtScrollView is active, use that RectTransform instead of the UIContainer transform.
Vector2 scale = new Vector3(1.0f / (float)Screen.width, 1.0f / (float)Screen.height, 0.0f);
Vector2 tanchorMin = t.TransformPoint(0.0f, 0.0f, 0.0f);
Vector2 tanchorMax = t.TransformPoint(1.0f, 1.0f, 0.0f);
tanchorMin.Scale(scale);
tanchorMax.Scale(scale);
//string output = "min max of " + t.gameObject.name + " is MIN: " + tanchorMin.ToString() + " and MAX: " + tanchorMax.ToString();
//anchorMin = t.TransformPoint(0.0f, 0.0f, 0.0f);
//anchorMax = t.TransformPoint(1.0f, 1.0f, 0.0f);
//return;
Transform parent = t.parent;
while (parent != null)
{
if (parent.gameObject.GetComponent <Canvas>() && parent.parent == null)
{
break;
}
if (stopAtScrollView)
{
if (parent.gameObject.GetComponent <ScrollRect>() != null)
{
// Return early
return;
}
}
// Add up the positions
RectTransform pTrans = parent.gameObject.GetComponent <RectTransform>();
parent = parent.parent;
if (pTrans == null)
{
continue;
}
//centerPos = pTrans.TransformPoint(centerPos);
anchorMin.x = pTrans.anchorMin.x + anchorMin.x * (pTrans.anchorMax.x - pTrans.anchorMin.x);
anchorMin.y = pTrans.anchorMin.y + anchorMin.y * (pTrans.anchorMax.y - pTrans.anchorMin.y);
anchorMax.x = pTrans.anchorMin.x + anchorMax.x * (pTrans.anchorMax.x - pTrans.anchorMin.x);
anchorMax.y = pTrans.anchorMin.y + anchorMax.y * (pTrans.anchorMax.y - pTrans.anchorMin.y);
}
//output += " and MIN: " + anchorMin.ToString() + " and MAX: " + anchorMax.ToString();
//Debug.Log(output);
}
public Vector2 GetRayPositionWs(CharacterRay2D ray)
{
Vector2 rayOrigin = transform.TransformPoint(Vector2.Scale(ray.m_position - m_scaleOffset, m_scale) + m_scaleOffset);
return(rayOrigin);
}
private void GenerateTiledSprite(VertexHelper toFill)
{
Vector4 vector;
Vector4 vector2;
Vector4 vector3;
Vector2 vector4;
if (overrideSprite != null)
{
vector = DataUtility.GetOuterUV(overrideSprite);
vector2 = DataUtility.GetInnerUV(overrideSprite);
vector3 = overrideSprite.border;
vector4 = overrideSprite.rect.size;
}
else
{
vector = Vector4.zero;
vector2 = Vector4.zero;
vector3 = Vector4.zero;
vector4 = Vector2.one * 100f;
}
Rect pixelAdjustedRect = GetPixelAdjustedRect();
float num = (vector4.x - vector3.x - vector3.z) / multipliedPixelsPerUnit;
float num2 = (vector4.y - vector3.y - vector3.w) / multipliedPixelsPerUnit;
vector3 = GetAdjustedBorders(vector3 / multipliedPixelsPerUnit, pixelAdjustedRect);
Vector2 vector5 = new Vector2(vector2.x, vector2.y);
Vector2 vector6 = new Vector2(vector2.z, vector2.w);
float x = vector3.x;
float num3 = pixelAdjustedRect.width - vector3.z;
float y = vector3.y;
float num4 = pixelAdjustedRect.height - vector3.w;
toFill.Clear();
Vector2 vector7 = vector6;
if (num <= 0f)
{
num = num3 - x;
}
if (num2 <= 0f)
{
num2 = num4 - y;
}
if (overrideSprite != null && (hasBorder || overrideSprite.packed || overrideSprite.texture.wrapMode != TextureWrapMode.Repeat))
{
long num5;
long num6;
if (fillCenter)
{
num5 = (long)Math.Ceiling((num3 - x) / num);
num6 = (long)Math.Ceiling((num4 - y) / num2);
double num7;
if (hasBorder)
{
num7 = (num5 + 2.0) * (num6 + 2.0) * 4.0;
}
else
{
num7 = num5 * num6 * 4.0;
}
if (num7 > 65000.0)
{
Debug.LogError("Too many sprite tiles on Image \"" + name + "\". The tile size will be increased. To remove the limit on the number of tiles, set the Wrap mode to Repeat in the Image Import Settings", this);
double num8 = 16250.0;
double num9;
if (hasBorder)
{
num9 = (num5 + 2.0) / (num6 + 2.0);
}
else
{
num9 = num5 / (double)num6;
}
double num10 = Math.Sqrt(num8 / num9);
double num11 = num10 * num9;
if (hasBorder)
{
num10 -= 2.0;
num11 -= 2.0;
}
num5 = (long)Math.Floor(num10);
num6 = (long)Math.Floor(num11);
num = (num3 - x) / num5;
num2 = (num4 - y) / num6;
}
}
else if (hasBorder)
{
num5 = (long)Math.Ceiling((num3 - x) / num);
num6 = (long)Math.Ceiling((num4 - y) / num2);
if ((num6 + num5 + 2.0) * 2.0 * 4.0 > 65000.0)
{
Debug.LogError("Too many sprite tiles on Image \"" + name + "\". The tile size will be increased. To remove the limit on the number of tiles, set the Wrap mode to Repeat in the Image Import Settings", this);
double num12 = 16250.0;
double num13 = num5 / (double)num6;
double num14 = (num12 - 4.0) / (2.0 * (1.0 + num13));
double d = num14 * num13;
num5 = (long)Math.Floor(num14);
num6 = (long)Math.Floor(d);
num = (num3 - x) / num5;
num2 = (num4 - y) / num6;
}
}
else
{
num5 = (num6 = 0L);
}
if (fillCenter)
{
for (long num15 = 0L; num15 < num6; num15 += 1L)
{
float num16 = y + num15 * num2;
float num17 = y + (num15 + 1L) * num2;
if (num17 > num4)
{
vector7.y = vector5.y + (vector6.y - vector5.y) * (num4 - num16) / (num17 - num16);
num17 = num4;
}
vector7.x = vector6.x;
for (long num18 = 0L; num18 < num5; num18 += 1L)
{
float num19 = x + num18 * num;
float num20 = x + (num18 + 1L) * num;
if (num20 > num3)
{
vector7.x = vector5.x + (vector6.x - vector5.x) * (num3 - num19) / (num20 - num19);
num20 = num3;
}
AddQuad(toFill, new Vector2(num19, num16) + pixelAdjustedRect.position, new Vector2(num20, num17) + pixelAdjustedRect.position, color, vector5, vector7);
}
}
}
if (hasBorder)
{
vector7 = vector6;
for (long num21 = 0L; num21 < num6; num21 += 1L)
{
float num22 = y + num21 * num2;
float num23 = y + (num21 + 1L) * num2;
if (num23 > num4)
{
vector7.y = vector5.y + (vector6.y - vector5.y) * (num4 - num22) / (num23 - num22);
num23 = num4;
}
AddQuad(toFill, new Vector2(0f, num22) + pixelAdjustedRect.position, new Vector2(x, num23) + pixelAdjustedRect.position, color, new Vector2(vector.x, vector5.y), new Vector2(vector5.x, vector7.y));
AddQuad(toFill, new Vector2(num3, num22) + pixelAdjustedRect.position, new Vector2(pixelAdjustedRect.width, num23) + pixelAdjustedRect.position, color, new Vector2(vector6.x, vector5.y), new Vector2(vector.z, vector7.y));
}
vector7 = vector6;
for (long num24 = 0L; num24 < num5; num24 += 1L)
{
float num25 = x + num24 * num;
float num26 = x + (num24 + 1L) * num;
if (num26 > num3)
{
vector7.x = vector5.x + (vector6.x - vector5.x) * (num3 - num25) / (num26 - num25);
num26 = num3;
}
AddQuad(toFill, new Vector2(num25, 0f) + pixelAdjustedRect.position, new Vector2(num26, y) + pixelAdjustedRect.position, color, new Vector2(vector5.x, vector.y), new Vector2(vector7.x, vector5.y));
AddQuad(toFill, new Vector2(num25, num4) + pixelAdjustedRect.position, new Vector2(num26, pixelAdjustedRect.height) + pixelAdjustedRect.position, color, new Vector2(vector5.x, vector6.y), new Vector2(vector7.x, vector.w));
}
AddQuad(toFill, new Vector2(0f, 0f) + pixelAdjustedRect.position, new Vector2(x, y) + pixelAdjustedRect.position, color, new Vector2(vector.x, vector.y), new Vector2(vector5.x, vector5.y));
AddQuad(toFill, new Vector2(num3, 0f) + pixelAdjustedRect.position, new Vector2(pixelAdjustedRect.width, y) + pixelAdjustedRect.position, color, new Vector2(vector6.x, vector.y), new Vector2(vector.z, vector5.y));
AddQuad(toFill, new Vector2(0f, num4) + pixelAdjustedRect.position, new Vector2(x, pixelAdjustedRect.height) + pixelAdjustedRect.position, color, new Vector2(vector.x, vector6.y), new Vector2(vector5.x, vector.w));
AddQuad(toFill, new Vector2(num3, num4) + pixelAdjustedRect.position, new Vector2(pixelAdjustedRect.width, pixelAdjustedRect.height) + pixelAdjustedRect.position, color, new Vector2(vector6.x, vector6.y), new Vector2(vector.z, vector.w));
return;
}
}
else
{
Vector2 b = new Vector2((num3 - x) / num, (num4 - y) / num2);
if (fillCenter)
{
AddQuad(toFill, new Vector2(x, y) + pixelAdjustedRect.position, new Vector2(num3, num4) + pixelAdjustedRect.position, color, Vector2.Scale(vector5, b), Vector2.Scale(vector6, b));
}
}
}
public static Sprite GetOrCreateSprite(TilemapChunk.OnTilePrefabCreationData data)
{
Sprite sprite = null;
int tileId = Tileset.GetTileIdFromTileData(data.ParentTilemap.GetTileData(data.GridX, data.GridY));
Tile tile = data.ParentTilemap.Tileset.GetTile(tileId);
if (tile != null)
{
float pixelsPerUnit = data.ParentTilemap.Tileset.TilePxSize.x / data.ParentTilemap.CellSize.x;
Vector2 atlasSize = new Vector2(data.ParentTilemap.Tileset.AtlasTexture.width, data.ParentTilemap.Tileset.AtlasTexture.height);
Rect spriteUV = new Rect(Vector2.Scale(tile.uv.position, atlasSize), Vector2.Scale(tile.uv.size, atlasSize));
string spriteName = data.ParentTilemap.Tileset.name + "_" + tileId + "_" + pixelsPerUnit;
if (!s_spriteCache.TryGetValue(spriteName, out sprite) || !sprite)
{
sprite = Sprite.Create(data.ParentTilemap.Tileset.AtlasTexture, spriteUV, new Vector2(.5f, .5f), pixelsPerUnit);
sprite.name = spriteName;
s_spriteCache[spriteName] = sprite;
}
}
return(sprite);
}
public static void TestScaleBy()
{
const float floatScale = 4.8f;
const float floatStart = 1.2f;
float floatVal = floatStart;
Ref <float> floatRef = new Ref <float>(
() => floatVal,
t => floatVal = t
);
const double doubleScale = 3.2;
const double doubleStart = 9.2;
double doubleVal = doubleStart;
Ref <double> doubleRef = new Ref <double>(
() => doubleVal,
t => doubleVal = t
);
Vector2 vec2Scale = new Vector2(9.5f, 2.0f);
Vector2 vec2Start = new Vector2(4.0f, 5.0f);
Vector2 vec2Val = vec2Start;
Ref <Vector2> vec2Ref = new Ref <Vector2>(
() => vec2Val,
t => vec2Val = t
);
Vector3 vec3Scale = new Vector3(4.0f, 19.0f, 2.0f);
Vector3 vec3Start = new Vector3(92.0f, 0.5f, 34.0f);
Vector3 vec3Val = vec3Start;
Ref <Vector3> vec3Ref = new Ref <Vector3>(
() => vec3Val,
t => vec3Val = t
);
Vector4 vec4Scale = new Vector4(92.0f, 0.5f, 14.0f, 7.0f);
Vector4 vec4Start = new Vector4(0.4f, 10.0f, 3.0f, 82.0f);
Vector4 vec4Val = vec4Start;
Ref <Vector4> vec4Ref = new Ref <Vector4>(
() => vec4Val,
t => vec4Val = t
);
CommandQueue queue = new CommandQueue();
queue.Enqueue(
Cmd.Repeat(2,
Cmd.Sequence(
Cmd.Parallel(
Cmd.ScaleBy(floatRef, floatScale, 1.0),
Cmd.ScaleBy(doubleRef, doubleScale, 1.0),
Cmd.ScaleBy(vec2Ref, vec2Scale, 1.0),
Cmd.ScaleBy(vec3Ref, vec3Scale, 1.0),
Cmd.ScaleBy(vec4Ref, vec4Scale, 1.0)
),
Cmd.WaitForFrames(1)
)
)
);
queue.Update(0.2f);
Vector2 vec2ExpectedScale = vec2Scale;
Vector3 vec3ExpectedScale = vec3Scale;
Vector4 vec4ExpectedScale = vec4Scale;
vec2ExpectedScale.Scale(new Vector2(0.2f, 0.2f));
vec3ExpectedScale.Scale(new Vector3(0.2f, 0.2f, 0.2f));
vec4ExpectedScale.Scale(new Vector4(0.2f, 0.2f, 0.2f, 0.2f));
vec2ExpectedScale += new Vector2(0.8f, 0.8f);
vec3ExpectedScale += new Vector3(0.8f, 0.8f, 0.8f);
vec4ExpectedScale += new Vector4(0.8f, 0.8f, 0.8f, 0.8f);
vec2ExpectedScale.Scale(vec2Start);
vec3ExpectedScale.Scale(vec3Start);
vec4ExpectedScale.Scale(vec4Start);
AreEqual(floatVal, floatStart * (0.8f + floatScale * 0.2f), 0.001f);
AreEqual(doubleVal, doubleStart * (0.8 + doubleScale * 0.2), 0.001f);
AreEqual(vec2Val, vec2ExpectedScale, 0.001f);
AreEqual(vec3Val, vec3ExpectedScale, 0.001f);
AreEqual(vec4Val, vec4ExpectedScale, 0.001f);
queue.Update(0.8);
vec2ExpectedScale = vec2Scale;
vec3ExpectedScale = vec3Scale;
vec4ExpectedScale = vec4Scale;
vec2ExpectedScale.Scale(vec2Start);
vec3ExpectedScale.Scale(vec3Start);
vec4ExpectedScale.Scale(vec4Start);
AreEqual(floatVal, floatStart * floatScale, 0.001f);
AreEqual(doubleVal, doubleStart * doubleScale, 0.001f);
AreEqual(vec2Val, vec2ExpectedScale, 0.001f);
AreEqual(vec3Val, vec3ExpectedScale, 0.001f);
AreEqual(vec4Val, vec4ExpectedScale, 0.001f);
floatVal = floatStart;
doubleVal = doubleStart;
vec2Val = vec2Start;
vec3Val = vec3Start;
vec4Val = vec4Start;
queue.Update(0.0);
queue.Update(0.5);
vec2ExpectedScale = vec2Scale;
vec3ExpectedScale = vec3Scale;
vec4ExpectedScale = vec4Scale;
vec2ExpectedScale.Scale(new Vector2(0.5f, 0.5f));
vec3ExpectedScale.Scale(new Vector3(0.5f, 0.5f, 0.5f));
vec4ExpectedScale.Scale(new Vector4(0.5f, 0.5f, 0.5f, 0.5f));
vec2ExpectedScale += new Vector2(0.5f, 0.5f);
vec3ExpectedScale += new Vector3(0.5f, 0.5f, 0.5f);
vec4ExpectedScale += new Vector4(0.5f, 0.5f, 0.5f, 0.5f);
vec2ExpectedScale.Scale(vec2Start);
vec3ExpectedScale.Scale(vec3Start);
vec4ExpectedScale.Scale(vec4Start);
AreEqual(floatVal, floatStart * (0.5f + floatScale * 0.5f), 0.001f);
AreEqual(doubleVal, doubleStart * (0.5 + doubleScale * 0.5), 0.001f);
AreEqual(vec2Val, vec2ExpectedScale, 0.001f);
AreEqual(vec3Val, vec3ExpectedScale, 0.001f);
AreEqual(vec4Val, vec4ExpectedScale, 0.001f);
}
//-----------------------------------------------------
// ScreenCenter : resize l'image par rapport au centre de l'écran
// ie. le vecteur centreImage->centreEcran est affecté par le resize (longeur multipliée par factorDelta)
// !ScreenCenter : par rapport au centre de l'image seulement (factorDelta non utilisé)
// ie. la distance centreImage->centreEcran ne bouge pas
private Rect RescaleBgImg(Rect bgImgPixIn, bool screenCenter, float factorDelta = 0f)
{
// Rect bgImgPixIn = m_backgroundImage.guiTexture.pixelInset;
if(!screenCenter) // imgCenter
{
Vector2 center = bgImgPixIn.center;
bgImgPixIn.width = m_orgBgImgPixIn.width * m_zoomImage;
bgImgPixIn.height = m_orgBgImgPixIn.height * m_zoomImage;
bgImgPixIn.center = center;
}
else // screenCenter
{
// On passe en coordonnées par rapport au centre de l'écran
Vector2 center = new Vector2(bgImgPixIn.center.x - UsefulFunctions.ScrCenter().x,
bgImgPixIn.center.y - UsefulFunctions.ScrCenter().y);
center.Scale(new Vector2(factorDelta, factorDelta)); // Scale du vecteur
center.x += UsefulFunctions.ScrCenter().x; // On repasse en coordonnées "normales"
center.y += UsefulFunctions.ScrCenter().y;
bgImgPixIn.width = m_orgBgImgPixIn.width * m_zoomImage;
bgImgPixIn.height = m_orgBgImgPixIn.height * m_zoomImage;
bgImgPixIn.center = center;
}
return bgImgPixIn;
}
public Vector2[] CalculateUV(Vector3[] vertices)
{
Vector2[] uvs = new Vector2[vertices.Length];
float scale = (1f / Vector3.Distance(vertices[0], vertices[1]));
Vector2 topLeft = Vector2.zero;
int v = 0; // vertex iterator
int segments = connectEnds ? points.Count : points.Count - 1;
for (int i = 0; i < segments; i++)
{
Vector3 segCenter = (vertices[v + 0] + vertices[v + 1] + vertices[v + 2] + vertices[v + 3]) / 4f;
Vector2 u0 = vertices[v + 0].RotateAroundPoint(segCenter, theta[i] + (90f * Mathf.Deg2Rad)).ToXZVector2();
Vector2 u1 = vertices[v + 1].RotateAroundPoint(segCenter, theta[i] + (90f * Mathf.Deg2Rad)).ToXZVector2();
Vector2 u2 = vertices[v + 2].RotateAroundPoint(segCenter, theta[i] + (90f * Mathf.Deg2Rad)).ToXZVector2();
Vector2 u3 = vertices[v + 3].RotateAroundPoint(segCenter, theta[i] + (90f * Mathf.Deg2Rad)).ToXZVector2();
// normalizes uv scale
uvs[v + 0] = u0 * scale;
uvs[v + 1] = u1 * scale;
uvs[v + 2] = u2 * scale;
uvs[v + 3] = u3 * scale;
Vector2 delta = topLeft - uvs[v + 0];
uvs[v + 0] += delta;
uvs[v + 1] += delta;
uvs[v + 2] += delta;
uvs[v + 3] += delta;
topLeft = uvs[v + 2];
v += 4;
}
// Normalize X axis, apply to Y
scale = 1f / uvs[1].x - uvs[0].x;
for (int i = 0; i < uvs.Length; i++)
{
uvs[i] *= scale;
}
// optional uv modifications
if (swapUV)
{
for (int i = 0; i < uvs.Length; i++)
{
uvs[i] = new Vector2(uvs[i].y, uvs[i].x);
}
}
if (flipU)
{
for (int i = 0; i < uvs.Length; i++)
{
uvs[i] = new Vector2(-uvs[i].x, uvs[i].y);
}
}
if (flipV)
{
for (int i = 0; i < uvs.Length; i++)
{
uvs[i] = new Vector2(uvs[i].x, -uvs[i].y);
}
}
for (int i = 0; i < uvs.Length; i++)
{
uvs[i] += uvOffset;
uvs[i] = Vector2.Scale(uvs[i], uvScale);
}
return(uvs);
}
void calcVetores () {
borda = sprite.border / sprite.pixelsPerUnit;
Vector4 aux = borda;
borda.z = sprite.bounds.size.x - borda.z;
borda.w = sprite.bounds.size.y - borda.w;
size = sprite.bounds.size;
size.Scale(transform.localScale);
min = new Vector2(borda.x, borda.y);
max = new Vector2(size.x-aux.z, size.y-aux.w);
if (!fillOptions.left)
min.x = 0f;
if (!fillOptions.rigth)
max.x = size.x;
if (!fillOptions.bottom)
min.y = 0f;
if (!fillOptions.top)
max.y = size.y;
}
public static Vector2 Mul(this Vector2 v1, Vector2 v2)
{
return(Vector2.Scale(v1, v2));
}
protected Vector2 RealPosition(Vector2 pos, Vector2 bounds)
{
Vector2 transformAnchor = Vector2.zero;
if (positionSizeFromTransform) {
if (positionSizeFromTransformNormalized) {
transformAnchor = new Vector2(
transform.position.x * Screen2.width, -transform.position.y * Screen2.height);
} else {
transformAnchor = new Vector2(transform.position.x, -transform.position.y);
}
pos.Scale(transform.lossyScale);
}
Vector2 screenAnchor = Vector2.zero;
Vector2 boundsAnchor = Vector2.zero;
switch (pivot) {
case Pivot.TopLeft:
screenAnchor = Vector2.zero;
boundsAnchor = Vector2.zero;
break;
case Pivot.Top:
screenAnchor = new Vector2(Screen2.width / 2, 0);
boundsAnchor = new Vector2(bounds.x / 2, 0);
break;
case Pivot.TopRight:
screenAnchor = new Vector2(Screen2.width, 0);
boundsAnchor = new Vector2(bounds.x, 0);
break;
case Pivot.Right:
screenAnchor = new Vector2(Screen2.width, Screen2.height / 2);
boundsAnchor = new Vector2(bounds.x, bounds.y / 2);
break;
case Pivot.BottomRight:
screenAnchor = new Vector2(Screen2.width, Screen2.height);
boundsAnchor = new Vector2(bounds.x, bounds.y);
break;
case Pivot.Bottom:
screenAnchor = new Vector2(Screen2.width / 2, Screen2.height);
boundsAnchor = new Vector2(bounds.x / 2, bounds.y);
break;
case Pivot.BottomLeft:
screenAnchor = new Vector2(0, Screen2.height);
boundsAnchor = new Vector2(0, bounds.y);
break;
case Pivot.Left:
screenAnchor = new Vector2(0, Screen2.height / 2);
boundsAnchor = new Vector2(0, bounds.y / 2);
break;
case Pivot.Center:
screenAnchor = new Vector2(Screen2.width / 2, Screen2.height / 2);
boundsAnchor = new Vector2(bounds.x / 2, bounds.y / 2);
break;
}
if (anchorObject != null) {
Camera cam;
if (anchorCamera != null) {
cam = anchorCamera;
} else {
cam = Camera.main;
}
screenAnchor = cam.WorldToScreenPoint(anchorObject.transform.position);
screenAnchor.y = Screen2.height - screenAnchor.y;
}
var o = transformAnchor + screenAnchor - boundsAnchor + pos;
return o;
}
public static Vector2 InsideEllipse(this Random random, Vector2 radius)
{
return Vector2.Scale(random.InsideUnitCircle(), radius);
}
public Vector2 NormalizeInViewSpace(Vector2 vec)
{
vec = Vector2.Scale(vec, m_Scale);
vec /= vec.magnitude;
return(Vector2.Scale(vec, new Vector2(1 / m_Scale.x, 1 / m_Scale.y)));
}
void Update()
{
// Ensure the cursor is always locked when set
if (lockCursor)
{
Cursor.lockState = CursorLockMode.Locked;
}
Vector3 movement = Quaternion.Euler(0, Camera.main.transform.eulerAngles.y, 0) * new Vector3(Input.GetAxis("Horizontal"), 0.0f, Input.GetAxis("Vertical"));
transform.position += movement * movementSpeed * Time.deltaTime;
// Allow the script to clamp based on a desired target value.
var targetOrientation = Quaternion.Euler(targetDirection);
var targetCharacterOrientation = Quaternion.Euler(targetCharacterDirection);
// Get raw mouse input for a cleaner reading on more sensitive mice.
var mouseDelta = new Vector2(Input.GetAxisRaw("Mouse X"), Input.GetAxisRaw("Mouse Y"));
// Mouse scrollwheel input
float deltaMouseScrollWheel = Input.GetAxis("Mouse ScrollWheel");
// Scale input against the sensitivity setting and multiply that against the smoothing value.
mouseDelta = Vector2.Scale(mouseDelta, new Vector2(sensitivity.x * smoothing.x, sensitivity.y * smoothing.y));
// Interpolate mouse movement over time to apply smoothing delta.
_smoothMouse.x = Mathf.Lerp(_smoothMouse.x, mouseDelta.x, 1f / smoothing.x);
_smoothMouse.y = Mathf.Lerp(_smoothMouse.y, mouseDelta.y, 1f / smoothing.y);
// Find the absolute mouse movement value from point zero.
_mouseAbsolute += _smoothMouse;
// Clamp and apply the local x value first, so as not to be affected by world transforms.
if (clampInDegrees.x < 360)
{
_mouseAbsolute.x = Mathf.Clamp(_mouseAbsolute.x, -clampInDegrees.x * 0.5f, clampInDegrees.x * 0.5f);
}
// Then clamp and apply the global y value.
if (clampInDegrees.y < 360)
{
_mouseAbsolute.y = Mathf.Clamp(_mouseAbsolute.y, -clampInDegrees.y * 0.5f, clampInDegrees.y * 0.5f);
}
transform.localRotation = Quaternion.AngleAxis(-_mouseAbsolute.y, targetOrientation * Vector3.right) * targetOrientation;
float emulatedForward = deltaMouseScrollWheel;
//transform.position = transform.position + Camera.main.transform.forward * 5.0f; //* deltaMouseScrollWheel;
transform.position += new Vector3(0f, emulatedForward, 0f);
//Vector3 movement = Quaternion.Euler(0, Camera.main.transform.eulerAngles.y, 0) * new Vector3(deltaMouseScrollWheel, 0, deltaMouseScrollWheel);
//transform.position = movement;
// If there's a character body that acts as a parent to the camera
if (characterBody)
{
var yRotation = Quaternion.AngleAxis(_mouseAbsolute.x, Vector3.up);
characterBody.transform.localRotation = yRotation * targetCharacterOrientation;
}
else
{
var yRotation = Quaternion.AngleAxis(_mouseAbsolute.x, transform.InverseTransformDirection(Vector3.up));
transform.localRotation *= yRotation;
}
}
/// <summary>
/// Scales the rect around the pivot with scale
/// </summary>
public static Rect Scale(Rect rect, Vector2 pivot, Vector2 scale)
{
rect.position = Vector2.Scale(rect.position - pivot, scale) + pivot;
rect.size = Vector2.Scale(rect.size, scale);
return(rect);
}
public void SetVelocity(Vector2 direction, float speed)
{
Velocity = direction.Scale(speed);
}
private Rect RectTransformToScreenSpace(RectTransform transform)
{
Vector2 size = Vector2.Scale(transform.rect.size, transform.lossyScale);
return(new Rect((Vector2)transform.position - (size * 0.5f), size));
}
public override void Update()
{
if (this.mMoveEnabled)
{
if ((double)this.MoveOffset >= 1.0)
{
this.MoveOffset = 1f;
this.mMoveEnabled = false;
}
float num = this.MoveCurve.Evaluate(this.MoveOffset);
for (int index = 0; index < this.mStandCharaTransformList.Count; ++index)
{
this.mStandCharaTransformList[index].set_anchorMin(Vector2.op_Addition(this.FromAnchorMinList[index], Vector2.Scale(Vector2.op_Subtraction(this.mToAnchorList[index], this.FromAnchorMinList[index]), new Vector2(num, num))));
this.mStandCharaTransformList[index].set_anchorMax(Vector2.op_Addition(this.FromAnchorMaxList[index], Vector2.Scale(Vector2.op_Subtraction(this.mToAnchorList[index], this.FromAnchorMaxList[index]), new Vector2(num, num))));
}
this.MoveOffset += Time.get_deltaTime() / this.MoveTime;
}
if (this.mScaleEnabled)
{
if ((double)this.ScaleOffset >= 1.0)
{
this.ScaleOffset = 1f;
this.mScaleEnabled = false;
}
float num = this.ScaleCurve.Evaluate(this.ScaleOffset);
for (int index = 0; index < this.mStandCharaTransformList.Count; ++index)
{
Vector3 vector3;
// ISSUE: explicit reference operation
((Vector3)@vector3).\u002Ector(this.FromWidthList[index] + (this.mToWidth - this.FromWidthList[index]) * num, this.FromHeightList[index] + (this.mToHeght - this.FromHeightList[index]) * num, 1f);
((Transform)this.mStandCharaTransformList[index]).set_localScale(vector3);
}
this.ScaleOffset += Time.get_deltaTime() / this.ScaleTime;
}
if (this.mColorEnabled)
{
if ((double)this.ColorOffset >= 1.0)
{
this.ColorOffset = 1f;
this.mColorEnabled = false;
}
float num = this.ColorCurve.Evaluate(this.ColorOffset);
for (int index = 0; index < this.charaList.Count; ++index)
{
if (Object.op_Inequality((Object)((EventStandChara2)this.charaList[index].GetComponent <EventStandChara2>()).BodyObject, (Object)null))
{
Color color = Color.Lerp(this.BodyColorList[index], this.mToColor, num);
((Graphic)((EventStandChara2)this.charaList[index].GetComponent <EventStandChara2>()).BodyObject.GetComponent <RawImage>()).set_color(color);
}
if (Object.op_Inequality((Object)((EventStandChara2)this.charaList[index].GetComponent <EventStandChara2>()).FaceObject, (Object)null))
{
Color color = Color.Lerp(this.FaceColorList[index], this.mToColor, num);
((Graphic)((EventStandChara2)this.charaList[index].GetComponent <EventStandChara2>()).FaceObject.GetComponent <RawImage>()).set_color(color);
}
}
this.ColorOffset += Time.get_deltaTime() / this.ColorTime;
}
if (this.mMoveEnabled || this.mScaleEnabled || this.mColorEnabled)
{
return;
}
if (this.async)
{
this.enabled = false;
}
else
{
this.ActivateNext();
}
}
private void UpdateSelectedColor()
{
var boxSize = _boxSizePercent * Image.rectTransform.rect.width;
var boxSizeDim = new Vector2( boxSize, boxSize );
boxSizeDim.Scale( Image.rectTransform.lossyScale );
var boxStart = Convert.ToInt16( -boxSize / 2f );
var boxStartPosLocal = new Vector3( boxStart, boxStart );
boxStartPosLocal.Scale( Image.rectTransform.lossyScale );
var boxStartPos = Image.rectTransform.position + boxStartPosLocal;
var satValPos = SaturationValueSelector.transform.position - boxStartPos;
var sat = satValPos.x / boxSizeDim.x;
var val = satValPos.y / boxSizeDim.y;
var hue = (_hueTheta + Mathf.PI) / (2 * Mathf.PI);
var color = Color.HSVToRGB( hue, sat, val );
UIManager.SetSelectedColor( color );
}
void OnPreprocessTexture()
{
if (!s_Initialized)
{
return;
}
string guid = AssetDatabase.AssetPathToGUID(assetPath);
if (s_SpriteMeshToTextureCache.ContainsValue(guid))
{
TextureImporter textureImporter = (TextureImporter)assetImporter;
SerializedObject textureImporterSO = new SerializedObject(textureImporter);
SerializedProperty textureImporterSprites = textureImporterSO.FindProperty("m_SpriteSheet.m_Sprites");
foreach (KeyValuePair <string, string> pair in s_SpriteMeshToTextureCache)
{
if (pair.Value == guid)
{
SpriteMesh spriteMesh = LoadSpriteMesh(AssetDatabase.GUIDToAssetPath(pair.Key));
SpriteMeshData spriteMeshData = SpriteMeshUtils.LoadSpriteMeshData(spriteMesh);
if (spriteMesh && spriteMeshData && spriteMesh.sprite && spriteMeshData.vertices.Length > 0)
{
textureImporterSO.FindProperty("m_SpriteMeshType").intValue = 1;
if (textureImporter.spriteImportMode == SpriteImportMode.Multiple)
{
SerializedProperty spriteProp = null;
int i = 0;
string name = "";
while (i < textureImporterSprites.arraySize && name != spriteMesh.sprite.name)
{
spriteProp = textureImporterSprites.GetArrayElementAtIndex(i);
name = spriteProp.FindPropertyRelative("m_Name").stringValue;
++i;
}
if (name == spriteMesh.sprite.name)
{
Rect textureRect = SpriteMeshUtils.CalculateSpriteRect(spriteMesh, 5);
spriteProp.FindPropertyRelative("m_Rect").rectValue = textureRect;
spriteProp.FindPropertyRelative("m_Alignment").intValue = 9;
spriteProp.FindPropertyRelative("m_Pivot").vector2Value =
Vector2.Scale(spriteMeshData.pivotPoint - textureRect.position,
new Vector2(1f / textureRect.size.x, 1f / textureRect.size.y));
}
}
else
{
int width = 0;
int height = 0;
SpriteMeshUtils.GetSpriteTextureSize(spriteMesh.sprite, ref width, ref height);
textureImporterSO.FindProperty("m_Alignment").intValue = 9;
textureImporterSO.FindProperty("m_SpritePivot").vector2Value =
Vector2.Scale(spriteMeshData.pivotPoint, new Vector2(1f / width, 1f / height));
}
}
}
}
textureImporterSO.ApplyModifiedProperties();
}
}
private void Update()
{
if (locked || project == null) return;
if (dialogue)
{
dialogueBox.Show(dialogueActor.dialogue);
if (Input.anyKeyDown)
{
dialogueActor = null;
dialogueBox.Hide();
}
}
var color = Color.white * brightSlider.value;
color.a = 1;
brightImage.color = color;
nextCursor = new Vector2((cursor.localPosition.x / 256f + 0.5f) * Screen.width,
(cursor.localPosition.y / 256f + 0.5f) * Screen.height);
CheckHotkeys();
float interval = 0.1f;
var scene = playScene ?? editScene;
timer += Time.deltaTime;
worldView.Refresh();
while (timer > interval)
{
timer -= interval;
foreach (Actor actor in scene.actors)
{
if (actor.position.moving) continue;
while (true && false)
{
var fragment = actor.script.fragments.FirstOrDefault(frag => frag.name == actor.state.fragment);
if (fragment != null
&& actor.state.line < fragment.lines.Length)
{
string[] line = fragment.lines[actor.state.line];
if (line[0] == "move")
{
int dir = 0;
if (line[1] == "random") dir = Random.Range(0, 4);
if (line[1] == "east") dir = 0;
if (line[1] == "south") dir = 1;
if (line[1] == "west") dir = 2;
if (line[1] == "north") dir = 3;
actor.position.next = actor.position.prev + directions[dir] * 32;
actor.position.direction = (Position.Direction)dir;
}
else if (line[0] == "follow")
{
actor.state.fragment = line[1];
actor.state.line = 0;
continue;
}
actor.state.line += 1;
break;
}
}
}
}
foreach (Actor actor in scene.actors)
{
if (!actor.position.moving) continue;
var delta = actor.position.next - actor.position.prev + Vector2.one * 0.5f;
//actor.position.direction = (Position.Direction)Mathf.FloorToInt(Mathf.Atan2(delta.y, -delta.x) / (Mathf.PI * 0.5f) + 2);
actor.position.progress += Time.deltaTime * 2;
if (actor.position.progress >= 1)
{
actor.position.prev = actor.position.next;
actor.position.progress = 0;
}
}
//UpdateBorder(project.world.actors.First());
clickedOnWorld = !mouseOverUI && Input.GetMouseButtonDown(0);
clickingOnWorld = clickedOnWorld
|| (clickingOnWorld && Input.GetMouseButton(0));
var plane = new Plane(Vector3.forward, Vector3.zero);
var ray = Camera.main.ScreenPointToRay(Input.mousePosition);
float t;
plane.Raycast(ray, out t);
Vector2 point = ray.GetPoint(t);
Vector2 screenMouse;
RectTransformUtility.ScreenPointToLocalPointInRectangle(mouseCursorTransform.parent as RectTransform, Input.mousePosition, screenCanvas.worldCamera, out screenMouse);
mouseCursorTransform.localPosition = screenMouse;
{
ray = Camera.main.ScreenPointToRay(Input.mousePosition);
plane.Raycast(ray, out t);
nextMouse = ray.GetPoint(t);
var cursorScreen = new Vector2(cursor.anchoredPosition.x / 256,
cursor.anchoredPosition.y / 256);
cursorScreen.Scale(Vector2.one * Screen.width);
nextCursor = cursorScreen;
ray = Camera.main.ScreenPointToRay(cursorScreen);
plane.Raycast(ray, out t);
nextCursor = ray.GetPoint(t);
}
mouseHold = Input.GetMouseButton(0);
mousePress = Input.GetMouseButtonDown(0) && !mouseOverUI;
bool mouse = Input.GetMouseButton(0) && !mouseOverUI;
bool gamep = input.click.IsPressed && !hovering;
prev = gamep ? prevCursor : prevMouse;
next = gamep ? nextCursor : nextMouse;
#region angle bullshit
var delta2 = next - prev;
if (delta2.magnitude > 1)
{
float a = Mathf.Atan2(delta2.y, delta2.x);
angles.Enqueue(a);
}
else if (angles.Count > 0)
{
angles.Enqueue(angles.Peek());
}
if (angles.Count > 3) angles.Dequeue();
if (angles.Count > 0) angle = angles.Average();
#endregion
prev.x = Mathf.FloorToInt(prev.x);
prev.y = Mathf.FloorToInt(prev.y);
next.x = Mathf.FloorToInt(next.x);
next.y = Mathf.FloorToInt(next.y);
SetCursorSprite(normalCursor);
if (hud.mode != HUD.Mode.Draw)
{
drawHUD.expanded = false;
}
UpdateCharacterMovement();
if (possessedActor != null)
{
var view = worldView.actors.Get(possessedActor);
//pointerRenderer.gameObject.SetActive(true);
//trail.gameObject.SetActive(true);
float angle1 = (Time.timeSinceLevelLoad * 3) % (2 * Mathf.PI);
float ox = Mathf.Cos(angle1) * 24;
float oy = Mathf.Sin(angle1) * 24;
trail.next = (Vector2) view.transform.position
+ new Vector2(ox, oy);
}
else
{
pointerRenderer.gameObject.SetActive(false);
trail.gameObject.SetActive(false);
}
if (hud.mode == HUD.Mode.Play)
{
UpdatePlayInput();
}
else
{
CleanupPlay();
}
if (hud.mode == HUD.Mode.Draw && drawHUD.mode == DrawHUD.Mode.Paint)
{
UpdatePaintInput();
}
else
{
CleanupPaint();
}
if (hud.mode == HUD.Mode.Draw && drawHUD.mode == DrawHUD.Mode.Colors)
{
UpdateColorsInput();
}
if (hud.mode == HUD.Mode.Character)
{
UpdateCharacterInput();
}
else
{
CleanupCharacter();
}
if (hud.mode == HUD.Mode.Tile)
{
UpdateTileInput();
}
else
{
CleanupTiles();
}
prevMouse = nextMouse;
prevCursor = nextCursor;
}
void DoSpriteOverride(SpriteMesh spriteMesh, Sprite sprite)
{
TextureImporter textureImporter = (TextureImporter)assetImporter;
#if UNITY_5_1 || UNITY_5_2 || UNITY_5_3_OR_NEWER
Debug.Assert(textureImporter.spriteImportMode == SpriteImportMode.Single ||
textureImporter.spriteImportMode == SpriteImportMode.Multiple,
"Incompatible Sprite Mode. Use Single or Multiple.");
#endif
SpriteMeshData spriteMeshData = SpriteMeshUtils.LoadSpriteMeshData(spriteMesh);
if (spriteMeshData)
{
Vector2 factor = Vector2.one;
Rect spriteRect = sprite.rect;
Rect rectTextureSpace = new Rect();
if (textureImporter.spriteImportMode == SpriteImportMode.Single)
{
int width = 0;
int height = 0;
SpriteMeshUtils.GetSpriteTextureSize(spriteMesh.sprite, ref width, ref height);
rectTextureSpace = new Rect(0, 0, width, height);
}
else if (textureImporter.spriteImportMode == SpriteImportMode.Multiple)
{
rectTextureSpace = SpriteMeshUtils.CalculateSpriteRect(spriteMesh, 5);
}
factor = new Vector2(spriteRect.width / rectTextureSpace.width,
spriteRect.height / rectTextureSpace.height);
Vector2[] newVertices = new List <Vector2>(spriteMeshData.vertices).ConvertAll(v =>
MathUtils.ClampPositionInRect(Vector2.Scale(v, factor), spriteRect) - spriteRect.position)
.ToArray();
ushort[] newIndices =
new List <int>(spriteMeshData.indices).ConvertAll <ushort>(i => (ushort)i).ToArray();
sprite.OverrideGeometry(newVertices, newIndices);
}
}
public void OnDrawGizmos() {
tileSize = new Vector2(gameObject.GetComponent<BoxCollider2D>().size.x / width, gameObject.GetComponent<BoxCollider2D>().size.y / height);
tileSize.Scale(transform.localScale);
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
Vector2 pos = GetPositionFromTile(x, y);
Collider2D[] colliders = Physics2D.OverlapAreaAll(pos - tileSize / 2, pos + tileSize / 2);
bool passable = true;
foreach (Collider2D collider in colliders) {
if (collider.tag == "Obstacle") {
passable = false;
break;
}
}
if(passable)
Gizmos.DrawWireCube(pos, new Vector3(tileSize.x, tileSize.y, 0.0f));
}
}
}
public Vector2 CalculateTileTexelSize()
{
return(AtlasTexture != null?Vector2.Scale(AtlasTexture.texelSize, TilePxSize) : Vector2.zero);
}
protected override void DrawDialog(GameTime time)
{
SpriteFont font = HfGDesign.MenuFont (screen);
// text
for (int i = 0; i < Text.Length; ++i) {
string line = Text [i];
float scale = 0.15f * screen.viewport.ScaleFactor ().Length ();
Vector2 size = font.MeasureString (line).RelativeTo (screen.viewport) * scale;
Vector2 pos = new Vector2 (
(Info.RelativeSize ().X - size.X) / 2,
Info.RelativePadding ().Y + size.Y * i
);
spriteBatch.DrawString (
font, line, Info.ScaledPosition (screen.viewport) + pos.Scale (screen.viewport),
Color.White, 0, Vector2.Zero, scale, SpriteEffects.None, 0
);
}
}
public void UpdateTilesetConfigFromAtlasImportSettings()
{
if (AtlasTexture != null)
{
string assetPath = UnityEditor.AssetDatabase.GetAssetPath(AtlasTexture);
if (!string.IsNullOrEmpty(assetPath))
{
UnityEditor.TextureImporter textureImporter = UnityEditor.AssetImporter.GetAtPath(assetPath) as UnityEditor.TextureImporter;
if (textureImporter != null)
{
m_pixelsPerUnit = textureImporter.spritePixelsPerUnit;
if (textureImporter.textureType == UnityEditor.TextureImporterType.Sprite)
{
if (textureImporter.spriteImportMode == UnityEditor.SpriteImportMode.Multiple)
{
List <Tile> tiles = new List <Tile>();
if (textureImporter.spritesheet.Length >= 2)
{
UnityEditor.SpriteMetaData spr0 = textureImporter.spritesheet[0];
UnityEditor.SpriteMetaData spr1 = textureImporter.spritesheet[1];
TilePxSize = textureImporter.spritesheet[0].rect.size;
SliceOffset = spr0.rect.position; SliceOffset.y = AtlasTexture.height - spr0.rect.y - spr0.rect.height;
SlicePadding.x = spr1.rect.x - spr0.rect.xMax;
}
if (textureImporter.spritesheet.Length >= 2 && m_tiles.Count > 0)
{
//+++Ask before importing tiles
if (!UnityEditor.EditorUtility.DisplayDialog("Import Sprite Sheet?", "This texture atlas contain sliced sprites. Do you want to overwrite current tiles with these ones?", "Yes", "No"))
//---
{
m_tilesetHeight = 0;
foreach (UnityEditor.SpriteMetaData spriteData in textureImporter.spritesheet)
{
Rect rUV = new Rect(Vector2.Scale(spriteData.rect.position, AtlasTexture.texelSize), Vector2.Scale(spriteData.rect.size, AtlasTexture.texelSize));
tiles.Add(new Tile()
{
uv = rUV
});
if (tiles.Count >= 2)
{
if (tiles[tiles.Count - 2].uv.y != tiles[tiles.Count - 1].uv.y)
{
if (m_tilesetHeight == 1)
{
m_tilesetWidth = tiles.Count - 1;
SlicePadding.y = textureImporter.spritesheet[tiles.Count - 2].rect.y - textureImporter.spritesheet[tiles.Count - 1].rect.yMax;
}
++m_tilesetHeight;
}
}
else
{
++m_tilesetHeight;
}
}
TileRowLength = m_tilesetWidth;
//Copy data from previous tiles
#if UNITY_EDITOR
if (m_tiles != null && m_tiles.Count > 0 && UnityEditor.EditorUtility.DisplayDialog("Keep previous tile properties?", "Keeping previous tile properties will copy the collider and paramters of previous tiles", "Yes", "No"))
#endif
{
for (int i = 0; i < m_tiles.Count && i < tiles.Count; ++i)
{
tiles[i].collData = m_tiles[i].collData;
tiles[i].paramContainer = m_tiles[i].paramContainer;
tiles[i].prefabData = m_tiles[i].prefabData;
}
}
m_tiles = tiles;
}
}
}
}
}
}
}
}
public void SetDirection(Vector2 vector2)
{
direction = vector2;
direction.Scale(new Vector2(speed, speed));
}
public override void Update()
{
this.mStandCharaTransform.set_anchorMin(Vector2.op_Addition(this.FromAnchorMin, Vector2.Scale(Vector2.op_Subtraction(this.mToAnchor, this.FromAnchorMin), new Vector2(this.offset, this.offset))));
this.mStandCharaTransform.set_anchorMax(Vector2.op_Addition(this.FromAnchorMax, Vector2.Scale(Vector2.op_Subtraction(this.mToAnchor, this.FromAnchorMax), new Vector2(this.offset, this.offset))));
this.offset += Time.get_deltaTime() / this.MoveTime;
if ((double)this.offset < 1.0)
{
return;
}
this.offset = 1f;
RectTransform standCharaTransform = this.mStandCharaTransform;
Vector2 mToAnchor = this.mToAnchor;
this.mStandCharaTransform.set_anchorMax(mToAnchor);
Vector2 vector2 = mToAnchor;
standCharaTransform.set_anchorMin(vector2);
if (this.async)
{
this.enabled = false;
}
else
{
this.ActivateNext();
}
}
/// <summary>
/// Covert RectTransform to screen space.
/// </summary>
/// <returns>The transform to screen space.</returns>
/// <param name="transform">Transform.</param>
public static Rect RectTransformToScreenSpace(RectTransform transform)
{
Vector2 size = Vector2.Scale(transform.rect.size, transform.lossyScale);
return(new Rect(transform.position.x, Screen.height - transform.position.y, size.x, size.y));
}
private void UpdateLine()
{
_size = size;
float totalDistance = 0;
Vector3 lastPosition = Vector3.zero;
List <Vector3> vertices = new List <Vector3>();
List <Vector2> uvs = new List <Vector2>();
List <Vector3> normals = new List <Vector3>();
List <int> triangles = new List <int>();
List <Vector3> positions = new List <Vector3>();
for (int i = 0; i < coords.Length; i++)
{
// Get world position by coordinates
Vector3 position = OnlineMapsTileSetControl.instance.GetWorldPosition(coords[i]);
positions.Add(position);
if (i != 0)
{
// Calculate angle between coordinates.
float a = OnlineMapsUtils.Angle2DRad(lastPosition, position, 90);
// Calculate offset
Vector3 off = new Vector3(Mathf.Cos(a) * size, 0, Mathf.Sin(a) * size);
// Init verticles, normals and triangles.
int vCount = vertices.Count;
vertices.Add(lastPosition + off);
vertices.Add(lastPosition - off);
vertices.Add(position + off);
vertices.Add(position - off);
normals.Add(Vector3.up);
normals.Add(Vector3.up);
normals.Add(Vector3.up);
normals.Add(Vector3.up);
triangles.Add(vCount);
triangles.Add(vCount + 3);
triangles.Add(vCount + 1);
triangles.Add(vCount);
triangles.Add(vCount + 2);
triangles.Add(vCount + 3);
totalDistance += (lastPosition - position).magnitude;
}
lastPosition = position;
}
float tDistance = 0;
for (int i = 1; i < positions.Count; i++)
{
float distance = (positions[i - 1] - positions[i]).magnitude;
// Updates UV
uvs.Add(new Vector2(tDistance / totalDistance, 0));
uvs.Add(new Vector2(tDistance / totalDistance, 1));
tDistance += distance;
uvs.Add(new Vector2(tDistance / totalDistance, 0));
uvs.Add(new Vector2(tDistance / totalDistance, 1));
}
// Update mesh
mesh.vertices = vertices.ToArray();
mesh.normals = normals.ToArray();
mesh.uv = uvs.ToArray();
mesh.triangles = triangles.ToArray();
// Scale texture
Vector2 scale = new Vector2(totalDistance / size, 1);
scale.Scale(uvScale);
meshRenderer.material.mainTextureScale = scale;
}
protected Vector2 GetSizePixels(Vector2 manualSize)
{
Vector2 o;
switch (resizeMode) {
case ResizeMode.None:
o = TextureSizePixels;
break;
case ResizeMode.Fixed:
o = manualSize;
break;
case ResizeMode.Stretch:
o = new Vector2(manualSize.x * Screen2.width, manualSize.y * Screen2.height);
break;
case ResizeMode.KeepRatio:
var texSize = TextureSizePixels;
float height = manualSize.y * Screen2.height;
float width = (texSize.x / texSize.y) * height;
o = new Vector2(width, height);
break;
default:
Debug.LogError("Unknown resize mode: " + resizeMode);
o = manualSize;
break;
}
o.Scale(TransformScale());
return o;
}
public void Export()
{
int w = terrain.heightmapWidth;
int h = terrain.heightmapHeight;
Vector3 meshScale = terrain.size;
int tRes = (int)Mathf.Pow(2, (int)saveResolution);
meshScale = new Vector3(meshScale.x / (w - 1) * tRes, meshScale.y, meshScale.z / (h - 1) * tRes);
Vector2 uvScale = new Vector2(1.0f / (w - 1), 1.0f / (h - 1));
float[,] tData = terrain.GetHeights(0, 0, w, h);
w = (w - 1) / tRes + 1;
h = (h - 1) / tRes + 1;
Vector3[] tVertices = new Vector3[w * h];
Vector2[] tUV = new Vector2[w * h];
int[] tPolys;
if (saveFormat == SaveFormat.Triangles)
{
tPolys = new int[(w - 1) * (h - 1) * 6];
}
else
{
tPolys = new int[(w - 1) * (h - 1) * 4];
}
// Build vertices and UVs
for (int y = 0; y < h; y++)
{
for (int x = 0; x < w; x++)
{
tVertices[y * w + x] = Vector3.Scale(meshScale, new Vector3(-y, tData[x * tRes, y * tRes], x)) + terrainPos;
tUV[y * w + x] = Vector2.Scale(new Vector2(x * tRes, y * tRes), uvScale);
}
}
int index = 0;
if (saveFormat == SaveFormat.Triangles)
{
// Build triangle indices: 3 indices into vertex array for each triangle
for (int y = 0; y < h - 1; y++)
{
for (int x = 0; x < w - 1; x++)
{
// For each grid cell output two triangles
tPolys[index++] = (y * w) + x;
tPolys[index++] = ((y + 1) * w) + x;
tPolys[index++] = (y * w) + x + 1;
tPolys[index++] = ((y + 1) * w) + x;
tPolys[index++] = ((y + 1) * w) + x + 1;
tPolys[index++] = (y * w) + x + 1;
}
}
}
else
{
// Build quad indices: 4 indices into vertex array for each quad
for (int y = 0; y < h - 1; y++)
{
for (int x = 0; x < w - 1; x++)
{
// For each grid cell output one quad
tPolys[index++] = (y * w) + x;
tPolys[index++] = ((y + 1) * w) + x;
tPolys[index++] = ((y + 1) * w) + x + 1;
tPolys[index++] = (y * w) + x + 1;
}
}
}
// Export to .obj
StreamWriter sw = new StreamWriter(fileName);
try
{
sw.WriteLine("# Unity terrain OBJ File");
// Write vertices
System.Threading.Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("en-US");
counter = tCount = 0;
totalCount = (tVertices.Length * 2 + (saveFormat == SaveFormat.Triangles ? tPolys.Length / 3 : tPolys.Length / 4)) / progressUpdateInterval;
for (int i = 0; i < tVertices.Length; i++)
{
UpdateProgress();
StringBuilder sb = new StringBuilder("v ", 20);
// StringBuilder stuff is done this way because it's faster than using the "{0} {1} {2}"etc. format
// Which is important when you're exporting huge terrains.
sb.Append(tVertices[i].x.ToString()).Append(" ").
Append(tVertices[i].y.ToString()).Append(" ").
Append(tVertices[i].z.ToString());
sw.WriteLine(sb);
}
// Write UVs
for (int i = 0; i < tUV.Length; i++)
{
UpdateProgress();
StringBuilder sb = new StringBuilder("vt ", 22);
sb.Append(tUV[i].x.ToString()).Append(" ").
Append(tUV[i].y.ToString());
sw.WriteLine(sb);
}
if (saveFormat == SaveFormat.Triangles)
{
// Write triangles
for (int i = 0; i < tPolys.Length; i += 3)
{
UpdateProgress();
StringBuilder sb = new StringBuilder("f ", 43);
sb.Append(tPolys[i] + 1).Append("/").Append(tPolys[i] + 1).Append(" ").
Append(tPolys[i + 1] + 1).Append("/").Append(tPolys[i + 1] + 1).Append(" ").
Append(tPolys[i + 2] + 1).Append("/").Append(tPolys[i + 2] + 1);
sw.WriteLine(sb);
}
}
else
{
// Write quads
for (int i = 0; i < tPolys.Length; i += 4)
{
UpdateProgress();
StringBuilder sb = new StringBuilder("f ", 57);
sb.Append(tPolys[i] + 1).Append("/").Append(tPolys[i] + 1).Append(" ").
Append(tPolys[i + 1] + 1).Append("/").Append(tPolys[i + 1] + 1).Append(" ").
Append(tPolys[i + 2] + 1).Append("/").Append(tPolys[i + 2] + 1).Append(" ").
Append(tPolys[i + 3] + 1).Append("/").Append(tPolys[i + 3] + 1);
sw.WriteLine(sb);
}
}
}
catch (Exception err)
{
Debug.Log("Error saving file: " + err.Message);
}
sw.Close();
terrain = null;
EditorUtility.DisplayProgressBar("Saving file to disc.", "This might take a while...", 1f);
//EditorWindow.GetWindow<ExportTerrain>().Close();
EditorUtility.ClearProgressBar();
}
/// <summary>
/// Generate vertices for a tiled Image.
/// </summary>
void GenerateTiledSprite(VertexHelper toFill)
{
Vector4 outer, inner, border;
Vector2 spriteSize;
if (activeSprite != null)
{
outer = Sprites.DataUtility.GetOuterUV(activeSprite);
inner = Sprites.DataUtility.GetInnerUV(activeSprite);
border = activeSprite.border;
spriteSize = activeSprite.rect.size;
}
else
{
outer = Vector4.zero;
inner = Vector4.zero;
border = Vector4.zero;
spriteSize = Vector2.one * 100;
}
Rect rect = GetPixelAdjustedRect();
float tileWidth = (spriteSize.x - border.x - border.z) / pixelsPerUnit;
float tileHeight = (spriteSize.y - border.y - border.w) / pixelsPerUnit;
border = GetAdjustedBorders(border / pixelsPerUnit, rect);
var uvMin = new Vector2(inner.x, inner.y);
var uvMax = new Vector2(inner.z, inner.w);
// Min to max max range for tiled region in coordinates relative to lower left corner.
float xMin = border.x;
float xMax = rect.width - border.z;
float yMin = border.y;
float yMax = rect.height - border.w;
toFill.Clear();
var clipped = uvMax;
// if either width is zero we cant tile so just assume it was the full width.
if (tileWidth <= 0)
{
tileWidth = xMax - xMin;
}
if (tileHeight <= 0)
{
tileHeight = yMax - yMin;
}
if (activeSprite != null && (hasBorder || activeSprite.packed || activeSprite.texture.wrapMode != TextureWrapMode.Repeat))
{
// Sprite has border, or is not in repeat mode, or cannot be repeated because of packing.
// We cannot use texture tiling so we will generate a mesh of quads to tile the texture.
// Evaluate how many vertices we will generate. Limit this number to something sane,
// especially since meshes can not have more than 65000 vertices.
long nTilesW = 0;
long nTilesH = 0;
if (m_FillCenter)
{
nTilesW = (long)Math.Ceiling((xMax - xMin) / tileWidth);
nTilesH = (long)Math.Ceiling((yMax - yMin) / tileHeight);
double nVertices = 0;
if (hasBorder)
{
nVertices = (nTilesW + 2.0) * (nTilesH + 2.0) * 4.0; // 4 vertices per tile
}
else
{
nVertices = nTilesW * nTilesH * 4.0; // 4 vertices per tile
}
if (nVertices > 65000.0)
{
Debug.LogError("Too many sprite tiles on Image \"" + name + "\". The tile size will be increased. To remove the limit on the number of tiles, convert the Sprite to an Advanced texture, remove the borders, clear the Packing tag and set the Wrap mode to Repeat.", this);
double maxTiles = 65000.0 / 4.0; // Max number of vertices is 65000; 4 vertices per tile.
double imageRatio;
if (hasBorder)
{
imageRatio = (nTilesW + 2.0) / (nTilesH + 2.0);
}
else
{
imageRatio = (double)nTilesW / nTilesH;
}
double targetTilesW = Math.Sqrt(maxTiles / imageRatio);
double targetTilesH = targetTilesW * imageRatio;
if (hasBorder)
{
targetTilesW -= 2;
targetTilesH -= 2;
}
nTilesW = (long)Math.Floor(targetTilesW);
nTilesH = (long)Math.Floor(targetTilesH);
tileWidth = (xMax - xMin) / nTilesW;
tileHeight = (yMax - yMin) / nTilesH;
}
}
else
{
if (hasBorder)
{
// Texture on the border is repeated only in one direction.
nTilesW = (long)Math.Ceiling((xMax - xMin) / tileWidth);
nTilesH = (long)Math.Ceiling((yMax - yMin) / tileHeight);
double nVertices = (nTilesH + nTilesW + 2.0 /*corners*/) * 2.0 /*sides*/ * 4.0 /*vertices per tile*/;
if (nVertices > 65000.0)
{
Debug.LogError("Too many sprite tiles on Image \"" + name + "\". The tile size will be increased. To remove the limit on the number of tiles, convert the Sprite to an Advanced texture, remove the borders, clear the Packing tag and set the Wrap mode to Repeat.", this);
double maxTiles = 65000.0 / 4.0; // Max number of vertices is 65000; 4 vertices per tile.
double imageRatio = (double)nTilesW / nTilesH;
double targetTilesW = (maxTiles - 4 /*corners*/) / (2 * (1.0 + imageRatio));
double targetTilesH = targetTilesW * imageRatio;
nTilesW = (long)Math.Floor(targetTilesW);
nTilesH = (long)Math.Floor(targetTilesH);
tileWidth = (xMax - xMin) / nTilesW;
tileHeight = (yMax - yMin) / nTilesH;
}
}
else
{
nTilesH = nTilesW = 0;
}
}
if (m_FillCenter)
{
// TODO: we could share vertices between quads. If vertex sharing is implemented. update the computation for the number of vertices accordingly.
for (long j = 0; j < nTilesH; j++)
{
float y1 = yMin + j * tileHeight;
float y2 = yMin + (j + 1) * tileHeight;
if (y2 > yMax)
{
clipped.y = uvMin.y + (uvMax.y - uvMin.y) * (yMax - y1) / (y2 - y1);
y2 = yMax;
}
clipped.x = uvMax.x;
for (long i = 0; i < nTilesW; i++)
{
float x1 = xMin + i * tileWidth;
float x2 = xMin + (i + 1) * tileWidth;
if (x2 > xMax)
{
clipped.x = uvMin.x + (uvMax.x - uvMin.x) * (xMax - x1) / (x2 - x1);
x2 = xMax;
}
AddQuad(toFill, new Vector2(x1, y1) + rect.position, new Vector2(x2, y2) + rect.position, color, uvMin, clipped);
}
}
}
if (hasBorder)
{
clipped = uvMax;
for (long j = 0; j < nTilesH; j++)
{
float y1 = yMin + j * tileHeight;
float y2 = yMin + (j + 1) * tileHeight;
if (y2 > yMax)
{
clipped.y = uvMin.y + (uvMax.y - uvMin.y) * (yMax - y1) / (y2 - y1);
y2 = yMax;
}
AddQuad(toFill,
new Vector2(0, y1) + rect.position,
new Vector2(xMin, y2) + rect.position,
color,
new Vector2(outer.x, uvMin.y),
new Vector2(uvMin.x, clipped.y));
AddQuad(toFill,
new Vector2(xMax, y1) + rect.position,
new Vector2(rect.width, y2) + rect.position,
color,
new Vector2(uvMax.x, uvMin.y),
new Vector2(outer.z, clipped.y));
}
// Bottom and top tiled border
clipped = uvMax;
for (long i = 0; i < nTilesW; i++)
{
float x1 = xMin + i * tileWidth;
float x2 = xMin + (i + 1) * tileWidth;
if (x2 > xMax)
{
clipped.x = uvMin.x + (uvMax.x - uvMin.x) * (xMax - x1) / (x2 - x1);
x2 = xMax;
}
AddQuad(toFill,
new Vector2(x1, 0) + rect.position,
new Vector2(x2, yMin) + rect.position,
color,
new Vector2(uvMin.x, outer.y),
new Vector2(clipped.x, uvMin.y));
AddQuad(toFill,
new Vector2(x1, yMax) + rect.position,
new Vector2(x2, rect.height) + rect.position,
color,
new Vector2(uvMin.x, uvMax.y),
new Vector2(clipped.x, outer.w));
}
// Corners
AddQuad(toFill,
new Vector2(0, 0) + rect.position,
new Vector2(xMin, yMin) + rect.position,
color,
new Vector2(outer.x, outer.y),
new Vector2(uvMin.x, uvMin.y));
AddQuad(toFill,
new Vector2(xMax, 0) + rect.position,
new Vector2(rect.width, yMin) + rect.position,
color,
new Vector2(uvMax.x, outer.y),
new Vector2(outer.z, uvMin.y));
AddQuad(toFill,
new Vector2(0, yMax) + rect.position,
new Vector2(xMin, rect.height) + rect.position,
color,
new Vector2(outer.x, uvMax.y),
new Vector2(uvMin.x, outer.w));
AddQuad(toFill,
new Vector2(xMax, yMax) + rect.position,
new Vector2(rect.width, rect.height) + rect.position,
color,
new Vector2(uvMax.x, uvMax.y),
new Vector2(outer.z, outer.w));
}
}
else
{
// Texture has no border, is in repeat mode and not packed. Use texture tiling.
Vector2 uvScale = new Vector2((xMax - xMin) / tileWidth, (yMax - yMin) / tileHeight);
if (m_FillCenter)
{
AddQuad(toFill, new Vector2(xMin, yMin) + rect.position, new Vector2(xMax, yMax) + rect.position, color, Vector2.Scale(uvMin, uvScale), Vector2.Scale(uvMax, uvScale));
}
}
}
public override void OnActivate()
{
if (this.mStandCharaList.Count <= 0)
{
this.ActivateNext();
}
else
{
this.mMoveEnabled = this.MoveEnabled;
this.mScaleEnabled = this.ScaleEnabled;
this.mColorEnabled = this.ColorEnabled;
for (int index = 0; index < this.mStandCharaList.Count; ++index)
{
if (Object.op_Inequality((Object)this.mStandCharaList[index], (Object)null))
{
this.mStandCharaTransformList.Add((RectTransform)((Component)this.mStandCharaList[index]).GetComponent <RectTransform>());
}
}
if (this.Flip)
{
for (int index = 0; index < this.mStandCharaTransformList.Count; ++index)
{
((Transform)this.mStandCharaTransformList[index]).Rotate(new Vector3(0.0f, 180f, 0.0f));
}
}
if (this.mMoveEnabled)
{
for (int index = 0; index < this.mStandCharaTransformList.Count; ++index)
{
this.FromAnchorMinList.Add(this.mStandCharaTransformList[index].get_anchorMin());
this.FromAnchorMaxList.Add(this.mStandCharaTransformList[index].get_anchorMax());
if (this.Relative)
{
this.mToAnchorList.Add(Vector2.op_Addition(this.mStandCharaTransformList[index].get_anchorMin(), Vector2.Scale(this.MoveTo, new Vector2(0.5f, 1f))));
}
else
{
this.mToAnchorList.Add(this.convertPosition(this.MoveTo));
}
}
if ((double)this.MoveTime <= 0.0)
{
this.MoveOffset = 1f;
}
}
if (this.mScaleEnabled)
{
for (int index = 0; index < this.mStandCharaTransformList.Count; ++index)
{
this.FromWidthList.Add((float)((Transform)this.mStandCharaTransformList[index]).get_localScale().x);
this.FromHeightList.Add((float)((Transform)this.mStandCharaTransformList[index]).get_localScale().y);
}
this.mToWidth = (float)this.ScaleTo.x;
this.mToHeght = (float)this.ScaleTo.y;
if ((double)this.ScaleTime <= 0.0)
{
this.ScaleOffset = 1f;
}
}
if (this.mColorEnabled)
{
for (int index = 0; index < this.mStandCharaList.Count; ++index)
{
if (Object.op_Inequality((Object)this.mStandCharaList[index], (Object)null))
{
this.charaList.AddRange((IEnumerable <GameObject>) this.mStandCharaList[index].StandCharaList);
}
}
for (int index = 0; index < this.charaList.Count; ++index)
{
if (Object.op_Inequality((Object)((EventStandChara2)this.charaList[index].GetComponent <EventStandChara2>()).BodyObject, (Object)null))
{
this.BodyColorList.Add(((Graphic)((EventStandChara2)this.charaList[index].GetComponent <EventStandChara2>()).BodyObject.GetComponent <RawImage>()).get_color());
}
else
{
this.BodyColorList.Add(Color.get_white());
}
if (Object.op_Inequality((Object)((EventStandChara2)this.charaList[index].GetComponent <EventStandChara2>()).FaceObject, (Object)null))
{
this.FaceColorList.Add(((Graphic)((EventStandChara2)this.charaList[index].GetComponent <EventStandChara2>()).FaceObject.GetComponent <RawImage>()).get_color());
}
else
{
this.FaceColorList.Add(Color.get_white());
}
}
this.mToColor = this.ColorTo;
for (int index = 0; index < this.CharaIDs.Length; ++index)
{
string charaId = this.CharaIDs[index];
if (Event2dAction_OperateStandChara.CharaColorDic.ContainsKey(charaId))
{
Event2dAction_OperateStandChara.CharaColorDic[charaId] = this.ColorTo;
}
else
{
Event2dAction_OperateStandChara.CharaColorDic.Add(charaId, this.ColorTo);
}
}
if ((double)this.ColorTime <= 0.0)
{
this.ColorOffset = 1f;
}
}
if (!this.async)
{
return;
}
this.ActivateNext(true);
}
}
