public override void AddVoxel(VoxelSpace space, Vector3i index)
{
space.SetVoxel(index, new Voxel()
{
Exists = true, Orientation = Orientation, BlockType = VoxelType
});
}
protected override void DrawVoxelChange(VoxelSpace space, Vector3 hitLocation, Vector3i index)
{
if (space == null)
{
_displayGrid.GameObject.IsActive = false;
}
else
{
_displayGrid.GameObject.IsActive = true;
var displayVoxel = _displayGrid.GetVoxel(new Vector3i(0, 0, 0));
var newVoxel = new Voxel()
{
Exists = true,
BlockType = VoxelType,
Orientation = Orientation
};
if (displayVoxel != newVoxel)
{
_displayGrid.SetVoxel(new Vector3i(0, 0, 0), newVoxel);
}
var addIndex = CalculateAddIndex(space, hitLocation, index);
if (addIndex.HasValue)
{
var localPosition = addIndex.Value * space.VoxelSize;
var worldPosition = space.GameObject.Transform.GetWorld(localPosition);
_displayGrid.GameObject.Transform.Position = worldPosition;
_displayGrid.GameObject.Transform.Orientation = space.GameObject.Transform.WorldOrientation;
}
}
}
protected override void DoVoxelAction(VoxelSpace space, Vector3 hitLocation, Vector3i index)
{
space.SetVoxel(index, new Voxel()
{
Exists = false
});
}
protected override void DoVoxelAction(VoxelSpace voxels, Transform hitTransform, Vector3 hitLocation, Vector3i index)
{
voxels.SetVoxel(index, new Voxel()
{
Exists = false
});
}
private Vector3i?CalculateAddIndex(VoxelSpace space, Vector3 hitLocation, Vector3i index)
{
var size = space.VoxelSize;
var voxelLocation = index * size;
var relativeLocation = space.GameObject.Transform.GetLocal(hitLocation);
if (NearlyEqual(relativeLocation.X, voxelLocation.X))
{
return(new Vector3i(index.X - 1, index.Y, index.Z));
}
else if (NearlyEqual(relativeLocation.X, voxelLocation.X + size))
{
return(new Vector3i(index.X + 1, index.Y, index.Z));
}
else if (NearlyEqual(relativeLocation.Y, voxelLocation.Y))
{
return(new Vector3i(index.X, index.Y - 1, index.Z));
}
else if (NearlyEqual(relativeLocation.Y, voxelLocation.Y + size))
{
return(new Vector3i(index.X, index.Y + 1, index.Z));
}
else if (NearlyEqual(relativeLocation.Z, voxelLocation.Z))
{
return(new Vector3i(index.X, index.Y, index.Z - 1));
}
else if (NearlyEqual(relativeLocation.Z, voxelLocation.Z + size))
{
return(new Vector3i(index.X, index.Y, index.Z + 1));
}
else
{
return(null);
}
}
private static GameObject CreateShip(VoxelTypes types, MaterialInstance materialInstance)
{
var gridLength = 4;
var voxelSize = 1;
var voxelSpaceData = new VoxelGridData(gridLength, gridLength, gridLength, voxelSize);
voxelSpaceData[0, 0, 0] = new Voxel()
{
Exists = true
};
var voxelSpace = new VoxelSpace(new Vector3i(gridLength, gridLength, gridLength), voxelSize);
var spaceShip = new GameObject("Single Block");
spaceShip.AddComponent(voxelSpace);
spaceShip.AddComponent(new DynamicVoxelSpaceBody());
spaceShip.AddComponent(new Construct());
spaceShip.AddComponent(new ConstructFlightControl());
spaceShip.AddComponent(new ConstructVoxelSpaceExpander(types, materialInstance));
var voxelGridObj = new GameObject($"{spaceShip.Name} Voxel Grid");
voxelGridObj.AddComponent(new VoxelGrid(voxelSpaceData, new Dictionary <Vector3i, GameObject>()));
voxelGridObj.AddComponent(new VoxelMeshRenderable(types, materialInstance));
//voxelGridObj.AddComponent(new VoxelGridRenderable(types, materialInstance));
voxelSpace.Add(new Vector3i(0, 0, 0), voxelGridObj);
return(spaceShip);
}
public void Update(float time)
{
VoxelSpace space = default;
Vector3 hitLocation = default;
Vector3i spaceIndex = default;
var physicsSystem = GameObject.CurrentScene.GetSystem <PhysicsSystem>();
var handler = new FirstHitHandler(CollidableMobility.Static | CollidableMobility.Dynamic);
var forward = GameObject.Transform.Orientation.GetForwardVector();
physicsSystem.Raycast(GameObject.Transform.WorldPosition, forward, float.MaxValue, ref handler);
if (handler.Hit)
{
var t = handler.T;
object context;
if (handler.Collidable.Mobility == CollidableMobility.Dynamic)
{
context = physicsSystem.GetDynamicContext(handler.Collidable.Handle);
}
else
{
context = physicsSystem.GetStaticContext(handler.Collidable.Handle);
}
if (context is VoxelGridBody voxels)
{
hitLocation = GameObject.Transform.WorldPosition + forward * t;
space = voxels.GameObject.Parent?.GetComponent <VoxelSpace>();
if (space != null)
{
var grid = voxels.GameObject.GetComponent <VoxelGrid>();
var gridsIndex = space[grid];
if (gridsIndex.HasValue)
{
var gridIndex = voxels.GetVoxelIndex(handler.ChildIndex);
spaceIndex = gridsIndex.Value * space.GridSize + gridIndex;
}
}
}
if (context is DynamicVoxelSpaceBody voxelSpaceBody)
{
hitLocation = GameObject.Transform.Position + forward * t;
space = voxelSpaceBody.GameObject.GetComponent <VoxelSpace>();
if (space != null)
{
spaceIndex = voxelSpaceBody.GetSpaceIndex(handler.ChildIndex);
}
}
}
DrawVoxelChange(space, hitLocation, spaceIndex);
if (space != null && InputTracker.LockMouse && InputTracker.WasMouseButtonDowned(Veldrid.MouseButton.Left))
{
DoVoxelAction(space, hitLocation, spaceIndex);
}
}
protected override void DoVoxelAction(VoxelSpace space, Vector3 hitLocation, Vector3i index)
{
var addIndex = CalculateAddIndex(space, hitLocation, index);
if (addIndex.HasValue)
{
AddVoxel(space, addIndex.Value);
}
}
protected override void DoVoxelAction(VoxelSpace voxels, Transform hitTransform, Vector3 hitLocation, Vector3i index)
{
var addIndex = CalculateAddIndex(voxels, hitTransform, hitLocation, index);
if (addIndex.HasValue)
{
AddVoxel(voxels, addIndex.Value);
}
}
protected override void DrawVoxelChange(VoxelSpace voxels, Transform hitTransform, Vector3 hitLocation, Vector3i index)
{
var currentVoxel = voxels.GetVoxel(index);
if (currentVoxel.HasValue)
{
ref var displayVoxels = ref _displayGridEntity.Get <VoxelGrid>();
displayVoxels.SetVoxel(new Vector3i(0, 0, 0), currentVoxel.Value);
_displayGridEntity.Set(displayVoxels);
}
public override void AddVoxel(VoxelSpace space, Vector3i index)
{
space.SetVoxel(index, new Voxel()
{
Exists = true, Orientation = Orientation, BlockType = VoxelType
}, new Thruster()
{
Force = _force
}, new ThrusterFlame(_flameRect, true, _flameMaterial));
}
public WorldSpaceLoader(Action <Entity> setVoxelRendering, World world, Transform player, Entity voxelSpaceEntity, int loadRadius, int loadHeight, int chunkLength)
{
_setVoxelRendering = setVoxelRendering;
_world = world;
_player = player;
_voxelSpace = voxelSpaceEntity.Get <VoxelSpace>();
_voxelSpaceEntity = voxelSpaceEntity;
LoadRadius = loadRadius;
LoadHeight = loadHeight;
_chunkLength = chunkLength;
}
public WorldSpaceLoader(Action <Entity> setVoxelRendering, World world, Entity voxelSpaceEntity, int loadRadius, int loadHeight, int chunkLength)
{
_setVoxelRendering = setVoxelRendering;
_world = world;
_cameras = _world.GetEntities().With <Transform>().With <Camera>().AsSet();
_voxelSpace = voxelSpaceEntity.Get <VoxelSpace>();
_voxelSpaceEntity = voxelSpaceEntity;
LoadRadius = loadRadius;
LoadHeight = loadHeight;
_chunkLength = chunkLength;
}
public WorldSystem(GameObject player, VoxelSpace worldSpace, ChunkStorage storage, ChunkGenerator generator, int loadRadius, int chunkLength)
{
_player = player;
_worldSpace = worldSpace;
_storage = storage;
_generator = generator;
LoadRadius = loadRadius;
_chunkLength = chunkLength;
_chunkMap = new Dictionary <Vector3i, Chunk>();
_chunksToLoad = new ConcurrentQueue <Vector3i>();
_chunksToAdd = new ConcurrentQueue <Chunk>();
}
private static bool ShouldRenderSide(ref VoxelGrid grid, ref VoxelSpace space, VoxelTypes types, ushort otherType, int x, int y, int z)
{
var voxelIndex = new Vector3i(x, y, z);
if (grid.ContainsIndex(voxelIndex))
{
var voxel = grid[x, y, z];
return(!voxel.Exists || (types[voxel.BlockType].Transparent && voxel.BlockType != otherType));
}
else
{
var spaceIndex = space.GetSpaceIndexFromVoxelIndex(grid.MemberIndex, voxelIndex);
var voxel = space.GetVoxel(spaceIndex);
return(!voxel.HasValue || !voxel.Value.Exists || (types[voxel.Value.BlockType].Transparent && voxel.Value.BlockType != otherType));
}
}
/// <summary>
/// Initializes variables.
/// </summary>
public override void Init()
{
// bounding box
_boundingBox = new BoundingBox();
_boundingBox.UpdateCallbacks += OnBoundingBoxUpdate;
//get drone position from Calculator
_pointCalc = new PointCalculator();
// read shaders from files
_pointCloud = new PointCloud(RC, _boundingBox);
_voxelSpace = new VoxelSpace(RC, _boundingBox);
_dronePath = new DronePath(RC);
//Zoom Value
_zoom = 120;
// stream point cloud from text file
///*
//AssetReader.OnNewPointCallbacks += OnNewPointAdded;
//AssetReader.ReadFromAsset("PointCloud_IPM.txt");
//*/
//stream from binary via udp
PointCloudReader.OnNewPointCallbacks += OnNewPointAdded;
PointCloudReader.OnDronePositionCallbacks += OnDronePositionAdded;
// stream point cloud via udp
//UDPReceiver.OnNewPointCallbacks += OnNewPointAdded;
// UDPReceiver.OnDronePositionCallbacks += OnDronePositionAdded;
//UDPReceiver.StreamFrom(UDP_PORT);
// Set the clear color for the backbuffer
RC.ClearColor = new float4(0.95f, 0.95f, 0.95f, 1);
}
public RemoveVoxelEditingTool(Action <Entity> setVoxelRender, World world, PhysicsSystem physicsSystem, Entity entity) : base(world, physicsSystem, entity)
{
_displaySpaceEntity = world.CreateEntity();
var voxelSpace = new VoxelSpace(1, 1, _displaySpaceEntity);
_displaySpaceEntity.Set(voxelSpace);
var spaceTransform = new Transform();
_displaySpaceEntity.Set(spaceTransform);
_displayGridEntity = world.CreateEntity();
_displayGridEntity.Set(new LightVertexResources());
_displayGridEntity.Set(new VoxelGrid(1, 1, voxelSpace, Vector3i.Zero));
voxelSpace[Vector3i.Zero] = _displayGridEntity;
setVoxelRender(_displayGridEntity);
var gridTransform = new Transform();
spaceTransform.AddChild(gridTransform);
_displayGridEntity.Set(gridTransform);
_displayGridEntity.Disable();
}
protected abstract void DoVoxelAction(VoxelSpace space, Vector3 hitLocation, Vector3i index);
protected override void DrawVoxelChange(VoxelSpace voxelSpace, Transform hitTransform, Vector3 hitLocation, Vector3i index)
{
ref var displayVoxels = ref _displayGridEntity.Get <VoxelGrid>();
public abstract void AddVoxel(VoxelSpace space, Vector3i index);
static void Main(string[] args)
{
WindowCreateInfo wci = new WindowCreateInfo
{
X = 100,
Y = 100,
WindowWidth = 1280,
WindowHeight = 720,
WindowTitle = "Tortuga Demo"
};
GraphicsDeviceOptions options = new GraphicsDeviceOptions(
debug: false,
swapchainDepthFormat: PixelFormat.R16_UNorm,
syncToVerticalBlank: true,
resourceBindingModel: ResourceBindingModel.Improved,
preferDepthRangeZeroToOne: true,
preferStandardClipSpaceYDirection: true);
#if DEBUG
options.Debug = true;
#endif
var scene = new Scene();
var types = new VoxelTypes(new[]
{
new VoxelType(
"DarkStone",
new Vector2(390, 1690),
new Vector2(390, 1690),
new Vector2(390, 1690)),
new VoxelType(
"Metal",
new Vector2(650, 1300),
new Vector2(650, 1300),
new Vector2(650, 1300)),
new VoxelType(
"Thruster",
new Vector2(650, 1170),
new Vector2(650, 1300),
new Vector2(650, 1300))
});
var resourceLoader = new ResourceLoader();
var voxelTexturesResource = resourceLoader.LoadImage("Assets\\spritesheet_tiles.png");
var mesh3dMaterial = new Material(Mesh3d.VertexCode, Mesh3d.FragmentCode);
var voxelMaterialInstance = new MaterialInstance(mesh3dMaterial, voxelTexturesResource, new ObjectProperties()
{
Colour = RgbaFloat.White
});
var noCullingMaterial = new Material(Mesh3d.VertexCode, Mesh3d.UnlitFragmentCode, true);
var noCullingVoxelMaterial = new MaterialInstance(noCullingMaterial, voxelTexturesResource, new ObjectProperties()
{
Colour = RgbaFloat.White
});
//var cross = QuadCrossFactory.Build(new Rectangle(390, 130, 128, 128), true, noCullingVoxelMaterial);
//cross.Name = "Cross";
//scene.AddGameObject(cross);
var tools = new Tool[]
{
new RemoveVoxelEditingTool()
{
Name = "Remove"
},
new BasicVoxelAddingTool("DarkStone", 0, types, voxelMaterialInstance),
new BasicVoxelAddingTool("Metal", 1, types, voxelMaterialInstance),
new ThrusterVoxelEditingTool(new Rectangle(390, 130, 128, 128), noCullingVoxelMaterial, 2, types, voxelMaterialInstance)
{
Name = "Thruster"
}
};
var px = Image.Load("Assets\\skybox_px.png");
var nx = Image.Load("Assets\\skybox_nx.png");
var py = Image.Load("Assets\\skybox_py.png");
var ny = Image.Load("Assets\\skybox_ny.png");
var pz = Image.Load("Assets\\skybox_pz.png");
var nz = Image.Load("Assets\\skybox_nz.png");
var camera = new GameObject("Player");
camera.Transform.Position = new Vector3(0, 0, 3);
camera.AddComponent(new Camera());
camera.AddComponent(new Character());
camera.AddComponent(new CharacterInput());
camera.AddComponent(new ComponentSwitcher(tools));
//camera.AddComponent(new EditorMenu());
//camera.AddComponent(new Inspector());
//camera.AddComponent(new Clunker.Editor.Console.Console());
camera.AddComponent(new Skybox(px, nx, py, ny, pz, nz));
scene.AddGameObject(camera);
var ship = CreateShip(types, voxelMaterialInstance);
scene.AddGameObject(ship);
//camera.AddComponent(new ObjectFollower() { ToFollow = ship, Distance = new Vector3(0.5f, 1, 6) });
var chunkSize = 32;
var worldSpaceObj = new GameObject("World Space");
var worldSpace = new VoxelSpace(new Vector3i(chunkSize, chunkSize, chunkSize), 1);
worldSpaceObj.AddComponent(worldSpace);
scene.AddGameObject(worldSpaceObj);
var worldSystem = new WorldSystem(
camera,
worldSpace,
new ChunkStorage(),
new ChunkGenerator(types, voxelMaterialInstance, chunkSize, 1),
10, chunkSize);
scene.AddSystem(worldSystem);
scene.AddSystem(new PhysicsSystem());
var app = new ClunkerApp(resourceLoader, scene);
app.Start(wci, options).Wait();
}
protected override void DrawVoxelChange(VoxelSpace space, Vector3 hitLocation, Vector3i index)
{
}
protected abstract void DrawVoxelChange(VoxelSpace space, Vector3 hitLocation, Vector3i index);
