public void CreateModel()
{
EntityFactory.InitializeProtobufInheritanceHierarchy();
var conf =
WorldConfiguration.LoadFromFile(@"C:\Dev\Utopia\Utopia\Resources\Shared.Resources\Config\Island.realm");
try
{
var model = VoxelModel.GenerateTreeModel(0, conf.TreeBluePrints[0]);
model.SaveToFile(@"C:\Dev\Utopia\Setup\Output\Tree.uvm");
}
catch (Exception e)
{
MessageBox.Show(e.Message + e.StackTrace);
}
}
public void EntityGrowCheck(UtopiaTime now, GrowingEntity entity, ServerChunk chunk, Random random)
{
if (entity.LastGrowUpdate.IsZero)
{
return;
}
var checkTimeSpan = now - entity.LastGrowUpdate;
bool updated;
bool rotten;
// grow time left at the current season
var tillTheEndOfSeason = UtopiaTimeSpan.FromSeasons(1d - entity.LastGrowUpdate.TotalSeasons % 1d);
if (checkTimeSpan <= tillTheEndOfSeason)
{
// small grow update
updated = GrowSeasonLogic(entity, now.Season, checkTimeSpan, random, chunk, out rotten);
if (rotten)
{
return;
}
}
else
{
// grow at the end of the first season
updated = GrowSeasonLogic(entity, now.Season, tillTheEndOfSeason, random, chunk, out rotten);
if (rotten)
{
return;
}
// align time to the beginning of next season
checkTimeSpan -= tillTheEndOfSeason;
while (checkTimeSpan.TotalSeconds > 0)
{
var seasonCheckSpan = checkTimeSpan.TotalSeasons > 0 ? UtopiaTimeSpan.FromSeasons(1) : checkTimeSpan;
updated = GrowSeasonLogic(entity, (now - checkTimeSpan).Season, seasonCheckSpan, random, chunk, out rotten) || updated;
if (rotten)
{
return;
}
checkTimeSpan -= seasonCheckSpan;
}
}
if (updated)
{
if (entity is PlantGrowingEntity)
{
if (chunk != null)
{
chunk.Entities.RemoveById(entity.StaticId);
chunk.Entities.Add(entity);
}
}
var tree = entity as TreeGrowingEntity;
if (tree != null)
{
var treeBlueprint = _server.EntityFactory.Config.TreeBluePrintsDico[tree.TreeTypeId];
if (tree.CurrentGrowTime > treeBlueprint.GrowTime)
{
// the tree is ready
var model = VoxelModel.GenerateTreeModel(tree.TreeRndSeed, treeBlueprint);
// create tree blocks
var rootOffset = model.States[0].PartsStates[0].Translation;
var cursor = _server.LandscapeManager.GetCursor(tree.Position);
var frame = model.Frames[0];
var range = new Range3I(new Vector3I(), frame.BlockData.ChunkSize);
using (cursor.TransactionScope())
{
foreach (var position in range)
{
var value = frame.BlockData.GetBlock(position);
if (value == 0)
{
continue;
}
var blockType = value == 1 ? treeBlueprint.TrunkBlock : treeBlueprint.FoliageBlock;
var worldPos = (Vector3I)(tree.Position + rootOffset) + position;
cursor.GlobalPosition = worldPos;
if (cursor.Read() == WorldConfiguration.CubeId.Air)
{
cursor.Write(blockType);
}
}
}
// create tree soul
var soul = _server.EntityFactory.CreateEntity <TreeSoul>();
soul.Position = tree.Position;
soul.TreeRndSeed = tree.TreeRndSeed;
soul.TreeTypeId = tree.TreeTypeId;
chunk.Entities.Add(soul);
// remove the growing tree
chunk.Entities.RemoveById(tree.StaticId);
}
else
{
// just make the model bigger
tree.Scale = (float)tree.CurrentGrowTime.TotalSeconds / treeBlueprint.GrowTime.TotalSeconds;
chunk.Entities.RemoveById(tree.StaticId);
chunk.Entities.Add(tree);
}
}
}
}
private void AddVoxelEntity(EntityCollectionEventArgs e)
{
var voxelEntity = e.Entity as IVoxelEntity;
if (voxelEntity == null)
{
return; //My static entity is not a Voxel Entity => Not possible to render it so !!!
}
//Create the Voxel Model Instance for the Item
VisualVoxelModel model = null;
if (!string.IsNullOrEmpty(voxelEntity.ModelName))
{
model = _voxelModelManager.GetModel(voxelEntity.ModelName, false);
}
if (model != null && voxelEntity.ModelInstance == null) //The model blueprint is existing, and I need to create an instance of it !
{
var treeGrowing = e.Entity as TreeGrowingEntity;
if (treeGrowing != null)
{
if (treeGrowing.Scale > 0)
{
// we need to use generated voxel model
TreeBpSeed key;
key.TreeTypeId = treeGrowing.TreeTypeId;
key.TreeSeed = treeGrowing.TreeRndSeed;
VisualVoxelModel treeModel;
if (_cachedTrees.TryGetValue(key, out treeModel))
{
model = treeModel;
}
else
{
var voxelModel = VoxelModel.GenerateTreeModel(treeGrowing.TreeRndSeed,
_visualWorldParameters.WorldParameters.Configuration.TreeBluePrintsDico[
treeGrowing.TreeTypeId]);
model = new VisualVoxelModel(voxelModel, _voxelModelManager.VoxelMeshFactory);
model.BuildMesh();
_cachedTrees.Add(key, model);
}
}
}
var treeSoul = e.Entity as TreeSoul;
if (treeSoul != null)
{
TreeBpSeed key;
key.TreeTypeId = treeSoul.TreeTypeId;
key.TreeSeed = treeSoul.TreeRndSeed;
_cachedTrees.Remove(key);
}
voxelEntity.ModelInstance = new VoxelModelInstance(model.VoxelModel);
//Assign state in case of growing entity !
var growingEntity = e.Entity as PlantGrowingEntity;
if (growingEntity != null)
{
voxelEntity.ModelInstance.SetState(growingEntity.GrowLevels[growingEntity.CurrentGrowLevelIndex].ModelState);
}
var visualVoxelEntity = new VisualVoxelEntity(voxelEntity, _voxelModelManager);
//Get default world translation
Matrix instanceTranslation = Matrix.Translation(voxelEntity.Position.AsVector3());
//Apply special rotation to the creation instance
Quaternion instanceRotation = Quaternion.Identity;
if (voxelEntity is IRndYRotation && ((IRndYRotation)voxelEntity).RndRotationAroundY)
{
instanceRotation = Quaternion.RotationAxis(Vector3.UnitY, (float)(_rnd.NextDouble() * MathHelper.TwoPi));
}
else if (voxelEntity is IItem)
{
var item = voxelEntity as IItem;
instanceRotation = item.Rotation;
}
//Apply special scaling to created entity (By default all blue print are 16 times too big.
Matrix instanceScaling = Matrix.Scaling(1.0f / 16.0f);
if (treeGrowing != null && treeGrowing.Scale > 0)
{
instanceScaling = Matrix.Scaling(treeGrowing.Scale);
}
//Create the World transformation matrix for the instance.
//We take the Model instance world matrix where we add a Rotation and scaling proper to the instance
visualVoxelEntity.VoxelEntity.ModelInstance.World = instanceScaling * instanceTranslation;
visualVoxelEntity.VoxelEntity.ModelInstance.Rotation = instanceRotation;
var result = GetCube(visualVoxelEntity.VoxelEntity.Position.ToCubePosition());
if (result.IsValid)
{
visualVoxelEntity.BlockLight = result.Cube.EmissiveColor;
}
else
{
visualVoxelEntity.BlockLight = new ByteColor(255, 255, 255, 255);
}
if (visualVoxelEntity.VisualVoxelModel.Initialized == false)
{
visualVoxelEntity.VisualVoxelModel.BuildMesh();
}
if (voxelEntity.ModelInstance.CanPlay("Idle"))
{
voxelEntity.ModelInstance.Play("Idle", true);
}
lock (_syncRoot)
{
List <VisualVoxelEntity> list;
if (_visualVoxelEntities.TryGetValue(voxelEntity.ModelName, out list))
{
list.Add(visualVoxelEntity);
}
else
{
_visualVoxelEntities.Add(voxelEntity.ModelName, new List <VisualVoxelEntity> {
visualVoxelEntity
});
}
}
var lightEntity = e.Entity as ILightEmitterEntity;
if (e.AtChunkCreationTime == false && lightEntity != null)
{
//Get the Cube where is located the entity
var entityWorldPosition = lightEntity.Position;
var entityBlockPosition = new Vector3I(MathHelper.Floor(entityWorldPosition.X),
MathHelper.Floor(entityWorldPosition.Y),
MathHelper.Floor(entityWorldPosition.Z));
//new TerraCubeWithPosition(entityBlockPosition, WorldConfiguration.CubeId.Air, _visualWorldParameters.WorldParameters.Configuration),
this.UpdateOrder = 1;
var cubeRange = new Range3I
{
Position = new Vector3I(entityBlockPosition.X, 0, entityBlockPosition.Z),
Size = Vector3I.One
};
_chunkEntityImpactManager.CheckImpact(this, cubeRange);
}
}
}