static public int constructor(IntPtr l) {
try {
UnityEngine.Debug o;
o=new UnityEngine.Debug();
pushValue(l,true);
pushValue(l,o);
return 2;
}
catch(Exception e) {
return error(l,e);
}
}
public static int constructor(IntPtr l)
{
try {
UnityEngine.Debug o;
o=new UnityEngine.Debug();
pushValue(l,o);
return 1;
}
catch(Exception e) {
LuaDLL.luaL_error(l, e.ToString());
return 0;
}
}
public static void StartDetection(UnityAction callback)
{
Debug.LogError(FINAL_LOG_PREFIX + "is not supported on selected platform!");
}
public static void StopDetection()
{
Debug.LogError(FINAL_LOG_PREFIX + "is not supported on selected platform!");
}
private void StartDetectionInternal(UnityAction callback)
{
if (isRunning)
{
Debug.LogWarning(FINAL_LOG_PREFIX + "already running!", this);
return;
}
if (!enabled)
{
Debug.LogWarning(FINAL_LOG_PREFIX + "disabled but StartDetection still called from somewhere (see stack trace for this message)!", this);
return;
}
#if UNITY_EDITOR
if (!UnityEditor.EditorPrefs.GetBool("ACTDIDEnabledGlobal", false))
{
Debug.LogWarning(FINAL_LOG_PREFIX + "is not enabled in Anti-Cheat Toolkit Settings!\nPlease, check readme.pdf for details.", this);
DisposeInternal();
return;
}
#if !DEBUG_NORMAL
if (Application.isEditor)
{
Debug.LogWarning(FINAL_LOG_PREFIX + "does not work in editor (check readme.pdf for details).", this);
DisposeInternal();
return;
}
#else
Debug.LogWarning(FINAL_LOG_PREFIX + "works in debug mode. There WILL BE false positives in editor, it's fine!", this);
#endif
#endif
if (callback != null && detectionEventHasListener)
{
Debug.LogWarning(FINAL_LOG_PREFIX + "has properly configured Detection Event in the inspector, but still get started with Action callback. Both Action and Detection Event will be called on detection. Are you sure you wish to do this?", this);
}
if (callback == null && !detectionEventHasListener)
{
Debug.LogWarning(FINAL_LOG_PREFIX + "was started without any callbacks. Please configure Detection Event in the inspector, or pass the callback Action to the StartDetection method.", this);
enabled = false;
return;
}
detectionAction = callback;
started = true;
isRunning = true;
if (allowedAssemblies == null)
{
LoadAndParseAllowedAssemblies();
}
if (signaturesAreNotGenuine)
{
OnCheatingDetected();
return;
}
if (!FindInjectionInCurrentAssemblies())
{
// listening for new assemblies
AppDomain.CurrentDomain.AssemblyLoad += OnNewAssemblyLoaded;
}
else
{
OnCheatingDetected();
}
}
private void WarnNoCellPrefab()
{
#if !UNITY_EDITOR
Debug.LogWarning("No cell prefab set");
#endif
}
public static void DrawLine(Vector3 start, Vector3 end, Color?color = null)
{
Debug.DrawLine(start, end, color ?? DefaultColor);
}
//TODO: Refactor Stringify functions to share core logic
/*
* I know, I know, this is really bad form. It turns out that there is a
* significant amount of garbage created when calling as a coroutine, so this
* method is duplicated. Hopefully there won't be too many future changes, but
* I would still like a more elegant way to optionaly yield
*/
void Stringify(int depth, StringBuilder builder, bool pretty = false) //Convert the JSONObject into a string
//Profiler.BeginSample("JSONprint");
{
if (depth++ > MAX_DEPTH)
{
Debug.Log("reached max depth!");
return;
}
switch (type)
{
case Type.BAKED:
builder.Append(str);
break;
case Type.STRING:
builder.AppendFormat("\"{0}\"", str);
break;
case Type.NUMBER:
#if USEFLOAT
if (float.IsInfinity(n))
{
builder.Append(INFINITY);
}
else if (float.IsNegativeInfinity(n))
{
builder.Append(NEGINFINITY);
}
else if (float.IsNaN(n))
{
builder.Append(NaN);
}
#else
if (double.IsInfinity(n))
{
builder.Append(INFINITY);
}
else if (double.IsNegativeInfinity(n))
{
builder.Append(NEGINFINITY);
}
else if (double.IsNaN(n))
{
builder.Append(NaN);
}
#endif
else
{
builder.Append(n.ToString());
}
break;
case Type.OBJECT:
builder.Append("{");
if (list.Count > 0)
{
#if (PRETTY) //for a bit more readability, comment the define above to disable system-wide
if (pretty)
{
builder.Append("\n");
}
#endif
for (int i = 0; i < list.Count; i++)
{
string key = keys[i];
JSONObject obj = list[i];
if (obj)
{
#if (PRETTY)
if (pretty)
{
for (int j = 0; j < depth; j++)
{
builder.Append("\t"); //for a bit more readability
}
}
#endif
builder.AppendFormat("\"{0}\":", key);
obj.Stringify(depth, builder, pretty);
builder.Append(",");
#if (PRETTY)
if (pretty)
{
builder.Append("\n");
}
#endif
}
}
#if (PRETTY)
if (pretty)
{
builder.Length -= 2;
}
else
#endif
builder.Length--;
}
#if (PRETTY)
if (pretty && list.Count > 0)
{
builder.Append("\n");
for (int j = 0; j < depth - 1; j++)
{
builder.Append("\t"); //for a bit more readability
}
}
#endif
builder.Append("}");
break;
case Type.ARRAY:
builder.Append("[");
if (list.Count > 0)
{
#if (PRETTY)
if (pretty)
{
builder.Append("\n"); //for a bit more readability
}
#endif
for (int i = 0; i < list.Count; i++)
{
if (list[i])
{
#if (PRETTY)
if (pretty)
{
for (int j = 0; j < depth; j++)
{
builder.Append("\t"); //for a bit more readability
}
}
#endif
list[i].Stringify(depth, builder, pretty);
builder.Append(",");
#if (PRETTY)
if (pretty)
{
builder.Append("\n"); //for a bit more readability
}
#endif
}
}
#if (PRETTY)
if (pretty)
{
builder.Length -= 2;
}
else
#endif
builder.Length--;
}
#if (PRETTY)
if (pretty && list.Count > 0)
{
builder.Append("\n");
for (int j = 0; j < depth - 1; j++)
{
builder.Append("\t"); //for a bit more readability
}
}
#endif
builder.Append("]");
break;
case Type.BOOL:
if (b)
{
builder.Append("true");
}
else
{
builder.Append("false");
}
break;
case Type.NULL:
builder.Append("null");
break;
}
//Profiler.EndSample();
}
IEnumerator FindPath(Vector3 startPos, Vector3 endPos)
{
Stopwatch sw = new Stopwatch();
sw.Start();
Vector3[] wayPoints = new Vector3[0];
bool pathSuccess = false;
Node startNode = grid.GetNodeFromWorldPosition(startPos);
Node endNode = grid.GetNodeFromWorldPosition(endPos);
if (!endNode.Walkable)
{
Debug.LogError("End Node NOT Walkable");
endNode = FindNearestNode(endNode);
}
if (startNode.Walkable && endNode.Walkable)
{
Heap <Node> openSet = new Heap <Node>(grid.MaxSize);
HashSet <Node> closedSet = new HashSet <Node>();
openSet.Add(startNode);
while (openSet.Count > 0)
{
Node currentNode = openSet.RemoveFirstItem();
closedSet.Add(currentNode);
if (currentNode == endNode)
{
sw.Stop();
pathSuccess = true;
Debug.Log("Path found in = " + sw.ElapsedMilliseconds + " ms");
}
foreach (Node neighbour in grid.GetNeighbours(currentNode))
{
if (!neighbour.Walkable || closedSet.Contains(neighbour))
{
continue;
}
int newMovementCostToNeighbour = currentNode.GCost + GetDistance(currentNode, neighbour);
if (newMovementCostToNeighbour < neighbour.GCost || !openSet.Contains(neighbour))
{
neighbour.GCost = newMovementCostToNeighbour;
neighbour.HCost = GetDistance(neighbour, endNode);
neighbour.parent = currentNode;
if (!openSet.Contains(neighbour))
{
openSet.Add(neighbour);
}
else
{
openSet.UpdateItem(neighbour);
}
}
}
}
}
yield return(null);
if (pathSuccess)
{
wayPoints = RetracePath(startNode, endNode);
}
RequestManager.FinishedProcessingPath(wayPoints, pathSuccess);
}
private void _UpdateTextureFromNative()
{
// Debug.Log("_UpdateTextureFromNative");
lock (this)
{
#if UNITY_WEBGL && !UNITY_EDITOR
// _UpdateStatus(); //hack todo onLoaded
// _UpdateDuration(); //hack todo onLoaded
_UpdateNativeVideoSize();
if (_videoTexture == null)
{
Debug.Log("NEW.Texture");
Debug.Log(String.Format("NativeVideoSize({0}:{1})", _currentNativeVideoSize.x, _currentNativeVideoSize.y));
_videoTexture = new Texture2D(64, 64, TextureFormat.ARGB32, false);
//_videoTexture = new Texture2D(0, 0, TextureFormat.RGBA32, false);
// _videoTexture.wrapMode = TextureWrapMode.Repeat;
_videoTexture.wrapMode = TextureWrapMode.Clamp;
_videoTexture.Apply();
MPMP_SetNativeTextureID(_id, _videoTexture.GetNativeTexturePtr().ToInt32());
}
else
{
if (_oldNativeVideoSize.x != _currentNativeVideoSize.x || _oldNativeVideoSize.y != _currentNativeVideoSize.y)
{
Debug.Log("CHANGE.Texture");
Debug.Log(String.Format("NativeVideoSize({0}:{1})", _currentNativeVideoSize.x, _currentNativeVideoSize.y));
_videoTexture.Resize((int)_currentNativeVideoSize.x, (int)_currentNativeVideoSize.y, TextureFormat.ARGB32, false);
_videoTexture.Apply();
}
}
MPMP_UpdateNativeTexture(_id, _videoTexture.GetNativeTexturePtr().ToInt32());//Rendering
if (_videoMaterial != null)
{
_videoMaterial.SetTexture(texturePropertyName, _videoTexture);
}
#else
nativeTexturePtr = MPMP_GetNativeTexture(_id);
if (nativeTexturePtr == IntPtr.Zero)
{
//Debug.Log("_UpdateTextureFromNative.NULLTexture");
return;
}
//GetNativeVideoSize(_id, ref _currentNativeVideoSize);
_UpdateNativeVideoSize();
if (_videoTexture == null)
{
// Debug.Log("UpdateTextureFromNative.NEW");
// Debug.Log(String.Format("NativeVideoSize({0}:{1})", _currentNativeVideoSize.x, _currentNativeVideoSize.y));
_videoTexture = Texture2D.CreateExternalTexture((int)_currentNativeVideoSize.x, (int)_currentNativeVideoSize.y, TextureFormat.RGBA32, true, true, nativeTexturePtr);
_videoTexture.filterMode = FilterMode.Bilinear;
_videoTexture.wrapMode = TextureWrapMode.Repeat;
}
else
{
// Debug.Log("UpdateTextureFromNative.RESIZE");
// Debug.Log(String.Format("NativeVideoSize({0}:{1})", _currentNativeVideoSize.x, _currentNativeVideoSize.y));
if (_oldNativeVideoSize.x != _currentNativeVideoSize.x || _oldNativeVideoSize.y != _currentNativeVideoSize.y)
{
//Debug.Log("UpdateTextureFromNative.RESIZE");
_videoTexture.Resize((int)_currentNativeVideoSize.x, (int)_currentNativeVideoSize.y, TextureFormat.RGBA32, true);
//_videoTexture.Apply();????
//Resources.UnloadUnusedAssets();
//GC.Collect;
}
}
_videoTexture.UpdateExternalTexture(nativeTexturePtr);
if (_isOnWindows)
{
_videoTexture.filterMode = (FilterMode)_filtermode;
_videoTexture.wrapMode = TextureWrapMode.Repeat;//.Clamp;
if (_filtermode != FilterModeMPMP.Point)
{
_videoTexture.anisoLevel = _anisoLevel + 1; // 16;
}
}
if (_videoMaterial != null)
{
_videoMaterial.SetTexture(texturePropertyName, _videoTexture);
if (_isOnWindows)
{
if (_filtermode != FilterModeMPMP.Point)
{
_videoMaterial.GetTexture(texturePropertyName).anisoLevel = _anisoLevel; //15
}
}
}
#endif
}//lock
_oldNativeVideoSize = _currentNativeVideoSize;
}
//callback Method is called from native plugin if we debug
static void CallbackNativeDebug(string str)
{
Debug.Log(String.Format("NATIVE::{0}", str));
}
void Awake()
{
// Debug.Log("::::::::::::::::::::::::::::::::::::::");
#if UNITY_EDITOR
EditorPlayMode.PlayModeChanged += OnPlayModeChanged;
#endif
Init();
if (Application.platform.ToString().StartsWith("OSX"))
{
OnPixelBufferError += (mpmp) => { Load(); };
}
/*
* OnTextureChanged += (mpmp) => {
* // _UpdateTextureFromNative();
* // _UpdateNativeVideoSize();
* // Vector2 size = mpmp.GetNativeVideoSize();
* // Debug.Log("OnTextureChanged:"+ size);
*
* };
*
* OnLoaded += (mpmp) =>
* {
* Debug.Log("OnLoaded");
* };
*/
SetUpdateFrequency(_updateFrequency);
if (_isOnWindows && _isOnWindows7)
{
return; // yield break;
}
// RenderEventFunc = GetRenderEventFunc();
#if !(UNITY_WEBGL && !UNITY_EDITOR)
RenderEventFunc = MPMP_GetRenderEventFunc();
#endif
#if ((UNITY_STANDALONE_WIN && !UNITY_EDITOR_OSX) || UNITY_EDITOR_WIN)
//Setup the debug callback system for Windows---
#if MPMP_DEBUG
//http://www.gamedev.net/page/resources/_/technical/game-programming/c-plugin-debug-log-with-unity-r3349
NativeCallbackDebugDelegate callbackDebug_delegate = new NativeCallbackDebugDelegate(CallbackNativeDebug);
_handleNativeCallbackDebug = GCHandle.Alloc(callbackDebug_delegate, GCHandleType.Pinned);
// Convert callback_delegate into a function pointer that can be used in unmanaged code.
_intptr_NativeCallbackDebug_delegate = Marshal.GetFunctionPointerForDelegate(callbackDebug_delegate);
// Call the API passing along the function pointer.
MPMP_SetDebugFunction(_intptr_NativeCallbackDebug_delegate);
try {
if (!MPMP_IsMEPlayerInitialized())
{
Debug.Log("InitDebugConsole");
MPMP_InitDebugConsole();
}
}
catch (Exception e)
{
Debug.Log("EXCEPTION:" + e.Message);
}
#endif
MPMP_UnityPluginInit();//Set the Unity graphics device in the native plugin
#endif //Windows
#if UNITY_ANDROID && !UNITY_EDITOR
AndroidJavaClass unity_jc = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
AndroidJavaObject activity_jo = unity_jc.GetStatic <AndroidJavaObject>("currentActivity");
AndroidJavaObject mpmp_jo = new AndroidJavaObject("org.monoflow.media.MPMP", activity_jo);
//AndroidJavaClass mpmp_jc = new AndroidJavaClass("org.monoflow.media.MPMP");
_id = mpmp_jo.Call <int>("GetId");
#else
//Windows,Editor,iOS
ColorSpace cs = QualitySettings.activeColorSpace;
bool isLinear = (cs == ColorSpace.Linear);
//There are some issues with dual graphic card setups/ NVIDIA and linear colorspace so we can force to use always RGB textures on the native side. But this will cause not accurate texture colors!
if (forceGamma)
{
isLinear = false;
}
_id = MPMP_New(isLinear); //Create the native player
#endif
// Debug.Log("ID:" + _id);
if (!_instances.ContainsKey(_id))
{
_instances.Add(_id, this);
}
//Setup the callback system-----------------------
// Call the API passing along the function pointer.
#if UNITY_EDITOR_OSX || UNITY_STANDALONE_OSX || (UNITY_IPHONE && !UNITY_EDITOR_WIN)
MPMP_SetCallbackFunction(_id, CallBackNativeAOT);
#else
//-------
#if UNITY_WEBGL && !UNITY_EDITOR
// SetCallbackFunction(WebGLCallbackFunc);
MPMP_SetCallbackFunction(_id, CallBackNativeAOT);
#else
NativeCallbackDelegate _callback_delegate = new NativeCallbackDelegate(CallBackNative);
_handleNativeCallback = GCHandle.Alloc(_callback_delegate, GCHandleType.Pinned);
// Convert callback_delegate into a function pointer that can be used in unmanaged code.
_intptr_NativeCallback_delegate = Marshal.GetFunctionPointerForDelegate(_callback_delegate);
MPMP_SetCallbackFunction(_id, _intptr_NativeCallback_delegate);
#endif
//---------
#endif
//--------------------------------------
MPMP_SetAutoPlay(_id, autoPlay);
MPMP_SetLooping(_id, looping);
MPMP_SetVolume(_id, _volume);
#if (UNITY_ANDROID && !UNITY_EDITOR)
Debug.Log("Application.dataPath: " + Application.dataPath);
Debug.Log("Application.streamingAssetsPath: " + Application.streamingAssetsPath);
if (Application.dataPath.Contains(".obb") || Application.dataPath.Contains("/base.apk"))
{
SetOBBPath(_id, Application.dataPath);
}
//SetOBBPath(_id,Application.dataPath);//DEBUG
GL.IssuePluginEvent(RenderEventFunc, _id); //Trigger the OpenGL Initializing
#endif
#if (UNITY_EDITOR_OSX || UNITY_STANDALONE_OSX || (UNITY_IPHONE && !UNITY_EDITOR_WIN)) && MPMP_DEBUG
_ext2_SetLogCallback(_id, NativeCallbackFunc);
#endif
_UpdateStatus();
//Unity 5.3 bug with multiple instances of this script .Normal Update interval is used!
//yield return StartCoroutine(_Update());
/*
* yield return new WaitForEndOfFrame();//One frame delay to be sure that all stuff is initialized on the native site
* if (OnInit != null) OnInit(this);
*
* yield break;
*/
}
public static void NativeCallbackFunc(string message)
{
Debug.Log("Unity:NativeCallbackFunc:" + message);
}
public void Bake(int raySamples, List <Renderer> renderers, Action <SDFVolume, float[], float, object> bakeComplete, object passthrough = null)
{
onBakeComplete = bakeComplete;
int progressInterval = _settings.CellCount / 4;
int progress = 0;
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
vec3 halfVoxel = _settings.HalfVoxel;
float maxDistance = 0f;
//adjusted to best timings from testing but it could vary by CPU
int calcRayLengthBatchCount = 32;
calcRayLengthBatchCount = Mathf.Clamp(calcRayLengthBatchCount, 1, raySamples);
int raycastBatchCount = 8;
raycastBatchCount = Mathf.Clamp(raycastBatchCount, 1, raySamples);
int prepareRaysBatchCount = 64;
prepareRaysBatchCount = Mathf.Clamp(prepareRaysBatchCount, 1, raySamples);
int compareBatchCount = 128;
//for raycast method front facing geo and flipped backfacing geo is required
List <Collider> geoFront = new List <Collider>();
List <Collider> geoBack = new List <Collider>();
CreateColliders(ref renderers, ref geoFront, ref geoBack);
//prepare data
NativeArray <float> distances = new NativeArray <float>(_settings.CellCount, Allocator.TempJob);
NativeArray <CellResults> allResults = new NativeArray <CellResults>(_settings.CellCount, Allocator.TempJob);
//constant for all cells
NativeArray <vec3> sphereSamples = new NativeArray <vec3>(raySamples, Allocator.TempJob);
//NativeArray<vec3> randomDirections = new NativeArray<vec3>(raySamples, Allocator.TempJob);
NativeArray <vec4> volumePlanes = new NativeArray <vec4>(6, Allocator.TempJob);
GetUniformPointsOnSphereNormalized(ref sphereSamples);
//GetRandomDirections( _halfVoxel*settings.JitterScale, settings.JitterSeed, ref randomDirections);
vec3 aabbMin = BoundsWorldAABB.min;
vec3 aabbMax = BoundsWorldAABB.max;
//the max ray length, used to normalize all resulting distances
//so they are treated as 0 to 1 within a volume
float aabbMagnitude = BoundsWorldAABB.size.magnitude;
Plane pl = new Plane(Vector3.right, aabbMin);
Plane pr = new Plane(Vector3.left, aabbMax);
Plane pd = new Plane(Vector3.up, aabbMin);
Plane pu = new Plane(Vector3.down, aabbMax);
Plane pb = new Plane(Vector3.forward, aabbMin);
Plane pf = new Plane(Vector3.back, aabbMax);
volumePlanes[0] = new vec4(pl.normal.x, pl.normal.y, pl.normal.z, pl.distance);
volumePlanes[1] = new vec4(pr.normal.x, pr.normal.y, pr.normal.z, pr.distance);
volumePlanes[2] = new vec4(pd.normal.x, pd.normal.y, pd.normal.z, pd.distance);
volumePlanes[3] = new vec4(pu.normal.x, pu.normal.y, pu.normal.z, pu.distance);
volumePlanes[4] = new vec4(pb.normal.x, pb.normal.y, pb.normal.z, pb.distance);
volumePlanes[5] = new vec4(pf.normal.x, pf.normal.y, pf.normal.z, pf.distance);
//iterate each cell performing raycasted samples
for (int i = 0; i < _settings.CellCount; i++)
{
#if UNITY_EDITOR
if (i % progressInterval == 0)
{
EditorUtility.DisplayProgressBar(strProgressTitle, strProgress, i / (float)_settings.CellCount);
}
#endif
vec3 positionWS = _settings.ToPositionWS(i, LocalToWorldNoScale);
vec3 centerVoxelWS = positionWS + halfVoxel;
NativeArray <float> rayLengths = new NativeArray <float>(raySamples, Allocator.TempJob);
NativeArray <RaycastCommand> allRaycastsFront = new NativeArray <RaycastCommand>(raySamples, Allocator.TempJob);
NativeArray <RaycastCommand> allRaycastsBack = new NativeArray <RaycastCommand>(raySamples, Allocator.TempJob);
NativeArray <RaycastHit> frontHits = new NativeArray <RaycastHit>(raySamples, Allocator.TempJob);
NativeArray <RaycastHit> backHits = new NativeArray <RaycastHit>(raySamples, Allocator.TempJob);
//calculate the ray lengths, just so rays are clipped within the volume when raycasting
CalculateRayLengths calcRayLengths = new CalculateRayLengths
{
Samples = sphereSamples,
VolumePlanes = volumePlanes,
RayLengths = rayLengths,
RayLength = aabbMagnitude,
RayOrigin = centerVoxelWS
};
JobHandle rayLengthHandle = calcRayLengths.Schedule(raySamples, calcRayLengthBatchCount);
//prepare raycasts front
PrepareRaycastCommands frontPrc = new PrepareRaycastCommands
{
Samples = sphereSamples,
RayLengths = rayLengths,
LayerMask = LAYER_MASK_FRONT,
Raycasts = allRaycastsFront,
RayOrigin = centerVoxelWS,
};
//prepare raycasts back
PrepareRaycastCommands backPrc = new PrepareRaycastCommands
{
Samples = sphereSamples,
RayLengths = rayLengths,
LayerMask = LAYER_MASK_BACK,
Raycasts = allRaycastsBack,
RayOrigin = centerVoxelWS,
};
//schedule front raycasts
JobHandle prepareFrontHandle = frontPrc.Schedule(
raySamples, prepareRaysBatchCount, rayLengthHandle);
JobHandle scheduleFrontHandle = RaycastCommand.ScheduleBatch(
allRaycastsFront, frontHits, raycastBatchCount, prepareFrontHandle);
//schedule back raycasts
JobHandle prepareBackHandle = backPrc.Schedule(
raySamples, prepareRaysBatchCount, rayLengthHandle);
JobHandle scheduleBackHandle = RaycastCommand.ScheduleBatch(
allRaycastsBack, backHits, raycastBatchCount, prepareBackHandle);
//combine handles
JobHandle frontBackHandle = JobHandle.CombineDependencies(scheduleFrontHandle, scheduleBackHandle);
//process results and put into current cell index
ProcessHits processHits = new ProcessHits
{
FrontHits = frontHits,
BackHits = backHits,
Results = allResults.Slice(i, 1),
};
JobHandle cellHandle = processHits.Schedule(frontBackHandle);
cellHandle.Complete();
rayLengths.Dispose();
allRaycastsFront.Dispose();
allRaycastsBack.Dispose();
frontHits.Dispose();
backHits.Dispose();
} //for each cell
//final distances
CompareDistances compareDistances = new CompareDistances
{
Distances = distances,
Results = allResults
};
JobHandle compareDistancesHandle = compareDistances.Schedule(_settings.CellCount, compareBatchCount);
compareDistancesHandle.Complete();
stopwatch.Stop();
Debug.Log("SDF bake completed in " + stopwatch.Elapsed.ToString("mm\\:ss\\.ff"));
#if UNITY_EDITOR
EditorUtility.ClearProgressBar();
#endif
float[] distancesOut = new float[_settings.CellCount];
distances.CopyTo(distancesOut);
//cleanup all the temp arrays
distances.Dispose();
allResults.Dispose();
sphereSamples.Dispose();
//randomDirections.Dispose();
volumePlanes.Dispose();
foreach (var c in geoFront)
{
Object.DestroyImmediate(c.gameObject);
}
foreach (var c in geoBack)
{
Object.DestroyImmediate(c.gameObject);
}
//NOTE do not use max distance, instead use aabbMagnitude so distance fields are interchangeable
bakeComplete?.Invoke(this, distancesOut, aabbMagnitude, passthrough);
}
public void Damage(int damageAmount)
{
Debug.Log("ouch!!@");
}
public static void OnKeyDown(this IInspectorDrawer inspectorDrawer, Event e)
{
#if DEV_MODE && DEBUG_KEYBOARD_INPUT
Debug.Log(StringUtils.ToColorizedString(inspectorDrawer.ToString(), ".OnKeyDown(", e.keyCode, ") with HasFocus=", inspectorDrawer.HasFocus, ", selectedControl=", StringUtils.ToString(inspectorDrawer.SelectedOrDefaultView().FocusedDrawer), ", SelectedPart=", inspectorDrawer.Manager.SelectedInspectorPart));
#endif
if (!inspectorDrawer.HasFocus)
{
return;
}
var view = inspectorDrawer.SelectedOrDefaultView();
var keys = view.Preferences.keyConfigs;
#if !POWER_INSPECTOR_LITE
if (keys.stepBackInSelectionHistory.DetectAndUseInput(e))
{
view.StepBackInSelectionHistory();
return;
}
if (keys.stepForwardInSelectionHistory.DetectAndUseInput(e))
{
view.StepForwardInSelectionHistory();
return;
}
#endif
inspectorDrawer.Repaint();
DrawGUI.RegisterInputEvent(e);
var activeView = inspectorDrawer.SelectedOrDefaultView();
inspectorDrawer.Manager.ActiveInspector = activeView;
// give controls time to react to selection changes, editing text field changes etc.
// before cached values are updated. (e.g. unapplied changes in delayed fields are
// not discarded before they have time to get applied
activeView.ResetNextUpdateCachedValues();
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(!inspectorDrawer.HasFocus || activeView.Selected);
#endif
#if DEV_MODE && DEBUG_KEYBOARD_INPUT
Debug.Log(StringUtils.ToColorizedString("OnKeyDown activeView.Selected=", activeView.Selected, ", activeView.FocusedDrawer=", activeView.FocusedDrawer + ", Manager.SelectedInspector=", inspectorDrawer.Manager.SelectedInspector, ", inspectorDrawer.HasFocus=", inspectorDrawer.HasFocus));
#endif
if (activeView.Toolbar.OnKeyboardInputGivenWhenNotSelected(e, activeView.Preferences.keyConfigs))
{
if (e.type != EventType.Used)
{
DrawGUI.Use(e);
ExitGUIUtility.ExitGUI();
}
}
IDrawer selectedControl = null;
if (activeView.Selected)
{
selectedControl = activeView.FocusedDrawer;
if (selectedControl != null)
{
var onKeyboardInputBeingGiven = selectedControl.OnKeyboardInputBeingGiven;
if (onKeyboardInputBeingGiven != null)
{
#if DEV_MODE && DEBUG_KEYBOARD_INPUT
Debug.Log("onKeyboardInputBeingGiven(" + StringUtils.ToString(e) + "): " + StringUtils.ToString(onKeyboardInputBeingGiven));
#endif
if (onKeyboardInputBeingGiven(selectedControl, e, selectedControl.Inspector.Preferences.keyConfigs))
{
return;
}
}
if (selectedControl.OnKeyboardInputGiven(e, selectedControl.Inspector.Preferences.keyConfigs))
{
return;
}
}
else if (inspectorDrawer.Manager.SelectedInspectorPart == InspectorPart.Toolbar)
{
activeView.Toolbar.OnKeyboardInputGiven(e, activeView.Preferences.keyConfigs);
}
else if (inspectorDrawer.Manager.SelectedInspectorPart == InspectorPart.Viewport || inspectorDrawer.Manager.SelectedInspectorPart == InspectorPart.None)
{
bool fieldChangeInputGiven;
if (keys.DetectNextField(e, true) || keys.DetectPreviousField(e, true) ||
keys.nextFieldLeft.DetectAndUseInput(e) || keys.nextFieldRight.DetectAndUseInput(e) ||
keys.nextFieldDown.DetectAndUseInput(e) || keys.nextFieldUp.DetectAndUseInput(e))
{
fieldChangeInputGiven = true;
}
else if (e.modifiers == EventModifiers.FunctionKey)
{
switch (e.keyCode)
{
case KeyCode.DownArrow:
case KeyCode.UpArrow:
case KeyCode.LeftArrow:
case KeyCode.RightArrow:
fieldChangeInputGiven = true;
break;
default:
fieldChangeInputGiven = false;
break;
}
}
else
{
fieldChangeInputGiven = false;
}
if (fieldChangeInputGiven)
{
var drawers = activeView.State.drawers;
if (drawers.Length == 0)
{
if (activeView.Toolbar != null)
{
activeView.Toolbar.OnFindCommandGiven();
}
else
{
KeyboardControlUtility.SetKeyboardControl(0, 3);
}
}
else
{
var first = drawers[0];
var select = first.GetNextSelectableDrawerRight(true, null);
#if DEV_MODE && DEBUG_NEXT_FIELD
Debug.Log(first + ".GetNextSelectableDrawerRight: " + StringUtils.ToString(select));
#endif
if (select != null)
{
activeView.Select(select, ReasonSelectionChanged.SelectNextControl);
}
}
}
}
}
if (DrawGUI.EditingTextField && keys.DetectTextFieldReservedInput(e, TextFieldType.TextRow))
{
#if DEV_MODE && DEBUG_KEYBOARD_INPUT
Debug.Log(StringUtils.ToColorizedString("OnKeyboardInputGiven( ", StringUtils.ToString(e), ") DetectTextFieldReservedInput: ", true, " with selectedControl=", selectedControl));
#endif
return;
}
if (keys.addComponent.DetectInput(e))
{
#if DEV_MODE
Debug.Log("AddComponent shortcut detected");
#endif
if (AddComponentButtonDrawer.OpenSelectedOrFirstFoundInstance(activeView))
{
DrawGUI.Use(e);
}
}
if (keys.toggleSplitView.DetectInput(e))
{
var splittable = inspectorDrawer as ISplittableInspectorDrawer;
if (splittable != null && splittable.CanSplitView)
{
DrawGUI.Use(e);
splittable.SetSplitView(!splittable.ViewIsSplit);
ExitGUIUtility.ExitGUI();
}
}
if (keys.refresh.DetectAndUseInput(e))
{
var selectedInspector = inspectorDrawer.Manager.SelectedInspector;
if (selectedInspector != null && selectedInspector.InspectorDrawer == inspectorDrawer)
{
selectedInspector.ForceRebuildDrawers();
ExitGUIUtility.ExitGUI();
}
else
{
var mainView = inspectorDrawer.MainView;
mainView.ForceRebuildDrawers();
var splittable = inspectorDrawer as ISplittableInspectorDrawer;
if (splittable != null && splittable.ViewIsSplit)
{
splittable.SplitView.ForceRebuildDrawers();
ExitGUIUtility.ExitGUI();
}
}
}
var keyCode = e.keyCode;
switch (keyCode)
{
case KeyCode.Menu:
if (selectedControl != null)
{
selectedControl.OpenContextMenu(e, selectedControl.RightClickArea, false, selectedControl.SelectedPart);
}
break;
case KeyCode.Space:
inspectorDrawer.Manager.RegisterKeyHeldDown(keyCode, "space");
break;
case KeyCode.F2:
inspectorDrawer.Repaint();
if (!DrawGUI.EditingTextField)
{
DrawGUI.Use(e);
DrawGUI.EditingTextField = true;
}
break;
case KeyCode.Escape:
#if DEV_MODE
Debug.Log("!!! ESCAPE !!!");
#endif
//when dragging a control, allow aborting using the escape key
if (inspectorDrawer.Manager.MouseDownInfo.MouseDownOverDrawer != null)
{
inspectorDrawer.Manager.MouseDownInfo.Clear();
}
if (DrawGUI.EditingTextField)
{
DrawGUI.Use(e);
DrawGUI.EditingTextField = false;
}
break;
case KeyCode.AltGr:
case KeyCode.RightAlt:
KeyConfig.OnAltGrDown();
break;
#if DEV_MODE
case KeyCode.I:
if (e.control && e.alt)
{
Debug.Log("INFO: FocusedDrawer=" + StringUtils.ToString(inspectorDrawer.SelectedOrDefaultView().FocusedDrawer) + ", EditingTextField=" + DrawGUI.EditingTextField);
}
break;
#endif
}
}
public AdjustParameter()
{
Debug.Log("AdjustParameter Constructor");
}
/// <summary>
/// Collect CPU combinations for the specified TargetPlatform and TargetCPU
/// </summary>
/// <param name="targetPlatform">The target platform (e.g Windows)</param>
/// <param name="targetCpu">The target CPU (e.g X64_SSE4)</param>
/// <param name="report">Error reporting</param>
/// <returns>The list of CPU combinations</returns>
private static List <BurstOutputCombination> CollectCombinations(TargetPlatform targetPlatform, TargetCpu targetCpu, BuildReport report)
{
var combinations = new List <BurstOutputCombination>();
if (targetPlatform == TargetPlatform.macOS)
{
// NOTE: OSX has a special folder for the plugin
// Declared in GetStagingAreaPluginsFolder
// PlatformDependent\OSXPlayer\Extensions\Managed\OSXDesktopStandalonePostProcessor.cs
#if UNITY_2019_3_OR_NEWER
combinations.Add(new BurstOutputCombination(Path.Combine(Path.GetFileName(report.summary.outputPath), "Contents", "Plugins"), targetCpu));
#else
combinations.Add(new BurstOutputCombination("UnityPlayer.app/Contents/Plugins", targetCpu));
#endif
}
else if (targetPlatform == TargetPlatform.iOS)
{
if (Application.platform != RuntimePlatform.OSXEditor)
{
Debug.LogWarning("Burst Cross Compilation to iOS for standalone player, is only supported on OSX Editor at this time, burst is disabled for this build.");
}
else
{
var targetArchitecture = (IOSArchitecture)UnityEditor.PlayerSettings.GetArchitecture(report.summary.platformGroup);
if (targetArchitecture == IOSArchitecture.ARMv7 || targetArchitecture == IOSArchitecture.Universal)
{
// PlatformDependent\iPhonePlayer\Extensions\Common\BuildPostProcessor.cs
combinations.Add(new BurstOutputCombination("StaticLibraries", TargetCpu.ARMV7A_NEON32, DefaultLibraryName + "32"));
}
if (targetArchitecture == IOSArchitecture.ARM64 || targetArchitecture == IOSArchitecture.Universal)
{
// PlatformDependent\iPhonePlayer\Extensions\Common\BuildPostProcessor.cs
combinations.Add(new BurstOutputCombination("StaticLibraries", TargetCpu.ARMV8A_AARCH64, DefaultLibraryName + "64"));
}
}
}
else if (targetPlatform == TargetPlatform.Android)
{
//TODO: would be better to query AndroidNdkRoot (but thats not exposed from unity)
string ndkRoot = null;
#if UNITY_2019_3_OR_NEWER && UNITY_ANDROID
ndkRoot = UnityEditor.Android.AndroidExternalToolsSettings.ndkRootPath;
#elif UNITY_2019_1_OR_NEWER
// 2019.1 now has an embedded ndk
if (EditorPrefs.HasKey("NdkUseEmbedded"))
{
if (EditorPrefs.GetBool("NdkUseEmbedded"))
{
ndkRoot = Path.Combine(BuildPipeline.GetPlaybackEngineDirectory(BuildTarget.Android, BuildOptions.None), "NDK");
}
else
{
ndkRoot = EditorPrefs.GetString("AndroidNdkRootR16b");
}
}
#endif
// If we still don't have a valid root, try the old key
if (string.IsNullOrEmpty(ndkRoot))
{
ndkRoot = EditorPrefs.GetString("AndroidNdkRoot");
}
// Verify the directory at least exists, if not we fall back to ANDROID_NDK_ROOT current setting
if (!string.IsNullOrEmpty(ndkRoot) && !Directory.Exists(ndkRoot))
{
ndkRoot = null;
}
// Always set the ANDROID_NDK_ROOT (if we got a valid result from above), so BCL knows where to find the Android toolchain and its the one the user expects
if (!string.IsNullOrEmpty(ndkRoot))
{
Environment.SetEnvironmentVariable("ANDROID_NDK_ROOT", ndkRoot);
}
var androidTargetArch = UnityEditor.PlayerSettings.Android.targetArchitectures;
if ((androidTargetArch & AndroidArchitecture.ARMv7) != 0)
{
combinations.Add(new BurstOutputCombination("libs/armeabi-v7a", TargetCpu.ARMV7A_NEON32));
}
if ((androidTargetArch & AndroidArchitecture.ARM64) != 0)
{
combinations.Add(new BurstOutputCombination("libs/arm64-v8a", TargetCpu.ARMV8A_AARCH64));
}
#if !UNITY_2019_2_OR_NEWER
if ((androidTargetArch & AndroidArchitecture.X86) != 0)
{
combinations.Add(new BurstOutputCombination("libs/x86", TargetCpu.X86_SSE2));
}
#endif
}
else if (targetPlatform == TargetPlatform.UWP)
{
// TODO: Make it configurable for x86 (sse2, sse4)
combinations.Add(new BurstOutputCombination("Plugins/x64", TargetCpu.X64_SSE4));
combinations.Add(new BurstOutputCombination("Plugins/x86", TargetCpu.X86_SSE2));
combinations.Add(new BurstOutputCombination("Plugins/ARM", TargetCpu.THUMB2_NEON32));
combinations.Add(new BurstOutputCombination("Plugins/ARM64", TargetCpu.ARMV8A_AARCH64));
}
else if (targetPlatform == TargetPlatform.Lumin)
{
// Set the LUMINSDK_UNITY so bcl.exe will be able to find the SDK
if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable("LUMINSDK_UNITY")))
{
var sdkRoot = EditorPrefs.GetString("LuminSDKRoot");
if (!string.IsNullOrEmpty(sdkRoot))
{
Environment.SetEnvironmentVariable("LUMINSDK_UNITY", sdkRoot);
}
}
combinations.Add(new BurstOutputCombination("Data/Plugins/", targetCpu));
}
else
{
combinations.Add(new BurstOutputCombination("Data/Plugins/", targetCpu));
}
return(combinations);
}
void Parse(string str, int maxDepth = -2, bool storeExcessLevels = false, bool strict = false)
{
if (!string.IsNullOrEmpty(str))
{
str = str.Trim(WHITESPACE);
if (strict)
{
if (str[0] != '[' && str[0] != '{')
{
type = Type.NULL;
Debug.LogWarning("Improper (strict) JSON formatting. First character must be [ or {");
return;
}
}
if (str.Length > 0)
{
#if UNITY_WP8
if (str == "true")
{
type = Type.BOOL;
b = true;
}
else if (str == "false")
{
type = Type.BOOL;
b = false;
}
else if (str == "null")
{
type = Type.NULL;
#else
if (string.Compare(str, "true", true) == 0)
{
type = Type.BOOL;
b = true;
}
else if (string.Compare(str, "false", true) == 0)
{
type = Type.BOOL;
b = false;
}
else if (string.Compare(str, "null", true) == 0)
{
type = Type.NULL;
#endif
#if USEFLOAT
}
else if (str == INFINITY)
{
type = Type.NUMBER;
n = float.PositiveInfinity;
}
else if (str == NEGINFINITY)
{
type = Type.NUMBER;
n = float.NegativeInfinity;
}
else if (str == NaN)
{
type = Type.NUMBER;
n = float.NaN;
#else
}
else if (str == INFINITY)
{
type = Type.NUMBER;
n = double.PositiveInfinity;
}
else if (str == NEGINFINITY)
{
type = Type.NUMBER;
n = double.NegativeInfinity;
}
else if (str == NaN)
{
type = Type.NUMBER;
n = double.NaN;
#endif
}
else if (str[0] == '"')
{
type = Type.STRING;
this.str = str.Substring(1, str.Length - 2);
}
else
{
int tokenTmp = 1;
/*
* Checking for the following formatting (www.json.org)
* object - {"field1":value,"field2":value}
* array - [value,value,value]
* value - string - "string"
* - number - 0.0
* - bool - true -or- false
* - null - null
*/
int offset = 0;
switch (str[offset])
{
case '{':
type = Type.OBJECT;
keys = new List <string>();
list = new List <JSONObject>();
break;
case '[':
type = Type.ARRAY;
list = new List <JSONObject>();
break;
default:
try {
#if USEFLOAT
n = System.Convert.ToSingle(str);
#else
n = System.Convert.ToDouble(str);
#endif
type = Type.NUMBER;
} catch (System.FormatException) {
type = Type.NULL;
Debug.LogWarning("improper JSON formatting:" + str);
}
return;
}
string propName = "";
bool openQuote = false;
bool inProp = false;
int depth = 0;
while (++offset < str.Length)
{
if (System.Array.IndexOf(WHITESPACE, str[offset]) > -1)
{
continue;
}
if (str[offset] == '\\')
{
offset += 1;
continue;
}
if (str[offset] == '"')
{
if (openQuote)
{
if (!inProp && depth == 0 && type == Type.OBJECT)
{
propName = str.Substring(tokenTmp + 1, offset - tokenTmp - 1);
}
openQuote = false;
}
else
{
if (depth == 0 && type == Type.OBJECT)
{
tokenTmp = offset;
}
openQuote = true;
}
}
if (openQuote)
{
continue;
}
if (type == Type.OBJECT && depth == 0)
{
if (str[offset] == ':')
{
tokenTmp = offset + 1;
inProp = true;
}
}
if (str[offset] == '[' || str[offset] == '{')
{
depth++;
}
else if (str[offset] == ']' || str[offset] == '}')
{
depth--;
}
//if (encounter a ',' at top level) || a closing ]/}
if ((str[offset] == ',' && depth == 0) || depth < 0)
{
inProp = false;
string inner = str.Substring(tokenTmp, offset - tokenTmp).Trim(WHITESPACE);
if (inner.Length > 0)
{
if (type == Type.OBJECT)
{
keys.Add(propName);
}
if (maxDepth != -1) //maxDepth of -1 is the end of the line
{
list.Add(Create(inner, (maxDepth < -1) ? -2 : maxDepth - 1));
}
else if (storeExcessLevels)
{
list.Add(CreateBakedObject(inner));
}
}
tokenTmp = offset + 1;
}
}
}
}
else
{
type = Type.NULL;
}
}
else
{
type = Type.NULL; //If the string is missing, this is a null
}
//Profiler.EndSample();
}
private void OnPostBuildPlayerScriptDLLsImpl(BuildReport report)
{
var aotSettingsForTarget = BurstPlatformAotSettings.GetOrCreateSettings(report.summary.platform);
// Early exit if burst is not activated or the platform is not supported
if (aotSettingsForTarget.DisableBurstCompilation || !IsSupportedPlatform(report.summary.platform))
{
return;
}
var commonOptions = new List <string>();
var stagingFolder = Path.GetFullPath(TempStagingManaged);
var playerAssemblies = GetPlayerAssemblies(report);
// grab the location of the root of the player folder - for handling nda platforms that require keys
var keyFolder = BuildPipeline.GetPlaybackEngineDirectory(report.summary.platform, BuildOptions.None);
commonOptions.Add(GetOption(OptionAotKeyFolder, keyFolder));
// Extract the TargetPlatform and Cpu from the current build settings
TargetCpu targetCpu;
var targetPlatform = GetTargetPlatformAndDefaultCpu(report.summary.platform, out targetCpu);
commonOptions.Add(GetOption(OptionPlatform, targetPlatform));
// --------------------------------------------------------------------------------------------------------
// 1) Calculate AssemblyFolders
// These are the folders to look for assembly resolution
// --------------------------------------------------------------------------------------------------------
var assemblyFolders = new List <string> {
stagingFolder
};
if (report.summary.platform == BuildTarget.WSAPlayer)
{
// On UWP, not all assemblies are copied to StagingArea, so we want to
// find all directories that we can reference assemblies from
// If we don't do this, we will crash with AssemblyResolutionException
// when following type references.
foreach (var assembly in playerAssemblies)
{
foreach (var assemblyRef in assembly.compiledAssemblyReferences)
{
// Exclude folders with assemblies already compiled in the `folder`
var assemblyName = Path.GetFileName(assemblyRef);
if (assemblyName != null && File.Exists(Path.Combine(stagingFolder, assemblyName)))
{
continue;
}
var directory = Path.GetDirectoryName(assemblyRef);
if (directory != null)
{
var fullPath = Path.GetFullPath(directory);
if (IsMonoReferenceAssemblyDirectory(fullPath) || IsDotNetStandardAssemblyDirectory(fullPath))
{
// Don't pass reference assemblies to burst because they contain methods without implementation
// If burst accidentally resolves them, it will emit calls to burst_abort.
fullPath = Path.Combine(EditorApplication.applicationContentsPath, "MonoBleedingEdge/lib/mono/unityaot");
fullPath = Path.GetFullPath(fullPath); // GetFullPath will normalize path separators to OS native format
if (!assemblyFolders.Contains(fullPath))
{
assemblyFolders.Add(fullPath);
}
fullPath = Path.Combine(fullPath, "Facades");
if (!assemblyFolders.Contains(fullPath))
{
assemblyFolders.Add(fullPath);
}
}
else if (!assemblyFolders.Contains(fullPath))
{
assemblyFolders.Add(fullPath);
}
}
}
}
}
// Copy assembly used during staging to have a trace
if (BurstLoader.IsDebugging)
{
try
{
var copyAssemblyFolder = Path.Combine(Environment.CurrentDirectory, "Logs", "StagingAssemblies");
try
{
if (Directory.Exists(copyAssemblyFolder))
{
Directory.Delete(copyAssemblyFolder);
}
}
catch
{
}
if (!Directory.Exists(copyAssemblyFolder))
{
Directory.CreateDirectory(copyAssemblyFolder);
}
foreach (var file in Directory.EnumerateFiles(stagingFolder))
{
File.Copy(file, Path.Combine(copyAssemblyFolder, Path.GetFileName(file)));
}
}
catch
{
}
}
// --------------------------------------------------------------------------------------------------------
// 2) Calculate root assemblies
// These are the assemblies that the compiler will look for methods to compile
// This list doesn't typically include .NET runtime assemblies but only assemblies compiled as part
// of the current Unity project
// --------------------------------------------------------------------------------------------------------
var rootAssemblies = new List <string>();
foreach (var playerAssembly in playerAssemblies)
{
// the file at path `playerAssembly.outputPath` is actually not on the disk
// while it is in the staging folder because OnPostBuildPlayerScriptDLLs is being called once the files are already
// transferred to the staging folder, so we are going to work from it but we are reusing the file names that we got earlier
var playerAssemblyPathToStaging = Path.Combine(stagingFolder, Path.GetFileName(playerAssembly.outputPath));
if (!File.Exists(playerAssemblyPathToStaging))
{
Debug.LogWarning($"Unable to find player assembly: {playerAssemblyPathToStaging}");
}
else
{
rootAssemblies.Add(playerAssemblyPathToStaging);
}
}
commonOptions.AddRange(assemblyFolders.Select(folder => GetOption(OptionAotAssemblyFolder, folder)));
// --------------------------------------------------------------------------------------------------------
// 3) Calculate the different target CPU combinations for the specified OS
//
// Typically, on some platforms like iOS we can be asked to compile a ARM32 and ARM64 CPU version
// --------------------------------------------------------------------------------------------------------
var combinations = CollectCombinations(targetPlatform, targetCpu, report);
// --------------------------------------------------------------------------------------------------------
// 4) Compile each combination
//
// Here bcl.exe is called for each target CPU combination
// --------------------------------------------------------------------------------------------------------
string debugLogFile = null;
if (BurstLoader.IsDebugging)
{
// Reset log files
try
{
var logDir = Path.Combine(Environment.CurrentDirectory, "Logs");
debugLogFile = Path.Combine(logDir, "burst_bcl_editor.log");
if (!Directory.Exists(logDir))
{
Directory.CreateDirectory(logDir);
}
File.WriteAllText(debugLogFile, string.Empty);
}
catch
{
debugLogFile = null;
}
}
// Log the targets generated by BurstReflection.FindExecuteMethods
foreach (var combination in combinations)
{
// Gets the output folder
var stagingOutputFolder = Path.GetFullPath(Path.Combine(TempStaging, combination.OutputPath));
var outputFilePrefix = Path.Combine(stagingOutputFolder, combination.LibraryName);
var options = new List <string>(commonOptions)
{
GetOption(OptionAotOutputPath, outputFilePrefix),
GetOption(OptionTarget, combination.TargetCpu)
};
if (targetPlatform == TargetPlatform.iOS)
{
options.Add(GetOption(OptionStaticLinkage));
}
// finally add method group options
options.AddRange(rootAssemblies.Select(path => GetOption(OptionRootAssembly, path)));
// Log the targets generated by BurstReflection.FindExecuteMethods
if (BurstLoader.IsDebugging && debugLogFile != null)
{
try
{
var writer = new StringWriter();
writer.WriteLine("-----------------------------------------------------------");
writer.WriteLine("Combination: " + combination);
writer.WriteLine("-----------------------------------------------------------");
foreach (var option in options)
{
writer.WriteLine(option);
}
writer.WriteLine("Assemblies in AssemblyFolders:");
foreach (var assemblyFolder in assemblyFolders)
{
writer.WriteLine("|- Folder: " + assemblyFolder);
foreach (var assemblyOrDll in Directory.EnumerateFiles(assemblyFolder, "*.dll"))
{
var fileInfo = new FileInfo(assemblyOrDll);
writer.WriteLine(" |- " + assemblyOrDll + " Size: " + fileInfo.Length + " Date: " + fileInfo.LastWriteTime);
}
}
File.AppendAllText(debugLogFile, writer.ToString());
}
catch
{
// ignored
}
}
// Write current options to the response file
var responseFile = Path.GetTempFileName();
File.WriteAllLines(responseFile, options);
if (BurstLoader.IsDebugging)
{
Debug.Log($"bcl @{responseFile}\n\nResponse File:\n" + string.Join("\n", options));
}
try
{
string generatedDebugInformationInOutput = "";
if ((report.summary.options & BuildOptions.Development) != 0)
{
generatedDebugInformationInOutput = GetOption(OptionDebug);
}
BclRunner.RunManagedProgram(Path.Combine(BurstLoader.RuntimePath, BurstAotCompilerExecutable),
$"{generatedDebugInformationInOutput} @{responseFile}",
new BclOutputErrorParser(),
report);
}
catch (BuildFailedException)
{
throw;
}
catch (Exception e)
{
throw new BuildFailedException(e);
}
}
}
public void Log(string txt, LogType type = LogType.Log, Exception e = null,
Dictionary <string, string> data = null)
{
var dataString = string.Empty;
if (data != null)
{
dataString = DataToString.DetailString(data);
}
string stack;
#if UNITY_EDITOR
string frame = $"thread: {Environment.CurrentManagedThreadId}";
try
{
if (MAINTHREADID == Environment.CurrentManagedThreadId)
{
frame += $" frame: {Time.frameCount}";
}
}
catch
{
//there is something wrong with Environment.CurrentManagedThreadId
}
#endif
switch (type)
{
case LogType.Log:
{
#if UNITY_EDITOR
stack = ExtractFormattedStackTrace();
Debug.Log($"{frame} <b><color=teal>".FastConcat(txt, "</color></b> ", Environment.NewLine, stack)
.FastConcat(Environment.NewLine, dataString));
#else
Debug.Log(txt);
#endif
break;
}
case LogType.LogDebug:
{
#if UNITY_EDITOR
stack = ExtractFormattedStackTrace();
Debug.Log($"{frame} <b><color=orange>".FastConcat(txt, "</color></b> ", Environment.NewLine, stack)
.FastConcat(Environment.NewLine, dataString));
#else
Debug.Log(txt);
#endif
break;
}
case LogType.Warning:
{
#if UNITY_EDITOR
stack = ExtractFormattedStackTrace();
Debug.LogWarning($"{frame} <b><color=yellow>".FastConcat(txt, "</color></b> ", Environment.NewLine, stack)
.FastConcat(Environment.NewLine, dataString));
#else
Debug.LogWarning(txt);
#endif
break;
}
case LogType.Error:
case LogType.Exception:
{
if (e != null)
{
txt = txt.FastConcat(e.Message);
stack = ExtractFormattedStackTrace(new StackTrace(e, true));
}
else
{
stack = ExtractFormattedStackTrace();
}
#if UNITY_EDITOR
var fastConcat = $"{frame} <b><color=red>".FastConcat(txt, "</color></b> ", Environment.NewLine, stack)
.FastConcat(Environment.NewLine, dataString);
if (MAINTHREADID == Environment.CurrentManagedThreadId)
{
var error = Application.GetStackTraceLogType(UnityEngine.LogType.Error);
Application.SetStackTraceLogType(UnityEngine.LogType.Error, StackTraceLogType.None);
Debug.LogError(fastConcat);
Application.SetStackTraceLogType(UnityEngine.LogType.Error, error);
}
else
{
Debug.LogError(txt);
}
#else
if (type == LogType.Error)
{
Debug.LogError(txt);
}
else
if (e != null)
{
Debug.LogException(e);
}
#endif
break;
}
}
}
private static void RunProgram(
Program p,
string exe,
string args,
string workingDirectory,
CompilerOutputParserBase parser,
BuildReport report)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
using (p)
{
p.GetProcessStartInfo().WorkingDirectory = workingDirectory;
p.Start();
p.WaitForExit();
stopwatch.Stop();
Console.WriteLine("{0} exited after {1} ms.", (object)exe, (object)stopwatch.ElapsedMilliseconds);
IEnumerable <UnityEditor.Scripting.Compilers.CompilerMessage> compilerMessages = null;
string[] errorOutput = p.GetErrorOutput();
string[] standardOutput = p.GetStandardOutput();
if (parser != null)
{
compilerMessages = parser.Parse(errorOutput, standardOutput, true, "n/a (burst)");
}
var errorMessageBuilder = new StringBuilder();
if (p.ExitCode != 0)
{
if (compilerMessages != null)
{
foreach (UnityEditor.Scripting.Compilers.CompilerMessage compilerMessage in compilerMessages)
{
Debug.LogPlayerBuildError(compilerMessage.message, compilerMessage.file, compilerMessage.line, compilerMessage.column);
}
}
// We try to output the version in the heading error if we can
var matchVersion = MatchVersion.Match(exe);
errorMessageBuilder.Append(matchVersion.Success ?
"Burst compiler (" + matchVersion.Groups[1].Value + ") failed running" :
"Burst compiler failed running");
errorMessageBuilder.AppendLine();
errorMessageBuilder.AppendLine();
// Don't output the path if we are not burst-debugging or the exe exist
if (BurstLoader.IsDebugging || !File.Exists(exe))
{
errorMessageBuilder.Append(exe).Append(" ").Append(args);
errorMessageBuilder.AppendLine();
errorMessageBuilder.AppendLine();
}
errorMessageBuilder.AppendLine("stdout:");
foreach (string str in standardOutput)
{
errorMessageBuilder.AppendLine(str);
}
errorMessageBuilder.AppendLine("stderr:");
foreach (string str in errorOutput)
{
errorMessageBuilder.AppendLine(str);
}
throw new BuildFailedException(errorMessageBuilder.ToString());
}
Console.WriteLine(p.GetAllOutput());
}
}
void BuildTreeInternal(PWNode node, BiomeSwitchNode currentNode, int depth, BiomeSwitchNode parent = null)
{
if (node == null)
{
return;
}
//TODO: anchor to multiple PWNodeBiomeSwitch management
if (node.GetType() == typeof(PWNodeBiomeSwitch))
{
PWNodeBiomeSwitch bSwitch = node as PWNodeBiomeSwitch;
int outputLinksCount = bSwitch.GetLinks().Count;
int childIndex = 0;
List <PWNode> outputNodeList = new List <PWNode>();
Debug.Log("encountered switch: " + bSwitch.switchMode);
currentNode.SetChildCount(outputLinksCount);
switch (bSwitch.switchMode)
{
case BiomeSwitchMode.Water:
int?terrestrialAnchorId = node.GetAnchorId(PWAnchorType.Output, 0);
int?aquaticAnchorId = node.GetAnchorId(PWAnchorType.Output, 1);
if (terrestrialAnchorId != null)
{
var nodes = node.GetNodesAttachedToAnchor(terrestrialAnchorId.Value);
outputNodeList.AddRange(nodes);
// Debug.Log("terrestrialNodes: " + nodes[0].nodeId);
for (int i = 0; i < nodes.Count; i++)
{
currentNode.GetChildAt(childIndex++).SetSwitchValue(false, bSwitch.switchMode, "terrestrial", Color.black);
}
biomeCoverage[BiomeSwitchMode.Water] += 0.5f;
}
//get all nodes on the first anchor:
if (aquaticAnchorId != null)
{
var nodes = node.GetNodesAttachedToAnchor(aquaticAnchorId.Value);
// Debug.Log("aquaticNodes: " + nodes[0].nodeId);
outputNodeList.AddRange(nodes);
for (int i = 0; i < nodes.Count; i++)
{
currentNode.GetChildAt(childIndex++).SetSwitchValue(true, bSwitch.switchMode, "aquatic", Color.blue);
}
biomeCoverage[BiomeSwitchMode.Water] += 0.5f;
}
break;
default:
// Debug.Log("swicth data count for node " + node.nodeId + ": " + bSwitch.switchDatas.Count);
for (int anchorIndex = 0; anchorIndex < bSwitch.switchDatas.Count; anchorIndex++)
{
int?anchorId = node.GetAnchorId(PWAnchorType.Output, anchorIndex);
var sData = bSwitch.switchDatas[anchorIndex];
if (anchorId == null)
{
continue;
}
var attachedNodesToAnchor = node.GetNodesAttachedToAnchor(anchorId.Value);
outputNodeList.AddRange(attachedNodesToAnchor);
// if (attachedNodesToAnchor.Count == 0)
// Debug.LogWarning("nothing attached to the biome switch output " + anchorIndex);
foreach (var attachedNode in attachedNodesToAnchor)
{
var child = currentNode.GetChildAt(childIndex++);
child.SetSwitchValue(sData.min, sData.max, bSwitch.switchMode, sData.name, sData.color);
}
biomeCoverage[bSwitch.switchMode] += (sData.max - sData.min) / (sData.absoluteMax - sData.absoluteMin);
}
break;
}
childIndex = 0;
foreach (var outNode in outputNodeList)
{
if (bSwitch.switchMode == BiomeSwitchMode.Water)
{
Debug.Log("water switch mode output type: " + currentNode.GetChildAt(childIndex) + " [" + childIndex + "] -> " + outNode);
}
BuildTreeInternal(outNode, currentNode.GetChildAt(childIndex, true), depth + 1, currentNode);
Type outNodeType = outNode.GetType();
if (outNodeType == typeof(PWNodeBiomeSwitch) || outNodeType == typeof(PWNodeBiomeBinder))
{
childIndex++;
}
}
}
else if (node.GetType() == typeof(PWNodeBiomeBinder))
{
PWNodeBiomeBinder binder = node as PWNodeBiomeBinder;
string biomeName = currentNode.biomeName;
if (String.IsNullOrEmpty(biomeName))
{
Debug.LogWarning("Biome name null or empty for biomeBinder: " + binder);
return;
}
//Biome binder detected, assign the biome to the current Node:
currentNode.biome = binder.outputBiome;
// Debug.Log("current node: " + currentNode + ", preview color: " + currentNode.previewColor);
//set the color of the biome in the binder
binder.outputBiome.previewColor = currentNode.previewColor;
Debug.Log("set biome " + currentNode.biome + " in node " + currentNode);
//set the biome ID and name:
currentNode.biome.name = biomeName;
currentNode.biome.id = biomeIdCount++;
//store the biome in dictionaries for fast access
biomePerId[currentNode.biome.id] = currentNode.biome;
biomePerName[biomeName] = currentNode.biome;
}
else
{
foreach (var outNode in node.GetOutputNodes())
{
BuildTreeInternal(outNode, currentNode, depth++, parent);
}
}
return;
}
// Update the view count as often as possible
private IEnumerator UpdateViews()
{
while (Connected && IRC.ChannelName.Length > 0)
{
var form = new WWWForm();
form.AddField("name", "value");
var headers = form.headers;
var url = "https://api.twitch.tv/kraken/streams/" + IRC.ChannelName;
headers["Client-ID"] = "REMOVED FOR GITHUB"; //#TODO Replace with your Client-ID
var www = new WWW(url, null, headers);
yield return(www);
if (string.IsNullOrEmpty(www.error))
{
var obj = JsonUtility.FromJson <ChannelDataFull>(www.text);
if (obj != null)
{
if (obj.stream != null)
{
if (obj.stream.channel != null)
{
if (ChannelNameTextMesh != null)
{
var text = "";
if (!string.IsNullOrEmpty(obj.stream.channel.display_name))
{
text = string.Format("#{0}", obj.stream.channel.display_name);
}
else if (!string.IsNullOrEmpty(obj.stream.channel.name))
{
text = string.Format("#{0}", obj.stream.channel.name);
}
else
{
text = "Not Streaming";
}
ChannelNameTextMesh.text = text;
}
if (ViewerCountTextMesh != null)
{
ViewerCountTextMesh.text = string.Format("Viewers: {0}", obj.stream.viewers);
}
}
else
{
ClearViewerCountAndChannelName();
}
}
else
{
ClearViewerCountAndChannelName();
}
}
}
else
{
Debug.LogError("Error on page (" + url + "): " + www.error);
}
yield return(new WaitForSeconds(10f));
}
}
private void LoadAndParseAllowedAssemblies()
{
#if DEBUG_NORMAL
Debug.Log(Constants.LOG_PREFIX + "Starting LoadAndParseAllowedAssemblies()", this);
Stopwatch sw = Stopwatch.StartNew();
#endif
TextAsset assembliesSignatures = (TextAsset)Resources.Load("fndid", typeof(TextAsset));
if (assembliesSignatures == null)
{
signaturesAreNotGenuine = true;
return;
}
#if DEBUG_NORMAL
sw.Stop();
Debug.Log(Constants.LOG_PREFIX + "Creating separator array and opening MemoryStream", this);
sw.Start();
#endif
string[] separator = { ":" };
MemoryStream ms = new MemoryStream(assembliesSignatures.bytes);
BinaryReader br = new BinaryReader(ms);
int count = br.ReadInt32();
#if DEBUG_NORMAL
sw.Stop();
Debug.Log(Constants.LOG_PREFIX + "Allowed assemblies count from MS: " + count, this);
sw.Start();
#endif
allowedAssemblies = new AllowedAssembly[count];
for (int i = 0; i < count; i++)
{
string line = br.ReadString();
#if DEBUG_PARANOID
sw.Stop();
Debug.Log(Constants.LOG_PREFIX + "Line: " + line, this);
sw.Start();
#endif
line = ObscuredString.EncryptDecrypt(line, "Elina");
#if DEBUG_PARANOID
sw.Stop();
Debug.Log(Constants.LOG_PREFIX + "Line decrypted : " + line, this);
sw.Start();
#endif
string[] strArr = line.Split(separator, StringSplitOptions.RemoveEmptyEntries);
int stringsCount = strArr.Length;
#if DEBUG_PARANOID
sw.Stop();
Debug.Log(Constants.LOG_PREFIX + "stringsCount : " + stringsCount, this);
sw.Start();
#endif
if (stringsCount > 1)
{
string assemblyName = strArr[0];
int[] hashes = new int[stringsCount - 1];
for (int j = 1; j < stringsCount; j++)
{
hashes[j - 1] = int.Parse(strArr[j]);
}
allowedAssemblies[i] = new AllowedAssembly(assemblyName, hashes);
}
else
{
signaturesAreNotGenuine = true;
br.Close();
ms.Close();
#if DEBUG_NORMAL
sw.Stop();
#endif
return;
}
}
br.Close();
ms.Close();
Resources.UnloadAsset(assembliesSignatures);
#if DEBUG_NORMAL
sw.Stop();
Debug.Log(Constants.LOG_PREFIX + "Allowed Assemblies parsing duration: " + sw.ElapsedMilliseconds + " ms.", this);
#endif
hexTable = new string[256];
for (int i = 0; i < 256; i++)
{
hexTable[i] = i.ToString("x2");
}
}
// Build the given messages and materials into a list of lines for our TextMeshes
private void WordWrapText(List <TwitchChat> messages, TwitchEmoteMaterialRecycler.EmoteMaterial[] mats) // TODO: Don't rebuild the #$%^ing list every time we get a message, just push the data along and rebuild the newest line
{
try
{
lock (BuilderLocker)
{
mats = mats.DistinctBy(p => p.Id).ToArray();
_emoteMap.Clear();
for (var i = 0; i < mats.Length; i++)
{
_emoteMap.Add(mats[i].Id, mats[i].Material);
}
const int maxEmotesPerLine = 7;
var lines = new List <LineEmotePair>();
TextMesh.text = "";
var ren = TextMesh.GetComponent <Renderer>();
const float rowLimit = 0.975f; //find the sweet spot
var messageEmotes = new List <MaterialIndexPair> [messages.Count];
for (var mi = 0; mi < messages.Count; mi++)
{
messageEmotes[mi] = new List <MaterialIndexPair>();
}
for (var mi = 0; mi < messages.Count; mi++)
{
var m = messages[mi];
TextMesh.text = string.Format("<color=#{0}FF>{1}</color>: ", m.Color, m.Name);
var builder = "";
var message = m.Message;
// Insert the Emotes for this message
if (m.Emotes != null && m.Emotes.Count > 0)
{
var indexIncrease = 0;
var nextIndex = 0;
foreach (var key in m.Emotes)
{
// Cache the emote list so we can have seven unique emotes per message
Material mat;
if (!_emoteMap.TryGetValue(key.EmoteId, out mat))
{
continue;
}
var ind = 0;
var foundKey = false;
foreach (var matPair in messageEmotes[mi].Where(matPair => key.EmoteId == matPair.EmoteId))
{
foundKey = true;
ind = matPair.Index;
break;
}
if (!foundKey)
{
ind = nextIndex;
messageEmotes[mi].Add(new MaterialIndexPair(ind, key.EmoteId, mat));
nextIndex++;
}
var text = string.Format("<quad material={0} size=64 x=0 y=0 width=1 height=1 />", ind);
message = message.Insert(key.EmoteStart + indexIncrease, text);
indexIncrease += text.Length;
}
}
// Convert this message into Lines, such that they do not exceed the bounds of the chat box
var buildingQuad = false;
var buildingQuadNow = false;
var quadBuilder = "";
var parts = message.Split(' ');
var lineEmotes = new List <MaterialIndexPair>();
var lineEmoteCount = 0;
var emotes = messageEmotes[mi].ToArray();
var emoteMap = new Dictionary <int, int>();
var currentIndex = -1;
foreach (var t in parts)
{
builder = TextMesh.text;
if (t == "<quad") // This is the beginning of an emote
{
buildingQuad = true;
}
if (!buildingQuad)
{
// Add these text pieces
TextMesh.text += t + " ";
if (ren.bounds.extents.x > rowLimit)
{
lines.Add(new LineEmotePair(builder.TrimEnd(), lineEmotes.ToArray()));
lineEmotes.Clear();
emoteMap.Clear();
lineEmoteCount = 0;
TextMesh.text = t + " ";
}
builder = TextMesh.text;
}
else
{
if (buildingQuadNow || lineEmoteCount < maxEmotesPerLine)
{
buildingQuadNow = true; // Allow an emoji to finish building even if it exceeds the limits
// Here we are constructing the quad used in the TextMesh so that it will display an Emoji
string te;
if (t.StartsWith("material="))
{
// Remap the materials for this line
var index = int.Parse(t.Substring(9, 1));
currentIndex = index;
int ind;
if (emoteMap.TryGetValue(index, out ind))
{
// This emote was already used on this line
te = "material=" + ind;
}
else
{
// This emote is new to this line, we must map it for future use on this line
lineEmoteCount++;
lineEmotes.Add(new MaterialIndexPair(lineEmoteCount, emotes[index].EmoteId, emotes[index].Material));
te = "material=" + lineEmoteCount;
emoteMap.Add(index, lineEmoteCount);
}
}
else
{
te = t;
}
quadBuilder += te + " ";
if (t != "/>")
{
continue;
}
buildingQuad = false;
buildingQuadNow = false;
TextMesh.text += quadBuilder.TrimEnd() + " ";
if (currentIndex == -1)
{
Debug.LogWarning("This shouldn't happen..");
continue;
}
if (ren.bounds.extents.x > rowLimit)
{
// This Emoji violates the line's bounds
// Check if this material belongs on the next line only
var curId = lineEmotes[lineEmoteCount - 1].EmoteId;
var count = 0;
foreach (var emote in lineEmotes.Where(emote => emote.EmoteId == curId))
{
count++;
if (count >= 2)
{
break;
}
}
if (count == 1)
{
lineEmotes.RemoveAt(lineEmoteCount - 1); // Remove the last material if it only belongs to this emote
}
lines.Add(new LineEmotePair(builder.TrimEnd(), lineEmotes.ToArray())); // Assign the previous working buffer to the last line
// Push this Emoji to the next line and reconstruct it there
lineEmotes.Clear();
emoteMap.Clear();
var nextQuad = "";
var nexQuadParts = quadBuilder.Split(' ');
lineEmoteCount = 1;
// Reconstruct this Emoji for the next line
foreach (var tt in nexQuadParts)
{
string tte;
if (tt.StartsWith("material="))
{
tte = "material=" + lineEmoteCount;
}
else
{
tte = tt;
}
nextQuad += tte + " ";
}
// Update the Emoji map with the material for the Emoji being pushed to the next line
lineEmotes.Add(new MaterialIndexPair(lineEmoteCount, emotes[currentIndex].EmoteId, emotes[currentIndex].Material));
emoteMap.Add(currentIndex, lineEmoteCount);
currentIndex = -1;
TextMesh.text = " " + nextQuad.Trim() + " ";
}
// Clear the working buffers
builder = TextMesh.text;
quadBuilder = "";
}
else // Too many emotes on this line, ignore this quad
{
if (t != "/>")
{
continue;
}
buildingQuad = false;
}
}
}
lines.Add(new LineEmotePair(builder.TrimEnd(), lineEmotes.ToArray())); // Add the final line from the builder to the list of lines
}
// Clear the builder's text
TextMesh.text = "";
// Remove excess lines
while (lines.Count > ChatLineCount)
{
lines.RemoveAt(0);
}
// Set the Emote materials and TextMesh texts
var offset = ChatLineCount - lines.Count;
for (var i = 0; i < ChatLineCount; i++)
{
if (i >= lines.Count)
{
continue;
}
SetMaterialSize(ChatTextRenderers[i + offset], lines[i].EmoteList.Length + 1);
for (var j = 0; j < lines[i].EmoteList.Length; j++)
{
SetMaterial(ChatTextRenderers[i + offset], lines[i].EmoteList[j].Index, lines[i].EmoteList[j].Material);
}
ChatTextMeshes[i + offset].text = lines[i].LineText;
}
// Refresh the texts to force them to display correctly
foreach (TextMesh t in ChatTextMeshes)
{
t.anchor = TextAnchor.UpperLeft;
t.anchor = TextAnchor.LowerLeft;
}
}
}
catch (Exception e)
{
Debug.LogException(e);
}
}
public static void Dispose()
{
Debug.LogError(FINAL_LOG_PREFIX + "is not supported on selected platform!");
}
// ========================================================================== //
/* protected - Override & Unity API */
private void OnGUI()
{
UnitySO_GeneratorConfig pConfig = UnitySO_GeneratorConfig.instance;
if (pConfig == null)
{
Debug.LogError("pConfig == null");
return;
}
GUILayout.Space(10f);
DrawPath_File(pConfig, "Credential Path", ref pConfig.strCredential_FilePath);
GUILayout.Space(10f);
DrawPath_Folder(pConfig, "SOScript Folder Path", ref pConfig.strSOScript_FolderPath);
DrawPath_Folder(pConfig, "Json Data Folder Path", ref pConfig.strJsonData_FolderPath);
GUILayout.Space(10f);
DrawPath_Folder(pConfig, "SO Export Path", ref pConfig.strDataExport_FolderPath);
if (_pTypeDataList == null)
{
ParsingConfig(pConfig);
}
GUILayout.BeginHorizontal();
{
EditorGUI.BeginChangeCheck();
pConfig.pTypeDataFile = (TextAsset)EditorGUILayout.ObjectField("TypeData File : ", pConfig.pTypeDataFile, typeof(TextAsset), false, GUILayout.Width(700f));
if (EditorGUI.EndChangeCheck())
{
pConfig.DoSave();
}
if (GUILayout.Button("Parsing File"))
{
if (ParsingConfig(pConfig) == false)
{
Debug.LogError("TypeDataList JsonParsing Fail");
return;
}
}
}
GUILayout.EndHorizontal();
GUILayout.Space(30f);
if (_pTypeDataList != null)
{
GUILayout.Label($"TypeData File is Valid");
}
else
{
GUILayout.Label($"TypeData File is InValid");
}
bool bIsPossibleUpdate = Check_IsPossible_Update(pConfig);
GUI.enabled = bIsPossibleUpdate;
if (GUILayout.Button("Update Form Local", GUILayout.Width(200f)))
{
DoUpdate_FromLocalFile();
}
GUILayout.Space(30f);
GUILayout.BeginHorizontal();
{
GUILayout.Label($"SheetID : ", GUILayout.Width(100f));
EditorGUI.BeginChangeCheck();
pConfig.strSheetID = GUILayout.TextField(pConfig.strSheetID);
if (EditorGUI.EndChangeCheck())
{
pConfig.DoSave();
}
if (GUILayout.Button("Connect!", GUILayout.Width(100f)))
{
#pragma warning disable 4014
DoConnect();
#pragma warning restore 4014
}
}
GUILayout.EndHorizontal();
if (_pConnector.bIsConnected)
{
GUILayout.Label($"Excel is Connected : {_strSheetID_Connected} - Sheet List");
}
else
{
GUILayout.Label($"Excel is Not Connected", GetRedGUIStyle());
}
GUILayout.Space(30f);
if (_pTypeDataList == null)
{
return;
}
bool bIsMatchSheetID = Check_IsMatch_SheetID();
bool bIsPossibleDownload = Check_IsPossibleDownload(bIsMatchSheetID);
DrawSheetsScroll(pConfig, bIsPossibleUpdate, bIsPossibleDownload);
GUILayout.Space(30f);
if (bIsMatchSheetID == false)
{
GUILayout.Label($"SheetID Is Not Match - Local : {_pTypeDataList.strFileName}, Current Connected : {_strSheetID_Connected}", GetRedGUIStyle());
}
GUILayout.BeginHorizontal();
{
GUILayout.Label($"CommandLine : ", GUILayout.Width(100f));
EditorGUI.BeginChangeCheck();
pConfig.strSOCommandLine = GUILayout.TextField(pConfig.strSOCommandLine);
if (EditorGUI.EndChangeCheck())
{
pConfig.DoSave();
}
}
GUILayout.EndHorizontal();
GUI.enabled = bIsPossibleDownload;
if (GUILayout.Button("Download And Update", GUILayout.Width(200f)))
{
DoDownload_And_Update();
}
}
private static void ChangeFormat(List <string> fbxFiles)
{
ResConfig resConfig = null;
var databaseFile = "database_models_gltf.txt";
if (!File.Exists(databaseFile))
{
resConfig = new ResConfig()
{
items = new List <ResItem>()
};
}
else
{
var content = File.ReadAllText(databaseFile);
resConfig = JsonUtility.FromJson <ResConfig>(content);
}
bool hasError = false;
StringBuilder errorMsg = new StringBuilder();
string destDir = "res_models";
int totalCount = fbxFiles.Count;
int counter = 0;
foreach (var fbxFile in fbxFiles)
{
string input = Path.GetFullPath(fbxFile);
string refPath = Path.GetFullPath(fbxFile).Replace(dataPath + Path.DirectorySeparatorChar, "").ToLower();
string outputDir = Path.Combine(destDir, refPath);
outputDir = Path.GetDirectoryName(outputDir) + Path.DirectorySeparatorChar + Path.GetFileNameWithoutExtension(fbxFile);
outputDir = outputDir.ToLower();
if (!Directory.Exists(outputDir))
{
Directory.CreateDirectory(outputDir);
}
var glftFileName = Path.GetFileNameWithoutExtension(fbxFile) + ".gltf";
var gltfFilePath = Path.Combine(Environment.CurrentDirectory, Path.Combine(outputDir, glftFileName).ToLower());
string arguments = input + " -o " + gltfFilePath;
RunCommand(arguments);
EditorUtility.DisplayProgressBar(title, "请稍后", counter / totalCount * 1.0f);
counter++;
var prefix = outputDir.Replace("res_models/", string.Empty);
var bufferFilePath = prefix + "/buffer.bin";
var gltfRefPath = prefix + "/" + glftFileName;
var realPath = outputDir + "/buffer.bin";
var gltfRealPath = outputDir + "/" + glftFileName;
var gltfItems = resConfig.items.Where(s => s.path == gltfRefPath);
var bufferItems = resConfig.items.Where(s => s.path == bufferFilePath);
for (int i = 0; i < gltfItems.Count(); i++)
{
resConfig.items.Remove(gltfItems.ElementAt(i));
}
for (int i = 0; i < bufferItems.Count(); i++)
{
resConfig.items.Remove(bufferItems.ElementAt(i));
}
var gltfItem = CreateConfigItem(gltfRealPath, glftFileName, gltfRefPath);
var bufferItem = CreateConfigItem(realPath, Path.GetFileNameWithoutExtension(fbxFile) + "/buffer.bin", bufferFilePath);
resConfig.items.Add(gltfItem);
resConfig.items.Add(bufferItem);
}
EditorUtility.ClearProgressBar();
if (hasError)
{
Debug.LogError(errorMsg.ToString());
}
File.WriteAllText(databaseFile, JsonUtility.ToJson(resConfig, true));
EditorUtility.DisplayDialog(title, hasError?errorMsg.ToString():"转换完成", "确定");
}
public JSONObjectEnumer(JSONObject jsonObject)
{
Debug.Assert(jsonObject.isContainer); //must be an array or object to itterate
_jobj = jsonObject;
}
public static void Initialize()
{
Debug.Log("AdjustParameter Initialize");
}
public override void DoUpdate(float deltaTime)
{
if (!Running)
{
return;
}
if (_constStateService.IsVideoMode)
{
return;
}
cmdBuffer.Ping = _networkService.Ping;
cmdBuffer.UpdateFramesInfo();
var missFrameTick = cmdBuffer.GetMissServerFrameTick();
//客户端落后服务器太多帧 请求丢失帧
if (cmdBuffer.IsNeedReqMissFrame())
{
_networkService.SendMissFrameReq(missFrameTick);
}
//if (!cmdBuffer.CanExecuteNextFrame()) { //因为网络问题 需要等待服务器发送确认包 才能继续往前
// return;
//}
_frameDeadline = Time.realtimeSinceStartup + MaxSimulationMsPerFrame;
var minTickToBackup = missFrameTick - FrameBuffer.SnapshotFrameInterval;
//追帧 无输入
_constStateService.isPursueFrame = true;
if (!PursueServer(minTickToBackup))
{
_constStateService.isPursueFrame = false;
Debug.Log($"PurchaseServering curTick:" + _world.Tick);
return;
}
_constStateService.isPursueFrame = false;
var frameDeltaTime = (Time.realtimeSinceStartup - timestampOnPurcue) * 1000;
var targetTick = Mathf.CeilToInt(frameDeltaTime / NetworkDefine.UPDATE_DELTATIME) + tickOnPursue;
//正常跑帧
while (_world.Tick < targetTick)
{
var curTick = _world.Tick;
cmdBuffer.UpdateFramesInfo();
//校验服务器包 如果有预测失败 则需要进行回滚
if (cmdBuffer.IsNeedRevert)
{
_world.RollbackTo(cmdBuffer.nextTickToCheck, missFrameTick);
_world.CleanUselessSnapshot(System.Math.Min(cmdBuffer.nextTickToCheck - 1, _world.Tick));
minTickToBackup = System.Math.Max(minTickToBackup, _world.Tick + 1);
while (_world.Tick < missFrameTick)
{
var sFrame = cmdBuffer.GetServerFrame(_world.Tick);
Logging.Debug.Assert(sFrame != null && sFrame.tick == _world.Tick,
$" logic error: server Frame must exist tick {_world.Tick}");
//服务器超前 客户端 应该追上去 将服务器中的输入作为客户端输入
cmdBuffer.PushLocalFrame(sFrame);
Simulate(sFrame, _world.Tick >= minTickToBackup);
}
while (_world.Tick < curTick)
{
var frame = cmdBuffer.GetLocalFrame(_world.Tick);
FillInputWithLastFrame(frame); //加上输入预判 减少回滚
Logging.Debug.Assert(frame != null && frame.tick == _world.Tick,
$" logic error: local frame must exist tick {_world.Tick}");
Predict(frame, _world.Tick > minTickToBackup);
}
}
{
if (_world.Tick == curTick) //当前帧 没有被执行 需要执行之
{
ServerFrame cFrame = null;
var sFrame = cmdBuffer.GetServerFrame(_world.Tick);
if (sFrame != null)
{
cFrame = sFrame;
}
else
{
var input = new Msg_PlayerInput(curTick, _localActorId, _inputService.GetInputCmds());
cFrame = new ServerFrame();
var inputs = new Msg_PlayerInput[_actorCount];
inputs[_localActorId] = input;
cFrame.Inputs = inputs;
cFrame.tick = curTick;
FillInputWithLastFrame(cFrame);
#if DEBUG_FRAME_DELAY
input.timeSinceStartUp = Time.realtimeSinceStartup;
#endif
if (curTick > cmdBuffer.maxServerTickInBuffer) //服务器的输入还没到 需要同步输入到服务器
{
SendInput(input);
}
}
cmdBuffer.PushLocalFrame(cFrame);
Predict(cFrame);
}
}
} //end of while(_world.Tick < targetTick)
CheckAndSendHashCodes();
}