AudioClip GetClipByType(ClipType clipType) { switch (clipType) { case ClipType.yes: return(clipYes); case ClipType.no: return(clipNo); case ClipType.acquired: return(clipAcquired); case ClipType.lost: return(clipLost); case ClipType.music: return(clipMusic); case ClipType.turn: return(clipTurn); case ClipType.acknowledge: return(clipAcknowledge); case ClipType.done: return(clipDone); } return(null); }
public static List <Polygon> Execute( List <Polygon> a, List <Polygon> b, ClipType clipType) { Paths solution = new Paths(); Clipper clipper = new Clipper(); var aPaths = a.Select(poly => poly.GetPoints()).ToList(); clipper.AddPaths(aPaths, PolyType.ptSubject, true); var bPaths = b.Select(poly => poly.GetPoints()).ToList(); clipper.AddPaths(bPaths, PolyType.ptClip, true); clipper.Execute(clipType, solution); List <Polygon> solutionPolygons = new List <Polygon>(); foreach (Path path in solution) { Polygon polygon = new Polygon(path); solutionPolygons.Add(polygon); } return(solutionPolygons); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="da">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess da) { // SETALL INPUT PARAMETERS List <Curve> curvesA = NGonsCore.Clipper.DataAccessHelper.FetchList <Curve>(da, "A"); List <Curve> curvesB = NGonsCore.Clipper.DataAccessHelper.FetchList <Curve>(da, "B"); try { ClipType type = (ClipType)NGonsCore.Clipper.DataAccessHelper.Fetch <int>(da, "BooleanType"); //Plane pln = NGonsCore.Clipper.DataAccessHelper.Fetch<Plane>(da,"Plane"); //double tolerance = NGonsCore.Clipper.DataAccessHelper.Fetch<double>(da,"Tolerance"); double tolerance = 0.001; // Convert the curves to polylines // This is a crude way of doing this. // Should we add some parameters for this perhaps? List <Polyline> polylinesA = Polyline3D.ConvertCurvesToPolyline(curvesA).ToList(); List <Polyline> polylinesB = Polyline3D.ConvertCurvesToPolyline(curvesB).ToList(); // If we don't have a plane, let's try to create a plane from the first curve. //if (pln.Equals(default(Plane)) || !pln.IsValid) { // ReSharper disable once PossibleMultipleEnumeration Plane pln = polylinesA.First().FitPlane(); //} // do the boolean operation List <Polyline> result = Polyline3D.Boolean(type, polylinesA, polylinesB, pln, tolerance, EvenOdd); // OUTPUT LOGIC da.SetDataList("Result", result); } catch (Exception e) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, e.Message + ": " + e.StackTrace); } }
public static string ToTitle(this ClipType clipType) { switch (clipType) { case ClipType.ExtraTimeOrPen: return("Extra Time/Pens if any"); case ClipType.FirstHalf: return("1st Half"); case ClipType.HalfTime: return("Half Time"); case ClipType.Highlights: return("Hightlights"); case ClipType.PostMatch: return("Post match"); case ClipType.PreMatch: return("Pre-match"); case ClipType.SecondHalf: return("2nd Half"); default: return(null); } }
public AudioSource GetSource(WindowBase window, ClipType clipType, int id) { #if UNITY_EDITOR if (Application.isPlaying == false) { return null; } #endif var key = (window != null) ? (long)window.GetInstanceID() : (long)(((int)clipType << 16) | (id & 0xffff)); AudioSource value; if (this.instances.TryGetValue(key, out value) == false) { value = this.source.Spawn(); this.instances.Add(key, value); } List<AudioSource> valuesByType; if (this.instancesByType.TryGetValue(clipType, out valuesByType) == false) { this.instancesByType.Add(clipType, new List<AudioSource>() { value }); } else { valuesByType.Add(value); } return value; }
public static void Play(WindowBase window, Source sourceInfo, ClipType clipType, int id) { var source = sourceInfo.GetSource(window, clipType, id); if (source == null) return; if (id == 0) { // Stop Manager.Stop(window, sourceInfo, clipType, id); return; } var state = Manager.currentData.GetState(clipType, id); if (state == null) { Manager.Stop(window, sourceInfo, clipType, id); return; } Manager.Reset(source); if (clipType == ClipType.Music) { source.clip = state.clip; source.Play(); } else if (clipType == ClipType.SFX) { source.PlayOneShot(state.clip); } }
public void Execute(ClipType clipType, Region output) { List <List <IntPoint> > solution = new List <List <IntPoint> > (); Execute(clipType, solution); int contourCount = solution.Count; if (contourCount == 0) { output.Clear(); } else { int best = 0; int pointCount = solution [0].Count; for (int k = 1; k < contourCount; k++) { int candidatePointCount = solution [k].Count; if (candidatePointCount > pointCount) { pointCount = candidatePointCount; best = k; } } List <IntPoint> points = solution [best]; int count = points.Count; Vector2[] newPoints = new Vector2[count]; for (int k = 0; k < count; k++) { newPoints [k] = new Vector2((float)points [k].X / MULTIPLIER, (float)points [k].Y / MULTIPLIER); } output.UpdatePointsAndRect(newPoints); } }
public Polygon Clip(Polygon clippingPoly, ClipType type = ClipType.ctIntersection) { List <List <IntPoint> > list = new List <List <IntPoint> >(); list.Add(GetPath()); List <List <IntPoint> > list2 = new List <List <IntPoint> >(); list2.Add(clippingPoly.GetPath()); Clipper clipper = new Clipper(0); PolyTree polytree = new PolyTree(); clipper.AddPaths(list, PolyType.ptSubject, true); clipper.AddPaths(list2, PolyType.ptClip, true); clipper.Execute(type, polytree, PolyFillType.pftEvenOdd, PolyFillType.pftEvenOdd); List <List <IntPoint> > list3 = Clipper.PolyTreeToPaths(polytree); if (list3.Count > 0) { List <Vector2> list4 = new List <Vector2>(); for (int i = 0; i < list3[0].Count; i++) { List <Vector2> list5 = list4; IntPoint intPoint = list3[0][i]; float x = (float)intPoint.X * 0.0001f; IntPoint intPoint2 = list3[0][i]; list5.Add(new Vector2(x, (float)intPoint2.Y * 0.0001f)); } return(new Polygon(list4)); } return(null); }
public State GetState(ClipType clipType, int key) { #if UNITY_EDITOR if (Application.isPlaying == false) { if (clipType == ClipType.Music) { return this.music.FirstOrDefault(item => item.key == key); } else if (clipType == ClipType.SFX) { return this.fx.FirstOrDefault(item => item.key == key); } } #endif if (clipType == ClipType.Music) { return this.musicCache.GetValue(key); } else if (clipType == ClipType.SFX) { return this.fxCache.GetValue(key); } return null; }
public void Execute(ClipType clipType, Region output) { if (solution == null) { solution = new List <List <IntPoint> > (); } Execute(clipType, solution); int contourCount = solution.Count; if (contourCount == 0) { output.Clear(); } else { // Use the largest contour int best = 0; int pointCount = solution [0].Count; for (int k = 1; k < contourCount; k++) { int candidatePointCount = solution [k].Count; if (candidatePointCount > pointCount) { pointCount = candidatePointCount; best = k; } } Vector2[] newPoints = BuildPointArray(solution [best]); output.UpdatePointsAndRect(newPoints); } }
public void PlayClip(ClipType cType, AudioSource audioSrc = null, float resetTime = -1f) { if (!GameSettings.isSFXOn) { return; } if (audioSrc == null) { audioSrc = audSrc; } switch (cType) { case ClipType.UI_BUTTON_CLICK: audioSrc.clip = clickClip; break; case ClipType.TORCH_BUTTON_CLICK: break; } audSrc.Play(); if (resetTime > 0f) { StartCoroutine(ResetAudioSrc(resetTime)); } }
private static IPolygon BinaryOperation(IPolygon p, IPolygon q, ClipType operationType) { if (p.IsEmpty && q.IsEmpty) { return(Polygon.Empty); } var boundingBox = Box2.Hull(p.BoundingBox(), q.BoundingBox()); var fixedP = ConvertToFixedPoint(p, boundingBox); var fixedQ = ConvertToFixedPoint(q, boundingBox); try { var clipper = new Clipper(); clipper.AddPaths(fixedP, PolyType.ptSubject, closed: true); clipper.AddPaths(fixedQ, PolyType.ptClip, closed: true); var fixedAnswer = new ClipperPolygon(); clipper.Execute(operationType, fixedAnswer); return(ConvertToFloatingPoint(fixedAnswer, boundingBox)); } catch (Exception e) { Console.WriteLine("EXCEPTION: {0}", e); return(Polygon.Empty); } }
public static PolygonList Execute(PolygonList a, PolygonList b, ClipType clipType) { PolyTree solution = new PolyTree(); Clipper clipper = new Clipper(); PolygonList a_flat = new PolygonList(); _addRecursive(a, ref a_flat); PolygonList b_flat = new PolygonList(); _addRecursive(b, ref b_flat); clipper.AddPaths(a_flat, PolyType.ptSubject, true); clipper.AddPaths(b_flat, PolyType.ptClip, true); clipper.Execute(clipType, solution); PolygonList solutionPolygons = new PolygonList(); foreach (PolyNode node in solution.Childs) { Polygon polygon = new Polygon(node); solutionPolygons.AddRange(polygon.Flatten()); } return(solutionPolygons); }
//Assuming explosionPoints centered on 0,0 public void ExplosionCut(Vector2[] cutVertices, Vector2 worldHitPoint, ClipType clipType = ClipType.ctDifference) { Transform ourTransform = gameObject.transform; PolyClipper.OffsetVertices( cutVertices, PolyClipper.GetOffset((Vector2)ourTransform.position, worldHitPoint)); //IF YOU MAKE NON KINEMATIC, PROBLEM: //Moved Relative to PARENT, NOT ROTATED RELATIVE TO PARENT //Polygon points are all moved relative to parent GO's transform Vector2[] ourVertices = ourPolygon.points; IntoLocalSpace(ourVertices); // public enum ClipType { ctIntersection, ctUnion, ctDifference, ctXor }; List<Vector2[]> cutPolygons = PolyClipper.ClipPoly(ourVertices,cutVertices,clipType); if(cutPolygons.Count == 0){ Destroy(this.gameObject); return; } OutLocalSpace(cutPolygons[0]); UpdateShape( cutPolygons[0] ); for(int i = 1; i<cutPolygons.Count; i++){ //OutLocalSpace(cutPolygons[i]); CreateCopy( cutPolygons[i] ); } }
/// <summary> /// Creates a TypedAudioClip and adds it to the typedAudioClips collection. /// Note: The method allows you to omit type and name, but you should always provide these parameters if you want to play the clip /// </summary> /// <param name="clip"></param> /// <param name="type"></param> /// <param name="name">Must be unique to guarantee playability</param> /// <returns></returns> public int AddAudioClip(AudioClip clip, ClipType type = ClipType.Undefined, string name = "GiveMeAName") { TypedAudioClip c = new TypedAudioClip(clip, type, name); typedAudioClips.Add(c); return(typedAudioClips.IndexOf(c)); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { // SET ALL INPUT PARAMETERS List <Curve> A = DA.FetchList <Curve>("A"); List <Curve> B = DA.FetchList <Curve>("B"); try { ClipType type = (ClipType)DA.Fetch <int>("BooleanType"); Plane pln = DA.Fetch <Plane>("Plane"); double tolerance = DA.Fetch <double>("Tolerance"); // Convert the curves to polylines // This is a crude way of doing this. // Should we add some parameters for this perhaps? IEnumerable <Polyline> APl = Polyline3D.ConvertCurvesToPolyline(A); IEnumerable <Polyline> BPl = Polyline3D.ConvertCurvesToPolyline(B); // If we don't have a plane, let's try to create a plane from the first curve. if (pln.Equals(default(Plane)) || !pln.IsValid) { pln = APl.First().FitPlane(); } List <Polyline> result = new List <Polyline>(); // do the boolean operation result = Polyline3D.Boolean(type, APl, BPl, pln, tolerance, EvenOdd); // OUTPUT LOGIC DA.SetDataList("Result", result); } catch (Exception e) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, e.Message + ": " + e.StackTrace.ToString()); } }
public void ApplyVolume(ClipType clipType, AudioSource source) { if (source != null) { source.volume = this.GetVolume(clipType); } }
public Clip(BitmapImage thumb, ClipEvent clipEvent, ClipType clipType, IReadOnlyCollection <Video> videos) { Thumb = thumb; _event = clipEvent; Type = clipType; Videos = videos; }
public State GetState(ClipType clipType, int key) { #if UNITY_EDITOR if (Application.isPlaying == false) { if (clipType == ClipType.Music) { return(this.music.FirstOrDefault(item => item.key == key)); } else if (clipType == ClipType.SFX) { return(this.fx.FirstOrDefault(item => item.key == key)); } } #endif if (clipType == ClipType.Music) { return(this.musicCache.GetValue(key)); } else if (clipType == ClipType.SFX) { return(this.fxCache.GetValue(key)); } return(null); }
private IEnumerable <Clip> GetEventClips(ClipType clipType, CancellationToken cancellationToken) { return(_usbFileSystemService .GetClips(clipType) .Where(IsClipValid) .Where(c => _options.CamerasToProcess.Contains(c.Camera)) .Where(c => !_archiveService.IsArchived(c))); // var clips = _usbFileSystemService // .GetClips(clipType) // .ToArray(); // // var clipsToArchive = new List<Clip>(); // // foreach (var eventClips in clips.GroupBy(c => c.EventDate)) // { // // Group clips by minute and only take minutes we want to keep // var clipsByMinute = eventClips // .GroupBy(c => c.Date) // .OrderByDescending(c => c.Key) // .Take(_options.KeepClipsPerEventAmount); // // // Filter clips in every minute // clipsToArchive.AddRange(clipsByMinute // .SelectMany(cbm => cbm) // .Where(IsClipValid) // .Where(c => _options.CamerasToProcess.Contains(c.Camera)) // .Where(c => !_archiveService.IsArchived(c))); // } // // _archiveService.CreateClips(clips.Except(clipsToArchive), cancellationToken); // // return clipsToArchive; }
/// <summary> /// Called by explosions to partially destroy this object. /// </summary> /// <param name="force"> Force to apply to this object </param> /// <param name="explosionPoints"> WORLD position of explosion points </param> /// <param name="clipType"> public enum ClipType { ctIntersection, ctUnion, ctDifference, ctXor }; </param> public void ExplosionCut(Vector2 force, List <Vector2> explosionPoints, ClipType clipType = ClipType.ctDifference) { Transform ourTransform = gameObject.transform; PolyClipper clipper = new PolyClipper(); Polygon explosionPolygon = new Polygon(explosionPoints); List <Vector2[]> cutPolygons = clipper.ClipPoly(polygon.points.ToArray(), explosionPolygon.getWorldToLocalPoints(this.transform).ToArray(), clipType); if (cutPolygons.Count == 0) { Destroy(this.gameObject); return; } //Update children copies before determining if self is anchored for (int i = 1; i < cutPolygons.Count; i++) { CreateCopy(cutPolygons[i]); } updateShape(cutPolygons[0]); determineAnchored(isAnchored()); }
//Apply a polygon clipper operation on subject vertices using cut vertices public static List<Vector2[]> ClipPoly(Vector2[] subject, Vector2[] cut, ClipType operation) { List<Vector2[]> cutPolygons = new List<Vector2[]>(); Paths subj = new Paths(1); subj.Add(Vector2ToIntList(subject)); Paths clip = new Paths(1); clip.Add(Vector2ToIntList(cut)); Paths solution = new Paths(); Clipper c = new Clipper(); c.AddPaths(subj, PolyType.ptSubject, true); c.AddPaths(clip, PolyType.ptClip, true); c.Execute(operation,solution, PolyFillType.pftEvenOdd, PolyFillType.pftEvenOdd); /* for(int i = 0; i<solution.Count; i++){ if( Mathf.Abs((float)Clipper.Area(solution[i])) > ignoreArea){ cutPolygons.Add( IntListToVector2( solution[i] )); } } */ return IntListsToVector2(solution); }
public void PlayRandomClip(ClipType clipType, Transform audioSource) { switch (clipType) { case ClipType.DEATH: PlayRandom(deathSounds, audioSource); break; case ClipType.JUMP: PlayRandom(jumpSounds, audioSource); break; case ClipType.WEB: PlayRandom(webSounds, audioSource); break; case ClipType.FIRE: PlayRandom(fireSounds, audioSource); break; case ClipType.IMPACT: PlayRandom(impactSounds, audioSource); break; case ClipType.POINTS_GAINED: PlayRandom(pointsGainedSounds, audioSource); break; case ClipType.TAKE_DAMAGE: PlayRandom(takeDamageSounds, audioSource); break; } }
public bool IsOperation(PolyLog ppLog, PolyLog pLog, ClipType ctOperation) { foreach (APPair aP in pLog.ApPairs) { if (aP.AdderComp == this.Comp) { //foreach (APPair apPairThis in this.ApPairs) if (ppLog != null) { foreach (APPair aPP in ppLog.ApPairs) { if (EntraSolver.IsPolyOperation(aP.Poly, aPP.Poly, ClipType.ctIntersection)) { //if (EntraSolver.IsPolyOperation(apPairParent.Poly, apPairThis.Poly, ClipType.ctIntersection)) return(true); } //EntraDrawer.DrawIntoFileTesting(aPP.Poly); //EntraDrawer.DrawIntoFileTesting(aP.Poly); } } else { // Frog return(true); } } } return(false); }
public long GetKey(WindowBase window, ClipType clipType, int id) { var key = (long)(((int)clipType << 16) | (id & 0xffff)); return key; }
public static void Stop(WindowBase window, Source sourceInfo, ClipType clipType, int id) { if (id == 0) { // Stop all var sources = sourceInfo.GetPlayingSources(window, clipType); if (sources == null) { return; } foreach (var source in sources) { if (source != null) { source.Stop(); source.clip = null; } } } else { var source = sourceInfo.GetPlayingSource(window, clipType, id); if (source == null) { return; } source.Stop(); source.clip = null; } }
public static void Play(WindowBase window, Source sourceInfo, ClipType clipType, int id, bool replaceOnEquals) { if (clipType == ClipType.Music) { var currentMusicId = sourceInfo.GetCurrentMusicId(); if (currentMusicId > 0) { var equals = (currentMusicId == id); if (equals == false || replaceOnEquals == true) { // Stop Manager.Stop(window, sourceInfo, clipType, currentMusicId); } else if (equals == true) { // Don't play anything return; } } } var source = sourceInfo.GetSource(window, clipType, id); if (source == null) return; if (id == 0) { // Stop Manager.Stop(window, sourceInfo, clipType, id); return; } var state = Manager.currentData.GetState(clipType, id); if (state == null) { Manager.Stop(window, sourceInfo, clipType, id); return; } Manager.Reset(source); sourceInfo.ApplyVolume(clipType, source); if (clipType == ClipType.Music) { source.clip = state.clip; source.Play(); } else if (clipType == ClipType.SFX) { source.PlayOneShot(state.clip); } }
/// <summary> /// Performs the clipping operation. /// Can be called multiple times without reassigning subject and clip polygons /// (ie when different clipping operations are required on the same polygon sets). /// </summary> /// <param name="clipType"> Type of the clipping operation. </param> /// <param name="output"> The List that will receive the result of the clipping operation. </param> /// <param name="subjectFillType"> Fill rule that will be applied to the subject paths. </param> /// <param name="clipFillType"> Fill rule that will be applied to the clip paths. </param> /// <returns> True if the operation was successful, false otherwise. </returns> public bool Clip(ClipType clipType, ref List <List <Vector2> > output, PolyFillType subjectFillType, PolyFillType clipFillType) { var intOutput = new List <List <IntPoint> >(); bool succeeded = clipper.Execute(clipType, intOutput, subjectFillType, clipFillType); ClipperUtility.ToVector2Paths(intOutput, ref output); return(succeeded); }
public async Task GetClipsAsync(ClipType clipType, DeviceInformationDisplay deviceInfoDisplay) { SentryEventItemsViewSource.Clear(); if (null == deviceInfoDisplay) { return; } var sentryClipsFolder = await deviceInfoDisplay.StorageFolder.GetFolderAsync("TeslaCam\\SentryClips"); List <string> fileTypeFilter = new List <string>(); fileTypeFilter.Add(".jpg"); fileTypeFilter.Add(".png"); fileTypeFilter.Add(".bmp"); fileTypeFilter.Add(".gif"); var query = sentryClipsFolder.CreateFolderQueryWithOptions(new Windows.Storage.Search.QueryOptions(Windows.Storage.Search.CommonFileQuery.OrderByName, fileTypeFilter)); var folders = await query.GetFoldersAsync(); foreach (var folder in folders) { var thumbSource = folder.Path + @"\thumb.png"; var jsonPath = folder.Path + @"\event.json"; StorageFile sfi = await StorageFile.GetFileFromPathAsync(thumbSource); StorageFile json = await StorageFile.GetFileFromPathAsync(jsonPath); var thumbImage = await FromStorageFile(sfi); var jonText = await StringFromStorageFile(json); var clipEvent = new ClipEvent(jonText); var files = await folder.GetFilesAsync(); var videoPaths = new List <string>(); foreach (var file in files) { if (file.FileType != ".mp4") { continue; } videoPaths.Add(file.Path); } var videos = videoPaths.Select(path => new Video(path)).ToList().AsReadOnly(); SentryEventItemsViewSource.Add(new Clip(thumbImage, clipEvent, ClipType.Sentry, videos)); } }
static PathWriter CombinePaths(VertexStoreSnap a, VertexStoreSnap b, ClipType clipType) { List <List <IntPoint> > aPolys = CreatePolygons(a); List <List <IntPoint> > bPolys = CreatePolygons(b); Clipper clipper = new Clipper(); clipper.AddPaths(aPolys, PolyType.ptSubject, true); clipper.AddPaths(bPolys, PolyType.ptClip, true); List <List <IntPoint> > intersectedPolys = new List <List <IntPoint> >(); clipper.Execute(clipType, intersectedPolys); PathWriter output = new PathWriter(); foreach (List <IntPoint> polygon in intersectedPolys) { bool first = true; int j = polygon.Count; if (j > 0) { //first one IntPoint point = polygon[0]; output.MoveTo(point.X / 1000.0, point.Y / 1000.0); //next ... if (j > 1) { for (int i = 1; i < j; ++i) { point = polygon[i]; output.LineTo(point.X / 1000.0, point.Y / 1000.0); } } } //foreach (IntPoint point in polygon) //{ // if (first) // { // output.AddVertex(point.X / 1000.0, point.Y / 1000.0, ShapePath.FlagsAndCommand.CommandMoveTo); // first = false; // } // else // { // output.AddVertex(point.X / 1000.0, point.Y / 1000.0, ShapePath.FlagsAndCommand.CommandLineTo); // } //} output.CloseFigure(); } output.Stop(); return(output); }
public void Execute(ClipType clipType) { if (subject == null) { Debug.LogError("Clipper.Execute called without defined subject"); return; } Execute(clipType, subject); }
public static void Play(WindowBase window, Source sourceInfo, ClipType clipType, int id, bool replaceOnEquals) { if (clipType == ClipType.Music) { var currentMusicId = sourceInfo.GetCurrentMusicId(); if (currentMusicId > 0) { var equals = (currentMusicId == id); if (equals == false || replaceOnEquals == true) { // Stop Manager.Stop(window, sourceInfo, clipType, currentMusicId); } else if (equals == true) { // Don't play anything return; } } } var source = sourceInfo.GetSource(window, clipType, id); if (source == null) { return; } if (id == 0) { // Stop Manager.Stop(window, sourceInfo, clipType, id); return; } var state = Manager.currentData.GetState(clipType, id); if (state == null) { Manager.Stop(window, sourceInfo, clipType, id); return; } Manager.Reset(source); sourceInfo.ApplyVolume(clipType, source); if (clipType == ClipType.Music) { source.clip = state.clip; source.Play(); } else if (clipType == ClipType.SFX) { source.PlayOneShot(state.clip); } }
public static void SetVolume(ClipType clipType, float value) { if (WindowSystem.instance == null) { return; } WindowSystem.instance.audio.SetVolume(clipType, value); }
public void Play(ClipType type) { var clip = clips.Find((Clip c) => { return(c.type == type); }); if (clip != null) { Play(clip.autioClip); } }
public static List <Audio.Data.State> GetAudioItems(ClipType clipType) { if (FlowSystem.HasData() == false) { return(null); } return(FlowSystem.instance.data.audio.GetStates(clipType)); }
public static float GetVolume(ClipType clipType) { if (WindowSystem.instance == null) { return(0f); } return(WindowSystem.instance.audio.GetVolume(clipType)); }
public TypedAudioClip(AudioClip clip, ClipType type = ClipType.Undefined, string name = "NoName", float volume = 1f, bool mute = false, bool playOnAwake = false, bool loop = false) { this.clip = clip; this.type = type; this.name = name; this.volume = volume; this.mute = mute; this.playOnAwake = playOnAwake; this.loop = loop; }
public List<State> GetStates(ClipType clipType) { if (clipType == ClipType.Music) { return this.music; } else if (clipType == ClipType.SFX) { return this.fx; } return null; }
public float GetVolume(ClipType clipType) { var volume = 0f; if (clipType == ClipType.Music) { volume = this.musicVolume; } else if (clipType == ClipType.SFX) { volume = this.sfxVolume; } return volume; }
public static void Change(WindowBase window, Source sourceInfo, ClipType clipType, int id, Audio.Window audioSettings) { var source = sourceInfo.GetSource(window, clipType, id); if (source == null) return; source.bypassEffects = audioSettings.bypassEffect; source.bypassListenerEffects = audioSettings.bypassListenerEffect; source.bypassReverbZones = audioSettings.bypassReverbEffect; source.loop = audioSettings.loop; source.priority = audioSettings.priority; source.volume = audioSettings.volume; source.pitch = audioSettings.pitch; source.panStereo = audioSettings.panStereo; source.spatialBlend = audioSettings.spatialBlend; source.reverbZoneMix = audioSettings.reverbZoneMix; }
private PathStorage CombinePaths(IVertexSource a, IVertexSource b, ClipType clipType) { List<List<IntPoint>> aPolys = VertexSourceToClipperPolygons.CreatePolygons(a); List<List<IntPoint>> bPolys = VertexSourceToClipperPolygons.CreatePolygons(b); Clipper clipper = new Clipper(); clipper.AddPaths(aPolys, PolyType.ptSubject, true); clipper.AddPaths(bPolys, PolyType.ptClip, true); List<List<IntPoint>> intersectedPolys = new List<List<IntPoint>>(); clipper.Execute(clipType, intersectedPolys); PathStorage output = VertexSourceToClipperPolygons.CreatePathStorage(intersectedPolys); output.Add(0, 0, ShapePath.FlagsAndCommand.CommandStop); return output; }
public List<AudioSource> GetSources(WindowBase window, ClipType clipType) { #if UNITY_EDITOR if (Application.isPlaying == false) { return null; } #endif List<AudioSource> valuesByType; if (this.instancesByType.TryGetValue(clipType, out valuesByType) == false) { return null; } else { return valuesByType; } }
private PathStorage CombinePaths(IVertexSource a, IVertexSource b, ClipType clipType) { List<List<IntPoint>> aPolys = CreatePolygons(a); List<List<IntPoint>> bPolys = CreatePolygons(b); Clipper clipper = new Clipper(); clipper.AddPaths(aPolys, PolyType.ptSubject, true); clipper.AddPaths(bPolys, PolyType.ptClip, true); List<List<IntPoint>> intersectedPolys = new List<List<IntPoint>>(); clipper.Execute(clipType, intersectedPolys); PathStorage output = new PathStorage(); foreach (List<IntPoint> polygon in intersectedPolys) { bool first = true; foreach (IntPoint point in polygon) { if (first) { output.Add(point.X / 1000.0, point.Y / 1000.0, ShapePath.FlagsAndCommand.CommandMoveTo); first = false; } else { output.Add(point.X / 1000.0, point.Y / 1000.0, ShapePath.FlagsAndCommand.CommandLineTo); } } output.ClosePolygon(); } output.Add(0, 0, ShapePath.FlagsAndCommand.CommandStop); return output; }
public void SetVolume(ClipType clipType, float value) { if (clipType == ClipType.Music) { this.musicVolume = value; } else if (clipType == ClipType.SFX) { this.sfxVolume = value; } var sources = this.GetPlayingSources(null, clipType); if (sources != null) { foreach (var source in sources) { this.ApplyVolume(clipType, source); } } }
//------------------------------------------------------------------------------ public bool Execute(ClipType clipType, PolyTree polytree) { return Execute(clipType, polytree, PolyFillType.pftEvenOdd, PolyFillType.pftEvenOdd); }
public static void Stop(WindowBase window, Source sourceInfo, ClipType clipType, int id) { if (id == 0) { // Stop all var sources = sourceInfo.GetSources(window, clipType); if (sources == null) return; foreach (var source in sources) { if (source != null) { source.Stop(); source.clip = null; } } } else { var source = sourceInfo.GetSource(window, clipType, id); if (source == null) return; source.Stop(); source.clip = null; } }
public AudioSource GetPlayingSource(WindowBase window, ClipType clipType, int id) { #if UNITY_EDITOR if (Application.isPlaying == false) { return null; } #endif var key = this.GetKey(window, clipType, id); AudioSource value; if (this.instances.TryGetValue(key, out value) == false) { return null; } else { return value; } }
//------------------------------------------------------------------------------ public bool Execute(ClipType clipType, ExPolygons solution) { return Execute(clipType, solution, PolyFillType.pftEvenOdd, PolyFillType.pftEvenOdd); }
//------------------------------------------------------------------------------ public bool Execute(ClipType clipType, PolyTree polytree, PolyFillType subjFillType, PolyFillType clipFillType) { if (m_ExecuteLocked) return false; m_ExecuteLocked = true; m_SubjFillType = subjFillType; m_ClipFillType = clipFillType; m_ClipType = clipType; m_UsingPolyTree = true; bool succeeded = ExecuteInternal(); //build the return polygons ... if (succeeded) BuildResult2(polytree); m_ExecuteLocked = false; return succeeded; }
/// <summary> /// Joins all the polygones. /// ClipType: http://www.angusj.com/delphi/clipper/documentation/Docs/Units/ClipperLib/Types/ClipType.htm /// PolyFillType: http://www.angusj.com/delphi/clipper/documentation/Docs/Units/ClipperLib/Types/PolyFillType.htm /// </summary> /// <param name="sList">The s list.</param> /// <param name="cType">Type of the c.</param> /// <param name="pType">Type of the p.</param> /// <param name="pFType1">The p f type1.</param> /// <param name="pFType2">The p f type2.</param> /// <returns></returns> public static List<Polygon> ELJoinPolygons(this List<Polygon> sList, ClipType cType, PolyType pType = PolyType.ptClip, PolyFillType pFType1 = PolyFillType.pftNonZero, PolyFillType pFType2 = PolyFillType.pftNonZero) { var p = ELClipPolygons(sList); var tList = new List<List<IntPoint>>(); var c = new Clipper(); c.AddPaths(p, pType, true); c.Execute(cType, tList, pFType1, pFType2); return ToPolygons(tList); }
public RangeList[] GetBoundedRanges(int x, int y, int width, int height, CoordType coordType, ClipType xClipType, ClipType yClipType) { return proxy.GetBoundedRanges (x, y, width, height, coordType, xClipType, yClipType); }
//public static void public static List<List<Vertex>> Clip(Vertex subject, Vertex clip, ClipType clipType) { bool isIntersect = false; //phase 1 for (var si = subject; si != null; si = si.Next == subject ? null : si.Next) { if (si.IsIntersect) continue; for (var cj = clip; cj != null; cj = cj.Next == clip ? null : cj.Next) { if (cj.IsIntersect) continue; var cross = Segment.Intersect (si.ToPoint(), si.NonIntersectionNext.ToPoint(), cj.ToPoint(), cj.NonIntersectionNext.ToPoint()); if (cross.HasValue) { double a = cross.Value.DistanceBetween (si.ToPoint ()) / si.ToPoint ().DistanceBetween (si.NonIntersectionNext.ToPoint ()); double b = cross.Value.DistanceBetween (cj.ToPoint ()) / cj.ToPoint ().DistanceBetween (cj.NonIntersectionNext.ToPoint ()); Vertex i1 = new Vertex () { X = cross.Value.X, Y = cross.Value.Y, IsIntersect = true, Alpha = a, }; Vertex i2 = new Vertex () { X = cross.Value.X, Y = cross.Value.Y, IsIntersect = true, Alpha = b, }; i1.Neibour = i2; i2.Neibour = i1; i1.InsertTo (si, si.NonIntersectionNext); i2.InsertTo (cj, cj.NonIntersectionNext); isIntersect = true; } } } if(!isIntersect) { List<List<Vertex>> result = new List<List<Vertex>>(); if (subject.Contains(clip)) { result.Add(clip.ToVertexList()); } else if (clip.Contains(subject)) { result.Add(subject.ToVertexList()); } return result; } //phase 2 bool status = clip.Contains(subject); if (clipType == ClipType.Union || clipType == ClipType.Difference) status = !status; for (var si = subject; si != null; si = si.Next == subject ? null : si.Next) { if (si.IsIntersect) { si.IsExit = status; status = !status; } } status = subject.Contains(clip); if (clipType == ClipType.Union) status = !status; for (var cj = clip; cj != null; cj = cj.Next == clip ? null : cj.Next) { if (cj.IsIntersect) { cj.IsExit = status; status = !status; } } //phase 3 Vertex current; List<List<Vertex>> polygonList = new List<List<Vertex>>(); for (var si = subject; si != null; si = si.Next == subject ? null : si.Next) { if (si.IsIntersect && !si.IsVisit) { current = si; var polygon = new List<Vertex>(); polygonList.Add(polygon); polygon.Add(current); do { current.IsVisit = true; if (current.IsExit) { do { current = current.Previous; if(current.Neibour!= polygon[0]) polygon.Add(current); current.IsVisit = true; } while (!current.IsIntersect); } else { do { current = current.Next; if(current.Neibour != polygon[0]) polygon.Add(current); current.IsVisit = true; } while (!current.IsIntersect); } current = current.Neibour; } while (!current.IsVisit); } } return polygonList; }
void calculateRegionPath(ClipType clipType) { Clipper c = new Clipper(); var subjects = solution; //subjects.Add (solution); var clips = new Paths (); foreach (var path in regionList [regionList.Count - 1].regionPath) clips.Add (path); c.AddPolygons(subjects, PolyType.ptSubject); c.AddPolygons(clips, PolyType.ptClip); solution.Clear(); bool succeeded = c.Execute(clipType, solution, SUBJ_FILL_TYPE, CLIP_FILL_TYPE); if (succeeded) { PathsToInternalPath (solution); // Not sure what this is returning // var bounds = c.GetBounds (); // regionBounds.X = bounds.left / scale; // regionBounds.Y = bounds.top / scale; // regionBounds.Width = (bounds.right - bounds.left) / scale; // regionBounds.Height = (bounds.bottom - bounds.top) / scale; if (regionPath.IsEmpty) regionBounds = RectangleF.Empty; else regionBounds = regionPath.BoundingBox; } }
public AudioSource GetSource(WindowBase window, ClipType clipType, int id) { #if UNITY_EDITOR if (Application.isPlaying == false) { return null; } #endif if (clipType == ClipType.Music) { this.currentMusicId = id; } var key = this.GetKey(window, clipType, id); AudioSource value; if (this.instances.TryGetValue(key, out value) == false) { value = this.source.Spawn(); #if UNITY_EDITOR value.gameObject.name = string.Format("[ AudioSource ] {0} {1} {2}", (window != null ? window.name : string.Empty), clipType, id); #endif this.instances.Add(key, value); } List<AudioSource> valuesByType; if (this.instancesByType.TryGetValue(clipType, out valuesByType) == false) { this.instancesByType.Add(clipType, new List<AudioSource>() { value }); } else { valuesByType.Add(value); } this.ApplyVolume(clipType, value); return value; }
public void playClip(ClipType cliptype) { switch (cliptype) { case ClipType.ENEMYSPAWN: AudioSource.PlayClipAtPoint(clipEnemySpawn, Camera.mainCamera.transform.position);break; case ClipType.EAT: AudioSource.PlayClipAtPoint(clipEat, Camera.mainCamera.transform.position);break; case ClipType.HURT: AudioSource.PlayClipAtPoint(clipHurt, Camera.mainCamera.transform.position);break; case ClipType.DIE: AudioSource.PlayClipAtPoint(clipDie, Camera.mainCamera.transform.position);break; case ClipType.MUSIC: break; } }
//------------------------------------------------------------------------------ public bool Execute(ClipType clipType, Paths solution, PolyFillType subjFillType, PolyFillType clipFillType) { if (m_ExecuteLocked) return false; if (m_HasOpenPaths) throw new ClipperException("Error: PolyTree struct is need for open path clipping."); m_ExecuteLocked = true; solution.Clear(); m_SubjFillType = subjFillType; m_ClipFillType = clipFillType; m_ClipType = clipType; m_UsingPolyTree = false; bool succeeded = ExecuteInternal(); //build the return polygons ... if (succeeded) BuildResult(solution); m_ExecuteLocked = false; return succeeded; }
//------------------------------------------------------------------------------ public bool Execute(ClipType clipType, ExPolygons solution, PolyFillType subjFillType, PolyFillType clipFillType) { if (m_ExecuteLocked) return false; m_ExecuteLocked = true; solution.Clear(); m_SubjFillType = subjFillType; m_ClipFillType = clipFillType; m_ClipType = clipType; bool succeeded = ExecuteInternal(true); //build the return polygons ... if (succeeded) BuildResultEx(solution); m_ExecuteLocked = false; return succeeded; }
public void ApplyVolume(ClipType clipType, AudioSource source) { if (source != null) source.volume = this.GetVolume(clipType); }
public void RemoveAudioItem(ClipType clipType, int key) { this.audio.Remove(clipType, key); }
public void AddAudioItem(ClipType clipType, Audio.Data.State state) { state.key = this.GetNextAudioItemId(clipType); this.audio.Add(clipType, state); }