private void CalcBodyCenter(functionType function)
{
center.X = (xMax + xMin) / 2;
center.Z = (zMin + zMax) / 2;
center.Y = function(center.X, center.Z);
//center.Y = mas[(int)Math.Round((center.X + 2) / xStep), (int)Math.Round((center.Z + 2) / zStep)];
}
private IEnumerator Chacking(functionType callback)
{
while (true)
{
yield return(new WaitForFixedUpdate());
if (!audioSource.isPlaying)
{
callback();
break;
}
}
}
private IEnumerator lChecking(functionType callback)
{
while (true)
{
yield return(new WaitForFixedUpdate());
if (!last_tap.isPlaying)
{
callback();
break;
}
}
}
private IEnumerator OnPlayFinished(functionType callback, AudioSource audio)
{
while (true)
{
yield return(new WaitForFixedUpdate());
if (!audio.isPlaying)
{
callback(audio);
break;
}
}
}
private IEnumerator Checking(functionType callback)
{
while (true)
{
yield return(new WaitForFixedUpdate());
if (!sound.isPlaying)
{
call = true;
break;
}
}
}
public void drawZ(Graphics g, functionType function)
{
graphics = g;
Point2D prevPoint,
leftPoint = new Point2D(NULL, NULL),
rigthPoint = new Point2D(NULL, NULL);
for (double currentZ = zMax; currentZ >= zMin; currentZ -= zStep)
{
double y;
y = function(xMin, currentZ);
prevPoint = c3Dto2D(xMin, y, currentZ);
DrawifOK(prevPoint, ref leftPoint);
if (!(CheckPoint(prevPoint) && CheckPoint(leftPoint)))
{
continue;
}
Vis prevVisible = CheckVis(prevPoint);
Point2D currentPoint = new Point2D();
for (double currentX = xMin; currentX <= xMax; currentX += xStep)
{
cur = false;
if (currentX > xMax - zStep / 2)
{
// cur = true;
}
y = function(currentX, currentZ);
currentPoint = c3Dto2D(currentX, y, currentZ);
if (!CheckPoint(currentPoint))
{
continue;
}
Vis currentVisibily = CheckVis(currentPoint);
if (currentVisibily == prevVisible)
{
if (currentVisibily == Vis.lower || currentVisibily == Vis.upper)
{
DrawLine(prevPoint, currentPoint);
Smooth(prevPoint, currentPoint);
}
prevVisible = currentVisibily;
prevPoint = currentPoint;
}
DrawifOK(currentPoint, ref rigthPoint);
}
}
}
public bool addNewSimulationUnit(string id, functionType fType, int address)
{
Thread t = null;
SimulationUnit u = new SimulationUnit();;
foreach (var idt in threadsDict.Keys)
{
if (idt == id)
{
return(false);
}
}
u.id = id;
switch (fType)
{
case functionType.Sin:
t = new Thread(new ParameterizedThreadStart(Sine));
u.fType = functionType.Sin;
break;
case functionType.Cos:
t = new Thread(new ParameterizedThreadStart(Cosine));
u.fType = functionType.Cos;
break;
case functionType.Ramp:
t = new Thread(new ParameterizedThreadStart(Ramp));
u.fType = functionType.Ramp;
break;
case functionType.Triangle:
t = new Thread(new ParameterizedThreadStart(Triangle));
u.fType = functionType.Triangle;
break;
case functionType.Rectangle:
t = new Thread(new ParameterizedThreadStart(Rectangle));
u.fType = functionType.Rectangle;
break;
}
u.address = address;
unitsDict[id] = u;
threadsDict[id] = t;
t.Start(address);
return(true);
}
public void Draw(Graphics g, functionType function)
{
if (!flag)
{
CalcFunction(function);
}
if (resTemp != resttt)
{
CalcBodyCenter(function);
resTemp = resttt;
}
StartDoubleBuffering();
ResetHor();
drawZ(g, function);
finishDoubleBuffering();
}
private void DrawHelperZ(Graphics imageGraphics, functionType function)
{
Point2D prevPoint,
leftPoint = new Point2D(EMPTY_VALUE, EMPTY_VALUE),
rightPoint = new Point2D(EMPTY_VALUE, EMPTY_VALUE);
for (double currentZ = zMax; currentZ >= zMin; currentZ -= zStep)
{
double y;
y = function(xMin, currentZ);
prevPoint = TransformView(xMin, y, currentZ).ToPoint2D();
ProcessEdge(prevPoint, ref leftPoint);
if (!(CheckPoint(prevPoint) && CheckPoint(leftPoint)))
{
continue;
}
VisibilityType prevVisibility = CheckVisibility(prevPoint);
Point2D currentPoint = new Point2D();
for (double currentX = xMin; currentX <= xMax; currentX += xStep)
{
y = function(currentX, currentZ);
currentPoint = TransformView(currentX, y, currentZ).ToPoint2D();
if (!CheckPoint(currentPoint))
{
continue;
}
VisibilityType currentVisibility = CheckVisibility(currentPoint);
if (currentVisibility == prevVisibility)
{
if (currentVisibility == VisibilityType.VisibleAndLower || currentVisibility == VisibilityType.VisibleAndUpper)
{
DrawLine(prevPoint, currentPoint);
Smooth(prevPoint, currentPoint);
}
}
else
{
ProcessHorizonIntersectingLine(currentVisibility, prevVisibility, prevPoint, currentPoint);
}
prevVisibility = currentVisibility;
prevPoint = currentPoint;
}
ProcessEdge(currentPoint, ref rightPoint);
}
}
private void CalcFunction(functionType function)
{
int i = 0, j = 0;
for (double currentZ = zMin; currentZ <= zMax; currentZ += zStep)
{
if (i >= 67)
{
i = 0;
}
for (double currentX = xMin; currentX <= xMax; currentX += xStep)
{
if (j >= 67)
{
j = 0;
}
mas[i, j] = function(currentX, currentZ);
j++;
}
i++;
j = 0;
}
}
public void Draw(Graphics imageGraphics, functionType function)
{
#region Debug
Debug.Assert(imageGraphics != null);
Debug.Assert(zMin != EMPTY_VALUE && zMax != EMPTY_VALUE && xMin != EMPTY_VALUE &&
xMax != EMPTY_VALUE);
Debug.Assert(xStep != 0 && zStep != 0);
#endregion
CalcBodyCenter(function);
StartDoubleBuffering();
ResetHorizons();
isInverted = false;
currentFunction = function;
functionType wrapperFunc = new functionType(functionWrapper);
// if (!(Math.PI / 2.0 < angleY && angleY < 3 * Math.PI / 2.0))
// zStep *= -1;
try
{
DrawHelperZ(imageGraphics, wrapperFunc);
//ResetHorizons();
// angleY += Math.PI / 2.0;
// isInverted = true;
// DrawHelperZ(imageGraphics, wrapperFunc);
// isInverted = false;
// angleY -= Math.PI / 2.0;
}
catch (Exception)
{
Debug.Assert(false);
}
finally
{
FinishDoubleBuffering(imageGraphics);
}
}
public bool addNewSimulationDriverUnit(string id, functionType fType, int address)
{
return(simulationDriver.addNewSimulationUnit(id, fType, address));
}
private void CalcBodyCenter(functionType function)
{
bodyCenter.X = (xMax + xMin) / 2;
bodyCenter.Z = (zMin + zMax) / 2;
bodyCenter.Y = function(bodyCenter.X, bodyCenter.Z);
}
private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
{
int selectedIndex = function.SelectedIndex;
fType = (functionType)selectedIndex;
}
