Class TCastleTiledMapControl

This item has no description.

This item has no description.

This item has no description. Showing description inherited from TCastleUserInterface.Render.

Render a control. Called only when Exists and render context is initialized.

Do not call this method. It will be automatically called by the engine when needed. It will be called when UI is part of TCastleContainer.Controls list or rendered (e.g. for off-screen rendering) by TCastleContainer.RenderControl.

You should only override this method.

See https://castle-engine.io/manual_2d_ui_custom_drawn.php for examples what you can put here.

You can depend on some OpenGL state being set before calling this method. You can depend on it being set, and you can carelessly change it. This state we set:

• Viewport is set to include whole container.

• Depth test is off.

• For ancient fixed-function pipeline (see TGLFeatures.RequestCapabilities):

  • The 2D orthographic projection is always set at the beginning. Useful for 2D controls.

  • The modelview matrix is set to identity. The matrix mode is always modelview.

  • The raster position is set to (0,0). The (deprecated) WindowPos is also set to (0,0).

  • Texturing, lighting, fog is off.

Beware that GLSL RenderContext.CurrentProgram has undefined value when this is called. You should always set it, before making direct OpenGL drawing calls (all the engine drawing routines do it already, this is only a concern if you make direct OpenGL / OpenGLES calls).

This item has no description. Showing description inherited from TCastleComponent.PropertySections.

Section where to show property in the editor.

Warning: this symbol is deprecated: set Url instead of calling LoadFromFile

Load given TMX file to memory and creates structures.

Detect tile under given position.

The interpretation of Position depends on ContainerCoordinates, and is similar to e.g. TCastleViewport.PositionToCameraPlane:

• When ContainerCoordinates = True, then Position is relative to the whole container (like TCastleWindow or TCastleControl).

  And it is expressed in real device coordinates, just like TInputPressRelease.Position when mouse is being clicked, or like TInputMotion.Position when mouse is moved.

• When ContainerCoordinates = False, then Position is relative to this UI control.

  And it is expressed in coordinates after UI scaling. IOW, if the size of this control is Width = 100, then Position.X between 0 and 100 reflects the visible range of this control.

Note that you can query the positions that are outside of this UI control, or even outside of the container. They will return correct map tiles, as if the map was rendered there. If you want to avoid this, you can e.g. check whether Position is inside the RenderRect (if it's a position in container coordinates, with ContainerCoordinates = True).

This method returns False if the position is outside of the map. Valid map tiles are from (0, 0) (lower-left) to (TCastleTiledMapData.Width - 1, TCastleTiledMapData.Height - 1) (upper-right).

Rectangle where the given map tile is rendered. Useful to render something over a TCastleTiledMapControl, e.g. a pawn in a game.

In some way, this method is an inverse of the PositionToTile method. It converts map (tile) coordinates back into coordinates useful to display something. The ContainerCoordinates value determines the coordinate system of the resulting rectangle. It's meaning is similar to the ContainerCoordinates parameter of the PositionToTile method.

• When ContainerCoordinates = True, the resulting rectangle is relative to the whole container (like TCastleWindow or TCastleControl). And is expressed in real device coordinates.

  These are the same coordinates as expressed by RenderRect method. You can pass the resulting rectangle straight to DrawRectangle, or TDrawableImage.Draw, or TSprite.Draw, to draw something over this tile.

• When ContainerCoordinates = False, the resulting rectangle is specified in local coordinates of this control, and is expressed in coordinates after UI scaling.

  These are the same coordinates as used by children controls (TCastleUserInterface) or the TCastleTiledMapControl. E.g. you can insert a TCastleImageControl as a child of TCastleTiledMapControl, and set it's position/size this way, to draw an image over this tile.

This method works for any TilePosition, even outside of valid map positions. Returns TFloatRectangle.Empty is Map not loaded (Url not set).

Some maps may use tilesets in which image size is different than map tile size. That is, TCastleTiledMapData.TTileset.TileWidth may be different than TCastleTiledMapData.TileWidth for some tilesets. The simpler version of this method, without ForceTileWidth/Height, just returns the size of the map tile looking at (TCastleTiledMapData.TileWidth, TCastleTiledMapData.TileHeight), since it doesn't know the tileset you use.

You can pass ForceTileWidth and ForceTileHeight to set particular size.

This item has no description.

Origin determines the map position at control's left-bottom corner. Increasing Origin.X moves visually the map to the left, increasing Origin.Y moves it down.

Currently loaded map (from Url), if any. Nil if no map is loaded (when Url is empty). Read-only.

This item has no description. Showing description inherited from TCastleUserInterface.ClipChildren.

Clip the rendering of children.

By default this is False and so the control can draw outside of it's designated rectangle (RenderRect). Although all the standard UI controls are carefully implemented such that their Render and RenderOverChildren draw only within their RenderRect. But it is easy to place children controls outside of this rectangle.

When this property is True, the rendering is clipped, so the "overflowing" parts are never visible. This affects both Render and RenderOverChildren of this control, as well as all children rendering.

Url (or just filename) of the Tiled map file (TMX).

This item has no description.

Show objects like polylines and points on the map.

How are images scaled (because of UI scaling, because of Scale). True means we use nice "bilinear" filter. False means we use pixelated "nearest" filter.

Beware that using True, and scaling the map, requires preparing the tileset (atlas of tile images) in a proper way. The space around each tile must have at least 1-pixel margin filled with the same color and alpha ("color bleeding"), otherwise bad colors will creep in because of bilinear filtering. Alternatively, you can use SmoothScalingSafeBorder.

In case of SmoothScaling, prevent the color outside of rendered frame from creeping in, by stretching the rendered frame a bit. See TSprite.SmoothScalingSafeBorder.

It is better to prepare the sprite (tileset) images with some spacing between tiles, and color bleeding, instead of using this property. This property workarounds the fact that some sprite (tileset) images lack proper spacing and color bleeding, but it distorts the image a bit, so it's no longer pixel-perfect.

Origin that can be visually edited in Castle Game Engine Editor, Lazarus and Delphi. Normal user code does not need to deal with this, instead read or write Origin directly.

See also

Origin

Origin determines the map position at control's left-bottom corner.