diff --git a/api/android-sdk-core.api b/api/android-sdk-core.api index 0529e36..7905a04 100644 --- a/api/android-sdk-core.api +++ b/api/android-sdk-core.api @@ -1580,7 +1580,7 @@ final class com.mapconductor.core.marker.AbstractDefaultIcon$PinBounds { public final float getTop(); public final float getBottom(); } -public abstract class com.mapconductor.core.marker.AbstractMarkerController implements com.mapconductor.core.controller.SlottedOverlayController>, com.mapconductor.core.marker.MarkerEventHostInterface { +public abstract class com.mapconductor.core.marker.AbstractMarkerController implements com.mapconductor.core.controller.SlottedOverlayController>, com.mapconductor.core.marker.MarkerEventHostInterface, com.mapconductor.core.marker.MarkerDrawOrderReceiver { public com.mapconductor.core.marker.AbstractMarkerController(com.mapconductor.core.marker.MarkerManager, com.mapconductor.core.marker.MarkerOverlayRendererInterface, kotlin.jvm.functions.Function1); public com.mapconductor.core.marker.AbstractMarkerController(com.mapconductor.core.marker.MarkerManager, com.mapconductor.core.marker.MarkerOverlayRendererInterface, kotlin.jvm.functions.Function1, int, kotlin.jvm.internal.DefaultConstructorMarker); public com.mapconductor.core.marker.MarkerManager getMarkerManager(); @@ -1616,6 +1616,7 @@ public abstract class com.mapconductor.core.marker.AbstractMarkerController getEntity(java.lang.String); public boolean has(java.lang.String); + public java.lang.Object onDrawOrderFrameChanged(com.mapconductor.core.marker.MarkerDrawOrder$Frame, kotlin.coroutines.Continuation); public void setClickListenerAny(java.lang.Object); public java.lang.Object update(java.lang.Object, kotlin.coroutines.Continuation); public java.lang.Object find(com.mapconductor.core.features.GeoPointInterface); @@ -1645,6 +1646,11 @@ public abstract class com.mapconductor.core.marker.AbstractMarkerOverlayRenderer public final com.mapconductor.core.marker.MarkerAnimationOverlayHost getAnimationOverlayHost(); public final void setAnimationOverlayHost(com.mapconductor.core.marker.MarkerAnimationOverlayHost); public boolean getSupportsAnimationOverlay(); + public final com.mapconductor.core.marker.MarkerDrawOrder$Frame getDrawOrderFrame(); + public final double drawOrderOf(com.mapconductor.core.marker.MarkerState); + public final int drawOrderIntOf(com.mapconductor.core.marker.MarkerState); + public java.lang.Object onDrawOrderFrameChanged(com.mapconductor.core.marker.MarkerDrawOrder$Frame, java.util.List>, kotlin.coroutines.Continuation); + protected java.lang.Object applyDrawOrder(java.util.List>, kotlin.coroutines.Continuation); public void setMarkerVisible(com.mapconductor.core.marker.MarkerEntityInterface, boolean); public abstract void setMarkerPosition(com.mapconductor.core.marker.MarkerEntityInterface, com.mapconductor.core.features.GeoPoint); public java.lang.Object onAnimate(com.mapconductor.core.marker.MarkerEntityInterface, kotlin.coroutines.Continuation); @@ -1805,6 +1811,21 @@ public final class com.mapconductor.core.marker.MarkerCollector implements com.m public java.lang.Object add(com.mapconductor.core.ComponentState, kotlin.coroutines.Continuation); public com.mapconductor.core.marker.MarkerCollector(long, kotlinx.coroutines.CoroutineScope, kotlin.jvm.internal.DefaultConstructorMarker); } +public final class com.mapconductor.core.marker.MarkerDrawOrder$Frame { + public static final com.mapconductor.core.marker.MarkerDrawOrder$Frame$Companion Companion; + public final double getHeadingDegrees(); + public final double getOriginLongitude(); + public final boolean differsEnoughFrom(com.mapconductor.core.marker.MarkerDrawOrder$Frame); + public final double component1(); + public final double component2(); + public final com.mapconductor.core.marker.MarkerDrawOrder$Frame copy(double, double); + public java.lang.String toString(); + public int hashCode(); + public boolean equals(java.lang.Object); +} +public final class com.mapconductor.core.marker.MarkerDrawOrder$Frame$Companion { + public final com.mapconductor.core.marker.MarkerDrawOrder$Frame getNorthUp(); +} public final class com.mapconductor.core.marker.MarkerEntity implements com.mapconductor.core.marker.MarkerEntityInterface { public com.mapconductor.core.marker.MarkerEntity(ActualMarker, com.mapconductor.core.marker.MarkerState, boolean, boolean, boolean); public com.mapconductor.core.marker.MarkerEntity(java.lang.Object, com.mapconductor.core.marker.MarkerState, boolean, boolean, boolean, int, kotlin.jvm.internal.DefaultConstructorMarker); @@ -1942,6 +1963,7 @@ public interface com.mapconductor.core.marker.MarkerOverlayRendererInterface); public default void onDragSelectionChanged(com.mapconductor.core.marker.MarkerEntityInterface, com.mapconductor.core.marker.MarkerEntityInterface); public default void onDragPositionChanged(com.mapconductor.core.features.GeoPointInterface); + public default java.lang.Object onDrawOrderFrameChanged(com.mapconductor.core.marker.MarkerDrawOrder$Frame, java.util.List>, kotlin.coroutines.Continuation); } public interface com.mapconductor.core.marker.MarkerOverlayRendererInterface$AddParamsInterface { public abstract com.mapconductor.core.marker.MarkerState getState(); @@ -1955,6 +1977,7 @@ public interface com.mapconductor.core.marker.MarkerOverlayRendererInterface$Cha public final class com.mapconductor.core.marker.MarkerOverlayRendererInterface$DefaultImpls { public static void onDragSelectionChanged(com.mapconductor.core.marker.MarkerOverlayRendererInterface, com.mapconductor.core.marker.MarkerEntityInterface, com.mapconductor.core.marker.MarkerEntityInterface); public static void onDragPositionChanged(com.mapconductor.core.marker.MarkerOverlayRendererInterface, com.mapconductor.core.features.GeoPointInterface); + public static java.lang.Object onDrawOrderFrameChanged(com.mapconductor.core.marker.MarkerOverlayRendererInterface, com.mapconductor.core.marker.MarkerDrawOrder$Frame, java.util.List>, kotlin.coroutines.Continuation); } public interface com.mapconductor.core.marker.MarkerRenderingStrategyInterface { public abstract com.mapconductor.core.marker.MarkerManager getMarkerManager(); @@ -2147,7 +2170,7 @@ public final class com.mapconductor.core.marker.PointD { public int hashCode(); public boolean equals(java.lang.Object); } -public final class com.mapconductor.core.marker.StrategyMarkerController implements com.mapconductor.core.controller.SlottedOverlayController>, com.mapconductor.core.controller.OnCameraChangeReceiverInterface, com.mapconductor.core.marker.MarkerEventHostInterface { +public final class com.mapconductor.core.marker.StrategyMarkerController implements com.mapconductor.core.controller.SlottedOverlayController>, com.mapconductor.core.controller.OnCameraChangeReceiverInterface, com.mapconductor.core.marker.MarkerEventHostInterface, com.mapconductor.core.marker.MarkerDrawOrderReceiver { public com.mapconductor.core.marker.StrategyMarkerController(com.mapconductor.core.marker.MarkerRenderingStrategyInterface, com.mapconductor.core.marker.MarkerOverlayRendererInterface); public com.mapconductor.core.marker.MarkerOverlayRendererInterface getRenderer(); public com.mapconductor.core.marker.MarkerManager getMarkerManager(); @@ -2176,6 +2199,7 @@ public final class com.mapconductor.core.marker.StrategyMarkerController getEntity(java.lang.String); public com.mapconductor.core.marker.MarkerEntityInterface find(com.mapconductor.core.features.GeoPointInterface); public java.lang.Object onCameraChanged(com.mapconductor.core.map.MapCameraPosition, kotlin.coroutines.Continuation); + public java.lang.Object onDrawOrderFrameChanged(com.mapconductor.core.marker.MarkerDrawOrder$Frame, kotlin.coroutines.Continuation); public void destroy(); public com.mapconductor.core.controller.OverlayKind getKind(); public com.mapconductor.core.controller.OverlayHit resolveTap(com.mapconductor.core.features.GeoPointInterface); diff --git a/src/androidTest/java/com/mapconductor/core/marker/DefaultIconAnchorDeviceTest.kt b/src/androidTest/java/com/mapconductor/core/marker/DefaultIconAnchorDeviceTest.kt new file mode 100644 index 0000000..5945ed4 --- /dev/null +++ b/src/androidTest/java/com/mapconductor/core/marker/DefaultIconAnchorDeviceTest.kt @@ -0,0 +1,55 @@ +package com.mapconductor.core.marker + +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.unit.dp +import androidx.test.ext.junit.runners.AndroidJUnit4 +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import android.util.Log + +/** + * アンカーがピンの先端に乗っているか。`scale` で縮めても `iconSize` で縮めても同じ。 + * + * 先端は、アンカー列で一番下にある不透明な画素。アンカーの y との差を px で測る。 + */ +@RunWith(AndroidJUnit4::class) +class DefaultIconAnchorDeviceTest { + private fun tipGapPx(icon: ColorDefaultIcon): Float { + val bitmapIcon = icon.toBitmapIcon() + val bitmap = bitmapIcon.bitmap + val anchorX = (bitmapIcon.anchor.x * bitmap.width).toInt().coerceIn(0, bitmap.width - 1) + val anchorY = bitmapIcon.anchor.y * bitmap.height + var lowest = -1 + for (y in 0 until bitmap.height) { + for (dx in -1..1) { + val x = (anchorX + dx).coerceIn(0, bitmap.width - 1) + if ((bitmap.getPixel(x, y) ushr 24) > 128) lowest = y + } + } + val gap = anchorY - (lowest + 1) + Log.i( + "IconAnchor", + "${bitmap.width}x${bitmap.height} anchor=${bitmapIcon.anchor} tipBottom=${lowest + 1} gap=$gap", + ) + return gap + } + + @Test + fun anchorSitsOnTheTipWhateverTheSize() { + val icons = + listOf( + ColorDefaultIcon(fillColor = Color.Red), + ColorDefaultIcon(fillColor = Color.Red, label = "T"), + ColorDefaultIcon(fillColor = Color.Blue, label = "P", scale = 0.6f), + ColorDefaultIcon(fillColor = Color.Blue, label = "P", iconSize = 28.dp), + ColorDefaultIcon(fillColor = Color.Blue, scale = 0.6f), + ColorDefaultIcon(fillColor = Color.Blue, scale = 2f), + ) + val gaps = icons.map { tipGapPx(it) / it.toBitmapIcon().bitmap.height } + // 素のピン(1 番目)の先端とアンカーの差を基準に、どの大きさでも同じ割合であること。 + for (gap in gaps) { + assertTrue("gaps $gaps", kotlin.math.abs(gap - gaps[0]) <= 0.02f) + } + } +} diff --git a/src/main/java/com/mapconductor/core/controller/BaseMapViewController.kt b/src/main/java/com/mapconductor/core/controller/BaseMapViewController.kt index 2916cdd..7ff3bd3 100644 --- a/src/main/java/com/mapconductor/core/controller/BaseMapViewController.kt +++ b/src/main/java/com/mapconductor/core/controller/BaseMapViewController.kt @@ -19,6 +19,9 @@ import com.mapconductor.core.map.MapDiagnostics import com.mapconductor.core.map.MapViewHolderInterface import com.mapconductor.core.marker.MarkerAnimationOverlayHost import com.mapconductor.core.marker.MarkerCapableInterface +import com.mapconductor.core.marker.MarkerDrawOrder +import com.mapconductor.core.marker.MarkerDrawOrderReceiver +import com.mapconductor.core.marker.MarkerDrawOrderTracker import com.mapconductor.core.marker.MarkerState import com.mapconductor.core.marker.OnMarkerEventHandler import com.mapconductor.core.marker.StrategyMarkerController @@ -54,6 +57,16 @@ abstract class BaseMapViewController : private var lastNotifiedCameraPosition: MapCameraPosition? = null abstract val mainCoroutine: CoroutineScope private val overlayControllers = CopyOnWriteArrayList>() + + /** + * 同じ zIndex のマーカーを地図の向きに合わせて並べ直させる(画面で下ほど手前)。 + * 回転が止まってから、登録されたマーカーのコントローラ全部へ一度だけ配る。 + */ + private val markerDrawOrder by lazy { + MarkerDrawOrderTracker(defaultCoroutine) { frame -> + overlayControllers.forEach { (it as? MarkerDrawOrderReceiver)?.onDrawOrderFrameChanged(frame) } + } + } protected var cameraMoveStartCallback: OnCameraMoveHandler? = null protected var cameraMoveCallback: OnCameraMoveHandler? = null protected var cameraMoveEndCallback: OnCameraMoveHandler? = null @@ -153,6 +166,11 @@ abstract class BaseMapViewController : override fun registerOverlayController(controller: OverlayControllerInterface<*, *>) { if (overlayControllers.contains(controller)) return overlayControllers.add(controller) + // 地図が回った後に登録されたら、今の向きで並べ直させる。 + val frame = markerDrawOrder.frame + if (controller is MarkerDrawOrderReceiver && frame != MarkerDrawOrder.Frame.NorthUp) { + defaultCoroutine.launch { controller.onDrawOrderFrameChanged(frame) } + } // 登録が初期カメラ確定より後になることがある(RN の拡張レンダラや遅延マウントの // クラスタリングなど)。ユーザー操作までカメライベントを出さないプロバイダ // (HERE)では次のイベントが永遠に来ず、「登録したのに一度も計算されない」型の @@ -536,6 +554,7 @@ abstract class BaseMapViewController : protected suspend fun notifyMapCameraPosition(mapCameraPosition: MapCameraPosition) { lastNotifiedCameraPosition = mapCameraPosition + markerDrawOrder.onCameraChanged(mapCameraPosition) overlayControllers.forEach { if (it is OnCameraChangeReceiverInterface) { it.onCameraChanged(mapCameraPosition) diff --git a/src/main/java/com/mapconductor/core/marker/AbstractMarkerController.kt b/src/main/java/com/mapconductor/core/marker/AbstractMarkerController.kt index 5c74161..128964f 100644 --- a/src/main/java/com/mapconductor/core/marker/AbstractMarkerController.kt +++ b/src/main/java/com/mapconductor/core/marker/AbstractMarkerController.kt @@ -17,7 +17,8 @@ abstract class AbstractMarkerController( MarkerState, MarkerEntityInterface, >, - MarkerEventHostInterface { + MarkerEventHostInterface, + MarkerDrawOrderReceiver { override val zIndex: Int = 10 val semaphore = Semaphore(1) @@ -376,6 +377,10 @@ abstract class AbstractMarkerController( override fun getEntity(id: String): MarkerEntityInterface? = markerManager.getEntity(id) override fun has(id: String): Boolean = markerManager.hasEntity(id) + + override suspend fun onDrawOrderFrameChanged(frame: MarkerDrawOrder.Frame) { + semaphore.withPermit { renderer.onDrawOrderFrameChanged(frame, markerManager.allEntities()) } + } } private const val MARKER_RENDER_BATCH_SIZE = 500 diff --git a/src/main/java/com/mapconductor/core/marker/AbstractMarkerOverlayRenderer.kt b/src/main/java/com/mapconductor/core/marker/AbstractMarkerOverlayRenderer.kt index e9896d8..15c1334 100644 --- a/src/main/java/com/mapconductor/core/marker/AbstractMarkerOverlayRenderer.kt +++ b/src/main/java/com/mapconductor/core/marker/AbstractMarkerOverlayRenderer.kt @@ -45,6 +45,30 @@ abstract class AbstractMarkerOverlayRenderer< */ open val supportsAnimationOverlay: Boolean = false + /** 同じ zIndex のマーカーを並べる向き([onDrawOrderFrameChanged] で変わる)。 */ + var drawOrderFrame: MarkerDrawOrder.Frame = MarkerDrawOrder.Frame.NorthUp + private set + + /** [drawOrderFrame] で並べたときの描く順。大きいほど手前。 */ + fun drawOrderOf(state: MarkerState): Double = MarkerDrawOrder.of(state.zIndex, state.position, drawOrderFrame) + + /** [drawOrderOf] の整数版。 */ + fun drawOrderIntOf(state: MarkerState): Int = MarkerDrawOrder.ofInt(state.zIndex, state.position, drawOrderFrame) + + override suspend fun onDrawOrderFrameChanged( + frame: MarkerDrawOrder.Frame, + entities: List>, + ) { + drawOrderFrame = frame + applyDrawOrder(entities) + } + + /** + * [drawOrderFrame] が変わったので、[entities] の描く順を付け直す。 + * 既定は何もしない(北が上の順のまま)。 + */ + protected open suspend fun applyDrawOrder(entities: List>) = Unit + /** Hide/show the native marker while the overlay animation runs. */ open fun setMarkerVisible( markerEntity: MarkerEntityInterface, diff --git a/src/main/java/com/mapconductor/core/marker/MarkerDrawOrder.kt b/src/main/java/com/mapconductor/core/marker/MarkerDrawOrder.kt new file mode 100644 index 0000000..e263e89 --- /dev/null +++ b/src/main/java/com/mapconductor/core/marker/MarkerDrawOrder.kt @@ -0,0 +1,161 @@ +package com.mapconductor.core.marker + +import com.mapconductor.core.InternalMapConductorApi +import com.mapconductor.core.features.GeoPointInterface +import kotlin.math.PI +import kotlin.math.abs +import kotlin.math.cos +import kotlin.math.floor +import kotlin.math.ln +import kotlin.math.sin +import kotlin.math.sqrt + +/** + * マーカーの帯の中での描く順。どのドライバーもこれで並べる。 + * + * - 第 1 キーは `zIndex`(未指定は 0)。大きいほど手前。 + * - 同じ `zIndex` なら、**地図の向きに合わせた画面で下にあるほど**手前。 + * 画面上の高さも同じなら左ほど手前(北が上なら南ほど・西ほど手前)。 + * + * 2 つ目は Google Maps JS の既定(画面で下のマーカーが手前、回転するとその場で + * 入れ替わる)に合わせている。ただし Google は高さが同じとき後から足した方を + * 手前にするが、ここでは左を手前にして、追加した順には左右させない。 + * + * 返す値は `zIndex + 端数`。端数は [0, 0.5) に収めるので、`zIndex` の大小を + * 決してひっくり返さない。以前は未指定のときだけ `-緯度 × 10^6 - 経度` を + * 使っていたため、次の 2 つが起きていた。 + * + * - 北半球(東京で約 -3.57e7)では、Google Maps が明示の `zIndex = 1` を + * それより奥に描いた(大きすぎる値を正しく比べない。実機で確認)。 + * - 南半球では値が大きな正になり、明示の小さな `zIndex` を追い越した。 + * + * 値を小さく保つのはそのため。 + * + * 向きは [Frame] で渡す。省略すると北が上([Frame.NorthUp])。**タイルに焼き込む + * マーカーは常に北が上で並べる**(タイルは北が上で描くので、回転のたびに描き直す + * ことになるため)。 + */ +@InternalMapConductorApi +object MarkerDrawOrder { + /** 端数の上限。0.5 未満にして、隣の `zIndex` と重ならないようにする。 */ + private const val TIEBREAK_SPAN = 0.45 + + /** 左右の寄与。画面上の高さが同じときだけ効くよう、十分小さくする。 */ + private const val LEFT_WEIGHT = 1e-9 + + private const val MAX_MERCATOR_LATITUDE = 85.05112878 + + /** 並べ直しに値する向きの変化(度)。 */ + private const val HEADING_STEP = 0.5 + + /** 並べ直しに値する基準経度の変化(度)。ずれが効くのは基準の裏側(±180°)だけ。 */ + private const val ORIGIN_STEP = 90.0 + + /** + * 並べる向き。 + * + * @property headingDegrees カメラが向いている方位(heading。時計回り、度。90 なら + * 画面の上が東)。MapConductor の `bearing` とは符号が逆なので + * [com.mapconductor.core.map.CameraBearing.toNativeHeading] で直して渡す。 + * @property originLongitude 経度の折り返しの基準。カメラの中心の経度を渡すと、 + * 日付変更線をまたいで見ていても正しく並ぶ。 + */ + data class Frame( + val headingDegrees: Double = 0.0, + val originLongitude: Double = 0.0, + ) { + /** [other] から変わったとき、並べ直す必要があるか。 */ + fun differsEnoughFrom(other: Frame): Boolean = + angleBetween(headingDegrees, other.headingDegrees) >= HEADING_STEP || + angleBetween(originLongitude, other.originLongitude) >= ORIGIN_STEP + + companion object { + val NorthUp = Frame() + } + } + + /** + * 描く順の値。大きいほど手前。 + * + * Float にして渡す SDK(Google Maps)でも、`zIndex` が数百までなら数十メートルの + * 差を見分けられる。 + */ + fun of( + zIndex: Int?, + position: GeoPointInterface, + headingDegrees: Double = 0.0, + originLongitude: Double = 0.0, + ): Double = (zIndex ?: 0) + tiebreak(position, headingDegrees, originLongitude) + + fun of( + zIndex: Int?, + position: GeoPointInterface, + frame: Frame, + ): Double = of(zIndex, position, frame.headingDegrees, frame.originLongitude) + + /** + * 整数しか受けない SDK 向け(HERE の `drawOrder` など)。 + * + * `zIndex × [INT_STRIDE] + 端数を [INT_STRIDE] 段に刻んだ値`。`zIndex` は + * ±(Int.MAX / [INT_STRIDE]) の範囲に収めること。 + */ + fun ofInt( + zIndex: Int?, + position: GeoPointInterface, + headingDegrees: Double = 0.0, + originLongitude: Double = 0.0, + ): Int { + val primary = (zIndex ?: 0).coerceIn(-MAX_INT_Z_INDEX, MAX_INT_Z_INDEX) + val step = (tiebreak(position, headingDegrees, originLongitude) / TIEBREAK_SPAN * (INT_STRIDE - 1)).toInt() + return primary * INT_STRIDE + step + } + + fun ofInt( + zIndex: Int?, + position: GeoPointInterface, + frame: Frame, + ): Int = ofInt(zIndex, position, frame.headingDegrees, frame.originLongitude) + + /** [ofInt] で 1 つの `zIndex` に割り当てる段の数。赤道でおよそ 60 m 刻み。 */ + const val INT_STRIDE: Int = 1_000_000 + + /** [ofInt] が扱える `zIndex` の絶対値。 */ + const val MAX_INT_Z_INDEX: Int = Int.MAX_VALUE / INT_STRIDE - 1 + + private fun tiebreak( + position: GeoPointInterface, + headingDegrees: Double, + originLongitude: Double, + ): Double { + // Web Mercator の世界座標 [0, 1]。y は北が 0、南が 1。 + val latitude = position.latitude.coerceIn(-MAX_MERCATOR_LATITUDE, MAX_MERCATOR_LATITUDE) + val wx = (position.longitude + 180.0) / 360.0 + val sinLat = sin(latitude * PI / 180.0) + val wy = 0.5 - ln((1.0 + sinLat) / (1.0 - sinLat)) / (4.0 * PI) + // 基準からの差。経度は [-0.5, 0.5) に折り返す。 + val dx = wrap(wx - (originLongitude + 180.0) / 360.0) + val dy = wy - 0.5 + // 画面の下向き・右向きの成分(カメラは北から時計回りに heading だけ向いている)。 + val theta = headingDegrees * PI / 180.0 + val down = -dx * sin(theta) + dy * cos(theta) + val right = dx * cos(theta) + dy * sin(theta) + // どちらも [0, 1] に収める(|dx|, |dy| ≤ 0.5 なので回しても √2 / 2 以内)。 + val down01 = (0.5 + down / SQRT2).coerceIn(0.0, 1.0) + val left01 = (0.5 - right / SQRT2).coerceIn(0.0, 1.0) + val share = down01 * (1.0 - LEFT_WEIGHT) + left01 * LEFT_WEIGHT + // 0.5 に届かないよう、端の 1.0 は上限の少し手前に寄せる。 + return (TIEBREAK_SPAN * share).coerceAtMost(TIEBREAK_SPAN * (1.0 - 1e-12)) + } + + private val SQRT2 = sqrt(2.0) + + private fun wrap(value: Double): Double = value - floor(value + 0.5) + + private fun angleBetween( + a: Double, + b: Double, + ): Double { + val d = abs(((a - b) % 360.0 + 360.0) % 360.0) + return if (d > 180.0) 360.0 - d else d + } +} diff --git a/src/main/java/com/mapconductor/core/marker/MarkerDrawOrderTracker.kt b/src/main/java/com/mapconductor/core/marker/MarkerDrawOrderTracker.kt new file mode 100644 index 0000000..50886f5 --- /dev/null +++ b/src/main/java/com/mapconductor/core/marker/MarkerDrawOrderTracker.kt @@ -0,0 +1,95 @@ +package com.mapconductor.core.marker + +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberUpdatedState +import androidx.compose.runtime.snapshotFlow +import com.mapconductor.core.InternalMapConductorApi +import com.mapconductor.core.map.CameraBearing +import com.mapconductor.core.map.MapCameraPosition +import kotlin.time.Duration +import kotlin.time.Duration.Companion.milliseconds +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Job +import kotlinx.coroutines.delay +import kotlinx.coroutines.flow.collectLatest +import kotlinx.coroutines.launch + +/** + * 地図の向きに合わせてマーカーを並べ直してもらう側。 + * + * マーカーのコントローラが実装し、[com.mapconductor.core.controller.BaseMapViewController] + * が向きの変化を配る。 + */ +@InternalMapConductorApi +interface MarkerDrawOrderReceiver { + suspend fun onDrawOrderFrameChanged(frame: MarkerDrawOrder.Frame) +} + +/** + * カメラの向きを見て、[MarkerDrawOrder.Frame] が変わったら一度だけ知らせる。 + * + * 回している間は毎フレームのカメラが来るので、向きが [settle] のあいだ止まってから + * 知らせる(大量のマーカーを毎フレーム並べ直さない)。パンやズームでは前後関係が + * 変わらないので知らせない。 + */ +@InternalMapConductorApi +class MarkerDrawOrderTracker( + private val scope: CoroutineScope, + private val settle: Duration = 150.milliseconds, + private val onChanged: suspend (MarkerDrawOrder.Frame) -> Unit, +) { + /** 今マーカーを並べている向き。新しく足すマーカーもこれで並べる。 */ + @Volatile + var frame: MarkerDrawOrder.Frame = MarkerDrawOrder.Frame.NorthUp + private set + + private var target: MarkerDrawOrder.Frame = frame + private var pending: Job? = null + + fun onCameraChanged(camera: MapCameraPosition) { + val next = MarkerDrawOrder.Frame(CameraBearing.toNativeHeading(camera.bearing), camera.position.longitude) + synchronized(this) { + if (!next.differsEnoughFrom(target)) return + target = next + pending?.cancel() + pending = + scope.launch { + delay(settle) + frame = next + onChanged(next) + } + } + } +} + +/** + * Compose でマーカーを描くドライバー向けの [MarkerDrawOrderTracker]。 + * + * 後に置いたものほど上に描かれるので、`markers.sortedBy { MarkerDrawOrder.of(..., frame) }` + * の `frame` にこれを渡す。向きが変わって [settle] だけ止まったときだけ値が変わる + * (パン・ズームや回転の途中では組み直さない)。 + */ +@InternalMapConductorApi +@Composable +fun rememberMarkerDrawOrderFrame( + settle: Duration = 150.milliseconds, + camera: () -> MapCameraPosition, +): MarkerDrawOrder.Frame { + val frame = remember { mutableStateOf(MarkerDrawOrder.Frame.NorthUp) } + val latestCamera by rememberUpdatedState(camera) + LaunchedEffect(settle) { + snapshotFlow { + val c = latestCamera() + MarkerDrawOrder.Frame(CameraBearing.toNativeHeading(c.bearing), c.position.longitude) + }.collectLatest { next -> + if (!next.differsEnoughFrom(frame.value)) return@collectLatest + delay(settle) + frame.value = next + } + } + return frame.value +} diff --git a/src/main/java/com/mapconductor/core/marker/MarkerOverlayRendererInterface.kt b/src/main/java/com/mapconductor/core/marker/MarkerOverlayRendererInterface.kt index a4701dc..d74e387 100644 --- a/src/main/java/com/mapconductor/core/marker/MarkerOverlayRendererInterface.kt +++ b/src/main/java/com/mapconductor/core/marker/MarkerOverlayRendererInterface.kt @@ -51,4 +51,16 @@ interface MarkerOverlayRendererInterface { * ドラッグ層を持つプロバイダがここで層を描き直す。 */ fun onDragPositionChanged(position: GeoPointInterface) = Unit + + /** + * 地図が回って、同じ zIndex のマーカーを並べる向きが変わった。 + * + * [frame] を覚えておき、以後のマーカーも [MarkerDrawOrder] にこれを渡して並べる。 + * [entities] は今ある全マーカー。ネイティブの描く順を付け直す。**既定は何もしない** + * (北が上の順のまま)。 + */ + suspend fun onDrawOrderFrameChanged( + frame: MarkerDrawOrder.Frame, + entities: List>, + ) = Unit } diff --git a/src/main/java/com/mapconductor/core/marker/MarkerTileRenderer.kt b/src/main/java/com/mapconductor/core/marker/MarkerTileRenderer.kt index f664be5..d03abd0 100644 --- a/src/main/java/com/mapconductor/core/marker/MarkerTileRenderer.kt +++ b/src/main/java/com/mapconductor/core/marker/MarkerTileRenderer.kt @@ -430,7 +430,10 @@ class MarkerTileRenderer( } else { markerManager.findMarkersInBounds(extended) } - return found.filter { it.tiling } + // 後に描いたものが上に残る(間引きでも各マス目の最後が勝つ)。描く順を + // [MarkerDrawOrder] にそろえる: zIndex が大きいほど、同じなら南・西ほど上。 + // 索引の列挙順に任せると、ネイティブのマーカーと前後が食い違う。 + return found.filter { it.tiling }.sortedBy { MarkerDrawOrder.of(it.state.zIndex, it.state.position) } } // First query uses a conservative padding (in dp) so we capture markers slightly outside diff --git a/src/main/java/com/mapconductor/core/marker/StrategyMarkerController.kt b/src/main/java/com/mapconductor/core/marker/StrategyMarkerController.kt index e9ad09d..1f41182 100644 --- a/src/main/java/com/mapconductor/core/marker/StrategyMarkerController.kt +++ b/src/main/java/com/mapconductor/core/marker/StrategyMarkerController.kt @@ -19,7 +19,8 @@ class StrategyMarkerController( MarkerEntityInterface, >, OnCameraChangeReceiverInterface, - MarkerEventHostInterface { + MarkerEventHostInterface, + MarkerDrawOrderReceiver { override val markerManager: MarkerManager = strategy.markerManager override val zIndex: Int = 10 private var mapCameraPosition: MapCameraPosition? = null @@ -148,6 +149,10 @@ class StrategyMarkerController( add(pending) } + override suspend fun onDrawOrderFrameChanged(frame: MarkerDrawOrder.Frame) { + semaphore.withPermit { renderer.onDrawOrderFrameChanged(frame, markerManager.allEntities()) } + } + override fun destroy() { strategy.clear() } diff --git a/src/test/java/com/mapconductor/core/marker/MarkerDrawOrderTest.kt b/src/test/java/com/mapconductor/core/marker/MarkerDrawOrderTest.kt new file mode 100644 index 0000000..836f20b --- /dev/null +++ b/src/test/java/com/mapconductor/core/marker/MarkerDrawOrderTest.kt @@ -0,0 +1,131 @@ +package com.mapconductor.core.marker + +import com.mapconductor.core.InternalMapConductorApi +import com.mapconductor.core.features.GeoPoint +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test + +@OptIn(InternalMapConductorApi::class) +class MarkerDrawOrderTest { + private val tokyo = GeoPoint(35.7, 139.8, 0.0) + private val sydney = GeoPoint(-33.9, 151.2, 0.0) + + @Test + fun explicitZIndexBeatsUnspecifiedInBothHemispheres() { + for (point in listOf(tokyo, sydney, GeoPoint(-89.9, -179.9, 0.0), GeoPoint(89.9, 179.9, 0.0))) { + assertTrue(MarkerDrawOrder.of(1, point) > MarkerDrawOrder.of(null, point)) + assertTrue(MarkerDrawOrder.ofInt(1, point) > MarkerDrawOrder.ofInt(null, point)) + } + // 南半球の未指定でも、北の明示 1 を越えない。 + assertTrue(MarkerDrawOrder.of(1, tokyo) > MarkerDrawOrder.of(null, GeoPoint(-89.9, -179.9, 0.0))) + assertTrue(MarkerDrawOrder.ofInt(1, tokyo) > MarkerDrawOrder.ofInt(null, GeoPoint(-89.9, -179.9, 0.0))) + } + + @Test + fun zIndexIsPrimaryIncludingNegatives() { + assertTrue(MarkerDrawOrder.of(-1, sydney) < MarkerDrawOrder.of(0, tokyo)) + assertTrue(MarkerDrawOrder.of(2, tokyo) > MarkerDrawOrder.of(1, sydney)) + assertTrue(MarkerDrawOrder.ofInt(-1, sydney) < MarkerDrawOrder.ofInt(0, tokyo)) + } + + @Test + fun southThenWestBreakTies() { + val north = GeoPoint(35.7001, 139.8, 0.0) + val west = GeoPoint(35.7, 139.7999, 0.0) + assertTrue(MarkerDrawOrder.of(null, tokyo) > MarkerDrawOrder.of(null, north)) + assertTrue(MarkerDrawOrder.of(null, west) > MarkerDrawOrder.of(null, tokyo)) + assertTrue(MarkerDrawOrder.of(3, sydney) > MarkerDrawOrder.of(3, tokyo)) + // Float にしても数メートルの緯度差は残る(Google Maps は Float で受ける)。 + val tenMetersSouth = GeoPoint(35.7 - 0.0001, 139.8, 0.0) + assertTrue(MarkerDrawOrder.of(null, tenMetersSouth).toFloat() > MarkerDrawOrder.of(null, tokyo).toFloat()) + assertTrue(MarkerDrawOrder.ofInt(null, sydney) > MarkerDrawOrder.ofInt(null, tokyo)) + } + + @Test + fun tiebreakStaysBelowHalf() { + val extreme = GeoPoint(-90.0, -180.0, 0.0) + assertTrue(MarkerDrawOrder.of(0, extreme) < 0.5) + assertTrue(MarkerDrawOrder.of(0, GeoPoint(90.0, 180.0, 0.0)) >= 0.0) + } + + // ---- 地図の向き(heading)に合わせた並び ---- + + private val north = GeoPoint(35.71, 139.8, 0.0) + private val south = GeoPoint(35.69, 139.8, 0.0) + private val east = GeoPoint(35.7, 139.81, 0.0) + private val west = GeoPoint(35.7, 139.79, 0.0) + + private fun inFront( + a: GeoPoint, + b: GeoPoint, + heading: Double, + origin: Double = 139.8, + ): Boolean = MarkerDrawOrder.of(null, a, heading, origin) > MarkerDrawOrder.of(null, b, heading, origin) + + @Test + fun headingZeroKeepsNorthUpOrder() { + val points = listOf(tokyo, sydney, north, south, east, west, GeoPoint(60.0, -170.0, 0.0), GeoPoint(-10.0, 20.0, 0.0)) + for (a in points) { + for (b in points) { + if (a == b) continue + assertEquals( + "$a vs $b", + MarkerDrawOrder.of(null, a) > MarkerDrawOrder.of(null, b), + MarkerDrawOrder.of(null, a, 0.0, 0.0) > MarkerDrawOrder.of(null, b, 0.0, 0.0), + ) + } + } + } + + @Test + fun lowerOnScreenIsInFrontAtEveryHeading() { + // 0°: 南が画面の下。 + assertTrue(inFront(south, north, 0.0)) + assertTrue(inFront(west, east, 0.0)) + // 90°(画面の上が東): 西が画面の下。 + assertTrue(inFront(west, east, 90.0)) + // 同じ経度の南北は画面の同じ高さに並ぶ。左(北)が手前。 + assertTrue(inFront(north, south, 90.0)) + // 180°: 北が画面の下。 + assertTrue(inFront(north, south, 180.0)) + // 270°(画面の上が西): 東が画面の下。 + assertTrue(inFront(east, west, 270.0)) + assertTrue(inFront(south, north, 270.0)) + } + + @Test + fun zIndexDominatesAtEveryHeading() { + for (heading in listOf(0.0, 45.0, 90.0, 135.0, 180.0, 270.0, 359.0)) { + for (a in listOf(north, south, east, west, sydney)) { + for (b in listOf(north, south, east, west, sydney)) { + assertTrue(MarkerDrawOrder.of(1, a, heading, 139.8) > MarkerDrawOrder.of(null, b, heading, 139.8)) + assertTrue(MarkerDrawOrder.ofInt(1, a, heading, 139.8) > MarkerDrawOrder.ofInt(null, b, heading, 139.8)) + val v = MarkerDrawOrder.of(0, a, heading, 139.8) + assertTrue(v >= 0.0 && v < 0.5) + } + } + } + } + + @Test + fun antimeridianPairOrdersAcrossTheSeam() { + // 日付変更線の両側。179.99E は 179.99W の西隣。 + val westOfSeam = GeoPoint(0.0, 179.99, 0.0) + val eastOfSeam = GeoPoint(0.0, -179.99, 0.0) + // 90°(画面の上が東)では西が手前。 + assertTrue(inFront(westOfSeam, eastOfSeam, 90.0, origin = 180.0)) + assertTrue(inFront(eastOfSeam, westOfSeam, 270.0, origin = 180.0)) + } + + @Test + fun frameChangesOnlyOnBearingOrFarOrigin() { + val f = MarkerDrawOrder.Frame(10.0, 139.0) + assertFalse(MarkerDrawOrder.Frame(10.2, 150.0).differsEnoughFrom(f)) + assertTrue(MarkerDrawOrder.Frame(10.6, 139.0).differsEnoughFrom(f)) + assertTrue(MarkerDrawOrder.Frame(359.9, 139.0).differsEnoughFrom(MarkerDrawOrder.Frame(0.5, 139.0))) + assertFalse(MarkerDrawOrder.Frame(359.9, 139.0).differsEnoughFrom(MarkerDrawOrder.Frame(0.1, 139.0))) + assertTrue(MarkerDrawOrder.Frame(10.0, -100.0).differsEnoughFrom(f)) + } +}