/// <summary>
/// Method to parsing one sentence of given text
/// </summary>
/// <param name="sentence">Sentence to parse</param>
/// <returns>List of parsed elements</returns>
public SentenceGraph ParseSentence(string sentence)
{
Dictionary <int, List <IProcessable> > dependencyTree;
SentenceGraph graph = new SentenceGraph();
// recreating dependency tree given as REST API response from UDPipe
var validLines = this.Client.GetResponse(sentence);
dependencyTree = GetDependencyTree(validLines);
// new root element
var root = this.ElementFactory.CreateRoot(sentence);
// compressing dependency tree into graph
this.Comparer.Tree = dependencyTree;
IProcessable element = CompressDependencyTree(dependencyTree, graph, root).FinalizeProcessing(graph);
// Clear graph if nothing were found for safety
if (element is Root)
{
graph.Clear();
}
// Adding last processed vertex (is added only if its only vertex in sentence)
if (element is IDrawable drawable)
{
graph.AddVertex(drawable);
}
return(graph);
}
private IProcessable ProcessElement(Numeral num, ISentenceGraph graph)
{
num.DependencyType = this.DependencyType;
this.DependingNumeral = num;
return(this);
}
protected override IProcessable ProcessElement(IProcessable element, ISentenceGraph graph)
{
switch (element)
{
case Adjective adj: return(this.ProcessElement(adj, graph));
case Noun noun: return(this.ProcessElement(noun, graph));
case NounSet nounSet: return(this.ProcessElement(nounSet, graph));
case Adposition adp: return(this.ProcessElement(adp, graph));
case Numeral num: return(this.ProcessElement(num, graph));
case Verb verb: return(this.ProcessElement(verb, graph));
case Adverb adv: return(this.ProcessElement(adv, graph));
case Coordination cor: return(this.ProcessCoordination(cor));
default: break;
}
return(this);
}
private IProcessable ProcessElement(Verb verb, ISentenceGraph graph)
{
// Skip copula
if (this.DependencyTypeHelper.IsCopula(verb.DependencyType))
{
return(this);
}
IProcessable processElement = this;
// Process all depending drawables of the verb
if (verb.DependingDrawables.Count != 0)
{
verb.DependingDrawables.ForEach(dd => processElement = processElement.Process(dd, graph));
verb.DependingDrawables.Clear();
}
// Process all related actions
verb.RelatedActions.ForEach(ra => processElement.Process(ra, graph));
verb.RelatedActions.Clear();
// Process non used adposition
if (verb.DrawableAdposition != null)
{
processElement.Process(verb.DrawableAdposition, graph);
verb.DrawableAdposition = null;
}
// Replace verb object in the graph
if (verb.Object != null)
{
if (verb.Object is NounSet)
{
((NounSet)verb.Object).Nouns.ForEach(n =>
{
if (graph.Vertices.Contains(n))
{
graph.ReplaceVertex((IDrawable)processElement, n);
}
});
}
if (graph.Vertices.Contains((IDrawable)verb.Object))
{
graph.ReplaceVertex((IDrawable)processElement, (IDrawable)verb.Object);
}
}
// Process only non negated verbs
if (!verb.IsNegated && processElement == this)
{
foreach (var noun in this.Nouns)
{
noun.Process(verb, graph);
}
}
return(processElement);
}
static private ProcessType SafeProcTypeGet(IProcessable aObject, ProcessType aNeededProcessType)
{
if (aObject.State != AnalysisState.Processed)
{
return(ProcessType.ProcessFull);
}
return(aNeededProcessType);
}
private void HandleEndProcessing()
{
currentlyProcessing.currentState |= stateModifier;
isProcessing = false;
currentTaskHandler.OnTaksEnded();
MixSalad(currentlyProcessing);
currentlyProcessing = null;
}
private void AssertProcessableBasic(IProcessable processable, Type t, int id = DEFAULT_ID, string dependency = "_", bool isNegated = false)
{
Assert.IsNotNull(processable);
Assert.IsInstanceOfType(processable, t);
Assert.AreEqual(processable.Id, id);
Assert.AreEqual(processable.DependencyType, dependency);
Assert.AreEqual(processable.IsNegated, isNegated);
}
public ProcessableProgressBar(IProcessable processable, Action processAction) : this()
{
ProcessableBusiness = processable;
ProcessAction = processAction;
ProcessableBusiness.OnStart += ProcessableBusiness_OnStart;
ProcessableBusiness.OnUpdate += ProcessableBusiness_OnUpdate;
ProcessableBusiness.OnFinished += ProcessableBusiness_OnFinished;
}
private object AsyncProcess(IProcessable c, string tag, int thread)
{
var container = c as VoxelContainer;
Dictionary <long, int> Voxels = null;
if (tag == "Terrain")
{
Voxels = container.Solid;
}
else if (tag == "Liquid")
{
Voxels = container.Liquid;
}
if (Voxels.Count == 0)
{
return(null);
}
int vcount = 0;
int icount = 0;
int texw = 0;
int texh = 0;
var keys = Voxels.Keys.ToArray();
var vals = Voxels.Values.ToArray();
var data = datas[thread];
Stopwatch watch = new Stopwatch();
watch.Start();
Mesher.MeshVoxels(Voxels.Count, keys, vals,
data.Vertices, data.Normals, data.UVs, data.Tris, ref vcount, ref icount, data.Tex, ref texw, ref texh, tag == "Liquid");
watch.Stop();
UnityEngine.Debug.Log(watch.Elapsed);
if (tag == "Terrain")
{
var cs = WorldGenerator.ChunkSize;
container.aocol = new Color[cs * cs * cs];
for (int la = 0; la < cs * cs * cs; la++)
{
int x = la % cs;
int y = (la / cs) % cs;
int z = (la / (cs * cs));
float val = container.CalcAO(x, y, z);
//float val = 1;
//val = z/15f;
//float val = (x == 0 && y == 0 && z == 0) || (x == 1 && y==1 && z==1) ? 1 : 0;
container.aocol[la] = new Color(val, val, val);
}
}
return(new object[] { data.GetVertices(vcount), data.GetNormals(vcount), data.GetUVs(vcount), data.GetTris(icount), texw, texh, data.GetTex(texw, texh) });
}
private IProcessable ProcessElement(Verb verb, ISentenceGraph graph)
{
// skip copula
if (this.DependencyHelper.IsCopula(verb.DependencyType))
{
return(this);
}
IProcessable processElement = this;
// Don't process negated verb
if (!verb.IsNegated)
{
this.Actions.Add(verb);
}
// Process all depending drawables
if (verb.DependingDrawables.Count != 0)
{
verb.DependingDrawables.ForEach(dd => processElement = processElement.Process(dd, graph));
verb.DependingDrawables.Clear();
}
// Process all related actions
verb.RelatedActions.ForEach(ra => processElement.Process(ra, graph));
verb.RelatedActions.Clear();
// Process unprocessed adposition
if (verb.DrawableAdposition != null)
{
processElement.Process(verb.DrawableAdposition, graph);
}
// Replace verb object in the graph
if (verb.Object != null)
{
if (verb.Object is NounSet ns)
{
ns.Nouns.ForEach(n =>
{
if (graph.Vertices.Contains(n))
{
graph.ReplaceVertex((IDrawable)processElement, n);
}
});
}
if (graph.Vertices.Contains((IDrawable)verb.Object))
{
graph.ReplaceVertex((IDrawable)processElement, (IDrawable)verb.Object);
}
}
return(processElement);
}
//
// DO NOT USE ConfigureAwait(false) WITH ProcessAsync() unless ensuring ProcessAsync() implementation is cross-thread compatible
// ProcessAsync() often does a lot with forms in the UI context
//
/// <summary>Process the first valid product. Create default context</summary>
/// <returns>Returns either the status handler from the process, or null if all books have been processed</returns>
public static async Task <StatusHandler> ProcessFirstValidAsync(this IProcessable processable)
{
var libraryBook = processable.getNextValidBook();
if (libraryBook == null)
{
return(null);
}
return(await processBookAsync(processable, libraryBook));
}
public void Process(IProcessable process, Action action)
{
ProgressBar = new ProcessableProgressBar(process, action);
ProgressBar.OnStart += OnStart;
ProgressBar.OnUpdate += OnUpdate;
ProgressBar.OnFinished += OnFinished;
processing = new ThreadStart(action);
ProcessingThread = new Thread(processing);
ProcessingThread.Start();
ShowDialog();
}
public static async Task <StatusHandler> ProcessSingleAsync(this IProcessable processable, LibraryBook libraryBook)
{
if (!processable.Validate(libraryBook))
{
return new StatusHandler {
"Validation failed"
}
}
;
return(await processable.ProcessBookAsync_NoValidation(libraryBook));
}
/// <summary>
/// Set process state from input IProcessable
/// </summary>
private void SetProcessValue(IProcessable processable)
{
if (OperationTypesDataSource != null)
{
var currentType = OperationTypesDataSource.FirstOrDefault(x => x.Index == processable.Index);
if (currentType != null)
{
currentType.Process = processable.GetProcessed();
}
}
}
private void ManufacturerInitializeComputersFromInput()
{
var manufacturerName = Console.ReadLine();
ManufacturerFactory manufacturerCreator = new ManufacturerFactory();
ComputersFactory manufacturer = manufacturerCreator.CreateManufacturer(manufacturerName);
this.pc = manufacturer.CreatePc();
this.laptop = manufacturer.CreateLaptop();
this.server = manufacturer.CreateServer();
}
private void ManufacturerInitializeComputersFromInput()
{
var manufacturerName = Console.ReadLine();
ManufacturerFactory manufacturerCreator = new ManufacturerFactory();
ComputersFactory manufacturer = manufacturerCreator.CreateManufacturer(manufacturerName);
this.pc = manufacturer.CreatePc();
this.laptop = manufacturer.CreateLaptop();
this.server = manufacturer.CreateServer();
}
/// <summary>
/// Interface overriden method
/// </summary>
/// <param name="element">Element to process</param>
/// <param name="graph">Sentence graph</param>
/// <returns>Processed element</returns>
public IProcessable Process(IProcessable element, ISentenceGraph graph)
{
if (element == null)
{
return(this);
}
if (element is Negation)
{
return(this.ProcessNegation((Negation)element));
}
if (element.IsNegated && !(this is Noun) && !(element is Verb))
{
if (element is IDrawable drawable)
{
graph.RemoveVertex(drawable, true);
}
return(this);
}
if (this.IsNegated && this.DependencyHelper.IsSubject(element.DependencyType))
{
if (this is Verb verb)
{
this.ProcessableHelper.RemoveVerbFromGraph(verb, graph);
}
return(element);
}
if (!this.CoordinationTypeHelper.IsAllowedCoordination(this.CoordinationType) && this.DependencyHelper.IsConjuction(element.DependencyType))
{
this.CoordinationType = CoordinationType.AND;
if (element is IDrawable drawable)
{
graph.RemoveVertex(drawable, true);
}
if (element is Verb verb)
{
this.ProcessableHelper.RemoveVerbFromGraph(verb, graph);
}
return(this);
}
var returnElement = this.ProcessElement(element, graph);
return(returnElement.IsNegated && returnElement != this ? this : returnElement);
}
public InjectionConfigurationViewModel(
DomainActionBuilder actionBuilder,
ComponentViewModelFactory componentViewModelFactory,
IFindFirstLaunchTimeQuery findFirstLaunchTimeQuery,
IFindGamePackageByIdQuery findGamePackageByIdQuery,
IFindGamesQuery findGamesQuery,
IFindLastEditedGamePackageQuery findLastEditedGamePackageQuery,
IDirectoryPicker directoryPicker,
IEqualityComparer <ProxySettings> stateEqualityComparer,
IEventPublisher publisher,
IFilePicker filePicker,
IPluginFactory pluginFactory,
INavigationService navigationService,
IProcessable processable,
ITaskRunner runner)
{
_actionBuilder = actionBuilder;
_componentViewModelFactory = componentViewModelFactory;
_findFirstLaunchTimeQuery = findFirstLaunchTimeQuery;
_findGamePackageByIdQuery = findGamePackageByIdQuery;
_findGamesQuery = findGamesQuery;
_findLastEditedGamePackageQuery = findLastEditedGamePackageQuery;
_directoryPicker = directoryPicker;
_stateEqualityComparer = stateEqualityComparer;
_publisher = publisher;
_filePicker = filePicker;
_pluginFactory = pluginFactory;
_navigationService = navigationService;
_processable = processable;
_runner = runner;
_publisher.Register <ApplicationActionEvent>(this);
_publisher.Register <ApplicationMinimizedEvent>(this);
_publisher.Register <ApplicationRestoredEvent>(this);
ActionCommand = new ActionCommand(() => _queue.QueueTask(ExecuteActionAsync), IsActionEnabled);
ActivationState = new StateViewModel(_runner);
AddGameProfileCommand = new ActionCommand(() => _queue.QueueTask(AddGameProfileAsync), () => true);
ChangedCommand = new ActionCommand(async() => await UpdateGameProfileAsync(), () => true);
ClearGameFilePathCommand = new ActionCommand(async() => await ClearApplicationFilePathAsync(), () => !GameFilePath.IsNullOrEmpty());
EditGameProfileCommand = new ActionCommand(() => _queue.QueueAction(EditPluginMainSettings), () => true);
MoveToGameFilePathCommand = new ActionCommand(MoveToApplicationPath, () => !GameFilePath.IsNullOrEmpty());
MoveToConfigurationDirectoryPathCommand = new ActionCommand(MoveToConfigurationDirectoryPath, () => !GameFilePath.IsNullOrEmpty());
MoveToLogsDirectoryPathCommand = new ActionCommand(MoveToLogsDirectoryPath, () => !GameFilePath.IsNullOrEmpty());
SwitchModeCommand = new ActionCommand(async() => await SwapModeAsync(), () => true);
PickGameFilePathCommand = new ActionCommand(async() => await PickApplicationFilePathAsync(), () => true);
PickPluginSettingsEditViewCommand = new GenericActionCommand <IComponentViewModel>(EditPluginComponent, () => true);
RemoveGameProfileCommand = new ActionCommand(async() => await RemoveGameProfileAsync(), () => _package?.Game.Profiles.Count > 1);
RenameGameProfileCommand = new ActionCommand(async() => await RenameGameProfileAsync(), () => true);
ValidationTriggeredCommand = new GenericActionCommand <ValidationResultEventArgs>(eventArgs => _queue.QueueAction(Validate), () => true);
}
private IProcessable ProcessElement(Numeral num, ISentenceGraph graph)
{
IProcessable processElem = this;
num.DependingDrawables.ForEach(dd => processElem = processElem.Process(dd, graph));
num.DependingActions.ForEach(da => processElem = processElem.Process(da, graph));
this.Process(num.DependingNumeral, graph);
// Process appositional
if (this.DependencyHelper.IsAppositional(num.DependencyType))
{
return(processElem);
}
// Process numeral expressing part of noun phrase
if (this.DependencyHelper.IsNounPhrase(this.DependencyType) || this.DependencyHelper.IsCompound(this.DependencyType))
{
this.Extensions.Add(num);
return(processElem);
}
// We don't process time
if (this.DependencyHelper.IsTime(num.DependencyType))
{
return(processElem);
}
// Add extension if numeral is not modifying number of instances
if (!this.DependencyHelper.IsNumeralModifier(num.DependencyType))
{
if (num.Id > this.Id)
{
this.Suffixes.Add(num);
}
else
{
this.Extensions.Add(num);
}
return(processElem);
}
// no need to create noun set
if (num.GetValue() <= 1)
{
return(processElem);
}
// Create new noun with given number of values
return(new NounSet(this.ElementFactory, this.EdgeFactory, this, num.GetValue()));
}
private void SyncGenerate(IProcessable c, string tag, object d)
{
var crd = d as int[];
int vx, vy, vz;
Utils.CoordChunkToVoxel(crd[0], 0, crd[1], out vx, out vy, out vz);
for (int la = 0; la < 16; la++)
{
for (int lb = 0; lb < 16; lb++)
{
Generator.GenerateVoxelsForCoord(vx + la, vz + lb);
}
}
}
private static LibraryBook getNextValidBook(this IProcessable processable)
{
var libraryBooks = DbContexts.GetContext().GetLibrary_Flat_NoTracking();
foreach (var libraryBook in libraryBooks)
{
if (processable.Validate(libraryBook))
{
return(libraryBook);
}
}
return(null);
}
/// <summary>
/// Adds the object into the pool.
/// </summary>
/// <param name="obj">The object to add.</param>
public void Add(IProcessable obj)
{
// Make sure that the object is not null
if (obj == null)
{
throw new ArgumentNullException(nameof(obj));
}
// Otherwise, add it to the general pool
if (objects.Contains(obj))
{
throw new InvalidOperationException("The object is already part of this pool.");
}
objects.Add(obj);
}
private void SetProcessEngine()
{
if (_simulationEngine.Configuration.IsRecrystallization)
{
_processEngine = _recrystallizationEngine;
}
else if (_simulationEngine.Configuration.IsMC)
{
_processEngine = _MCEngine;
}
else
{
_processEngine = _CAEngine;
}
}
/// <summary>
/// Method for creating new text elements
/// </summary>
/// <param name="parts">UDPipe service response line</param>
/// <returns>New text element</returns>
public IProcessable Create(string[] parts)
{
// Map known cases
this.MapKnownCases(parts[2], ref parts[3]);
IProcessable part = null;
switch (parts[3])
{
case "PROPN":
case "NOUN":
part = this.ProcessNoun(parts);
break;
case "ADJ":
part = this.ProcessAdj(parts);
break;
case "ADP":
part = new Adposition(int.Parse(parts[0]), parts[2], parts[7]);
break;
case "NUM":
part = new Numeral(int.Parse(parts[0]), parts[2], parts[7]);
break;
case "VERB":
part = this.ProcessVerb(parts);
break;
case "ADV":
part = new Adverb(int.Parse(parts[0]), parts[2], parts[7]);
break;
case "CONJ":
part = new Coordination(int.Parse(parts[0]), parts[2], parts[7]);
break;
case "NEG":
part = new Negation(int.Parse(parts[0]), parts[2], parts[7]);
break;
default:
break;
}
return(part);
}
static void Main(string[] args)
{
using (IDbConnection connection = ConnectionFactory.CreateConnection())
{
if (args.Length == 0)
{
Console.WriteLine("ERROR: an argument must be given.");
return;
}
int jobId = Convert.ToInt32(args[0]);
ProcessingVO processingVO = processingDAO.Get(jobId);
processingBO = CreateProcessing(processingVO);
processingBO?.Process();
}
}
private static void LoadProcessingDefinitions(int jobId, ProgramLoadMode loadMode)
{
switch (loadMode)
{
case ProgramLoadMode.Database:
processingBO = LoadFromDatabase(jobId);
break;
case ProgramLoadMode.XmlFile:
processingBO = LoadFromXmlFile(jobId);
break;
default:
break;
}
}
private static async Task runSingleBackupAsync(IProcessable processable, AutomatedBackupsForm automatedBackupsForm, string productId)
{
automatedBackupsForm.Show();
try
{
var statusHandler = await processable.ProcessSingleAsync(productId);
validateStatus(statusHandler, automatedBackupsForm);
}
catch (Exception ex)
{
automatedBackupsForm.AppendError(ex);
}
automatedBackupsForm.FinalizeUI();
}
public void Process(IProcessable veggie, ITaskHandler taskHandler)
{
if (!isProcessing)
{
currentlyProcessing = veggie;
isProcessing = true;
taskCompletionTime = veggie.processingTime;
taskTimeElapsed = 0;
progress = 0;
currentTaskHandler = taskHandler;
taskHandler.OnStartedTask();
}
else
{
Debug.LogError("This processor is busy processing.");
}
}
public static async Task <StatusHandler> ProcessBookAsync_NoValidation(this IProcessable processable, LibraryBook libraryBook)
{
Serilog.Log.Logger.Information("Begin " + nameof(ProcessBookAsync_NoValidation) + " {@DebugInfo}", new
{
libraryBook.Book.Title,
libraryBook.Book.AudibleProductId,
libraryBook.Book.Locale,
Account = libraryBook.Account?.ToMask() ?? "[empty]"
});
var status
= (await processable.ProcessAsync(libraryBook))
?? new StatusHandler {
"Processable should never return a null status"
};
return(status);
}
public InjectionConfigurationViewModel Create(IProcessable processable)
{
return(new InjectionConfigurationViewModel(
_actionBuilder,
_componentViewModelFactory,
_findFirstLaunchTimeQuery,
_findGamePackageByIdQuery,
_findGamesQuery,
_findLastEditedGamePackageQuery,
_directoryPicker,
_stateEqualityComparer,
_eventPublisher,
_filePicker,
_pluginFactory,
_navigationService,
processable,
_runner));
}
private void ProcessNode(IProcessable processor, float delta, float inverseDelta)
{
if (processor == null)
{
GD.PrintErr("A node has been put in the process group " +
"but it isn't derived from IProcessable");
return;
}
var bag = processor.ProcessCompoundStorage;
// Set all compounds to not be useful, when some compound is
// used it will be marked useful
bag.ClearUseful();
var processStatistics = processor.ProcessStatistics;
processStatistics?.MarkAllUnused();
foreach (TweakedProcess process in processor.ActiveProcesses)
{
// If rate is 0 dont do it
// The rate specifies how fast fraction of the specified process
// numbers this cell can do
// TODO: would be nice still to report these to process statistics
if (process.Rate <= 0.0f)
{
continue;
}
var processData = process.Process;
var currentProcessStatistics = processStatistics?.GetAndMarkUsed(process);
currentProcessStatistics?.BeginFrame(delta);
RunProcess(delta, processData, bag, process, currentProcessStatistics, inverseDelta);
}
bag.ClampNegativeCompoundAmounts();
processStatistics?.RemoveUnused();
}
/// <summary>
/// Enqueue's a processable message
/// </summary>
/// <param name="message"></param>
public void enqueueMessage(IProcessable message)
{
Logging.LogMessage("Enqueing message long running is " + message.isLongRunTask());
if (message.isLongRunTask())
{
longRunningProcessing(message);
}
else
{
TaskHandeler lowestHandeler = queues[0];
int lowestProcesTime = queues[0].procesTime;
for (int i = 1; i < queues.Length; i++)
{
if (queues[i].procesTime < lowestProcesTime)
{
lowestHandeler = queues[i];
lowestProcesTime = queues[i].procesTime;
}
}
lowestHandeler.enqueueMessages(message);
}
}
private void SyncProcess(IProcessable c, string tag, object d)
{
if (d == null) return;
var container = c as VoxelContainer;
if (container == null) return;
var data = d as object[];
if (data == null) return;
if (tag == "Liquid")
{
foreach (Transform t in container.transform)
{
Destroy(t.gameObject);
}
GameObject liGo = new GameObject("Liquid");
liGo.isStatic = true;
liGo.transform.parent = container.transform;
liGo.transform.localPosition = Vector3.zero;
var vertList = data[0] as Vector3[];
var nrmList = data[1] as Vector3[];
var uvList = data[2] as Vector2[];
var indList = data[3] as int[];
var texW = (int)data[4];
var texH = (int)data[5];
var itex = data[6] as int[];
var mesh = new Mesh();
mesh.vertices = vertList;
mesh.normals = nrmList;
mesh.uv = uvList;
mesh.triangles = indList;
mesh.RecalculateNormals();
mesh.RecalculateBounds();
mesh.Optimize();
var mf = liGo.AddComponent<MeshFilter>();
mf.mesh = mesh;
//Debug.Log(texW + " " + texH);
var tex = new Texture2D(texW, texH);
tex.filterMode = FilterMode.Point;
tex.wrapMode = TextureWrapMode.Clamp;
var tdata = new Color32[texW * texH];
var handle = GCHandle.Alloc(tdata, GCHandleType.Pinned);
Marshal.Copy(itex, 0, handle.AddrOfPinnedObject(), itex.Length);
handle.Free();
////Debug.Log(String.Format("{0}:{1}:{2}:{3}", tdata[0].r, tdata[0].g, tdata[0].b, tdata[0].a));
tex.SetPixels32(tdata);
tex.Apply();
liGo.AddComponent<MeshRenderer>();
//container.renderer.material = new Material(container.Shader);
liGo.renderer.material = new Material(LiquidShader);
if (liGo.renderer.material.mainTexture != null)
{
Destroy(liGo.renderer.material.mainTexture);
}
liGo.renderer.material.mainTexture = tex;
liGo.renderer.material.SetTexture("_TopSkin", container.TopTexture);
liGo.renderer.material.SetTexture("_SideSkin", container.SideTexture);
liGo.renderer.material.SetTexture("_BottomSkin", container.BottomTexture);
liGo.renderer.material.SetTexture("_AO", container.AOTexture);
}
else if (tag == "Terrain")
{
var vertList = data[0] as Vector3[];
var nrmList = data[1] as Vector3[];
var uvList = data[2] as Vector2[];
var indList = data[3] as int[];
var texW = (int) data[4];
var texH = (int) data[5];
var itex = data[6] as int[];
var mesh = new Mesh();
mesh.vertices = vertList;
mesh.normals = nrmList;
mesh.uv = uvList;
mesh.triangles = indList;
mesh.RecalculateNormals();
mesh.RecalculateBounds();
mesh.Optimize();
var mf = container.GetComponent<MeshFilter>();
mf.mesh = mesh;
//Debug.Log(texW + " " + texH);
var tex = new Texture2D(texW, texH);
tex.filterMode = FilterMode.Point;
tex.wrapMode = TextureWrapMode.Clamp;
var tdata = new Color32[texW*texH];
var handle = GCHandle.Alloc(tdata, GCHandleType.Pinned);
Marshal.Copy(itex, 0, handle.AddrOfPinnedObject(), itex.Length);
handle.Free();
////Debug.Log(String.Format("{0}:{1}:{2}:{3}", tdata[0].r, tdata[0].g, tdata[0].b, tdata[0].a));
tex.SetPixels32(tdata);
tex.Apply();
if (container.AOTexture != null)
{
Destroy(container.AOTexture);
}
var cs = WorldGenerator.ChunkSize;
container.AOTexture = new Texture3D(cs, cs, cs, TextureFormat.ARGB32, false);
container.AOTexture.filterMode = FilterMode.Trilinear;
container.AOTexture.wrapMode = TextureWrapMode.Clamp;
container.AOTexture.SetPixels(aocol);
container.AOTexture.Apply();
//container.renderer.material = new Material(container.Shader);
container.renderer.material = new Material(Shader);
if (container.renderer.material.mainTexture != null)
{
Destroy(container.renderer.material.mainTexture);
}
container.renderer.material.mainTexture = tex;
container.renderer.material.SetTexture("_TopSkin", container.TopTexture);
container.renderer.material.SetTexture("_SideSkin", container.SideTexture);
container.renderer.material.SetTexture("_BottomSkin", container.BottomTexture);
container.renderer.material.SetTexture("_AO", container.AOTexture);
container.renderer.material.SetVector("_ChunkPos", new Vector4(VX, VY, VZ));
container.renderer.material.SetTexture("_Break", container.BreakTexture);
container.renderer.material.SetTexture("_BreakCoords", container.breakCoords);
}
}
/// <summary>
/// Enqueue's a message so it will be handeled
/// </summary>
/// <param name="information">The message information which needs to be enqueued</param>
public void enqueueMessages(IProcessable information)
{
messageQueue.Enqueue(information);
}
/// <summary>
/// Creates a long running processer
/// </summary>
/// <param name="message"></param>
private void longRunningProcessing(IProcessable message)
{
//ImmidiateTaskProcessor processor = new ImmidiateTaskProcessor(message);
//processor.processMessage();
}
private object AsyncProcess(IProcessable c, string tag, int thread)
{
var container = c as VoxelContainer;
Dictionary<long, int> Voxels = null;
if (tag == "Terrain")
{
Voxels = container.Solid;
}
else if (tag == "Liquid")
{
Voxels = container.Liquid;
}
if (Voxels.Count == 0) return null;
int vcount = 0;
int icount = 0;
int texw = 0;
int texh = 0;
var keys = Voxels.Keys.ToArray();
var vals = Voxels.Values.ToArray();
var data = datas[thread];
Stopwatch watch = new Stopwatch();
watch.Start();
Mesher.MeshVoxels(Voxels.Count, keys, vals,
data.Vertices, data.Normals, data.UVs, data.Tris, ref vcount, ref icount, data.Tex, ref texw, ref texh, tag=="Liquid");
watch.Stop();
UnityEngine.Debug.Log(watch.Elapsed);
if (tag == "Terrain")
{
var cs = WorldGenerator.ChunkSize;
container.aocol = new Color[cs*cs*cs];
for (int la = 0; la < cs*cs*cs; la++)
{
int x = la%cs;
int y = (la/cs)%cs;
int z = (la/(cs*cs));
float val = container.CalcAO(x, y, z);
//float val = 1;
//val = z/15f;
//float val = (x == 0 && y == 0 && z == 0) || (x == 1 && y==1 && z==1) ? 1 : 0;
container.aocol[la] = new Color(val, val, val);
}
}
return new object[] { data.GetVertices(vcount), data.GetNormals(vcount), data.GetUVs(vcount), data.GetTris(icount), texw, texh, data.GetTex(texw, texh) };
}
internal static void processMessage(IProcessable information)
{
information.ProcessLogic();
}
private void SyncGenerate(IProcessable c, string tag, object d)
{
var crd = d as int[];
int vx, vy, vz;
Utils.CoordChunkToVoxel(crd[0], 0, crd[1], out vx, out vy, out vz);
for (int la = 0; la < 16; la++)
{
for (int lb = 0; lb < 16; lb++)
{
Generator.GenerateVoxelsForCoord(vx + la, vz + lb);
}
}
}
