/// <summary>
/// Load initial resources.
/// </summary>
public virtual void LoadResources()
{
// - Loads essential shaders
ShaderManager.LoadShader <DefaultShader>();
var Rectangle = VertexManager.Alloc(4);
Rectangle[0] = new VertexData(new Vector3(-0.5F, -0.5F, 0F), Color4.Black);
Rectangle[1] = new VertexData(new Vector3(0.5F, -0.5F, 0F), Color4.Black);
Rectangle[2] = new VertexData(new Vector3(0.5F, 0.5F, 0F), Color4.Black);
Rectangle[3] = new VertexData(new Vector3(-0.5F, 0.5F, 0F), Color4.Black);
Rectangle.Invalidate();
var Indexes = IndexManager.Alloc(6);
Indexes[0] = 0;
Indexes[1] = 1;
Indexes[2] = 2;
Indexes[3] = 2;
Indexes[4] = 3;
Indexes[5] = 0;
Indexes.Invalidate();
}
//Method used to add a new line renderer vertex and a new vertex sphere.
public GameObject addVertex(Vector3 pos, int vertexID, GameObject selectedVertex)
{
pos = rotateVertex(pos, -getLocalRotation());
//Get the vertex spheres that are children of this object
List <GameObject> children = getChildrenVertices();
//Add the selected vertex to that list (as it won't be a child of the object if it's selected), and sort the list.
if (selectedVertex)
{
children.Add(selectedVertex);
}
children.Sort(sortByVertexID);
//for loop to go through each vertex and update it's vertexID if it's PAST the selected vertex
foreach (GameObject child in children)
{
VertexManager childsVM = child.GetComponent <VertexManager>();
if (childsVM.getVertexID() >= vertexID)
{
childsVM.setVertexID(childsVM.getVertexID() + 1);
}
}
//create a new vertex sphere
GameObject newVert = drawVert(pos, vertexID, false);
VertexManager newVertsVM = newVert.GetComponent <VertexManager>();
//make the new vertex's size and "length" field equal to the one currently selected
if (selectedVertex)
{
newVert.transform.localScale = selectedVertex.transform.lossyScale;
newVertsVM.setVertexLength(selectedVertex.GetComponent <VertexManager>().getVertexLength());
}
//add this new vertex to the dictionary of vertexmanagers with its current timing
timingDict[newVertsVM.getVertexTiming()].Add(newVertsVM);
//add this new vertex to the list of children, and sort the list again.
children.Add(newVert);
children.Sort(sortByVertexID);
//create a Vector3[] to hold the positions that the line renderer will be set to.
Vector3[] finalPositions = new Vector3[children.Count];
//translate the position of every child and add it to finalPositions.
for (int i = 0; i < children.Count; i++)
{
Vector3 tempPos = children[i].transform.position;
tempPos = rotateVertex(tempPos, -getLocalRotation());
//tempPos = vertexRotationTwo(tempPos, localRotation+270, i);
finalPositions[i] = tempPos;
}
//create a new vertex on the line renderer and set it's positions to finalPositions.
attachedLR.positionCount += 1;
attachedLR.SetPositions(finalPositions);
boxColliderManager.addBoxCollider(vertexID);
return(newVert);
}
//method called when user wants to remove the vertex currently being held from the game.
public void removeVertex()
{
//if statement to check whether a vertex is currently being held:
if (!currentRigidBody)
{
//if no held vertex, try to remove one that may be being hovered over.
GameObject nearestVertex = hoverOverVertex();
if (nearestVertex)
{
nearestVertex.transform.parent = gameObject.transform;
VertexManager nearestVertexManager = nearestVertex.GetComponent <VertexManager>();
nearestVertexManager.getParentsLineManager().removeVertex(nearestVertex.transform.position, nearestVertexManager.getVertexID(), nearestVertex);
resetVariables();
}
}
else if (isEditable(currentVertexManager.getVertexID(), currentVertexManager.getBaseLineParent().gameObject))
{
//if statement won't be entered if the id of the vertex being held is 1 (because that vertex is needed)
currentVertexManager.getParentsLineManager().removeVertex(transform.position, currentVertexManager.getVertexID(), currentGameObject);
resetVariables();
}
else
{
return;
}
}
/// <summary>
/// Initialize the graphic library.
/// </summary>
public override void Initialize()
{
base.Initialize();
// - Create a Vulkan instance, this instance must be alive during all the game execution
Library.Initialize(TargetSurface);
// - Makes a new device manager
PhysicalDevice.Initialize(TargetSurface);
// - Initialize the physical device on this drawing area
GraphicDevice.Initialize();
// - Initialize index and vert manager
VertexManager.Setup();
IndexManager.Setup();
// - Makes syncronization semaphores and fances CPU<->GPU
for (int i = 0; i < MaxFrameInFlight; ++i)
{
CommandBuffers.Add(null);
Commands.Add(GraphicDevice.Handle.CreateCommandPool(GraphicDevice.GraphicQueueIndex, CommandPoolCreateFlags.ResetCommandBuffer));
ImageAvailableSemaphores.Add(GraphicDevice.Handle.CreateSemaphore());
RenderFinishedSemaphores.Add(GraphicDevice.Handle.CreateSemaphore());
InFlightFences.Add(GraphicDevice.Handle.CreateFence(FenceCreateFlags.Signaled));
}
}
/// <summary>
/// This call configure the graphic library for the new device instance.
/// </summary>
public override void InvalidateDevice()
{
base.InvalidateDevice();
// - Wait the GPU (we must operate only when GPU is idle)
GraphicDevice.Handle.WaitIdle();
// - Dispose render pass
DefaultRenderPass.Dispose();
// - Dispose the pipeline
Pipeline.Dispose();
// - Dipose current swapchain
Swapchain.Dispose();
// - Dispose current VK surface
DrawingSurface.Dispose();
// - Dispose vertex and index managers
VertexManager.Dispose();
IndexManager.Dispose();
// - Release all VK shaders
ShaderManager.Dispose();
for (int i = 0; i < MaxFrameInFlight; ++i)
{
if (CommandBuffers[i] != null)
{
foreach (var buffer in CommandBuffers[i])
{
buffer.Reset();
}
Commands[i].FreeCommandBuffers(CommandBuffers[i]);
}
}
foreach (Fence fence in InFlightFences)
{
fence.Destroy();
}
foreach (Semaphore sem in ImageAvailableSemaphores)
{
sem.Destroy();
}
foreach (Semaphore sem in RenderFinishedSemaphores)
{
sem.Destroy();
}
// - Dispose device
GraphicDevice.Dispose();
// - Initialize device
Initialize();
// - Reconfigure the renderer
ConfigureRendering();
}
//the main method for this script, used to go through all vertices (spheres) in the environment and update their positions
private void getVertexStats()
{
//get all vertices (spheres)
allVertices = GameObject.FindGameObjectsWithTag("Vertex");
foreach (GameObject vertex in allVertices)
{
//get each vertexManager attached to current vertex (sphere)
vertexManager = vertex.GetComponent <VertexManager>();
//Set the vector variables according to the vertice (sphere) position. To do maths on later.
xVector.Set(vertex.transform.position.x, 0f, 0f);
yVector.Set(0f, vertex.transform.position.y, 0f);
zVector.Set(0f, 0f, vertex.transform.position.z);
//calculate the distance between the vertices (sphere) x, y, and z cords from the center.
xDist = Vector3.Distance(gameObject.transform.position, xVector);
yDist = Vector3.Distance(gameObject.transform.position, yVector);
zDist = Vector3.Distance(gameObject.transform.position, zVector);
if (vertexManager != null && vertexManager.getVertexID() != 0 && vertexManager.getVertexID() != vertexManager.getParentsLineManager().getNumberOfVertices() - 1)
{
//setting vertex volume by passing x^2 + z^2 to convert volume
vertexManager.setVertexVolume(convertVolume((xDist * xDist) + (zDist * zDist)));
//setting vertex timing by passing y distance.
vertexManager.setVertexTiming(convertTiming(vertex.transform.position.y));
//calling calculateAngle with the vertices (sphere) x and z cordinates, and then setting the vertices note accordingly.
float vertexAngle = calculateAngle(vertexManager.transform.position.x, vertexManager.transform.position.z);
vertexManager.setVertexAngle(vertexAngle);
vertexManager.setVertexNote(convertAngle(vertexAngle));
}
}
}
/// <summary>
/// Implement IDisposable.
/// </summary>
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
GraphicDevice.Handle.WaitForFences(InFlightFences.ToArray(), true, UInt64.MaxValue);
// - Wait the GPU (we must operate only when GPU is idle)
GraphicDevice.Handle.WaitIdle();
// - Dispose render pass
DefaultRenderPass.Dispose();
// - Dispose the pipeline
Pipeline.Dispose();
// - Dipose current swapchain
Swapchain.Dispose();
// - Dispose vertex and index managers
VertexManager.Dispose();
IndexManager.Dispose();
// - Release all VK shaders
ShaderManager.Dispose();
for (int i = 0; i < MaxFrameInFlight; ++i)
{
if (CommandBuffers[i] != null)
{
foreach (var buffer in CommandBuffers[i])
{
buffer.Reset();
}
}
}
foreach (CommandPool pool in Commands)
{
pool?.Destroy();
}
foreach (Fence fence in InFlightFences)
{
fence?.Destroy();
}
foreach (Semaphore sem in ImageAvailableSemaphores)
{
sem?.Destroy();
}
foreach (Semaphore sem in RenderFinishedSemaphores)
{
sem?.Destroy();
}
// - Dispose device
GraphicDevice.Dispose();
// - Dispose vulkan
Library.Dispose();
}
//method used when letting go of an object (either voluntarily or forced)
private void resetVariables()
{
fixedJoint.connectedBody = null;
currentRigidBody = null;
currentVertexManager = null;
currentGameObject = null;
hoveringBoxColliders = new List <GameObject>();
}
/// <summary>
/// 破棄します。
/// </summary>
protected override void DisposeResource()
{
if (vertexManager != null)
{
vertexManager.Dispose();
vertexManager = null;
}
}
protected override void Awake()
{
base.Awake();
_name = "Planète Twippie";
_planetManager = PlanetManager.Instance;
_planetManager.Add(this);
_vertexManager = GetComponent <VertexManager>();
_twippieManager = TwippieManager.Instance;
}
private void SetVertexColours()
{
// Pass colours to vertexManagers
for (int i = 0; i < m_numMeshes; i++)
{
VertexManager vm = m_VertexManagers[i];
int meshVertCount = vm.m_VertexIDs.Count * 4;
vm.SetMeshCols(m_VertexColours.GetRange(MaxVertIndexPerMesh * i * 4, meshVertCount));
//VertexManager vmOutline = m_OutlineVertexManagers[i];
//vmOutline.SetMeshCols(m_OutlineColours.GetRange(MaxVertIndexPerMesh * i * 4, meshVertCount));
}
}
//Method used to remove a vertex from a line and return it back to the pool
public void removeVertex(Vector3 pos, int vertexID, GameObject selectedVertex)
{
boxColliderManager.removeBoxCollider(vertexID);
//if statement to detect whether the vertex being removed is the last in the line.
if (vertexID == attachedLR.positionCount - 1)
{
//Lower the position count by 1 and return the object to the pool.
attachedLR.positionCount -= 1;
timingDict[selectedVertex.GetComponent <VertexManager>().getVertexTiming()].Remove(selectedVertex.GetComponent <VertexManager>());
objectPooler.returnToPool("Vertex", selectedVertex);
}
else
{
//removing a vertex from the middle of a list
//get the children of the lineBase and sort them
List <GameObject> children = getChildrenVertices();
children.Sort(sortByVertexID);
//go through each vertex sphere that is a child of lineBase and lower it's vertexID by 1 if it is past the vertex being removed.
foreach (GameObject child in children)
{
VertexManager childsVM = child.GetComponent <VertexManager>();
if (childsVM.getVertexID() >= vertexID)
{
childsVM.setVertexID(childsVM.getVertexID() - 1);
}
}
//Translate the vector3 pos to take into account the position of the baseline object.
pos = rotateVertex(pos, -getLocalRotation());
//create a list of final positions that the line renderer vertices will be set too
Vector3[] finalPositions = new Vector3[children.Count];
for (int i = 0; i < children.Count; i++)
{
Vector3 tempPos = children[i].transform.position;
tempPos = rotateVertex(tempPos, -getLocalRotation());
finalPositions[i] = tempPos;
}
//lower the number of vertices in the line renderer by 1, and set the remaining vertices to finalPositions
attachedLR.positionCount -= 1;
timingDict[selectedVertex.GetComponent <VertexManager>().getVertexTiming()].Remove(selectedVertex.GetComponent <VertexManager>());
attachedLR.SetPositions(finalPositions);
//return the removed vertex sphere back to the pool
objectPooler.returnToPool("Vertex", selectedVertex);
}
}
protected override void Awake()
{
base.Awake();
_objectManager = ObjetManager.Instance;
_zoneManager = ZoneManager.Instance;
_vertexManager = VertexManager.Instance;
_transform = transform;
VerticeIds = new List <Guid>();
NeighbourIds = new List <Guid>();
PathCosts = new Dictionary <Guid, PathCost>();
Resources = new List <Resource>();
TwippieIds = new List <Guid>();
Col = UnityEngine.Random.ColorHSV();
}
//remove this method???
private Vector3 tetherToPoint(VertexManager vm, Vector3 currentPos)
{
float volume = vm.getVertexVolume();
if (!vm.getParentsLineManager().checkIfTetheredForXZ(currentGameObject))
{
return(currentPos);
}
else
{
float m = (currentPos.z / currentPos.x);
float newX = (0.815f / (Mathf.Sqrt(Mathf.Pow(m, 2) + 1)));
float newZ = newX * m;
currentPos.Set(newX, currentPos.y, newZ);
return(currentPos);
//return currentPos.normalized*0.815f;
}
}
//Method used to call drawVert(...) multiple time with the given Vector3[] of vertices
private void drawVerts(Vector3[] currentVerts)
{
int vertexID = 0;
foreach (var vert in currentVerts)
{
VertexManager newVert = drawVert(vert, vertexID, true).GetComponent <VertexManager>();
if (vertexID == 0)
{
newVert.setVertexTiming(-1);
}
else if (vertexID == getNumberOfVertices() - 1)
{
newVert.setVertexTiming(GridManager.getYSegments());
}
vertexID++;
}
}
//method to see whether a vertex is currently close enough to the controller to be considered "hovering over"
public GameObject hoverOverVertex()
{
if (GetNearestRigidBody())
{
GameObject nearestVertex = GetNearestRigidBody().gameObject;
Vector3 nearestVertexVector = nearestVertex.transform.position;
if (Vector3.Distance(transform.position, nearestVertexVector) < 0.1f)
{
//is within range
VertexManager nearestVertexManager = nearestVertex.GetComponent <VertexManager>();
if (isEditable(nearestVertexManager.getVertexID(), nearestVertexManager.getBaseLineParent().gameObject))
{
//is "editable"
return(nearestVertex);
}
}
}
return(null);
}
//method that is called when the controller should pick up the nearest rigid body
public void pickUp()
{
currentRigidBody = GetNearestRigidBody();
if (!currentRigidBody)
{
return;
}
else
{
//if statement checking the id of the vertex:
if (currentRigidBody.GetComponent <VertexManager>().getBaseLineParent().GetComponent <LineManager>().getNumberOfVertices() - 1 == currentRigidBody.GetComponent <VertexManager>().getVertexID())
{
//if the id is the last in the line, cycle the voice of the line
currentRigidBody.GetComponent <VertexManager>().getParentsLineManager().cycleVoices();
resetVariables();
}
else
{
//set current-XYZ variables
currentGameObject = currentRigidBody.gameObject;
currentVertexManager = currentRigidBody.GetComponent <VertexManager>();
currentVertexManager.setIsSelected(true);
Vector3 oldPos = currentGameObject.transform.position;
//set the rigidBody parent and position to the controller holding it.
currentRigidBody.transform.parent = gameObject.transform;
currentRigidBody.transform.position = transform.position;
fixedJoint.connectedBody = currentRigidBody;
currentVertexManager.onPickUp();
//if statement to check whether the id of the vertex is editable, if it isn't, act as if a new vertex should be made:
if (!isEditable(currentVertexManager.getVertexID(), currentVertexManager.getBaseLineParent().gameObject))
{
VertexManager newlyCreatedVertexManager = addNewVertex().GetComponent <VertexManager>();
newlyCreatedVertexManager.moveTo(oldPos);
}
}
}
}
//method used to check if the current held vertex is going too low, too far from center, or too close to center.
private void outOfBoundsCheck()
{
bool outOfBounds = false;
int r = 4;
Vector3 pos = transform.position;
float currentX = pos.x;
float currentY = pos.y;
float currentZ = pos.z;
VertexManager tempVertexManager = currentVertexManager;
if (currentY <= 0.1)
{
//pos.Set(pos.x, 0.15f, pos.z);
//letGo();
//currentVertexManager.moveTo(pos);
outOfBounds = true;
}
else if (Mathf.Sqrt(Mathf.Pow(currentX, 2) + Mathf.Pow(currentZ, 2)) > r)
{
float m = (currentZ / currentX);
float newX = ((r - 0.01f) / (Mathf.Sqrt(Mathf.Pow(m, 2) + 1)));
float newZ = newX * m;
pos.Set(newX, currentY, newZ);
//letGo();
tempVertexManager.moveTo(pos);
outOfBounds = true;
//return;
}
else if (checkSiblingHeights() != transform.position.y)
{
pos.y = checkSiblingHeights();
tempVertexManager.moveTo(pos);
outOfBounds = true;
}
if (!outOfBounds)
{
Vector3 tempPos = transform.position;
tempVertexManager.moveTo(tempPos);
}
}
//simple method for changing a hovered over vertices timing and y cordindate
public void moveVertexDown()
{
GameObject nearestVertex = hoverOverVertex();
if (nearestVertex)
{
VertexManager nearestVertexManager = nearestVertex.GetComponent <VertexManager>();
float nearestVertexTiming = nearestVertexManager.getVertexTiming();
float lowerSiblingY;
float lowerSiblingTiming;
nearestVertexManager.getLowerVertex(out lowerSiblingY, out lowerSiblingTiming);
if (nearestVertexTiming <= GridManager.getYSegments() - 1 && nearestVertexTiming < lowerSiblingTiming)
{
Vector3 currentPos = nearestVertex.transform.position;
Vector3 newPos = new Vector3(currentPos.x, GridManager.getYFromTiming((int)nearestVertexTiming + 1), currentPos.z);
nearestVertexManager.moveTo(newPos);
}
}
}
//simple method for changing a hovered over vertices timing and y cordindate
public void moveVertexUp()
{
GameObject nearestVertex = hoverOverVertex();
if (nearestVertex)
{
VertexManager nearestVertexManager = nearestVertex.GetComponent <VertexManager>();
float nearestVertexTiming = nearestVertexManager.getVertexTiming();
float higherSiblingY;
float higherSiblingTiming;
nearestVertexManager.getHigherVertex(out higherSiblingY, out higherSiblingTiming);
if (nearestVertexTiming != 0 && nearestVertexTiming > higherSiblingTiming)
{
Vector3 currentPos = nearestVertex.transform.position;
Vector3 newPos = new Vector3(currentPos.x, GridManager.getYFromTiming((int)nearestVertexTiming - 1), currentPos.z);
nearestVertexManager.moveTo(newPos);
}
}
}
//method used to return the nearest rigid body to the called of method
private Rigidbody GetNearestRigidBody()
{
Rigidbody neartestRigidBody = null;
float minDistance = float.MaxValue;
float distance = 0.0f;
foreach (Rigidbody contactBody in contactRigidBodies)
{
VertexManager vm = contactBody.gameObject.GetComponent <VertexManager>();
//don't bother checking the position of contactBody if its ID is 0 as that vertex cannot be selected
if (contactBody.gameObject.active && contactBody.gameObject.GetComponent <VertexManager>().getVertexID() >= 1)
{
distance = (contactBody.gameObject.transform.position - transform.position).sqrMagnitude;
if (distance < minDistance)
{
minDistance = distance;
neartestRigidBody = contactBody;
}
}
}
return(neartestRigidBody);
}
//update the timing dictionary by removing the vertex manager from the old key and inserting it into the new one.
public void updateTimingDict(float oldTiming, float newTiming, VertexManager vm)
{
timingDict[oldTiming].Remove(vm);
timingDict[newTiming].Add(vm);
}
/// <summary>
/// コンストラクタです。
/// </summary>
/// <param name="device"></param>
public ShaderCommon(PPDDevice device)
{
vertexManager = new VertexManager(device);
}
//given a note, play it on Super Collider.
private void playNote(GridManager.Notes note)
{
print(note);
VertexManager.contactSC(note, 0.5f, 0.5f, "VoiceA");
}
public void BuildLineMeshes()
{
// Clear any existing mesh objects
for (int i = 0; i < m_LineModelObj.transform.childCount; i++)
{
Destroy(m_LineModelObj.transform.GetChild(i).gameObject);
}
numVerts = lines.Count;
meshes = new List <Mesh>();
meshParts = new List <GameObject>();
float lineWidth = 2.5f;
int numMeshesRequired = (numVerts / ((MAX_VERTICES_PER_MESH / 4) - 1)) + 1;
// Per mesh m
for (int m = 0; m < numMeshesRequired; m++)
{
// Create mesh and vertecis, uv and triangles lists
Mesh mesh = new Mesh();
List <Vector3> vertices = new List <Vector3>();
List <Vector2> UVs = new List <Vector2>();
List <int> triangles = new List <int>();
// Create list of vert ids that will be in current mesh
List <int> vs = new List <int>();
int vertCounter = 0;
// Calculate start and end vert indexes for current mesh
int startInd = m * ((MAX_VERTICES_PER_MESH / 4) - 1);
int endInd = Mathf.Min(startInd + ((MAX_VERTICES_PER_MESH / 4) - 1), numVerts);
// For each vert in this mesh (Square mode)
for (int v = startInd; v < endInd - 1; v += 2)
{
// add vert indexes to current vs list
vs.Add(v);
vs.Add(v + 1);
// Get start and end points of line
Vector3 end = lines[v];
Vector3 start = lines[v + 1];
// calculate normal and 'side' direction of line segment
Vector3 normal = Vector3.Cross(start, end);
Vector3 side = Vector3.Cross(normal, end - start);
side.Normalize();
Vector3 side2 = Vector3.Normalize(Quaternion.AngleAxis(90, end - start) * side);
// Create vectors for each corner of the Hexagonal mesh
Vector3 a = start + side * (lineWidth / 2) - side2 * (lineWidth / 2);
Vector3 b = start + side * (lineWidth / 2) + side2 * (lineWidth / 2);
Vector3 c = start - side * (lineWidth / 2) + side2 * (lineWidth / 2);
Vector3 d = start - side * (lineWidth / 2) - side2 * (lineWidth / 2);
Vector3 e = end + side * (lineWidth / 2) - side2 * (lineWidth / 2);
Vector3 f = end + side * (lineWidth / 2) + side2 * (lineWidth / 2);
Vector3 g = end - side * (lineWidth / 2) + side2 * (lineWidth / 2);
Vector3 h = end - side * (lineWidth / 2) - side2 * (lineWidth / 2);
// add vectors to vertices list
vertices.Add(a);
vertices.Add(b);
vertices.Add(c);
vertices.Add(d);
vertices.Add(e);
vertices.Add(f);
vertices.Add(g);
vertices.Add(h);
// Add uvs for these 8 vectors
UVs.Add(new Vector2(vertices[vertCounter].x, vertices[vertCounter].z));
UVs.Add(new Vector2(vertices[vertCounter + 1].x, vertices[vertCounter + 1].z));
UVs.Add(new Vector2(vertices[vertCounter + 2].x, vertices[vertCounter + 2].z));
UVs.Add(new Vector2(vertices[vertCounter + 3].x, vertices[vertCounter + 3].z));
UVs.Add(new Vector2(vertices[vertCounter + 4].x, vertices[vertCounter + 4].z));
UVs.Add(new Vector2(vertices[vertCounter + 5].x, vertices[vertCounter + 5].z));
UVs.Add(new Vector2(vertices[vertCounter + 6].x, vertices[vertCounter + 6].z));
UVs.Add(new Vector2(vertices[vertCounter + 7].x, vertices[vertCounter + 7].z));
// Add triangles for these 12 vectors
triangles.Add(vertCounter);
triangles.Add(vertCounter + 1);
triangles.Add(vertCounter + 4);
triangles.Add(vertCounter + 1);
triangles.Add(vertCounter + 5);
triangles.Add(vertCounter + 4);
triangles.Add(vertCounter + 1);
triangles.Add(vertCounter + 2);
triangles.Add(vertCounter + 5);
triangles.Add(vertCounter + 2);
triangles.Add(vertCounter + 6);
triangles.Add(vertCounter + 5);
triangles.Add(vertCounter + 2);
triangles.Add(vertCounter + 3);
triangles.Add(vertCounter + 6);
triangles.Add(vertCounter + 3);
triangles.Add(vertCounter + 7);
triangles.Add(vertCounter + 6);
triangles.Add(vertCounter + 3);
triangles.Add(vertCounter);
triangles.Add(vertCounter + 7);
triangles.Add(vertCounter);
triangles.Add(vertCounter + 4);
triangles.Add(vertCounter + 7);
// Increment vert counter
vertCounter += 8;
}
/* Rectange mode
* for (int i = startInd; i < endInd - 1; i += 2)
* {
* // add vert indexes to current vs list
* vs.Add(i);
* vs.Add(i + 1);
*
* // Get start and end points of line
* Vector3 end = lines[i];
* Vector3 start = lines[i + 1];
*
* // calculate normal and 'side' direction of line segment
* Vector3 normal = Vector3.Cross(start, end);
* Vector3 side = Vector3.Cross(normal, end - start);
* side.Normalize();
*
* // Create vectors for each corner of the line segment
* Vector3 a = start + side * (lineWidth / 2);
* Vector3 b = start + side * (lineWidth / -2);
* Vector3 c = end + side * (lineWidth / 2);
* Vector3 d = end + side * (lineWidth / -2);
*
* // add vectors to vertices list
* vertices.Add(a);
* vertices.Add(b);
* vertices.Add(c);
* vertices.Add(d);
*
* // Add uvs for these 4 vectors
*
* UVs.Add(new Vector2(vertices[vertCounter].x, vertices[vertCounter].z));
* UVs.Add(new Vector2(vertices[vertCounter + 1].x, vertices[vertCounter + 1].z));
* UVs.Add(new Vector2(vertices[vertCounter + 2].x, vertices[vertCounter + 2].z));
* UVs.Add(new Vector2(vertices[vertCounter + 3].x, vertices[vertCounter + 3].z));
*
* // Add triangles for these 4 vectors
* triangles.Add(vertCounter);
* triangles.Add(vertCounter + 2);
* triangles.Add(vertCounter + 1);
*
* triangles.Add(vertCounter + 1);
* triangles.Add(vertCounter + 2);
* triangles.Add(vertCounter + 3);
*
* // Increment vert counter
* vertCounter += 4;
* }
*/
// Add arrays to mesh object
mesh.vertices = vertices.ToArray();
mesh.triangles = triangles.ToArray();
mesh.uv = UVs.ToArray();
mesh.RecalculateNormals();
//UnityEditor.AssetDatabase.CreateAsset(mesh, "Assets/FullCortexModel/LineSquare/MeshPartSquare__" + m + ".asset");
// Create lineSeg object
GameObject lineSeg = Instantiate(m_LineSegPrefab);
lineSeg.transform.SetParent(m_LineModelObj.transform);
// Reset lineSeg object's transform
lineSeg.transform.localScale = new Vector3(1, 1, 1);
lineSeg.transform.localPosition = Vector3.zero;
// Set mesh
lineSeg.GetComponent <MeshFilter>().mesh = mesh;
// Set data in VertexData script on lineSeg
VertexManager vd = lineSeg.GetComponent <VertexManager>();
if (vd)
{
vd.m_MeshID = m;
vd.m_VertexIDs = vs;
}
meshes.Add(mesh);
meshParts.Add(lineSeg);
}
//PrefabUtility.ReplacePrefab(m_LineModelObj, m_lineModelPrefab, ReplacePrefabOptions.ConnectToPrefab);
MeshInfo meshInf = new MeshInfo();
meshInf.numVerts = numVerts;
meshInf.numMeshes = meshes.Count;
m_meshInfo = meshInf;
m_buildRun = true;
MeshData.SaveMeshInfo(meshInf);
}
private void Awake()
{
_vertexManager = GetComponent <VertexManager>();
Planet = GetComponent <Planet>();
Colors = new Color[_nbVertex];
}
//method called by pulse manager to calculate a pulse should be on this line renderer. (and for creating new lead on pulses)
public Vector3 interpole(float height, bool playVertex)
{
float lowerBoundTiming = float.MinValue;
float upperBoundTiming = float.MaxValue;
int lowerBoundIndex = 0;
int upperBoundIndex = 0;
int flooredHeight = Mathf.FloorToInt(height);
//get all of the children, even ones attached to controllers.
List <GameObject> childrenVertices = getAllChildrenVerticesForInterpole();
childrenVertices.Sort(sortByVertexID);
//first 1/3 of method used for deducing which 2 vertices the pulse should be between based on a given height.
foreach (GameObject Vertex in childrenVertices)
{
VertexManager currentVertexManager = Vertex.GetComponent <VertexManager>();
if (currentVertexManager.getVertexTiming() >= lowerBoundTiming && currentVertexManager.getVertexTiming() <= height)
{
lowerBoundTiming = currentVertexManager.getVertexTiming();
lowerBoundIndex = currentVertexManager.getVertexID();
}
if (currentVertexManager.getVertexTiming() < upperBoundTiming && currentVertexManager.getVertexTiming() > height && currentVertexManager.getVertexTiming() != upperBoundTiming)
{
upperBoundTiming = currentVertexManager.getVertexTiming();
upperBoundIndex = currentVertexManager.getVertexID();
}
}
if (lastHeight > flooredHeight && flooredHeight == 0)
{
if (playVertex)
{
foreach (VertexManager vm in timingDict[0])
{
vm.playVertex();
}
}
}
else if (lastHeight < flooredHeight)
{
float diffOfHeights = flooredHeight - lastHeight;
if (playVertex && flooredHeight < GridManager.getYSegments() - 1)
{
foreach (VertexManager vm in timingDict[flooredHeight])
{
vm.playVertex();
}
}
}
if (flooredHeight != -1)
{
lastHeight = flooredHeight;
}
float difference = upperBoundTiming - lowerBoundTiming;
float segment = 1 / difference;
float leftover = height - lowerBoundTiming;
int numberOfDivs = Mathf.FloorToInt(leftover);
float t = (numberOfDivs * segment) + ((leftover % 1) / difference);
if (flooredHeight == -1)
{
//lead on pulse:
return(Vector3.Lerp(PulseTranslation(attachedLR.GetPosition(0)), PulseTranslation(attachedLR.GetPosition(1)), 1 - (height * -1)));
}
else
{
return(Vector3.Lerp(PulseTranslation(attachedLR.GetPosition(lowerBoundIndex)), PulseTranslation(attachedLR.GetPosition(upperBoundIndex)), t));
}
}
// Start is called before the first frame update
void Start()
{
instance = this;
graph = FindObjectOfType <Graph>();
}
/// <summary>
/// Render a set of asssets on the screen.
/// </summary>
public override void Render(Asset[] assets)
{
base.Render(assets);
CommandBuffers[CurrentFrame] = GraphicDevice.Handle.AllocateCommandBuffers(Commands[CurrentFrame], CommandBufferLevel.Primary, (uint)Swapchain.Images.Count());
for (int index = 0; index < Swapchain.Images.Count(); index++)
{
var commandBuffer = CommandBuffers[CurrentFrame][index];
commandBuffer.Begin(CommandBufferUsageFlags.SimultaneousUse);
commandBuffer.BeginRenderPass(DefaultRenderPass.Handle, Swapchain.VideoBuffers[index].Handler, new Rect2D(Swapchain.SurfaceSize), (ClearValue)(0F, 1F, 0F, 1F), SubpassContents.Inline);
if (assets != null)
{
foreach (Asset asset in assets)
{
// - Gets the mesh from the mesh store
var mesh = GeometryDispatcher.Get(asset.Mesh);
VertexManager.Bind(commandBuffer);
IndexManager.Bind(commandBuffer, (int)mesh.Indexes.Offset);
commandBuffer.BindPipeline(PipelineBindPoint.Graphics, Pipeline.PipelineInstance);
commandBuffer.DrawIndexed((uint)mesh.Indexes.Count, (uint)mesh.Indexes.Count / 3, 0, 0, 0);
}
}
commandBuffer.EndRenderPass();
commandBuffer.End();
}
uint nextImage = Swapchain.Handle.AcquireNextImage(uint.MaxValue, ImageAvailableSemaphores[CurrentFrame], null);
if (ImagesInFlight[(int)nextImage] != null)
{
GraphicDevice.Handle.WaitForFences(ImagesInFlight[(int)nextImage], true, UInt64.MaxValue);
}
// - Mark the image as now being in use by this frame
ImagesInFlight[(int)nextImage] = InFlightFences[CurrentFrame];
try
{
GraphicDevice.Handle.ResetFences(InFlightFences[CurrentFrame]);
GraphicDevice.GraphicQueue.Submit
(
new SubmitInfo
{
CommandBuffers = new[] { CommandBuffers[CurrentFrame][nextImage] },
SignalSemaphores = new[] { RenderFinishedSemaphores[CurrentFrame] },
WaitDestinationStageMask = new[] { PipelineStageFlags.ColorAttachmentOutput },
WaitSemaphores = new[] { ImageAvailableSemaphores[CurrentFrame] }
},
InFlightFences[CurrentFrame]
);
}
catch (DeviceLostException)
{
InvalidateDevice();
}
try
{
var present = GraphicDevice.PresentQueue.Present(RenderFinishedSemaphores[CurrentFrame], Swapchain.Handle, nextImage, new Result[1]);
switch (present)
{
case Result.Suboptimal:
InvalidateGraphics();
break;
}
if (present == Result.Success)
{
GraphicDevice.Handle.WaitForFences(InFlightFences[CurrentFrame], true, UInt64.MaxValue);
Commands[(CurrentFrame + 1) % MaxFrameInFlight].FreeCommandBuffers(CommandBuffers[(CurrentFrame + 1) % MaxFrameInFlight]);
CommandBuffers[(CurrentFrame + 1) % MaxFrameInFlight] = null;
}
}
catch
{
InvalidateGraphics();
}
finally
{
}
CurrentFrame = (CurrentFrame + 1) % MaxFrameInFlight;
}
/// <summary>
///
/// </summary>
public override void LoadAttachments(IEnumerable <Resource.IDescriptor> resources)
{
// - Skip buffer creation if no resources to load
if (resources.Count() <= 0)
{
return;
}
// - Creates a command buffer for data transfer
var commands = GraphicDevice.Handle.AllocateCommandBuffer(Commands[0], CommandBufferLevel.Primary);
commands.Begin(CommandBufferUsageFlags.OneTimeSubmit);
foreach (Resource.IDescriptor res in resources)
{
switch (res)
{
case Shape.Descriptor shape:
// - Loads the geometry
Geometry pointer = GeometryDispatcher.Load(shape);
// - Set resource loaded in the source thread
shape.SourceScheduler.Add(() =>
{
shape.SetResource(pointer);
shape.SetState(Resource.State.Loaded);
});
break;
default:
throw new Exception($"Resource {res.GetType().Name} does not has a loader.");
}
}
{
// - Upload invalidated vertexs
VertexManager.Upload(commands, 1000);
// - Upload invalidated indexes
IndexManager.Upload(commands, 1000);
}
commands.End();
// - Perform all attachment operations
GraphicDevice.GraphicQueue.Submit
(
new SubmitInfo
{
CommandBuffers = new[] { commands }
},
null
);
// - Free attachment command buffer
Commands[0].FreeCommandBuffers(commands);
// - Wait the GPU (we must operate only when GPU is idle)
GraphicDevice.Handle.WaitIdle();
}