private static RgbaImage TextureDefinitionToImage(TextureDefinition definition) { RgbaImage newImage = new RgbaImage(definition.Dimension) { Namespace = definition.Namespace, Offset = definition.Offset }; foreach (TextureDefinitionPatch patch in definition.Patches) { if (TryGetOrReadImage(patch.Name, patch.Namespace, out RgbaImage image)) { Vec2I position = patch.Origin; if (patch.UseOffsets) { position += image.Offset; } // TODO: Handle the other fields on the patch (ex: flipping, rotation). newImage.DrawOntoThis(image, position); } else { throw new Exception($"Cannot find image patch {patch.Name} in texture definition {definition.Name}"); } } return(newImage); }
public PathStep(Vec2I Position, int TravelCost, int Heuristic) { position = Position; travelCost = TravelCost; heuristic = Heuristic; fullCost = travelCost + heuristic; }
public Breath(Vec2I Position, int Direction, int Distance, int Steps) { position = Position; direction = Direction; distance = Distance; steps = Steps; }
private void Init() { gridPos = TheGrid.GridPosition(transform.position); size = TheGrid.size; //each room spans the entire level at the moment //later on we can optimize this so level designer can restrict the area if (!TheGrid.Valid(gridPos)) { Debug.Log("Room \"" + gameObject.name + "\" out of grid! (" + gridPos + ")"); enabled = false; return; } HeatmapNode h = Heatmap.GetNode(gridPos); if (h == null) { Debug.Log("Room \"" + gameObject.name + "\" does not reside in heatmap! (" + gridPos + ")"); enabled = false; return; } parent = new Vec2I[size.x, size.y]; travelCost = new int[size.x, size.y]; steps = new int[size.x, size.y]; exist = new bool[size.x, size.y]; }
private void OnConsoleVideoMode(string arguments) { if (!string.IsNullOrEmpty(arguments)) { try { Vec2I mode = Vec2I.Parse(arguments); if (EngineApp.Instance.FullScreen && !DisplaySettings.VideoModeExists(mode)) { string text = string.Format("Cannot change screen resolution to \"{0}x{1}\". " + "This resolution is not supported by the system.", mode.X, mode.Y); Log.Warning(text); return; } EngineApp.Instance.VideoMode = mode; } catch (Exception ex) { Log.Warning(ex.Message); } } else { Print(string.Format("Value: \"{0}\"", EngineApp.Instance.VideoMode)); } }
void FormClosed(object sender, FormClosedEventArgs e) { CollectionEditor.CollectionForm form = (CollectionEditor.CollectionForm)sender; //save window settings lastWindowPosition = new Vec2I(form.Location.X, form.Location.Y); lastWindowSize = new Vec2I(form.Size.Width, form.Size.Height); if (form.DialogResult == DialogResult.Cancel) { //restore properties foreach (KeyValuePair <object, List <Pair <PropertyInfo, object> > > keyValuePair in propertyCopies) { object listItem = keyValuePair.Key; List <Pair <PropertyInfo, object> > pairList = keyValuePair.Value; foreach (Pair <PropertyInfo, object> pair in pairList) { PropertyInfo property = pair.First; object value = pair.Second; property.SetValue(listItem, value, null); } } } }
/// <summary> /// Creates a TextureX patch from the data provided. /// </summary> /// <param name="offset">The offset from the top left.</param> /// <param name="patchIndex">The PNames index.</param> /// <param name="stepDirection">An unused value.</param> /// <param name="colormap">Another unused value.</param> public TextureXPatch(Vec2I offset, short patchIndex, short stepDirection, short colormap) { Offset = offset; PatchIndex = patchIndex; StepDirection = stepDirection; Colormap = colormap; }
public static CelestialInfo FromStream(IStarboundStream stream) { CelestialInfo cInfo = new CelestialInfo(); cInfo.planetOrbitalLevels = stream.ReadInt32(); cInfo.satelliteOrbitalLevels = stream.ReadInt32(); cInfo.ChunkSize = stream.ReadInt32(); cInfo.xyCoordRange = Vec2I.FromStream(stream); cInfo.zCoordRange = stream.ReadToEnd(); // cInfo.zCoordRange = Vec2I.FromStream(stream); //doc lies??? // cInfo.zCoordRange = stream.ReadInt32(); /* * cInfo.OrbitalLevels = stream.ReadInt32(); * cInfo.ChunkSize = stream.ReadInt32(); * cInfo.XyCoordinateMin = stream.ReadInt32(); * cInfo.XyCoordinateMax = stream.ReadInt32(); * cInfo.ZCoordinateMin = stream.ReadInt32(); * cInfo.ZCoordinateMax = stream.ReadInt32(); * * ulong length = stream.ReadVLQ(); * * for (ulong i = 0; i < length; i++) * { * cInfo.Sectors.Add(Sector.FromStream(stream)); * } */ return(cInfo); }
private void Awake() { Messaging.DevTools.VisualizeHeatmap.AddListener(() => { Vec2I campos = TheGrid.GridPosition(Camera.main.transform.position); for (int x = campos.x - (int)Options.ScreenDistance.x; x <= campos.x + (int)Options.ScreenDistance.x; x++) { for (int y = campos.y - (int)Options.ScreenDistance.y; y <= campos.y + (int)Options.ScreenDistance.y; y++) { HeatmapNode node = Heatmap.GetNode(new Vec2I(x, y)); if (node != null) { VisualizeNode(Heatmap.Nodes[x, y]); VisualizeConnections(Heatmap.Nodes[x, y]); } } } }); Messaging.DevTools.ClearVisualizations.AddListener(() => { foreach (GameObject visualized in Visualized) { Destroy(visualized); } Visualized.Clear(); }); }
// protected override void OnCreateTexture( string definitionName, ref Vec2I size, ref PixelFormat format ) { base.OnCreateTexture( definitionName, ref size, ref format ); if( definitionName == "scene" || definitionName == "temp" ) size = Owner.DimensionsInPixels.Size / 2; }
public Breath(Vec2I GridPos, Vec2I Parent, int TravelCost, int Steps) { gridPos = GridPos; parent = Parent; travelCost = TravelCost; steps = Steps; }
protected override void OnCreateTexture(string definitionName, ref Vec2I size, ref PixelFormat format) { base.OnCreateTexture(definitionName, ref size, ref format); if (definitionName == "rt_downscale" || definitionName == "rt_blurHorizontal" || definitionName == "rt_blurVertical") { float divisor = 8.0f - blurTextureResolution; if (divisor <= 1) { divisor = 1; } Vec2 sizeFloat = Owner.DimensionsInPixels.Size.ToVec2() / divisor; size = new Vec2I((int)sizeFloat.X, (int)sizeFloat.Y); if (size.X < 1) { size.X = 1; } if (size.Y < 1) { size.Y = 1; } downscaleTextureSize = size; } }
public BooleanBox(Vec2I Origo, Vec2I Size) { origo = Origo; size = Size; data = new bool[size.x, size.y]; }
public List <Breath> GetNearbyBreaths(Vec2I pos, int extend) { List <Breath> list = new List <Breath>(); if (extend == 0) { Breath b = GetBreath(pos); if (b != null) { list.Add(b); } return(list); } foreach (Vec2I n in Vec2I.Neighbors(pos + new Vec2I(maxDistance, maxDistance))) { if (Valid(n)) { if (exist[n.x, n.y]) { list.Add(new Breath(n, parent[n.x, n.y], travelCost[n.x, n.y], steps[n.x, n.y])); } } } return(list); }
public static Vec2I[] CartesianLine(int x0, int y0, int x1, int y1) { bool steep = Mathf.Abs(y1 - y0) > Mathf.Abs(x1 - x0); if (steep) { Swap(ref x0, ref y0); Swap(ref x1, ref y1); } bool flip = false; if (x0 > x1) { Swap(ref x0, ref x1); Swap(ref y0, ref y1); flip = true; } int dx = x1 - x0; int dy = Mathf.Abs(y1 - y0); int error = dx / 2; int ystep = (y0 < y1) ? 1 : -1; int y = y0; Vec2I[] array = new Vec2I[x1 - x0 + 1]; if (flip) { int i = array.Length - 1; for (int x = x0; x <= x1; x++) { array[i--] = steep ? new Vec2I(y, x) : new Vec2I(x, y); error = error - dy; if (error < 0) { y += ystep; error += dx; } } } else { int i = 0; for (int x = x0; x <= x1; x++) { array[i++] = steep ? new Vec2I(y, x) : new Vec2I(x, y); error = error - dy; if (error < 0) { y += ystep; error += dx; } } } return(array); }
protected override void OnAwake() { base.OnAwake(); for (int r = 0; r < Room.Rooms.Length; r++) { if (Room.Rooms[r].name == TargetRoomName) { targetRoom = r; break; } } Messaging.Mission.MissionTrigger.AddListener((s) => { if (s != MissionTrigger) { return; } activated = true; }); /*for (int r = 0; r < Room.Rooms.Length; r++) * if (Room.Rooms[r].ClosestNeighborTowards[targetRoom] != -1) * Debug.Log("Room \"" + Room.Rooms[r].name + "\" closest neighbor towards targetroom is \"" + Room.Rooms[Room.Rooms[r].ClosestNeighborTowards[targetRoom]].name + "\"");*/ character.OnInputRequest = StandAround; Messaging.Player.PlayerGridPosition.AddListener((p) => { playerGridPos = p; }); }
/////////////// private bool CreateRenderTexture() { Vec2I size = new Vec2I(512, 256); string textureName = TextureManager.Instance.GetUniqueName("RenderToTextureExample"); texture = TextureManager.Instance.Create(textureName, Texture.Type.Type2D, size, 1, 0, PixelFormat.R8G8B8, Texture.Usage.RenderTarget); if (texture == null) return false; renderTexture = texture.GetBuffer().GetRenderTarget(); //you can update render texture manually by means renderTexture.Update() method. For this task set AutoUpdate = false; renderTexture.AutoUpdate = true; //create camera string cameraName = SceneManager.Instance.GetUniqueCameraName("RenderToTextureExample"); camera = SceneManager.Instance.CreateCamera(cameraName); camera.Purpose = Camera.Purposes.Special; camera.AllowMapCompositorManager = false; //add viewport viewport = renderTexture.AddViewport(camera); viewport.BackgroundColor = new ColorValue(0, 0, 0, 1); viewport.ShadowsEnabled = false; viewport.MaterialScheme = ""; //add listener renderTargetListener = new SceneRenderTargetListener(this); renderTexture.AddListener(renderTargetListener); return true; }
protected override void OnCreateTexture(string definitionName, ref Vec2I size, ref PixelFormat format) { base.OnCreateTexture(definitionName, ref size, ref format); //if (definitionName == "scene" || definitionName == "temp") // size = Owner.DimensionsInPixels.Size / 2; }
public static Optional <TextureXImage> From(ByteReader reader) { try { UpperString name = reader.StringWithoutNulls(8); TextureXFlags flags = (TextureXFlags)reader.UShort(); Vector2 scale = new Vector2(reader.Byte(), reader.Byte()); Dimension dimension = new Dimension(reader.Short(), reader.Short()); int columnDirectory = reader.Int(); int patchCount = reader.Short(); List <TextureXPatch> patches = Range(patchCount).Map(i => { Vec2I offset = new Vec2I(reader.Short(), reader.Short()); short patchIndex = reader.Short(); short stepDirection = reader.Short(); short colormap = reader.Short(); return(new TextureXPatch(offset, patchIndex, stepDirection, colormap)); }).ToList(); return(new TextureXImage(name, flags, scale, dimension, columnDirectory, patches)); } catch { return(Empty); } }
public override void Read(IStarboundStream stream) { OutputConnectorLocation = Vec2I.FromStream(stream); OutputConnectorLocation = Vec2I.FromStream(stream); InputObjectLocation = Vec2I.FromStream(stream); InputConnectorLocation = Vec2I.FromStream(stream); }
protected override void OnMaterialRender(uint passId, Material material, ref bool skipPass) { base.OnMaterialRender(passId, material, ref skipPass); if (passId == 700 || passId == 701) { bool horizontal = passId == 700; Vec2[] sampleOffsets = new Vec2[15]; Vec4[] sampleWeights = new Vec4[15]; // calculate gaussian texture offsets & weights Vec2I textureSize = Owner.DimensionsInPixels.Size; float texelSize = 1.0f / (float)(horizontal ? textureSize.X : textureSize.Y); texelSize *= fuzziness; // central sample, no offset sampleOffsets[0] = Vec2.Zero; { float distribution = GaussianDistribution(0, 0, 3); sampleWeights[0] = new Vec4(distribution, distribution, distribution, 0); } // 'pre' samples for (int n = 1; n < 8; n++) { float distribution = GaussianDistribution(n, 0, 3); sampleWeights[n] = new Vec4(distribution, distribution, distribution, 1); if (horizontal) { sampleOffsets[n] = new Vec2((float)n * texelSize, 0); } else { sampleOffsets[n] = new Vec2(0, (float)n * texelSize); } } // 'post' samples for (int n = 8; n < 15; n++) { sampleWeights[n] = sampleWeights[n - 7]; sampleOffsets[n] = -sampleOffsets[n - 7]; } //convert to Vec4 array Vec4[] vec4Offsets = new Vec4[15]; for (int n = 0; n < 15; n++) { Vec2 offset = sampleOffsets[n]; vec4Offsets[n] = new Vec4(offset.X, offset.Y, 0, 0); } GpuProgramParameters parameters = material.GetBestTechnique(). Passes[0].FragmentProgramParameters; parameters.SetNamedConstant("sampleOffsets", vec4Offsets); parameters.SetNamedConstant("sampleWeights", sampleWeights); } }
private bool MoveTowardsBreath() { Breath b = GameManager.Instance.Player[0].playerBreath.GetBreath(owner.cell); if (b == null) { return(false); } if (b.direction == 0) { return(false); } Vec2I d = Vec2I.directions[b.direction]; Vec2I target = owner.cell + d; if (AI.GetHeat(target).x >= 1f) { return(false); } if (AI.HasLedge(owner.cell, target)) { return(false); } wantDirection = new Vector3(d.x, 0, d.y).normalized; wantMove = true; return(true); }
void CreateBrowser() { if (!isCefRuntimeInitialized) { InitializeCefRuntime(); } if (isCefRuntimeInitialized) { this.viewSize = GetNeededSize(); var windowInfo = CefWindowInfo.Create(); windowInfo.SetAsWindowless(IntPtr.Zero, false); var client = new WebClient(this); var settings = new CefBrowserSettings { // AuthorAndUserStylesDisabled = false, }; CefBrowserHost.CreateBrowser(windowInfo, client, settings, !string.IsNullOrEmpty(StartURL) ? StartURL : "about:blank"); if (!string.IsNullOrEmpty(startUrl)) { LoadURL(startUrl); } } }
private void Awake() { Messaging.System.LevelLoaded.AddListener((i) => { Vector2 size = transform.localScale; Vector2 offset = transform.position; TheGrid.min = Vec2I.Floor(offset - size / 2); TheGrid.max = Vec2I.Ceil(offset + size / 2); TheGrid.size = TheGrid.max - TheGrid.min; Heatmap.Recalculate(); Room.ReconstructNetwork(); AfterInit.Invoke(); //report room information /*foreach (Room r in Room.Rooms) * { * string d = "Room \"" + r.gameObject.name + "\" has " + r.Neighbors.Count + " neigbors: \n"; * r.Neighbors.Perform((n) => { d += "\"" + Room.Rooms[n.Data].gameObject.name + "\" "; }); * Debug.Log(d); * * Debug.Log("ROOM \"" + r.gameObject.name + "\" neighbors:"); * r.Neighbors.Perform((n) => * { * Debug.Log("neighbor \"" + Room.Rooms[n.Data].gameObject.name + "\" distance: "+ r.DistanceToNeighbor[n.Data]); * }); * }*/ }); }
internal void DestroyViewport() { if (renderTargetListener != null) { RenderTarget renderTarget = texture.GetBuffer().GetRenderTarget(); renderTarget.RemoveListener(renderTargetListener); renderTargetListener.Dispose(); renderTargetListener = null; } if (viewport != null) { viewport.Dispose(); viewport = null; } if (camera != null) { camera.Dispose(); camera = null; } if (texture != null) { texture.Dispose(); texture = null; instance.preventTextureCreationRemainingFrames = 2; } initializedTextureSize = Vec2I.Zero; }
private void Awake() { Messaging.Player.Position.AddListener((v) => { Vec2I g = TheGrid.GridPosition(v); if (lastPlayerGridPosition == g) { return; } lastPlayerGridPosition = g; int gridDistance = Vec2I.Max(g, TheGrid.GridPosition(transform.position)); if (gridDistance <= ShowTextDistance) { if (floatingText == null) { floatingText = Messaging.GUI.FloatingText(transform.position + Offset, ShowText, TextColorFar); } floatingText.color = gridDistance <= UseDistance ? TextColorClose : TextColorFar; } else if (floatingText != null && gridDistance > ShowTextDistance) { Destroy(floatingText.gameObject); floatingText = null; } }); }
protected override void OnPreRenderTargetUpdate(RenderTargetEvent evt) { base.OnPreRenderTargetUpdate(evt); Camera defaultCamera = RendererWorld.Instance.DefaultCamera; Camera camera = owner.camera; //set camera settings to default state camera.ProjectionType = defaultCamera.ProjectionType; camera.OrthoWindowHeight = defaultCamera.OrthoWindowHeight; camera.NearClipDistance = defaultCamera.NearClipDistance; camera.FarClipDistance = defaultCamera.FarClipDistance; Vec2I sizeInPixels = owner.Viewport.DimensionsInPixels.Size; camera.AspectRatio = (float)sizeInPixels.X / (float)sizeInPixels.Y; camera.Fov = defaultCamera.Fov; camera.FixedUp = defaultCamera.FixedUp; camera.Direction = defaultCamera.Direction; camera.Position = defaultCamera.Position; ////override visibility (hide main scene objects, show from lists) //List<SceneNode> sceneNodes = new List<SceneNode>(); //if( owner.sceneNode != null ) // sceneNodes.Add( owner.sceneNode ); //SceneManager.Instance.SetOverrideVisibleObjects( new SceneManager.OverrideVisibleObjectsClass( // new StaticMeshObject[ 0 ], sceneNodes.ToArray(), new RenderLight[ 0 ] ) ); if (owner.Render != null) { owner.Render(owner, camera); } }
private bool MoveToRandomNearbyCell() { List <Vec2I> possible = new List <Vec2I>(); foreach (Vec2I neighbor in owner.cell.neighbors) { if (!AI.CanPath(neighbor)) { continue; } if (AI.GetHeat(neighbor).x >= 1f) { continue; } if (AI.HasLedge(owner.cell, neighbor)) { continue; } possible.Add(neighbor); } if (possible.Count == 0) { return(false); } Vec2I d = Vec2I.directions[AxMath.RogueDirection(owner.cell, possible[Random.Range(0, possible.Count)])]; wantDirection = new Vector3(d.x, 0, d.y).normalized; return(true); }
private void BlipMove(ref MonsterCharacter.InputFrame frame) { frame.up = dir.y; frame.right = dir.x; frame.WantDirection = Quaternion.Euler(0, 0, AxMath.SafeAtan2(dir.y, dir.x) * Mathf.Rad2Deg); if (blipTimer > 0) { blipTimer -= Time.deltaTime; return; } blipTimer = BlipTime; dir = Vec2I.zero; if (Random.value < BlipWaitChance) { return; } if (Leashed) { if ((homePosition - transform.position).sqrMagnitude >= LeashRange * LeashRange) { Vector2 distance = transform.position - Camera.main.transform.position; if (Mathf.Max(distance.x) > Options.AlertDistance.x || Mathf.Max(distance.y) > Options.AlertDistance.y) { Destroy(gameObject); } } } if (Random.value < BlipRandomChance) { dir = Vec2I.directions[Random.Range(1, Vec2I.directions.Length)]; return; } if (HuntPlayer) { if (LastKnownPlayerRoom != -1) { targetRoom = LastKnownPlayerRoom; } } if (targetRoom >= 0 && targetRoom < Room.Rooms.Length) { //simplistic behavior //dir = Room.Rooms[targetRoom].parent[thing.gridPos.x, thing.gridPos.y] - thing.gridPos; //return; //to avoid monsters piling up on single point if (Vec2I.Manhattan(Room.Rooms[targetRoom].gridPos, thing.gridPos) < NearSteps) { return; } if (!AI.RoomPath(thing.gridPos, Room.Rooms[targetRoom], MaxSteps, out Vec2I[] path))
public static Vec2I NaturalStep(Vec2I[] path, int maxSteps) { if (path.Length == 0) { return(Vec2I.zero); } if (path.Length < 3) { return(path[1]); } if (maxSteps < 2) { return(path[1]); } Vec2I[] lastLine = new Vec2I[0]; int steps = 0; int e = 2; again: Vec2I[] line = AxMath.CartesianLine(path[0], path[e]); for (int i = 0; i < line.Length; i++) { HeatmapNode n = Heatmap.GetNode(line[i]); if (n == null) { goto failed; } if (!n.WideOpen) { goto failed; } } if (steps <= maxSteps) { if (e == path.Length - 1) { return(path[e]); } lastLine = line; steps++; e++; goto again; } failed: if (e > 2) { return(lastLine[lastLine.Length - 1]); } return(path[1]); }
//returns Vec2I direction between two points public static int Atan2Direction(Vec2I origo, Vec2I target) { if (origo == target) { return(0); } return((int)(((SafeAtan2(target.y - origo.y, target.x - origo.x) + Mathf.PI) / TAU * 8) % 8 + 1)); }
public static int GetRoomIndex(Vec2I gridpos) { if (!TheGrid.Valid(gridpos)) { return(-1); } return(RoomIndex[gridpos.x, gridpos.y]); }
protected override void OnBeginRenderLightmap( StaticLightingCalculationWorld.MeshObject meshObject, LightmapImage renderingImage ) { lightmapMeshObject = meshObject; lightmapRenderingImage = renderingImage; lightmapBucketIndex = Vec2I.Zero; Vec2I textureSize = lightmapRenderingImage.Size; //generate lightmapTriangleMap { lightmapTriangleMap = new int[ textureSize.Y ][]; for( int y = 0; y < textureSize.Y; y++ ) { lightmapTriangleMap[ y ] = new int[ textureSize.X ]; for( int x = 0; x < textureSize.X; x++ ) lightmapTriangleMap[ y ][ x ] = -1; } Mesh mesh = meshObject.Mesh; int triangleCount = mesh.Indices.Length / 3; for( int triangleIndex = 0; triangleIndex < triangleCount; triangleIndex++ ) { int index0 = mesh.Indices[ triangleIndex * 3 + 0 ]; int index1 = mesh.Indices[ triangleIndex * 3 + 1 ]; int index2 = mesh.Indices[ triangleIndex * 3 + 2 ]; Vec3 position0 = mesh.Positions[ index0 ]; Vec3 position1 = mesh.Positions[ index1 ]; Vec3 position2 = mesh.Positions[ index2 ]; if( MathUtils.IsDegenerateTriangle( position0, position1, position2 ) ) continue; Vec2 texCoord0 = mesh.LightmapTexCoords[ index0 ]; Vec2 texCoord1 = mesh.LightmapTexCoords[ index1 ]; Vec2 texCoord2 = mesh.LightmapTexCoords[ index2 ]; Vec2I pixelIndex0 = GetPixelIndexByTexCoord( texCoord0 ); Vec2I pixelIndex1 = GetPixelIndexByTexCoord( texCoord1 ); Vec2I pixelIndex2 = GetPixelIndexByTexCoord( texCoord2 ); Geometry2D.FillTriangle( pixelIndex0, pixelIndex1, pixelIndex2, new RectI( Vec2I.Zero, textureSize ), delegate( Vec2I point ) { lightmapTriangleMap[ point.Y ][ point.X ] = triangleIndex; } ); } } }
protected override void OnCreateTexture( string definitionName, ref Vec2I size, ref PixelFormat format ) { base.OnCreateTexture( definitionName, ref size, ref format ); if( definitionName == "rt_brightPass" ) { size = Owner.DimensionsInPixels.Size / 2; brightPassTextureSize = size; } else if( definitionName == "rt_bloomBlur" || definitionName == "rt_bloomHorizontal" || definitionName == "rt_bloomVertical" ) { size = Owner.DimensionsInPixels.Size / 4; bloomTextureSize = size; } }
public void ClearMotionMap() { initialized = false; gridCellSizeInv = 0; onClosedList = 0; openList = null; whichList = null; openX = null; openY = null; parentX = null; parentY = null; Fcost = null; Gcost = null; Hcost = null; pathLength = 0; pathArray = null; mapSize = Vec2I.Zero; mapMaxIndex = Vec2I.Zero; mapMotionPosition = Vec2.Zero; mapMotion = null; mapMotionRectangles = new Dictionary<MapObject, RectI[]>(); renderVertices.Clear(); renderFreeIndices.Clear(); renderBusyIndices.Clear(); }
bool CreateRenderTarget() { DestroyRenderTarget(); if( RendererWorld.Instance == null ) return false; Vec2I textureSize = GetDemandTextureSize(); if( textureSize.X < 1 || textureSize.Y < 1 ) return false; string textureName = TextureManager.Instance.GetUniqueName( "WPFRenderTexture" ); int hardwareFSAA = 0; if( !RendererWorld.InitializationOptions.AllowSceneMRTRendering ) { if( !int.TryParse( RendererWorld.InitializationOptions.FullSceneAntialiasing, out hardwareFSAA ) ) hardwareFSAA = 0; } texture = TextureManager.Instance.Create( textureName, Texture.Type.Type2D, textureSize, 1, 0, Engine.Renderer.PixelFormat.R8G8B8, Texture.Usage.RenderTarget, false, hardwareFSAA ); if( texture == null ) return false; currentTextureSize = textureSize; renderTexture = texture.GetBuffer().GetRenderTarget(); renderTexture.AutoUpdate = false; renderTexture.AllowAdditionalMRTs = true; camera = SceneManager.Instance.CreateCamera( SceneManager.Instance.GetUniqueCameraName( "UserControl" ) ); camera.Purpose = Camera.Purposes.MainCamera; //update camera settings camera.NearClipDistance = cameraNearFarClipDistance.Minimum; camera.FarClipDistance = cameraNearFarClipDistance.Maximum; camera.AspectRatio = (float)texture.Size.X / (float)texture.Size.Y; camera.FixedUp = cameraFixedUp; camera.Position = cameraPosition; camera.Direction = cameraDirection; camera.Fov = cameraFov; camera.ProjectionType = cameraProjectionType; camera.OrthoWindowHeight = cameraOrthoWindowHeight; viewport = renderTexture.AddViewport( camera ); //Initialize HDR compositor for HDR render technique if( EngineApp.RenderTechnique == "HDR" ) { viewport.AddCompositor( "HDR", 0 ); viewport.SetCompositorEnabled( "HDR", true ); } //Initialize Fast Approximate Antialiasing (FXAA) { bool useMRT = RendererWorld.InitializationOptions.AllowSceneMRTRendering; string fsaa = RendererWorld.InitializationOptions.FullSceneAntialiasing; if( ( useMRT && ( fsaa == "" || fsaa == "RecommendedSetting" ) && IsActivateFXAAByDefault() ) || fsaa == "FXAA" ) { if( RenderSystem.Instance.HasShaderModel3() ) InitializeFXAACompositor(); } } //add listener renderTargetListener = new ViewRenderTargetListener( this ); renderTexture.AddListener( renderTargetListener ); if( guiRenderer == null ) guiRenderer = new GuiRenderer( viewport ); else guiRenderer.ChangeViewport( viewport ); if( controlManager == null ) controlManager = new ScreenControlManager( guiRenderer ); //initialize D3DImage output if( d3dImageIsSupported && allowUsingD3DImage ) { // create a D3DImage to host the scene and monitor it for changes in front buffer availability if( d3dImage == null ) { d3dImage = new D3DImage(); d3dImage.IsFrontBufferAvailableChanged += D3DImage_IsFrontBufferAvailableChanged; CompositionTarget.Rendering += D3DImage_OnRendering; } // set output to background image Background = new ImageBrush( d3dImage ); // set the back buffer using the new scene pointer HardwarePixelBuffer buffer = texture.GetBuffer( 0, 0 ); GetD3D9HardwarePixelBufferData data = new GetD3D9HardwarePixelBufferData(); data.hardwareBuffer = buffer._GetRealObject(); data.outPointer = IntPtr.Zero; unsafe { GetD3D9HardwarePixelBufferData* pData = &data; if( !RenderSystem.Instance.CallCustomMethod( "Get D3D9HardwarePixelBuffer getSurface", (IntPtr)pData ) ) Log.Fatal( "Get D3D9HardwarePixelBuffer getSurface failed." ); } d3dImage.Lock(); d3dImage.SetBackBuffer( D3DResourceType.IDirect3DSurface9, data.outPointer ); d3dImage.Unlock(); } return true; }
void Client_ReceiveIndex( RemoteEntityWorld sender, ReceiveDataReader reader ) { Vec2I value = reader.ReadVec2I(); if( !reader.Complete() ) return; index = value; }
static void CalculateGaussianBlur5x5SampleOffsets( Vec2I textureSize, Vec2[] sampleOffsets, Vec4[] sampleWeights, float multiplier ) { float tu = 1.0f / (float)textureSize.X; float tv = 1.0f / (float)textureSize.Y; Vec4 white = new Vec4( 1, 1, 1, 1 ); float totalWeight = 0.0f; int index = 0; for( int x = -2; x <= 2; x++ ) { for( int y = -2; y <= 2; y++ ) { // Exclude pixels with a block distance greater than 2. This will // create a kernel which approximates a 5x5 kernel using only 13 // sample points instead of 25; this is necessary since 2.0 shaders // only support 16 texture grabs. if( Math.Abs( x ) + Math.Abs( y ) > 2 ) continue; // Get the unscaled Gaussian intensity for this offset sampleOffsets[ index ] = new Vec2( x * tu, y * tv ); sampleWeights[ index ] = white * GaussianDistribution( (float)x, (float)y, 1 ); totalWeight += sampleWeights[ index ].X; index++; } } // Divide the current weight by the total weight of all the samples; Gaussian // blur kernels add to 1.0f to ensure that the intensity of the image isn't // changed when the blur occurs. An optional multiplier variable is used to // add or remove image intensity during the blur. for( int i = 0; i < index; i++ ) { sampleWeights[ i ] /= totalWeight; sampleWeights[ i ] *= multiplier; } }
public bool FindPath( float unitSize, Vec2 start, Vec2 end, int maxFieldsDistance, int maxFieldsToCheck, bool smooth, bool visualizeForDebugging, List<Vec2> path ) { if( !initialized ) return false; path.Clear(); float internalUnitSize = unitSize * gridCellSizeInv; int nInternalUnitSize = (int)( internalUnitSize + .99999f ); if( nInternalUnitSize == 0 ) Log.Fatal( "GridBasedNavigationSystem: FindPath: nInternalUnitSize == 0." ); Vec2 internalStart = ( start - mapMotionPosition ) * gridCellSizeInv; Vec2 internalEnd = ( end - mapMotionPosition ) * gridCellSizeInv; Vec2I nInternalStart = new Vec2I( (int)internalStart.X, (int)internalStart.Y ); Vec2I nInternalEnd = new Vec2I( (int)internalEnd.X, (int)internalEnd.Y ); if( nInternalStart.X < 0 || nInternalStart.X >= mapSize.X || nInternalStart.Y < 0 || nInternalStart.Y >= mapSize.Y ) return false; if( nInternalEnd.X < 0 || nInternalEnd.X >= mapSize.X || nInternalEnd.Y < 0 || nInternalEnd.Y >= mapSize.Y ) return false; int nPathSize = DoFindA( nInternalStart, nInternalEnd, nInternalUnitSize, maxFieldsDistance, maxFieldsToCheck, visualizeForDebugging ); if( nPathSize == 0 ) return false; if( smooth ) { //remove fictitious points nPathSize = RemoveFictitiousPoints( nInternalStart, nPathSize ); if( nPathSize == 0 ) return false; } pathArray[ 0 ] = nInternalStart; if( smooth ) { //smooth path nPathSize = Smooth( internalStart, nPathSize + 1, internalUnitSize ); if( nPathSize == 0 ) return false; } for( int n = 0; n < nPathSize; n++ ) { Vec2 internalPoint = new Vec2( pathArray[ n ].X, pathArray[ n ].Y ) + new Vec2( .5f, .5f ); path.Add( internalPoint * GridCellSize + mapMotionPosition ); } if( !smooth || pathLength == 1 ) path.Add( end ); return true; }
public Vec2 GetPieceDestinationPosition( Vec2I index ) { //piece size is always 1,1 return new Vec2( .5f, .5f ) + index.ToVec2(); }
void ServerOrSingle_SetPieceCount( Vec2I pieceCount ) { this.pieceCount = pieceCount; //send pieceCount to clients if( EntitySystemWorld.Instance.IsServer() ) Server_SendPieceCountToClients( EntitySystemWorld.Instance.RemoteEntityWorlds ); }
void ServerOrSingle_GeneratePuzzles( Vec2I pieceCount ) { ServerOrSingle_DestroyPuzzles(); ServerOrSingle_SetPieceCount( pieceCount ); for( int y = 0; y < pieceCount.Y; y++ ) for( int x = 0; x < pieceCount.X; x++ ) ServerOrSingle_CreatePiece( new Vec2I( x, y ) ); }
void ServerOrSingle_CreatePiece( Vec2I index ) { JigsawPuzzlePiece piece = (JigsawPuzzlePiece)Entities.Instance.Create( "JigsawPuzzlePiece", Map.Instance ); piece.ServerOrSingle_SetIndex( index ); //calculate position { Rect area = GetGameArea(); area.Expand( -.5f ); Rect exceptArea = GetDestinationArea(); exceptArea.Expand( 1 ); float x = 0; float y = 0; bool free = false; do { free = true; EngineRandom random = World.Instance.Random; x = area.Minimum.X + random.NextFloat() * area.Size.X; y = area.Minimum.Y + random.NextFloat() * area.Size.Y; if( exceptArea.IsContainsPoint( new Vec2( x, y ) ) ) free = false; Bounds checkBounds = new Bounds( new Vec3( x - .5f, y - .5f, -100 ), new Vec3( x + .5f, y + .5f, 100 ) ); Map.Instance.GetObjects( checkBounds, delegate( MapObject mapObject ) { JigsawPuzzlePiece p = mapObject as JigsawPuzzlePiece; if( p != null ) free = false; } ); } while( !free ); piece.Position = new Vec3( x, y, .1f ); } piece.PostCreate(); }
void Client_ReceivePieceCount( RemoteEntityWorld sender, ReceiveDataReader reader ) { Vec2I value = reader.ReadVec2I(); if( !reader.Complete() ) return; pieceCount = value; }
int DoFindA( Vec2I start, Vec2I end, int unitSize, int maxFieldsDistance, int maxFieldsToCheck, bool visualizeForDebugging ) { const int found = 1, nonexistent = 2; const int notStarted = 0;// path-related constants const int walkable = 0;// walkability array constants int onOpenList = 0, parentXval = 0, parentYval = 0, a = 0, b = 0, m = 0, u = 0, v = 0, temp = 0, corner = 0, numberOfOpenListItems = 0, addedGCost = 0, tempGcost = 0, path = 0, tempx, pathX, pathY, //cellPosition, newOpenListItemID = 0; //1. Convert location data (in pixels) to coordinates in the walkability array. int startX = start.X; int startY = start.Y; int targetX = end.X; int targetY = end.Y; //2.Quick Path Checks: Under the some circumstances no path needs to // be generated ... // If starting location and target are in the same location... if( start == end ) return 0; // if (startX == targetX && startY == targetY && pathLocation[pathfinderID] > 0) // return found; // if (startX == targetX && startY == targetY && pathLocation[pathfinderID] == 0) // return nonexistent; // If target square is unwalkable, return that it's a nonexistent path. if( !IsFreeInMapMotion( new Vec2I( targetX, targetY ), unitSize ) ) return 0; //3.Reset some variables that need to be cleared if( onClosedList > 1000000 ) //reset whichList occasionally { for( int y = 0; y < mapSize.Y; y++ ) for( int x = 0; x < mapSize.X; x++ ) whichList[ x, y ] = 0; //memset( whichList, 0, sizeof( whichList ) ); onClosedList = 10; } onClosedList = onClosedList + 2; //changing the values of onOpenList and onClosed list is faster than redimming whichList() array onOpenList = onClosedList - 1; pathLength = notStarted;//i.e, = 0 //pathLocation = notStarted;//i.e, = 0 Gcost[ startX, startY ] = 0; //reset starting square's G value to 0 //4.Add the starting location to the open list of squares to be checked. numberOfOpenListItems = 1; openList[ 1 ] = 1;//assign it as the top (and currently only) item in the open list, which is maintained as a binary heap (explained below) openX[ 1 ] = startX; openY[ 1 ] = startY; int fieldsCheckedCount = 0; //5.Do the following until a path is found or deemed nonexistent. do { //6.If the open list is not empty, take the first cell off of the list. // This is the lowest F cost cell on the open list. if( numberOfOpenListItems != 0 ) { //7. Pop the first item off the open list. parentXval = openX[ openList[ 1 ] ]; parentYval = openY[ openList[ 1 ] ]; //record cell coordinates of the item whichList[ parentXval, parentYval ] = onClosedList;//add the item to the closed list // Open List = Binary Heap: Delete this item from the open list, which // is maintained as a binary heap. For more information on binary heaps, see: // http://www.policyalmanac.org/games/binaryHeaps.htm numberOfOpenListItems = numberOfOpenListItems - 1;//reduce number of open list items by 1 // Delete the top item in binary heap and reorder the heap, with the lowest F cost item rising to the top. openList[ 1 ] = openList[ numberOfOpenListItems + 1 ];//move the last item in the heap up to slot #1 v = 1; // Repeat the following until the new item in slot #1 sinks to its proper spot in the heap. do { u = v; if( 2 * u + 1 <= numberOfOpenListItems ) //if both children exist { //Check if the F cost of the parent is greater than each child. //Select the lowest of the two children. if( Fcost[ openList[ u ] ] >= Fcost[ openList[ 2 * u ] ] ) v = 2 * u; if( Fcost[ openList[ v ] ] >= Fcost[ openList[ 2 * u + 1 ] ] ) v = 2 * u + 1; } else { if( 2 * u <= numberOfOpenListItems ) //if only child #1 exists { //Check if the F cost of the parent is greater than child #1 if( Fcost[ openList[ u ] ] >= Fcost[ openList[ 2 * u ] ] ) v = 2 * u; } } if( u != v ) //if parent's F is > one of its children, swap them { temp = openList[ u ]; openList[ u ] = openList[ v ]; openList[ v ] = temp; } else break; //otherwise, exit loop } while( true ); //7.Check the adjacent squares. (Its "children" -- these path children // are similar, conceptually, to the binary heap children mentioned // above, but don't confuse them. They are different. Path children // are portrayed in Demo 1 with grey pointers pointing toward // their parents.) Add these adjacent child squares to the open list // for later consideration if appropriate (see various if statements // below). for( b = parentYval - 1; b <= parentYval + 1; b++ ) { for( a = parentXval - 1; a <= parentXval + 1; a++ ) { // If not off the map (do this first to avoid array out-of-bounds errors) if( a != -1 && b != -1 && a != mapSize.X && b != mapSize.Y ) { // If not already on the closed list (items on the closed list have // already been considered and can now be ignored). if( whichList[ a, b ] != onClosedList ) { // If not a wall/obstacle square. if( Math.Abs( a - start.X ) <= maxFieldsDistance && Math.Abs( b - start.Y ) <= maxFieldsDistance ) { if( IsFreeInMapMotion( new Vec2I( a, b ), unitSize ) ) { // Don't cut across corners corner = walkable; if( a == parentXval - 1 ) { if( b == parentYval - 1 ) { if( !IsFreeInMapMotion( new Vec2I( parentXval - 1, parentYval ), unitSize ) || !IsFreeInMapMotion( new Vec2I( parentXval, parentYval - 1 ), unitSize ) ) corner = 1; } else if( b == parentYval + 1 ) { if( !IsFreeInMapMotion( new Vec2I( parentXval, parentYval + 1 ), unitSize ) || !IsFreeInMapMotion( new Vec2I( parentXval - 1, parentYval ), unitSize ) ) corner = 1; } } else if( a == parentXval + 1 ) { if( b == parentYval - 1 ) { if( !IsFreeInMapMotion( new Vec2I( parentXval, parentYval - 1 ), unitSize ) || !IsFreeInMapMotion( new Vec2I( parentXval + 1, parentYval ), unitSize ) ) corner = 1; } else if( b == parentYval + 1 ) { if( !IsFreeInMapMotion( new Vec2I( parentXval + 1, parentYval ), unitSize ) || !IsFreeInMapMotion( new Vec2I( parentXval, parentYval + 1 ), unitSize ) ) corner = 1; } } if( corner == walkable ) { // If not already on the open list, add it to the open list. if( whichList[ a, b ] != onOpenList ) { //check for max fields fieldsCheckedCount++; if( fieldsCheckedCount == maxFieldsToCheck ) { goto notFound; } //visualize if( visualizeForDebugging ) { Vec2 startPoint2 = mapMotionPosition + new Vec2( (float)a + .5f, (float)b + .5f ) * GridCellSize; Vec3 startPoint = new Vec3( startPoint2.X, startPoint2.Y, GetMotionMapHeight( startPoint2 ) ); Vec2 endPoint2 = mapMotionPosition + new Vec2( (float)parentXval + .5f, (float)parentYval + .5f ) * GridCellSize; Vec3 endPoint = new Vec3( endPoint2.X, endPoint2.Y, GetMotionMapHeight( endPoint2 ) ); Camera camera = RendererWorld.Instance.DefaultCamera; camera.DebugGeometry.Color = new ColorValue( 1, 1, 1, .5f ); camera.DebugGeometry.AddArrow( startPoint + new Vec3( 0, 0, .1f ), endPoint + new Vec3( 0, 0, .1f ) ); } //Create a new open list item in the binary heap. newOpenListItemID = newOpenListItemID + 1; //each new item has a unique ID # m = numberOfOpenListItems + 1; openList[ m ] = newOpenListItemID;//place the new open list item (actually, its ID#) at the bottom of the heap openX[ newOpenListItemID ] = a; openY[ newOpenListItemID ] = b;//record the x and y coordinates of the new item //Figure out its G cost if( Math.Abs( a - parentXval ) == 1 && Math.Abs( b - parentYval ) == 1 ) addedGCost = 14;//cost of going to diagonal squares else addedGCost = 10;//cost of going to non-diagonal squares Gcost[ a, b ] = Gcost[ parentXval, parentYval ] + addedGCost; //Figure out its H and F costs and parent Hcost[ openList[ m ] ] = 10 * ( Math.Abs( a - targetX ) + Math.Abs( b - targetY ) ); Fcost[ openList[ m ] ] = Gcost[ a, b ] + Hcost[ openList[ m ] ]; parentX[ a, b ] = parentXval; parentY[ a, b ] = parentYval; //Move the new open list item to the proper place in the binary heap. //Starting at the bottom, successively compare to parent items, //swapping as needed until the item finds its place in the heap //or bubbles all the way to the top (if it has the lowest F cost). while( m != 1 ) //While item hasn't bubbled to the top (m=1) { //Check if child's F cost is < parent's F cost. If so, swap them. if( Fcost[ openList[ m ] ] <= Fcost[ openList[ m / 2 ] ] ) { temp = openList[ m / 2 ]; openList[ m / 2 ] = openList[ m ]; openList[ m ] = temp; m = m / 2; } else break; } numberOfOpenListItems = numberOfOpenListItems + 1;//add one to the number of items in the heap //Change whichList to show that the new item is on the open list. whichList[ a, b ] = onOpenList; } //8.If adjacent cell is already on the open list, check to see if this // path to that cell from the starting location is a better one. // If so, change the parent of the cell and its G and F costs. else //If whichList(a,b) = onOpenList { //Figure out the G cost of this possible new path if( Math.Abs( a - parentXval ) == 1 && Math.Abs( b - parentYval ) == 1 ) addedGCost = 14;//cost of going to diagonal tiles else addedGCost = 10;//cost of going to non-diagonal tiles tempGcost = Gcost[ parentXval, parentYval ] + addedGCost; //If this path is shorter (G cost is lower) then change //the parent cell, G cost and F cost. if( tempGcost < Gcost[ a, b ] ) //if G cost is less, { parentX[ a, b ] = parentXval; //change the square's parent parentY[ a, b ] = parentYval; Gcost[ a, b ] = tempGcost;//change the G cost //Because changing the G cost also changes the F cost, if //the item is on the open list we need to change the item's //recorded F cost and its position on the open list to make //sure that we maintain a properly ordered open list. for( int x = 1; x <= numberOfOpenListItems; x++ ) //look for the item in the heap { if( openX[ openList[ x ] ] == a && openY[ openList[ x ] ] == b ) //item found { Fcost[ openList[ x ] ] = Gcost[ a, b ] + Hcost[ openList[ x ] ];//change the F cost //See if changing the F score bubbles the item up from it's current location in the heap m = x; while( m != 1 ) //While item hasn't bubbled to the top (m=1) { //Check if child is < parent. If so, swap them. if( Fcost[ openList[ m ] ] < Fcost[ openList[ m / 2 ] ] ) { temp = openList[ m / 2 ]; openList[ m / 2 ] = openList[ m ]; openList[ m ] = temp; m = m / 2; } else break; } break; //exit for x = loop } //If openX(openList(x)) = a } //For x = 1 To numberOfOpenListItems }//If tempGcost < Gcost(a,b) }//else If whichList(a,b) = onOpenList }//If not cutting a corner }//If not a wall/obstacle square. } }//If not already on the closed list }//If not off the map }//for (a = parentXval-1; a <= parentXval+1; a++){ }//for (b = parentYval-1; b <= parentYval+1; b++){ }//if (numberOfOpenListItems != 0) //9.If open list is empty then there is no path. else { path = nonexistent; break; } //If target is added to open list then path has been found. if( whichList[ targetX, targetY ] == onOpenList ) { path = found; break; } } while( true );//Do until path is found or deemed nonexistent //10.Save the path if it exists. if( path == found ) { //a.Working backwards from the target to the starting location by checking // each cell's parent, figure out the length of the path. pathX = targetX; pathY = targetY; do { //Look up the parent of the current cell. tempx = parentX[ pathX, pathY ]; pathY = parentY[ pathX, pathY ]; pathX = tempx; //Figure out the path length pathLength = pathLength + 1; } while( pathX != startX || pathY != startY ); //construct patharray { int pos = pathLength - 1; pathX = targetX; pathY = targetY; do { /*patharray[pos]*/ pathArray[ pos + 1 ] = new Vec2I( pathX, pathY ); pos--; tempx = parentX[ pathX, pathY ]; pathY = parentY[ pathX, pathY ]; pathX = tempx; } while( pathX != startX || pathY != startY ); } return pathLength; } notFound: return 0; }
void InitializeMotionMap() { initialized = true; if( gridCellSize != 0 ) gridCellSizeInv = 1.0f / gridCellSize; Rect bounds = gridBounds; if( bounds == Rect.Zero ) bounds = new Rect( Vec2.Zero, new Vec2( 10, 10 ) ); Vec2 v = bounds.GetSize() * gridCellSizeInv; mapSize = new Vec2I( (int)v.X, (int)v.Y ); mapMotionPosition = new Vec2( bounds.Minimum.X, bounds.Minimum.Y ); mapMaxIndex = mapSize - new Vec2I( mapSize.X > 0 ? 1 : 0, mapSize.Y > 0 ? 1 : 0 ); openList = new int[ mapSize.X * mapSize.Y + 2 ]; whichList = new int[ mapSize.X, mapSize.Y ]; openX = new int[ mapSize.X * mapSize.Y + 2 ]; openY = new int[ mapSize.X * mapSize.Y + 2 ]; parentX = new int[ mapSize.X, mapSize.Y ]; parentY = new int[ mapSize.X, mapSize.Y ]; Fcost = new int[ mapSize.X * mapSize.Y + 2 ]; Gcost = new int[ mapSize.X, mapSize.Y ]; Hcost = new int[ mapSize.X * mapSize.Y + 2 ]; pathArray = new Vec2I[ mapSize.X * mapSize.Y ]; renderVertices.Clear(); renderFreeIndices.Clear(); renderBusyIndices.Clear(); mapMotionRectangles.Clear(); mapMotion = new byte[ mapSize.X, mapSize.Y ]; FillMotionMap(); }
Vec2I GetNearestFreeMotionMap( Vec2I pos, int unitSize ) { if( IsFreeInMapMotion( pos, unitSize ) ) return pos; for( int r = 1; ; r++ ) { for( int n = 0; n <= r; n++ ) { Vec2I p; p = pos + new Vec2I( n, -r ); if( IsFreeInMapMotion( p, unitSize ) ) return p; p = pos + new Vec2I( n, r ); if( IsFreeInMapMotion( p, unitSize ) ) return p; p = pos + new Vec2I( -n, -r ); if( IsFreeInMapMotion( p, unitSize ) ) return p; p = pos + new Vec2I( -n, r ); if( IsFreeInMapMotion( p, unitSize ) ) return p; p = pos + new Vec2I( -r, n ); if( IsFreeInMapMotion( p, unitSize ) ) return p; p = pos + new Vec2I( r, n ); if( IsFreeInMapMotion( p, unitSize ) ) return p; p = pos + new Vec2I( -r, -n ); if( IsFreeInMapMotion( p, unitSize ) ) return p; p = pos + new Vec2I( -r, n ); if( IsFreeInMapMotion( p, unitSize ) ) return p; } } }
Vec2I GetMapMotionPosition( Vec2 pos ) { Vec2 pf = ( pos - mapMotionPosition ) * gridCellSizeInv; Vec2I p = new Vec2I( (int)pf.X, (int)pf.Y ); p.Clamp( new Vec2I( 0, 0 ), mapMaxIndex ); return p; }
protected override void OnCreateTexture( string definitionName, ref Vec2I size, ref PixelFormat format ) { base.OnCreateTexture( definitionName, ref size, ref format ); //change format of rt_scene and rt_final textures if HDR compositor is enabled. if( definitionName == "rt_scene" || definitionName == "rt_final" ) { CompositorInstance hdrInstance = Owner.GetCompositorInstance( "HDR" ); if( hdrInstance != null && hdrInstance.Enabled ) format = PixelFormat.Float16RGB; else format = PixelFormat.R8G8B8; } if( definitionName == "rt_depth" || definitionName == "rt_occlusion" ) { float divisor = downsampling; if( divisor < 1 ) divisor = 1; Vec2 sizeFloat = Owner.DimensionsInPixels.Size.ToVec2() / divisor; size = new Vec2I( (int)sizeFloat.X, (int)sizeFloat.Y ); if( size.X < 1 ) size.X = 1; if( size.Y < 1 ) size.Y = 1; downscaleTextureSize = size; } }
RectI GetMapMotionRectangle( Rect rect ) { Vec2 minf = ( rect.Minimum - mapMotionPosition ) * gridCellSizeInv; Vec2 maxf = ( rect.Maximum - mapMotionPosition ) * gridCellSizeInv; Vec2I min = new Vec2I( (int)minf.X, (int)minf.Y ); Vec2I max = new Vec2I( (int)maxf.X, (int)maxf.Y ); min.Clamp( new Vec2I( 0, 0 ), mapMaxIndex ); max.Clamp( new Vec2I( 0, 0 ), mapMaxIndex ); return new RectI( min, max ); }
static void CalculateDownScale4x4SampleOffsets( Vec2I sourceTextureSize, Vec2[] sampleOffsets ) { // Sample from the 16 surrounding points. Since the center point will be in // the exact center of 16 texels, a 0.5f offset is needed to specify a texel // center. Vec2 invSize = 1.0f / sourceTextureSize.ToVec2(); int index = 0; for( int y = 0; y < 4; y++ ) { for( int x = 0; x < 4; x++ ) { sampleOffsets[ index ] = new Vec2( ( (float)x - 1.5f ), ( (float)y - 1.5f ) ) * invSize; index++; } } }
bool IsFreeInMapMotion( Vec2I pos, int unitSize ) { if( unitSize != 1 ) { if( pos.X + unitSize - 1 >= mapSize.X ) return false; if( pos.Y + unitSize - 1 >= mapSize.Y ) return false; for( int y = 0; y < unitSize; y++ ) for( int x = 0; x < unitSize; x++ ) if( !IsFreeInMapMotion( pos + new Vec2I( x, y ) ) ) return false; return true; } else return IsFreeInMapMotion( pos ); }
bool IsFreeInMapMotion( Vec2I pos ) { return mapMotion[ pos.X, pos.Y ] == 0; }
private void CreateViewport() { int index = instance.views.IndexOf(this); DestroyViewport(); Vec2I textureSize = GetNeededTextureSize(); string textureName = TextureManager.Instance.GetUniqueName( string.Format("MultiViewRendering{0}", index)); PixelFormat format = PixelFormat.R8G8B8; int fsaa; if (!int.TryParse(RendererWorld.InitializationOptions.FullSceneAntialiasing, out fsaa)) fsaa = 0; texture = TextureManager.Instance.Create(textureName, Texture.Type.Type2D, textureSize, 1, 0, format, Texture.Usage.RenderTarget, false, fsaa); if (texture == null) { Log.Fatal("MultiViewRenderingManager: Unable to create texture."); return; } RenderTarget renderTarget = texture.GetBuffer().GetRenderTarget(); renderTarget.AutoUpdate = true; renderTarget.AllowAdditionalMRTs = true; //create camera camera = SceneManager.Instance.CreateCamera( SceneManager.Instance.GetUniqueCameraName(string.Format("MultiViewRendering{0}", index))); camera.Purpose = Camera.Purposes.MainCamera; //add viewport viewport = renderTarget.AddViewport(camera, 0); viewport.ShadowsEnabled = true; //Create compositor for HDR render technique bool hdrCompositor = RendererWorld.Instance.DefaultViewport.GetCompositorInstance("HDR") != null; if (hdrCompositor) { viewport.AddCompositor("HDR"); viewport.SetCompositorEnabled("HDR", true); } //FXAA antialiasing post effect bool fxaaCompositor = RendererWorld.Instance.DefaultViewport.GetCompositorInstance("FXAA") != null; if (fxaaCompositor) { viewport.AddCompositor("FXAA"); viewport.SetCompositorEnabled("FXAA", true); } //add listener renderTargetListener = new ViewRenderTargetListener(this); renderTarget.AddListener(renderTargetListener); initializedTextureSize = textureSize; }
public void ServerOrSingle_SetIndex( Vec2I index ) { this.index = index; //send Index to clients if( EntitySystemWorld.Instance.IsServer() ) Server_SendIndexToClients( EntitySystemWorld.Instance.RemoteEntityWorlds ); }
protected override void OnCreateTexture( string definitionName, ref Vec2I size, ref PixelFormat format ) { base.OnCreateTexture( definitionName, ref size, ref format ); if( definitionName == "rt_scattering" || definitionName == "rt_blur" ) { float divisor = 9.0f - resolution; if( divisor <= 1 ) divisor = 1; Vec2 sizeFloat = Owner.DimensionsInPixels.Size.ToVec2() / divisor; size = new Vec2I( (int)sizeFloat.X, (int)sizeFloat.Y ); } }
private void MainForm_FormClosing( object sender, FormClosingEventArgs e ) { DestroyWorkAreaControl(); showMaximized = WindowState != FormWindowState.Normal; startWindowSize = new Vec2I( Size.Width, Size.Height ); if( !forceCloseForm ) { string configFile = VirtualFileSystem.GetRealPathByVirtual( dockingConfigFileName ); if( !Directory.Exists( Path.GetDirectoryName( configFile ) ) ) Directory.CreateDirectory( Path.GetDirectoryName( configFile ) ); dockPanel.SaveAsXml( configFile ); } instance = null; }
Vec2I GetDemandTextureSize() { double dpiFactor = GetDPIFactor(); Vec2I size = new Vec2I( (int)( ActualWidth / dpiFactor + .999 ), (int)( ActualHeight / dpiFactor + .999 ) ); return size; }
protected override void OnCreateTexture( string definitionName, ref Vec2I size, ref PixelFormat format ) { base.OnCreateTexture( definitionName, ref size, ref format ); if( definitionName == "rt_downscale" || definitionName == "rt_blurHorizontal" || definitionName == "rt_blurVertical" ) { float divisor = 8.0f - blurTextureResolution; if( divisor <= 1 ) divisor = 1; Vec2 sizeFloat = Owner.DimensionsInPixels.Size.ToVec2() / divisor; size = new Vec2I( (int)sizeFloat.X, (int)sizeFloat.Y ); if( size.X < 1 ) size.X = 1; if( size.Y < 1 ) size.Y = 1; downscaleTextureSize = size; } }