public void SetApexHeight(Point2D apexPoint, float value, int lod) { Preconditions.Assert(lod >= _submap.LodFactor, "Cant set apex height. Lod factor is too small"); var pixelSize = (int)Math.Pow(2, lod - _submap.LodFactor); if (Equals(apexPoint, _submap.SubmapPosition.DownLeftPoint)) { _submap.Heightmap.SetDownLeftApexMarginHeight(value, pixelSize); } else if (Equals(apexPoint, _submap.SubmapPosition.DownRightPoint)) { _submap.Heightmap.SetDownRightApexMarginHeight(value, pixelSize); } else if (Equals(apexPoint, _submap.SubmapPosition.TopLeftPoint)) { _submap.Heightmap.SetTopLeftApexMarginHeight(value, pixelSize); } else if (Equals(apexPoint, _submap.SubmapPosition.TopRightPoint)) { _submap.Heightmap.SetTopRightApexMarginHeight(value, pixelSize); } else { Preconditions.Fail(string.Format("Point {0} is not apex point", apexPoint)); } }
private IEnumerable <SolidTextureGeneratingStatus> Generate(int sideSize, int maxPixelsPerDispatch, string kernelName) { var slicesPerDispatch = (int)Math.Floor((float)maxPixelsPerDispatch / (sideSize * sideSize)); Preconditions.Assert(slicesPerDispatch > 0, "MaxPixelsPerDispatch must be bigger, now it is 0"); var texture = new RenderTexture(sideSize, sideSize, 0, RenderTextureFormat.R8, RenderTextureReadWrite.Default); texture.dimension = TextureDimension.Tex3D; texture.enableRandomWrite = true; texture.volumeDepth = sideSize; texture.wrapMode = TextureWrapMode.Repeat; texture.Create(); for (int i = 0; i < Mathf.CeilToInt((float)sideSize / slicesPerDispatch); i++) { ExecuteDispatch(sideSize, i, slicesPerDispatch, texture, kernelName).Wait(); yield return(new SolidTextureGeneratingStatus() { Done = false, SolidTexture = texture }); } yield return(new SolidTextureGeneratingStatus() { Done = true, SolidTexture = texture }); }
public ulong[] GenerateUniformGroupFromCycle(List <int> cycle, uint dimensions) { Preconditions.Assert(cycle.Count <= 64, "Cycle count must be <= 64 (ulong size)"); ulong[] uniforms = new ulong[dimensions]; for (int i = 0; i < cycle.Count; i++) { for (int d = 0; d < dimensions; d++) { uniforms[d] = uniforms[d] << 1; ulong bit = (((ulong)cycle[i]) >> d) & 1; // we take i-th bit counting from right uniforms[d] = uniforms[d] | bit; } } // le trick int repetitionsCount = Mathf.FloorToInt(64 / cycle.Count); int baseSize = cycle.Count; for (int d = 0; d < dimensions; d++) { ulong repetitionBase = uniforms[d]; for (int i = 1; i < repetitionsCount; i++) { uniforms[d] = uniforms[d] | (repetitionBase << i * baseSize); } } return(uniforms); }
public override void StartBehaviourTreeUpdate(BehaviourTreeRoot root) { Preconditions.Assert(_rootSnapshot == null, "RootSnapshotNotNull"); Preconditions.Assert(_snapshotsStack == null, "SnapshotStack not null"); _rootSnapshot = CreateBaseTaskSnapshot(root.Child); _snapshotsStack = new Stack <AiRegistryTaskSnapshot>(); }
public void AddMultistepOrder(MultistepRenderingProcessOrder <Texture, TextureRenderingTemplate> processOrder) { var template = processOrder.Order; Preconditions.Assert(template.RenderingRectangle == null, "E781: Cannot render multistep when filling RenderTexture!"); var outTextureInfo = template.OutTextureInfo; var shaderName = template.ShaderName; var pack = template.UniformPack; var material = new Material(Shader.Find(shaderName)); template.Keywords.EnableInMaterial(material); pack.SetUniformsToMaterial(material); var renderTextureFormat = template.RenderTextureFormat; MultistepTextureRenderingInput input = new MultistepTextureRenderingInput() { MultistepCoordUniform = new MultistepRenderingCoordUniform( new Vector4( template.Coords.X, template.Coords.Y, template.Coords.Width, template.Coords.Height ), "_Coords"), OutTextureinfo = outTextureInfo, RenderTextureInfoFormat = renderTextureFormat, RenderMaterial = material, StepSize = _configuration.StepSize, CreateTexture2D = template.CreateTexture2D }; _multistepTextureRenderer.StartRendering(input); _multistepProcessOrder = processOrder; }
public HeightmapMarginWithInfo UpdateWherePossible(HeightmapMarginWithInfo newMargin) { //Preconditions.Assert( _heightmapMargin.Length == newMargin.HeightmapLength, todo change not to length but to lods // string.Format("Current margin length is {0} != new margin length == {1} ", _heightmapMargin.Length, newMargin.HeightmapLength)); Preconditions.Assert( (newMargin.Position.IsHorizontal && Position.IsHorizontal) || (newMargin.Position.IsVertical && Position.IsVertical), string.Format("Current and new margins are one vertical one horizontal: Old {0} new {1}", _heightmapMargin, newMargin)); bool haveCommonElements = Position.HaveCommonElementWith(newMargin.Position); Preconditions.Assert(haveCommonElements, string.Format("Current {0} and new {1} margin dont have common elements", HeightmapMargin, newMargin)); MarginPosition commonSegment = Position.GetCommonSegment(newMargin.Position); var ourStartPercent = Position.InvLerp(commonSegment.StartPoint); var ourStartOffset = (int)Math.Round((double)HeightmapWorkingLength * ourStartPercent); var ourEndPercent = Position.InvLerp(commonSegment.EndPoint); var ourEndOffset = (int)Math.Round((double)HeightmapWorkingLength * ourEndPercent); var theirStartPercent = newMargin.Position.InvLerp(commonSegment.StartPoint); var theirStartOffset = (int)Math.Round((double)newMargin.HeightmapWorkingLength * theirStartPercent); var theirEndPercent = newMargin.Position.InvLerp(commonSegment.EndPoint); var theirEndOffset = (int)Math.Round((double)newMargin.HeightmapWorkingLength * theirEndPercent); return(new HeightmapMarginWithInfo( SetMarginSubElement(ourStartOffset, ourEndOffset, theirStartOffset, theirEndOffset, newMargin), Position, LodFactor)); }
public StripRegistrationResult RegisterStrip(StripSide leader) { Preconditions.Assert( Math.Abs(leader.NormalizedMarginUvOfTerrain.x) < 0.00001f && Math.Abs(leader.NormalizedMarginUvOfTerrain.y - 1) < 0.00001f, "Leader's marginUv must be 0-1, but is " + leader.NormalizedMarginUvOfTerrain); for (int i = 0; i < _stripColumns.Length; i++) { var column = _stripColumns[i]; if (column.HasEmptyStrip) { var stripInColumnIndex = column.AllocateStrip(leader); return(new StripRegistrationResult() { StripPosition = new WeldStripPosition() { ColumnIndex = i, StripInColumnIndex = stripInColumnIndex }, WeldUvs = TerrainWeldUvs.CreateFrom(leader.WeldSideType, CreateNormalizedWeldRange( CalculateWeldRange(stripInColumnIndex, leader.NormalizedMarginUvOfTerrain), i)) }); } } Preconditions.Fail("E22. There are no empty strips"); return(null); }
public WeldStrip GetSegment(int index) { var strip = _strips[index]; Preconditions.Assert(strip != null, $"E64 Strip of index {index} is not allocated"); return(strip); }
public void RemoveTerrain(int terrainId) { foreach (var pair in _terrainSideToStripPositions.Where(c => c.Key.TerrainId == terrainId) .ToList()) // when given terrain is leader { _terrainSideToStripPositions.Remove(pair.Key); var wasRemoved = _level2Manager.RemoveWeld(pair.Value, terrainId); _followerStripPositions.Where(c => c.Value.Equals(pair.Value)).ToList() .ForEach(c => _followerStripPositions.Remove(c.Key)); Preconditions.Assert(wasRemoved, "leader was removed, but there was no removal of strip"); } foreach (var pair in _followerStripPositions.Where(c => c.Key.TerrainId == terrainId) .ToList()) // when given terrain is follower { var wasRemoved = _level2Manager.RemoveWeld(pair.Value, terrainId); if (wasRemoved) //last follower - can removfe leader { _terrainSideToStripPositions.Where(c => c.Value.Equals(pair.Value)).ToList() .ForEach(c => _terrainSideToStripPositions.Remove(c.Key)); } _followerStripPositions.Remove(pair.Key); } }
private Vector2 CalculateFollowerMarginUv(WeldSideSource biggerTerrain, WeldSideSource smallerTerrain) { var biggerSideRange = new Vector2(0, 0); if (biggerTerrain.SideType.GetOrientation() == WeldOrientation.Horizontal) { biggerSideRange = RectangleUtils.CalculateSubPosition(biggerTerrain.Terrain.DetailGlobalArea, biggerTerrain.Terrain.UvCoordsPositions2D).XRange; } else { biggerSideRange = RectangleUtils.CalculateSubPosition(biggerTerrain.Terrain.DetailGlobalArea, biggerTerrain.Terrain.UvCoordsPositions2D).YRange; } var smallerSideRange = new Vector2(0, 0); if (smallerTerrain.SideType.GetOrientation() == WeldOrientation.Horizontal) { smallerSideRange = RectangleUtils.CalculateSubPosition(smallerTerrain.Terrain.DetailGlobalArea, smallerTerrain.Terrain.UvCoordsPositions2D).XRange; } else { smallerSideRange = RectangleUtils.CalculateSubPosition(smallerTerrain.Terrain.DetailGlobalArea, smallerTerrain.Terrain.UvCoordsPositions2D).YRange; } var uv = VectorUtils.CalculateSubelementUv(biggerSideRange, smallerSideRange); Preconditions.Assert(uv.IsNormalized(), $"E76 Margin uv is not normalized: {uv}, biggerSideRange:{biggerSideRange}, smallerSideRange {smallerSideRange}"); return(uv); }
public void AddSide(WeldSideSource weldSideSource) { if (weldSideSource.SideType == WeldSideType.Bottom) { Preconditions.Assert(First == null, $"E12 Bottom of weld is arleady taken. New {weldSideSource}, old {First}"); First = weldSideSource; } else if (weldSideSource.SideType == WeldSideType.Left) { Preconditions.Assert(First == null, $"E12 Left of weld is arleady taken. New {weldSideSource}, old {First}"); First = weldSideSource; } else if (weldSideSource.SideType == WeldSideType.Top) { Preconditions.Assert(Second == null, $"E12 Top of weld is arleady taken. New {weldSideSource}, old {Second}"); Second = weldSideSource; } else if (weldSideSource.SideType == WeldSideType.Right) { Preconditions.Assert(Second == null, $"E12 Right of weld is arleady taken. New {weldSideSource}, old {Second}"); Second = weldSideSource; } else { Preconditions.Fail("Not supported sideType " + weldSideSource.SideType); } }
public async Task <TextureWithSize> RetriveHeightDetailElementAsync(string filename) { IntVector2 textureSize = new IntVector2(241, 241); var path = _mainDictionaryPath + filename + _extension; Preconditions.Assert(File.Exists(path), $"Cannot retrive heightDetailElement of path {path} as it does not exist"); { var texture = await _commonExecutor.AddAction(() => { var tex = SavingFileManager.LoadPngTextureFromFile(path, textureSize.X, textureSize.Y, TextureFormat.ARGB32, true, true); tex.wrapMode = TextureWrapMode.Clamp; return(tex); }); var transformator = new TerrainTextureFormatTransformator(_commonExecutor); var plainTexture = await transformator.EncodedHeightTextureToPlainAsync(new TextureWithSize() { Texture = texture, Size = textureSize }); return(new TextureWithSize() { Size = textureSize, Texture = plainTexture }); } }
public void AddVectorArrayToBlock(IUniformArray uniformArray, int elementsToSkipCount, int elementsToTakeCount) { Preconditions.Assert(uniformArray.Count == _arraySize, string.Format("Cant add vector of length {0} to block, as block length is {1}", uniformArray.Count, _arraySize)); uniformArray.AddToBlock(_block, elementsToSkipCount, elementsToTakeCount); }
public List <uint> ClaimForGroup(List <Vector2> positions) { Preconditions.Assert(!IsDirty, "Cannot claim for group, registry is dirty"); Preconditions.Assert(IsEmpty, "Cannot claim for group, registry is not empty"); Preconditions.Assert(positions.Count <= _configuration.ScopeLength, "Group count is bigger than scopeLength, count is " + positions.Count); _localeArray = ConstantSizeClaimableContainer <Vector2?> .CreateFull(_configuration.ScopeLength); for (int i = 0; i < positions.Count; i++) { _localeArray.SetElementWithoutClaimedSpaceChanges(positions[i], i); } var outList = new List <uint>(); for (uint i = 0; i < positions.Count; i++) { _updateOrders.Add(new EPropLocaleBufferScopeUpdateOrder() { Index = i, FlatPosition = positions[(int)i] }); outList.Add(i); } return(outList); }
public void AddSegment(SegmentInformation segmentInfo) { var sap = segmentInfo.SegmentAlignedPosition; Preconditions.Assert(!_tokensDict.ContainsKey(sap), $"There arleady is segment of sap {sap}"); RequiredSegmentSituation requiredSituation; bool fillingIsNecessary; if (segmentInfo.SegmentState == SegmentState.Active) { fillingIsNecessary = true; requiredSituation = RequiredSegmentSituation.Filled; } else if (segmentInfo.SegmentState == SegmentState.Standby) { fillingIsNecessary = false; requiredSituation = RequiredSegmentSituation.Filled; } else { fillingIsNecessary = false; requiredSituation = RequiredSegmentSituation.Created; } var newToken = new SegmentGenerationProcessToken(SegmentGenerationProcessSituation.BeforeStartOfCreation, requiredSituation); _tokensDict[sap] = new SegmentGenerationProcessTokenWithFillingNecessity() { Token = newToken, FillingIsNecessary = fillingIsNecessary }; _executor.ExecuteSegmentAction(newToken, sap); }
public async Task <bool> AddAssetAsync(TQuery query, TAsset asset) { LogUsedMemory(); var activeTreeElement = TryRetriveAssetFromTree(query); Preconditions.Assert(activeTreeElement == null, "There arleady is one detailElement of given description: qa: " + query); var newElement = new ReferenceCountedAsset() { Element = asset, ReferenceCount = 1 }; await ClearNonReferencedElements(); if (await ThereIsPlaceForNewAssetAsync(asset)) { await AddElementToActiveTreeAsync(query, newElement); return(true); } else { return(false); } }
public HeightmapArray SimplyfyHeightmapNoMargins(HeightmapArray heightmap, int newWidth, int newHeight) { Preconditions.Assert(!heightmap.HasMargin, "heightmap Does Have margins"); float[,] newHeightmap = SimplyfyByBlockAverageNoMargins(heightmap.HeightmapAsArray, newWidth, newHeight); return(new HeightmapArray(newHeightmap)); }
public INprRenderingPostProcessingDirector ConfigureEnviroment(HatchGeneratingMode mode, GameObject cameraObject, GameObject hatchedObject) { Preconditions.Assert(PerModeConfigurations.Any(c => c.Mode == mode), "There is no configuration for mode " + mode); var conf = PerModeConfigurations.First(c => c.Mode == mode); hatchedObject.GetComponent <MeshRenderer>().material = conf.ObjectMaterial; if (conf.SourceGameObject != null) { foreach (var sourceComponent in conf.SourceGameObject.GetComponents <MonoBehaviour>()) { var newComponent = hatchedObject.AddComponent(sourceComponent.GetType()); ComponentUtils.CopyClassValues(sourceComponent, newComponent); } } INprRenderingPostProcessingDirector ppDirector = null; if (conf.SourceCameraObject != null) { foreach (var sourceComponent in conf.SourceCameraObject.GetComponents <MonoBehaviour>()) { var newComponent = cameraObject.AddComponent(sourceComponent.GetType()); ComponentUtils.CopyClassValues(sourceComponent, newComponent); if (newComponent is INprRenderingPostProcessingDirector) { ppDirector = (INprRenderingPostProcessingDirector)newComponent; } } } return(ppDirector); }
public HeightmapMargin SetLength(int newWorkingLength) { if (WorkingLength > newWorkingLength) { Preconditions.Assert(WorkingLength % newWorkingLength == 0, "New margin is not multiplication of current margin"); var newPointSize = Length / newWorkingLength; float[] newValues = new float[newWorkingLength + 1]; for (var i = 0; i < newWorkingLength; i++) { newValues[i] = _marginValues.Skip(i * newPointSize).Take(newPointSize).Sum() / newPointSize; //average } newValues[newWorkingLength] = _marginValues[WorkingLength]; return(new HeightmapMargin(newValues)); } else if (WorkingLength < newWorkingLength) { Preconditions.Assert(newWorkingLength % WorkingLength == 0, "New margin is not multiplication of current margin"); var newPointSize = newWorkingLength / WorkingLength; float[] newValues = new float[newWorkingLength + 1]; for (var i = 0; i < WorkingLength; i++) { for (var j = 0; j < newPointSize; j++) { newValues[i * newPointSize + j] = Mathf.Lerp(_marginValues[i], _marginValues[i + 1], (float)j / newPointSize); } } newValues[newWorkingLength] = _marginValues[WorkingLength]; return(new HeightmapMargin(newValues)); } return(new HeightmapMargin(_marginValues)); }
private void AssertPositionsAreCorrect(Point2D endPos, Point2D startPos) { Preconditions.Assert(!Equals(startPos, endPos), string.Format("Start pos {0} and end pos {1} of margin can't be the same", startPos, endPos)); Preconditions.Assert(startPos.X == endPos.X || startPos.Y == endPos.Y, string.Format("Start pos {0} and end pos {1} are not horizontal nor vertical", startPos, endPos)); }
public float GetValue(IntVector2 point) { Preconditions.Assert(point.Y >= _yStart && point.Y < _yStart + _subArrayHeight, "Y not in area"); float value = 0; value = _array[point.X, point.Y - _yStart]; return(value); }
public void Set(Vector2 point) { var pos = FindCellPosition(point); Preconditions.Assert(!_array[pos.X, pos.Y].HasValue, $"Grid cell of index {pos.X} {pos.Y} arleady has value!"); _array[pos.X, pos.Y] = point; }
public HeightmapArray SimplyfyHeightmap(HeightmapArray heightmap, int newWorkingWidth, int newWorkingHeight) { Preconditions.Assert(heightmap.HasMargin, "heightmap Does Not Have margins"); float[,] newHeightmap = SimplyfyByBlockAverageIgnoreMergeMargins(heightmap.HeightmapAsArray, newWorkingWidth, newWorkingHeight); return(new HeightmapArray(newHeightmap)); }
public Dictionary <LocaleBufferScopeIndexType, EPropLocaleBufferScopeRegistry> TakeAwayScopes() { Preconditions.Assert(!IsDirty, "One of the scopes is still dirty"); var toReturn = _scopes; _scopes = new Dictionary <LocaleBufferScopeIndexType, EPropLocaleBufferScopeRegistry>(); return(toReturn); }
private void FreeScopes(List <LocaleBufferScopeIndexType> scopesToFree) { foreach (var id in scopesToFree) { Preconditions.Assert(!_scopes[id].IsDirty, $"Scope of id {id} we are trying to free is still dirty"); _scopes[id] = null; } }
private async Task FillSegment(SegmentGenerationProcessToken token, IntVector2 sap) { Preconditions.Assert(token.CurrentSituation == SegmentGenerationProcessSituation.Created, "Unexpected situaton " + token.CurrentSituation); token.CurrentSituation = SegmentGenerationProcessSituation.DuringFilling; await _segmentFillingFunc(sap, _currentlyCreatedSegments[sap]); token.CurrentSituation = SegmentGenerationProcessSituation.Filled; }
public void CreatedNewNode(Ring1Node ring1Node) { Preconditions.Assert(!_ring1NodePositionsToId.ContainsKey(ring1Node.Ring1Position), "Terrain was not created for this node"); var newId = _lastId++; _ring1NodePositionsToId[ring1Node.Ring1Position] = newId; _currentOrder.NewListenersGenerator[newId] = () => _newListenersCreator.CreateNewListener(ring1Node); }
public MeshCurvatureDetailSE Generate(UnaliasedMesh mesh, int radius = 5, bool useKring = true) { //var originalVertices = mesh.vertices; //var originalTriangles = mesh.triangles; //var verticlesToOriginalVerticles = new Dictionary<Vector3, List<int>>(); //for (int i = 0; i < originalVertices.Length; i++) //{ // var vert = originalVertices[i]; // if (!verticlesToOriginalVerticles.ContainsKey(vert)) // { // verticlesToOriginalVerticles[vert] = new List<int>(); // } // verticlesToOriginalVerticles[vert].Add(i); //} //var vertices = verticlesToOriginalVerticles.Keys.ToArray(); //var originalIndexToIndexDict = new int[originalVertices.Length]; //for (int i = 0; i < vertices.Length; i++) //{ // var v = vertices[i]; // foreach (var originalIndex in verticlesToOriginalVerticles[v]) // { // originalIndexToIndexDict[originalIndex] = i; // } //} //var triangles = originalTriangles // .Select(c => originalIndexToIndexDict[c]) // .ToArray(); var verticesFlatArray = mesh.Vertices.SelectMany(c => c.ToArray()).ToArray(); var verticesCount = mesh.Vertices.Length; var trianglesCount = mesh.Triangles.Length / 3; var outDirection1 = new float[3 * verticesCount]; var outDirection2 = new float[3 * verticesCount]; var outValues1 = new float[verticesCount]; var outValues2 = new float[verticesCount]; PrincipalCurvatureDll.EnableLogging(); int callStatus = PrincipalCurvatureDll.compute_principal_curvature(verticesFlatArray, verticesCount, mesh.Triangles, trianglesCount, outDirection1, outDirection2, outValues1, outValues2, radius, useKring); Preconditions.Assert(callStatus == 0, "Calling compute_principal_curvature failed, as returned status " + callStatus); var od1 = FlatArrayToVectorArray(outDirection1); var od2 = FlatArrayToVectorArray(outDirection2); return(MeshCurvatureDetailSE.CreateDetail( mesh.OriginalIndexToIndex.Select(c => od1[c]).ToArray(), mesh.OriginalIndexToIndex.Select(c => od2[c]).ToArray(), mesh.OriginalIndexToIndex.Select(c => outValues1[c]).ToArray(), mesh.OriginalIndexToIndex.Select(c => outValues2[c]).ToArray() )); }
private static Vector3[] FlatArrayToVectorArray(float[] flatArray) { Preconditions.Assert(flatArray.Length % 3 == 0, "Input array length must be divible by 3, but is " + flatArray.Length); return(flatArray .Select((c, i) => new { v = c, index = i }) .GroupBy(c => c.index / 3) .Select(c => c.ToArray()) .Select(c => new Vector3(c[0].v, c[1].v, c[2].v)) .ToArray()); }
public GrassPack(Matrix4x4[] maticesArray, MyMaterialPropertyBlock propertiesBlock) { Preconditions.Assert(maticesArray.Length <= Constants.MaxInstancesPerPack, String.Format("In grass pack there can be at max {0} elements, but is {1}", Constants.MaxInstancesPerPack, maticesArray.Length)); CastShadows = ShadowCastingMode.Off; MaticesArray = maticesArray; InstancesCount = maticesArray.Length; MyBlock = propertiesBlock; }