void RegisterMeshNode(IntVector4 node) { if (!mMeshNodes.Contains(node)) { mMeshNodes.Add(node); } }
public static void WriteVector4(System.IO.BinaryWriter w, IntVector4 v) { w.Write(v.x); w.Write(v.y); w.Write(v.z); w.Write(v.w); }
public ILayerMasked Do(Vector2 size) { //int maxDim = (int)JryMath.Max(size.X, size.Y); //CONSTANT - There is a problem with values that are not 2^n wher n is element of N var maxDim = 256; int gradSize = 8; IInterpolation interpolation = new LinearClipped(); Layer2DObject map = new Layer2DObject(size); int hgrid = (int)size.X; int vgrid = (int)size.Y; float gain = _noiseParameters.Amplitude; float lacunarity = _noiseParameters.Lacunarity; var gradients = setupGradient(gradSize); //set up the random numbers table int[] permutations = getPermutaions(maxDim); int maxDimMinOne = maxDim - 1; int gradSizeMinOne = gradSize - 1; for (int i = 0; i < vgrid; i++) { for (int j = 0; j < hgrid; j++) { float pixel_value = 0.0f; float amplitude = 1.0f; float frequency = 1.0f / maxDim; for (int k = _noiseParameters.FromDepth; k < _noiseParameters.ToDepth; k++) { int x = JryMath.Floor(j * frequency); int y = JryMath.Floor(i * frequency); float fracX = j * frequency - x; float fracY = i * frequency - y; // following two lines solved the bug. x += k; y += k; IntVector4 v = getIndices(permutations, maxDimMinOne, gradSizeMinOne, x, y); Vector2[] grads = getGrads(gradients, v); float interpolatedxy = biInterpolate(interpolation, grads, fracX, fracY); pixel_value += interpolatedxy * amplitude; amplitude *= gain; frequency *= lacunarity; } //put it in the map map[j, i] = pixel_value; } } return(map); }
// this function should only be used by the root node. public Block45OctNode RerootToContainPos(IntVector4 pos) { if (!Covers(pos)) { // make a new node that can cover atpos and pos is ALIGNED with LOD Node width // B45Node width should be equal to or smaller than LODNode width int maskX, maskY, maskZ; if (_pos.w < Block45Constants.MAX_LOD) { int posMask = (1 << (Block45Constants._scaledShift + _pos.w + 1)) - 1; maskX = ((_pos.x & posMask) != 0 && pos.x < _pos.x) ? 1 : 0; maskY = ((_pos.y & posMask) != 0 && pos.y < _pos.y) ? 1 : 0; maskZ = ((_pos.z & posMask) != 0 && pos.z < _pos.z) ? 1 : 0; } else { maskX = (pos.x < _pos.x) ? 1 : 0; maskY = (pos.y < _pos.y) ? 1 : 0; maskZ = (pos.z < _pos.z) ? 1 : 0; } int thisOctant = maskX + (maskY << 1) + (maskZ << 2); // righttop to leftbottom IntVector4 newRootPos = new IntVector4(_pos.x - maskX * ScaledSize, _pos.y - maskY * ScaledSize, _pos.z - maskZ * ScaledSize, _pos.w + 1); Block45OctNode newRoot = Block45OctNode.CreateNode(newRootPos, OnCreateNode); this._parent = newRoot; newRoot.Split(thisOctant, this); return(newRoot.RerootToContainPos(pos)); } return(this); }
public void AddRequest(VFVoxelChunkData chunkData) { IntVector4 chunkPos = chunkData.ChunkPosLod; // Req to chunks out of range will return, these chunks will be null and can not be write according to WriteVoxelAtIdx's code if (chunkPos.x < 0 || chunkPos.x >= VoxelTerrainConstants._worldMaxCX || chunkPos.y < 0 || chunkPos.y >= VoxelTerrainConstants.WorldMaxCY(chunkPos.w) || chunkPos.z < 0 || chunkPos.z >= VoxelTerrainConstants._worldMaxCZ) { chunkData.OnDataLoaded(VFVoxelChunkData.S_ChunkDataAir); return; } if (_bImmMode) // no caching { int px, py, pz; VFFileUtil.WorldChunkPosToPiecePos(chunkPos, out px, out py, out pz); ReadPieceDataToBuff(px, py, pz, chunkPos.w); _buff.Decompress(px, py, pz, chunkPos.w); _buff.SetChunkData(chunkData, _chunkDataProc); } else { ReqValue reqValue; if (!_chunkReqList.TryGetValue(chunkData, out reqValue) || !chunkData.IsStampIdentical(reqValue.stamp)) { VFFileUtil.WorldChunkPosToPiecePos(chunkPos, out reqValue.px, out reqValue.py, out reqValue.pz); reqValue.pw = chunkPos.w; reqValue.stamp = chunkData.StampOfUpdating; _chunkReqList[chunkData] = reqValue; } } }
public VFVoxelChunkData readChunk(int cx, int cy, int cz, int lod = 0) { int chunkNumX = LODOctreeMan._xChunkCount >> lod; int chunkNumY = LODOctreeMan._yChunkCount >> lod; int chunkNumZ = LODOctreeMan._zChunkCount >> lod; int cxround = (cx >> lod) % chunkNumX; int cyround = (cy >> lod) % chunkNumY; int czround = (cz >> lod) % chunkNumZ; if (cxround < 0) { cxround += chunkNumX; } if (cyround < 0) { cyround += chunkNumY; } if (czround < 0) { czround += chunkNumZ; } VFVoxelChunkData chunkData = (VFVoxelChunkData)_lodNodes[lod][cxround, cyround, czround]._data[_idxData]; IntVector4 poslod = chunkData.ChunkPosLod; if (poslod.x != cx || poslod.y != cy || poslod.z != cz || poslod.w != lod) { return(null); } return(chunkData); }
public bool IsPosValid(IntVector4 pos) { if (pos.w != 0) { return(false); } // lod 0 LODOctreeNode node = GetNodeWithCPos(pos.x >> VoxelTerrainConstants._shift, pos.y >> VoxelTerrainConstants._shift, pos.z >> VoxelTerrainConstants._shift, pos.w); if (node == null) { return(false); } int n = node._data.Length; for (int i = 0; i < n; i++) { //TODO : code //if(!node._data[i]..IsReady) return false; } return(true); }
void OnTerrainColliderCreated(IntVector4 node) { if (Match(node)) { OnTerrainEnter(node); } }
void OnTerrainColliderDestroy(IntVector4 node) { if (Match(node)) { OnTerrainExit(node); } }
void OnTerrainPositionDetory(IntVector4 node) { if (node.w == LODOctreeMan._maxLod) { RemoveSPTerrainRect(node); } }
void OnTerrainMeshCreated(IntVector4 node) { if (CSMain.s_MgCreator.Assembly == null) { return; } if (!VFVoxelTerrain.TerrainColliderComplete) { return; } if (node.w == 0 && automaticData != null) { float dx = CSMain.s_MgCreator.Assembly.Position.x - node.x; float dy = CSMain.s_MgCreator.Assembly.Position.y - node.y; float dz = CSMain.s_MgCreator.Assembly.Position.z - node.z; float side = VoxelTerrainConstants._numVoxelsPerAxis << node.w; if (dx >= PETools.PEMath.Epsilon && dx <= side && dy >= PETools.PEMath.Epsilon && dy <= side && dz >= PETools.PEMath.Epsilon && dz <= side) { //To do : destroy block foreach (KeyValuePair <int, CSCommon> kp in CSMain.s_MgCreator.GetCommonEntities()) { if (Random.value < 0.5f) { DigTerrainManager.DestroyTerrainInRange(1, kp.Value.Position, 255.0f, 10.0f); } } } } }
void OnTerrainMeshDestroy(IntVector4 node) { if (node.w == 0) { RemoveMeshNode(node); } }
void OnTerrainMeshCreated(IntVector4 node) { if (node.w == 0) { IntVector2 mark = AiUtil.ConvertToIntVector2FormLodLevel(node, VoxelTerrainMaxLod); if (pointTable.ContainsKey(mark)) { SPTerrainRect tRect = pointTable[mark]; if (tRect != null) { List <SPPoint> points = tRect.points; points = points.FindAll(ret => Match(ret, node.x, node.z)); foreach (SPPoint point in points) { point.AttachEvent(node); //point.position = new Vector3(point.position.x, node.y, point.position.z); } } } RegisterMeshNode(node); LODOctreeMan.self.AttachNodeEvents(null, null, null, null, OnTerrainColliderCreated, node.ToVector3(), 0); } }
void RemoveMeshNode(IntVector4 node) { if (mMeshNodes.Contains(node)) { mMeshNodes.Remove(node); } }
void SetupEnvironmentAudio(IntVector4 node) { if (Random.value < audioRate) { SetupAudioController(node); } }
void OnColliderCreate(IntVector4 node) { if (m_Obj != null) { m_Obj.SetActive(true); } }
void SetupAudioController(IntVector4 node) { Vector3 position = node.ToVector3(); position += new Vector3(Random.Range(0.0f, VoxelTerrainConstants._numVoxelsPerAxis << node.w), 0.0f, Random.Range(0.0f, VoxelTerrainConstants._numVoxelsPerAxis << node.w)); int height = VoxelTerrainConstants._numVoxelsPerAxis << node.w; RaycastHit hitInfo; if (Physics.Raycast(position + Vector3.up * height, Vector3.down, out hitInfo, height, GameConfig.GroundLayer)) { float waterHeight; if (PETools.PEUtil.GetWaterSurfaceHeight(hitInfo.point, out waterHeight)) { position = hitInfo.point + Vector3.up * Random.Range(0.0f, waterHeight - hitInfo.point.y); } else { position = hitInfo.point + Vector3.up * Random.Range(0.5f, 5.0f); } int sid = AISpawnDataStory.GetEnvMusicID(GetMapID(position)); Transform parent = mAudioPoint != null ? mAudioPoint.transform : null; AudioController ctrl = AudioManager.instance.Create(position, sid, parent, false, false); envSounds.Add(ctrl); } }
void OnColliderDestroy(IntVector4 node) { if (m_Obj != null) { m_Obj.SetActive(false); } }
public GridLayout(string CellsArrangement, string Spaceoffsets, int spaceX, int spaceY) { Space = new IntVector2(spaceX, spaceY); CellsArrangement = Arrangement; Offsets = Get4(Spaceoffsets); RegenerateLayout(); }
void OnMeshDestroy(IntVector4 node) { if (m_Obj != null) { GameObject.Destroy(m_Obj); } }
// Read & Write voxel public byte this[IntVector3 idx, IntVector4 cposlod] { get { return(m_Chunks[cposlod.x, cposlod.y, cposlod.z].ReadVoxelAtIdx(idx.x, idx.y, idx.z).Volume); } }
public void GetOfs(IntVector4 piecePos, out int pieceDataOfs, out int pieceDataLen) { #if USE_ZIPPED_DATA // TODO: optimization int ofsx = (piecePos.x % VoxelTerrainConstants._mapPieceCountXorZ) >> _lod; int ofsz = (piecePos.z % VoxelTerrainConstants._mapPieceCountXorZ) >> _lod; int ofsy = (piecePos.y) >> _lod; // X,Z,then Y ----> correspongding to data making int idx = (ofsx * (FSetDataCountXZ >> _lod) + ofsz) * (FSetDataCountY >> _lod) + ofsy; idx *= 4; pieceDataOfs = ofsData[idx] + (ofsData[idx + 1] << 8) + (ofsData[idx + 2] << 16) + (ofsData[idx + 3] << 24); int fSetOfsDataLenLod = (VFFileDataClone.FSetDataCountXZ >> _lod) * (VFFileDataClone.FSetDataCountXZ >> _lod) * (VFFileDataClone.FSetDataCountY >> _lod) * 4; if (idx >= fSetOfsDataLenLod - 4) { pieceDataLen = len - pieceDataOfs; } else { pieceDataLen = ofsData[idx + 4] + (ofsData[idx + 5] << 8) + (ofsData[idx + 6] << 16) + (ofsData[idx + 7] << 24) - pieceDataOfs; } #else pieceDataOfs = 0; pieceDataLen = len; #endif }
public static Block45OctNode GetNodeRW(IntVector4 poslod, ref Block45OctNode root) // Write new if null { // Note: if req's w > root.w, root would be returned root = root.RerootToContainPos(poslod); int ind = 0; int nodeCenterX = 0; int nodeCenterY = 0; int nodeCenterZ = 0; Block45OctNode cur = root; while (cur._pos.w > poslod.w) { if (cur.IsLeaf) { cur.Split(); } int centerOfs = Block45Constants.CenterOfs(cur._pos.w); nodeCenterX = cur._pos.x + centerOfs; nodeCenterY = cur._pos.y + centerOfs; nodeCenterZ = cur._pos.z + centerOfs; ind = ((poslod.x >= nodeCenterX) ? 1 : 0) | ((poslod.y >= nodeCenterY) ? 2 : 0) | ((poslod.z >= nodeCenterZ) ? 4 : 0); cur = cur._children[ind]; } return(cur); }
public static void AddReadRequest(VFVoxelChunkData chunkData) { IntVector4 chunkPos = chunkData.ChunkPosLod; // Req to chunks out of range will return, these chunks will be null and can not be write according to WriteVoxelAtIdx's code if (chunkPos.x < 0 || chunkPos.x >= VoxelTerrainConstants._worldMaxCX) { return; } if (chunkPos.y < 0 || chunkPos.y >= VoxelTerrainConstants.WorldMaxCY(chunkPos.w)) { return; } if (chunkPos.z < 0 || chunkPos.z >= VoxelTerrainConstants._worldMaxCZ) { return; } // no caching IntVector4 piecePos; VFFileDataClone.WorldChunkPosToPiecePos(chunkPos, out piecePos); IntVector4 fileIndex; VFFileDataClone.PiecePos2FileIndex(piecePos, out fileIndex); VFPieceDataClone pieceData = GetPieceDataSub(piecePos, GetFileSetSub(fileIndex)); pieceData.Decompress(); pieceData.SetChunkData(chunkData); pieceData._data = null; pieceData = null; }
public void ReplaceChunkDatas(List <IntVector4> newChunkPosList, ProcToMergeChunkAtPos mergeChunkDataAtPos) { Dictionary <IntVector4, Dictionary <IntVector4, List <IntVector4> > > file2piece2chunkList = new Dictionary <IntVector4, Dictionary <IntVector4, List <IntVector4> > >(); int n = newChunkPosList.Count; int px, py, pz; int fx, fz; for (int i = 0; i < n; i++) { IntVector4 chunkPos = newChunkPosList[i]; VFFileUtil.WorldChunkPosToPiecePos(chunkPos, out px, out py, out pz); VFFileUtil.PiecePos2FilePos(px, py, pz, chunkPos.w, out fx, out fz); IntVector4 filePos = new IntVector4(fx, 0, fz, chunkPos.w); IntVector4 piecePos = new IntVector4(px, py, pz, chunkPos.w); if (!file2piece2chunkList.ContainsKey(filePos)) { file2piece2chunkList.Add(filePos, new Dictionary <IntVector4, List <IntVector4> >()); } if (!file2piece2chunkList[filePos].ContainsKey(piecePos)) { file2piece2chunkList[filePos].Add(piecePos, new List <IntVector4>()); } file2piece2chunkList[filePos][piecePos].Add(chunkPos); } List <IntVector4> fileIndexList = file2piece2chunkList.Keys.Cast <IntVector4>().ToList(); int nFileIndexList = fileIndexList.Count; for (int i = 0; i < nFileIndexList; i++) { IntVector4 fileIndex = fileIndexList[i]; ReplacePiecesInFile(file2piece2chunkList[fileIndex], mergeChunkDataAtPos, fileIndex); } }
void OnTerrainColliderDestroy(IntVector4 node) { if (node.w == 0) { IntVector2 mark = new IntVector2(node.x, node.z); if (exists.Contains(mark)) { List <AudioController> acList = envSounds.FindAll(ret => Match(ret, node)); foreach (AudioController acCtrl in acList) { envSounds.Remove(acCtrl); acCtrl.Delete(); } List <GameObject> envEffList = envEffects.FindAll(ret => MatchEffect(ret, node)); foreach (GameObject ite in envEffList) { envEffects.Remove(ite); GameObject.Destroy(ite); } exists.Remove(mark); } } }
private static int GetComponent(IntVector4 v, char component) { switch (component) { case '0': return(0); case '1': return(1); case 'x': case 'r': return(v.x); case 'y': case 'g': return(v.y); case 'z': case 'b': return(v.z); case 'w': case 'a': return(v.w); } throw new InvalidOperationException("Invalid component: " + component); }
void SetupEnvironmentEffect(IntVector4 node) { if (Random.value < effectRate) { SetupEffect(node); } }
public override void Init(IntVector4 idx, Transform parent = null, int spid = 0, int pathid = 0, bool isActive = true, bool revisePos = true, bool isBoss = false, bool isErode = true, bool isDelete = true, SimplexNoise noise = null, AssetReq.ReqFinishDelegate onSpawned = null, CommonInterface common = null) { base.Init(idx, parent, spid, pathid, isActive, revisePos, isBoss, isErode, isDelete, noise, onSpawned, common); if (pathid > 0) { AiAsset.AiDataBlock aiData = AiAsset.AiDataBlock.GetAIDataBase(pathid); if (aiData != null) { //mDamage = aiData.damageSimulate; mMaxHp = aiData.maxHpSimulate; mHp = mMaxHp; } } if (spid > 0) { AISpawnPath path = AISpawnPath.GetSpawnPath(spid); { if (path != null) { //mDamage = path.damage; mMaxHp = path.maxHp; mHp = mMaxHp; } } } }
public virtual void Init(IntVector4 idx, Transform parent = null, int spid = 0, int pathid = 0, bool isActive = true, bool revisePos = true, bool isBoss = false, bool isErode = true, bool isDelete = true, SimplexNoise noise = null, AssetReq.ReqFinishDelegate onSpawned = null, CommonInterface common = null) { mIndex = idx; mType = PointType.PT_NULL; mSpID = spid; mPathID = pathid; mActive = isActive; mIsBoss = isBoss; mErode = isErode; mDelete = isDelete; mNoise = noise; mNodes = new List <IntVector4>(); mRevisePosition = revisePos; mWaitForSpawned = false; mReqFinish = onSpawned; //mCommon = common; AttachEventFromMesh(); AttachCollider(); RegisterPoint(this); }