public void Update()
{
if (isWarping)
{
WarpState += 0.0055655558f;
if (WarpState > 1f)
{
WarpState = 1f;
}
}
else
{
WarpState -= 0.06667667f;
if (WarpState < 0f)
{
WarpState = 0f;
}
}
Vector4 playerRot = new Vector4(rootTransform.rotation.x, rootTransform.rotation.y, rootTransform.rotation.z, rootTransform.rotation.w);
if (WarpState > 0.001f && !warpEffectActivated)
{
for (int i = 0; i < warpRotations.Length; i++)
{
warpRotations[i] = playerRot;
}
VFAudio.Create("warp-begin", base.transform, Vector3.zero, true, 0);
ToggleEffect(true);
}
else if (WarpState == 0 && warpEffectActivated)
{
VFAudio.Create("warp-end", base.transform, Vector3.zero, true, 0);
ToggleEffect(false);
}
Array.Copy(warpRotations, 0, warpRotations, 1, warpRotations.Length - 1);
warpRotations[0] = playerRot;
ParticleSystem.EmissionModule emission = astrosParticles.emission;
ParticleSystem.VelocityOverLifetimeModule velocityOverTime = astrosParticles.velocityOverLifetime;
ParticleSystem.ShapeModule shape = astrosParticles.shape;
Vector3 lhs = velocity.normalized;
// to compute the emission we would need to know the players local star, so default to this for now
emission.rateOverTime = 120f;
velocityOverTime.speedModifierMultiplier = 20000f;
velocityOverTime.x = (float)lhs.x;
velocityOverTime.y = (float)lhs.y;
velocityOverTime.z = (float)lhs.z;
shape.position = lhs * 10000.0f;
shape.rotation = rootTransform.rotation.eulerAngles;
distortRenderer.GetComponent <Transform>().localRotation = rootTransform.rotation;
nebulasRenderer.GetComponent <Transform>().localRotation = rootTransform.rotation;
float num1 = intensByState.Evaluate(WarpState);
float num2 = intensByState_astro.Evaluate(WarpState);
tunnelMat.SetFloat("_Multiplier", tunnelMul * num1);
tunnelMat.SetVectorArray("_WarpRotations", warpRotations);
distortMat.SetFloat("_DistortionStrength", distortMul * num1);
astrosMat.SetFloat("_Multiplier", astrosMul * num2);
nebulasMat.SetFloat("_Multiplier", nebulasMul * num2);
}
public void HideClickTut()
{
data.tween.AddTween(1, tweenOutClick, onClickOutEnd);
clickBackground.GetComponent <Collider>().enabled = false;
}
void Start()
{
var mesh = _source.GetComponent <MeshFilter>().sharedMesh;
var vcount = mesh.vertexCount;
_rootPoints = new NativeArray <RootPoint>
(vcount, Allocator.Persistent);
_positionBuffer = new NativeArray <float4>
(vcount * _segmentCount, Allocator.Persistent);
_velocityBuffer = new NativeArray <float3>
(vcount * _segmentCount, Allocator.Persistent);
var vertices = mesh.vertices;
var normals = mesh.normals;
for (var vi = 0; vi < vcount; vi++)
{
_rootPoints[vi] = new RootPoint
{
position = vertices[vi], normal = normals[vi]
}
}
;
_positionMap = new Texture2D
(_segmentCount, vcount, TextureFormat.RGBAFloat, false);
_target.SetTexture("PositionMap", _positionMap);
_target.SetUInt("VertexCount", (uint)vcount);
_target.SetUInt("SegmentCount", (uint)_segmentCount);
_time = Time.time;
}
void OnDestroy()
{
if (_rootPoints.IsCreated)
{
_rootPoints.Dispose();
}
if (_positionBuffer.IsCreated)
{
_positionBuffer.Dispose();
}
if (_velocityBuffer.IsCreated)
{
_velocityBuffer.Dispose();
}
if (_positionMap != null)
{
Destroy(_positionMap);
}
}
void Update()
{
var nextTime = Time.time;
while (_time + _maxTimeStep < nextTime)
{
var job = new UpdateJob
{
// Buffers
R = _rootPoints,
P = _positionBuffer,
V = _velocityBuffer,
// Settings
prof = _profile,
seed = _randomSeed,
// Current state
tf = (float4x4)_source.transform.localToWorldMatrix,
t = _time,
dt = _maxTimeStep
};
job.ScheduleParallel
(_rootPoints.Length, 1, default(JobHandle)).Complete();
_time += _maxTimeStep;
}
_positionMap.LoadRawTextureData(_positionBuffer);
_positionMap.Apply();
}
#endregion
}
public Vector3 GetCenter()
{
var collider = bodyMesh.GetComponent <BoxCollider>();
return(bodyMesh.transform.TransformPoint(collider.center));
}
void Awake()
{
maxDisco = 100;
material = mesh.GetComponent <MeshRenderer>().materials[0];
}
// Use this for initialization
void Start()
{
fpsMonitor = GetComponent <FpsMonitor>();
imageSizeDropdown.value = (int)imageSize;
countDropdown.value = 2;
fgTex = Resources.Load("lena") as Texture2D;
bgTex = new Texture2D(fgTex.width, fgTex.height, TextureFormat.RGBA32, false);
alphaTex = new Texture2D(fgTex.width, fgTex.height, TextureFormat.RGBA32, false);
dstTex = new Texture2D(fgTex.width, fgTex.height, TextureFormat.RGBA32, false);
fgMat = new Mat(fgTex.height, fgTex.width, CvType.CV_8UC3);
bgMat = new Mat(fgTex.height, fgTex.width, CvType.CV_8UC3);
alphaMat = new Mat(fgTex.height, fgTex.width, CvType.CV_8UC1);
dstMat = new Mat(fgTex.height, fgTex.width, CvType.CV_8UC3, new Scalar(0, 0, 0));
// Generate fgMat.
Utils.texture2DToMat(fgTex, fgMat);
// Generate bgMat.
Core.flip(fgMat, bgMat, 1);
Core.bitwise_not(bgMat, bgMat);
// Generate alphaMat.
for (int r = 0; r < alphaMat.rows(); r++)
{
alphaMat.row(r).setTo(new Scalar(r / (alphaMat.rows() / 256)));
}
#pragma warning disable 0618
Imgproc.linearPolar(alphaMat, alphaMat, new Point(alphaMat.cols() / 2, alphaMat.rows() / 2), alphaMat.rows(), Imgproc.INTER_CUBIC | Imgproc.WARP_FILL_OUTLIERS | Imgproc.WARP_INVERSE_MAP);
#pragma warning restore 0618
// Generate large size Mat.
fgMatLarge = new Mat();
bgMatLarge = new Mat();
alphaMatLarge = new Mat();
dstMatLarge = new Mat();
Imgproc.resize(fgMat, fgMatLarge, new Size(), 2, 2, 0);
Imgproc.resize(bgMat, bgMatLarge, new Size(), 2, 2, 0);
Imgproc.resize(alphaMat, alphaMatLarge, new Size(), 2, 2, 0);
Imgproc.resize(dstMat, dstMatLarge, new Size(), 2, 2, 0);
// Generate small size Mat (ROI).
OpenCVForUnity.CoreModule.Rect rect = new OpenCVForUnity.CoreModule.Rect(127, 127, 256, 256);
fgMatROI = new Mat(fgMat, rect);
bgMatROI = new Mat(bgMat, rect);
alphaMatROI = new Mat(alphaMat, rect);
dstMatROI = new Mat(dstMat, rect);
Utils.matToTexture2D(fgMat, fgTex, true, 0, true);
Utils.matToTexture2D(bgMat, bgTex, true, 0, true);
Utils.matToTexture2D(alphaMat, alphaTex, true, 0, true);
Utils.matToTexture2D(dstMat, dstTex, true, 0, true);
fgQuad.GetComponent <Renderer>().material.mainTexture = fgTex;
bgQuad.GetComponent <Renderer>().material.mainTexture = bgTex;
alphaQuad.GetComponent <Renderer>().material.mainTexture = alphaTex;
dstQuad.GetComponent <Renderer>().material.mainTexture = dstTex;
}
public void Push(MeshRenderer renderer)
{
var meshFilter = renderer.GetComponent <MeshFilter>();
if (meshFilter == null)
{
Debug.LogWarningFormat("{0} has no mesh filter", renderer.name);
return;
}
var mesh = meshFilter.sharedMesh;
if (mesh == null)
{
Debug.LogWarningFormat("{0} has no mesh", renderer.name);
return;
}
var indexOffset = Positions.Count;
var boneIndexOffset = Bones.Count;
Positions.AddRange(mesh.vertices
.Select(x => renderer.transform.TransformPoint(x))
);
Normals.AddRange(mesh.normals
.Select(x => renderer.transform.TransformVector(x))
);
UV.AddRange(mesh.uv);
Tangents.AddRange(mesh.tangents
.Select(t =>
{
var v = renderer.transform.TransformVector(t.x, t.y, t.z);
return(new Vector4(v.x, v.y, v.z, t.w));
})
);
var self = renderer.transform;
var bone = self.parent;
if (bone == null)
{
Debug.LogWarningFormat("{0} is root gameobject.", self.name);
return;
}
var bindpose = bone.worldToLocalMatrix;
BoneWeights.AddRange(Enumerable.Range(0, mesh.vertices.Length)
.Select(x => new BoneWeight()
{
boneIndex0 = Bones.Count,
weight0 = 1,
})
);
BindPoses.Add(bindpose);
Bones.Add(bone);
for (int i = 0; i < mesh.subMeshCount; ++i)
{
var indices = mesh.GetIndices(i).Select(x => x + indexOffset);
var mat = renderer.sharedMaterials[i];
var sameMaterialSubMeshIndex = SubMeshes.FindIndex(x => ReferenceEquals(x.Material, mat));
if (sameMaterialSubMeshIndex >= 0)
{
SubMeshes[sameMaterialSubMeshIndex].Indices.AddRange(indices);
}
else
{
SubMeshes.Add(new SubMesh
{
Indices = indices.ToList(),
Material = mat,
});
}
}
}
void Start()
{
Renderer r = m_material.GetComponent <Renderer> ();
m_startingColor = r.material.color;
}
// public void changeTexture(GameObject child) {
// child.GetComponent<MeshRenderer>().material = destroyedMat;
// }
public void changeTexture(MeshRenderer child)
{
child.GetComponent <MeshRenderer>().material = destroyedMat;
}
void _players_view()
{
// _frp( FRP_LOW + "_players_view()" + FRP_END );
if (is_in_game)
{
_frp(FRP_ERR + "Menu was alive while game running for some reason... Disappearing" + FRP_END);
this.gameObject.SetActive(false);
return;
}
// Take most updated data
_api_users_refresh();
// Constantly internalize local state into ht8b.cs to make sure we can allow us to play
// when system control is handed over to it
main.local_playerid = local_playerid;
ui_textplayers[0].text = "";
ui_textplayers[1].text = "";
uint readied_players = 0;
// Texts for who is playing
for (uint i = 0; i < (teams_allowed == 1? 4: 2); i++)
{
if (player_ready[i])
{
#if UNITY_EDITOR
if ((i & 0x1U) == 1)
{
ui_textplayers[1].text += "<UNITY_EDITOR>\n";
readied_players |= 0x2u;
}
else
{
ui_textplayers[0].text = "\n<UNITY_EDITOR>" + ui_textplayers[0].text;
readied_players |= 0x1u;
}
#else
string dispname = player_apis[i].displayName;
if (i == local_playerid)
{
// Check for value stomping
if (player_apis[i] != Networking.LocalPlayer)
{
_frp(FRP_ERR + "Local player value was stomped by a rogue network event" + FRP_END);
local_playerid = -1;
return;
}
// Show local player in italics
dispname = "<i>" + dispname + "</i>";
}
if ((i & 0x1U) == 1)
{
ui_textplayers[1].text += dispname + "\n";
readied_players |= 0x2;
}
else
{
ui_textplayers[0].text = "\n" + dispname + ui_textplayers[0].text;
readied_players |= 0x1;
}
#endif
}
// Update join buttons
if (local_playerid >= 0)
{
if (i == (uint)local_playerid)
{
ui_joinbuttons[i].gameObject.SetActive(true);
ui_joinbuttons[i].sharedMaterial = mat_low;
}
else
{
ui_joinbuttons[i].gameObject.SetActive(false);
}
}
else
{
if (player_ready[i])
{
ui_joinbuttons[i].gameObject.SetActive(false);
}
else
{
ui_joinbuttons[i].gameObject.SetActive(true);
ui_joinbuttons[i].sharedMaterial = mat_high;
}
}
}
if ((readied_players == 0x3u || gamemode_id == 2u) && local_playerid == 0)
{
ui_start.sharedMaterial = mat_high;
ui_start.GetComponent <BoxCollider>().enabled = true;
}
else
{
ui_start.sharedMaterial = mat_low;
ui_start.GetComponent <BoxCollider>().enabled = false;
}
}
public void initTarget()
{
if (missileObjects != null)
{
for (int x = 0; x < missileObjects.Length; x++)
{
DestroyObject(missileObjects[x]);
Destroy(missiles[x]);
}
}
time = 1;
Debug.Log("Button pressed");
if (readTargetButton.GetComponent <CSVReader>().data != null)
{
Debug.Log("Read target csv reader not null");
targetData = readTargetButton.GetComponent <CSVReader>().data;
fileLength = targetData.GetLength(1) - 1;
missileObjects = new GameObject[fileLength];
missiles = new MeshRenderer[fileLength];
for (int x = 0; x < missileObjects.Length - 1; x++)
{
missileObjects[x] = new GameObject();
}
for (int x = 0; x < fileLength - 1; x++)
{
missileObjects[x].AddComponent <MeshRenderer>();
missileObjects[x].AddComponent <MeshCollider>();
missileObjects[x].AddComponent <ClickScript>();
missiles[x] = missileObjects[x].GetComponent <MeshRenderer>();
missiles[x] = Instantiate(missle.GetComponent <MeshRenderer>());
missiles[x].GetComponent <ClickScript>().setNumber(x);
Vector3 scale = new Vector3();
scale.x = .1f;
scale.y = .1f;
scale.z = .1f;
missiles[x].transform.localScale = scale;
}
//can tasks be marked as X percent complete
Debug.Log("Target data init file length " + fileLength);
fileLength--;
targetPosX = new double[fileLength];
targetPosY = new double[fileLength];
targetPosZ = new double[fileLength];
targetVelocityX = new double[fileLength];
targetVelocityY = new double[fileLength];
targetVelocityZ = new double[fileLength];
targetLeg = new int[targetData.GetLength(0)];
accelX = new double[fileLength];
accelY = new double[fileLength];
accelZ = new double[fileLength];
targetLegPosition = new int[fileLength];
fileLength++;
//init all targets ignore descriptons line
for (int x = 0; x < fileLength - 1; x++)
{
targetPosX[x] = double.Parse(targetData[0, x + 1]) * scalingFactor;
targetPosY[x] = double.Parse(targetData[1, x + 1]) * scalingFactor;
targetPosZ[x] = double.Parse(targetData[2, x + 1]) * scalingFactor;
targetLegPosition[x] = 6;
targetLeg[x] = int.Parse(targetData[targetLegPosition[x], x + 1]);
Debug.Log("Target Position Init " + targetPosX[x] / 20 + " " + targetPosY[x] / 20 + " " + targetPosZ[x] / 20 + " X = " + x);
targetVelocityX[x] = 0;
targetVelocityY[x] = 0;
targetVelocityZ[x] = 0;
Vector3 newPos = new Vector3();
newPos.x = (float)targetPosX[x];
newPos.y = (float)targetPosY[x];
newPos.z = (float)targetPosZ[x];
missiles[x].transform.position = newPos;
}
}
Debug.Log("Init Done");
}
