public IChunk[] GenerateChunk(IPlanet planet, Index2 index)
{
IChunk[] result = new IChunk[planet.Size.Z];
for (int layer = 0; layer < planet.Size.Z; layer++)
result[layer] = new Chunk(new Index3(index.X, index.Y, layer), planet.Id);
int part = (planet.Size.Z * Chunk.CHUNKSIZE_Z) / 4;
for (int y = 0; y < Chunk.CHUNKSIZE_Y; y++)
{
float heightY = (float)Math.Sin((float)(y * Math.PI) / 15f);
for (int x = 0; x < Chunk.CHUNKSIZE_X; x++)
{
float heightX = (float)Math.Sin((float)(x * Math.PI) / 18f);
float height = ((heightX + heightY + 2) / 4) * (2 * part);
for (int z = 0; z < planet.Size.Z * Chunk.CHUNKSIZE_Z; z++)
{
if (z < (int)(height + part))
{
int block = z % (Chunk.CHUNKSIZE_Z);
int layer = (int)(z / Chunk.CHUNKSIZE_Z);
result[layer].SetBlock(x, y, block, new SandBlock());
}
}
}
}
return result;
}
/// <summary>
/// Lädt eine <see cref="IChunkColumn"/>.
/// </summary>
/// <param name="universeGuid">GUID des Universums.</param>
/// <param name="planet">Index des Planeten.</param>
/// <param name="columnIndex">Zu serialisierende ChunkColumn.</param>
/// <returns>Die neu geladene ChunkColumn.</returns>
public IChunkColumn LoadColumn(Guid universeGuid, IPlanet planet, Index2 columnIndex)
{
string file = Path.Combine(GetRoot(), universeGuid.ToString(), planet.Id.ToString(), string.Format(ColumnFilename, columnIndex.X, columnIndex.Y));
if (!File.Exists(file))
return null;
try {
using (Stream stream = File.Open(file, FileMode.Open, FileAccess.Read))
{
using (GZipStream zip = new GZipStream(stream, CompressionMode.Decompress))
{
return planet.Generator.GenerateColumn(zip, DefinitionManager.Instance, planet.Id, columnIndex);
}
}
}
catch (IOException)
{
try
{
File.Delete(file);
}
catch (IOException) { }
return null;
}
}
public override void Populate(IDefinitionManager definitionManager, IPlanet planet, IChunkColumn column00, IChunkColumn column10, IChunkColumn column01, IChunkColumn column11)
{
// Tree Definitions initialisieren
if (treeDefinitions == null)
{
treeDefinitions = definitionManager.GetDefinitions<ITreeDefinition>().OrderBy(d => d.Order).ToArray();
foreach (var treeDefinition in treeDefinitions)
treeDefinition.Init(definitionManager);
}
int salt = (column00.Index.X & 0xffff) + ((column00.Index.Y & 0xffff) << 16);
Random random = new Random(planet.Seed + salt);
Index3 sample = new Index3(column00.Index.X * Chunk.CHUNKSIZE_X, column00.Index.Y * Chunk.CHUNKSIZE_Y, column00.Heights[0, 0]);
foreach (var treeDefinition in treeDefinitions)
{
int density = treeDefinition.GetDensity(planet, sample);
if (density <= 0) continue;
for (int i = 0; i < density; i++)
{
int x = random.Next(Chunk.CHUNKSIZE_X / 2, Chunk.CHUNKSIZE_X * 3 / 2);
int y = random.Next(Chunk.CHUNKSIZE_Y / 2, Chunk.CHUNKSIZE_Y * 3 / 2);
int z = LocalBuilder.GetSurfaceHeight(column00, column10, column01, column11, x, y);
LocalBuilder builder = new LocalBuilder(x, y, z + 1, column00, column10, column01, column11);
treeDefinition.PlantTree(definitionManager, planet, new Index3(x, y, z), builder, random.Next(int.MaxValue));
}
}
}
public SuperBiomeBase(IPlanet planet, float valueRangeOffset, float valueRange)
{
this.Planet = planet;
this.SubBiomes = new List<IBiome>();
this.ValueRangeOffset = valueRangeOffset;
this.ValueRange = valueRange;
}
public IChunk[] GenerateChunk(IEnumerable<IBlockDefinition> blockDefinitions, IPlanet planet, Index2 index)
{
IBlockDefinition sandDefinition = blockDefinitions.FirstOrDefault(d => typeof(SandBlockDefinition) == d.GetType());
ushort sandIndex = (ushort)(Array.IndexOf(blockDefinitions.ToArray(), sandDefinition) + 1);
IChunk[] result = new IChunk[planet.Size.Z];
for (int layer = 0; layer < planet.Size.Z; layer++)
result[layer] = new Chunk(new Index3(index.X, index.Y, layer), planet.Id);
int part = (planet.Size.Z * Chunk.CHUNKSIZE_Z) / 4;
for (int y = 0; y < Chunk.CHUNKSIZE_Y; y++)
{
float heightY = (float)Math.Sin((float)(y * Math.PI) / 15f);
for (int x = 0; x < Chunk.CHUNKSIZE_X; x++)
{
float heightX = (float)Math.Sin((float)(x * Math.PI) / 18f);
float height = ((heightX + heightY + 2) / 4) * (2 * part);
for (int z = 0; z < planet.Size.Z * Chunk.CHUNKSIZE_Z; z++)
{
if (z < (int)(height + part))
{
int block = z % (Chunk.CHUNKSIZE_Z);
int layer = (int)(z / Chunk.CHUNKSIZE_Z);
result[layer].SetBlock(x, y, block, sandIndex);
}
}
}
}
return result;
}
public OceanBiomeGenerator(IPlanet planet, float minVal, float maxVal, float valueRangeOffset, float valueRange)
{
this.Planet = planet;
this.MinValue = minVal;
this.MaxValue = maxVal;
this.ValueRangeOffset = valueRangeOffset;
this.ValueRange = valueRange;
}
public ActorHost(Player player)
{
Player = player;
localChunkCache = new Cache<Index3, IChunk>(10, loadChunk, null);
planet = ResourceManager.Instance.GetPlanet(Player.Position.Planet);
ActiveTool = null;
}
public FlatlandBiome(IPlanet planet, float minValue, float maxValue, float valueRangeOffset, float valueRange)
{
this.BiomeNoiseGenerator = new SimplexNoiseGenerator(planet.Seed + 2) { FrequencyX = 1f / 256, FrequencyY = 1f / 256, Persistance = 0.25f, Octaves = 3, Factor = 1f };
this.Planet = planet;
this.MinValue = minValue;
this.MaxValue = maxValue;
this.ValueRangeOffset = valueRangeOffset;
this.ValueRange = valueRange;
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="planet">Planet to render</param>
/// <param name="effectPath">Path to the terrain effect</param>
public PlanetPackTextureTechnique( IPlanet planet, string effectPath )
{
Arguments.CheckNotNull( planet, "planet" );
Arguments.CheckNotNullOrEmpty( effectPath, "effectPath" );
m_Planet = planet;
m_NoiseTexture = ( ITexture2d )AssetManager.Instance.Load( "Terrain/TiledNoise.noise.jpg" );
m_Effect = new EffectAssetHandle( effectPath, true );
m_Effect.OnReload += Effect_OnReload;
m_Technique = new TechniqueSelector( m_Effect, "DefaultTechnique" );
}
public ActorHost(Player player)
{
Player = player;
planet = ResourceManager.Instance.GetPlanet(Player.Position.Planet);
localChunkCache = new LocalChunkCache(ResourceManager.Instance.GlobalChunkCache, 2, 1, true);
_oldIndex = Player.Position.ChunkIndex;
ActiveTool = null;
ReadyState = false;
}
public override void PlantTree(IDefinitionManager definitionManager, IPlanet planet, Index3 index, LocalBuilder builder, int seed)
{
ushort ground = builder.GetBlock(0, 0, -1);
if (ground == water) return;
Random rand = new Random(seed);
int height = rand.Next(2, 4);
for (int i = 0; i < height; i++)
builder.SetBlock(0, 0, i, cactus);
}
public ActorHost(Player player, IChunkLoader chunkLoader)
{
_chunkLoader = chunkLoader;
Player = player;
planet = ResourceManager.Instance.GetPlanet(Player.Position.Planet);
_oldIndex = Player.Position.ChunkIndex;
ActiveTool = null;
State = WorldState.Loading;
}
public void DeployTo(IPlanet planet, int landingPointX, int landingPointY, Movement.CardinalHeading landingCardinalHeading)
{
this.DeployedTo = planet;
if (landingPointX < 0 ||
landingPointY < 0 ||
landingPointX > planet.Size.Width ||
landingPointY > planet.Size.Height)
{
throw new ArgumentException("Rover cannot be deployed to a point outside the bounds of a planet.");
}
this.Position = new Position(landingPointX, landingPointY, landingCardinalHeading);
}
public SurfaceBiomeGenerator(IPlanet planet, int seaLevel)
: base(planet, 0f, 1f)
{
this.SeaLevel = seaLevel;
BiomeNoiseGenerator = new SimplexNoiseGenerator(planet.Seed) { FrequencyX = 1f / 10000, FrequencyY = 1f / 10000, Factor = 1f };
float offset = (float)seaLevel / (Planet.Size.Z * Chunk.CHUNKSIZE_Z);
SubBiomes.Add(new OceanBiomeGenerator(planet, 0f, 0.3f, 0f, offset));
SubBiomes.Add(new LandBiomeGenerator(planet, 0.5f, 1f, offset, 1 - offset));
SortSubBiomes();
}
/// <summary>
/// Setup constructor
/// </summary>
/// <param name="projectType">Project type that created this project</param>
/// <param name="name">Project name</param>
/// <param name="modelFactory">Factory used for creating environment models from templates</param>
/// <param name="renderFactory">Factory used for creating environment renderers from models</param>
/// <param name="template">ProjectType to use</param>
/// <param name="planet">Planet to use</param>
protected PlanetProject( ProjectType projectType, string name, IPlanetEnvironmentModelFactory modelFactory, IPlanetEnvironmentRendererFactory renderFactory, IPlanetModelTemplate template, IPlanet planet )
: base(projectType, name, null, null)
{
Arguments.CheckNotNull( template, "template" );
Arguments.CheckNotNull( modelFactory, "modelFactory" );
Arguments.CheckNotNull( renderFactory, "renderFactory" );
Arguments.CheckNotNull( planet, "planet" );
new PlanetTemplateWatcher( template, planet, modelFactory, renderFactory );
m_Planet = planet;
m_PlanetTemplate = template;
template.CreateModelInstance( planet.Model, modelFactory, InstanceContext );
}
/// <summary>
/// Setzt den Zentrums-Chunk für diesen lokalen Cache.
/// </summary>
/// <param name="planet">Der Planet, auf dem sich der Chunk befindet</param>
/// <param name="index">Die Koordinaten an der sich der Chunk befindet</param>
/// <param name="successCallback">Routine die Aufgerufen werden soll, falls das setzen erfolgreich war oder nicht</param>
public void SetCenter(IPlanet planet, Index3 index, Action<bool> successCallback = null)
{
if (_loadingTask != null && !_loadingTask.IsCompleted)
{
_cancellationToken.Cancel();
_cancellationToken = new CancellationTokenSource();
_loadingTask = _loadingTask.ContinueWith(_ => InternalSetCenter(_cancellationToken.Token, planet, index, successCallback));
}
else
{
_cancellationToken = new CancellationTokenSource();
_loadingTask = Task.Factory.StartNew(() => InternalSetCenter(_cancellationToken.Token, planet, index, successCallback));
}
}
/// <summary>
/// Setup constructor
/// </summary>
public PlanetTemplateWatcher( IPlanetModelTemplate planetTemplate, IPlanet planet, IPlanetEnvironmentModelFactory modelFactory, IPlanetEnvironmentRendererFactory rendererFactory )
{
Arguments.CheckNotNull( planetTemplate, "planetTemplate" );
Arguments.CheckNotNull( planet, "planet" );
m_ModelFactory = modelFactory;
m_RendererFactory = rendererFactory;
m_PlanetTemplate = planetTemplate;
m_Planet = planet;
m_PlanetTemplate.ComponentAdded += OnTemplateAdded;
m_PlanetTemplate.ComponentRemoved += OnTemplateRemoved;
m_Planet.Model.ComponentAdded += OnModelAdded;
m_Planet.Model.ComponentRemoved += OnModelRemoved;
}
public override void PlantTree(IDefinitionManager definitionManager, IPlanet planet, Index3 index, LocalBuilder builder, int seed)
{
ushort ground = builder.GetBlock(0, 0, -1);
if (ground == water) return;
Random rand = new Random(seed);
int height = rand.Next(3, 5);
int radius = rand.Next(3, height);
builder.FillSphere(0, 0, height, radius, leave);
for (int i = 0; i < height + 2; i++)
{
builder.SetBlock(0, 0, 0 + i, wood);
}
}
public LandBiomeGenerator(IPlanet planet, float minVal, float maxVal, float valueRangeOffset, float valueRange)
: base(planet, valueRangeOffset, valueRange)
{
BiomeNoiseGenerator = new SimplexNoiseGenerator(planet.Seed + 1) { FrequencyX = 1f / 1000, FrequencyY = 1f / 1000, Persistance = 0.25f, Octaves = 5, Factor = 1f };
this.MinValue = minVal;
this.MaxValue = maxVal;
SubBiomes.Add(new FlatlandBiome(planet, 0f, 0.2f, 0f, 0.1f));
SubBiomes.Add(new HillsBiome(planet, 0.3f, 0.5f, 0.1f, 0.4f));
SubBiomes.Add(new HighMountainBiome(planet, 0.8f, 1f, 0.2f, 0.8f));
SortSubBiomes();
}
/// <summary>
/// Sets up the terrain rendering effect
/// </summary>
protected virtual void SetupTerrainEffect( IEffect effect, IPlanet planet )
{
IPlanetTerrainPackTextureModel textureModel = ( IPlanetTerrainPackTextureModel )planet.PlanetModel.TerrainModel;
ITexture2d packTexture = textureModel.TerrainPackTexture;
ITexture2d typesTexture = textureModel.TerrainTypesTexture;
effect.Parameters[ "PlanetMaximumTerrainHeight" ].Set( planet.PlanetModel.TerrainModel.MaximumHeight.ToRenderUnits );
effect.Parameters[ "TerrainPackTexture" ].Set( packTexture );
effect.Parameters[ "TerrainTypeTexture" ].Set( typesTexture );
effect.Parameters[ "NoiseTexture" ].Set( m_NoiseTexture );
IPlanetAtmosphereRenderer atmosphereRenderer = planet.PlanetRenderer.AtmosphereRenderer;
if ( atmosphereRenderer != null )
{
atmosphereRenderer.SetupAtmosphereEffectParameters( effect, true, false );
}
}
/// <summary>
/// Resolve references to non-service entities.
/// Subscribe to events.
/// </summary>
void Start() {
// get registry lookups
planet = registry.LookUp<IPlanet>("Planet");
gameUI = registry.LookUp<IGameUI>("GameUI");
// subscribe to events
time.CountdownFinished += OnCountdownFinished;
gameUI.onGameReady += OnGameReady;
// turn on controls
shipController.Connect();
// start the first wave
gameUI.TriggerWaveStartAnimation();
}
void Start()
{
ship = registry.LookUp<IShip>("Ship");
planet = registry.LookUp<IPlanet>("Planet");
}
public override int GetDensity(IPlanet planet, Index3 index)
{
return 4;
}
public IChunk[] GenerateChunk(IEnumerable<IBlockDefinition> blockDefinitions, IPlanet planet, Index2 index)
{
IBlockDefinition sandDefinition = blockDefinitions.FirstOrDefault(d => typeof(SandBlockDefinition) == d.GetType());
ushort sandIndex = (ushort)(Array.IndexOf(blockDefinitions.ToArray(), sandDefinition) + 1);
IBlockDefinition groundDefinition = blockDefinitions.FirstOrDefault(d => typeof(GroundBlockDefinition) == d.GetType());
ushort groundIndex = (ushort)(Array.IndexOf(blockDefinitions.ToArray(), groundDefinition) + 1);
IBlockDefinition stoneDefinition = blockDefinitions.FirstOrDefault(d => typeof(StoneBlockDefinition) == d.GetType());
ushort stoneIndex = (ushort)(Array.IndexOf(blockDefinitions.ToArray(), stoneDefinition) + 1);
IBlockDefinition waterDefinition = blockDefinitions.FirstOrDefault(d => typeof(WaterBlockDefinition) == d.GetType());
ushort waterIndex = (ushort)(Array.IndexOf(blockDefinitions.ToArray(), waterDefinition) + 1);
IBlockDefinition grassDefinition = blockDefinitions.FirstOrDefault(d => typeof(GrassBlockDefinition) == d.GetType());
ushort grassIndex = (ushort)(Array.IndexOf(blockDefinitions.ToArray(), grassDefinition) + 1);
if (!(planet is ComplexPlanet))
throw new ArgumentException("planet is not a Type of ComplexPlanet");
ComplexPlanet localPlanet = (ComplexPlanet)planet;
float[,] localHeightmap = localPlanet.BiomeGenerator.GetHeightmap(index);
IChunk[] chunks = new IChunk[planet.Size.Z];
for (int i = 0; i < planet.Size.Z; i++)
chunks[i] = new Chunk(new Index3(index, i), planet.Id);
int obersteSchicht;
bool surfaceBlock;
bool ozeanSurface;
for (int x = 0; x < Chunk.CHUNKSIZE_X; x++)
{
for (int y = 0; y < Chunk.CHUNKSIZE_Y; y++)
{
obersteSchicht = 5;
surfaceBlock = true;
ozeanSurface = false;
for (int i = chunks.Length - 1; i >= 0; i--)
{
for (int z = Chunk.CHUNKSIZE_Z - 1; z >= 0; z--)
{
int absoluteZ = (z + (i * Chunk.CHUNKSIZE_Z));
if (absoluteZ <= localHeightmap[x, y] * localPlanet.Size.Z * Chunk.CHUNKSIZE_Z)
{
if (obersteSchicht > 0)
{
float temp = localPlanet.ClimateMap.GetTemperature(new Index3(index.X * Chunk.CHUNKSIZE_X + x, index.Y * Chunk.CHUNKSIZE_Y + y, i * Chunk.CHUNKSIZE_Z + z));
if ((ozeanSurface || surfaceBlock) && (absoluteZ <= (localPlanet.BiomeGenerator.SeaLevel + 2)) && (absoluteZ >= (localPlanet.BiomeGenerator.SeaLevel - 2)))
{
chunks[i].SetBlock(x, y, z, sandIndex);
}
else if (temp >= 35)
{
chunks[i].SetBlock(x, y, z, sandIndex);
}
else if (absoluteZ >= localPlanet.Size.Z * Chunk.CHUNKSIZE_Z * 0.6f)
{
if (temp > 12)
chunks[i].SetBlock(x, y, z, groundIndex);
else
chunks[i].SetBlock(x, y, z, stoneIndex);
}
else if (temp >= 8)
{
if (surfaceBlock && !ozeanSurface)
{
chunks[i].SetBlock(x, y, z, grassIndex);
surfaceBlock = false;
}
else
{
chunks[i].SetBlock(x, y, z, groundIndex);
}
}
else
{
chunks[i].SetBlock(x, y, z, groundIndex);
}
obersteSchicht--;
}
else
{
chunks[i].SetBlock(x, y, z, stoneIndex);
}
}
else if ((z + (i * Chunk.CHUNKSIZE_Z)) <= localPlanet.BiomeGenerator.SeaLevel)
{
chunks[i].SetBlock(x, y, z, waterIndex);
ozeanSurface = true;
}
}
}
}
}
//float[,] cloudmap = null;
////Biomes.BiomeBlockValue[, ,] blockValues = localPlanet.BiomeGenerator.GetBlockValues(index,heightmap,0f,1f);
////for (int x = 0; x < Chunk.CHUNKSIZE_X; x++)
//Parallel.For(0, Chunk.CHUNKSIZE_X, x =>
//{
// for (int y = 0; y < Chunk.CHUNKSIZE_Y; y++)
// {
// bool grass = true, sand = false;
// for (int i = chunks.Length - 1; i >= 0; i--)
// {
// for (int z = Chunk.CHUNKSIZE_Z - 1; z >= 0; z--)
// {
// //Biomes.BiomeBlockValue blockValue = blockValues[x, y, z + i * Chunk.CHUNKSIZE_Z];
// int blockHeight = Math.Max(z + Chunk.CHUNKSIZE_Z * (i), 0);
// //float density = heightmap[x,y] * (Chunk.CHUNKSIZE_Z * (planet.Size.Z)) - blockHeight;
// Index3 blockIndex = new Index3(index.X * Chunk.CHUNKSIZE_X + x, index.Y * Chunk.CHUNKSIZE_Y + y, i * Chunk.CHUNKSIZE_Z + z);
// if (blockValue.Density > 0.6f || (z < 3 && i == 0))
// {
// if (blockValue.IsDessert || (grass | sand) && (z + (i * Chunk.CHUNKSIZE_Z)) <= localPlanet.BiomeGenerator.SeaLevel && (z + (i * Chunk.CHUNKSIZE_Z)) >= localPlanet.BiomeGenerator.SeaLevel - 2)
// {
// chunks[i].SetBlock(new Index3(x, y, z), new SandBlock());
// grass = false;
// sand = true;
// }
// else if (grass && planet.ClimateMap.GetTemperature(blockIndex) > 18.0f)
// {
// chunks[i].SetBlock(new Index3(x, y, z), new GrassBlock());
// grass = false;
// }
// //else if (z < Chunk.CHUNKSIZE_Z - 1 && noiseplus >= resDensity)
// //{
// // chunks[i].SetBlock(new Index3(x, y, z), new StoneBlock());
// //}
// else
// {
// chunks[i].SetBlock(new Index3(x, y, z), new GroundBlock());
// grass = false;
// }
// }
// else if ((z + (i * Chunk.CHUNKSIZE_Z)) <= localPlanet.BiomeGenerator.SeaLevel)
// {
// grass = false;
// sand = true;
// chunks[i].SetBlock(new Index3(x, y, z), new WaterBlock());
// }
// }
// }
// }
//});
return chunks;
}
public SceneControl(ScreenComponent manager, string style = "")
: base(manager, style)
{
player = manager.Player;
camera = manager.Camera;
Manager = manager;
simpleShader = manager.Game.Content.Load<Effect>("simple");
sunTexture = manager.Game.Content.Load<Texture2D>("Textures/sun");
List<Bitmap> bitmaps = new List<Bitmap>();
var definitions = DefinitionManager.GetBlockDefinitions();
foreach (var definition in definitions)
bitmaps.AddRange(definition.Textures);
int size = (int)Math.Ceiling(Math.Sqrt(bitmaps.Count));
Bitmap blocks = new Bitmap(size * TEXTURESIZE, size * TEXTURESIZE);
using (Graphics g = Graphics.FromImage(blocks))
{
int counter = 0;
foreach (var bitmap in bitmaps)
{
int x = counter % size;
int y = (int)(counter / size);
g.DrawImage(bitmap, new System.Drawing.Rectangle(TEXTURESIZE * x, TEXTURESIZE * y, TEXTURESIZE, TEXTURESIZE));
counter++;
}
}
using (MemoryStream stream = new MemoryStream())
{
blocks.Save(stream, ImageFormat.Png);
stream.Seek(0, SeekOrigin.Begin);
blockTextures = Texture2D.FromStream(manager.GraphicsDevice, stream);
}
planet = ResourceManager.Instance.GetPlanet(0);
_manager = ResourceManager.Instance.GetManagerForPlanet(planet.Id);
chunkRenderer = new ChunkRenderer[
(int)Math.Pow(2, VIEWRANGE) * (int)Math.Pow(2, VIEWRANGE),
planet.Size.Z];
for (int i = 0; i < chunkRenderer.GetLength(0); i++)
for (int j = 0; j < chunkRenderer.GetLength(1); j++)
chunkRenderer[i, j] = new ChunkRenderer(simpleShader, manager.GraphicsDevice, camera.Projection, blockTextures);
// Entfernungsarray erzeugen
//for (int x = -VIEWRANGE; x <= VIEWRANGE; x++)
// for (int y = -VIEWRANGE; y <= VIEWRANGE; y++)
// for (int z = 0; z <= planet.Size.Z; z++)
// distances.Add(new Index3(x, y, z));
//distances = distances.OrderBy(d => d.LengthSquared()).ToList();
backgroundThread = new Thread(BackgroundLoop);
backgroundThread.Priority = ThreadPriority.Lowest;
backgroundThread.IsBackground = true;
backgroundThread.Start();
selectionLines = new[]
{
new VertexPositionColor(new Vector3(-0.001f, +1.001f, +1.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
new VertexPositionColor(new Vector3(+1.001f, +1.001f, +1.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
new VertexPositionColor(new Vector3(-0.001f, -0.001f, +1.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
new VertexPositionColor(new Vector3(+1.001f, -0.001f, +1.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
new VertexPositionColor(new Vector3(-0.001f, +1.001f, -0.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
new VertexPositionColor(new Vector3(+1.001f, +1.001f, -0.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
new VertexPositionColor(new Vector3(-0.001f, -0.001f, -0.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
new VertexPositionColor(new Vector3(+1.001f, -0.001f, -0.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
};
billboardVertices = new[]
{
new VertexPositionTexture(new Vector3(-0.5f, 0.5f, 0), new Vector2(0, 0)),
new VertexPositionTexture(new Vector3(0.5f, 0.5f, 0), new Vector2(1, 0)),
new VertexPositionTexture(new Vector3(-0.5f, -0.5f, 0), new Vector2(0, 1)),
new VertexPositionTexture(new Vector3(0.5f, 0.5f, 0), new Vector2(1, 0)),
new VertexPositionTexture(new Vector3(0.5f, -0.5f, 0), new Vector2(1, 1)),
new VertexPositionTexture(new Vector3(-0.5f, -0.5f, 0), new Vector2(0, 1)),
};
selectionIndeces = new short[]
{
0, 1, 0, 2, 1, 3, 2, 3,
4, 5, 4, 6, 5, 7, 6, 7,
0, 4, 1, 5, 2, 6, 3, 7
};
sunEffect = new BasicEffect(manager.GraphicsDevice);
sunEffect.TextureEnabled = true;
selectionEffect = new BasicEffect(manager.GraphicsDevice);
selectionEffect.VertexColorEnabled = true;
MiniMapTexture = new RenderTarget2D(manager.GraphicsDevice, 128, 128, false, SurfaceFormat.Color, DepthFormat.Depth24Stencil8); // , false, SurfaceFormat.Color, DepthFormat.Depth24Stencil8, 0, RenderTargetUsage.PreserveContents);
miniMapProjectionMatrix = Matrix.CreateOrthographic(128, 128, 1, 10000);
}
public SceneControl(ScreenComponent manager, string style = "")
: base(manager, style)
{
player = manager.Player;
camera = manager.Camera;
assets = manager.Game.Assets;
Manager = manager;
simpleShader = manager.Game.Content.Load<Effect>("simple");
sunTexture = assets.LoadTexture(typeof(ScreenComponent), "sun");
//List<Bitmap> bitmaps = new List<Bitmap>();
var definitions = DefinitionManager.Instance.GetBlockDefinitions();
int textureCount = 0;
foreach (var definition in definitions)
{
textureCount += definition.Textures.Length;
}
int bitmapSize = 128;
blockTextures = new Texture2DArray(manager.GraphicsDevice, 1, bitmapSize, bitmapSize, textureCount);
int layer = 0;
foreach (var definition in definitions)
{
foreach (var bitmap in definition.Textures)
{
System.Drawing.Bitmap texture = manager.Game.Assets.LoadBitmap(definition.GetType(), bitmap);
var scaled = texture;//new Bitmap(bitmap, new System.Drawing.Size(bitmapSize, bitmapSize));
int[] data = new int[scaled.Width * scaled.Height];
var bitmapData = scaled.LockBits(new System.Drawing.Rectangle(0, 0, scaled.Width, scaled.Height), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
System.Runtime.InteropServices.Marshal.Copy(bitmapData.Scan0, data, 0, data.Length);
blockTextures.SetData(data, layer);
scaled.UnlockBits(bitmapData);
layer++;
}
}
/*int size = (int)Math.Ceiling(Math.Sqrt(bitmaps.Count));
Bitmap blocks = new Bitmap(size * TEXTURESIZE, size * TEXTURESIZE);
using (Graphics g = Graphics.FromImage(blocks))
{
int counter = 0;
foreach (var bitmap in bitmaps)
{
int x = counter % size;
int y = (int)(counter / size);
g.DrawImage(bitmap, new System.Drawing.Rectangle(TEXTURESIZE * x, TEXTURESIZE * y, TEXTURESIZE, TEXTURESIZE));
counter++;
}
}
using (MemoryStream stream = new MemoryStream())
{
blocks.Save(stream, ImageFormat.Png);
stream.Seek(0, SeekOrigin.Begin);
blockTextures = Texture2D.FromStream(manager.GraphicsDevice, stream);
}*/
planet = ResourceManager.Instance.GetPlanet(0);
// TODO: evtl. Cache-Size (Dimensions) VIEWRANGE + 1
int range = ((int)Math.Pow(2, VIEWRANGE) - 2) / 2;
localChunkCache = new LocalChunkCache(ResourceManager.Instance.GlobalChunkCache, VIEWRANGE, range);
chunkRenderer = new ChunkRenderer[
(int)Math.Pow(2, VIEWRANGE) * (int)Math.Pow(2, VIEWRANGE),
planet.Size.Z];
orderedChunkRenderer = new List<ChunkRenderer>(
(int)Math.Pow(2, VIEWRANGE) * (int)Math.Pow(2, VIEWRANGE) * planet.Size.Z);
for (int i = 0; i < chunkRenderer.GetLength(0); i++)
{
for (int j = 0; j < chunkRenderer.GetLength(1); j++)
{
ChunkRenderer renderer = new ChunkRenderer(simpleShader, manager.GraphicsDevice, camera.Projection, blockTextures);
chunkRenderer[i, j] = renderer;
orderedChunkRenderer.Add(renderer);
}
}
backgroundThread = new Thread(BackgroundLoop);
backgroundThread.Priority = ThreadPriority.Lowest;
backgroundThread.IsBackground = true;
backgroundThread.Start();
var selectionVertices = new[]
{
new VertexPositionColor(new Vector3(-0.001f, +1.001f, +1.001f), Color.Black * 0.5f),
new VertexPositionColor(new Vector3(+1.001f, +1.001f, +1.001f), Color.Black * 0.5f),
new VertexPositionColor(new Vector3(-0.001f, -0.001f, +1.001f), Color.Black * 0.5f),
new VertexPositionColor(new Vector3(+1.001f, -0.001f, +1.001f), Color.Black * 0.5f),
new VertexPositionColor(new Vector3(-0.001f, +1.001f, -0.001f), Color.Black * 0.5f),
new VertexPositionColor(new Vector3(+1.001f, +1.001f, -0.001f), Color.Black * 0.5f),
new VertexPositionColor(new Vector3(-0.001f, -0.001f, -0.001f), Color.Black * 0.5f),
new VertexPositionColor(new Vector3(+1.001f, -0.001f, -0.001f), Color.Black * 0.5f),
};
var billboardVertices = new[]
{
new VertexPositionTexture(new Vector3(-0.5f, 0.5f, 0), new Vector2(0, 0)),
new VertexPositionTexture(new Vector3(0.5f, 0.5f, 0), new Vector2(1, 0)),
new VertexPositionTexture(new Vector3(-0.5f, -0.5f, 0), new Vector2(0, 1)),
new VertexPositionTexture(new Vector3(0.5f, 0.5f, 0), new Vector2(1, 0)),
new VertexPositionTexture(new Vector3(0.5f, -0.5f, 0), new Vector2(1, 1)),
new VertexPositionTexture(new Vector3(-0.5f, -0.5f, 0), new Vector2(0, 1)),
};
var selectionIndices = new short[]
{
0, 1, 0, 2, 1, 3, 2, 3,
4, 5, 4, 6, 5, 7, 6, 7,
0, 4, 1, 5, 2, 6, 3, 7
};
selectionLines = new VertexBuffer(manager.GraphicsDevice, VertexPositionColor.VertexDeclaration, selectionVertices.Length);
selectionLines.SetData(selectionVertices);
selectionIndexBuffer = new IndexBuffer(manager.GraphicsDevice, DrawElementsType.UnsignedShort, selectionIndices.Length);
selectionIndexBuffer.SetData(selectionIndices);
billboardVertexbuffer = new VertexBuffer(manager.GraphicsDevice, VertexPositionTexture.VertexDeclaration, billboardVertices.Length);
billboardVertexbuffer.SetData(billboardVertices);
sunEffect = new BasicEffect(manager.GraphicsDevice);
sunEffect.TextureEnabled = true;
selectionEffect = new BasicEffect(manager.GraphicsDevice);
selectionEffect.VertexColorEnabled = true;
MiniMapTexture = new RenderTarget2D(manager.GraphicsDevice, 128, 128, PixelInternalFormat.Rgb8); // , false, SurfaceFormat.Color, DepthFormat.Depth24Stencil8, 0, RenderTargetUsage.PreserveContents);
miniMapProjectionMatrix = Matrix.CreateOrthographic(128, 128, 1, 10000);
}
public SceneControl(ScreenComponent manager, string style = "")
: base(manager, style)
{
player = manager.Player;
camera = manager.Camera;
Manager = manager;
simpleShader = manager.Game.Content.Load<Effect>("simple");
sunTexture = manager.Game.Content.LoadTexture2DFromFile("./Assets/OctoAwesome.Client/sun.png", manager.GraphicsDevice);
List<Bitmap> bitmaps = new List<Bitmap>();
var definitions = DefinitionManager.Instance.GetBlockDefinitions();
foreach (var definition in definitions)
bitmaps.AddRange(definition.Textures);
int size = (int)Math.Ceiling(Math.Sqrt(bitmaps.Count));
Bitmap blocks = new Bitmap(size * TEXTURESIZE, size * TEXTURESIZE);
using (Graphics g = Graphics.FromImage(blocks))
{
int counter = 0;
foreach (var bitmap in bitmaps)
{
int x = counter % size;
int y = (int)(counter / size);
g.DrawImage(bitmap, new System.Drawing.Rectangle(TEXTURESIZE * x, TEXTURESIZE * y, TEXTURESIZE, TEXTURESIZE));
counter++;
}
}
using (MemoryStream stream = new MemoryStream())
{
blocks.Save(stream, ImageFormat.Png);
stream.Seek(0, SeekOrigin.Begin);
blockTextures = Texture2D.FromStream(manager.GraphicsDevice, stream);
}
planet = ResourceManager.Instance.GetPlanet(0);
// TODO: evtl. Cache-Size (Dimensions) VIEWRANGE + 1
int range = ((int)Math.Pow(2, VIEWRANGE) - 2) / 2;
localChunkCache = new LocalChunkCache(ResourceManager.Instance.GlobalChunkCache, VIEWRANGE, range);
chunkRenderer = new ChunkRenderer[
(int)Math.Pow(2, VIEWRANGE) * (int)Math.Pow(2, VIEWRANGE),
planet.Size.Z];
orderedChunkRenderer = new List<ChunkRenderer>(
(int)Math.Pow(2, VIEWRANGE) * (int)Math.Pow(2, VIEWRANGE) * planet.Size.Z);
for (int i = 0; i < chunkRenderer.GetLength(0); i++)
{
for (int j = 0; j < chunkRenderer.GetLength(1); j++)
{
ChunkRenderer renderer = new ChunkRenderer(simpleShader, manager.GraphicsDevice, camera.Projection, blockTextures);
chunkRenderer[i, j] = renderer;
orderedChunkRenderer.Add(renderer);
}
}
backgroundThread = new Thread(BackgroundLoop);
backgroundThread.Priority = ThreadPriority.Lowest;
backgroundThread.IsBackground = true;
backgroundThread.Start();
selectionLines = new[]
{
new VertexPositionColor(new Vector3(-0.001f, +1.001f, +1.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
new VertexPositionColor(new Vector3(+1.001f, +1.001f, +1.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
new VertexPositionColor(new Vector3(-0.001f, -0.001f, +1.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
new VertexPositionColor(new Vector3(+1.001f, -0.001f, +1.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
new VertexPositionColor(new Vector3(-0.001f, +1.001f, -0.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
new VertexPositionColor(new Vector3(+1.001f, +1.001f, -0.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
new VertexPositionColor(new Vector3(-0.001f, -0.001f, -0.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
new VertexPositionColor(new Vector3(+1.001f, -0.001f, -0.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
};
billboardVertices = new[]
{
new VertexPositionTexture(new Vector3(-0.5f, 0.5f, 0), new Vector2(0, 0)),
new VertexPositionTexture(new Vector3(0.5f, 0.5f, 0), new Vector2(1, 0)),
new VertexPositionTexture(new Vector3(-0.5f, -0.5f, 0), new Vector2(0, 1)),
new VertexPositionTexture(new Vector3(0.5f, 0.5f, 0), new Vector2(1, 0)),
new VertexPositionTexture(new Vector3(0.5f, -0.5f, 0), new Vector2(1, 1)),
new VertexPositionTexture(new Vector3(-0.5f, -0.5f, 0), new Vector2(0, 1)),
};
selectionIndeces = new short[]
{
0, 1, 0, 2, 1, 3, 2, 3,
4, 5, 4, 6, 5, 7, 6, 7,
0, 4, 1, 5, 2, 6, 3, 7
};
sunEffect = new BasicEffect(manager.GraphicsDevice);
sunEffect.TextureEnabled = true;
selectionEffect = new BasicEffect(manager.GraphicsDevice);
selectionEffect.VertexColorEnabled = true;
MiniMapTexture = new RenderTarget2D(manager.GraphicsDevice, 128, 128, false, SurfaceFormat.Color, DepthFormat.Depth24Stencil8); // , false, SurfaceFormat.Color, DepthFormat.Depth24Stencil8, 0, RenderTargetUsage.PreserveContents);
miniMapProjectionMatrix = Matrix.CreateOrthographic(128, 128, 1, 10000);
}
private void savePlanet(int index, IPlanet value)
{
}
protected override void LoadContent()
{
List<Bitmap> bitmaps = new List<Bitmap>();
var definitions = BlockDefinitionManager.GetBlockDefinitions();
foreach (var definition in definitions)
bitmaps.AddRange(definition.Textures);
int size = (int)Math.Ceiling(Math.Sqrt(bitmaps.Count));
Bitmap blocks = new Bitmap(size * TEXTURESIZE, size * TEXTURESIZE);
using (Graphics g = Graphics.FromImage(blocks))
{
int counter = 0;
foreach (var bitmap in bitmaps)
{
int x = counter % size;
int y = (int)(counter / size);
g.DrawImage(bitmap, new System.Drawing.Rectangle(TEXTURESIZE * x, TEXTURESIZE * y, TEXTURESIZE, TEXTURESIZE));
counter++;
}
}
using (MemoryStream stream = new MemoryStream())
{
blocks.Save(stream, ImageFormat.Png);
stream.Seek(0, SeekOrigin.Begin);
blockTextures = Texture2D.FromStream(GraphicsDevice, stream);
}
planet = ResourceManager.Instance.GetPlanet(0);
chunkRenderer = new ChunkRenderer[
((VIEWRANGE * 2) + 1) *
((VIEWRANGE * 2) + 1) *
((VIEWHEIGHT * 2) + 1)];
for (int i = 0; i < chunkRenderer.Length; i++)
{
chunkRenderer[i] = new ChunkRenderer(GraphicsDevice, camera.Projection, blockTextures);
freeChunkRenderer.Enqueue(chunkRenderer[i]);
}
// Entfernungsarray erzeugen
for (int x = -VIEWRANGE; x <= VIEWRANGE; x++)
for (int y = -VIEWRANGE; y <= VIEWRANGE; y++)
for (int z = -VIEWHEIGHT; z <= VIEWHEIGHT; z++)
distances.Add(new Index3(x, y, z));
distances = distances.OrderBy(d => d.LengthSquared()).ToList();
backgroundThread = new Thread(BackgroundLoop);
backgroundThread.Priority = ThreadPriority.Lowest;
backgroundThread.IsBackground = true;
backgroundThread.Start();
selectionLines = new[]
{
new VertexPositionColor(new Vector3(-0.001f, +1.001f, +1.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
new VertexPositionColor(new Vector3(+1.001f, +1.001f, +1.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
new VertexPositionColor(new Vector3(-0.001f, -0.001f, +1.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
new VertexPositionColor(new Vector3(+1.001f, -0.001f, +1.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
new VertexPositionColor(new Vector3(-0.001f, +1.001f, -0.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
new VertexPositionColor(new Vector3(+1.001f, +1.001f, -0.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
new VertexPositionColor(new Vector3(-0.001f, -0.001f, -0.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
new VertexPositionColor(new Vector3(+1.001f, -0.001f, -0.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
};
selectionIndeces = new short[]
{
0, 1, 0, 2, 1, 3, 2, 3,
4, 5, 4, 6, 5, 7, 6, 7,
0, 4, 1, 5, 2, 6, 3, 7
};
selectionEffect = new BasicEffect(GraphicsDevice);
selectionEffect.VertexColorEnabled = true;
MiniMapTexture = new RenderTarget2D(GraphicsDevice, 128, 128, false, SurfaceFormat.Color, DepthFormat.Depth24Stencil8, 0, RenderTargetUsage.PreserveContents);
minimapEffect = new BasicEffect(GraphicsDevice);
minimapEffect.Projection = Matrix.CreateOrthographic(100, 100, 1, 10000);
minimapEffect.EnableDefaultLighting();
base.LoadContent();
}
public void Show()
{
_planet = _planetFactory.Create(DoubleVector3.Zero, PhysicalConstants.RadiusOfEarth);
_cameraController.AttachToPlanet(_planet);
_windowManager.ShowAllWindows();
}
