void Start()
{
// Use Simplex Terrain and our basic Marching Cubes algorithm
terrGen = new SimplexTerrainGenerator ();
// Generate the lookup table for the 256 first pass smoothed surface net possibilities
SurfaceNetLookupTable.GenerateSmoothedPointLocations(Smoothing);
// Set the MeshGenerator of your choice
//meshGen = new RegularCubeMeshGenerator ();
//meshGen = new MarchingCubesMeshGenerator();
meshGen = new SurfaceNetsMeshGenerator();
world = new WorldData (terrGen, meshGen, ChunkXSize, ChunkYSize);
// Add chunks to the list of nearby chunks for instantiation during runtime
// Reduces black screen load time
nearbyChunks = new List<Chunk> ();
for (int i=0; i<world.chunks.GetLength(0); i++) {
for (int j=0; j<i+1 && j<world.chunks.GetLength(1); j++) {
nearbyChunks.Add (world.chunks [i, j]);
}
for (int k=0; k<i; k++)
{
nearbyChunks.Add (world.chunks[k,i]);
}
}
}
public MapViewGenerator(IMeshGenerator meshGenerator, IOutlineDrawer outlineDrawer,
MonoBehaviourProvider monoBehaviourProvider)
{
_meshGenerator = meshGenerator;
_outlineDrawer = outlineDrawer;
_monoBehaviourProvider = monoBehaviourProvider;
}
void Start()
{
// Use Simplex Terrain and our basic Marching Cubes algorithm
terrGen = new SimplexTerrainGenerator();
meshGen = new MarchingCubesMeshGenerator();
world = new WorldData(terrGen, meshGen);
// Grab the meshfilter from our current object
// Replace the mesh data with calculated mesh data from WorldData
var meshfilter = GetComponent<MeshFilter>();
Mesh mesh = new Mesh();
Chunk testChunk = world.chunks[0,0];
mesh.vertices = testChunk.vertices;
mesh.uv = testChunk.uvRays;
mesh.triangles = testChunk.triangles;
meshfilter.mesh = mesh;
//meshfilter.mesh.vertices = world.vertices;
//meshfilter.mesh.uv = world.uvRays;
//meshfilter.mesh.triangles = world.triangles;
// Update the mesh collider to use the graphical mesh for the physics engine
mesh.RecalculateNormals();
var meshcollider = GetComponent<MeshCollider>();
meshcollider.sharedMesh = mesh;
}
public WorldData(IGenerateTerrain terrGen, IMeshGenerator meshGen)
{
chunks = new Chunk[numChunksX,numChunksY];
TerrainGenerator = terrGen;
MeshGenerator = meshGen;
RegenerateWorld();
}
public WorldData(IGenerateTerrain terrGen, IMeshGenerator meshGen)
{
points = new bool[ChunkXSize,ChunkYSize,ZSize];
TerrainGenerator = terrGen;
MeshGenerator = meshGen;
TerrainGenerator.GenerateTerrain(this);
MeshGenerator.GenerateMesh(this);
}
public void SetSize(MeshGeneratorType type, Vector2 size)
{
IMeshGenerator generator = GetGenerator(type);
if (generator != null)
{
generator.SetSize(size);
}
}
public World(WorldData worldData, ITerrainGenerator terrainGenerator, ILightProcessor lightProcessor,
IMeshGenerator meshGenerator, IWorldDecorator worldDecorator)
{
m_WorldData = worldData;
m_LightProcessor = lightProcessor;
m_MeshGenerator = meshGenerator;
m_WorldDecorator = worldDecorator;
m_TerrainGenerator = terrainGenerator;
}
public WorldData(IGenerateTerrain terrGen, IMeshGenerator meshGen, int chunksX, int chunksY)
{
numChunksX = chunksX;
numChunksY = chunksY;
chunks = new Chunk[numChunksX,numChunksY];
TerrainGenerator = terrGen;
MeshGenerator = meshGen;
RegenerateWorld();
}
public Vector2 GetSize(MeshGeneratorType type)
{
IMeshGenerator generator = GetGenerator(type);
if (generator != null)
{
return(generator.GetSize());
}
return(default(Vector2));
}
private void Start()
{
_environmentProfileRepository = metaContext.Get <IEnvironmentProfileRepository>();
Validate();
_meshGenerator = metaContext.Get <IMeshGenerator>();
_meshGenerator.Material = _scanningMaterial;
_modelFileManipulator = metaContext.Get <IModelFileManipulator>();
SetState(ReconstructionState.Initializing);
}
public ChunkGenerator(ProceduralTerrainSettings _typeSettings)
{
var settings = _typeSettings.Get();
meshGenerator = MeshGeneratorFactory.Create(_typeSettings);
noiseGenerator = new NoiseGenerator(settings);
chunksPerFrame = settings.chunksPerFrame;
priorityChunkQueue = new Queue <TerrainChunk>();
chunkQueue = new Queue <TerrainChunk>();
outdatedChunks = new Queue <TerrainChunk>();
}
public IMapView CreateMapView(IMapModel mapModel, IMeshGenerator meshGenerator, IOutlineDrawer outlineDrawer)
{
var outlineMaterial = _assetProvider.GetOutlineMaterial();
var mapZonePrefab = _assetProvider.GetMapZonePrefab();
outlineDrawer.OutlineMaterial = outlineMaterial;
IMapViewGenerator mapViewGenerator = new MapViewGenerator(meshGenerator, outlineDrawer, _monoProvider);
var mapView = mapViewGenerator.CreateMapView(mapZonePrefab, mapModel);
return(mapView);
}
/// <summary>
/// 生成网格
/// </summary>
/// <param name="target"></param>
/// <param name="tex"></param>
/// <param name="size"></param>
/// <param name="xCells"></param>
/// <param name="zCells"></param>
/// <param name="maxLod"></param>
/// <param name="discardSamples"></param>
public static void GenerateMesh(GameObject target, Texture2D tex, IMeshGenerator generator)
{
if (tex == null)
{
return;
}
if (target == null)
{
return;
}
if (generator == null)
{
return;
}
string savePath = EditorUtility.SaveFilePanel("保存Mesh路径", "Assets/", "New Water Mesh", "asset");
if (string.IsNullOrEmpty(savePath))
{
return;
}
savePath = FileUtil.GetProjectRelativePath(savePath);
if (string.IsNullOrEmpty(savePath))
{
return;
}
//var unlitMesh = new ASL.UnlitWater.LodMesh(xCells, zCells, size.x*2, size.y*2,
// -size.x, -size.y, maxLod, uvDir, discardSamples);
Mesh mesh = generator.GenerateMesh(tex);
if (!mesh)
{
return;
}
MeshFilter mf = target.GetComponent <MeshFilter>();
if (!mf)
{
mf = target.AddComponent <MeshFilter>();
}
mf.sharedMesh = mesh;
AssetDatabase.CreateAsset(mesh, savePath);
MeshCollider mc = target.GetComponent <MeshCollider>();
if (mc)
{
mc.sharedMesh = mesh;
}
}
void Start()
{
terrGen = new SimplexTerrainGenerator();
meshGen = new MarchingCubesMeshGenerator();
world = new WorldData(terrGen, meshGen);
transform.Rotate(new Vector3(2, 2, 2));
var meshfilter = GetComponent<MeshFilter>();
Mesh mesh = new Mesh();
mesh.vertices = world.vertices;
mesh.uv = world.uvRays;
mesh.triangles = world.triangles;
//meshfilter.mesh.vertices = world.vertices;
//meshfilter.mesh.uv = world.uvRays;
//meshfilter.mesh.triangles = world.triangles;
meshfilter.mesh = mesh;
mesh.RecalculateNormals();
var meshcollider = GetComponent<MeshCollider>();
meshcollider.sharedMesh = mesh;
//var thing = GetComponent<MeshRenderer>();
}
public Chunk(int xPos, int yPos, int xySize, int zSize, IGenerateTerrain terrGen, IMeshGenerator meshGen, WorldData world)
{
TerrainGenerator = terrGen;
MeshGenerator = meshGen;
XYSize = xySize;
ZSize = zSize;
XPosition = xPos;
YPosition = yPos;
upperLimit = new int[XYSize+2, XYSize+2];
lowerLimit = new int[XYSize+2, XYSize+2];
blocks = new Block[xySize+2, xySize+2, zSize];
for(int i=0; i<blocks.GetLength(0); i++)
{
for (int j=0; j<blocks.GetLength(1); j++)
{
for (int k=0; k<blocks.GetLength(2); k++)
{
blocks[i,j,k] = new Block();
}
}
}
this.world = world;
}
protected TargetColliderGenerator(IApiColliderGenerator api, ITargetData data, IMeshGenerator meshGenerator)
{
_api = api;
Data = data;
MeshGenerator = meshGenerator;
}
public PrimitiveColliderGenerator(IApiColliderGenerator primitiveApi, IMeshGenerator meshGenerator)
{
_api = primitiveApi;
_meshGenerator = meshGenerator;
}
public HitTargetColliderGenerator(IApiColliderGenerator api, ITargetData data, IMeshGenerator meshProvider) : base(api, data, meshProvider)
{
}
