void HandleLodChunks()
{
if (terrainChunks != null)
{
ReleaseIndirectArgsBuffers();
}
if (renderType == GrassRenderType.Mesh)
{
terrainChunks = MeshChunker.Chunk(grassMesh, chunksX, chunksY, chunksZ, grassPerTri, drawMat.GetFloat("bladeHeight"));
}
else
{
terrainChunks = MeshChunker.ChunkTerrain(terrainObject, chunksX, chunksZ, grassPerTri, terrainExpansion, drawMat.GetFloat("bladeHeight"));
if (!terrainNormalMap)
{
terrainNormalMap = TextureCreator.GetTerrainNormalMap(terrainObject, gfComputeShader, normalKernel, highQualityHeightmap);
terrainMapOffset = 1f / terrainNormalMap.width * 0.5f;
}
if (discardEmptyChunks)
{
DiscardUnusedChunks();
}
}
CheckIndirectInstancingArgs();
}
internal GraphicFactory(GraphicInfo ginfo, GraphicsDevice device, IContentManager contentManager)
{
this.device = device;
this.ginfo = ginfo;
this.contentManager = contentManager;
SpriteBatch = new SpriteBatch(device);
RenderTargetPool = new RenderTargetPool(device);
texCreator = new TextureCreator(ginfo, this);
}
void OnMapDataRecived(MapData mapData)
{
this.mapData = mapData;
mapDataRecived = true;
Texture2D texture = TextureCreator.TextureFromColorMap(mapData.colorMap, MapGenerator.mapChunkSize, MapGenerator.mapChunkSize);
meshRenderer.material.mainTexture = texture;
UpdateTerrainChunk();
}
private void CreateTexture()
{
if (!IsDirty)
{
return;
}
sprite = TextureCreator.GetGradientTexture(rectTransform.rect, new LinearGradient(_gradient, Vector2.zero, Vector2.one));
}
public void GenerateTexture()
{
Random.InitState(FirstName.GetHashCode() + LastName.GetHashCode());
if (m_textureCreator == null)
{
m_textureCreator = gameObject.AddComponent <TextureCreator>();
}
m_textureCreator.resolution = Mathf.RoundToInt(Map(400, 1000, 1, 10, Shy_Outgoing));
m_textureCreator.frequency = Map(1, 25, 1, 10, Serious_Playful);
m_textureCreator.octaves = Mathf.RoundToInt(Map(1, 6, 1, 10, Grouchy_Nice));
m_textureCreator.lacunarity = Map(1, 4, 1, 10, Lazy_Active);
m_textureCreator.persistence = Map(0, 1, 1, 10, Sloppy_Neat);
if (Serious_Playful <= 3)
{
m_textureCreator.dimensions = 1;
}
else if (Serious_Playful <= 7)
{
m_textureCreator.dimensions = 2;
}
else
{
m_textureCreator.dimensions = 3;
}
if (Lazy_Active < 5)
{
m_textureCreator.type = NoiseMethodType.Value;
}
else
{
m_textureCreator.type = NoiseMethodType.Perlin;
}
// Color
GradientColorKey[] gradientColorKeys = new GradientColorKey[Random.Range(3, 6)];
GradientAlphaKey[] gradientAlphaKeys = new GradientAlphaKey[2];
gradientAlphaKeys[0] = new GradientAlphaKey();
gradientAlphaKeys[1] = new GradientAlphaKey();
gradientAlphaKeys[0].time = 0;
gradientAlphaKeys[0].alpha = 255;
gradientAlphaKeys[1].time = 1;
gradientAlphaKeys[1].alpha = 255;
for (int i = 0; i < gradientColorKeys.Length; i++)
{
GradientColorKey gck = new GradientColorKey();
gck.color = Random.ColorHSV();
gck.time = Random.Range(0f, 1f);
gradientColorKeys[i] = gck;
}
m_textureCreator.coloring.SetKeys(gradientColorKeys, gradientAlphaKeys);
m_textureCreator.FillTexture();
}
protected override void Initialize()
{
path = new List <Point>(84);
steps = 0;
cheatMode = false;
whiteSquare = TextureCreator.CreateTexture(GraphicsDevice, pointSize, pointSize, t => Color.White);
InitializeEntities();
base.Initialize();
}
void OnEnable()
{
Texture2D windTex = TextureCreator.PerlinCurl(256, 0);
Shader.SetGlobalTexture("_WindTex", windTex);
windSampler = new WindSampler();
windSampler._WindTex = windTex;
Texture2D noiseTex = TextureCreator.PerlinCloudsTiling(256, 0);
Shader.SetGlobalTexture("_NoiseTex", noiseTex);
}
private void Start()
{
halton = MathUtil.GenerateHalton23(MAX_CLUSTERS * MAX_GRID_CELLS);
meshRenderer = GetComponent <MeshRenderer>();
materialProps = new MaterialPropertyBlock();
GetDefaultMaterialProps();
if (grassGrowthMask == null && generateGrassGrowthMask)
{
grassGrowthMask = TextureCreator.Perlin(256, 1337.0f, 37.0f, 1);
}
}
//this method will be called by the map generator script when the map Data has been generated.
void OnMapDataRecieved(MapData mapData)
{
//do something with the Mapdata
//now call the request mesh data to obtain the meshdata to create the mesh.
// mapGenScript.RequestMeshData(mapData, OnMeshDataRecieved);
this.mapData = mapData;
MapDataRecieved = true;
Texture2D texture = TextureCreator.TextureFromColorMap(mapData.colorMap, MapGenerator.mapChunkSize, MapGenerator.mapChunkSize);
terrainRenderer.material.mainTexture = texture;
updateTerrainChunk();
}
public void DrawMapInEditor()
{
MapData mapdata = GenerateMapData(Vector2.zero);
MapDisplay display = FindObjectOfType <MapDisplay>();
if (drawMode == DrawMode.noiseMap)
{
display.DrawTexture(TextureCreator.TextureFromHeightMap(mapdata.heightMap));
}
else if (drawMode == DrawMode.colorMap)
{
display.DrawTexture(TextureCreator.TextureFromColorMap(mapdata.colorMap, mapChunkSize, mapChunkSize));
}
else if (drawMode == DrawMode.Mesh)
{
display.DrawMesh(MeshGenerator.CreateTerrainMesh(mapdata.heightMap, meshHeightMultipler, meshHeightCurve, previewLOD), TextureCreator.TextureFromColorMap(mapdata.colorMap, mapChunkSize, mapChunkSize));
}
}
public void mapDisplayCaller()
{
MapData mapData = GenerateMapData(Vector2.zero);
// creating an object of type mapDisplay
MapDisplay display = FindObjectOfType <MapDisplay>();
if (drawMode == DrawMode.drawNoiseMap)
{
display.DrawTexture(TextureCreator.TextureFromHeightMap(mapData.heightMap));
}
else if (drawMode == DrawMode.drawColorMap)
{
display.DrawTexture(TextureCreator.TextureFromColorMap(mapData.colorMap, mapChunkSize, mapChunkSize));
}
else if (drawMode == DrawMode.drawMesh)
{
display.DrawMesh(MeshGenerator.GenerateTerrainMesh(mapData.heightMap, MeshHeightMultiplier, heightCurve, EditorPreviewLOD), TextureCreator.TextureFromColorMap(mapData.colorMap, mapChunkSize, mapChunkSize));
}
}
private void PropagateChanges(TextureManager tm)
{
if (Application.isPlaying)
{
for (int i = 0; i < tm.transform.GetChildCount(); i++)
{
Transform folder = tm.transform.GetChild(i);
for (int j = 0; j < folder.GetChildCount(); ++j)
{
TextureCreator go = (TextureCreator)folder.GetChild(j).gameObject.GetComponent <TextureCreator>();
go.resolution = tm.resolution;
go.frequency = tm.frequency;
go.lacunarity = tm.lacunarity;
go.persistence = tm.persistence;
go.dimensions = tm.dimensions;
go.type = tm.type;
go.coloring = tm.coloring;
go.repeatable_tiles = tm.repeatable_tiles;
go.FillTexture();
}
}
}
}
private void OnEnable()
{
tc = (TextureCreator)target;
Undo.undoRedoPerformed += RefreshCreator;
}
private void OnEnable()
{
creator = target as TextureCreator; //Get a instance of the TextureCreator.
Undo.undoRedoPerformed += RefreshCreator; //Assign the TextureCreator to the Undo.undoRedoPerformed delegate.
}
public void GenerateGrid()
{
grid = new Tile[xSize, ySize];
TextureCreator map = TextureCreator.GetMap;
if (int.Parse(seed) == 0)
{
int xVal = Random.Range(1, 3) * 1000;
int yVal = Random.Range(1, 3) * 1000;
xVal += Random.Range(0, 1000);
yVal += Random.Range(0, 1000);
seed = xVal.ToString() + yVal.ToString();
}
seed.Substring(1, 3);
float xPos = float.Parse(seed.Substring(1, 3)) / 10;
float yPos = float.Parse(seed.Substring(5, 3)) / 10;
if (seed[0] == '2')
{
xPos *= -1;
}
if (seed[4] == '2')
{
yPos *= -1;
}
map.transform.position = new Vector3(xPos, yPos, -1f);
for (int x = 0; x < xSize; x++)
{
for (int y = 0; y < ySize; y++)
{
Color color = map.GetTexture(new Vector2(x, y));
//sand
if (color.Equals(Color.white))
{
emptyTile = GetTileOfType(TileType.Sand);
}
//deep water
else if (color.Equals(Color.blue))
{
emptyTile = GetTileOfType(TileType.DeepWater);
}
//grass
else if (color.Equals(Color.green))
{
emptyTile = GetTileOfType(TileType.Grass);
//spawn tree
int rand = Random.Range(0, 100);
if (rand < treeChance)
{
bool skip = false;
if (x > 0 && y > 0)
{
if (grid[x - 1, y - 1].GetComponent <Foliage>())
{
skip = true;
}
}
if (x > 0)
{
if (grid[x - 1, y].GetComponent <Foliage>())
{
skip = true;
}
}
if (x > 0 && y < ySize - 1)
{
if (grid[x - 1, y + 1].GetComponent <Foliage>())
{
skip = true;
}
}
if (y > 0)
{
if (grid[x, y - 1].GetComponent <Foliage>())
{
skip = true;
}
}
if (!skip)
{
emptyTile = GetTileOfType(TileType.Tree);
emptyTile.tileUnderneath = TileType.Grass;
emptyTile.GetComponent <Foliage>().age = 1;
}
}
}
//stone walls - can be used for caves
else if (color.Equals(Color.black))
{
emptyTile = GetTileOfType(TileType.Stone, Category.Walls);
}
//water
else if (color.Equals(Color.cyan))
{
emptyTile = GetTileOfType(TileType.Water);
}
Tile t = Instantiate(emptyTile, new Vector3(x, y, 0), emptyTile.transform.rotation);
t.built = true;
t.name = t.name + " " + x + ":" + y;
t.transform.SetParent(transform);
t.x = x;
t.y = y;
grid[x, y] = t;
PathNode node = grid[x, y].GetComponent <PathNode>();
node.x = x;
node.y = y;
node.walkable = true;
}
}
}
private void OnEnable()
{
creator = target as TextureCreator;
Undo.undoRedoPerformed += RefreshCreator;
}
void OnEnable()
{
m_creator = (TextureCreator)target;
Undo.undoRedoPerformed += Refresh;
}
private void OnEnable()
{
creator = target as TextureCreator;
Undo.undoRedoPerformed += RefreshCreator;
}
/// <summary>
/// Load content in thread safe mode (Context usage being not tread safe)
/// </summary>
/// <param name="context"></param>
protected void LoadContentComponent(DeviceContext context)
{
_transparentBackGroundTexture = ToDispose(new SpriteTexture(1, 1, ToDispose(TextureCreator.GenerateColoredTexture(_engine.Device, context, new ByteColor(100, 100, 100, 200), true)), new Vector2(0, 0)));
if (_backPanel != null)
{
_backPanel.Dispose();
RemoveToDispose(_backPanel);
}
_backPanel = ToDispose(new ImageControl()
{
Image = _transparentBackGroundTexture, Name = "BackPanel"
});
_form.Children.Add(_backPanel);
UpdateLayout(_engine.ViewPort, _engine.BackBufferTex.Description);
btGraphicPressed();
}
