Minor refactoring

livemap/src/commonMain/kotlin/jetbrains/livemap/LiveMap.kt

@@ -29,6 +29,7 @@ import jetbrains.livemap.MapWidgetUtil.MAX_ZOOM
 import jetbrains.livemap.camera.CameraComponent
 import jetbrains.livemap.camera.CameraInputSystem
 import jetbrains.livemap.camera.CameraScale
+import jetbrains.livemap.camera.CameraScale.CameraScaleEffectComponent
 import jetbrains.livemap.camera.CameraUpdateDetectionSystem
 import jetbrains.livemap.core.ecs.*
 import jetbrains.livemap.core.input.*
@@ -62,46 +63,44 @@ import jetbrains.livemap.tiles.components.CellLayerComponent
 import jetbrains.livemap.tiles.components.CellLayerKind
 import jetbrains.livemap.tiles.components.DebugCellLayerComponent
 import jetbrains.livemap.tiles.http.HttpTileLayerComponent
-import jetbrains.livemap.tiles.http.HttpTileLoadingSystem
 import jetbrains.livemap.ui.LiveMapUiSystem
 import jetbrains.livemap.ui.ResourceManager
 import jetbrains.livemap.ui.UiRenderingTaskSystem
 import jetbrains.livemap.ui.UiService
 
 class LiveMap(
  private val myMapProjection: MapProjection,
- private val viewProjection: ViewProjection,
+ private val myViewProjection: ViewProjection,
  private val myMapLayers: List<MapLayer>,
  private val myTileService: TileService,
  private val myTileGeometryProvider: TileGeometryProvider,
  private val myDevParams: DevParams,
  private val myEmptinessChecker: EmptinessChecker,
  private val myMapLocationConsumer: (DoubleRectangle) -> Unit
 ) : BaseLiveMap() {
- private val renderTarget: RenderTarget = myDevParams.read(RENDER_TARGET)
- private var ecsController: EcsController? = null
+ private val myRenderTarget: RenderTarget = myDevParams.read(RENDER_TARGET)
  private var myTimerReg = Registration.EMPTY
- private lateinit var context: LiveMapContext
- private lateinit var layerRenderingSystem: LayersRenderingSystem
- private lateinit var layersOrder: List<RenderLayer>
  private var myInitialized: Boolean = false
- private var myLayerManager: LayerManager? = null
+ private lateinit var myEcsController: EcsController
+ private lateinit var myContext: LiveMapContext
+ private lateinit var myLayerRenderingSystem: LayersRenderingSystem
+ private lateinit var myLayersOrder: List<RenderLayer>
+ private lateinit var myLayerManager: LayerManager
  private lateinit var myDiagnostics: Diagnostics
- private lateinit var schedulerSystem: SchedulerSystem
- private lateinit var uiService: UiService
+ private lateinit var mySchedulerSystem: SchedulerSystem
+ private lateinit var myUiService: UiService
 
  override fun draw(canvasControl: CanvasControl) {
  val componentManager = EcsComponentManager()
- context = LiveMapContext(
+ myContext = LiveMapContext(
  myMapProjection,
  canvasControl,
- MapRenderContext(viewProjection, canvasControl),
- null
+ MapRenderContext(myViewProjection, canvasControl)
  )
 
- uiService = UiService(componentManager, ResourceManager(context.mapRenderContext.canvasProvider))
+ myUiService = UiService(componentManager, ResourceManager(myContext.mapRenderContext.canvasProvider))
 
- myLayerManager = createLayerManager(componentManager, renderTarget, canvasControl)
+ myLayerManager = createLayerManager(componentManager, myRenderTarget, canvasControl)
 
  val updateController = UpdateController(
  { dt -> animationHandler(componentManager, dt) },
@@ -117,33 +116,36 @@ class LiveMap(
 
  private fun animationHandler(componentManager: EcsComponentManager, dt: Long): Boolean {
  if (!myInitialized) {
- initLayers(myLayerManager!!, componentManager)
- initSystems(componentManager)
- initCamera(componentManager)
- myDiagnostics = if (myDevParams.isSet(PERF_STATS)) {
- LiveMapDiagnostics(
- isLoading,
- layersOrder,
- layerRenderingSystem,
- schedulerSystem,
- context.metricsService,
- uiService,
- componentManager
- )
- } else {
- Diagnostics()
- }
-
+ init(componentManager)
  myInitialized = true
  }
 
- ecsController?.update(dt.toDouble())
+ myEcsController.update(dt.toDouble())
 
  myDiagnostics.update(dt)
 
  return true
  }
 
+ private fun init(componentManager: EcsComponentManager) {
+ initLayers(myLayerManager, componentManager)
+ initSystems(componentManager)
+ initCamera(componentManager)
+ myDiagnostics = if (myDevParams.isSet(PERF_STATS)) {
+ LiveMapDiagnostics(
+ isLoading,
+ myLayersOrder,
+ myLayerRenderingSystem,
+ mySchedulerSystem,
+ myContext.metricsService,
+ myUiService,
+ componentManager
+ )
+ } else {
+ Diagnostics()
+ }
+ }
+
  private fun initSystems(componentManager: EcsComponentManager) {
  val tileLoadingSystem =
  if (myDevParams.isSet(DEBUG_TILES))
@@ -153,15 +155,15 @@ class LiveMap(
 
 
  val microTaskExecutor: MicroTaskExecutor = when (myDevParams.read(MICRO_TASK_EXECUTOR)) {
- UI_THREAD -> SyncMicroTaskExecutor(context, myDevParams.read(COMPUTATION_FRAME_TIME).toLong())
+ UI_THREAD -> SyncMicroTaskExecutor(myContext, myDevParams.read(COMPUTATION_FRAME_TIME).toLong())
  AUTO, BACKGROUND -> AsyncMicroTaskExecutorFactory.create()
- } ?: SyncMicroTaskExecutor(context, myDevParams.read(COMPUTATION_FRAME_TIME).toLong())
+ } ?: SyncMicroTaskExecutor(myContext, myDevParams.read(COMPUTATION_FRAME_TIME).toLong())
 
 
- schedulerSystem = SchedulerSystem(microTaskExecutor, componentManager)
- ecsController = EcsController(
+ mySchedulerSystem = SchedulerSystem(microTaskExecutor, componentManager)
+ myEcsController = EcsController(
  componentManager,
- context,
+ myContext,
  listOf(
  // Input systems
  MouseInputSystem(componentManager),
@@ -175,7 +177,7 @@ class LiveMap(
  AnimationObjectSystem(componentManager),
  AnimationSystem(componentManager),
  ViewProjectionUpdateSystem(componentManager),
- LiveMapUiSystem(uiService, componentManager, myMapLocationConsumer),
+ LiveMapUiSystem(myUiService, componentManager, myMapLocationConsumer),
 
  CellStateUpdateSystem(componentManager),
  TileRequestSystem(componentManager),
@@ -207,8 +209,8 @@ class LiveMap(
  EntitiesRenderingTaskSystem(componentManager),
 
  UiRenderingTaskSystem(componentManager),
- layerRenderingSystem,
- schedulerSystem,
+ myLayerRenderingSystem,
+ mySchedulerSystem,
 
  // Effects
  GrowingPath.GrowingPathEffectSystem(componentManager),
@@ -233,25 +235,25 @@ class LiveMap(
  Rectangle().apply {
  rect = newDoubleRectangle(
  Coordinates.ZERO_CLIENT_POINT,
- viewProjection.viewSize
+ myViewProjection.viewSize
  )
  }
  )
  + listeners
  }
 
  listeners.addDoubleClickListener { event ->
- if (camera.contains(CameraScale.CameraScaleEffectComponent::class) || camera.getComponent<CameraComponent>().zoom == MAX_ZOOM.toDouble()) {
+ if (camera.contains<CameraScaleEffectComponent>() || camera.getComponent<CameraComponent>().zoom == MAX_ZOOM.toDouble()) {
  return@addDoubleClickListener
  }
 
  val origin = event.location!!.let { ClientPoint(it.x, it.y) }
- val currentMapCenter = viewProjection.getMapCoord(viewProjection.viewSize / 2.0)
+ val currentMapCenter = myViewProjection.getMapCoord(myViewProjection.viewSize / 2.0)
 
  CameraScale.setAnimation(
  camera,
  origin,
- viewProjection.getMapCoord(origin)
+ myViewProjection.getMapCoord(origin)
  .run { this - currentMapCenter }
  .run { this / 2.0 }
  .run { this + currentMapCenter},
@@ -262,8 +264,8 @@ class LiveMap(
 
  private fun initLayers(layerManager: LayerManager, componentManager: EcsComponentManager) {
  // layers
- layersOrder = layerManager.createLayersOrderComponent().renderLayers
- layerRenderingSystem = layerManager.createLayerRenderingSystem()
+ myLayersOrder = layerManager.createLayersOrderComponent().renderLayers
+ myLayerRenderingSystem = layerManager.createLayerRenderingSystem()
 
  componentManager
  .createEntity("layers_order")
@@ -301,7 +303,7 @@ class LiveMap(
  MapLayerKind.V_LINE -> mapObject2Entity.processLine(mapObjects, false)
  MapLayerKind.TEXT -> mapObject2Entity.processText(
  mapObjects,
- TextMeasurer(context.mapRenderContext.canvasProvider.createCanvas(Vector.ZERO).context2d)
+ TextMeasurer(myContext.mapRenderContext.canvasProvider.createCanvas(Vector.ZERO).context2d)
  )
  else -> error("")
  }
@@ -336,7 +338,7 @@ class LiveMap(
 
  override fun dispose() {
  myTimerReg.dispose()
- ecsController?.dispose()
+ myEcsController.dispose()
  }
 
  private class UpdateController(

livemap/src/commonMain/kotlin/jetbrains/livemap/LiveMapContext.kt

@@ -2,12 +2,10 @@ package jetbrains.livemap
 
 import jetbrains.datalore.base.event.MouseEventSource
 import jetbrains.livemap.core.ecs.EcsContext
-import jetbrains.livemap.core.rendering.SpriteSheet
 import jetbrains.livemap.projections.MapProjection
 
 open class LiveMapContext(
  open val mapProjection: MapProjection,
  eventSource: MouseEventSource,
- open val mapRenderContext: MapRenderContext,
- val spriteSheet: SpriteSheet?
+ open val mapRenderContext: MapRenderContext
 ) : EcsContext(eventSource)

livemap/src/commonMain/kotlin/jetbrains/livemap/entities/Entities.kt

@@ -4,18 +4,16 @@ import jetbrains.livemap.camera.CameraComponent
 import jetbrains.livemap.camera.CameraListenerComponent
 import jetbrains.livemap.camera.CenterChangedComponent
 import jetbrains.livemap.camera.ZoomChangedComponent
-import jetbrains.livemap.core.animation.Animation
 import jetbrains.livemap.core.ecs.AnimationComponent
-import jetbrains.livemap.core.ecs.AnimationObjectComponent
 import jetbrains.livemap.core.ecs.EcsComponentManager
 import jetbrains.livemap.core.ecs.EcsEntity
+import jetbrains.livemap.core.ecs.addComponents
 import jetbrains.livemap.core.rendering.layers.ParentLayerComponent
 import jetbrains.livemap.entities.placement.ScreenLoopComponent
 import jetbrains.livemap.entities.placement.ScreenOriginComponent
 import jetbrains.livemap.entities.placement.WorldOriginComponent
 import jetbrains.livemap.entities.rendering.Renderer
 import jetbrains.livemap.entities.rendering.RendererComponent
-import jetbrains.livemap.projections.ClientPoint
 import jetbrains.livemap.projections.WorldPoint
 
 object Entities {
@@ -25,58 +23,40 @@ object Entities {
  parentLayerComponent: ParentLayerComponent, renderer: Renderer, name: String
  ): EcsEntity {
  return componentManager
- .createEntity(name)
- .addComponent(parentLayerComponent)
- .addComponent(RendererComponent(renderer))
- .addComponent(WorldOriginComponent(worldPlacement))
- .addComponent(CameraListenerComponent())
- .addComponent(CenterChangedComponent())
- .addComponent(ZoomChangedComponent())
- .addComponent(ScreenLoopComponent())
- .addComponent(ScreenOriginComponent())
+ .createEntity(name).addComponents {
+ + parentLayerComponent
+ + RendererComponent(renderer)
+ + WorldOriginComponent(worldPlacement)
+ + CameraListenerComponent()
+ + CenterChangedComponent()
+ + ZoomChangedComponent()
+ + ScreenLoopComponent()
+ + ScreenOriginComponent()
+ }
  }
 
  fun dynamicMapEntity(
  componentManager: EcsComponentManager, parentLayerComponent: ParentLayerComponent,
  renderer: Renderer, name: String
  ): EcsEntity {
  return componentManager
- .createEntity(name)
- .addComponent(parentLayerComponent)
- .addComponent(RendererComponent(renderer))
- .addComponent(CameraListenerComponent())
- .addComponent(CenterChangedComponent())
- .addComponent(ZoomChangedComponent())
- .addComponent(ScreenLoopComponent())
- .addComponent(ScreenOriginComponent())
+ .createEntity(name).addComponents {
+ + parentLayerComponent
+ + RendererComponent(renderer)
+ + CameraListenerComponent()
+ + CenterChangedComponent()
+ + ZoomChangedComponent()
+ + ScreenLoopComponent()
+ + ScreenOriginComponent()
+ }
  }
 
  fun camera(componentManager: EcsComponentManager): EcsEntity {
  return componentManager.getEntity(CameraComponent::class)
  }
 
- fun createScreenEntity(
- componentManager: EcsComponentManager,
- screenPlacement: ClientPoint,
- name: String
- ): EcsEntity {
- return componentManager
- .createEntity(name)
- .addComponent(CameraListenerComponent())
- .addComponent(CenterChangedComponent())
- .addComponent(ZoomChangedComponent())
- .addComponent(
- ScreenOriginComponent()
- .apply { origin = screenPlacement }
- )
- }
-
- fun animationObject(componentManager: EcsComponentManager, animation: Animation, name: String): EcsEntity {
- return componentManager.createEntity(name).addComponent(AnimationObjectComponent(animation))
- }
-
  fun animation(componentManager: EcsComponentManager, name: String): EcsEntity {
- return componentManager.createEntity(name).addComponent(AnimationComponent())
+ return componentManager.createEntity(name).addComponents { + AnimationComponent() }
  }
 
  class MapEntityFactory(layerEntity: EcsEntity) {