public ChordObject DouplicateChordObject(ChordObject chordObj, List <ChordObject> chordObjects)
{
// 0. Refs
var fields = Player.inst.curFieldSet;
var ID = chordObj.fieldID;
var parent = MeshRef.inst.recordObj_parent;
var material = MeshRef.inst.recordObjs_mat[chordObj.trackLayer];
var pos = Recorder.inst.NextLoopPosition(chordObj.sequencer, chordObj.start);
var layer = 8;
var visible = true;
var collider = true;
var tag = MeshRef.inst.chordObjTag;
// 1. Instantiate & scale!
var newObj = MeshCreation.CreateLaneSurface(fields, ID, "ChordObject", parent, material, visible, collider, tag, 1f, layer).gameObject;
newObj.transform.localScale = chordObj.obj.transform.localScale;
var douplicateObj = ChordObject.Create(newObj, null, pos, ID, chordObj.notes, chordObj.sequencer, chordObj.trackLayer, chordObj.start, chordObj.end, chordObj.loopStart, chordObj.loopEnd_extended);
// 2. Set data
chordObj.douplicate = douplicateObj;
chordObj.hasRespawned = true;
// 3. Add to list
chordObjects.Add(douplicateObj);
return(douplicateObj);
}
public override void _Ready()
{
maze = new Maze(ShapeGeometry.MakePolygon(6, 21, (float)Math.PI / 2),
new Vector2(-21, -21), new Vector2(21, 21));
//maze = new Maze(ShapeGeometry.MakeStar(12, 21, (float)Math.PI / 2), new Vector2(-21, -21), new Vector2(21, 21));
//Draw cells to single mesh and apply to screen
var surfTool = MeshCreation.CreateSurfaceTool();
var walls = maze.GetWalls();
foreach (var wall in walls)
{
if (!wall.KnockedDown)
{
MeshCreation.AddWall(surfTool, new Vector3(wall.GetPoint1X(), 0.0f, wall.GetPoint1Y()),
new Vector3(wall.GetPoint2X(), 0.0f, wall.GetPoint2Y()), 0.1f, 2.0f);
}
}
this.AddChild(MeshCreation.CreateMeshInstanceFromMesh(MeshCreation.CreateMeshFromSurfaceTool(surfTool)));
//Put players at start
KinematicBody player = (KinematicBody)this.GetParent().GetNode("player");
var startingCell = maze.GetStartingCell();
player.SetTranslation(new Vector3(startingCell.X, 0.0f, startingCell.Y));
//Put flag at end
Spatial flag = (Spatial)this.GetParent().GetNode("Flag");
var endingCell = maze.GetEndingCell();
flag.SetTranslation(new Vector3(endingCell.X, 0.0f, endingCell.Y));
}
// ------------------------------ Public functions ------------------------------
/// <summary>
/// Instantiate 2 lane surfaces (current chord, looped chord) from recording-data and keep scaling it by a coroutine upwards from zero until stopped. Writes into recording (!).
/// </summary>
/// <param name="recording">Recording data.</param>
/// <param name="chordObjects">List to add the new chord objects.</param>
public void CreateChordObjectTwice(Recording recording, List <ChordObject>[] chordObjects, int trackLayer)
{
// 0. Refs
var fields = Player.inst.curFieldSet;
var ID = recording.fieldID;
var parent = MeshRef.inst.recordObj_parent;
var material = MeshRef.inst.recordObjs_mat[trackLayer];
var pos1 = Player.inst.transform.position;
var pos2 = Recorder.inst.NextLoopPosition(recording.sequencer, recording.start);
var layer1 = LayerMask.NameToLayer(MeshRef.inst.highlightSurfaces_layer);
var renderQueue1 = MeshRef.inst.highlightSurfaces_renderQueue + 1;
var layer2 = LayerMask.NameToLayer(MeshRef.inst.recordLayer);
//var layer = 8;
var collider = true;
var visible = true;
var tag = MeshRef.inst.chordObjTag;
// 1. Instantiate
var obj1 = MeshCreation.CreateLaneSurface(fields, ID, "ChordObject", parent, material, visible, collider, tag, 1f, layer1, renderQueue1).gameObject;
var obj2 = MeshCreation.CreateLaneSurface(fields, ID, "ChordObject", parent, material, visible, collider, tag, 1f, layer2).gameObject;
var recordObject2 = ChordObject.Create(obj2, null, pos2, ID, recording.notes, recording.sequencer, trackLayer, recording.start, recording.end, recording.loopStart, recording.loopEnd_extended);
var recordObject1 = ChordObject.Create(obj1, recordObject2, pos1, ID, recording.notes, recording.sequencer, trackLayer, recording.start, recording.end, recording.loopStart, recording.loopEnd_extended);
recordObject1.hasRespawned = true;
// 2. Add to list
chordObjects[trackLayer].Add(recordObject1);
chordObjects[trackLayer].Add(recordObject2);
// 3. Edit recording / Start scaling
recording.obj = recordObject1; // Nur für scaling-coroutine
recording.loopObj = recordObject2; // Nur für scaling-coroutine
recording.scaleRoutine = StartCoroutine(ScaleChordObject(recordObject1, recordObject2));
}
IEnumerator Start()
{
inst = this;
var cursorOffset = new Vector2(MeshRef.inst.mouse.width / 2, MeshRef.inst.mouse.height / 2);
Cursor.SetCursor(MeshRef.inst.mouse, cursorOffset, CursorMode.Auto);
// Wait (cause raycasts wouldnt hit any collider)
yield return(new WaitForFixedUpdate()); yield return(new WaitForEndOfFrame());
// 1. Create all meshes
MeshCreation.CreateAll();
// 2. Fill fields with last content (chords & colors)
LoopData.Init();
#region hack: isNotSpawning = false
for (int i = 0; i < TunnelData.fields.Length; i++)
{
Player.inst.curFieldSet[i].isNotSpawning = false;
}
#endregion
// EVENTS
MusicRef.inst.beatSequencer.beatEvent.AddListener(MusicManager.inst.OnBeat);
MusicRef.inst.beatSequencer.beatEvent.AddListener(MusicManager.inst.OnVeryFirstBeats);
GameEvents.inst.onVeryFirstBeat += OnVeryFirstBeat;
GameEvents.inst.onVerySecondBeat += OnVerySecondBeat;
GameEvents.inst.onPlayPerformed += VisualController.inst.OnPlayField_byInput;
GameEvents.inst.onPlayCanceled += VisualController.inst.OnStopfield_byInput;
GameEvents.inst.onChangeField += VisualController.inst.OnFieldChange;
GameEvents.inst.onMouseInside += VisualController.inst.OnMouseInside;
GameEvents.inst.onMouseOutside += VisualController.inst.OnMouseOutside;
GameEvents.inst.onScreenResize += CameraOps.PanCamera;
// Music-related
GameEvents.inst.onPlayPerformed += MusicManager.inst.OnFieldStart;
GameEvents.inst.onChangeField += MusicManager.inst.OnFieldChange;
GameEvents.inst.onPlayCanceled += MusicManager.inst.OnFieldLeave;
GameEvents.inst.onScreenResize?.Invoke(); // Hack
yield return(null);
}
public void FitEdge(ref Mesh mesh, Polyline pts, double tol)
{
MeshCreation mc = new MeshCreation();
List <int> index = mc.MeshEdgeVerticeIndex(mesh);
for (int i = 0; i < index.Count; i++)
{
Point3d pt = mesh.Vertices[index[i]];
int sign = 0; double dist = double.MaxValue;
for (int j = 0; j < pts.Count; j++)
{
double t = pts[j].DistanceTo(pt);
if (t < dist)
{
dist = t; sign = j;
}
}
mesh.Vertices.SetVertex(index[i], pts[sign]);
}
for (int i = 0; i < mesh.Vertices.Count; i++)
{
Point3d pt = mesh.Vertices[i];
int sign = 0; double dist = double.MaxValue;
for (int j = 0; j < pts.Count; j++)
{
double t = pts[j].DistanceTo(pt);
if (t < dist)
{
dist = t; sign = j;
}
}
if (dist < tol)
{
mesh.Vertices.SetVertex(i, pts[sign]);
}
}
}
public MeshConvert()
{
mc = new MeshCreation();
}
// Creates a wire mesh and places the spheres to make sure the tile is aligned.
private void CreateMeshForTile(Tile tile, float sphereScale)
{
//Get tile center point
decimal tileCenterX = 0;
decimal tileCenterY = 0;
decimal tileCenterZ = 0;
List <Point> points = tile.boundary;
//Calculate the average center point and polygon side length.
foreach (Point point in points)
{
tileCenterX += point.x / points.Count;
tileCenterY += point.y / points.Count;
tileCenterZ += point.z / points.Count;
}
//Create the center point
var tileCenterPoint = new Vector3((float)tileCenterX, (float)tileCenterY, (float)tileCenterZ);
if (points.Count == 5)
{
tileCenterPoint = tileCenterPoint + (tileCenterPoint.Normalized() * 6);
}
GD.Print(tileCenterPoint);
//Create surface tool
var material = new SpatialMaterial();
//material.SetEmission(new Color(1.0f, 0.0f, 0.0f));
//material.SetEmissionEnergy(0.5f);
material.SetAlbedo(new Color(0.0f, 0.0f, 0.0f));
//material.SetMetallic(0.5f);
material.SetCullMode(SpatialMaterial.CullMode.Back);
var surfaceTool = MeshCreation.CreateSurfaceTool(material);
//Make triangles for polygon
for (var index = 0; index < points.Count; index++)
{
var point = new Vector3((float)points[index].x, (float)points[index].y, (float)points[index].z);
Vector3 nextPoint;
if (index < points.Count - 1)
{
nextPoint = new Vector3((float)points[index + 1].x, (float)points[index + 1].y, (float)points[index + 1].z);
}
else
{
nextPoint = new Vector3((float)points[0].x, (float)points[0].y, (float)points[0].z);
}
if (points.Count == 5)
{
point = point + (point.Normalized() * 6);
nextPoint = nextPoint + (nextPoint.Normalized() * 6);
}
MeshCreation.AddTriangle(surfaceTool, point, nextPoint, tileCenterPoint, true);
}
//Add to scene
var meshInstance = MeshCreation.CreateMeshInstanceFromMesh(MeshCreation.CreateMeshFromSurfaceTool(surfaceTool));
this.AddChild(meshInstance);
/*
* var surfTool = new SurfaceTool();
* var mesh = new ArrayMesh();
* var material = new SpatialMaterial();
* material.SetEmission(new Color(1.0f, 0.0f, 0.0f));
* material.SetAlbedo(new Color(1.0f, 0.0f, 0.0f));
* surfTool.Begin(Mesh.PrimitiveType.TriangleStrip);
* //LineLoop - Nothing
* //Lines - Nothing
* //LineStrip - Nothing
* //Points - Nothing
* //TriangleFan - Nothing
* //Triangles - Nothing
* //TriangleStrip - Nothing
* surfTool.SetMaterial(material);
* decimal tileCenterX = 0;
* decimal tileCenterY = 0;
* decimal tileCenterZ = 0;
* decimal polygonRadius = 0;
*
* List<Point> points = tile.boundary;
* var lastPoint = points[points.Count - 1];
* Vector3 lastPointVector = new Vector3((float)lastPoint.x, (float)lastPoint.y, (float)lastPoint.z);
* decimal polygonSideLength = 0;
* foreach (Point point in points) {
* surfTool.AddUv(new Vector2(0, 0));
* surfTool.AddVertex(new Vector3((float)point.x, (float)point.y, (float)point.z));
*
* tileCenterX += point.x / points.Count;
* tileCenterY += point.y / points.Count;
* tileCenterZ += point.z / points.Count;
* Vector3 currentVector = new Vector3((float)point.x, (float)point.y, (float)point.z);
* polygonSideLength += (decimal)currentVector.DistanceTo(lastPointVector);
* lastPointVector = currentVector;
* }
* polygonSideLength = polygonSideLength / points.Count;
*
* var tileCenterPoint = new Vector3((float)tileCenterX, (float)tileCenterY, (float)tileCenterZ);
* var firstPoint = new Vector3((float)points[0].x, (float)points[0].y, (float)points[0].z);
*
* foreach (Point point in points)
* {
* var vector = new Vector3((float) point.x, (float)point.y, (float)point.z);
* polygonRadius += (decimal)vector.DistanceTo(tileCenterPoint);
* }
* polygonRadius = polygonRadius / points.Count;
*
* var polygonRotation = firstPoint.AngleTo(tileCenterPoint);
*
*
* var sphereCenterPoint = new Vector3(0f, 0f, 0f);
*
* MeshInstance sphere = (MeshInstance)blueSphereMeshScene.Instance();
* sphere.SetTranslation(tileCenterPoint);
* sphere.SetScale(new Vector3(sphereScale, sphereScale, sphereScale));
* this.AddChild(sphere);
*
* MeshInstance sphere2 = (MeshInstance)greenSphereMeshScene.Instance();
* sphere2.SetTranslation(firstPoint);
* sphere2.SetScale(new Vector3(sphereScale, sphereScale, sphereScale));
* this.AddChild(sphere2);
*
* MeshInstance sphere3 = (MeshInstance)greenSphereMeshScene.Instance();
* sphere3.SetTranslation((firstPoint - tileCenterPoint) / 2 + tileCenterPoint);
* sphere3.SetScale(new Vector3(sphereScale, sphereScale, sphereScale));
* this.AddChild(sphere3);
*
* surfTool.GenerateNormals();
* surfTool.Index();
* surfTool.Commit(mesh);
* var meshInstance = new MeshInstance();
* meshInstance.SetMesh(mesh);
* meshInstance.CreateTrimeshCollision();
* this.AddChild(meshInstance);
*/
}
