public void move(Vector3Int endGridPos, bool comeback, bool sliding) { if (!isMoving) { isMoving = true; Vector3 startPosition = transform.position; Vector3 endPosition = tilemap_Obstacle.CellToLocal(endGridPos); CustomTile endTile = tilemap_Obstacle.GetTile <CustomTile>(endGridPos); if (sliding && comeback) { Vector3 direction = (endPosition - startPosition).normalized; endGridPos -= Vector3Int.FloorToInt(direction); endPosition = tilemap_Obstacle.CellToLocal(endGridPos); endTile = tilemap_Obstacle.GetTile <CustomTile>(endGridPos); comeback = false; } if (startPosition != endPosition) { playerOverTarget = endTile.type == "target"; StartCoroutine(LerpMove(startPosition, endPosition, endTile, comeback)); } else { EventManager.TriggerEvent("ready"); isMoving = false; } } }
private void CreateLevel() { for (int j = 0; j < 7; j++) { for (int i = 0; i < 17; i++) { prefabBulle.GetComponent <SpriteRenderer>().color = color.GetRandomColor(); GameObject tmp = Instantiate(prefabBulle, tilemap.LocalToWorld(tilemap.CellToLocal(new Vector3Int(-17 + i, 19 - j, 0))), Quaternion.identity); board.SetEmplacement(-17 + i, 19 - j, tmp); } } }
public void AddCapitalStructure(Vector3Int buildPos, int playerId) { GameTile gameTile = tiles[buildPos]; gameTile.OwnerId = playerId; gameTile.OwnerInfluence = 1000; gameTile.GameFieldTileType = GameTile.TileType.Structure; gameTile.StructType = GameTile.StructureType.Capital; gameTile.BuildingLvl = 1; if (gameTile.tileGameObject != null) { Destroy(gameTile.tileGameObject); } gameTile.tileGameObject = Instantiate(capitalPrefab, tilemap.CellToLocal(buildPos), Quaternion.identity); }
private void SelectTile(Vector3Int gridPos) { _selectedTile = tileMap.GetTile(gridPos); _selectedTilePos = gridPos; _tileSelection = Instantiate(Resources.Load("TileSelectionSprite"), tileMap.CellToLocal(new Vector3Int(-gridPos.x, gridPos.y, 0)), Quaternion.identity) as GameObject; _isTileSelected = true; }
void Start() { t = GetComponent <Tilemap>(); BoundsInt bounds = t.cellBounds; var s = t.layoutGrid.cellSize / 2; var availablePlaces = new List <Vector3>(); for (int n = t.cellBounds.xMin; n < t.cellBounds.xMax; n++) { for (int p = t.cellBounds.yMin; p < t.cellBounds.yMax; p++) { Vector3Int localPlace = (new Vector3Int(n, p, (int)t.transform.position.y)); Vector3 place = t.CellToWorld(localPlace); var tile = t.GetTile(localPlace); if (tile) { availablePlaces.Add(place); var c = new GameObject().AddComponent <BoxCollider2D>(); c.isTrigger = true; c.transform.parent = t.transform; c.transform.localPosition = t.CellToLocal(localPlace) + s; c.gameObject.layer = LayerMask.NameToLayer("SpeedBoost"); } } } }
public bool openSpace(Vector3Int spot) { if (!(walkAble(spot))) { return(false); } Vector3 irl = walkableMap.CellToLocal(spot); Vector3Int up_left = spot + new Vector3Int(-1, 1, 0); Vector3Int left = spot + new Vector3Int(-1, 0, 0); Vector3Int down_left = spot + new Vector3Int(-1, -1, 0); Vector3Int down = spot + new Vector3Int(0, -1, 0); Vector3Int down_right = spot + new Vector3Int(1, -1, 0); Vector3Int right = spot + new Vector3Int(1, 0, 0); Vector3Int up_right = spot + new Vector3Int(1, 1, 0); Vector3Int up = spot + new Vector3Int(0, 1, 0); Vector3 top_left = walkableMap.CellToWorld(up_left) * 5; Vector3 bottom_right = walkableMap.CellToWorld(down_right) * 5; //Debug.DrawLine (top_left, bottom_right); Collider2D[] mobs = Physics2D.OverlapAreaAll(new Vector2(top_left.x, top_left.y), new Vector2(bottom_right.x, bottom_right.y)); bool mobbed = (mobs.Length > 0); // Debug.Log (mobs.Length); return(walkAble(spot) && !mobbed && walkAble(up_left) && walkAble(left) && walkAble(down_left) && walkAble(down) && walkAble(down_right) && walkAble(right) && walkAble(up_right) && walkAble(up)); }
void Start() { t = gameObject.GetComponent <Tilemap>(); BoundsInt bounds = t.cellBounds; TileBase[] allTiles = t.GetTilesBlock(bounds); var s = t.cellSize / 2; var availablePlaces = new List <Vector3>(); for (int n = t.cellBounds.xMin; n < t.cellBounds.xMax; n++) { for (int p = t.cellBounds.yMin; p < t.cellBounds.yMax; p++) { Vector3Int localPlace = (new Vector3Int(n, p, (int)t.transform.position.y)); Vector3 place = t.CellToWorld(localPlace); var tile = t.GetTile(localPlace); if (tile) { availablePlaces.Add(place); var c = new GameObject().AddComponent <BoxCollider2D>(); c.isTrigger = true; c.transform.parent = t.transform; c.transform.localPosition = t.CellToLocal(localPlace) + s; Debug.Log("x:" + n + " y:" + p + " tile:" + tile.name); } } } }
private void AddResource(GameObject resourceGameObject, GameTile.ResourceType resourceType, Vector3Int pos) { GameTile gameTile = GameFieldTiles.instance.tiles[pos]; gameTile.GameFieldTileType = GameTile.TileType.Resource; gameTile.ResType = resourceType; gameTile.tileGameObject = Instantiate(resourceGameObject, gameField.CellToLocal(pos), Quaternion.identity); gameTile.tileGameObject.transform.parent = gameField.transform; }
public Vector3 LocalCoordinateForTileWithCurrentMousePosition() { Vector3 rawPosition = Camera.main.ScreenToWorldPoint(Input.mousePosition); Vector3 fixedPosition = new Vector3(rawPosition.x, rawPosition.y, 0); Vector3Int cellPosition = tilemap.WorldToCell(fixedPosition); return(tilemap.CellToLocal(cellPosition)); }
public Vector3 TileToWorld(Vector3Int tileSelected) { Vector3 tile; tile = tm.CellToLocal(tileSelected); Debug.Log("Tile : " + tileSelected + " World : " + tile); return(tile); }
/// <summary> /// Creates a tile at the given coordinates /// </summary> /// <param name="cord">The position of the engine</param> /// <param name="tilemap">The tilemap to use</param> /// <param name="direction">The direction it is facing</param> public override void Instantiate(Vector3Int cord, Tilemap tilemap, Direction direction) { base.Instantiate(cord, tilemap, direction); Quaternion rot = TileInfo.TransformMatrix[direction].rotation; GameObject gameObject = Instantiate(exhaust, tilemap.CellToLocal(cord) + new Vector3(0.5f * tilemap.cellSize.x, 0.5f * tilemap.cellSize.y), rot * Quaternion.Euler(90, 0, 0), tilemap.transform); gameObject.transform.position += rot * exhaustPos + 2 * Vector3.forward; tilemap.transform.parent.GetComponent <ShipManager>().MovementManager .AddEngine(cord, this, gameObject, direction); }
/// <summary> /// Creates a tile at the given coordinates /// </summary> /// <param name="cord">The position of the engine</param> /// <param name="tilemap">The tilemap to use</param> /// <param name="direction">The direction it is facing</param> public override void Instantiate(Vector3Int cord, Tilemap tilemap, Direction direction) { base.Instantiate(cord, tilemap, direction); GameObject gameObject = Instantiate(turretTemplate, tilemap.CellToLocal(cord) + new Vector3(0.5f * tilemap.cellSize.x, 0.5f * tilemap.cellSize.y), TileInfo.TransformMatrix[direction].rotation, tilemap.transform); var spriteRenderer = gameObject.GetComponent <SpriteRenderer>(); spriteRenderer.sprite = turret; spriteRenderer.sortingOrder = layer + 1; tilemap.transform.parent.GetComponent <ShipManager>().WeaponsManager.AddWeapon(cord, this, gameObject); }
IEnumerator SmoothMove(Vector3Int newTile) { moving = true; float movementSpeedLocal; Vector3 positionToMove = tilemap.CellToLocal(newTile) + tilemap.tileAnchor; Vector3 originPosition = tilemap.CellToLocal(currentTile) + tilemap.tileAnchor; if (originPosition.y != positionToMove.y && originPosition.x == positionToMove.x) { movementSpeedLocal = verticalMovementSpeed; } else { movementSpeedLocal = horizontalMovementSpeed; } // SFX stuff. Messy. Need to clean up if ((positionToMove.x > originPosition.x || positionToMove.x < originPosition.x) && originPosition.y == positionToMove.y && AudioManager.instance != null) { AudioManager.instance.PlaySound("BoxMove"); } while (transform.position != positionToMove) { float ratio = Mathf.Abs((Mathf.Abs((transform.position - originPosition).magnitude) + movementSpeedLocal * Time.deltaTime) / (positionToMove - originPosition).magnitude); transform.position = Vector3.Lerp(originPosition, positionToMove, ratio); yield return(null); } currentTile = newTile; moving = false; }
void UpdateCursorPosition(Vector3Int offset) { Vector3Int newPosition = _currentPosition + offset; if (!_board.ContainsPoint(newPosition.x, newPosition.y)) { return; } _currentPosition += offset; CustomTileData tileData = _board.tileData[_currentPosition.x, _currentPosition.y]; Vector3Int offsetNeededForRenderingOnMap = new Vector3Int(1, 1, tileData.position.z); transform.position = _tilemap.CellToLocal(_currentPosition + offsetNeededForRenderingOnMap); }
public void HighlightTile(Vector3 globalPos) { var cell = Tilemap.WorldToCell(globalPos); Decal.transform.localPosition = Tilemap.CellToLocal(cell); Decal.SetActive(true); var construction = DataHolder.SelectedCity.Constructions.Find(x => x.X == cell.x & x.Y == cell.y); if (construction == null) { UIController.ShowConstructionList(cell.x, cell.y); } else { UIController.ShowInfoAboutConstruction(construction); } }
public void GenerateSpriteMask() { DestroySpriteMasks(); t = GetComponent <Tilemap>(); BoundsInt bounds = t.cellBounds; var s = t.layoutGrid.cellSize / 2; var availablePlaces = new List <Vector3>(); for (int n = t.cellBounds.xMin; n < t.cellBounds.xMax; n++) { for (int p = t.cellBounds.yMin; p < t.cellBounds.yMax; p++) { Vector3Int localPlace = (new Vector3Int(n, p, (int)t.transform.position.y)); Vector3 place = t.CellToWorld(localPlace); TileBase tile = t.GetTile(localPlace); //CompositeCollider2D compositeCollider = t.GetComponent<CompositeCollider2D>(); //for (int i = 0; i < compositeCollider.pathCount; i++) //{ // Vector2[] points = new Vector2[compositeCollider.GetPathPointCount(i)]; //} if (tile) { availablePlaces.Add(place); var c = new GameObject().AddComponent <SpriteMask>(); c.GetComponent <SpriteMask>().sprite = tileMask; c.transform.parent = t.transform; c.transform.localPosition = t.CellToLocal(localPlace) + s; c.name = "SpriteMask"; generatedSpriteMasks.Add(c.gameObject); } } } }
private void SetupPotentialPortalLocations() { for (int x = floorDecor.cellBounds.xMin; x < floorDecor.cellBounds.xMax; x++) { for (int y = floorDecor.cellBounds.yMin; y < floorDecor.cellBounds.yMax; y++) { var pos = new Vector3Int(x, y, 0); var localPosition = floorDecor.CellToLocal(pos) + new Vector3(0.5f, 0.5f, 0); if (floorDecor.GetTile(pos) == null || wallDecor.GetTile(pos) != null) { continue; } var worldPosition = floorDecor.LocalToWorld(localPosition); var result = Physics2D.OverlapCircle(worldPosition, 1f, LayerMask.GetMask("Wall")); if (result != null) { failedPortalLocations.Add(worldPosition); } else { potentialPortalSpawnLocations.Add(localPosition); } //if (result == null) //{ // potentialPortalSpawnLocations.Add(localPosition); //} } } // The max distance between portals is roughly the distance between the first and last portal // since we're traversing the nodes from corner to corner maxPortalDist = (potentialPortalSpawnLocations[0] - potentialPortalSpawnLocations[potentialPortalSpawnLocations.Count - 1]).magnitude; }
public void GenerateMap() { // background if (backgroundFill && backGroundTile) { List <TileBase> tiles = new List <TileBase>(); foreach (Vector3Int p in mapSize.allPositionsWithin) { //tilemap.SetTile(p, backGroundTile); tiles.Add(backGroundTile); } tilemap.SetTilesBlock(mapSize, tiles.ToArray()); } // cities centers //citiesCenters = new Vector3Int[6]; int generatedCities = citiesCenters.Length; tilemap.SetTile(new Vector3Int(0, 0, 0), waterTile); for (int i = 0; i < citiesCenters.Length; i++) { float angle = 60 * i * Mathf.Deg2Rad; Vector3 p1 = new Vector3(citiesDistances * Mathf.Cos(angle), citiesDistances * Mathf.Sin(angle), 0); citiesCenters[i] = tilemap.LocalToCell(p1);// new Vector3Int((int)p1.x, (int)p1.y, (int)p1.z); } // forest for (int i = 0; i < generatedCities; i++) { BoundsInt cityBound = new BoundsInt(citiesCenters[i] - new Vector3Int(cityRadius, cityRadius, 0), new Vector3Int(2 * cityRadius, 2 * cityRadius, 1)); foreach (Vector3Int cell in cityBound.allPositionsWithin) { Vector3 p2 = tilemap.CellToLocal(cell); float r = Vector3.Distance(tilemap.CellToLocal(citiesCenters[i]), p2); if (r < cityRadius && RandomForest(r / cityRadius) > forestThreshold) { tilemap.SetTile(cell, forestTile); if (Random.Range(0, 2) != 0) { Matrix4x4 matrix = Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(0f, 180f, 0f), Vector3.one); tilemap.SetTransformMatrix(cell, matrix); } } else if (r < cityRadius) { tilemap.SetTile(cell, backGroundTile); } } tilemap.SetTile(citiesCenters[i], waterTile); } // rivers for (int i = 0; i < generatedCities; i++) { Vector3Int start = citiesCenters[i]; List <Vector3Int> path = GetNoisyPath(start, new Vector3Int(0, 0, 0), waysDecimation, waysDisplacementNoise, true, riverDeadendsProbability); foreach (Vector3Int p2 in path) { tilemap.SetTile(p2, waterTile); } float angle = 60 * i * Mathf.Deg2Rad; Vector3 p1 = new Vector3(2 * citiesDistances * Mathf.Cos(angle), 2 * citiesDistances * Mathf.Sin(angle), 0); List <Vector3Int> path2 = GetNoisyPath(start, new Vector3Int((int)p1.x, (int)p1.y, (int)p1.z), waysDecimation, waysDisplacementNoise, true, riverDeadendsProbability); foreach (Vector3Int p2 in path2) { tilemap.SetTile(p2, waterTile); } } // roads for (int i = 0; i < generatedCities; i++) { Vector3Int start = citiesCenters[i]; Vector3Int end = citiesCenters[(i + 1) % citiesCenters.Length]; List <Vector3Int> path = GetNoisyPath(start, end, waysDecimation, waysDisplacementNoise); foreach (Vector3Int p2 in path) { tilemap.SetTile(p2, roadTile); } } if (generatedCities != citiesCenters.Length) { Vector3Int start = citiesCenters[0]; Vector3Int end = citiesCenters[citiesCenters.Length - 1]; List <Vector3Int> path = GetNoisyPath(start, end, waysDecimation, waysDisplacementNoise); foreach (Vector3Int p2 in path) { tilemap.SetTile(p2, roadTile); } } for (int i = 0; i < generatedCities; i++) { tilemap.SetTile(citiesCenters[i], debugTile1); } }
private void Generate(Tilemap tilemap) { int tileCount = tilemap.GetUsedTilesCount(); TileBase[] tiles = new TileBase[tileCount]; tilemap.GetUsedTilesNonAlloc(tiles); tilemap.CompressBounds(); Vector2 tilemapSize = tilemap.localBounds.size; Vector2Int textureSize = Vector2Int.RoundToInt(tilemapSize * pixelsPerUnit); Vector2Int powerOf2Size = new Vector2Int(Mathf.NextPowerOfTwo(textureSize.x), Mathf.NextPowerOfTwo(textureSize.y)); Texture2D texture = new Texture2D(powerOf2Size.x, powerOf2Size.y, TextureFormat.ARGB32, false); Color zeroColor = new Color(0, 0, 0, 0); for (int x = 0; x < powerOf2Size.x; x++) { for (int y = 0; y < powerOf2Size.y; y++) { texture.SetPixel(x, y, zeroColor); } } BoundsInt bounds = tilemap.cellBounds; TileBase[] allTiles = tilemap.GetTilesBlock(bounds); for (int x = 0; x < bounds.size.x; x++) { for (int y = 0; y < bounds.size.y; y++) { TileBase tileBase = allTiles[x + y * bounds.size.x]; if (tileBase == null) { continue; } Tile tile = tileBase as Tile; if (tile == null) { continue; } Sprite tileSprite = tilemap.GetSprite(new Vector3Int(x + bounds.x, y + bounds.y, 0)); Vector2 tileSize = tileSprite.bounds.size; tileSize.x /= transform.lossyScale.x; tileSize.y /= transform.lossyScale.y; Vector2Int tileSizePixels = Vector2Int.RoundToInt(tileSize * pixelsPerUnit); Vector2 pivot = tileSprite.pivot; int tileSpriteWidth = Mathf.RoundToInt(tileSprite.rect.xMax); int tileSpriteHeight = Mathf.RoundToInt(tileSprite.rect.yMax); pivot.x *= tileSize.x / tileSpriteWidth; pivot.y *= tileSize.y / tileSpriteHeight; Vector2 tilePos = tilemap.CellToLocal(new Vector3Int(x, y, 0)); Vector2 tileOrigin = tilePos; tileOrigin.x *= textureSize.x / tilemapSize.x; tileOrigin.y *= textureSize.y / tilemapSize.y; Vector2Int tileOriginPixels = Vector2Int.RoundToInt(tileOrigin); //Color[] pixels = tile.sprite.texture.GetPixels(); //texture.SetPixels(tileOriginPixels.x, tileOriginPixels.y, tileSizePixels.x, tileSizePixels.y, pixels); Texture2D spriteTex = tileSprite.texture; for (int px = 0; px < tileSizePixels.x; px++) { for (int py = 0; py < tileSizePixels.y; py++) { int tx = px * tileSpriteWidth / tileSizePixels.x; int ty = py * tileSpriteHeight / tileSizePixels.y; Color pixel = spriteTex.GetPixel(tx, ty); texture.SetPixel(tileOriginPixels.x + px, tileOriginPixels.y + py, pixel); } } } } texture.Apply(); Rect rect = new Rect(Vector2.zero, textureSize); resultSprite = Sprite.Create(texture, rect, (Vector2)textureSize / 2f, pixelsPerUnit); CreateAsset(); }
void Place(string obj, int i, int j) { GameObject.Find(obj).transform.SetPositionAndRotation(gridLabirinto.CellToLocal(new Vector3Int(j, -i, 0)) + new Vector3(0.45f, 0.45f, -1f), Quaternion.identity); }
public Vector3 CellToLocal(Vector3Int cell) { return tilemap.CellToLocal(cell); }
// Need to rework the animation stuff / this is messy as is IEnumerator SmoothMove(Vector3Int newTile) { moving = true; float movementSpeedLocal; Vector3 positionToMove = tilemap.CellToLocal(newTile) + tilemap.tileAnchor; Vector3 originPosition = tilemap.CellToLocal(currentTile) + tilemap.tileAnchor; if (originPosition.y != positionToMove.y && originPosition.x == positionToMove.x) { movementSpeedLocal = verticalMovementSpeed; } else { movementSpeedLocal = horizontalMovementSpeed; } // animation checks if (positionToMove.x > originPosition.x) { animator.SetBool("isSlidingRight", true); } else if (positionToMove.x < originPosition.x) { animator.SetBool("isSlidingLeft", true); } else if (positionToMove.y - originPosition.y < 0) { animator.SetBool("HasStartedFalling", true); } while (transform.position != positionToMove) { float ratio = Mathf.Abs((Mathf.Abs((transform.position - originPosition).magnitude) + movementSpeedLocal * Time.deltaTime) / (positionToMove - originPosition).magnitude); transform.position = Vector3.Lerp(originPosition, positionToMove, ratio); // If we are moving upwards and only have one tile length left to move, start the approach peak animation if (positionToMove.y - transform.position.y < tilelength / 2 && positionToMove.y - transform.position.y > 0 && hanging) { //animator.SetTrigger("ApproachJumpPeak"); animator.SetBool("HaveApproachedPeak", true); } else if (positionToMove.y < transform.position.y && Mathf.Abs(positionToMove.y - transform.position.y) < tilelength / 2) { animator.SetBool("HasLanded", true); } else if (hanging && gridCollisionFlags.above) { animator.SetTrigger("HeadBonk"); } yield return(null); } currentTile = newTile; moving = false; if (hanging) { tilesMovedDuringHangtime += Mathf.Abs(originPosition.x - positionToMove.x); } //Reset animation flags animator.SetBool("isSlidingRight", false); animator.SetBool("isSlidingLeft", false); animator.SetBool("HaveApproachedPeak", false); animator.SetBool("HasStartedFalling", false); animator.SetBool("HasJumped", false); animator.SetBool("HasLanded", false); //animator.ResetTrigger("HeadBonk"); }
private bool UploadData(HEU_SessionBase session, HAPI_NodeId inputNodeID, HEU_InputData inputData) { if (settings == null) { HEU_Logger.LogError("Tilemap Settings not found!"); return(false); } HEU_InputDataTilemap inputTilemap = inputData as HEU_InputDataTilemap; if (inputTilemap == null) { HEU_Logger.LogError("Expected HEU_InputDataTilemap type for inputData, but received unssupported type."); return(false); } List <Vector3> vertices = new List <Vector3>(); List <Vector3> colors = new List <Vector3>(); List <string> tileNames = new List <string>(); List <Vector3> tileSizes = new List <Vector3>(); List <Vector3Int> tileCoords = new List <Vector3Int>(); Tilemap tileMap = inputTilemap._tilemap; if (!tileMap.gameObject.activeInHierarchy) { HEU_Logger.LogWarning("Tilemap inputs must be active in the hierarchy in order to properly send input data"); } Grid gridLayout = tileMap.layoutGrid; Matrix4x4 orientation = tileMap.orientationMatrix; Vector3 orientationPosition = orientation.DecomposeToPosition(); Vector3 orientationRotationEuler = orientation.DecomposeToRotation().eulerAngles; orientationRotationEuler.y = -orientationRotationEuler.y; orientationRotationEuler.z = -orientationRotationEuler.z; Quaternion orientationRotation = Quaternion.Euler(orientationRotationEuler); Vector3 orientationScale = orientation.DecomposeToScale(); List <float> pointOrient = new List <float>(); List <Vector3> pointScale = new List <Vector3>(); TileBase[] tileArray = tileMap.GetTilesBlock(tileMap.cellBounds); int tileCount = 0; Vector3 anchorOffset = tileMap.tileAnchor; anchorOffset.Scale(gridLayout.cellSize); Vector3 pointPos; Vector3Int boundsMin = new Vector3Int(int.MaxValue, int.MaxValue, int.MaxValue); Vector3Int boundsMax = new Vector3Int(int.MinValue, int.MinValue, int.MinValue); foreach (Vector3Int tilePos in tileMap.cellBounds.allPositionsWithin) { if (tileMap.HasTile(tilePos)) { boundsMin = Vector3Int.Min(tilePos, boundsMin); boundsMax = Vector3Int.Max(tilePos, boundsMax); } } boundsMax += Vector3Int.one; BoundsInt tileMapBounds = new BoundsInt { min = boundsMin, max = boundsMax }; foreach (Vector3Int tilePos in tileMapBounds.allPositionsWithin) { if (!settings._exportUnusedTiles && !tileMap.HasTile(tilePos)) { continue; } Vector3Int usedTilePos = tilePos; //For Houdini (to use Labs Wang Tile tools, we need to reverse point order on the x axis) //so we just iterate in reverse order on the x //usedTilePos.x = tileMapBounds.size.x - 1 - tilePos.x + 2 * tileMapBounds.min.x; tileCount++; pointPos = tileMap.CellToLocal(usedTilePos) + anchorOffset; if (settings._applyTilemapOrientation) { pointPos += orientationPosition; pointOrient.Add(orientationRotation[0]); pointOrient.Add(orientationRotation[1]); pointOrient.Add(orientationRotation[2]); pointOrient.Add(orientationRotation[3]); pointScale.Add(orientationScale); } vertices.Add(pointPos); if (tileMap.HasTile(usedTilePos)) { Tile tile = tileMap.GetTile <Tile>(usedTilePos); tileNames.Add(tile.name); if (settings._applyTileColor) { colors.Add(new Vector3(tile.color.r, tile.color.g, tile.color.b)); } tileSizes.Add(new Vector3(tile.sprite.rect.size.x / tile.sprite.pixelsPerUnit, tile.sprite.rect.size.y / tile.sprite.pixelsPerUnit, 0.0f)); } else { tileNames.Add(""); if (settings._applyTileColor) { colors.Add(Vector3.zero); } tileSizes.Add(Vector3.zero); } tileCoords.Add(usedTilePos); } HAPI_PartInfo partInfo = new HAPI_PartInfo(); partInfo.faceCount = 0; partInfo.vertexCount = 0; partInfo.pointCount = tileCount; partInfo.pointAttributeCount = 1; partInfo.vertexAttributeCount = 0; partInfo.primitiveAttributeCount = 0; partInfo.detailAttributeCount = 1; if (tileSizes.Count > 0) { partInfo.pointAttributeCount++; } if (settings._applyTileColor && colors.Count > 0) { partInfo.pointAttributeCount++; } if (tileCoords.Count > 0) { partInfo.pointAttributeCount++; } if (pointOrient.Count > 0) { partInfo.pointAttributeCount++; } if (pointScale.Count > 0) { partInfo.pointAttributeCount++; } if (!settings._createGroupsForTiles && tileNames.Count > 0) { partInfo.pointAttributeCount++; } HAPI_GeoInfo displayGeoInfo = new HAPI_GeoInfo(); if (!session.GetDisplayGeoInfo(inputNodeID, ref displayGeoInfo)) { return(false); } HAPI_NodeId displayNodeID = displayGeoInfo.nodeId; if (!session.SetPartInfo(displayNodeID, 0, ref partInfo)) { Debug.LogError("Failed to set input part info. "); return(false); } if (!HEU_InputMeshUtility.SetMeshPointAttribute(session, displayNodeID, 0, HEU_HAPIConstants.HAPI_ATTRIB_POSITION, 3, vertices.ToArray(), ref partInfo, true)) { Debug.LogError("Failed to set point positions."); return(false); } if (!HEU_InputMeshUtility.SetMeshPointAttribute(session, displayNodeID, 0, "unity_tile_size", 2, tileSizes.ToArray(), ref partInfo, false)) { Debug.Log("Failed to set tile size attributes. "); return(false); } if (settings._applyTileColor) { if (!HEU_InputMeshUtility.SetMeshPointAttribute(session, displayNodeID, 0, HEU_HAPIConstants.HAPI_ATTRIB_COLOR, 3, colors.ToArray(), ref partInfo, false)) { Debug.Log("Failed to set tile color attributes. "); return(false); } } if (!HEU_InputMeshUtility.SetMeshPointAttribute(session, displayNodeID, 0, "unity_tile_pos", 2, tileCoords.ToArray(), ref partInfo)) { Debug.Log("Failed to set point tile coordinates attributes."); return(false); } if (settings._createGroupsForTiles) { //Get a list of unique tiles used TileBase[] usedTiles = new TileBase[tileMap.GetUsedTilesCount()]; tileMap.GetUsedTilesNonAlloc(usedTiles); //Set point groups based on tile type int[] pointGroupMembership = new int[tileCount]; foreach (TileBase tileType in usedTiles) { if (!session.AddGroup(displayNodeID, 0, HAPI_GroupType.HAPI_GROUPTYPE_POINT, tileType.name)) { return(false); } int index = 0; foreach (string tileName in tileNames) { if (tileName.Equals(tileType.name)) { pointGroupMembership[index] = 1; } else { pointGroupMembership[index] = 0; } index++; } if (!session.SetGroupMembership(displayNodeID, 0, HAPI_GroupType.HAPI_GROUPTYPE_POINT, tileType.name, pointGroupMembership, 0, tileCount)) { return(false); } } } else { if (!HEU_InputMeshUtility.SetMeshPointAttribute(session, displayNodeID, 0, "unity_tile_name", tileNames.ToArray(), ref partInfo)) { Debug.Log("Failed to set point tile name attributes."); return(false); } } if (!HEU_InputMeshUtility.SetMeshDetailAttribute(session, displayNodeID, 0, "unity_tile_bounds", 2, tileMapBounds.size, ref partInfo)) { Debug.Log("Failed to set detail tile map bounds attribute."); return(false); } if (settings._applyTilemapOrientation) { if (!HEU_InputMeshUtility.SetMeshPointAttribute(session, displayNodeID, 0, HEU_Defines.HAPI_ATTRIB_ORIENT, 4, pointOrient.ToArray(), ref partInfo)) { Debug.LogError("Failed to set point rotations."); return(false); } if (!HEU_InputMeshUtility.SetMeshPointAttribute(session, displayNodeID, 0, HEU_Defines.HAPI_ATTRIB_SCALE, 3, pointScale.ToArray(), ref partInfo, false)) { Debug.LogError("Failed to set point scales."); return(false); } } return(session.CommitGeo(displayNodeID)); }
private bool UploadData( HEU_SessionBase session, HAPI_NodeId inputNodeID, HEU_InputData inputData) { HEU_InputDataTilemap inputTilemap = inputData as HEU_InputDataTilemap; if(inputTilemap == null) { Debug.LogError("Expected HEU_InputDataTilemap type for inputData, but received unssupported type."); return false; } List<Vector3> vertices = new List<Vector3>(); List<Vector3> colors = new List<Vector3>(); //List<Vector3> uvs = new List<Vector3>(); List<Vector3> normals = new List<Vector3>(); List<string> tileNames = new List<string>(); List<Vector3> tileSizes = new List<Vector3>(); List<Vector3Int> tileCoords = new List<Vector3Int>(); Tilemap tileMap = inputTilemap._tilemap; Grid gridLayout = tileMap.layoutGrid; //Get a list of unique tiles used TileBase[] usedTiles = new TileBase[ tileMap.GetUsedTilesCount() ]; tileMap.GetUsedTilesNonAlloc(usedTiles); TileBase[] tileArray = tileMap.GetTilesBlock( tileMap.cellBounds ); //tileArray = tileArray.Where( x => x != null).ToArray(); //only existing tiles int tileCount = 0; Vector3 anchorOffset = tileMap.tileAnchor; anchorOffset.Scale(gridLayout.cellSize); Vector3 pointPos; Vector3 pointNormal = new Vector3(0.0f, 0.0f, 1.0f); Vector3Int boundsMin = new Vector3Int(int.MaxValue, int.MaxValue, int.MaxValue); Vector3Int boundsMax = new Vector3Int(int.MinValue, int.MinValue, int.MinValue); foreach (Vector3Int tilePos in tileMap.cellBounds.allPositionsWithin) { if (tileMap.HasTile(tilePos)) { boundsMin = Vector3Int.Min(tilePos, boundsMin); boundsMax = Vector3Int.Max(tilePos, boundsMax); } } boundsMax += Vector3Int.one; BoundsInt tileMapBounds = new BoundsInt { min = boundsMin, max = boundsMax }; //foreach (Vector3Int tilePos in tileMap.cellBounds.allPositionsWithin) Vector3Int tilePosReverseX = new Vector3Int(); foreach(Vector3Int tilePos in tileMapBounds.allPositionsWithin) { #if !EXPORT_RECT_GRID if(!tileMap.HasTile(tilePos)) continue; #endif tilePosReverseX = tilePos; //For Hudini (to use Labs Wang Tile tools, we need to reverse point order on the x axis) //so we just iterate in reverse order on the x tilePosReverseX.x = tileMapBounds.size.x - 1 - tilePos.x + 2 * tileMapBounds.min.x; tileCount++; pointPos = tileMap.CellToLocal(tilePosReverseX) + anchorOffset; vertices.Add(pointPos); normals.Add(pointNormal); if (tileMap.HasTile(tilePosReverseX)) { Tile tile = tileMap.GetTile<Tile>(tilePosReverseX); tileNames.Add(tile.name); colors.Add(new Vector3(tile.color.r, tile.color.g, tile.color.b)); tileSizes.Add(new Vector3(tile.sprite.rect.size.x / tile.sprite.pixelsPerUnit, tile.sprite.rect.size.y / tile.sprite.pixelsPerUnit, 0.0f)); } else { tileNames.Add(""); colors.Add(Vector3.zero); tileSizes.Add(Vector3.zero); } tileCoords.Add(tilePosReverseX); } HAPI_PartInfo partInfo = new HAPI_PartInfo(); partInfo.faceCount = 0; partInfo.vertexCount = 0; partInfo.pointCount = tileCount; partInfo.pointAttributeCount = 1; partInfo.vertexAttributeCount = 0; partInfo.primitiveAttributeCount = 0; partInfo.detailAttributeCount = 0; HAPI_GeoInfo displayGeoInfo = new HAPI_GeoInfo(); if(!session.GetDisplayGeoInfo(inputNodeID, ref displayGeoInfo)) { return false; } HAPI_NodeId displayNodeID = displayGeoInfo.nodeId; if(!session.SetPartInfo(displayNodeID, 0, ref partInfo)) { Debug.LogError("Failed to set input part info. "); return false; } if(!HEU_InputMeshUtility.SetMeshPointAttribute(session, displayNodeID, 0, HEU_Defines.HAPI_ATTRIB_POSITION, 3, vertices.ToArray(), ref partInfo, true)) { Debug.LogError("Failed to set point positions."); return false; } if (!HEU_InputMeshUtility.SetMeshPointAttribute(session, displayNodeID, 0, "size", 2, tileSizes.ToArray(), ref partInfo, false)) { Debug.Log("Failed to set tile size attributes. "); return false; } if(!HEU_InputMeshUtility.SetMeshPointAttribute(session, displayNodeID, 0, HEU_Defines.HAPI_ATTRIB_COLOR, 3, colors.ToArray(), ref partInfo, false)) { Debug.Log("Failed to set tile color attributes. "); return false; } if(!HEU_InputMeshUtility.SetMeshPointAttribute(session, displayNodeID, 0, HEU_Defines.HAPI_ATTRIB_NORMAL, 3, normals.ToArray(), ref partInfo, true)) { Debug.Log("Failed to set point normal attributes."); return false; } if(!HEU_InputMeshUtilityExt.SetMeshPointAttribute(session, displayNodeID, 0, "tilepos", 2, tileCoords.ToArray(), ref partInfo)) { Debug.Log("Failed to set point tile coordinates attributes."); return false; } #if TILENAME_GROUPS //Set point groups based on tile type int[] pointGroupMembership = new int[tileCount]; foreach(TileBase tileType in usedTiles) { if(!session.AddGroup( displayNodeID, 0, HAPI_GroupType.HAPI_GROUPTYPE_POINT, tileType.name)) return false; int index = 0; foreach( string tileName in tileNames) { if(tileName.Equals(tileType.name)) pointGroupMembership[index] = 1; else pointGroupMembership[index] = 0; index++; } if(!session.SetGroupMembership(displayNodeID, 0, HAPI_GroupType.HAPI_GROUPTYPE_POINT, tileType.name, pointGroupMembership, 0, tileCount)) return false; } #else if(!HEU_InputMeshUtilityExt.SetMeshPointAttribute(session, displayNodeID, 0, "tilename", tileNames.ToArray(), ref partInfo)) { Debug.Log("Failed to set point tile name attributes."); return false; } #endif if(!HEU_InputMeshUtilityExt.SetMeshDetailAttribute(session, displayNodeID, 0, "bounds", 2, tileMapBounds.size, ref partInfo)) { Debug.Log("Failed to set detail tile map bounds attribute."); return false; } return session.CommitGeo(displayNodeID); }