protected override void Init(MyObjectBuilder_DefinitionBase builder) { base.Init(builder); var materialBuilder = builder as MyObjectBuilder_TransparentMaterialDefinition; MyDebug.AssertDebug(materialBuilder != null, "Initializing transparent material definition using wrong object builder."); Texture = materialBuilder.Texture; TextureType = materialBuilder.TextureType; CanBeAffectedByLights = materialBuilder.CanBeAffectedByOtherLights; AlphaMistingEnable = materialBuilder.AlphaMistingEnable; IgnoreDepth = materialBuilder.IgnoreDepth; NeedSort = materialBuilder.NeedSort; UseAtlas = materialBuilder.UseAtlas; AlphaMistingStart = materialBuilder.AlphaMistingStart; AlphaMistingEnd = materialBuilder.AlphaMistingEnd; SoftParticleDistanceScale = materialBuilder.SoftParticleDistanceScale; Emissivity = materialBuilder.Emissivity; AlphaSaturation = materialBuilder.AlphaSaturation; Reflection = materialBuilder.Reflection; Reflectivity = materialBuilder.Reflectivity; Color = materialBuilder.Color; AlphaCutout = materialBuilder.AlphaCutout; TargetSize = materialBuilder.TargetSize; }
internal void Clear() { m_deviceContext.ClearState(); m_inputLayout = null; m_primitiveTopology = PrimitiveTopology.Undefined; m_indexBufferRef = null; m_indexBufferFormat = 0; m_indexBufferOffset = 0; for (int i = 0; i < m_vertexBuffers.Length; i++) m_vertexBuffers[i] = null; for (int i = 0; i < m_vertexBuffersStrides.Length; i++) m_vertexBuffersStrides[i] = 0; m_blendState = null; m_stencilRef = 0; m_depthStencilState = null; m_rtvsCount = 0; for (int i = 0; i < m_rtvs.Length; i++) m_rtvs[i] = null; m_dsv = null; m_rasterizerState = null; m_scissorLeftTop = new Vector2I(-1, -1); m_scissorRightBottom = new Vector2I(-1, -1); m_viewport = default(RawViewportF); m_targetBuffer = null; m_targetOffsets = 0; m_statistics.ClearStates++; }
/// <summary> /// Serialize a chunk. /// </summary> /// <param name="chunk">The chunk to serialize.</param> /// <param name="chunkIndex">The chunk index.</param> public void SerializeChunk(Chunk chunk, Vector2I chunkIndex) { // NOTE: This should occur in a seperate thread, since terrain serialization isn't high priority. // However, care should be taken to consider the situation when a terrain is being serialized in another thread // and then a new deserialization request comes in for that chunk. In this case the deserialization thread // should block }
public TexturedExtensibleRectangle(IContext context, Vector2I size, Texture texture, int fixedBorderRadius) { DeviceContext = context.DirectX.DeviceContext; _shader = context.Shaders.Get<TextureShader>(); _texture = texture; _fixedBorderRadius = fixedBorderRadius; const int vertexCount = 16; _vertices = new VertexDefinition.PositionTexture[vertexCount]; VertexBuffer = Buffer.Create(context.DirectX.Device, _vertices, new BufferDescription { Usage = ResourceUsage.Dynamic, SizeInBytes = Utilities.SizeOf<VertexDefinition.PositionTexture>() * vertexCount, BindFlags = BindFlags.VertexBuffer, CpuAccessFlags = CpuAccessFlags.Write, OptionFlags = ResourceOptionFlags.None, StructureByteStride = 0 }); IndexCount = 54; uint[] indices = new uint[IndexCount]; for(uint i=0; i< 3; i++) for (uint j = 0; j < 3; j++) { indices[(i * 3 + j) * 6] = (i + 1) * 4 + j + 1; indices[(i * 3 + j) * 6 + 1] = i * 4 + j + 1; indices[(i * 3 + j) * 6 + 2] = i * 4 + j; indices[(i * 3 + j) * 6 + 3] = (i + 1) * 4 + j; indices[(i * 3 + j) * 6 + 4] = (i + 1) * 4 + j + 1; indices[(i * 3 + j) * 6 + 5] = i * 4 + j; } IndexBuffer = Buffer.Create(context.DirectX.Device, BindFlags.IndexBuffer, indices); Size = size; }
public Bitmap(Device device, ShaderResourceView texture, Vector2I screenSize, Vector2I size, float depth = 0.0f) { Texture = texture; ScreenSize = screenSize; Size = size; _changed = true; Depth = depth; VertexCount = 4; IndexCount = 6; _vertices = new TranslateShader.Vertex[VertexCount]; UInt32[] indices = {0, 1, 2, 0, 3, 1}; VertexBuffer = Buffer.Create(device, _vertices, new BufferDescription { Usage = ResourceUsage.Dynamic, SizeInBytes = Utilities.SizeOf<TranslateShader.Vertex>() * VertexCount, BindFlags = BindFlags.VertexBuffer, CpuAccessFlags = CpuAccessFlags.Write, OptionFlags = ResourceOptionFlags.None, StructureByteStride = 0 }); IndexBuffer = Buffer.Create(device, BindFlags.IndexBuffer, indices); }
public bool Contains(Vector2I point) { bool b1 = Sign(point, Points[0], Points[1]) < 0.0f; bool b2 = Sign(point, Points[1], Points[2]) < 0.0f; bool b3 = Sign(point, Points[2], Points[0]) < 0.0f; return ((b1 == b2) && (b2 == b3)); }
public TilesetImage(string imagePath, Vector2I tileSize, Vector2I tileMargin, Vector2I tileBorder) { ImagePath = imagePath; TileSize = tileSize; TileMargin = tileMargin; TileBorder = tileBorder; }
public void Init( string name, int width, int height, Format resourceFormat, Format srvFormat, BindFlags bindFlags, int samplesCount, int samplesQuality, ResourceOptionFlags roFlags, ResourceUsage ru, int mipmapLevels, CpuAccessFlags cpuAccessFlags) { m_name = name; m_size = new Vector2I(width, height); m_resourceFormat = resourceFormat; m_srvFormat = srvFormat; m_bindFlags = bindFlags; m_samplesCount = samplesCount; m_samplesQuality = samplesQuality; m_roFlags = roFlags; m_resourceUsage = ru; m_mipmapLevels = mipmapLevels; m_cpuAccessFlags = cpuAccessFlags; }
public Rectangle(Renderer renderer, Vector2I screenSize, Vector2I position, Vector2I size, Vector4 color, float depth = 0.0f) { _shader = renderer.ColorShader; Position = position; ScreenSize = screenSize; Size = size; _color = color; _changed = true; Depth = depth; int vertexCount = 4; _indexCount = 6; _vertices = new VertexDefinition.PositionColor[vertexCount]; UInt32[] indices = { 0, 1, 2, 0, 3, 1 }; _vertexBuffer = Buffer.Create(renderer.DirectX.Device, _vertices, new BufferDescription { Usage = ResourceUsage.Dynamic, SizeInBytes = Utilities.SizeOf<VertexDefinition.PositionColor>() * vertexCount, BindFlags = BindFlags.VertexBuffer, CpuAccessFlags = CpuAccessFlags.Write, OptionFlags = ResourceOptionFlags.None, StructureByteStride = 0 }); _indexBuffer = Buffer.Create(renderer.DirectX.Device, BindFlags.IndexBuffer, indices); }
internal void Init(string name, Texture2DDescription desc, Vector2I size, int bytes) { m_name = name; m_size = size; m_desc = desc; m_bytes = bytes; }
public static IEnumerable<Vector2I> ChebyshevNeighborhood(Vector2I position, int range = 1) { for (int i = -range; i <= range; ++i) for (int j = -range; j <= range; ++j) if (!(i == 0 && j == 0)) // omit center position yield return new Vector2I(position.X + i, position.Y + j); }
public Triangle(Vector2I a, Vector2I b, Vector2I c) { Points[0] = a; Points[1] = b; Points[2] = c; Id = AutoIncrement++; }
public DuplicatedCubeGrid(Vector2I dimensions) { Dimensions = dimensions; this[VboPosition.Vertices] = StaticVboFactory.GetDuplicatedCubeGridVertices(dimensions); EnableAttrib(VboPosition.Vertices); }
public RenderTexture(Device device, Vector2I screenSize) { var textureDesc = new Texture2DDescription() { Width = screenSize.X, Height = screenSize.Y, MipLevels = 1, ArraySize = 1, Format = Format.R32G32B32A32_Float, SampleDescription = new SampleDescription(1, 0), Usage = ResourceUsage.Default, BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource, CpuAccessFlags = CpuAccessFlags.None, OptionFlags = ResourceOptionFlags.None }; _renderTargetTexture = new Texture2D(device, textureDesc); _renderTargetView = new RenderTargetView(device, _renderTargetTexture, new RenderTargetViewDescription { Format = textureDesc.Format, Dimension = RenderTargetViewDimension.Texture2D, Texture2D = {MipSlice = 0}, }); // Create the render target view. ShaderResourceView = new ShaderResourceView(device, _renderTargetTexture, new ShaderResourceViewDescription { Format = textureDesc.Format, Dimension = ShaderResourceViewDimension.Texture2D, Texture2D = { MipLevels = 1, MostDetailedMip = 0 }, }); }
/// <summary> /// Generate a chunk and return it. The terrain object remains unmodified. /// </summary> /// <param name="terrain">The terrain.</param> /// <param name="chunkIndex">The chunk index.</param> /// <returns>The chunk.</returns> public Chunk GenerateChunk(Terrain terrain, Vector2I chunkIndex) { Chunk chunk = new Chunk(); // Calculate the position of the chunk in world coordinates var chunkPos = new Vector2I(chunkIndex.X * Chunk.SizeX, chunkIndex.Y * Chunk.SizeY); // Get the surface heights for this chunk int[] surfaceHeights = this.GenerateSurfaceHeights(chunkPos); // For now, fill the terrain with mud under the surface for (int x = 0; x < Chunk.SizeX; x++) { int surfaceHeight = surfaceHeights[x]; if (surfaceHeight > 0) { for (int y = 0; y < surfaceHeight; y++) { chunk[x, y] = new Block(BlockType.Dirt); } } } return chunk; }
public BasicFbo(RenderTargetManager textureManager, Vector2I size) { AttachTexture(FramebufferAttachment.DepthAttachment, textureManager.Get<RenderTargetDepthTexture>(size)); // Must be first due to error checking AttachTexture(FramebufferAttachment.ColorAttachment0, textureManager.Get<RenderTargetColorTexture>(size)); FramebufferErrorCode err = GL.CheckFramebufferStatus(FramebufferTarget.Framebuffer); Debug.Assert(err == FramebufferErrorCode.FramebufferComplete, "Framebuffer error: " + err); }
public bool InBounds(Vector2I position) { return IsVisible() && position.X >= Position.X && position.X < Position.X + Size.X && position.Y >= Position.Y && position.Y < Position.Y + Size.Y; }
public override bool InBoundsAndActive(Vector2I position) { if (Overlay || !IsVisible()) return false; return position.X >= Position.X && position.X < Position.X + Size.X && position.Y >= Position.Y && position.Y < Position.Y + Size.Y; }
public override void Close() { Id = 0; ScreenData = null; Resolution = new Vector2I(); base.Close(); }
public TileSetTileContentSource(BitmapTileSet tileSet, int tileIndex, Color tint, float rotate, Vector2I translate) { _tileSet = tileSet; _tileIndex = tileIndex; _tint = tint; _translate = translate; _rotate = rotate; }
public Text Create(string fontName, int fontSize, string content, Vector2I size, Color color, HorizontalAlignment horizontalAligment, VerticalAlignment verticalAlignment, Padding padding) { string fontKey = fontName + "-" + size; if (!_fontDictionary.ContainsKey(fontKey)) _fontDictionary.Add(fontKey, new Font(_context, fontName, fontSize)); return new Text(_context, content, _fontDictionary[fontKey], size, color, horizontalAligment, verticalAlignment, padding); }
Vector2I GetThreadsPerThreadGroup(Vector2I textureSizeInPixels) { int pixelsPerThreadGroupX = textureSizeInPixels.X / m_threadGroupCountX; int pixelsPerThreadGroupY = textureSizeInPixels.Y/ m_threadGroupCountY; return new Vector2I( (pixelsPerThreadGroupX + m_pixelsPerThreadX - 1) / m_pixelsPerThreadX, (pixelsPerThreadGroupY + m_pixelsPerThreadY - 1) / m_pixelsPerThreadY); }
public override void Close() { Id = 0; PreallocatedBuffer = null; Resolution = new Vector2I(); base.Close(); }
protected RenderTargetTexture(Vector2I size) : base(size.X, size.Y) // Use default pixel format) { Init2D(); SetParameters( TextureMinFilter.Nearest, TextureMagFilter.Nearest, TextureWrapMode.ClampToEdge); }
public Edge(Triangle onlyOne, Vector2I a, Vector2I b) { if(!(onlyOne.Points.Contains(a) && onlyOne.Points.Contains(b))) throw new InvalidOperationException("Points do not belong to the triangle."); Points[0] = a; Points[1] = b; Triangles[0] = null; Triangles[1] = onlyOne; }
protected RenderTargetTexture(Vector2I size, PixelFormat pixelFormat, PixelInternalFormat internalFormat) : base(size.X, size.Y) { Init2D(pixelFormat, internalFormat); SetParameters( TextureMinFilter.Nearest, TextureMagFilter.Nearest, TextureWrapMode.ClampToEdge); }
public void SetSetting(string mapName, string warpPointName, Vector2I tileDimension = null) { SetSetting( mapName, warpPointName, tileDimension == null ? null : (new IntRect( 0, 0, tileDimension.X * GameData.TILE_SIZE, tileDimension.Y * GameData.TILE_SIZE))); }
public void TestRectangleICenter() { // ARRANGE. var rectangle = new RectangleI(new Vector2I(2, 3), new Vector2I(6, 8)); var center = new Vector2I(5, 7); // ASSERT. Assert.AreEqual(center, rectangle.Center); }
private bool ContainsBlock(Vector2I blockPos) { foreach (LevelBlock levelBlock in levelBlockList) { if(levelBlock.xPos == blockPos.x && levelBlock.yPos == blockPos.y) return true; } return false; }
public CombatCell(Vector2I position) { Position = position; ColorEffects = new Dictionary<CellSelectionType, CellShape>(); foreach (CellSelectionType type in System.Enum.GetValues(typeof(CellSelectionType))) ColorEffects.Add(type, null); Combatants = new List<BaseCombatant>(); }
/// <summary>Attempts to find a curve under the provided coordinates.</summary> /// <param name="pixelCoords">Coordinates relative to this GUI element in pixels.</param> /// <returns>Index of the curve, or -1 if none found.</returns> public int FindCurve(Vector2I pixelCoords) { return(Internal_findCurve(mCachedPtr, ref pixelCoords)); }
/// <summary> /// Uses the assigned FPS, range and physical size to calculate the frame that is under the provided coordinates. /// </summary> /// <param name="pixelCoords">Coordinates relative to this GUI element.</param> /// <returns>Frame that was clicked on, or -1 if the coordinates are outside of valid bounds.</returns> public uint GetFrame(Vector2I pixelCoords) { return(Internal_getFrame(mCachedPtr, ref pixelCoords)); }
void SetInfluence(Vector2I pos, float value) { _influenceMap.SetInfluence(pos, value); }
internal static void PreparePointLights() { var activePointlights = 0; MyLights.Update(); BoundingFrustumD viewFrustumClippedD = MyRender11.Environment.ViewFrustumClippedD; if (MyStereoRender.Enable) { if (MyStereoRender.RenderRegion == MyStereoRegion.LEFT) { viewFrustumClippedD = MyStereoRender.EnvMatricesLeftEye.ViewFrustumClippedD; } else if (MyStereoRender.RenderRegion == MyStereoRegion.RIGHT) { viewFrustumClippedD = MyStereoRender.EnvMatricesRightEye.ViewFrustumClippedD; } } MyLights.PointlightsBvh.OverlapAllFrustum(ref viewFrustumClippedD, VisiblePointlights); bool visiblePointlights = VisiblePointlights.Count != 0; if (!visiblePointlights && !m_lastFrameVisiblePointlights) { return; } m_lastFrameVisiblePointlights = visiblePointlights; if (VisiblePointlights.Count > MyRender11Constants.MAX_POINT_LIGHTS) { VisiblePointlights.Sort((x, y) => x.ViewerDistanceSquared.CompareTo(y.ViewerDistanceSquared)); while (VisiblePointlights.Count > MyRender11Constants.MAX_POINT_LIGHTS) { VisiblePointlights.RemoveAtFast(VisiblePointlights.Count - 1); } } foreach (var light in VisiblePointlights) { MyLights.WritePointlightConstants(light, ref m_pointlightsCullBuffer[activePointlights]); activePointlights++; Debug.Assert(activePointlights <= MyRender11Constants.MAX_POINT_LIGHTS); } for (int lightIndex = activePointlights; lightIndex < MyRender11Constants.MAX_POINT_LIGHTS; ++lightIndex) { MyLights.WritePointlightConstants(LightId.NULL, ref m_pointlightsCullBuffer[lightIndex]); } var mapping = MyMapping.MapDiscard(MyCommon.GetObjectCB(16)); mapping.WriteAndPosition(ref activePointlights); mapping.Unmap(); mapping = MyMapping.MapDiscard(m_pointlightCullHwBuffer.Buffer); mapping.WriteAndPosition(m_pointlightsCullBuffer, 0, MyRender11Constants.MAX_POINT_LIGHTS); mapping.Unmap(); if (!MyStereoRender.Enable) { RC.CSSetCB(0, MyCommon.FrameConstants); } else { MyStereoRender.CSBindRawCB_FrameConstants(RC); } RC.CSSetCB(1, MyCommon.GetObjectCB(16)); //RC.BindUAV(0, MyScreenDependants.m_test); RC.BindUAV(0, MyScreenDependants.m_tileIndices); RC.BindGBufferForRead(0, MyGBuffer.Main); RC.CSBindRawSRV(MyCommon.POINTLIGHT_SLOT, m_pointlightCullHwBuffer); RC.SetCS(m_preparePointLights); Vector2I tiles = new Vector2I(MyScreenDependants.TilesX, MyScreenDependants.TilesY); if (MyStereoRender.Enable && MyStereoRender.RenderRegion != MyStereoRegion.FULLSCREEN) { tiles.X /= 2; } RC.DeviceContext.Dispatch(tiles.X, tiles.Y, 1); RC.SetCS(null); }
/// <summary> /// Renders all tilable objects in view. /// </summary> internal void Render() { Vector2I min, max; var cc = CameraController.Instance; if (cc != null && !GameUtil.IsCapturingTimeLapse()) { // Use camera area var visibleArea = cc.VisibleArea.CurrentArea; min = visibleArea.Min; max = visibleArea.Max; min.x /= CHUNK_SIZE; min.y /= CHUNK_SIZE; // Round UP! max.x = (max.x + CHUNK_SIZE - 1) / CHUNK_SIZE; max.y = (max.y + CHUNK_SIZE - 1) / CHUNK_SIZE; } else { min = Vector2I.zero; max = new Vector2I(Grid.WidthInCells / CHUNK_SIZE, Grid.HeightInCells / CHUNK_SIZE); } int minX = min.x, maxX = max.x, minY = min.y, maxY = max.y; int lMinX = lastVisible.x, lMaxX = lastVisible.width, lMinY = lastVisible.y, lMaxY = lastVisible.height; // Turn off hidden chunks for (int x = lMinX; x < lMaxX; x++) { for (int y = lMinY; y < lMaxY; y++) { if (y < minY || y >= maxY || x < minX || x >= maxX) { deactivated.Add(new Vector2I(x, y)); } } } // Store the last visible volume lastVisible.x = minX; lastVisible.y = minY; lastVisible.width = maxX; lastVisible.height = maxY; int n = deactivated.Count; foreach (var pair in renderInfo) { var info = pair.Value; for (int i = 0; i < n; i++) { var coords = deactivated[i]; info.Deactivate(coords.x, coords.y); } for (int x = minX; x < maxX; x++) { for (int y = minY; y < maxY; y++) { info.Rebuild(this, x, y); } } } deactivated.Clear(); forceRebuild = false; }
public FireplaceBurning(Vector2I position, string textureName) : base(position, textureName) { Init(); }
/// <summary> /// Inserts a string starting on a given line at a given position. /// </summary> public override void Insert(RichStringMembers text, Vector2I start) => Insert(new RichStringMembers[] { text }, start);
private static extern bool Internal_findTangent(IntPtr thisPtr, ref Vector2I pixelCoords, out TangentRef tangent);
/// <summary>Converts pixel coordinates into coordinates in curve space.</summary> /// <param name="pixelCoords">Coordinates relative to this GUI element, in pixels.</param> /// <param name="curveCoords"> /// Curve coordinates within the range as specified by setRange(). Only valid when function returns true. /// </param> /// <param name="padding">Determines should coordinates over the area reserved for padding be registered.</param> /// <returns>True if the coordinates are within the curve area, false otherwise.</returns> public bool PixelToCurveSpace(Vector2I pixelCoords, out Vector2 curveCoords, bool padding = false) { return(Internal_pixelToCurveSpace(mCachedPtr, ref pixelCoords, out curveCoords, padding)); }
public KeyToDoor(ITilesetTable tilesetTable, Vector2I position) : base(tilesetTable, position) { }
public KeyToDoor(int tileType, Vector2I position) : base(tileType, position) { }
private static extern uint Internal_getFrame(IntPtr thisPtr, ref Vector2I pixelCoords);
public static Component_Material CreateMaterial(Component materialsGroup, MaterialData data) { //create material var material = materialsGroup.CreateComponent <Component_Material>(enabled: false); material.Name = data.Name; material.ShadingModel = data.ShadingModel; material.TwoSided = data.TwoSided; if (!string.IsNullOrEmpty(data.OpacityTexture)) { material.BlendMode = Component_Material.BlendModeEnum.Masked; } //create shader graph Component_FlowGraph graph; { graph = material.CreateComponent <Component_FlowGraph>(); graph.Name = material.Name + " shader graph"; graph.Specialization = ReferenceUtility.MakeReference <Component_FlowGraphSpecialization>(null, MetadataManager.GetTypeOfNetType(typeof(Component_FlowGraphSpecialization_Shader)).Name + "|Instance"); var node = graph.CreateComponent <Component_FlowGraphNode>(); node.Name = "Node " + material.Name; node.Position = new Vector2I(10, -7); node.ControlledObject = ReferenceUtility.MakeThisReference(node, material); } const int step = 9; Vector2I position = new Vector2I(-20, -data.GetTextureCount() * step / 2); //BaseColor if (!string.IsNullOrEmpty(data.BaseColorTexture)) { var node = graph.CreateComponent <Component_FlowGraphNode>(); node.Name = "Node Texture Sample " + "BaseColor"; node.Position = position; position.Y += step; var sample = node.CreateComponent <Component_ShaderTextureSample>(); sample.Name = ComponentUtility.GetNewObjectUniqueName(sample); sample.Texture = new Reference <Component_Image>(null, data.BaseColorTexture); node.ControlledObject = ReferenceUtility.MakeThisReference(node, sample); material.BaseColor = ReferenceUtility.MakeThisReference(material, sample, "RGBA"); } else if (data.BaseColor.HasValue) { material.BaseColor = data.BaseColor.Value; } //Metallic if (!string.IsNullOrEmpty(data.MetallicTexture)) { var node = graph.CreateComponent <Component_FlowGraphNode>(); node.Name = "Node Texture Sample " + "Metallic"; node.Position = position; position.Y += step; var sample = node.CreateComponent <Component_ShaderTextureSample>(); sample.Name = ComponentUtility.GetNewObjectUniqueName(sample); sample.Texture = new Reference <Component_Image>(null, data.MetallicTexture); node.ControlledObject = ReferenceUtility.MakeThisReference(node, sample); material.Metallic = ReferenceUtility.MakeThisReference(material, sample, "R"); } //Roughness if (!string.IsNullOrEmpty(data.RoughnessTexture)) { var node = graph.CreateComponent <Component_FlowGraphNode>(); node.Name = "Node Texture Sample " + "Roughness"; node.Position = position; position.Y += step; var sample = node.CreateComponent <Component_ShaderTextureSample>(); sample.Name = ComponentUtility.GetNewObjectUniqueName(sample); sample.Texture = new Reference <Component_Image>(null, data.RoughnessTexture); node.ControlledObject = ReferenceUtility.MakeThisReference(node, sample); material.Roughness = ReferenceUtility.MakeThisReference(material, sample, "R"); } //Normal if (!string.IsNullOrEmpty(data.NormalTexture)) { var node = graph.CreateComponent <Component_FlowGraphNode>(); node.Name = "Node Texture Sample " + "Normal"; node.Position = position; position.Y += step; var sample = node.CreateComponent <Component_ShaderTextureSample>(); sample.Name = ComponentUtility.GetNewObjectUniqueName(sample); sample.Texture = new Reference <Component_Image>(null, data.NormalTexture); node.ControlledObject = ReferenceUtility.MakeThisReference(node, sample); material.Normal = ReferenceUtility.MakeThisReference(material, sample, "RGBA"); } //Displacement if (!string.IsNullOrEmpty(data.DisplacementTexture)) { var node = graph.CreateComponent <Component_FlowGraphNode>(); node.Name = "Node Texture Sample " + "Displacement"; node.Position = position; position.Y += step; var sample = node.CreateComponent <Component_ShaderTextureSample>(); sample.Name = ComponentUtility.GetNewObjectUniqueName(sample); sample.Texture = new Reference <Component_Image>(null, data.DisplacementTexture); node.ControlledObject = ReferenceUtility.MakeThisReference(node, sample); material.Displacement = ReferenceUtility.MakeThisReference(material, sample, "R"); } //AmbientOcclusion if (!string.IsNullOrEmpty(data.AmbientOcclusionTexture)) { var node = graph.CreateComponent <Component_FlowGraphNode>(); node.Name = "Node Texture Sample " + "AmbientOcclusion"; node.Position = position; position.Y += step; var sample = node.CreateComponent <Component_ShaderTextureSample>(); sample.Name = ComponentUtility.GetNewObjectUniqueName(sample); sample.Texture = new Reference <Component_Image>(null, data.AmbientOcclusionTexture); node.ControlledObject = ReferenceUtility.MakeThisReference(node, sample); material.AmbientOcclusion = ReferenceUtility.MakeThisReference(material, sample, "R"); } //Emissive if (!string.IsNullOrEmpty(data.EmissiveTexture)) { var node = graph.CreateComponent <Component_FlowGraphNode>(); node.Name = "Node Texture Sample " + "Emissive"; node.Position = position; position.Y += step; var sample = node.CreateComponent <Component_ShaderTextureSample>(); sample.Name = ComponentUtility.GetNewObjectUniqueName(sample); sample.Texture = new Reference <Component_Image>(null, data.EmissiveTexture); node.ControlledObject = ReferenceUtility.MakeThisReference(node, sample); material.Emissive = ReferenceUtility.MakeThisReference(material, sample, "RGBA"); } //Opacity if (!string.IsNullOrEmpty(data.OpacityTexture)) { var node = graph.CreateComponent <Component_FlowGraphNode>(); node.Name = "Node Texture Sample " + "Opacity"; node.Position = position; position.Y += step; var sample = node.CreateComponent <Component_ShaderTextureSample>(); sample.Name = ComponentUtility.GetNewObjectUniqueName(sample); sample.Texture = new Reference <Component_Image>(null, data.OpacityTexture); node.ControlledObject = ReferenceUtility.MakeThisReference(node, sample); material.Opacity = ReferenceUtility.MakeThisReference(material, sample, "R"); } material.Enabled = true; return(material); }
private static extern bool Internal_findKeyFrame(IntPtr thisPtr, ref Vector2I pixelCoords, out KeyframeRef keyframe);
/// <summary> /// Applies glyph formatting to a range of characters. /// </summary> /// <param name="start">Position of the first character being formatted.</param> /// <param name="end">Position of the last character being formatted.</param> public override void SetFormatting(Vector2I start, Vector2I end, GlyphFormat formatting, bool onlyChangeColor) { base.SetFormatting(start, end, formatting, onlyChangeColor); RewrapRange(start.X, end.X); }
private static extern int Internal_findCurve(IntPtr thisPtr, ref Vector2I pixelCoords);
public CachingValueProvider2D(Vector2I offset, Vector2I size, ValueProvider2D <T> source) { this.source = source; this.offset = offset; this.size = size; }
private static extern void Internal_curveToPixelSpace(IntPtr thisPtr, ref Vector2 curveCoords, out Vector2I __output);
public FireplaceBurning(Vector2I position) : base(position) { Init(); }
public BoardPieceMove(int fromX, int fromY, int toX, int toY) { From = new Vector2I(fromX, fromY); To = new Vector2I(toX, toY); }
internal MyDepthStencil(int width, int height, int sampleCount, int sampleQuality) { m_resolution = new Vector2I(width, height); m_samples = new Vector2I(sampleCount, sampleQuality); m_depthSubresource = new MyDepthView(this); m_stencilSubresource = new MyStencilView(this); Texture2DDescription desc = new Texture2DDescription(); desc.Width = width; desc.Height = height; desc.Format = Depth32F ? Format.R32G8X24_Typeless : Format.R24G8_Typeless; desc.ArraySize = 1; desc.MipLevels = 1; desc.BindFlags = BindFlags.DepthStencil | BindFlags.ShaderResource; desc.Usage = ResourceUsage.Default; desc.CpuAccessFlags = 0; desc.SampleDescription.Count = sampleCount; desc.SampleDescription.Quality = sampleQuality; desc.OptionFlags = 0; m_resource = new Texture2D(MyRender11.Device, desc); DepthStencilViewDescription dsvDesc = new DepthStencilViewDescription(); dsvDesc.Format = Depth32F ? Format.D32_Float_S8X24_UInt : Format.D24_UNorm_S8_UInt; if (sampleCount == 1) { dsvDesc.Dimension = DepthStencilViewDimension.Texture2D; dsvDesc.Flags = DepthStencilViewFlags.None; dsvDesc.Texture2D.MipSlice = 0; } else { dsvDesc.Dimension = DepthStencilViewDimension.Texture2DMultisampled; dsvDesc.Flags = DepthStencilViewFlags.None; } m_DSV = new DepthStencilView(MyRender11.Device, m_resource, dsvDesc); if (sampleCount == 1) { dsvDesc.Dimension = DepthStencilViewDimension.Texture2D; dsvDesc.Flags = DepthStencilViewFlags.ReadOnlyDepth; dsvDesc.Texture2D.MipSlice = 0; } else { dsvDesc.Dimension = DepthStencilViewDimension.Texture2DMultisampled; dsvDesc.Flags = DepthStencilViewFlags.ReadOnlyDepth; } m_DSV_roDepth = new DepthStencilView(MyRender11.Device, m_resource, dsvDesc); if (sampleCount == 1) { dsvDesc.Dimension = DepthStencilViewDimension.Texture2D; dsvDesc.Flags = DepthStencilViewFlags.ReadOnlyStencil; dsvDesc.Texture2D.MipSlice = 0; } else { dsvDesc.Dimension = DepthStencilViewDimension.Texture2DMultisampled; dsvDesc.Flags = DepthStencilViewFlags.ReadOnlyStencil; } m_DSV_roStencil = new DepthStencilView(MyRender11.Device, m_resource, dsvDesc); dsvDesc.Flags = DepthStencilViewFlags.ReadOnlyStencil | DepthStencilViewFlags.ReadOnlyDepth; if (sampleCount == 1) { dsvDesc.Dimension = DepthStencilViewDimension.Texture2D; dsvDesc.Texture2D.MipSlice = 0; } else { dsvDesc.Dimension = DepthStencilViewDimension.Texture2DMultisampled; } m_DSV_ro = new DepthStencilView(MyRender11.Device, m_resource, dsvDesc); ShaderResourceViewDescription srvDesc = new ShaderResourceViewDescription(); srvDesc.Format = Depth32F ? Format.R32_Float_X8X24_Typeless : Format.R24_UNorm_X8_Typeless; if (sampleCount == 1) { srvDesc.Dimension = ShaderResourceViewDimension.Texture2D; srvDesc.Texture2D.MipLevels = -1; srvDesc.Texture2D.MostDetailedMip = 0; } else { srvDesc.Dimension = ShaderResourceViewDimension.Texture2DMultisampled; } m_SRV_depth = new ShaderResourceView(MyRender11.Device, m_resource, srvDesc); srvDesc.Format = Depth32F ? Format.X32_Typeless_G8X24_UInt : Format.X24_Typeless_G8_UInt; if (sampleCount == 1) { srvDesc.Dimension = ShaderResourceViewDimension.Texture2D; srvDesc.Texture2D.MipLevels = -1; srvDesc.Texture2D.MostDetailedMip = 0; } else { srvDesc.Dimension = ShaderResourceViewDimension.Texture2DMultisampled; } m_SRV_stencil = new ShaderResourceView(MyRender11.Device, m_resource, srvDesc); }
public LocalArrayValueProvider2D(Vector2I size, T defaultValue) { this.defaultValue = defaultValue; this.size = size; }
////////////////////////////////////////////////////////////////////////// // Vector2I ////////////////////////////////////////////////////////////////////////// /// <summary> /// Convert value to a safely formated string. /// </summary> /// <param name="v">Value to convert.</param> /// <returns>A string without culture variation.</returns> public static string ToString(Vector2I v) { return (v.X.ToString(CultureInfo.InvariantCulture) + listSeparatorAndSpace + v.Y.ToString(CultureInfo.InvariantCulture)); }
public Trap(int tileType, Vector2I position) : base(tileType, position) { }
private static extern bool Internal_pixelToCurveSpace(IntPtr thisPtr, ref Vector2I pixelCoords, out Vector2 curveCoords, bool padding);
private void InitShaders() { if (m_markVS == VertexShaderId.NULL) { m_markVS = MyShaders.CreateVs("shape.hlsl"); } if (m_markPS == PixelShaderId.NULL) { m_markPS = MyShaders.CreatePs("shape.hlsl"); } if (m_inputLayout == InputLayoutId.NULL) { m_inputLayout = MyShaders.CreateIL(m_markVS.BytecodeId, MyVertexLayouts.GetLayout(MyVertexInputComponentType.POSITION3)); } if (m_combinePS == PixelShaderId.NULL) { m_combinePS = MyShaders.CreatePs("CombineShadows.hlsl"); } m_threadGroupCountX = 32; m_threadGroupCountY = 32; Vector2I pixelCount = MyRender11.ViewportResolution; Vector2I threadsPerThreadGroup = GetThreadsPerThreadGroup(pixelCount); int tryIndex = 0; while (threadsPerThreadGroup.X * threadsPerThreadGroup.Y > 1024) // Make sure we do are not over the limit of threads per thread group { if (tryIndex++ % 2 == 0) { ++m_threadGroupCountX; } else { ++m_threadGroupCountY; } threadsPerThreadGroup = GetThreadsPerThreadGroup(pixelCount); } int pixelsCoveredX = threadsPerThreadGroup.X * m_pixelsPerThreadX * m_threadGroupCountX; if (pixelsCoveredX < pixelCount.X) { ++m_threadGroupCountX; } int pixelsCoveredY = threadsPerThreadGroup.Y * m_pixelsPerThreadY * m_threadGroupCountY; if (pixelsCoveredY < pixelCount.Y) { ++m_threadGroupCountY; } m_gatherCS = MyShaders.CreateCs("shadows.hlsl", new [] { new ShaderMacro("NUMTHREADS_X", threadsPerThreadGroup.X), new ShaderMacro("NUMTHREADS_Y", threadsPerThreadGroup.Y), new ShaderMacro("THREAD_GROUPS_X", m_threadGroupCountX), new ShaderMacro("THREAD_GROUPS_Y", m_threadGroupCountY), new ShaderMacro("PIXELS_PER_THREAD_X", m_pixelsPerThreadX), new ShaderMacro("PIXELS_PER_THREAD_Y", m_pixelsPerThreadY) }); }
/// <summary>Attempts to find a a tangent handle under the provided coordinates.</summary> /// <param name="pixelCoords">Coordinates relative to this GUI element in pixels.</param> /// <param name="tangent"> /// Output object containing keyframe information and tangent type. Only valid if method returns true. /// </param> /// <returns>True if there is a tangent handle under the coordinates, false otherwise.</returns> public bool FindTangent(Vector2I pixelCoords, out TangentRef tangent) { return(Internal_findTangent(mCachedPtr, ref pixelCoords, out tangent)); }
/// <summary>Attempts to find a keyframe under the provided coordinates.</summary> /// <param name="pixelCoords">Coordinates relative to this GUI element in pixels.</param> /// <param name="keyframe"> /// Output object containing keyframe index and index of the curve it belongs to. Only valid if method returns true. /// </param> /// <returns>True if there is a keyframe under the coordinates, false otherwise.</returns> public bool FindKeyFrame(Vector2I pixelCoords, out KeyframeRef keyframe) { return(Internal_findKeyFrame(mCachedPtr, ref pixelCoords, out keyframe)); }
private void OnEditorUpdate() { if (currentType == InspectorType.SceneObject) { Component[] allComponents = activeSO.GetComponents(); bool requiresRebuild = allComponents.Length != inspectorComponents.Count; if (!requiresRebuild) { for (int i = 0; i < inspectorComponents.Count; i++) { if (inspectorComponents[i].instanceId != allComponents[i].InstanceId) { requiresRebuild = true; break; } } } if (requiresRebuild) { SceneObject so = activeSO; Clear(); SetObjectToInspect(so); } else { RefreshSceneObjectFields(false); InspectableState componentModifyState = InspectableState.NotModified; for (int i = 0; i < inspectorComponents.Count; i++) { componentModifyState |= inspectorComponents[i].inspector.Refresh(); } if (componentModifyState.HasFlag(InspectableState.ModifyInProgress)) { EditorApplication.SetSceneDirty(); } modifyState |= componentModifyState; } } else if (currentType == InspectorType.Resource) { inspectorResource.inspector.Refresh(); } // Detect drag and drop bool isValidDrag = false; if (activeSO != null) { if ((DragDrop.DragInProgress || DragDrop.DropInProgress) && DragDrop.Type == DragDropType.Resource) { Vector2I windowPos = ScreenToWindowPos(Input.PointerPosition); Vector2I scrollPos = windowPos; Rect2I contentBounds = inspectorLayout.Bounds; scrollPos.x -= contentBounds.x; scrollPos.y -= contentBounds.y; bool isInBounds = false; Rect2I dropArea = new Rect2I(); foreach (var bounds in dropAreas) { if (bounds.Contains(scrollPos)) { isInBounds = true; dropArea = bounds; break; } } Type draggedComponentType = null; if (isInBounds) { ResourceDragDropData dragData = DragDrop.Data as ResourceDragDropData; if (dragData != null) { foreach (var resPath in dragData.Paths) { ResourceMeta meta = ProjectLibrary.GetMeta(resPath); if (meta != null) { if (meta.ResType == ResourceType.ScriptCode) { ScriptCode scriptFile = ProjectLibrary.Load <ScriptCode>(resPath); if (scriptFile != null) { Type[] scriptTypes = scriptFile.Types; foreach (var type in scriptTypes) { if (type.IsSubclassOf(typeof(Component))) { draggedComponentType = type; isValidDrag = true; break; } } if (draggedComponentType != null) { break; } } } } } } } if (isValidDrag) { scrollAreaHighlight.Bounds = dropArea; if (DragDrop.DropInProgress) { activeSO.AddComponent(draggedComponentType); modifyState = InspectableState.Modified; EditorApplication.SetSceneDirty(); } } } } if (scrollAreaHighlight != null) { scrollAreaHighlight.Active = isValidDrag; } }
public Trap(ITilesetTable tilesetTable, Vector2I position) : base(tilesetTable, position) { }