feat: 全面迁移到 Flutter + 新增 GitHub 源与 CI 流水线
PR 审核 / 后端编译 (pull_request) Waiting to run
PR 审核 / 前端检查(Flutter) (pull_request) Waiting to run
PR 审核 / 安全扫描 (pull_request) Waiting to run

前端
- 移除全部 Avalonia 依赖,模型渲染与界面统一改用 Flutter
- 新增用户页:登录/注册(SHA-512 + 盐)、签到积分(30 天一循环)、
  主题色积分购买、二选一随机、今日人品
- 新增百宝箱页、模型内嵌渲染页、自绘标题栏(最小化/最大化/关闭)
- 下载页显示模型下载进度条,下载源读取加速
- 关于页新增「重新下载启动器」并在下载后做 sha256 完整性校验
- 修复浅色主题下标题栏不跟随主题色、无法连接后端等问题

后端
- 新增 UserService:.GC/user/<用户名>.yaml 存用户名/积分/SHA-512 口令,
  登录返回 session token,本地 .GC/user/user.yaml 保存登录态
- 新增 /api/user/{register,login,me,signin,theme} 接口
- 去掉 Avalonia 窗口宿主,后端只提供 HTTP API

下载源
- 新增 GitHub 镜像源(Morris-morris-cloud/GC),与 Xhmcl 并发测速
- 单源探测超时收紧到 2 秒,取最快且可用的源;GitHub 复用 GiteaRemote
  (contents 带 ref、releases 带 per_page=100)

构建与 CI
- macOS 上默认只出 macOS 包,Windows 交给原生 Windows 构建
- 修复 Windows 交叉编译中 flutter-cpp-client-wrapper 双层目录嵌套
- 新增 GitHub Actions:
  · nightly-prerelease:每天 21:00 编译三平台,发布 nightly 预发布
  · build-bot:Issue/PR 评论 @build-bot build <mac|win-amd|win-arm|all>,
    发布 ip-prerelease 预发布
  · pr-review:检查能否编译、静态分析、合并冲突、是否落后 main
- 忽略 79MB 课件产物等高线.html 与工具链临时备份
This commit is contained in:
Morris committed 2026-11-21 19:18:58 +08:00
1 parent b9cb56cb8b
commit ea1fa6b6d1
134 files changed
+4309 -16614

No files matched your search

@@ -1,29 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net8.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>disable</ImplicitUsings>
<RootNamespace>GC.EarthModels</RootNamespace>
<AssemblyName>EarthModelPreview</AssemblyName>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
</PropertyGroup>
<ItemGroup>
<!-- 直接编译共享引擎源码:封面必须由模型自己的渲染器画 -->
<Compile Include="../src/**/*.cs" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="Avalonia.Headless" Version="$(AvaloniaVersion)" />
<PackageReference Include="Avalonia.Skia" Version="$(AvaloniaVersion)" />
<!-- 通用封面路径会渲染模型自带的 UserControl,headless 下需要主题样式才会出内容 -->
<PackageReference Include="Avalonia.Themes.Fluent" Version="$(AvaloniaVersion)" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\_sdk\GC.ModelSdk\GC.ModelSdk.csproj" />
</ItemGroup>
</Project>
-292
View File
@@ -1,292 +0,0 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.Loader;
using Avalonia;
using Avalonia.Controls;
using Avalonia.Headless;
using Avalonia.Media.Imaging;
using Avalonia.Platform;
using GC.ModelSdk;
using GC.EarthModels;
namespace GC.EarthModels.Preview;
/// <summary>
/// 封面生成工具:给每个模型画一张 preview.png。
///
/// 两条路径:
/// 1) 通用路径(默认):按模型清单的 assembly + type 加载模型程序集,
/// 调它自己的 IModelRuntime.CreateView 做 headless 渲染 —— 任何新模型都能自动出封面。
/// 2) 地球模型路径:仍走共享引擎的 CelestialView(保留 --bench 基准测试能力)。
///
/// 封面在模型包里,启动器只负责显示。用法:
/// dotnet run --project model/_engine/PreviewGen -- &lt;仓库根&gt; [--bench]
/// </summary>
internal static class Program
{
private const int Width = 768;
private const int Height = 316;
/// <summary>headless 封面应用:带上 Fluent 主题,UserControl 才有模板可渲染。</summary>
private sealed class PreviewApp : Application
{
public override void Initialize()
{
Styles.Add(new Avalonia.Themes.Fluent.FluentTheme());
}
}
[STAThread]
public static int Main(string[] args)
{
var root = args.Length > 0 ? args[0] : Directory.GetCurrentDirectory();
var modelRoot = Path.Combine(root, "model");
if (!Directory.Exists(modelRoot))
{
Console.Error.WriteLine($"找不到模型库: {modelRoot}");
return 1;
}
var bench = args.Contains("--bench");
AppBuilder.Configure<PreviewApp>()
.UseSkia()
.UseHeadless(new AvaloniaHeadlessPlatformOptions { UseHeadlessDrawing = false })
.SetupWithoutStarting();
foreach (var modelDir in Directory.GetDirectories(modelRoot).OrderBy(p => p, StringComparer.Ordinal))
{
var id = Path.GetFileName(modelDir);
if (id.StartsWith('.') || id.StartsWith('_')) continue;
var dataDir = Path.Combine(modelDir, id + ".model");
if (!Directory.Exists(dataDir)) continue;
var outFile = Path.Combine(dataDir, "preview.png");
var hasScene = File.Exists(Path.Combine(dataDir, "scene.json"));
// 基准测试只对地球模型(依赖 CelestialView)
if (bench)
{
if (!hasScene) continue;
BenchEarthModel(dataDir, id);
continue;
}
var ok = false;
string? err = null;
if (hasScene)
ok = TryRenderEarthModel(dataDir, outFile, out err);
if (!ok)
ok = TryRenderViaContract(modelDir, dataDir, outFile, out err);
if (!ok)
Console.Error.WriteLine($"preview 跳过 {id}:{err}");
}
return 0;
}
// ─────────────────────────────────────────── 地球模型(保留原渲染器,封面一定是真场景)
private static bool TryRenderEarthModel(string dataDir, string outFile, out string? error)
{
error = null;
try
{
var runtime = SceneRuntime.Load(dataDir, 2048);
var texts = ModelStrings.Load(dataDir, "zh-CN");
var revolution = string.Equals(runtime.Scene.DefaultView, "revolution", StringComparison.OrdinalIgnoreCase);
var view = new CelestialView
{
Scene = runtime,
Texts = texts,
View = revolution ? SceneView.Revolution : SceneView.Rotation,
IsPlaying = false,
ShowHud = false,
ShowLabels = false,
ShowOrbit = true,
ShowGraticule = true,
Width = Width,
Height = Height
};
PrepareView(view, Width, Height);
view.JumpToOrbit(revolution ? 45 : 0);
view.JumpToSpin(20);
Save(view, outFile);
return true;
}
catch (Exception ex)
{
error = ex.Message;
return false;
}
}
private static void BenchEarthModel(string dataDir, string id)
{
var runtime = SceneRuntime.Load(dataDir, 2048);
var texts = ModelStrings.Load(dataDir, "zh-CN");
var revolution = string.Equals(runtime.Scene.DefaultView, "revolution", StringComparison.OrdinalIgnoreCase);
var view = new CelestialView
{
Scene = runtime,
Texts = texts,
View = revolution ? SceneView.Revolution : SceneView.Rotation,
IsPlaying = false,
ShowHud = false,
ShowLabels = false,
ShowOrbit = true,
ShowGraticule = true,
Width = Width,
Height = Height
};
PrepareView(view, Width, Height);
view.JumpToOrbit(revolution ? 45 : 0);
view.JumpToSpin(20);
view.Width = 1240;
view.Height = 820;
view.Measure(new Size(1240, 820));
view.Arrange(new Rect(0, 0, 1240, 820));
var animField = typeof(CelestialView)
.GetField("_animating", BindingFlags.NonPublic | BindingFlags.Instance);
var sw = System.Diagnostics.Stopwatch.StartNew();
for (var frame = 0; frame < 20; frame++)
{
view.JumpToSpin(20 + frame * 3);
using var tmp = new RenderTargetBitmap(new PixelSize(1240, 820), new Vector(96, 96));
tmp.Render(view);
}
sw.Stop();
var still = sw.Elapsed.TotalMilliseconds / 20;
animField?.SetValue(view, true);
sw.Restart();
for (var frame = 0; frame < 20; frame++)
{
view.JumpToSpin(20 + frame * 3);
using var tmp = new RenderTargetBitmap(new PixelSize(1240, 820), new Vector(96, 96));
tmp.Render(view);
}
sw.Stop();
Console.WriteLine($"{id}: 静止 {still:0.0} ms/frame · 播放 {sw.Elapsed.TotalMilliseconds / 20:0.0} ms/frame");
}
// ─────────────────────────────────────────── 通用路径:按契约加载模型自己的界面
private sealed class PreviewContext : IModelContext
{
public string ModelId { get; init; } = "";
public string ModelDirectory { get; init; } = "";
public string DataDirectory { get; init; } = "";
public string Language => "zh-CN";
public int MemoryBudgetMb => 512;
public void RequestClose() { }
public void ReportProgress(double value, string? message = null) { }
public void Log(string message) => Console.WriteLine(" " + message);
}
private static bool TryRenderViaContract(string modelDir, string dataDir, string outFile, out string? error)
{
error = null;
var manifestPath = Path.Combine(modelDir, Path.GetFileName(modelDir) + ".json");
if (!File.Exists(manifestPath)) { error = "缺少模型清单"; return false; }
try
{
using var doc = System.Text.Json.JsonDocument.Parse(File.ReadAllText(manifestPath));
var root = doc.RootElement;
var id = Path.GetFileName(modelDir);
var asmName = GetString(root, "assembly") ?? (id + ".dll");
var typeName = GetString(root, "type");
var asmPath = Path.Combine(dataDir, asmName);
if (!File.Exists(asmPath)) { error = $"找不到功能程序集 {asmName}"; return false; }
var alc = new AssemblyLoadContext("preview:" + id, isCollectible: true);
alc.Resolving += (_, name) =>
{
// 契约与 Avalonia 一律回到默认上下文,与启动器 ModelLoadContext 一致
if (name.Name is null) return null;
if (name.Name.StartsWith("System", StringComparison.OrdinalIgnoreCase)) return null;
var shared = new[] { "GC.ModelSdk", "Avalonia", "Avalonia.Base",
"Avalonia.Controls", "Avalonia.Skia", "Avalonia.Themes.Fluent", "SkiaSharp", "HarfBuzzSharp" };
if (shared.Contains(name.Name, StringComparer.OrdinalIgnoreCase)) return null;
var candidate = Path.Combine(dataDir, name.Name + ".dll");
return File.Exists(candidate) ? alc.LoadFromAssemblyPath(candidate) : null;
};
var asm = alc.LoadFromAssemblyPath(asmPath);
Type? factoryType = null;
if (!string.IsNullOrWhiteSpace(typeName))
factoryType = asm.GetType(typeName!, throwOnError: false);
factoryType ??= asm.GetTypes().FirstOrDefault(t =>
!t.IsAbstract && !t.IsInterface && typeof(IModelFactory).IsAssignableFrom(t));
if (factoryType == null) { error = "程序集里没有 IModelFactory 实现"; return false; }
if (Activator.CreateInstance(factoryType) is not IModelFactory factory)
{ error = "无法创建模型入口"; return false; }
var runtime = factory.Create();
var ctx = new PreviewContext
{
ModelId = id,
ModelDirectory = modelDir,
DataDirectory = dataDir
};
runtime.Prepare(ctx);
var view = runtime.CreateView(ctx);
if (view == null) { error = "模型没有返回界面"; return false; }
PrepareView(view, Width, Height);
Save(view, outFile);
runtime.Dispose();
(view as IDisposable)?.Dispose();
alc.Unload();
return true;
}
catch (Exception ex)
{
error = ex.ToString();
return false;
}
}
private static string? GetString(System.Text.Json.JsonElement e, string name)
=> e.TryGetProperty(name, out var v) && v.ValueKind == System.Text.Json.JsonValueKind.String
? v.GetString() : null;
// ─────────────────────────────────────────── 公共
private static void PrepareView(Control view, double w, double h)
{
// 封面是宽幅(768×316),模型界面按设计尺寸是 1240×820;这里把布局直接按封面
// 尺寸 Measure/Arrange,让卡片上看到的是完整布局而不是被裁掉一角。
view.Width = w;
view.Height = h;
view.Measure(new Size(w, h));
view.Arrange(new Rect(0, 0, w, h));
}
private static void Save(Control view, string outFile)
{
// headless 下 UserControl 必须挂进 Window 才有视觉树;直接 Render(Control)
// 会得到一张全黑的图(实测)。地球模型的裸 Control 走同一路径也正常工作。
var win = new Window
{
Width = Width,
Height = Height,
Background = Avalonia.Media.Brushes.White,
Content = view,
SystemDecorations = SystemDecorations.None,
ShowInTaskbar = false
};
win.Show();
using var bitmap = new RenderTargetBitmap(new PixelSize(Width, Height), new Vector(96, 96));
bitmap.Render(win);
bitmap.Save(outFile);
win.Content = null;
win.Close();
Console.WriteLine($"preview -> {outFile}");
}
}
File diff suppressed because it is too large. Load diff
-898
View File
@@ -1,898 +0,0 @@
using System;
using System.Collections.Generic;
using Avalonia;
using Avalonia.Animation;
using Avalonia.Animation.Easings;
using Avalonia.Controls;
using Avalonia.Controls.Primitives;
using Avalonia.Input;
using Avalonia.Layout;
using Avalonia.Media;
using Avalonia.Threading;
using GC.ModelSdk;
namespace GC.EarthModels;
/// <summary>
/// 模型自己的界面:画布 + 触控友好工具栏 + 课堂演示卡 + 节气定格与步进。
/// 启动器只负责下载、开窗口和进度条,不参与任何模型渲染或教学交互。
/// </summary>
public sealed class EarthModelView : UserControl, IDisposable
{
private static readonly IBrush PanelBg = new SolidColorBrush(Color.Parse("#C40A1020"));
private static readonly IBrush ControlBg = new SolidColorBrush(Color.Parse("#16233C"));
private static readonly IBrush Accent = new SolidColorBrush(Color.Parse("#2E6BE6"));
private static readonly IBrush TitleBrush = new SolidColorBrush(Color.Parse("#F2F6FF"));
private static readonly IBrush TextBrush = new SolidColorBrush(Color.Parse("#DCE7FA"));
private static readonly IBrush MutedBrush = new SolidColorBrush(Color.Parse("#7E93B8"));
private static readonly IBrush FaintBrush = new SolidColorBrush(Color.Parse("#61779C"));
private static readonly IBrush BodyBrush = new SolidColorBrush(Color.Parse("#8CA0C4"));
private static readonly IBrush WarmBrush = new SolidColorBrush(Color.Parse("#FFC46B"));
private static readonly TimeSpan HoverDuration = TimeSpan.FromMilliseconds(120);
private static readonly TimeSpan PanelDuration = TimeSpan.FromMilliseconds(190);
private readonly IModelContext _context;
private readonly ModelStrings _texts;
private readonly SceneRuntime _runtime;
private readonly List<string> _views;
private readonly List<ModelButton> _viewButtons = new();
private readonly CelestialView _canvas;
private readonly CelestialView _closeup;
private readonly DispatcherTimer _uiTimer;
private Border? _viewSwitch;
private StackPanel? _seasonPanel;
private Border? _lessons;
private Border? _closeupHost;
private TextBlock? _closeupLabel;
private ModelButton? _playButton;
private ModelButton? _overheadButton;
private TextBlock? _zoomText;
private TextBlock? _cardState;
private TextBlock? _cardTitle;
private TextBlock? _cardDate;
private TextBlock? _cardDirect;
private TextBlock? _cardNote;
private bool _playing = true;
private bool _labels = true;
private bool _orbit = true;
private bool _grid = true;
private bool _tilt;
private bool _showLessons = true;
private bool _showCloseup = true;
private bool _overhead;
private double _lastDeclination = double.NaN;
public EarthModelView(IModelContext context, SceneRuntime runtime)
{
_context = context;
_runtime = runtime;
_texts = ModelStrings.Load(context.DataDirectory, context.Language);
_views = ResolveViews(runtime.Scene);
// 自转模型主画布本身就是放大的地球,不需要再来一份特写
_showCloseup = IsRevolution;
Background = new SolidColorBrush(Color.Parse("#05070F"));
_canvas = new CelestialView
{
Scene = runtime,
Texts = _texts,
ShowLabels = true,
ShowOrbit = true,
ShowGraticule = true,
ShowKeyLatitudes = true,
FrameRate = 120,
View = IsRevolution ? SceneView.Revolution : SceneView.Rotation
};
_canvas.JumpToOrbit(StartAngle);
_canvas.JumpToSpin(20);
_canvas.ZoomChanged += zoom =>
{
if (_zoomText != null) _zoomText.Text = $"{zoom * 100:0}%";
};
// 课堂特写:同一套渲染器,把当前直射纬度放大给全班看
_closeup = new CelestialView
{
Scene = runtime,
Texts = _texts,
View = SceneView.Rotation,
IsPlaying = false,
ShowHud = false,
ShowLabels = true,
ShowGraticule = false,
ShowKeyLatitudes = true,
InsetMode = true,
Width = 240,
Height = 240
};
_closeup.JumpToSpin(20);
_uiTimer = new DispatcherTimer(TimeSpan.FromMilliseconds(140),
DispatcherPriority.Render, (_, _) => RefreshTeaching());
var root = new Grid { RowDefinitions = new RowDefinitions("Auto,Auto,*,Auto") };
var top = BuildTopBar();
root.Children.Add(top);
var options = BuildOptionsBar();
Grid.SetRow(options, 1);
root.Children.Add(options);
var stage = new Grid();
stage.Children.Add(_canvas);
stage.Children.Add(BuildZoomPad());
_lessons = BuildClassroomCard();
stage.Children.Add(_lessons);
Grid.SetRow(stage, 2);
root.Children.Add(stage);
var bottom = BuildBottomBar();
Grid.SetRow(bottom, 3);
root.Children.Add(bottom);
Content = root;
ApplyVisibility();
RefreshTeaching();
// 打开时整窗淡入,避免「啪」地出现
Opacity = 0;
Transitions = new Transitions
{
new DoubleTransition
{
Property = OpacityProperty,
Duration = TimeSpan.FromMilliseconds(260),
Easing = new CubicEaseOut()
}
};
AttachedToVisualTree += (_, _) =>
{
Opacity = 1;
_uiTimer.Start();
if (TopLevel.GetTopLevel(this) is Window window)
{
_hostWindow = window;
window.KeyDown += OnKeyDown;
}
};
DetachedFromVisualTree += (_, _) =>
{
_uiTimer.Stop();
if (_hostWindow != null)
{
_hostWindow.KeyDown -= OnKeyDown;
_hostWindow = null;
}
};
}
private Window? _hostWindow;
/// <summary>
/// 窗口关闭时释放计时器、解绑窗口事件并释放两块球面位图,
/// 否则 DispatcherTimer / KeyDown 会持有控件,使 collectible ALC 无法卸载。
/// </summary>
public void Dispose()
{
_uiTimer.Stop();
if (_hostWindow != null)
{
_hostWindow.KeyDown -= OnKeyDown;
_hostWindow = null;
}
_canvas.Dispose();
_closeup.Dispose();
System.GC.SuppressFinalize(this);
}
private string CurrentView { get; set; } = "rotation";
private double StartAngle => IsRevolution ? 60 : 0;
private bool IsRevolution => string.Equals(CurrentView, "revolution", StringComparison.OrdinalIgnoreCase);
private bool HasViewSwitch => _views.Count > 1;
private List<SeasonPoint> Seasons => _runtime.Scene.Orbit.Seasons;
private static string NormalizeView(string? view)
=> string.Equals(view, "revolution", StringComparison.OrdinalIgnoreCase) ? "revolution" : "rotation";
private List<string> ResolveViews(SceneDefinition scene)
{
var list = new List<string>();
foreach (var v in scene.Views)
{
var normalized = NormalizeView(v);
if (!list.Contains(normalized)) list.Add(normalized);
}
if (list.Count == 0) list.Add(NormalizeView(scene.DefaultView));
CurrentView = list[0];
return list;
}
// ---------------------------------------------------------------- 顶部主工具栏
private Control BuildTopBar()
{
// 关闭按钮统一放在窗口右上角的自建标题栏,这里不再重复放左上角
var title = new StackPanel { Spacing = 1, VerticalAlignment = VerticalAlignment.Center };
title.Children.Add(new TextBlock
{
Text = _texts.Pick(_runtime.Scene.NameI18n, _texts["title"]),
Foreground = TitleBrush,
FontSize = 14,
FontWeight = FontWeight.SemiBold
});
title.Children.Add(new TextBlock
{
Text = _texts.Pick(_runtime.Scene.DescriptionI18n, ""),
Foreground = MutedBrush,
FontSize = 10.5,
MaxWidth = 330,
TextTrimming = TextTrimming.CharacterEllipsis
});
var switchPanel = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 3 };
switchPanel.Children.Add(MakeViewButton("rotation", _texts["view.rotation"]));
switchPanel.Children.Add(MakeViewButton("revolution", _texts["view.revolution"]));
_viewSwitch = new Border
{
Background = ControlBg,
CornerRadius = new CornerRadius(10),
Padding = new Thickness(3),
Margin = new Thickness(16, 0, 0, 0),
VerticalAlignment = VerticalAlignment.Center,
Child = switchPanel
};
var actions = new StackPanel
{
Orientation = Orientation.Horizontal,
Spacing = 8,
VerticalAlignment = VerticalAlignment.Center
};
_playButton = MakeButton(_texts["pause"], TogglePlay);
_playButton.MinWidth = 74;
actions.Children.Add(_playButton);
actions.Children.Add(MakeButton(_texts["reset"], () =>
{
_canvas.ResetAnimation();
_canvas.JumpToOrbit(StartAngle);
RefreshTeaching();
}));
actions.Children.Add(MakeButton("◀", () => Step(-5), large: true));
actions.Children.Add(MakeButton("▶", () => Step(5), large: true));
actions.Children.Add(MakeButton(_texts["classroom"], () => SetLessonsVisible(!_showLessons)));
actions.Children.Add(MakeButton("⛶", ToggleFullScreen, large: true));
var grid = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto,*,Auto") };
Grid.SetColumn(title, 0);
title.Margin = new Thickness(14, 0, 0, 0);
grid.Children.Add(title);
Grid.SetColumn(_viewSwitch, 1);
grid.Children.Add(_viewSwitch);
Grid.SetColumn(actions, 3);
grid.Children.Add(actions);
return new Border { Background = PanelBg, Padding = new Thickness(16, 9), Child = grid };
}
// ---------------------------------------------------------------- 显示选项行
private Control BuildOptionsBar()
{
var row = new StackPanel
{
Orientation = Orientation.Horizontal,
Spacing = 7,
VerticalAlignment = VerticalAlignment.Center
};
row.Children.Add(MakeToggle(_texts["labels"], _labels, on => { _labels = on; _canvas.ShowLabels = on; }));
row.Children.Add(MakeToggle(_texts["orbit"], _orbit, on => { _orbit = on; _canvas.ShowOrbit = on; }));
row.Children.Add(MakeToggle(_texts["grid"], _grid, on => { _grid = on; _canvas.ShowGraticule = on; }));
row.Children.Add(MakeToggle(_texts["tilt"], _tilt, on => { _tilt = on; _canvas.ExaggerateTilt = on; }));
// 「放大」切换按钮已按需求移除;特写视图本身仍随公转显示
_overheadButton = MakeToggle(_texts["overhead"], _overhead, on =>
{
_overhead = on;
// 视角只由这个显式控件改变;拖动永远不会碰它
_canvas.CameraElevation = on ? (IsRevolution ? 74 : 62) : double.NaN;
});
row.Children.Add(_overheadButton);
var shortcut = new TextBlock
{
Text = _texts["shortcutHint"],
Foreground = FaintBrush,
FontSize = 10.5,
VerticalAlignment = VerticalAlignment.Center,
Margin = new Thickness(12, 0, 0, 0)
};
var grid = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,*") };
grid.Children.Add(row);
Grid.SetColumn(shortcut, 1);
grid.Children.Add(shortcut);
return new Border
{
Background = new SolidColorBrush(Color.Parse("#A00A1020")),
Padding = new Thickness(16, 7),
Child = grid
};
}
private ModelButton MakeViewButton(string view, string label)
{
var button = MakeButton(label, () => SwitchView(view));
button.SetBase(string.Equals(CurrentView, view, StringComparison.OrdinalIgnoreCase) ? Accent : ControlBg);
button.Tag = view;
button.IsVisible = _views.Contains(view);
_viewButtons.Add(button);
return button;
}
private ModelButton MakeToggle(string label, bool initial, Action<bool> changed)
{
var state = initial;
ModelButton? button = null;
button = MakeButton(label, () =>
{
state = !state;
changed(state);
button?.SetBase(state ? Accent : ControlBg);
});
button.SetBase(initial ? Accent : ControlBg);
return button;
}
private void SwitchView(string view)
{
CurrentView = NormalizeView(view);
_canvas.View = IsRevolution ? SceneView.Revolution : SceneView.Rotation;
_canvas.JumpToOrbit(StartAngle);
_canvas.CameraElevation = _overhead ? (IsRevolution ? 74 : 62) : double.NaN;
foreach (var button in _viewButtons)
button.SetBase(string.Equals(button.Tag as string, CurrentView, StringComparison.OrdinalIgnoreCase)
? Accent
: ControlBg);
ApplyVisibility();
RefreshTeaching();
}
// ---------------------------------------------------------------- 画布浮动缩放板(触控大按钮)
private Control BuildZoomPad()
{
var plus = MakeButton("+", () => _canvas.ZoomBy(1.25), large: true);
var minus = MakeButton("-", () => _canvas.ZoomBy(1 / 1.25), large: true);
var reset = MakeButton("⟲", () => _canvas.ResetView(), large: true);
foreach (var b in new[] { plus, minus, reset })
{
b.MinWidth = 62;
b.MinHeight = 48;
b.HorizontalAlignment = HorizontalAlignment.Stretch;
}
_zoomText = new TextBlock
{
Text = "100%",
Foreground = TextBrush,
FontSize = 13,
FontWeight = FontWeight.SemiBold,
TextAlignment = TextAlignment.Center,
Margin = new Thickness(0, 2, 0, 2)
};
var stack = new StackPanel { Spacing = 6, Width = 62 };
stack.Children.Add(new TextBlock
{
Text = _texts["zoom"],
Foreground = MutedBrush,
FontSize = 10.5,
TextAlignment = TextAlignment.Center
});
stack.Children.Add(plus);
stack.Children.Add(_zoomText);
stack.Children.Add(minus);
stack.Children.Add(reset);
return new Border
{
HorizontalAlignment = HorizontalAlignment.Left,
VerticalAlignment = VerticalAlignment.Bottom,
Margin = new Thickness(16, 0, 0, 16),
Background = new SolidColorBrush(Color.Parse("#C00B1226")),
BorderBrush = new SolidColorBrush(Color.Parse("#26374F")),
BorderThickness = new Thickness(1),
CornerRadius = new CornerRadius(14),
Padding = new Thickness(10),
Child = stack
};
}
// ---------------------------------------------------------------- 底部
private Control BuildBottomBar()
{
var speedLabel = new TextBlock
{
Text = _texts["speed"],
Foreground = new SolidColorBrush(Color.Parse("#9DB0D0")),
VerticalAlignment = VerticalAlignment.Center
};
var slider = new Slider
{
Minimum = 0.25,
Maximum = 4,
Value = 1,
Margin = new Thickness(12, 0, 0, 0),
Width = 180,
Height = 38
};
var speedText = new TextBlock
{
Text = "1×",
Foreground = TextBrush,
VerticalAlignment = VerticalAlignment.Center,
Width = 46,
Margin = new Thickness(6, 0, 0, 0)
};
slider.ValueChanged += (_, e) =>
{
_canvas.Speed = e.NewValue;
speedText.Text = $"{e.NewValue:0.##}×";
};
var hint = new TextBlock
{
Text = _texts["hint"],
Foreground = FaintBrush,
FontSize = 10.5,
VerticalAlignment = VerticalAlignment.Center,
Margin = new Thickness(20, 0, 0, 0),
TextTrimming = TextTrimming.CharacterEllipsis
};
_seasonPanel = new StackPanel
{
Orientation = Orientation.Horizontal,
Spacing = 7,
VerticalAlignment = VerticalAlignment.Center
};
_seasonPanel.Children.Add(new TextBlock
{
Text = _texts["seasons"],
Foreground = MutedBrush,
VerticalAlignment = VerticalAlignment.Center,
Margin = new Thickness(0, 0, 6, 0)
});
foreach (var season in Seasons) _seasonPanel.Children.Add(MakeSeasonButton(season));
var grid = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto,Auto,*,Auto") };
grid.Children.Add(speedLabel);
Grid.SetColumn(slider, 1);
grid.Children.Add(slider);
Grid.SetColumn(speedText, 2);
grid.Children.Add(speedText);
Grid.SetColumn(hint, 3);
grid.Children.Add(hint);
Grid.SetColumn(_seasonPanel, 4);
grid.Children.Add(_seasonPanel);
return new Border { Background = PanelBg, Padding = new Thickness(16, 8), Child = grid };
}
private ModelButton MakeSeasonButton(SeasonPoint season)
{
var captured = season;
var button = MakeButton(_texts[season.Key], () => JumpToSeason(captured));
button.MinHeight = 44;
return button;
}
// ---------------------------------------------------------------- 课堂演示卡
private Border BuildClassroomCard()
{
var header = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto") };
header.Children.Add(new TextBlock
{
Text = _texts["classroom"],
Foreground = TitleBrush,
FontWeight = FontWeight.SemiBold,
FontSize = 13,
VerticalAlignment = VerticalAlignment.Center
});
var close = MakeButton("✕", () => SetLessonsVisible(false));
close.SetBase(Brushes.Transparent);
Grid.SetColumn(close, 1);
header.Children.Add(close);
_cardState = new TextBlock
{
Text = _texts["running"],
Foreground = MutedBrush,
FontSize = 11,
Margin = new Thickness(0, 6, 0, 0)
};
_cardTitle = new TextBlock
{
Foreground = TitleBrush,
FontSize = 20,
FontWeight = FontWeight.Bold
};
_cardDate = new TextBlock { Foreground = MutedBrush, FontSize = 12 };
_cardDirect = new TextBlock
{
Foreground = WarmBrush,
FontSize = 27,
FontWeight = FontWeight.Bold
};
_cardNote = new TextBlock
{
Foreground = BodyBrush,
FontSize = 12,
TextWrapping = TextWrapping.Wrap,
LineHeight = 18
};
_closeupHost = new Border
{
CornerRadius = new CornerRadius(10),
BorderBrush = new SolidColorBrush(Color.Parse("#26374F")),
BorderThickness = new Thickness(1),
HorizontalAlignment = HorizontalAlignment.Center,
Margin = new Thickness(0, 4, 0, 2),
Child = _closeup
};
var readouts = new StackPanel { Spacing = 2 };
readouts.Children.Add(_cardState);
readouts.Children.Add(_cardTitle);
readouts.Children.Add(_cardDate);
readouts.Children.Add(new TextBlock
{
Text = _texts["directPoint"],
Foreground = MutedBrush,
FontSize = 11,
Margin = new Thickness(0, 8, 0, 0)
});
readouts.Children.Add(_cardDirect);
readouts.Children.Add(_cardNote);
_closeupLabel = new TextBlock
{
Text = _texts["closeup"],
Foreground = MutedBrush,
FontSize = 11,
Margin = new Thickness(0, 6, 0, 0)
};
readouts.Children.Add(_closeupLabel);
readouts.Children.Add(_closeupHost);
var list = new StackPanel { Spacing = 2 };
foreach (var lesson in _runtime.Scene.Lessons)
{
var title = new TextBlock
{
Text = _texts.Pick(lesson.TitleI18n, ""),
Foreground = new SolidColorBrush(Color.Parse("#CFE0FF")),
FontSize = 12,
FontWeight = FontWeight.SemiBold,
TextWrapping = TextWrapping.Wrap
};
var body = new TextBlock
{
Text = _texts.Pick(lesson.BodyI18n, ""),
Foreground = BodyBrush,
FontSize = 11,
TextWrapping = TextWrapping.Wrap
};
var stack = new StackPanel { Spacing = 3 };
stack.Children.Add(title);
stack.Children.Add(body);
var button = new Button
{
Content = stack,
Background = Brushes.Transparent,
BorderThickness = new Thickness(0),
HorizontalAlignment = HorizontalAlignment.Stretch,
HorizontalContentAlignment = HorizontalAlignment.Left,
Padding = new Thickness(8, 9),
Margin = new Thickness(0, 1),
MinHeight = 44,
Cursor = new Cursor(StandardCursorType.Hand),
Transitions = new Transitions
{
new BrushTransition { Property = BackgroundProperty, Duration = HoverDuration }
}
};
var captured = lesson;
button.Click += (_, _) => ApplyLesson(captured);
button.PointerEntered += (_, _) => button.Background = new SolidColorBrush(Color.Parse("#1B2A47"));
button.PointerExited += (_, _) => button.Background = Brushes.Transparent;
list.Children.Add(button);
}
var content = new StackPanel { Spacing = 8 };
content.Children.Add(readouts);
content.Children.Add(new TextBlock
{
Text = _texts["lessons"],
Foreground = TitleBrush,
FontWeight = FontWeight.SemiBold,
FontSize = 12.5
});
content.Children.Add(list);
var bodyGrid = new Grid { RowDefinitions = new RowDefinitions("Auto,*") };
bodyGrid.Children.Add(header);
var scroller = new ScrollViewer
{
Content = content,
VerticalScrollBarVisibility = ScrollBarVisibility.Auto,
Margin = new Thickness(0, 8, 0, 0)
};
Grid.SetRow(scroller, 1);
bodyGrid.Children.Add(scroller);
var panel = new Border
{
HorizontalAlignment = HorizontalAlignment.Right,
VerticalAlignment = VerticalAlignment.Stretch,
Width = 296,
Margin = new Thickness(0, 12, 16, 12),
Background = new SolidColorBrush(Color.Parse("#D00B1226")),
CornerRadius = new CornerRadius(14),
Padding = new Thickness(13),
BorderBrush = new SolidColorBrush(Color.Parse("#26374F")),
BorderThickness = new Thickness(1),
Child = bodyGrid,
RenderTransform = new TranslateTransform(0, 0)
};
panel.Transitions = new Transitions
{
new DoubleTransition { Property = OpacityProperty, Duration = PanelDuration, Easing = new CubicEaseOut() },
new DoubleTransition
{
Property = TranslateTransform.XProperty,
Duration = PanelDuration,
Easing = new CubicEaseOut()
}
};
return panel;
}
private void SetLessonsVisible(bool visible)
{
_showLessons = visible;
if (_lessons == null) return;
if (visible)
{
_lessons.IsVisible = true;
_lessons.Opacity = 1;
if (_lessons.RenderTransform is TranslateTransform transform) transform.X = 0;
return;
}
_lessons.Opacity = 0;
if (_lessons.RenderTransform is TranslateTransform hidden) hidden.X = 26;
var timer = new DispatcherTimer { Interval = PanelDuration };
timer.Tick += (_, _) =>
{
timer.Stop();
if (!_showLessons && _lessons != null) _lessons.IsVisible = false;
};
timer.Start();
}
/// <summary>课堂卡与地球特写跟随当前轨道位置刷新(播放时每 140ms 更新一次)。</summary>
private void RefreshTeaching()
{
if (_cardTitle == null) return;
var season = IsRevolution ? _canvas.NearestSeason(6) : null;
var decl = _canvas.SubsolarLatitude;
_cardState!.Text = _playing ? _texts["running"] : _texts["frozen"];
_cardState.Foreground = _playing ? MutedBrush : WarmBrush;
_cardTitle.Text = season != null
? _texts[season.Key]
: (IsRevolution ? _texts["seasons"] : _texts.Pick(_runtime.Scene.NameI18n, _texts["title"]));
_cardDate!.Text = IsRevolution ? _canvas.CurrentDate : _texts["dayNight"];
_cardDirect!.Text = season?.DeclinationDeg.HasValue == true
? FormatDeclination(season.DeclinationDeg.Value)
: _canvas.DeclinationLabel;
_cardNote!.Text = !IsRevolution
? _texts["rotationTeach"]
: season != null
? _texts.Pick(season.TeachingI18n, _texts["orbitTeach"])
: _texts["orbitTeach"];
// 特写的直射纬度用缓动逼近目标,而不是瞬间跳变:
// 公转时拖动/改变轨道角,晨昏线会平滑地移过去(每次 timer 步进一帧)。
if (_showCloseup)
{
var target = decl;
var current = _closeup.DeclinationDeg;
var diff = target - current;
if (Math.Abs(diff) < 0.02)
{
_closeup.DeclinationDeg = target;
}
else
{
// 每 140ms 走剩余距离的 ~18%,形成自然的 ease-out 动画
_closeup.DeclinationDeg = current + diff * 0.18;
}
_lastDeclination = target;
}
}
private string FormatDeclination(double d)
=> Math.Abs(d) < 0.05
? "0° " + _texts["lat.equator"]
: $"{Math.Abs(d):0.0}°" + (d > 0 ? _texts["northShort"] : _texts["southShort"]);
private void ApplyLesson(Lesson lesson)
{
if (!string.IsNullOrWhiteSpace(lesson.View))
{
var view = NormalizeView(lesson.View);
if (!string.Equals(view, CurrentView, StringComparison.OrdinalIgnoreCase)) SwitchView(view);
}
// 讲要点时自动定格,读数不再跳动,方便指读板书
SetPlaying(false);
if (lesson.AngleDeg.HasValue) _canvas.JumpToOrbit(lesson.AngleDeg.Value);
RefreshTeaching();
}
// ---------------------------------------------------------------- 教学操作
private void SetPlaying(bool play)
{
_playing = play;
_canvas.IsPlaying = play;
if (_playButton?.Content is TextBlock block)
block.Text = play ? _texts["pause"] : _texts["play"];
RefreshTeaching();
}
private void TogglePlay() => SetPlaying(!_playing);
private void Step(double deltaDeg)
{
SetPlaying(false);
if (IsRevolution) _canvas.StepOrbit(deltaDeg);
else _canvas.StepSpin(deltaDeg);
RefreshTeaching();
}
private void JumpToSeason(SeasonPoint season)
{
if (!IsRevolution) SwitchView("revolution");
SetPlaying(false);
_canvas.JumpToOrbit(season.AngleDeg);
RefreshTeaching();
}
private void JumpToSeasonIndex(int index)
{
if (index < 0 || index >= Seasons.Count) return;
JumpToSeason(Seasons[index]);
}
private void ToggleFullScreen()
{
try
{
if (TopLevel.GetTopLevel(this) is Window window)
window.WindowState = window.WindowState == WindowState.FullScreen
? WindowState.Normal
: WindowState.FullScreen;
}
catch (Exception ex)
{
_context.Log("全屏切换失败: " + ex.Message);
}
}
private void OnKeyDown(object? sender, KeyEventArgs e)
{
switch (e.Key)
{
case Key.Space:
TogglePlay();
e.Handled = true;
break;
case Key.Left:
Step(-5);
e.Handled = true;
break;
case Key.Right:
Step(5);
e.Handled = true;
break;
case Key.D1: JumpToSeasonIndex(0); e.Handled = true; break;
case Key.D2: JumpToSeasonIndex(1); e.Handled = true; break;
case Key.D3: JumpToSeasonIndex(2); e.Handled = true; break;
case Key.D4: JumpToSeasonIndex(3); e.Handled = true; break;
case Key.F: ToggleFullScreen(); e.Handled = true; break;
case Key.Add: _canvas.ZoomBy(1.25); e.Handled = true; break;
case Key.Subtract: _canvas.ZoomBy(1 / 1.25); e.Handled = true; break;
case Key.D0: _canvas.ResetView(); e.Handled = true; break;
}
}
// ---------------------------------------------------------------- 工具
private ModelButton MakeButton(string text, Action onClick, bool large = false)
{
var button = new ModelButton
{
Content = new TextBlock { Text = text, FontSize = large ? 20 : 12.5 },
Foreground = TextBrush,
BorderThickness = new Thickness(0),
CornerRadius = new CornerRadius(9),
Padding = large ? new Thickness(10, 8) : new Thickness(13, 9),
MinWidth = large ? 46 : 44,
MinHeight = 40,
HorizontalContentAlignment = HorizontalAlignment.Center,
VerticalAlignment = VerticalAlignment.Center,
Cursor = new Cursor(StandardCursorType.Hand)
};
button.SetBase(ControlBg);
button.Click += (_, _) => onClick();
return button;
}
private void ApplyVisibility()
{
if (_viewSwitch != null) _viewSwitch.IsVisible = HasViewSwitch;
if (_lessons != null) _lessons.IsVisible = _showLessons;
if (_seasonPanel != null) _seasonPanel.IsVisible = IsRevolution;
if (_closeupHost != null) _closeupHost.IsVisible = _showCloseup;
if (_closeupLabel != null) _closeupLabel.IsVisible = _showCloseup;
}
/// <summary>带悬停过渡的按钮:本地基础色 + 悬停提亮。</summary>
private sealed class ModelButton : Button
{
private IBrush _base = ControlBg;
private IBrush _hover = ControlBg;
public ModelButton()
{
Transitions = new Transitions
{
new BrushTransition { Property = BackgroundProperty, Duration = HoverDuration }
};
}
public void SetBase(IBrush brush)
{
_base = brush;
_hover = Lighten(brush);
Background = brush;
}
protected override void OnPointerEntered(PointerEventArgs e)
{
base.OnPointerEntered(e);
Background = _hover;
}
protected override void OnPointerExited(PointerEventArgs e)
{
base.OnPointerExited(e);
Background = _base;
}
private static IBrush Lighten(IBrush brush)
{
if (brush is not SolidColorBrush solid) return brush;
var c = solid.Color;
return new SolidColorBrush(Color.FromArgb(c.A,
(byte)Math.Min(255, c.R + 26),
(byte)Math.Min(255, c.G + 26),
(byte)Math.Min(255, c.B + 30)));
}
}
}
-45
View File
@@ -1,45 +0,0 @@
using System;
using Avalonia.Controls;
using GC.ModelSdk;
namespace GC.EarthModels;
/// <summary>
/// 地球模型共享运行时:读自己目录下的 scene.json / land.json / i18n,
/// 然后把自带界面交给启动器。启动器完全不知道“地球”“节气”这些东西。
/// </summary>
public sealed class EarthModelRuntime : IModelRuntime
{
public const int SupportedApiVersion = 1;
private SceneRuntime? _scene;
/// <summary>后台准备:读场景、生成地表纹理(耗时都花在这里,进度条能实时走)。</summary>
public void Prepare(IModelContext context)
{
context.ReportProgress(0.03, "读取场景数据");
_scene = SceneRuntime.Load(context.DataDirectory, context.MemoryBudgetMb, context.ReportProgress);
context.Log($"[{context.ModelId}] 场景已加载:{_scene.Scene.DefaultView}," +
$"地表纹理 {(_scene.Texture == null ? "无" : _scene.Texture.Width + "×" + _scene.Texture.Height)}");
}
/// <summary>UI 线程构建界面(很快)。</summary>
public Control CreateView(IModelContext context)
{
context.ReportProgress(0.78, "构建界面");
_scene ??= SceneRuntime.Load(context.DataDirectory, context.MemoryBudgetMb, context.ReportProgress);
var view = new EarthModelView(context, _scene);
context.ReportProgress(1.0, "准备就绪");
return view;
}
/// <summary>
/// 释放预烘焙纹理(约 3MB 托管数组)与场景引用。窗口关闭时由启动器调用,
/// 避免 collectible ALC 里的类型被长生命周期引用拖住而无法卸载。
/// </summary>
public void Dispose()
{
_scene = null;
System.GC.SuppressFinalize(this);
}
}
-132
View File
@@ -1,132 +0,0 @@
using System;
using System.Collections.Generic;
using System.Numerics;
namespace GC.EarthModels;
/// <summary>
/// 地理模型的球面几何工具:经纬度 ↔ 单位球坐标、正交投影到屏幕、
/// 以及把一条经纬度折线投影成「可见弧段」(背面自动裁掉)。
/// 纯 CPU、无依赖,供 GeographyView 画线稿用。
/// </summary>
public static class Geometry
{
public const float DegToRad = (float)(Math.PI / 180.0);
public const float RadToDeg = (float)(180.0 / Math.PI);
/// <summary>经纬度 → 单位球坐标(y 轴为地轴,lon 向东为正)。</summary>
public static Vector3 LatLonToUnit(double latDeg, double lonDeg)
{
var lat = (float)(latDeg * Math.PI / 180.0);
var lon = (float)(lonDeg * Math.PI / 180.0);
var cosLat = (float)Math.Cos(lat);
return new Vector3(cosLat * (float)Math.Sin(lon), (float)Math.Sin(lat), cosLat * (float)Math.Cos(lon));
}
/// <summary>把世界坐标旋转到相机空间(先用 planet 旋转地球,再用 cam 转到屏幕)。</summary>
public static Vector3 ToCamera(Vector3 world, Matrix4x4 planet, Matrix4x4 cam)
=> Vector3.Transform(Vector3.Transform(world, planet), cam);
/// <summary>相机空间的正交投影:球心在原点,半径 radius。</summary>
public static Vector2 Project(Vector3 camPos, float radius, float centerX, float centerY)
=> new(centerX + camPos.X * radius, centerY - camPos.Y * radius);
/// <summary>相机空间里该点是否朝向观察者(z>0 为正面)。</summary>
public static bool IsVisible(Vector3 camPos, float threshold = 0f) => camPos.Z > threshold;
/// <summary>
/// 把一条经纬度折线拆成若干段「可见」的屏幕折线。
/// 跨越地平线的相邻两点用线性插值求出交点作为端点,保证线不会穿过球体背面。
/// </summary>
public static List<List<Vector2>> ProjectPolyline(
IReadOnlyList<double[]> latLonPoints,
Matrix4x4 planet, Matrix4x4 cam,
float radius, float centerX, float centerY,
bool closed = false)
{
// 兼容旧调用:按需转换(点位少的分支,如洲界)
var unit = new Vector3[latLonPoints.Count];
for (var i = 0; i < latLonPoints.Count; i++)
{
var p = latLonPoints[i];
unit[i] = p.Length >= 2 ? LatLonToUnit(p[1], p[0]) : Vector3.Zero;
}
var valid = new bool[unit.Length];
for (var i = 0; i < latLonPoints.Count; i++) valid[i] = latLonPoints[i].Length >= 2;
return ProjectUnitPolyline(unit, valid, planet, cam, radius, centerX, centerY, closed);
}
/// <summary>
/// 预计算单位球坐标后的快速投影:每帧只做矩阵乘 + 正交投影,
/// 不再重复计算 sin/cos(地理模型约 2.6 万个点,这是最大开销)。
/// </summary>
public static List<List<Vector2>> ProjectUnitPolyline(
IReadOnlyList<Vector3> unitPoints,
IReadOnlyList<bool> valid,
Matrix4x4 planet, Matrix4x4 cam,
float radius, float centerX, float centerY,
bool closed = false)
{
var result = new List<List<Vector2>>();
if (unitPoints.Count < 2) return result;
var count = unitPoints.Count;
var total = closed ? count + 1 : count;
List<Vector2>? current = null;
Vector3 prevCam = default;
var havePrev = false;
for (var i = 0; i < total; i++)
{
var k = i % count;
if (!valid[k]) { havePrev = false; continue; }
var camPos = Vector3.Transform(Vector3.Transform(unitPoints[k], planet), cam);
var visible = camPos.Z > 0f;
if (!havePrev)
{
if (visible)
{
current = new List<Vector2> { Project(camPos, radius, centerX, centerY) };
}
prevCam = camPos;
havePrev = true;
continue;
}
var prevVisible = prevCam.Z > 0f;
if (visible && prevVisible)
{
current ??= new List<Vector2>();
current.Add(Project(camPos, radius, centerX, centerY));
}
else if (visible != prevVisible)
{
// 求出与地平线(z=0)的交点
var t = prevCam.Z / (prevCam.Z - camPos.Z);
var hit = Vector3.Lerp(prevCam, camPos, t);
hit.Z = 0f;
var hitScreen = Project(hit, radius, centerX, centerY);
if (visible)
{
current = new List<Vector2> { hitScreen };
current.Add(Project(camPos, radius, centerX, centerY));
}
else
{
current?.Add(hitScreen);
if (current is { Count: > 1 }) result.Add(current);
current = null;
}
}
prevCam = camPos;
}
if (current is { Count: > 1 }) result.Add(current);
return result;
}
}
-159
View File
@@ -1,159 +0,0 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Text.Json;
using System.Text.Json.Serialization;
namespace GC.EarthModels;
/// <summary>&lt;id&gt;.model/land.json —— 简化的大陆轮廓(经纬度多边形)。</summary>
public sealed class LandData
{
[JsonPropertyName("polygons")] public List<LandPolygon> Polygons { get; set; } = new();
public static LandData? Load(string path)
{
if (!File.Exists(path)) return null;
try
{
return JsonSerializer.Deserialize<LandData>(File.ReadAllText(path), ModelJson.Options);
}
catch (Exception ex)
{
Console.Error.WriteLine($"解析地表数据失败 {path}: {ex.Message}");
return null;
}
}
}
public sealed class LandPolygon
{
[JsonPropertyName("name")] public string? Name { get; set; }
/// <summary>[[lon, lat], ...]</summary>
[JsonPropertyName("points")] public List<double[]> Points { get; set; } = new();
}
/// <summary>
/// 等经纬度栅格地表掩膜(0=海洋 255=陆地),双线性采样。
/// 每个模型只生成一次,受内存预算约束。
/// </summary>
public sealed class LandMask
{
public int Width { get; init; }
public int Height { get; init; }
public byte[] Bits { get; init; } = Array.Empty<byte>();
public long ByteSize => Bits.LongLength;
public static LandMask Build(LandData data, int width = 1440, int height = 720)
{
var bits = new byte[width * height];
foreach (var poly in data.Polygons)
{
if (poly.Points.Count < 3) continue;
var pts = Unwrap(poly.Points);
if (pts.Count < 3) continue;
for (var shift = -1; shift <= 1; shift++)
Rasterize(bits, width, height, pts, shift * 360.0);
}
return new LandMask { Width = width, Height = height, Bits = bits };
}
private static List<(double Lon, double Lat)> Unwrap(List<double[]> points)
{
var result = new List<(double, double)>(points.Count);
if (points.Count == 0 || points[0].Length < 2) return result;
var prev = points[0][0];
result.Add((prev, points[0][1]));
for (var i = 1; i < points.Count; i++)
{
if (points[i].Length < 2) continue;
var lon = points[i][0];
while (lon - prev > 180) lon -= 360;
while (prev - lon > 180) lon += 360;
result.Add((lon, points[i][1]));
prev = lon;
}
return result;
}
private static void Rasterize(byte[] bits, int w, int h, List<(double Lon, double Lat)> pts, double lonShift)
{
var n = pts.Count;
var xs = new double[n];
var ys = new double[n];
double minY = double.MaxValue, maxY = double.MinValue;
for (var i = 0; i < n; i++)
{
xs[i] = (pts[i].Lon + lonShift + 180.0) / 360.0 * w;
ys[i] = (90.0 - pts[i].Lat) / 180.0 * h;
if (ys[i] < minY) minY = ys[i];
if (ys[i] > maxY) maxY = ys[i];
}
var y0 = Math.Max(0, (int)Math.Floor(minY));
var y1 = Math.Min(h - 1, (int)Math.Ceiling(maxY));
var crossings = new List<double>(16);
for (var y = y0; y <= y1; y++)
{
var sy = y + 0.5;
crossings.Clear();
for (var i = 0; i < n; i++)
{
var j = (i + 1) % n;
double ya = ys[i], yb = ys[j];
if (!((ya <= sy && yb > sy) || (yb <= sy && ya > sy))) continue;
var t = (sy - ya) / (yb - ya);
crossings.Add(xs[i] + t * (xs[j] - xs[i]));
}
if (crossings.Count < 2) continue;
crossings.Sort();
for (var k = 0; k + 1 < crossings.Count; k += 2)
{
var xa = (int)Math.Ceiling(crossings[k] - 0.5);
var xb = (int)Math.Floor(crossings[k + 1] - 0.5);
if (xb < xa) continue;
if (xb - xa >= w - 1)
{
for (var x = 0; x < w; x++) bits[y * w + x] = 255;
continue;
}
for (var x = xa; x <= xb; x++)
{
var mx = x % w;
if (mx < 0) mx += w;
bits[y * w + mx] = 255;
}
}
}
}
/// <summary>返回 0..1 的陆地覆盖度。</summary>
public double Sample(double lonDeg, double latDeg)
{
var u = (lonDeg + 180.0) / 360.0 * Width - 0.5;
var v = (90.0 - latDeg) / 180.0 * Height - 0.5;
var x0 = (int)Math.Floor(u);
var y0 = (int)Math.Floor(v);
var fx = u - x0;
var fy = v - y0;
double sum = 0;
for (var dy = 0; dy < 2; dy++)
{
var y = y0 + dy;
if (y < 0) y = 0;
if (y >= Height) y = Height - 1;
var wy = dy == 0 ? 1 - fy : fy;
for (var dx = 0; dx < 2; dx++)
{
var x = x0 + dx;
var mx = x % Width;
if (mx < 0) mx += Width;
var wx = dx == 0 ? 1 - fx : fx;
sum += Bits[y * Width + mx] * wx * wy;
}
}
return sum / 255.0;
}
}
-27
View File
@@ -1,27 +0,0 @@
using System.IO;
using System.Text.Encodings.Web;
using System.Text.Json;
using System.Text.Json.Serialization;
namespace GC.EarthModels;
/// <summary>模型自己的 JSON 读写(不依赖启动器)。</summary>
public static class ModelJson
{
public static readonly JsonSerializerOptions Options = new()
{
PropertyNameCaseInsensitive = true,
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
WriteIndented = true,
Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
AllowTrailingCommas = true,
ReadCommentHandling = JsonCommentHandling.Skip
};
public static T? Read<T>(string path)
{
if (!File.Exists(path)) return default;
return JsonSerializer.Deserialize<T>(File.ReadAllText(path), Options);
}
}
-186
View File
@@ -1,186 +0,0 @@
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Text.Json;
namespace GC.EarthModels;
/// <summary>
/// 模型自己的一份文案。优先读模型数据目录里的 <c>i18n/&lt;language&gt;.json</c>,
/// 缺失时回退到代码内的默认文案,保证模型在没有语言包时也能完整显示。
/// 启动器不再持有任何模型相关文案。
/// </summary>
public sealed class ModelStrings
{
private readonly Dictionary<string, string> _texts;
public string Language { get; }
private ModelStrings(string language, Dictionary<string, string> texts)
{
Language = language;
_texts = texts;
}
public static ModelStrings Default { get; } = new("zh-CN", DefaultTexts.Zh);
public string this[string key]
=> _texts.TryGetValue(key, out var value) ? value
: DefaultTexts.Zh.TryGetValue(key, out var fallback) ? fallback
: key;
public string F(string key, params object[] args)
=> string.Format(CultureInfo.InvariantCulture, this[key], args);
public string Pick(Dictionary<string, string>? i18n, string fallback)
{
if (i18n == null) return fallback;
if (i18n.TryGetValue(Language, out var exact) && !string.IsNullOrWhiteSpace(exact)) return exact;
foreach (var pair in i18n)
{
if (Language.StartsWith(pair.Key, StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(pair.Value))
return pair.Value;
}
if (i18n.TryGetValue("zh-CN", out var zh) && !string.IsNullOrWhiteSpace(zh)) return zh;
return fallback;
}
public static ModelStrings Load(string dataDirectory, string language)
{
var zh = new Dictionary<string, string>(DefaultTexts.Zh);
var isEnglish = language.StartsWith("en", StringComparison.OrdinalIgnoreCase);
var chosen = isEnglish ? new Dictionary<string, string>(DefaultTexts.En) : new Dictionary<string, string>(zh);
// 语言包可以覆盖任意键:i18n/<language>.json
var dir = Path.Combine(dataDirectory, "i18n");
Overlay(Path.Combine(dir, language + ".json"), chosen);
if (!isEnglish) Overlay(Path.Combine(dir, "zh-CN.json"), chosen);
return new ModelStrings(isEnglish ? "en" : "zh-CN", chosen);
}
private static void Overlay(string path, Dictionary<string, string> target)
{
if (!File.Exists(path)) return;
try
{
var map = JsonSerializer.Deserialize<Dictionary<string, string>>(File.ReadAllText(path), ModelJson.Options);
if (map == null) return;
foreach (var pair in map) target[pair.Key] = pair.Value;
}
catch (Exception ex)
{
Console.Error.WriteLine($"读取模型语言包失败 {path}: {ex.Message}");
}
}
}
internal static class DefaultTexts
{
public static readonly Dictionary<string, string> Zh = new()
{
["title"] = "地球模型",
["view.rotation"] = "自转",
["view.revolution"] = "公转",
["play"] = "播放",
["pause"] = "暂停",
["speed"] = "速度",
["reset"] = "重置",
["labels"] = "标注",
["orbit"] = "轨道",
["grid"] = "经纬网",
["tilt"] = "夸张倾角",
["lessons"] = "教学要点",
["seasons"] = "节气定位",
["close"] = "关闭窗口",
["hint"] = "双指捏合或滚轮缩放 · 拖动可转动地球",
["shortcutHint"] = "空格 播放/暂停 · ←→ 步进 · 1–4 二分二至 · F 全屏",
["classroom"] = "课堂演示",
["directPoint"] = "太阳直射",
["frozen"] = "已定格",
["running"] = "播放中",
["step"] = "步进",
["closeup"] = "地球特写",
["overhead"] = "俯视",
["sideview"] = "侧视",
["zoom"] = "缩放",
["orbitTeach"] = "太阳直射点在南北回归线之间往返,形成四季更替。",
["rotationTeach"] = "晨昏线把地球分成昼半球与夜半球;自转产生昼夜交替与地方时差。",
["dayNight"] = "昼夜交替周期 24 小时",
["lat.equator"] = "赤道",
["lat.tropicN"] = "北回归线 23.5°N",
["lat.tropicS"] = "南回归线 23.5°S",
["lat.polarN"] = "北极圈 66.5°N",
["lat.polarS"] = "南极圈 66.5°S",
["loading"] = "正在准备场景…",
["subsolar"] = "太阳直射点",
["north"] = "北极",
["south"] = "南极",
["northShort"] = "N",
["southShort"] = "S",
["sun"] = "太阳",
["earth"] = "地球",
["spinInfo"] = "自转 {0}° · 周期 {1} 小时",
["orbitInfo"] = "公转 {0}°",
["declinationInfo"] = "太阳直射 {0}",
["dateInfo"] = "日期 {0}",
["season.springEquinox"] = "春分",
["season.summerSolstice"] = "夏至",
["season.autumnEquinox"] = "秋分",
["season.winterSolstice"] = "冬至"
};
public static readonly Dictionary<string, string> En = new()
{
["title"] = "Earth model",
["view.rotation"] = "Rotation",
["view.revolution"] = "Revolution",
["play"] = "Play",
["pause"] = "Pause",
["speed"] = "Speed",
["reset"] = "Reset",
["labels"] = "Labels",
["orbit"] = "Orbit",
["grid"] = "Graticule",
["tilt"] = "Exaggerate tilt",
["lessons"] = "Teaching notes",
["seasons"] = "Solstices & equinoxes",
["close"] = "Close window",
["hint"] = "Pinch or scroll to zoom · drag to turn the Earth",
["shortcutHint"] = "Space play/pause · ←→ step · 1–4 solstices & equinoxes · F fullscreen",
["classroom"] = "Classroom",
["directPoint"] = "Subsolar",
["frozen"] = "Frozen",
["running"] = "Playing",
["step"] = "Step",
["closeup"] = "Earth close-up",
["overhead"] = "Top view",
["sideview"] = "Side view",
["zoom"] = "Zoom",
["orbitTeach"] = "The subsolar point travels between the tropics, producing the seasons.",
["rotationTeach"] = "The terminator splits day and night; rotation drives the day–night cycle and local time.",
["dayNight"] = "Day–night cycle: 24 h",
["lat.equator"] = "Equator",
["lat.tropicN"] = "Tropic of Cancer 23.5°N",
["lat.tropicS"] = "Tropic of Capricorn 23.5°S",
["lat.polarN"] = "Arctic Circle 66.5°N",
["lat.polarS"] = "Antarctic Circle 66.5°S",
["loading"] = "Preparing scene…",
["subsolar"] = "Subsolar point",
["north"] = "North pole",
["south"] = "South pole",
["northShort"] = "N",
["southShort"] = "S",
["sun"] = "Sun",
["earth"] = "Earth",
["spinInfo"] = "Rotation {0}° · period {1} h",
["orbitInfo"] = "Orbit {0}°",
["declinationInfo"] = "Subsolar {0}",
["dateInfo"] = "Date {0}",
["season.springEquinox"] = "Spring equinox",
["season.summerSolstice"] = "Summer solstice",
["season.autumnEquinox"] = "Autumn equinox",
["season.winterSolstice"] = "Winter solstice"
};
}
-76
View File
@@ -1,76 +0,0 @@
using System.Collections.Generic;
namespace GC.EarthModels;
/// <summary>&lt;id&gt;.model/scene.json —— 模型数据(可视化场景描述)。</summary>
public sealed class SceneDefinition
{
public int SchemaVersion { get; set; } = 1;
public string Type { get; set; } = "planet";
/// <summary>rotation | revolution</summary>
public string DefaultView { get; set; } = "rotation";
/// <summary>模型支持的视图;为空表示只有 defaultView。</summary>
public List<string> Views { get; set; } = new();
public Dictionary<string, string>? NameI18n { get; set; }
public Dictionary<string, string>? DescriptionI18n { get; set; }
public StarDefinition Star { get; set; } = new();
public PlanetDefinition Planet { get; set; } = new();
public OrbitDefinition Orbit { get; set; } = new();
public List<Lesson> Lessons { get; set; } = new();
}
public sealed class StarDefinition
{
public string Name { get; set; } = "Sun";
public Dictionary<string, string>? NameI18n { get; set; }
public string Color { get; set; } = "#FFC24B";
/// <summary>相对行星半径的视觉倍率</summary>
public double RadiusScale { get; set; } = 0.5;
}
public sealed class PlanetDefinition
{
public string Name { get; set; } = "Earth";
public Dictionary<string, string>? NameI18n { get; set; }
/// <summary>黄赤交角:教材值 23.5°(23°26′),决定南北回归线纬度。</summary>
public double AxialTiltDeg { get; set; } = 23.5;
/// <summary>回归线纬度,默认与黄赤交角一致;极圈 = 90 − 回归线。</summary>
public double TropicDeg { get; set; } = 23.5;
public double RotationHours { get; set; } = 23.93;
public double OrbitDays { get; set; } = 365.26;
public string OceanColor { get; set; } = "#1B5FA8";
public string LandColor { get; set; } = "#4F8C4C";
public string? IceColor { get; set; } = "#E8EEF4";
public string? LandFile { get; set; } = "land.json";
public bool ShowGraticule { get; set; } = true;
}
public sealed class OrbitDefinition
{
public double SemiMajorAxis { get; set; } = 4.0;
public double Eccentricity { get; set; } = 0.0167;
public bool Show { get; set; } = true;
/// <summary>节气方位声明:springTopSummerLeft = 上春分 / 左夏至(引擎按此布局绘制轨道)。</summary>
public string SeasonLayout { get; set; } = "springTopSummerLeft";
public List<SeasonPoint> Seasons { get; set; } = new();
}
public sealed class SeasonPoint
{
/// <summary>0=春分 90=夏至 180=秋分 270=冬至</summary>
public double AngleDeg { get; set; }
public string Key { get; set; } = "";
public string? Date { get; set; }
/// <summary>该节气的太阳直射纬度:春分/秋分 0,夏至 +23.5,冬至 −23.5。</summary>
public double? DeclinationDeg { get; set; }
/// <summary>课堂现象说明(写在模型数据里,启动器不参与)。</summary>
public Dictionary<string, string>? TeachingI18n { get; set; }
}
public sealed class Lesson
{
public Dictionary<string, string>? TitleI18n { get; set; }
public Dictionary<string, string>? BodyI18n { get; set; }
public string? View { get; set; }
public double? AngleDeg { get; set; }
}
-65
View File
@@ -1,65 +0,0 @@
using System;
using System.IO;
using Avalonia.Media;
namespace GC.EarthModels;
/// <summary>
/// 模型自己的场景运行时:场景描述 + 预烘焙地表纹理 + 调色板。
/// 数据来自模型数据目录,不依赖启动器。
/// </summary>
public sealed class SceneRuntime
{
public SceneDefinition Scene { get; init; } = new();
public PlanetTexture? Texture { get; init; }
public Color Ocean { get; init; } = Color.Parse("#1B5FA8");
public Color Land { get; init; } = Color.Parse("#4F8C4C");
public Color Ice { get; init; } = Color.Parse("#E6EDF4");
public Color Star { get; init; } = Color.Parse("#FFC24B");
public long MemoryBytes => Texture?.ByteSize ?? 0;
public static SceneRuntime Load(string dataDirectory, int memoryBudgetMb,
Action<double, string?>? progress = null)
{
progress?.Invoke(0.06, "读取场景数据");
var scenePath = Path.Combine(dataDirectory, "scene.json");
var scene = ModelJson.Read<SceneDefinition>(scenePath) ?? new SceneDefinition();
var ocean = Parse(scene.Planet.OceanColor, "#1B5FA8");
var land = Parse(scene.Planet.LandColor, "#4F8C4C");
var ice = Parse(scene.Planet.IceColor, "#E6EDF4");
LandData? landData = null;
var landFile = scene.Planet.LandFile;
if (!string.IsNullOrWhiteSpace(landFile))
{
var path = Path.IsPathRooted(landFile!) ? landFile! : Path.Combine(dataDirectory, landFile!);
progress?.Invoke(0.12, "读取地表轮廓");
landData = LandData.Load(path);
}
// 内存预算决定纹理分辨率(1024 宽约 3 MB)
var width = memoryBudgetMb >= 1024 ? PlanetTexture.DefaultWidth
: memoryBudgetMb >= 512 ? 768
: 512;
progress?.Invoke(0.16, "生成地表纹理");
var texture = PlanetTexture.Build(landData, width, ocean, land, ice,
t => progress?.Invoke(0.16 + t * 0.48, "生成地表纹理"));
progress?.Invoke(0.68, "场景就绪");
return new SceneRuntime
{
Scene = scene,
Texture = texture,
Ocean = ocean,
Land = land,
Ice = ice,
Star = Parse(scene.Star.Color, "#FFC24B")
};
}
private static Color Parse(string? value, string fallback)
=> Color.TryParse(string.IsNullOrWhiteSpace(value) ? fallback : value, out var c) ? c : Color.Parse(fallback);
}
-476
View File
@@ -1,476 +0,0 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Avalonia.Media;
namespace GC.EarthModels;
/// <summary>
/// 预烘焙的等经纬度地表贴图:反照率 + 高度 + 冰盖 + 云层 + 夜间灯光。
/// 只在模型加载时算一次,之后每帧只做采样 —— 比逐像素跑噪声快一个数量级,
/// 而且能画出「真实一点」的地表:海洋深度、沙漠/雨林/针叶林带、山脉阴影、极地冰盖。
/// </summary>
public sealed class PlanetTexture
{
public const int DefaultWidth = 1024;
public int Width { get; }
public int Height { get; }
/// <summary>打包的反照率(0xRRGGBB),每像素一次双线性即可拿三通道。</summary>
public uint[] Albedo { get; }
/// <summary>地形高度(0=海平面,255=高山)</summary>
public byte[] Elevation { get; }
/// <summary>云量</summary>
public byte[] Cloud { get; }
/// <summary>夜间灯光</summary>
public byte[] Lights { get; }
/// <summary>预烘焙的地形坡度:东向 / 北向高度梯度(加载时算一次,每帧直接采样)。</summary>
public float[] SlopeEast { get; }
public float[] SlopeNorth { get; }
public long ByteSize => (long)(Albedo.Length * 4 + Elevation.Length + Cloud.Length + Lights.Length
+ SlopeEast.Length * 4 + SlopeNorth.Length * 4);
private PlanetTexture(int width, int height)
{
Width = width;
Height = height;
var count = width * height;
Albedo = new uint[count];
Elevation = new byte[count];
Cloud = new byte[count];
Lights = new byte[count];
SlopeEast = new float[count];
SlopeNorth = new float[count];
}
public static PlanetTexture Build(LandData? landData, int width, Color ocean, Color land, Color ice,
Action<double>? progress = null)
{
width = Math.Clamp(width, 256, 2048);
var height = width / 2;
var texture = new PlanetTexture(width, height);
progress?.Invoke(0.08);
var mask = landData == null ? null : LandMask.Build(landData, width, height);
progress?.Invoke(0.28);
// 到海岸的距离:海里用来做深度,陆地上用来做大陆性(内陆更干)
var landDistance = new float[width * height];
var oceanDistance = new float[width * height];
ComputeDistances(mask, width, height, landDistance, oceanDistance);
progress?.Invoke(0.42);
Parallel.For(0, height, y =>
{
var lat = 90.0 - (y + 0.5) * 180.0 / height;
var latAbs = MathF.Abs((float)lat);
var rowBase = y * width;
for (var x = 0; x < width; x++)
{
var lon = (x + 0.5) * 360.0 / width - 180.0;
var index = rowBase + x;
var isLand = mask == null || mask.Bits[index] > 127;
var elevation = Fbm(lon * 2.1, lat * 2.1, 4, 0x51A3);
var moisture = Fbm(lon * 1.35 + 40, lat * 1.35 - 20, 3, 0x9E2B);
var detail = Fbm(lon * 0.85, lat * 0.85, 3, 0x2C77);
if (isLand)
{
// 内陆更干,靠海更湿
var inland = Math.Clamp(landDistance[index] / (width * 0.06f), 0f, 1f);
var wet = Math.Clamp(moisture * 0.78f + (1f - inland) * 0.16f
- MathF.Max(0f, latAbs - 45f) / 90f, 0f, 1f);
var (r, g, b) = LandPalette(latAbs, wet, inland, elevation, detail, land, ice);
texture.Albedo[index] = Pack(r, g, b);
texture.Elevation[index] = (byte)Math.Clamp(elevation * 235f + detail * 20f, 0, 255);
// 夜间灯光:沿海平原、中低纬,稀疏分布
// 夜间灯光:低频的城市群辉光(高频点会在小尺寸球面上变成噪点)
var cityGlow = Smooth(0.55f, 0.92f, Fbm(lon * 1.7, lat * 1.7, 3, 0x7A31));
if (latAbs < 60 && inland < 0.55f && elevation < 0.75f)
texture.Lights[index] = ToByte(cityGlow * 0.55f);
}
else
{
// 海洋:按离岸距离做深浅
var depth = Math.Clamp(oceanDistance[index] / (width * 0.09f), 0f, 1f);
depth = (float)Math.Pow(depth, 0.65);
var shallowR = Math.Min(1f, ocean.R / 255f + 0.16f);
var shallowG = Math.Min(1f, ocean.G / 255f + 0.22f);
var shallowB = Math.Min(1f, ocean.B / 255f + 0.16f);
var deepR = ocean.R / 255f * 0.32f;
var deepG = ocean.G / 255f * 0.40f;
var deepB = ocean.B / 255f * 0.52f;
var wave = (detail - 0.5f) * 0.035f;
texture.Albedo[index] = Pack(
ToByte(shallowR + (deepR - shallowR) * depth + wave),
ToByte(shallowG + (deepG - shallowG) * depth + wave),
ToByte(shallowB + (deepB - shallowB) * depth + wave));
texture.Elevation[index] = 0;
}
// 极地冰盖:纬度 + 噪声边界,海洋也能结冰
var iceEdge = 62f + (detail - 0.5f) * 9f;
var iceAmt = Smooth(iceEdge - 7f, iceEdge + 6f, latAbs);
if (iceAmt > 0.001f)
{
var iceR = ice.R / 255f;
var iceG = ice.G / 255f;
var iceB = ice.B / 255f;
var packed = texture.Albedo[index];
texture.Albedo[index] = Pack(
ToByte(Lerp(((packed >> 16) & 0xFF) / 255f, iceR, iceAmt)),
ToByte(Lerp(((packed >> 8) & 0xFF) / 255f, iceG, iceAmt)),
ToByte(Lerp((packed & 0xFF) / 255f, iceB, iceAmt)));
}
// 云:多个尺度的 fbm,赤道与中纬多云
var cloudBase = Fbm(lon * 0.55, lat * 0.7, 3, 0x1144);
var band = 0.5f + 0.5f * MathF.Cos(latAbs / 90f * MathF.PI * 3.1f);
var cloud = Smooth(0.48f, 0.84f, cloudBase * 0.86f + band * 0.14f);
texture.Cloud[index] = ToByte(cloud * 0.72f);
}
});
// 云层做一次模糊,避免小尺寸球面上采样出噪点
Blur(texture.Cloud, width, height, 2);
// 预烘焙地形坡度:渲染时不必每像素再取 4 次高度
BakeSlopes(texture, width, height);
progress?.Invoke(0.62);
return texture;
}
private static (byte R, byte G, byte B) LandPalette(float latAbs, float wet, float inland, float elevation,
float detail, Color landBase, Color ice)
{
// 基色随纬度:赤道雨林 -> 温带 -> 针叶林 -> 苔原
float r, g, b;
var tropical = (1f - Smooth(8f, 24f, latAbs));
var temperate = Smooth(20f, 34f, latAbs) * (1f - Smooth(46f, 60f, latAbs));
var boreal = Smooth(46f, 60f, latAbs) * (1f - Smooth(62f, 70f, latAbs));
var tundra = Smooth(60f, 72f, latAbs);
r = 0.13f; g = 0.36f; b = 0.17f; // 温带草原绿
r = Lerp(r, 0.10f, tropical); g = Lerp(g, 0.42f, tropical); b = Lerp(b, 0.19f, tropical);
r = Lerp(r, 0.17f, boreal); g = Lerp(g, 0.28f, boreal); b = Lerp(b, 0.17f, boreal);
r = Lerp(r, 0.34f, tundra); g = Lerp(g, 0.36f, tundra); b = Lerp(b, 0.31f, tundra);
// 湿润度:干 -> 沙漠/草原
var dry = Math.Clamp(1f - wet * 0.95f, 0f, 1f);
var desertBand = Math.Clamp(1f - MathF.Abs(latAbs - 24f) / 13f, 0f, 1f);
var desert = Math.Clamp(dry * 0.72f + desertBand * 0.62f, 0f, 1f);
r = Lerp(r, 0.72f, desert * 0.85f);
g = Lerp(g, 0.60f, desert * 0.85f);
b = Lerp(b, 0.38f, desert * 0.85f);
// 高原/山地:岩石和雪
var rock = Smooth(0.62f, 0.86f, elevation);
r = Lerp(r, 0.44f, rock * 0.7f);
g = Lerp(g, 0.40f, rock * 0.7f);
b = Lerp(b, 0.34f, rock * 0.7f);
var snow = Smooth(0.86f, 0.97f, elevation + (latAbs - 40f) / 220f);
r = Lerp(r, ice.R / 255f, snow);
g = Lerp(g, ice.G / 255f, snow);
b = Lerp(b, ice.B / 255f, snow);
// 细节扰动,避免大面积纯色
var grain = (detail - 0.5f) * 0.07f;
var baseMix = 0.25f;
return (
ToByte(Math.Clamp(r + grain + (landBase.R / 255f - 0.3f) * baseMix * 0.2f, 0f, 1f)),
ToByte(Math.Clamp(g + grain + (landBase.G / 255f - 0.45f) * baseMix * 0.2f, 0f, 1f)),
ToByte(Math.Clamp(b + grain + (landBase.B / 255f - 0.3f) * baseMix * 0.2f, 0f, 1f)));
}
/// <summary>可分离盒式模糊(原地),用于软化云层。</summary>
private static void Blur(byte[] data, int width, int height, int radius)
{
var temp = new byte[data.Length];
for (var y = 0; y < height; y++)
{
var row = y * width;
for (var x = 0; x < width; x++)
{
var sum = 0;
var count = 0;
for (var k = -radius; k <= radius; k++)
{
var sx = (x + k + width) % width;
sum += data[row + sx];
count++;
}
temp[row + x] = (byte)(sum / count);
}
}
for (var x = 0; x < width; x++)
{
for (var y = 0; y < height; y++)
{
var sum = 0;
var count = 0;
for (var k = -radius; k <= radius; k++)
{
var sy = Math.Clamp(y + k, 0, height - 1);
sum += temp[sy * width + x];
count++;
}
data[y * width + x] = (byte)(sum / count);
}
}
}
/// <summary>由高度图算东西/南北梯度,供球面光照直接使用。</summary>
private static void BakeSlopes(PlanetTexture t, int width, int height)
{
const float relief = 0.055f * 90f;
for (var y = 0; y < height; y++)
{
var row = y * width;
var up = Math.Max(0, y - 1) * width;
var down = Math.Min(height - 1, y + 1) * width;
for (var x = 0; x < width; x++)
{
var left = (x - 1 + width) % width;
var right = (x + 1) % width;
t.SlopeEast[row + x] = (t.Elevation[row + right] - t.Elevation[row + left]) / 255f * relief;
t.SlopeNorth[row + x] = (t.Elevation[up + x] - t.Elevation[down + x]) / 255f * relief;
}
}
}
// ---------------------------------------------------------------- 距离场
private static void ComputeDistances(LandMask? mask, int width, int height, float[] landDistance, float[] oceanDistance)
{
var count = width * height;
const float big = 1e6f;
for (var i = 0; i < count; i++)
{
var isLand = mask != null && mask.Bits[i] > 127;
landDistance[i] = isLand ? big : -big;
oceanDistance[i] = isLand ? -big : big;
}
// 两遍 chamfer:陆地到海洋的距离 / 海洋到陆地的距离
for (var y = 0; y < height; y++)
{
for (var x = 0; x < width; x++)
{
var i = y * width + x;
if (mask != null && mask.Bits[i] > 127)
{
var best = big;
if (x > 0 && mask.Bits[i - 1] <= 127) best = 0.5f;
if (x < width - 1 && mask.Bits[i + 1] <= 127) best = Math.Min(best, 0.5f);
if (y > 0 && mask.Bits[i - width] <= 127) best = Math.Min(best, 0.5f);
if (y < height - 1 && mask.Bits[i + width] <= 127) best = Math.Min(best, 0.5f);
if (best < big) landDistance[i] = best;
}
if (mask != null && mask.Bits[i] <= 127)
{
var best = big;
if (x > 0 && mask.Bits[i - 1] > 127) best = 0.5f;
if (x < width - 1 && mask.Bits[i + 1] > 127) best = Math.Min(best, 0.5f);
if (y > 0 && mask.Bits[i - width] > 127) best = Math.Min(best, 0.5f);
if (y < height - 1 && mask.Bits[i + width] > 127) best = Math.Min(best, 0.5f);
if (best < big) oceanDistance[i] = best;
}
}
}
// 正向传递
for (var y = 0; y < height; y++)
{
for (var x = 0; x < width; x++)
{
var i = y * width + x;
Propagate(landDistance, i, width, height, x, y, -1, 0, 1.4142f);
Propagate(oceanDistance, i, width, height, x, y, -1, 0, 1.4142f);
if (x > 0)
{
landDistance[i] = Math.Min(landDistance[i], landDistance[i - 1] + 1f);
oceanDistance[i] = Math.Min(oceanDistance[i], oceanDistance[i - 1] + 1f);
}
if (y > 0)
{
landDistance[i] = Math.Min(landDistance[i], landDistance[i - width] + 1f);
oceanDistance[i] = Math.Min(oceanDistance[i], oceanDistance[i - width] + 1f);
if (x > 0)
{
landDistance[i] = Math.Min(landDistance[i], landDistance[i - width - 1] + 1.4142f);
oceanDistance[i] = Math.Min(oceanDistance[i], oceanDistance[i - width - 1] + 1.4142f);
}
if (x < width - 1)
{
landDistance[i] = Math.Min(landDistance[i], landDistance[i - width + 1] + 1.4142f);
oceanDistance[i] = Math.Min(oceanDistance[i], oceanDistance[i - width + 1] + 1.4142f);
}
}
}
}
// 反向传递
for (var y = height - 1; y >= 0; y--)
{
for (var x = width - 1; x >= 0; x--)
{
var i = y * width + x;
if (x < width - 1)
{
landDistance[i] = Math.Min(landDistance[i], landDistance[i + 1] + 1f);
oceanDistance[i] = Math.Min(oceanDistance[i], oceanDistance[i + 1] + 1f);
}
if (y < height - 1)
{
landDistance[i] = Math.Min(landDistance[i], landDistance[i + width] + 1f);
oceanDistance[i] = Math.Min(oceanDistance[i], oceanDistance[i + width] + 1f);
if (x < width - 1)
{
landDistance[i] = Math.Min(landDistance[i], landDistance[i + width + 1] + 1.4142f);
oceanDistance[i] = Math.Min(oceanDistance[i], oceanDistance[i + width + 1] + 1.4142f);
}
if (x > 0)
{
landDistance[i] = Math.Min(landDistance[i], landDistance[i + width - 1] + 1.4142f);
oceanDistance[i] = Math.Min(oceanDistance[i], oceanDistance[i + width - 1] + 1.4142f);
}
}
}
}
for (var i = 0; i < count; i++)
{
landDistance[i] = MathF.Max(0f, landDistance[i]);
oceanDistance[i] = MathF.Max(0f, oceanDistance[i]);
}
}
private static void Propagate(float[] map, int index, int width, int height, int x, int y, int dx, int dy, float w)
{
var nx = x + dx;
var ny = y + dy;
if (nx < 0 || nx >= width || ny < 0 || ny >= height) return;
var other = ny * width + nx;
map[index] = Math.Min(map[index], map[other] + w);
}
// ---------------------------------------------------------------- 噪声
/// <summary>值噪声 + 分形叠加(确定性,跨平台一致)。</summary>
public static float Fbm(double x, double y, int octaves, int seed)
{
var amplitude = 1.0;
var frequency = 1.0;
var sum = 0.0;
var norm = 0.0;
for (var i = 0; i < octaves; i++)
{
sum += amplitude * ValueNoise(x * frequency, y * frequency, seed + i * 101);
norm += amplitude;
amplitude *= 0.5;
frequency *= 2.07;
}
return (float)(sum / norm);
}
private static double ValueNoise(double x, double y, int seed)
{
var xi = (int)Math.Floor(x);
var yi = (int)Math.Floor(y);
var xf = x - xi;
var yf = y - yi;
var u = xf * xf * (3 - 2 * xf);
var v = yf * yf * (3 - 2 * yf);
var a = Hash(xi, yi, seed);
var b = Hash(xi + 1, yi, seed);
var c = Hash(xi, yi + 1, seed);
var d = Hash(xi + 1, yi + 1, seed);
return (a + (b - a) * u) * (1 - v) + (c + (d - c) * u) * v;
}
private static double Hash(int x, int y, int seed)
{
var h = (uint)(x * 374761393 + y * 668265263 + seed * 1442695041);
h = (h ^ (h >> 13)) * 1274126177u;
h ^= h >> 16;
return (h & 0xFFFFFF) / (double)0xFFFFFF;
}
// ---------------------------------------------------------------- 采样
public void Sample(double lon, double lat, out float r, out float g, out float b,
out float elevation, out float cloud, out float lights,
out float slopeEast, out float slopeNorth)
{
var u = (lon + 180.0) / 360.0 * Width - 0.5;
var v = (90.0 - lat) / 180.0 * Height - 0.5;
var x0 = (int)Math.Floor(u);
var y0 = (int)Math.Floor(v);
var fx = (float)(u - x0);
var fy = (float)(v - y0);
var x1 = x0 + 1;
var y1 = y0 + 1;
if (x0 < 0) x0 += Width; if (x1 < 0) x1 += Width;
if (x0 >= Width) x0 -= Width; if (x1 >= Width) x1 -= Width;
y0 = Math.Clamp(y0, 0, Height - 1);
y1 = Math.Clamp(y1, 0, Height - 1);
var i00 = y0 * Width + x0;
var i10 = y0 * Width + x1;
var i01 = y1 * Width + x0;
var i11 = y1 * Width + x1;
float w00 = (1 - fx) * (1 - fy), w10 = fx * (1 - fy), w01 = (1 - fx) * fy, w11 = fx * fy;
var p00 = Albedo[i00];
var p10 = Albedo[i10];
var p01 = Albedo[i01];
var p11 = Albedo[i11];
var rr = ((p00 >> 16) & 0xFF) * w00 + ((p10 >> 16) & 0xFF) * w10 + ((p01 >> 16) & 0xFF) * w01 + ((p11 >> 16) & 0xFF) * w11;
var gg = ((p00 >> 8) & 0xFF) * w00 + ((p10 >> 8) & 0xFF) * w10 + ((p01 >> 8) & 0xFF) * w01 + ((p11 >> 8) & 0xFF) * w11;
var bb = (p00 & 0xFF) * w00 + (p10 & 0xFF) * w10 + (p01 & 0xFF) * w01 + (p11 & 0xFF) * w11;
r = rr / 255f;
g = gg / 255f;
b = bb / 255f;
elevation = (Elevation[i00] * w00 + Elevation[i10] * w10 + Elevation[i01] * w01 + Elevation[i11] * w11) / 255f;
cloud = (Cloud[i00] * w00 + Cloud[i10] * w10 + Cloud[i01] * w01 + Cloud[i11] * w11) / 255f;
lights = Lights[i00] / 255f;
slopeEast = SlopeEast[i00] * w00 + SlopeEast[i10] * w10 + SlopeEast[i01] * w01 + SlopeEast[i11] * w11;
slopeNorth = SlopeNorth[i00] * w00 + SlopeNorth[i10] * w10 + SlopeNorth[i01] * w01 + SlopeNorth[i11] * w11;
}
/// <summary>只采样高度(法线扰动用)。</summary>
public float SampleHeight(double lon, double lat)
{
var u = (lon + 180.0) / 360.0 * Width - 0.5;
var v = (90.0 - lat) / 180.0 * Height - 0.5;
var x = Math.Clamp((int)Math.Round(u), 0, Width - 1);
var y = Math.Clamp((int)Math.Round(v), 0, Height - 1);
return Elevation[y * Width + x] / 255f;
}
public float SampleCloud(double lon, double lat)
{
var u = (lon + 180.0) / 360.0 * Width - 0.5;
var v = (90.0 - lat) / 180.0 * Height - 0.5;
var x = Math.Clamp((int)Math.Round(u), 0, Width - 1);
var y = Math.Clamp((int)Math.Round(v), 0, Height - 1);
return Cloud[y * Width + x] / 255f;
}
public static byte ToByte(float v) => (byte)Math.Clamp((int)(v * 255f + 0.5f), 0, 255);
private static uint Pack(byte r, byte g, byte b) => ((uint)r << 16) | ((uint)g << 8) | b;
private static float Lerp(float a, float b, float t) => a + (b - a) * Math.Clamp(t, 0f, 1f);
private static float Smooth(float edge0, float edge1, float x)
{
if (edge1 <= edge0) return x >= edge1 ? 1f : 0f;
var t = Math.Clamp((x - edge0) / (edge1 - edge0), 0f, 1f);
return t * t * (3f - 2f * t);
}
}
-172
View File
@@ -1,172 +0,0 @@
using System;
using System.Numerics;
using System.Threading.Tasks;
using Avalonia.Media.Imaging;
namespace GC.EarthModels;
/// <summary>
/// 球体像素级渲染:正交投影 + 预烘焙地表纹理 + 地形光照 + 云层 + 夜灯 + 大气边缘光。
/// 纯 CPU 光栅、按行并行,不依赖 GPU,三平台效果一致。
/// </summary>
public static unsafe class SphereRaster
{
/// <summary>把球体画进 WriteableBitmap(整张位图会被覆盖)。</summary>
public static void Draw(WriteableBitmap bitmap, int size, Matrix4x4 cam, Matrix4x4 planet,
Vector3 light, PlanetTexture texture, double cloudShift, bool showClouds)
{
using var framebuffer = bitmap.Lock();
var stride = framebuffer.RowBytes / 4;
Render((uint*)framebuffer.Address, stride, size, cam, planet, light, texture, cloudShift, showClouds);
}
public static void Render(uint* dst, int stride, int size, Matrix4x4 cam, Matrix4x4 planet,
Vector3 light, PlanetTexture texture, double cloudShift, bool showClouds)
{
var radius = size * 0.5f - 1.0f;
var center = size * 0.5f;
var inv = 1f / radius;
// 相机空间法线 -> 行星本地法线
var combined = Matrix4x4.Multiply(planet, cam);
var mt = Matrix4x4.Transpose(combined);
float m11 = mt.M11, m12 = mt.M12, m13 = mt.M13;
float m21 = mt.M21, m22 = mt.M22, m23 = mt.M23;
float m31 = mt.M31, m32 = mt.M32, m33 = mt.M33;
var lx = light.X; var ly = light.Y; var lz = light.Z;
Parallel.For(0, size, y =>
{
var ny = (center - y - 0.5f) * inv;
var row = dst + (long)y * stride;
for (var x = 0; x < size; x++)
{
var nx = (x + 0.5f - center) * inv;
var r2 = nx * nx + ny * ny;
if (r2 >= 1f)
{
row[x] = 0;
continue;
}
var nz = MathF.Sqrt(1f - r2);
// 本地法线(用于取经纬度)
var ux = nx * m11 + ny * m21 + nz * m31;
var uy = nx * m12 + ny * m22 + nz * m32;
var uz = nx * m13 + ny * m23 + nz * m33;
var lat = MathF.Asin(Math.Clamp(uy, -1f, 1f)) * 57.2957795f;
var lon = MathF.Atan2(ux, uz) * 57.2957795f;
var cloudLon = lon + cloudShift;
if (cloudLon > 180) cloudLon -= 360;
if (cloudLon < -180) cloudLon += 360;
texture.Sample(lon, lat, out var ar, out var ag, out var ab,
out var elevation, out var cloud, out var lights,
out var dEast, out var dNorth);
// ---- 地形法线:局部基向量可由球面法线直接推出,不必再算 6 次三角函数
// 点 P=(cosLat·sinLon, sinLat, cosLat·cosLon) = (ux,uy,uz)
// 东向 = (cosLon,0,-sinLon),北向 = (-sinLat·sinLon, cosLat, -sinLat·cosLon)
var cosLat = MathF.Sqrt(MathF.Max(ux * ux + uz * uz, 1e-6f));
var invCos = 1f / cosLat;
var eastX = uz * invCos;
var eastZ = -ux * invCos;
var northX = -uy * ux * invCos;
var northY = cosLat;
var northZ = -uy * uz * invCos;
var nLocalX = ux + eastX * dEast + northX * dNorth;
var nLocalY = uy + northY * dNorth;
var nLocalZ = uz + eastZ * dEast + northZ * dNorth;
var nLen = MathF.Sqrt(nLocalX * nLocalX + nLocalY * nLocalY + nLocalZ * nLocalZ);
if (nLen > 0.0001f) { nLocalX /= nLen; nLocalY /= nLen; nLocalZ /= nLen; }
var nCamX = nLocalX * combined.M11 + nLocalY * combined.M21 + nLocalZ * combined.M31;
var nCamY = nLocalX * combined.M12 + nLocalY * combined.M22 + nLocalZ * combined.M32;
var nCamZ = nLocalX * combined.M13 + nLocalY * combined.M23 + nLocalZ * combined.M33;
var lam = nx * lx + ny * ly + nz * lz; // 几何光照(晨昏线)
var bump = nCamX * lx + nCamY * ly + nCamZ * lz; // 地形光照
var day = Smooth(-0.18f, 0.22f, lam);
var terrainLight = 0.82f + 0.42f * MathF.Max(0f, bump - lam);
var shade = (0.055f + 0.945f * day) * terrainLight;
var br = ar * shade;
var bg = ag * shade;
var bb = ab * shade;
// 海面高光(高度为 0 视为水面)
if (elevation < 0.02f)
{
var t2 = MathF.Max(0f, lam);
var t4 = t2 * t2 * t2 * t2;
var t8 = t4 * t4;
var t16 = t8 * t8;
var spec = t16 * t8 * t4 * t2 * t2 * 0.62f;
br += spec * 0.95f;
bg += spec * 0.98f;
bb += spec;
}
// 云层(随经度缓慢漂移)
if (showClouds && cloud > 0.02f)
{
var cloudLight = 0.10f + 0.90f * day;
var c = Math.Clamp(cloud * 0.92f, 0f, 1f);
var cloudR = 0.98f * cloudLight;
var cloudG = 0.985f * cloudLight;
var cloudB = 1.0f * cloudLight;
br += (cloudR - br) * c;
bg += (cloudG - bg) * c;
bb += (cloudB - bb) * c;
}
// 夜间灯光
if (lights > 0.01f)
{
var night = 1f - day;
var glow = lights * night * 0.35f;
br += glow * 0.95f;
bg += glow * 0.72f;
bb += glow * 0.38f;
}
// 大气边缘散射
var rim = 1f - nz;
rim *= rim;
var litRim = rim * MathF.Max(0f, lam) * 0.98f;
br += 0.30f * litRim;
bg += 0.55f * litRim;
bb += 1.00f * litRim;
// 夜面极淡反照
var nightSide = 1f - day;
br += 0.008f * nightSide;
bg += 0.013f * nightSide;
bb += 0.028f * nightSide;
var coverage = 1f;
var edge = (1f - MathF.Sqrt(r2)) * radius;
if (edge < 1f) coverage = MathF.Max(0f, edge);
var a = (uint)(coverage * 255f);
var r8 = (uint)(Math.Clamp(br, 0f, 1f) * 255f * coverage);
var g8 = (uint)(Math.Clamp(bg, 0f, 1f) * 255f * coverage);
var b8 = (uint)(Math.Clamp(bb, 0f, 1f) * 255f * coverage);
row[x] = (a << 24) | (r8 << 16) | (g8 << 8) | b8;
}
});
}
private static float Smooth(float edge0, float edge1, float x)
{
if (edge1 <= edge0) return x >= edge1 ? 1f : 0f;
var t = Math.Clamp((x - edge0) / (edge1 - edge0), 0f, 1f);
return t * t * (3f - 2f * t);
}
}
-17
View File
@@ -1,17 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>disable</ImplicitUsings>
<RootNamespace>GC.ModelSdk</RootNamespace>
<AssemblyName>GC.ModelSdk</AssemblyName>
<IsPackable>false</IsPackable>
<Description>Earth Model 模型契约:启动器与模型之间唯一的编译期依赖。</Description>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Avalonia" Version="$(AvaloniaVersion)" />
</ItemGroup>
</Project>
-77
View File
@@ -1,77 +0,0 @@
using System;
using Avalonia.Controls;
namespace GC.ModelSdk;
/// <summary>
/// 模型入口契约。模型程序集里必须有一个公开、无参构造的 <see cref="IModelFactory"/> 实现,
/// 启动器按模型清单里的 <c>assembly</c> + <c>type</c> 定位并创建它。
/// </summary>
public interface IModelFactory
{
/// <summary>
/// 契约版本。启动器目前支持 <b>1</b>。
/// 协商规则:必须与启动器支持的版本**相等**,否则启动器拒绝加载并提示用户更新;
/// 模型清单里还可以写 <c>minAppVersion</c> 要求更高的启动器版本。
/// 提升版本时必须保留旧接口的适配层,避免老客户端加载新模型后崩溃。
/// </summary>
int ApiVersion { get; }
/// <summary>创建一个模型运行时实例(每个窗口一个实例)。</summary>
IModelRuntime Create();
}
/// <summary>
/// 模型运行时:负责把模型自己的界面交给启动器。
/// 启动器只负责开窗口,**不参与任何渲染**。
///
/// 生命周期:<c>Create()</c> → <c>Prepare()</c>(后台线程,一次)→ <c>CreateView()</c>(UI 线程,一次)
/// → 用户关窗 → <c>Dispose()</c>(UI 线程)。<c>Dispose</c> 之后不要再调用任何
/// <see cref="IModelContext"/> 成员。
/// </summary>
public interface IModelRuntime : IDisposable
{
/// <summary>
/// 在**后台线程**准备数据(读文件、算纹理等),期间禁止创建或操作任何 UI 控件。
/// 启动器的进度窗会显示 <see cref="IModelContext.ReportProgress"/> 汇报的进度。
/// 默认空实现:模型也可以把准备工作留到 CreateView 里(那样会占用 UI 线程)。
/// </summary>
void Prepare(IModelContext context) { }
/// <summary>
/// 在 UI 线程创建模型窗口的内容。模型可以自由组合控件、自己画图、自己管动画。
/// 返回的控件会被直接放进窗口,铺满客户区。
/// </summary>
Control CreateView(IModelContext context);
}
/// <summary>启动器提供给模型的环境信息与能力。</summary>
public interface IModelContext
{
/// <summary>模型 id(即模型目录名)。</summary>
string ModelId { get; }
/// <summary>模型目录:<c>model/&lt;id&gt;</c>。</summary>
string ModelDirectory { get; }
/// <summary>模型数据目录:<c>model/&lt;id&gt;/&lt;id&gt;.model</c>,模型自己的场景数据、贴图、语言包都放这里。</summary>
string DataDirectory { get; }
/// <summary>界面语言(zh-CN / en)。模型应按它选择自己的文案。</summary>
string Language { get; }
/// <summary>用户在设置里分配的运行内存预算(MB),模型可据此控制缓存规模。</summary>
int MemoryBudgetMb { get; }
/// <summary>请求关闭承载此模型的窗口。**线程安全**,任意线程可调用。</summary>
void RequestClose();
/// <summary>
/// 汇报加载进度(0–1)与当前阶段文案。启动器的加载进度条会实时显示,
/// 也可以在任何时候调用(例如切换数据集时)。**线程安全**,任意线程可调用。
/// </summary>
void ReportProgress(double value, string? message = null);
/// <summary>输出日志(启动器会写到控制台)。**线程安全**,任意线程可调用。</summary>
void Log(string message);
}
+2 -2
View File
@@ -25,6 +25,6 @@
"button": "#9FB4D4",
"frame": "#0A1524"
},
"build": "773ab2161d",
"updatedAt": "2026-11-19T10:20:00Z"
"build": "d18eb85c8d",
"updatedAt": "2026-11-21T10:55:36Z"
}
@@ -1,23 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>disable</ImplicitUsings>
<RootNamespace>GC.ContourMap</RootNamespace>
<AssemblyName>ContourMapModel</AssemblyName>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Avalonia" Version="$(AvaloniaVersion)" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\_sdk\GC.ModelSdk\GC.ModelSdk.csproj">
<Private>false</Private>
</ProjectReference>
</ItemGroup>
</Project>
@@ -1,96 +0,0 @@
using System;
using System.Collections.Generic;
using Avalonia;
using Avalonia.Controls;
using Avalonia.Layout;
using Avalonia.Media;
using GC.ModelSdk;
namespace GC.ContourMap;
/// <summary>等高线模型入口(清单里的 type 指向这里)。</summary>
public sealed class ContourMapFactory : IModelFactory
{
public int ApiVersion => 1;
public IModelRuntime Create() => new ContourMapRuntime();
}
/// <summary>
/// 等高线模型运行时。
/// 依据人教版七年级上册「地形图的判读」:海拔与相对高度、等高线与等高距、
/// 山峰/山脊/山谷/鞍部/陡崖的判读、坡度陡缓与等高线疏密的关系。
/// </summary>
public sealed class ContourMapRuntime : IModelRuntime
{
private TerrainField? _field;
private Dictionary<string, string>? _texts;
private ContourPage? _page;
public void Prepare(IModelContext context)
{
context.ReportProgress(0.15, "生成地形高度场");
_field = new TerrainField(TerrainKind.Mountain, 192);
context.ReportProgress(0.70, "提取等高线");
_texts = LoadTexts(context.DataDirectory, context.Language);
context.ReportProgress(0.92, "准备界面");
context.Log($"[contour-map] 地形 {_field.Size}×{_field.Size}," +
$"海拔 {_field.MinHeight:0}~{_field.MaxHeight:0} m,等高距 {_field.EffectiveInterval:0} m");
}
public Control CreateView(IModelContext context)
{
_texts ??= LoadTexts(context.DataDirectory, context.Language);
// 实验地形 + 五大地貌都在界面里现场生成(切换很快,不必预先生成全部)
_page = new ContourPage(_texts);
return _page.Build();
}
public void Dispose()
{
_page?.Dispose();
_page = null;
_field = null;
_texts = null;
System.GC.SuppressFinalize(this);
}
/// <summary>
/// 文案 = 内置默认(保证任何语言都有词)+ dataDir/i18n/&lt;lang&gt;.json 覆盖。
/// 语言包缺失或某条没翻译时自动退回内置默认,不会露出裸 key。
/// </summary>
private static Dictionary<string, string> LoadTexts(string dataDir, string language)
{
var isEn = language.StartsWith("en", StringComparison.OrdinalIgnoreCase);
var map = new Dictionary<string, string>(DefaultTexts.Zh);
if (isEn) foreach (var kv in DefaultTexts.En) map[kv.Key] = kv.Value;
var candidates = new List<string>();
if (!string.IsNullOrWhiteSpace(language)) candidates.Add(language);
candidates.Add(isEn ? "en" : "zh-CN");
foreach (var lang in candidates)
{
var path = System.IO.Path.Combine(dataDir, "i18n", lang + ".json");
if (!System.IO.File.Exists(path)) continue;
try
{
using var doc = System.Text.Json.JsonDocument.Parse(System.IO.File.ReadAllText(path));
if (doc.RootElement.ValueKind != System.Text.Json.JsonValueKind.Object) continue;
foreach (var p in doc.RootElement.EnumerateObject())
{
if (p.Value.ValueKind != System.Text.Json.JsonValueKind.String) continue;
var v = p.Value.GetString();
if (!string.IsNullOrWhiteSpace(v)) map[p.Name] = v!;
}
break;
}
catch
{
// 语言包损坏不影响开课,继续用内置默认
}
}
return map;
}
}
-721
View File
@@ -1,721 +0,0 @@
using System;
using System.Collections.Generic;
using Avalonia;
using Avalonia.Controls;
using Avalonia.Input;
using Avalonia.Layout;
using Avalonia.Media;
namespace GC.ContourMap;
/// <summary>
/// 等高线模型界面(完整复刻 HTML 课件功能):
/// 顶部标题 + 全屏;左侧可交互 3D 画布;右侧实验流程/五大地貌/判读要点观察面板;
/// 底部播放控制、俯视切换、上色开关、实时读数;支持键盘 1-5 / 空格快捷键。
/// </summary>
public sealed class ContourPage
{
private static readonly Color CAppBg = Color.Parse("#0B1524");
private static readonly Color CPanel = Color.Parse("#101E31");
private static readonly Color CPanel2 = Color.Parse("#16263C");
private static readonly Color CLine = Color.Parse("#1E3350");
private static readonly Color CInk = Color.Parse("#EAF2FF");
private static readonly Color CInkDim = Color.Parse("#93A8C6");
private static readonly Color CInkFaint = Color.Parse("#6A80A0");
private static readonly Color CAccent = Color.Parse("#4D8CFF");
private static readonly Color CWarn = Color.Parse("#FFB454");
private static readonly Color CGood = Color.Parse("#5FD69B");
private readonly Dictionary<string, string> _texts;
private readonly Dictionary<LandformKind, TerrainField> _landformCache = new();
private TerrainField _experimentField;
private ContourView? _view;
private TextBlock? _readout;
private TextBlock? _featureText;
private TextBlock? _hintText;
private TextBlock? _playLabel;
private TextBlock? _observeHeading;
private TextBlock? _observeSummary;
private StackPanel? _featureList;
private TextBlock? _viewToggleLabel;
private readonly List<Border> _flowButtons = new();
private readonly List<Border> _landformButtons = new();
private Border? _playBtn;
private Border? _backBtn;
private Border? _colorBtn;
private TextBlock? _colorBtnText;
private ProgressBar? _progress;
private int _step = 0;
private LandformKind? _selectedLandform;
private bool _disposed;
private TopLevel? _topLevel;
private static readonly LandformKind[] LandformOrder =
{ LandformKind.Peak, LandformKind.Ridge, LandformKind.Valley, LandformKind.Saddle, LandformKind.Cliff };
public ContourPage(Dictionary<string, string> texts)
{
_texts = texts;
_experimentField = new TerrainField(TerrainKind.Mountain, 192);
}
private string T(string key) => _texts.TryGetValue(key, out var v) ? v : key;
private string T(string key, params object[] args)
{
var s = T(key);
try { return string.Format(System.Globalization.CultureInfo.InvariantCulture, s, args); }
catch { return s; }
}
private static SolidColorBrush B(Color c) => new(c);
private TerrainField GetLandformField(LandformKind kind)
{
if (!_landformCache.TryGetValue(kind, out var f))
{
f = new TerrainField(kind, 192);
_landformCache[kind] = f;
}
return f;
}
public Control Build()
{
var root = new Grid { Background = B(CAppBg) };
root.RowDefinitions.Add(new RowDefinition(GridLength.Auto));
root.RowDefinitions.Add(new RowDefinition(GridLength.Star));
root.RowDefinitions.Add(new RowDefinition(GridLength.Auto));
root.Children.Add(BuildHeader());
var body = new Grid { Margin = new Thickness(12, 8, 12, 6) };
body.ColumnDefinitions.Add(new ColumnDefinition(GridLength.Star));
body.ColumnDefinitions.Add(new ColumnDefinition(new GridLength(344)));
body.RowDefinitions.Add(new RowDefinition(GridLength.Auto));
body.RowDefinitions.Add(new RowDefinition(GridLength.Star));
_view = new ContourView(_experimentField, T);
_view.HoverChanged += OnHover;
_view.StepChanged += OnStepChanged;
_view.ProgressChanged += OnProgressChanged;
_view.PlaybackFinished += OnPlaybackFinished;
var canvasHolder = new Border
{
Background = B(Color.Parse("#08111E")),
BorderBrush = B(CLine),
BorderThickness = new Thickness(1),
CornerRadius = new CornerRadius(12),
ClipToBounds = true,
Child = _view
};
Grid.SetRow(canvasHolder, 1);
body.Children.Add(canvasHolder);
// ── 五大典型地貌标签(横向,像课件的选项卡)──
var tabs = new WrapPanel
{
Orientation = Orientation.Horizontal,
Margin = new Thickness(0, 0, 0, 8)
};
_backBtn = MakePillButton(T("btn.backExperiment"), CAccent);
_backBtn.IsVisible = false;
_backBtn.PointerPressed += (_, _) => BackToExperiment();
tabs.Children.Add(_backBtn);
foreach (var kind in LandformOrder)
{
var btn = MakeLandformButton(kind);
_landformButtons.Add(btn);
tabs.Children.Add(btn);
}
body.Children.Add(tabs);
var side = BuildSidePanel();
Grid.SetColumn(side, 1);
Grid.SetRow(side, 0);
Grid.SetRowSpan(side, 2);
body.Children.Add(side);
// 窄窗口(封面缩略图、小屏)隐藏右侧栏,画布优先;宽窗口才展示流程与观察面板
void ApplyResponsive(double width)
{
var narrow = width < 980;
side.IsVisible = !narrow;
body.ColumnDefinitions[1].Width = narrow ? new GridLength(0) : new GridLength(344);
}
root.SizeChanged += (_, e) => ApplyResponsive(e.NewSize.Width);
Grid.SetRow(body, 1);
root.Children.Add(body);
var footer = BuildFooter();
Grid.SetRow(footer, 2);
root.Children.Add(footer);
root.AttachedToVisualTree += (_, _) =>
{
_topLevel = TopLevel.GetTopLevel(root);
};
root.KeyDown += OnKeyDown;
root.Focusable = true;
return root;
}
/// <summary>窗口关闭时释放视图计时器,避免持有控件。</summary>
public void Dispose()
{
if (_disposed) return;
_disposed = true;
_view?.DisposeView();
}
private Control BuildHeader()
{
var title = new TextBlock
{
Text = T("app.title"),
Foreground = B(CInk),
FontSize = 18,
FontWeight = FontWeight.SemiBold
};
var sub = new TextBlock
{
Text = T("app.subtitle"),
Foreground = B(CInkDim),
FontSize = 11.5
};
var stack = new StackPanel { Spacing = 2 };
stack.Children.Add(title);
stack.Children.Add(sub);
var fsLabel = new TextBlock { Text = T("btn.fullscreen"), Foreground = B(CInk), FontSize = 11.5 };
var fsBtn = new Border
{
Background = B(CPanel2),
BorderBrush = B(CLine),
BorderThickness = new Thickness(1),
CornerRadius = new CornerRadius(8),
Padding = new Thickness(12, 6),
Cursor = new Avalonia.Input.Cursor(Avalonia.Input.StandardCursorType.Hand),
Child = fsLabel
};
fsBtn.PointerPressed += (_, _) => ToggleFullscreen(fsLabel);
var grid = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto") };
grid.Children.Add(stack);
Grid.SetColumn(fsBtn, 1);
grid.Children.Add(fsBtn);
return new Border
{
Background = B(CPanel),
BorderBrush = B(CLine),
BorderThickness = new Thickness(0, 0, 0, 1),
Padding = new Thickness(18, 11, 18, 12),
Child = grid
};
}
private Control BuildSidePanel()
{
var panel = new StackPanel { Spacing = 8, Margin = new Thickness(12, 0, 0, 0) };
// ── 实验流程四步 ──
panel.Children.Add(Section(T("flow.title")));
for (var i = 0; i < 4; i++)
{
var btn = MakeFlowButton(i);
_flowButtons.Add(btn);
panel.Children.Add(btn);
}
panel.Children.Add(Divider());
// ── 观察面板 ──
_observeHeading = new TextBlock
{
Text = T("observe.title"),
Foreground = B(CWarn),
FontSize = 12.5,
FontWeight = FontWeight.SemiBold
};
_observeSummary = new TextBlock
{
Text = T("observe.default"),
Foreground = B(CInkDim),
FontSize = 10.5,
TextWrapping = TextWrapping.Wrap,
LineHeight = 16
};
_featureList = new StackPanel { Spacing = 3 };
RenderObservation(null);
panel.Children.Add(_observeHeading);
panel.Children.Add(_observeSummary);
panel.Children.Add(_featureList);
// ── 判读要点 ──
panel.Children.Add(Section(T("side.rules")));
panel.Children.Add(Bullet(T("rule.interval")));
panel.Children.Add(Bullet(T("rule.dense")));
panel.Children.Add(Bullet(T("rule.index")));
panel.Children.Add(Bullet(T("rule.height")));
var scroll = new ScrollViewer
{
Content = new Border
{
Background = B(CPanel),
BorderBrush = B(CLine),
BorderThickness = new Thickness(1),
CornerRadius = new CornerRadius(12),
Padding = new Thickness(14, 12),
Child = panel
},
VerticalScrollBarVisibility = Avalonia.Controls.Primitives.ScrollBarVisibility.Auto
};
return scroll;
}
private Border MakeFlowButton(int index)
{
var name = new TextBlock
{
Text = $"{index + 1}. {T("flow.step." + index)}",
Foreground = B(CInk),
FontSize = 12.5,
FontWeight = FontWeight.SemiBold
};
var desc = new TextBlock
{
Text = T("flow.desc." + index),
Foreground = B(CInkFaint),
FontSize = 11,
TextWrapping = TextWrapping.Wrap,
LineHeight = 15
};
var stack = new StackPanel { Spacing = 1 };
stack.Children.Add(name);
stack.Children.Add(desc);
var border = new Border
{
Background = B(CPanel2),
BorderBrush = B(CLine),
BorderThickness = new Thickness(1),
CornerRadius = new CornerRadius(8),
Padding = new Thickness(9, 6),
Cursor = new Avalonia.Input.Cursor(Avalonia.Input.StandardCursorType.Hand),
Child = stack,
Tag = index
};
border.PointerPressed += (_, _) =>
{
BackToExperiment();
_view?.SetStep((ExperimentStep)index);
UpdateFlowStyles();
};
return border;
}
private Border MakeLandformButton(LandformKind kind)
{
var key = kind.ToString().ToLowerInvariant();
var name = new TextBlock
{
Text = T("landform." + key),
Foreground = B(CInk),
FontSize = 12.5,
FontWeight = FontWeight.SemiBold
};
var sub = new TextBlock
{
Text = T("landform." + key + ".sub"),
Foreground = B(CInkFaint),
FontSize = 10.5,
VerticalAlignment = VerticalAlignment.Center
};
var stack = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 7 };
stack.Children.Add(name);
stack.Children.Add(sub);
var border = new Border
{
Background = B(CPanel2),
BorderBrush = B(CLine),
BorderThickness = new Thickness(1),
CornerRadius = new CornerRadius(18),
Padding = new Thickness(14, 7),
Margin = new Thickness(0, 0, 8, 4),
Cursor = new Avalonia.Input.Cursor(Avalonia.Input.StandardCursorType.Hand),
Child = stack,
Tag = kind
};
border.PointerPressed += (_, _) => SelectLandform(kind);
return border;
}
private void SelectLandform(LandformKind kind)
{
_selectedLandform = kind;
_view?.Pause();
_view?.SetField(GetLandformField(kind));
_view?.SetMode(ViewMode.Perspective);
_view?.ShowContourPattern(); // 地貌专题先看完整的等高线形态
UpdateLandformStyles();
UpdateViewToggleLabel();
var key = kind.ToString().ToLowerInvariant();
if (_observeHeading != null) _observeHeading.Text = T("landform." + key) + " · " + T("landform." + key + ".sub");
if (_observeSummary != null) _observeSummary.Text = T("landform." + key + ".summary");
RenderFeatureList(key);
if (_backBtn != null) _backBtn.IsVisible = true;
if (_hintText != null) _hintText.Text = T("landform." + key + ".hint");
SetPlayLabel(T("btn.replay"));
}
private void BackToExperiment()
{
if (_selectedLandform == null) return;
_selectedLandform = null;
_view?.SetField(_experimentField);
_view?.SetMode(ViewMode.Perspective);
_view?.Reset();
UpdateLandformStyles();
UpdateViewToggleLabel();
RenderObservation(null);
if (_backBtn != null) _backBtn.IsVisible = false;
if (_hintText != null) _hintText.Text = T("hint.play");
SetPlayLabel(T("btn.play"));
}
private void RenderObservation(LandformKind? kind)
{
if (_observeHeading == null || _observeSummary == null || _featureList == null) return;
if (kind == null)
{
_observeHeading.Text = T("observe.title");
_observeSummary.Text = T("observe.default");
_featureList.Children.Clear();
_featureList.Children.Add(Bullet(T("observe.default.f1")));
_featureList.Children.Add(Bullet(T("observe.default.f2")));
}
else
{
var key = kind.Value.ToString().ToLowerInvariant();
_observeHeading.Text = T("landform." + key) + " · " + T("landform." + key + ".sub");
_observeSummary.Text = T("landform." + key + ".summary");
RenderFeatureList(key);
}
}
private void RenderFeatureList(string key)
{
if (_featureList == null) return;
_featureList.Children.Clear();
for (var i = 1; i <= 3; i++)
{
var k = $"landform.{key}.f{i}";
if (_texts.ContainsKey(k)) _featureList.Children.Add(Bullet(T(k)));
}
}
private Control BuildFooter()
{
// 播放 / 重置
_playLabel = new TextBlock { Text = T("btn.play"), Foreground = B(Colors.White), FontSize = 11.5, FontWeight = FontWeight.SemiBold };
_playBtn = new Border
{
Background = B(CAccent),
CornerRadius = new CornerRadius(8),
Padding = new Thickness(14, 7),
Cursor = new Avalonia.Input.Cursor(Avalonia.Input.StandardCursorType.Hand),
Child = _playLabel
};
_playBtn.PointerPressed += (_, _) => TogglePlay();
var resetBtn = MakePillButton(T("btn.reset"), Color.Parse("#2A3B55"));
resetBtn.PointerPressed += (_, _) =>
{
BackToExperiment();
_view?.Reset();
if (_progress != null) _progress.Value = 0;
if (_hintText != null) _hintText.Text = T("hint.play");
SetPlayLabel(T("btn.play"));
};
// 俯视 / 立体切换
_viewToggleLabel = new TextBlock { Text = T("btn.viewTop"), Foreground = B(CInk), FontSize = 11.5 };
var viewBtn = new Border
{
Background = B(CPanel2),
BorderBrush = B(CLine),
BorderThickness = new Thickness(1),
CornerRadius = new CornerRadius(8),
Padding = new Thickness(11, 6),
Cursor = new Avalonia.Input.Cursor(Avalonia.Input.StandardCursorType.Hand),
Child = _viewToggleLabel
};
viewBtn.PointerPressed += (_, _) =>
{
_view?.ToggleMode();
UpdateViewToggleLabel();
};
// 上色开关
_colorBtnText = new TextBlock { Text = T("btn.colorOn"), Foreground = B(Colors.White), FontSize = 11.5 };
_colorBtn = new Border
{
Background = B(CAccent),
CornerRadius = new CornerRadius(8),
Padding = new Thickness(11, 6),
Cursor = new Avalonia.Input.Cursor(Avalonia.Input.StandardCursorType.Hand),
Child = _colorBtnText
};
_colorBtn.PointerPressed += (_, _) => ToggleColor();
var controls = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8 };
controls.Children.Add(_playBtn);
controls.Children.Add(resetBtn);
controls.Children.Add(viewBtn);
controls.Children.Add(_colorBtn);
_progress = new ProgressBar
{
Minimum = 0,
Maximum = 100,
Value = 0,
Height = 4,
VerticalAlignment = VerticalAlignment.Center,
Foreground = B(CAccent),
Background = B(Color.Parse("#1E3350"))
};
_hintText = new TextBlock { Text = T("hint.play"), Foreground = B(CInkDim), FontSize = 11.5 };
_readout = new TextBlock { Text = T("footer.hint"), Foreground = B(CInk), FontSize = 11.5 };
_featureText = new TextBlock
{
Text = "",
Foreground = B(CGood),
FontSize = 11.5,
FontWeight = FontWeight.SemiBold,
HorizontalAlignment = HorizontalAlignment.Right
};
var info = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto") };
info.Children.Add(_readout);
Grid.SetColumn(_featureText, 1);
info.Children.Add(_featureText);
var leftStack = new StackPanel { Spacing = 4, VerticalAlignment = VerticalAlignment.Center };
leftStack.Children.Add(_hintText);
leftStack.Children.Add(info);
var progStack = new StackPanel { Spacing = 6, VerticalAlignment = VerticalAlignment.Center };
progStack.Children.Add(leftStack);
progStack.Children.Add(_progress);
var row = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto") };
row.Children.Add(progStack);
Grid.SetColumn(controls, 1);
row.Children.Add(controls);
return new Border
{
Background = B(CPanel),
BorderBrush = B(CLine),
BorderThickness = new Thickness(0, 1, 0, 0),
Padding = new Thickness(16, 9),
Child = row
};
}
private void TogglePlay()
{
if (_view == null) return;
if (_selectedLandform != null) BackToExperiment();
_view.TogglePlay();
SetPlayLabel(_view.IsPlaying ? T("btn.pause") : T("btn.play"));
if (_hintText != null)
_hintText.Text = _view.IsPlaying ? T("hint.playing") : T("hint.paused");
}
private void ToggleColor()
{
if (_view == null) return;
_view.Colored = !_view.Colored;
if (_colorBtn != null) _colorBtn.Background = B(_view.Colored ? CAccent : Color.Parse("#2A3B55"));
if (_colorBtnText != null) _colorBtnText.Text = _view.Colored ? T("btn.colorOn") : T("btn.color");
}
private void SetPlayLabel(string text) { if (_playLabel != null) _playLabel.Text = text; }
private void UpdateViewToggleLabel()
{
if (_viewToggleLabel == null || _view == null) return;
_viewToggleLabel.Text = _view.Mode == ViewMode.Top ? T("btn.view3d") : T("btn.viewTop");
}
private void UpdateFlowStyles()
{
for (var i = 0; i < _flowButtons.Count; i++)
{
var b = _flowButtons[i];
var active = i == _step && _selectedLandform == null;
var done = i < _step && _selectedLandform == null;
StylePill(b, active ? CAccent : done ? Color.Parse("#1C3A5E") : CPanel2,
active ? Colors.White : done ? CGood : CInkDim);
}
}
private void UpdateLandformStyles()
{
for (var i = 0; i < _landformButtons.Count; i++)
{
var b = _landformButtons[i];
var kind = LandformOrder[i];
var active = _selectedLandform == kind;
StylePill(b, active ? CAccent : CPanel2, active ? Colors.White : CInkDim);
}
}
private static void StylePill(Border b, Color bg, Color fg)
{
b.Background = B(bg);
if (b.Child is TextBlock tb) tb.Foreground = B(fg);
else if (b.Child is StackPanel sp)
foreach (var c in sp.Children)
if (c is TextBlock t) t.Foreground = B(fg);
}
private void OnStepChanged(ExperimentStep step)
{
_step = (int)step;
UpdateFlowStyles();
if (_selectedLandform == null && _observeSummary != null)
_observeSummary.Text = T("flow.desc." + _step);
}
private void OnProgressChanged(ExperimentStep step, double value)
=> _progress?.Value = value * 100;
private void OnPlaybackFinished()
{
SetPlayLabel(T("btn.replay"));
if (_hintText != null) _hintText.Text = T("hint.done");
}
private void OnHover(double u, double v, float height, TerrainFeature feature)
{
if (_readout == null || _featureText == null) return;
var field = _view?.Field ?? _experimentField;
var relative = height - field.MinHeight;
_readout.Text = T("footer.readout", (int)height, (int)relative);
_featureText.Text = FeatureName(feature);
_featureText.Foreground = B(feature switch
{
TerrainFeature.Peak => Color.Parse("#FFD166"),
TerrainFeature.Cliff => Color.Parse("#FF7B7B"),
TerrainFeature.Saddle => Color.Parse("#C08CFF"),
TerrainFeature.Ridge => Color.Parse("#5FD69B"),
TerrainFeature.Valley => Color.Parse("#5BC8FF"),
_ => CInkDim
});
}
private string FeatureName(TerrainFeature f) => f switch
{
TerrainFeature.Peak => T("feature.peak"),
TerrainFeature.Ridge => T("feature.ridge"),
TerrainFeature.Valley => T("feature.valley"),
TerrainFeature.Saddle => T("feature.saddle"),
TerrainFeature.Cliff => T("feature.cliff"),
TerrainFeature.Slope => T("feature.slope"),
_ => ""
};
private void OnKeyDown(object? sender, KeyEventArgs e)
{
// 空格:播放/暂停
if (e.Key == Key.Space)
{
e.Handled = true;
TogglePlay();
return;
}
// 1-5:切换五大地貌
var idx = -1;
switch (e.Key)
{
case Key.D1: case Key.NumPad1: idx = 0; break;
case Key.D2: case Key.NumPad2: idx = 1; break;
case Key.D3: case Key.NumPad3: idx = 2; break;
case Key.D4: case Key.NumPad4: idx = 3; break;
case Key.D5: case Key.NumPad5: idx = 4; break;
}
if (idx >= 0 && idx < LandformOrder.Length)
{
e.Handled = true;
SelectLandform(LandformOrder[idx]);
}
}
private void ToggleFullscreen(TextBlock label)
{
if (_topLevel is not Window window) return;
if (window.WindowState == WindowState.FullScreen)
{
window.WindowState = WindowState.Normal;
label.Text = T("btn.fullscreen");
}
else
{
window.WindowState = WindowState.FullScreen;
label.Text = T("btn.exitFullscreen");
}
}
// ── 控件工厂
private static TextBlock Section(string text) => new()
{
Text = text,
Foreground = BConst(CInk),
FontSize = 12.5,
FontWeight = FontWeight.SemiBold,
Margin = new Thickness(0, 2, 0, 2)
};
private static Border Divider() => new()
{
Height = 1,
Background = BConst(CLine),
Margin = new Thickness(0, 4, 0, 2)
};
private static TextBlock Bullet(string text) => new()
{
Text = "• " + text,
Foreground = BConst(CInkDim),
FontSize = 11.5,
TextWrapping = TextWrapping.Wrap,
LineHeight = 17
};
private Border MakePillButton(string label, Color bg)
{
var tb = new TextBlock { Text = label, Foreground = B(Colors.White), FontSize = 11.5, HorizontalAlignment = HorizontalAlignment.Center };
return new Border
{
Background = B(bg),
CornerRadius = new CornerRadius(8),
Padding = new Thickness(11, 6),
Cursor = new Avalonia.Input.Cursor(Avalonia.Input.StandardCursorType.Hand),
Child = tb
};
}
private static SolidColorBrush BConst(Color c) => new(c);
}
File diff suppressed because it is too large. Load diff
-225
View File
@@ -1,225 +0,0 @@
using System.Collections.Generic;
namespace GC.ContourMap;
/// <summary>内置全量文案兜底:没有语言包也能完整显示(复刻 HTML 课件全部文案)。</summary>
internal static class DefaultTexts
{
public static readonly Dictionary<string, string> Zh = new()
{
// 标题
["app.title"] = "等高线地形 · 五大典型地貌判读",
["app.subtitle"] = "七年级上册 · 从立体地形到平面等高线,判读山峰/山脊/山谷/鞍部/陡崖",
// 实验流程四步
["flow.title"] = "实验流程",
["flow.step.0"] = "等高切割",
["flow.step.1"] = "形成交线",
["flow.step.2"] = "投影成图",
["flow.step.3"] = "疏密判坡",
["flow.desc.0"] = "观察水平面与山体在同一海拔相交,形成连续闭合线。",
["flow.desc.1"] = "每个水平切面都会留下同高交线,多层交线共同描述山体起伏。",
["flow.desc.2"] = "把各高度交线垂直投影到同一平面,得到完整等高线地形图。",
["flow.desc.3"] = "等高线越密,坡度越陡;等高线越疏,坡度越缓。",
// 观察面板
["observe.title"] = "实验演示",
["observe.default"] = "点击开始实验,在立体地形中观察等高切割与交线形成,再通过四步图解理解投影与判坡。",
["observe.features"] = "判读要点",
["observe.default.f1"] = "同一条等高线上海拔相等",
["observe.default.f2"] = "相邻等高线高差保持一致",
// 五大典型地貌
["side.landforms"] = "五大典型地貌",
["landform.peak"] = "山峰",
["landform.ridge"] = "山脊",
["landform.valley"] = "山谷",
["landform.saddle"] = "鞍部",
["landform.cliff"] = "陡崖",
["landform.peak.sub"] = "闭合等高线",
["landform.ridge.sub"] = "凸低为脊",
["landform.valley.sub"] = "凸高为谷",
["landform.saddle.sub"] = "两峰之间",
["landform.cliff.sub"] = "密集或重合",
["landform.peak.summary"] = "山峰四周较低、中心突起;等高线闭合成环,海拔数值由外向内逐渐升高。",
["landform.ridge.summary"] = "等高线弯曲部分向海拔低处凸出,脊线常成为两侧水系的分水岭。",
["landform.valley.summary"] = "等高线弯曲部分向海拔高处凸出,谷底低洼并容易汇水形成河流。",
["landform.saddle.summary"] = "鞍部位于相邻两座山峰之间,是沿山脊方向相对低洼的过渡地带。",
["landform.cliff.summary"] = "陡崖坡面近直立,不同高程的等高线会高度密集,局部可投影到同一位置而重合。",
["landform.peak.f1"] = "中心海拔高、四周海拔低",
["landform.peak.f2"] = "闭合线越向内,数值越大",
["landform.peak.f3"] = "若数值向内降低,则应判为洼地",
["landform.ridge.f1"] = "等高线凸向低值方向",
["landform.ridge.f2"] = "脊线由高处向低处延伸",
["landform.ridge.f3"] = "雨水沿脊线两侧分流",
["landform.valley.f1"] = "等高线凸向高值方向",
["landform.valley.f2"] = "V 形尖端指向上游高处",
["landform.valley.f3"] = "谷底常发育河流",
["landform.saddle.f1"] = "两组闭合等高线相邻",
["landform.saddle.f2"] = "中部线条收窄,形似马鞍",
["landform.saddle.f3"] = "常是翻越山岭的低垭口",
["landform.cliff.f1"] = "密集表示陡坡,重合才是陡崖特征",
["landform.cliff.f2"] = "单位水平距离内高差很大",
["landform.cliff.f3"] = "n 条线重合时:(n−1)d ≤ ΔH < (n+1)d",
["landform.peak.hint"] = "山峰:闭合曲线,数值向中心升高",
["landform.ridge.hint"] = "山脊:等高线向低处凸出,凸低为脊",
["landform.valley.hint"] = "山谷:等高线向高处凸出,凸高为谷",
["landform.saddle.hint"] = "鞍部:两峰之间相对低洼,俯视轮廓呈收腰形",
["landform.cliff.hint"] = "陡崖:等高线密集或重合,坡度极陡",
// 按钮
["btn.play"] = "开始实验",
["btn.pause"] = "暂停实验",
["btn.replay"] = "重新实验",
["btn.reset"] = "重置",
["btn.view3d"] = "立体图",
["btn.viewTop"] = "俯视图",
["btn.color"] = "上色",
["btn.colorOn"] = "取消上色",
["btn.fullscreen"] = "全屏",
["btn.exitFullscreen"] = "退出全屏",
["btn.backExperiment"] = "返回实验",
// 侧栏判读要点(通用地形)
["side.features"] = "五种地形部位",
["feature.peak"] = "山峰",
["feature.peakDesc"] = "等高线闭合,数值由中心向四周递减。",
["feature.ridge"] = "山脊",
["feature.ridgeDesc"] = "等高线凸向低处,脊线是分水线。",
["feature.valley"] = "山谷",
["feature.valleyDesc"] = "等高线凸向高处,谷线是集水线,常发育河流。",
["feature.saddle"] = "鞍部",
["feature.saddleDesc"] = "两个山峰之间的低地,形如马鞍。",
["feature.cliff"] = "陡崖",
["feature.cliffDesc"] = "等高线重叠或非常密集,近乎垂直。",
["feature.slope"] = "坡面",
// 判读规则
["side.rules"] = "判读要点",
["rule.interval"] = "等高距:相邻两条等高线的高度差,本图 100 米。",
["rule.dense"] = "等高线越密坡越陡,越疏坡越缓。",
["rule.index"] = "每 5 条加粗一条计曲线,标注海拔便于读数。",
["rule.height"] = "海拔:某地高出海平面的垂直距离;相对高度:两点海拔之差。",
// 底部读数 / 图例
["footer.hint"] = "拖动立体地形旋转、滚轮缩放;鼠标悬停可查看该点海拔与地形部位",
["footer.readout"] = "海拔 {0} m 相对高度 {1} m",
["legend.title"] = "分层设色",
["profile.title"] = "地形剖面图",
["slope.gentle"] = "缓坡(线疏)",
["slope.steep"] = "陡坡(线密)",
["hint.play"] = "点击“开始实验”,观察等高切割与交线形成",
["hint.playing"] = "实验播放中",
["hint.paused"] = "实验已暂停 · 点击继续恢复播放",
["hint.done"] = "实验流程播放完成 · 可重新实验或选择典型地貌观察"
};
public static readonly Dictionary<string, string> En = new()
{
["app.title"] = "Contour Lines · Five Classic Landforms",
["app.subtitle"] = "Grade 7 · From 3D relief to contour maps: peaks, ridges, valleys, saddles and cliffs",
["flow.title"] = "Experiment flow",
["flow.step.0"] = "Contour cutting",
["flow.step.1"] = "Forming lines",
["flow.step.2"] = "Projection",
["flow.step.3"] = "Slope density",
["flow.desc.0"] = "Watch a horizontal plane intersect the mountain at one elevation, forming closed lines.",
["flow.desc.1"] = "Each horizontal slice leaves an equal-height line; stacked lines describe the relief.",
["flow.desc.2"] = "Project every intersection line vertically onto one plane to build the contour map.",
["flow.desc.3"] = "Contours closer together mean a steeper slope; wider apart mean a gentler one.",
["observe.title"] = "Experiment demo",
["observe.default"] = "Press play to watch contour cutting and line formation, then use the four steps to learn projection and slope reading.",
["observe.features"] = "Key points",
["observe.default.f1"] = "All points on one contour share the same elevation",
["observe.default.f2"] = "Neighbouring contours keep a constant height interval",
["side.landforms"] = "Five classic landforms",
["landform.peak"] = "Peak",
["landform.ridge"] = "Ridge",
["landform.valley"] = "Valley",
["landform.saddle"] = "Saddle",
["landform.cliff"] = "Cliff",
["landform.peak.sub"] = "Closed contours",
["landform.ridge.sub"] = "Bulges toward low ground",
["landform.valley.sub"] = "Bulges toward high ground",
["landform.saddle.sub"] = "Between two peaks",
["landform.cliff.sub"] = "Dense or overlapping",
["landform.peak.summary"] = "A peak rises in the centre with lower ground around it; contours close into rings and values increase inward.",
["landform.ridge.summary"] = "Contours bulge toward lower ground; a ridge line often divides two drainage systems.",
["landform.valley.summary"] = "Contours bulge toward higher ground; valleys are low and collect water into streams.",
["landform.saddle.summary"] = "A saddle lies between two adjacent peaks, a relatively low pass along the ridge.",
["landform.cliff.summary"] = "A cliff face is nearly vertical, so contours crowd tightly or even overlap.",
["landform.peak.f1"] = "High centre, low surroundings",
["landform.peak.f2"] = "Closed lines grow in value inward",
["landform.peak.f3"] = "If values drop inward, it is a depression",
["landform.ridge.f1"] = "Contours bulge toward lower values",
["landform.ridge.f2"] = "Ridge line runs from high to low",
["landform.ridge.f3"] = "Rain drains to either side of the ridge",
["landform.valley.f1"] = "Contours bulge toward higher values",
["landform.valley.f2"] = "V tip points upstream to high ground",
["landform.valley.f3"] = "Streams often form along the valley floor",
["landform.saddle.f1"] = "Two neighbouring closed contour groups",
["landform.saddle.f2"] = "Contours pinch in the middle like a saddle",
["landform.saddle.f3"] = "Often a low mountain pass",
["landform.cliff.f1"] = "Dense means steep; overlap means cliff",
["landform.cliff.f2"] = "Large elevation change over a short distance",
["landform.cliff.f3"] = "n overlapping lines: (n−1)d ≤ ΔH < (n+1)d",
["landform.peak.hint"] = "Peak: closed curves, values rise toward the centre",
["landform.ridge.hint"] = "Ridge: contours bulge toward low ground",
["landform.valley.hint"] = "Valley: contours bulge toward high ground",
["landform.saddle.hint"] = "Saddle: low ground between two peaks",
["landform.cliff.hint"] = "Cliff: contours dense or overlapping, very steep",
["btn.play"] = "Start experiment",
["btn.pause"] = "Pause experiment",
["btn.replay"] = "Replay experiment",
["btn.reset"] = "Reset",
["btn.view3d"] = "3D view",
["btn.viewTop"] = "Top view",
["btn.color"] = "Colour",
["btn.colorOn"] = "No colour",
["btn.fullscreen"] = "Fullscreen",
["btn.exitFullscreen"] = "Exit fullscreen",
["btn.backExperiment"] = "Back to experiment",
["side.features"] = "Five terrain features",
["feature.peak"] = "Peak",
["feature.peakDesc"] = "Closed contours; values decrease outward from the centre.",
["feature.ridge"] = "Ridge",
["feature.ridgeDesc"] = "Contours bulge toward lower ground; a watershed line.",
["feature.valley"] = "Valley",
["feature.valleyDesc"] = "Contours bulge toward higher ground; a drainage line, often a stream.",
["feature.saddle"] = "Saddle",
["feature.saddleDesc"] = "Low ground between two peaks, shaped like a saddle.",
["feature.cliff"] = "Cliff",
["feature.cliffDesc"] = "Contours overlap or crowd tightly — nearly vertical.",
["feature.slope"] = "Slope",
["side.rules"] = "Key rules",
["rule.interval"] = "Contour interval: height gap between neighbours (100 m here).",
["rule.dense"] = "Closer contours = steeper slope; wider spacing = gentler.",
["rule.index"] = "Every 5th contour is bolded and labelled as an index contour.",
["rule.height"] = "Elevation above sea level; relative height is the difference of two elevations.",
["footer.hint"] = "Drag the 3D terrain to rotate, scroll to zoom; hover to read elevation and terrain feature",
["footer.readout"] = "Elevation {0} m Relative height {1} m",
["legend.title"] = "Hypsometric tint",
["profile.title"] = "Terrain profile",
["slope.gentle"] = "Gentle (sparse lines)",
["slope.steep"] = "Steep (dense lines)",
["hint.play"] = "Press start to watch contour cutting and line formation",
["hint.playing"] = "Experiment playing",
["hint.paused"] = "Experiment paused · press to resume",
["hint.done"] = "Experiment finished · replay or choose a landform"
};
}
-194
View File
@@ -1,194 +0,0 @@
using System;
using System.Collections.Generic;
namespace GC.ContourMap;
/// <summary>地形部位识别结果:课本要求学生能在等高线图上认出这五种部位。</summary>
public enum TerrainFeature
{
None,
Peak, // 山峰
Ridge, // 山脊
Valley, // 山谷
Saddle, // 鞍部
Cliff, // 陡崖
Slope // 一般坡面
}
/// <summary>
/// 地形判读:根据高度场与坡度,判断任意一点属于哪种地形部位。
/// 这是课本「等高线判读」的核心,直接从数据算出来,不靠预设标记。
/// </summary>
public static class TerrainAnalyzer
{
/// <summary>
/// 判断某点的地形部位。
///
/// 先查地形自带的**标注区**(教学用,位置由地形定义保证准确),
/// 未命中再按坡度/曲率自动推断。纯几何推断对「鞍部」「陡崖」这类
/// 特征容易误判,教学场景必须精确。
/// </summary>
public static TerrainFeature Classify(TerrainField field, double u, double v)
{
var tagged = field.TagAt(u, v);
if (tagged != TerrainFeature.None) return tagged;
var h = field.SampleSmooth(u, v);
var grad = Gradient(field, u, v);
var slope = Math.Sqrt(grad.dU * grad.dU + grad.dV * grad.dV); // 归一化坡度
// 陡崖:坡度极大(等高线挤成一团)。
// 阈值按本图实际坡度分布标定(中位≈2.5、p99≈6.8),
// 取 p99 以上一小段,否则大片坡面会被误判成陡崖。
if (slope > 8.5) return TerrainFeature.Cliff;
// 山峰:比四周都高
if (IsLocalMax(field, u, v)) return TerrainFeature.Peak;
// 鞍部:两个方向上高、另两个方向上低
if (IsSaddle(field, u, v)) return TerrainFeature.Saddle;
// 山脊 / 山谷:看曲率(横切方向是凸还是凹)
var curvature = CrossCurvature(field, u, v, grad);
if (curvature < -0.55) return TerrainFeature.Ridge; // 向外凸
if (curvature > 0.55) return TerrainFeature.Valley; // 向内凹
return TerrainFeature.Slope;
}
private static (double dU, double dV) Gradient(TerrainField f, double u, double v)
{
const double h = 0.004;
var du = (f.SampleSmooth(u + h, v) - f.SampleSmooth(u - h, v)) / (2 * h);
var dv = (f.SampleSmooth(u, v + h) - f.SampleSmooth(u, v - h)) / (2 * h);
return (du / 1000.0, dv / 1000.0); // 归一化到 0~1 量级
}
private static bool IsLocalMax(TerrainField f, double u, double v)
{
var c = f.SampleSmooth(u, v);
const double r = 0.035;
foreach (var (du, dv) in new[] { (r, 0.0), (-r, 0.0), (0.0, r), (0.0, -r) })
{
// 越近边界越不判为峰
if (u + du < 0 || u + du > 1 || v + dv < 0 || v + dv > 1) return false;
if (f.SampleSmooth(u + du, v + dv) >= c - 4) return false;
}
return true;
}
private static bool IsSaddle(TerrainField f, double u, double v)
{
const double r = 0.05;
if (u - r < 0 || u + r > 1 || v - r < 0 || v + r > 1) return false;
var c = f.SampleSmooth(u, v);
var l = f.SampleSmooth(u - r, v); var rt = f.SampleSmooth(u + r, v);
var t = f.SampleSmooth(u, v - r); var b = f.SampleSmooth(u, v + r);
// 一对高、一对低 => 鞍部
var horizHigh = l > c + 8 && rt > c + 8;
var vertLow = t < c - 8 && b < c - 8;
var vertHigh = t > c + 8 && b > c + 8;
var horizLow = l < c - 8 && rt < c - 8;
return (horizHigh && vertLow) || (vertHigh && horizLow);
}
/// <summary>横切等高线方向的曲率:负=山脊(凸),正=山谷(凹)。</summary>
private static double CrossCurvature(TerrainField f, double u, double v, (double dU, double dV) grad)
{
var len = Math.Sqrt(grad.dU * grad.dU + grad.dV * grad.dV);
if (len < 1e-6) return 0;
// 垂直于梯度方向(即沿等高线方向)的平均法向变化
var nU = -grad.dV / len;
var nV = grad.dU / len;
const double r = 0.045;
var c = f.SampleSmooth(u, v);
if (u + nU * r < 0 || u + nU * r > 1 || v + nV * r < 0 || v + nV * r > 1) return 0;
if (u - nU * r < 0 || u - nU * r > 1 || v - nV * r < 0 || v - nV * r > 1) return 0;
var a = f.SampleSmooth(u + nU * r, v + nV * r);
var b = f.SampleSmooth(u - nU * r, v - nV * r);
return (a + b - 2 * c) / 1000.0 * 6.0;
}
/// <summary>
/// 教科书规范的**分层设色**:按固定高程档位套用固定色阶,档内不渐变。
///
/// 人教版七年级上册的分层设色色阶(自低到高):
/// 深绿 → 浅绿 → 绿 → 浅黄 → 黄 → 浅褐 → 褐 → 浅棕 → 白
/// 关键点:**同一档内颜色完全相同**,这样一眼就能数出有几层,
/// 而不是课本上那种连续渐变。
/// </summary>
public static (byte R, byte G, byte B) ColorForHeight(float h, float min, float max)
{
// 按绝对高程分档(教科书就是这么画的:看的是海拔,不是相对高度)
if (h < 200) return (0x1E, 0x6B, 0x3A); // 深绿:< 200 m
if (h < 400) return (0x4E, 0x9E, 0x4E); // 浅绿:200–400
if (h < 600) return (0xA8, 0xC6, 0x66); // 绿:400–600
if (h < 800) return (0xE8, 0xE2, 0x9A); // 浅黄:600–800
if (h < 1000) return (0xE0, 0xC0, 0x5A); // 黄:800–1000
if (h < 1200) return (0xC8, 0x9A, 0x63); // 浅褐:1000–1200
if (h < 1400) return (0xA8, 0x74, 0x4C); // 褐:1200–1400
if (h < 1600) return (0xC8, 0xA8, 0x8C); // 浅棕:1400–1600
return (0xF5, 0xF5, 0xF0); // 白:> 1600(雪线以上)
}
/// <summary>
/// 3D 立体视图用的连续设色:与俯视图同一套色阶,但在档位之间线性过渡。
/// 立体视图的色块是按三角面着色的,直接用硬分档会在坡面上切出锯齿状阶梯,
/// 看起来像渲染错误;俯视图仍保留硬分档(那才是课本的分层设色)。
/// </summary>
public static (byte R, byte G, byte B) ColorForHeightSmooth(float h)
{
// 每个档位的代表色(取档位中心),由低到高
(byte R, byte G, byte B)[] stops =
{
(0x1E, 0x6B, 0x3A), (0x4E, 0x9E, 0x4E), (0xA8, 0xC6, 0x66),
(0xE8, 0xE2, 0x9A), (0xE0, 0xC0, 0x5A), (0xC8, 0x9A, 0x63),
(0xA8, 0x74, 0x4C), (0xC8, 0xA8, 0x8C), (0xF5, 0xF5, 0xF0)
};
const float band = 200f;
var p = Math.Clamp(h / band - 0.5f, 0f, stops.Length - 1f); // 0 => 档心 100 m
var i = (int)Math.Floor(p);
var j = Math.Min(i + 1, stops.Length - 1);
var t = p - i;
t = t * t * (3 - 2 * t); // 平滑过渡
return (Lerp(stops[i].R, stops[j].R, t),
Lerp(stops[i].G, stops[j].G, t),
Lerp(stops[i].B, stops[j].B, t));
}
/// <summary>该颜色属于哪一档(用于图例)。</summary>
public static string BandName(float h) => h switch
{
< 200 => "200 米以下",
< 400 => "200–400 米",
< 600 => "400–600 米",
< 800 => "600–800 米",
< 1000 => "800–1000 米",
< 1200 => "1000–1200 米",
< 1400 => "1200–1400 米",
< 1600 => "1400–1600 米",
_ => "1600 米以上"
};
private static byte Lerp(byte a, byte b, double k)
=> (byte)Math.Clamp(a + (b - a) * k, 0, 255);
/// <summary>
/// 归一化坡度(0=平缓,1=陡峭),用于「疏密判坡」着色。
/// 以有限差分求地面梯度,并按本模型的典型高差归一化。
/// </summary>
public static double SlopeAt(TerrainField f, double u, double v)
{
const double h = 0.006;
var du = (f.SampleSmooth(u + h, v) - f.SampleSmooth(u - h, v)) / (2 * h);
var dv = (f.SampleSmooth(u, v + h) - f.SampleSmooth(u, v - h)) / (2 * h);
var grad = Math.Sqrt(du * du + dv * dv); // 米 / 归一化距离
// 按本图实际起伏自适应归一化:跨度越大,同样的相对坡度对应更大的梯度。
// 固定阈值会让所有山体都顶到 1(整片红),判坡就失效了。
var span = Math.Max(60f, f.MaxHeight - f.MinHeight);
return Math.Clamp(grad / (span * 2.6), 0, 1);
}
}
-707
View File
@@ -1,707 +0,0 @@
using System;
using System.Collections.Generic;
namespace GC.ContourMap;
/// <summary>五种基本地形类型(教科书分类)。</summary>
public enum TerrainKind
{
Mountain, // 山地:海拔高、起伏大
Basin, // 盆地:四周高、中间低
Hill, // 丘陵:海拔较低、坡度和缓
Plateau, // 高原:海拔高、地面平坦、边缘陡
Plain // 平原:海拔低、地面平坦
}
/// <summary>五大典型地貌部位(等高线判读的核心对象)。</summary>
public enum LandformKind
{
Peak, // 山峰:闭合等高线,数值向内升高
Ridge, // 山脊:等高线凸向低处,凸低为脊
Valley, // 山谷:等高线凸向高处,凸高为谷
Saddle, // 鞍部:两峰之间相对低洼,俯视收腰
Cliff // 陡崖:等高线密集甚至重合
}
/// <summary>
/// 地形高度场(等高线模型的数据核心)。
///
/// 用叠加的高斯山包合成一块教学用地形:
/// · 主峰(山峰)
/// · 次峰(与主峰之间形成鞍部)
/// · 两条山脊、一条山谷
/// · 一侧陡坡(等高线密集)、一侧缓坡(等高线稀疏)
/// · 一处陡崖
///
/// 高度单位米,网格分辨率可配置;网格值一次性算好,等高线由它切线得出。
/// </summary>
public sealed class TerrainField
{
/// <summary>网格边长(正方形,便于俯视与等高线处理)。</summary>
public int Size { get; }
/// <summary>海拔网格,[y, x],单位米。</summary>
public float[,] Heights { get; }
public float MinHeight { get; private set; }
public float MaxHeight { get; private set; }
/// <summary>等高距(米):教学图常用 100 m。</summary>
public float Interval { get; init; } = 100f;
/// <summary>这块地形属于哪种类型(决定界面标题与说明)。</summary>
public TerrainKind Kind { get; }
/// <summary>若这块地形是某个典型地貌部位,则记录其种类;否则为 null。</summary>
public LandformKind? Landform { get; }
public TerrainField(TerrainKind kind = TerrainKind.Mountain, int size = 192)
{
Size = size;
Kind = kind;
Heights = new float[size, size];
Build(kind);
}
/// <summary>创建一个专门表现某种典型地貌部位的高度场。</summary>
public TerrainField(LandformKind landform, int size = 192)
{
Size = size;
Kind = TerrainKind.Mountain;
Landform = landform;
Heights = new float[size, size];
BuildLandform(landform);
}
/// <summary>该类型对应的等高距:平原/丘陵用 20m,山地/高原/盆地用 100m。</summary>
public float EffectiveInterval => Kind switch
{
TerrainKind.Plain => 5f, // 平原起伏小,等高距要小才画得出线
TerrainKind.Hill => 10f, // 丘陵相对高差约 150 m
_ => 100f
};
/// <summary>归一化坐标 (u,v) ∈ [0,1],u 向东、v 向南。</summary>
public float HeightAt(double u, double v)
{
var x = (int)Math.Round(u * (Size - 1));
var y = (int)Math.Round(v * (Size - 1));
x = Math.Clamp(x, 0, Size - 1);
y = Math.Clamp(y, 0, Size - 1);
return Heights[y, x];
}
/// <summary>双线性插值取值,画平滑曲线时用。</summary>
public float SampleSmooth(double u, double v)
{
var fx = Math.Clamp(u, 0, 1) * (Size - 1);
var fy = Math.Clamp(v, 0, 1) * (Size - 1);
var x0 = (int)Math.Floor(fx); var y0 = (int)Math.Floor(fy);
var x1 = Math.Min(x0 + 1, Size - 1); var y1 = Math.Min(y0 + 1, Size - 1);
var tx = fx - x0; var ty = fy - y0;
var h00 = Heights[y0, x0]; var h10 = Heights[y0, x1];
var h01 = Heights[y1, x0]; var h11 = Heights[y1, x1];
var a = h00 * (1 - tx) + h10 * tx;
var b = h01 * (1 - tx) + h11 * tx;
return (float)(a * (1 - ty) + b * ty);
}
private void Build(TerrainKind kind)
{
switch (kind)
{
case TerrainKind.Mountain: BuildMountain(); break;
case TerrainKind.Basin: BuildBasin(); break;
case TerrainKind.Hill: BuildHill(); break;
case TerrainKind.Plateau: BuildPlateau(); break;
case TerrainKind.Plain: BuildPlain(); break;
}
BuildFeatures();
}
private void BuildMountain()
{
// 各山体参数:中心(u,v)、高度、东西半径、南北半径
var peaks = new (double U, double V, double H, double RU, double RV)[]
{
(0.34, 0.34, 1180, 0.26, 0.24), // 主峰
(0.66, 0.52, 860, 0.20, 0.20), // 次峰(与主峰间成鞍部)
(0.22, 0.70, 520, 0.18, 0.16), // 西侧小山
(0.78, 0.22, 430, 0.16, 0.15), // 东北小山
};
var min = float.MaxValue; var max = float.MinValue;
for (var y = 0; y < Size; y++)
{
for (var x = 0; x < Size; x++)
{
var u = (double)x / (Size - 1);
var v = (double)y / (Size - 1);
double h = 120; // 基准面(平原 / 河谷)
foreach (var p in peaks)
{
var du = (u - p.U) / p.RU;
var dv = (v - p.V) / p.RV;
var d2 = du * du + dv * dv;
h += p.H * Math.Exp(-d2 * 1.15);
}
// 山谷:沿一条斜线切下去,形成 V 形谷地
var valley = Math.Abs((u - 0.5) * 0.8 + (v - 0.44) * 0.6);
h -= 210 * Math.Exp(-valley * valley / 0.0016);
// 陡崖:东侧一条近乎垂直的高差带(等高线会挤在一起)
if (u > 0.86 && v > 0.18 && v < 0.72)
h += 260 * SmoothStep(0.86, 0.895, u);
// 缓坡:西南角缓慢抬升
if (u < 0.3 && v > 0.6)
h += 90 * (1 - u / 0.3) * ((v - 0.6) / 0.4);
// 轻微起伏,避免地形过于几何化
h += 18 * Math.Sin(u * 9.1) * Math.Cos(v * 7.7);
var hf = (float)Math.Max(0, h);
Heights[y, x] = hf;
if (hf < min) min = hf;
if (hf > max) max = hf;
}
}
MinHeight = min;
MaxHeight = max;
}
/// <summary>盆地:四周高、中间低,等高线由外向内递减。</summary>
private void BuildBasin()
{
var min = float.MaxValue; var max = float.MinValue;
for (var y = 0; y < Size; y++)
{
for (var x = 0; x < Size; x++)
{
var u = (double)x / (Size - 1);
var v = (double)y / (Size - 1);
var du = u - 0.5; var dv = v - 0.5;
var r = Math.Sqrt(du * du + dv * dv) * 2.0; // 0=中心 1=边缘
// 边缘抬升、中心下沉,形成碗状
double h = 160 + 900 * Math.Pow(Math.Clamp(r, 0, 1.15), 2.2);
// 一侧开个缺口(山口),让盆地向外开口
var gap = Math.Abs(Math.Atan2(dv, du) - 0.5);
if (gap < 0.35) h -= 320 * (1 - gap / 0.35) * (1 - Math.Clamp(r, 0, 1));
h += 14 * Math.Sin(u * 7.3) * Math.Cos(v * 6.1);
var hf = (float)Math.Max(0, h);
Heights[y, x] = hf;
if (hf < min) min = hf;
if (hf > max) max = hf;
}
}
MinHeight = min; MaxHeight = max;
}
/// <summary>丘陵:起伏和缓、海拔不高,等高线稀疏而弯曲。</summary>
private void BuildHill()
{
var bumps = new (double U, double V, double H, double R)[]
{
(0.30, 0.32, 120, 0.20), (0.66, 0.28, 95, 0.17),
(0.52, 0.62, 140, 0.22), (0.22, 0.72, 88, 0.16),
(0.78, 0.70, 110, 0.18),
};
var min = float.MaxValue; var max = float.MinValue;
for (var y = 0; y < Size; y++)
{
for (var x = 0; x < Size; x++)
{
var u = (double)x / (Size - 1);
var v = (double)y / (Size - 1);
double h = 60;
foreach (var b in bumps)
{
var du = (u - b.U) / b.R; var dv = (v - b.V) / b.R;
h += b.H * Math.Exp(-(du * du + dv * dv) * 1.3);
}
h += 10 * Math.Sin(u * 11.0) * Math.Cos(v * 9.0);
var hf = (float)Math.Max(0, h);
Heights[y, x] = hf;
if (hf < min) min = hf;
if (hf > max) max = hf;
}
}
MinHeight = min; MaxHeight = max;
}
/// <summary>高原:顶部平坦、边缘陡峭(等高线在中部稀疏、边缘密集)。</summary>
private void BuildPlateau()
{
var min = float.MaxValue; var max = float.MinValue;
for (var y = 0; y < Size; y++)
{
for (var x = 0; x < Size; x++)
{
var u = (double)x / (Size - 1);
var v = (double)y / (Size - 1);
// 到中心的距离,做平台 + 陡降
var du = (u - 0.5); var dv = (v - 0.5);
var r = Math.Sqrt(du * du + dv * dv) * 2.0;
double h;
if (r < 0.55) h = 1250; // 平坦顶面
else h = 1250 - 1000 * SmoothStep(0.55, 0.78, r); // 边缘陡降
// 顶面轻微起伏,避免完全平板
if (r < 0.55) h += 25 * Math.Sin(u * 6.0) * Math.Cos(v * 5.0);
h += 30 * (1 - Math.Clamp(r, 0, 1));
var hf = (float)Math.Max(0, h);
Heights[y, x] = hf;
if (hf < min) min = hf;
if (hf > max) max = hf;
}
}
MinHeight = min; MaxHeight = max;
}
/// <summary>平原:地面低平、起伏极小,等高线很少。</summary>
private void BuildPlain()
{
var min = float.MaxValue; var max = float.MinValue;
for (var y = 0; y < Size; y++)
{
for (var x = 0; x < Size; x++)
{
var u = (double)x / (Size - 1);
var v = (double)y / (Size - 1);
// 整体微倾 + 极缓的起伏
double h = 40 + 22 * u + 8 * Math.Sin(u * 4.2) * Math.Cos(v * 3.6);
var hf = (float)Math.Max(0, h);
Heights[y, x] = hf;
if (hf < min) min = hf;
if (hf > max) max = hf;
}
}
MinHeight = min; MaxHeight = max;
}
// ───────────────────────── 五大典型地貌部位 ─────────────────────────
private void BuildLandform(LandformKind landform)
{
switch (landform)
{
case LandformKind.Peak: BuildPeak(); break;
case LandformKind.Ridge: BuildRidge(); break;
case LandformKind.Valley: BuildValley(); break;
case LandformKind.Saddle: BuildSaddle(); break;
case LandformKind.Cliff: BuildCliff(); break;
}
BuildFeatures();
}
/// <summary>山峰:单峰为主、层层闭合,四周逐级降低。配一处小侧峰便于读鞍部。</summary>
private void BuildPeak()
{
var min = double.MaxValue; var max = double.MinValue;
for (var y = 0; y < Size; y++)
for (var x = 0; x < Size; x++)
{
var u = (double)x / (Size - 1);
var v = (double)y / (Size - 1);
var du = u - 0.5; var dv = (v - 0.5) / 0.94;
var r = Math.Sqrt(du * du + dv * dv);
// 主峰:宽阔的穹状山体(半径约占图幅 8 成),层层闭合的等高线才画得开
var core = Math.Exp(-Math.Pow(r / 0.36, 1.85));
var rim = 1 - SmoothStep(0.36, 0.50, r); // 山脚过渡到平地
var h = 65 + 1230 * core * rim;
// 东南侧肩部,让等高线不是完美同心圆
h += 120 * Math.Exp(-(Math.Pow(u - 0.72, 2) + Math.Pow(v - 0.66, 2)) / 0.016) * rim;
h += 22 * Math.Sin(u * 7.3 + 0.6) * Math.Cos(v * 6.1) * rim;
h = Math.Max(0, h);
Heights[y, x] = (float)h;
if (h < min) min = h; if (h > max) max = h;
}
MinHeight = (float)min; MaxHeight = (float)max;
Tags.Clear();
Tags.Add((0.5, 0.5, 0.09, TerrainFeature.Peak));
}
/// <summary>山脊:一条狭长高地,等高线沿脊线向低处凸出(凸低为脊)。</summary>
private void BuildRidge()
{
var min = double.MaxValue; var max = double.MinValue;
for (var y = 0; y < Size; y++)
for (var x = 0; x < Size; x++)
{
var u = (double)x / (Size - 1);
var v = (double)y / (Size - 1);
// 脊线沿 u 方向(西高东低),东西向是长坡,南北向是宽缓的两翼
var crestV = 0.5 + 0.10 * Math.Sin(u * 3.1); // 脊线轻微弯曲
var across = v - crestV;
var crest = 1150 - 380 * u; // 脊线海拔由西向东降低
var lateral = Math.Exp(-Math.Pow(Math.Abs(across) / 0.27, 1.55));
var h = 85 + (crest - 85) * lateral;
// 两翼的次级起伏,避免像一堵直墙
h += 60 * Math.Exp(-Math.Pow(Math.Abs(across) - 0.30, 2) / 0.010) * (0.4 + 0.6 * (1 - u));
h += 24 * Math.Sin(u * 8.0) * Math.Cos(v * 5.6);
h = Math.Max(0, h);
Heights[y, x] = (float)h;
if (h < min) min = h; if (h > max) max = h;
}
MinHeight = (float)min; MaxHeight = (float)max;
Tags.Clear();
Tags.Add((0.30, 0.50, 0.09, TerrainFeature.Ridge));
Tags.Add((0.70, 0.50, 0.09, TerrainFeature.Ridge));
}
/// <summary>山谷:两侧高地夹持的低槽,等高线形成 V 形指向上游(凸高为谷)。</summary>
private void BuildValley()
{
var min = double.MaxValue; var max = double.MinValue;
for (var y = 0; y < Size; y++)
for (var x = 0; x < Size; x++)
{
var u = (double)x / (Size - 1);
var v = (double)y / (Size - 1);
// 谷轴沿 v 方向:两侧高、中间是 V 形谷底;北侧(v 小)为上游更高
var side = Math.Pow(Math.Abs(u - 0.5) / 0.5, 1.5); // 0=谷心 1=图边
var downhill = 1 - v; // 上游 1 → 下游 0
var h = 90 + 760 * downhill + 585 * side * (0.30 + 0.70 * downhill);
// 谷底再切深一点,形成明显的集水线
h -= 70 * Math.Exp(-Math.Pow(u - 0.5, 2) / 0.0022);
h += 18 * Math.Sin(u * 6.5) * Math.Cos(v * 7.2);
h = Math.Max(0, h);
Heights[y, x] = (float)h;
if (h < min) min = h; if (h > max) max = h;
}
MinHeight = (float)min; MaxHeight = (float)max;
Tags.Clear();
Tags.Add((0.50, 0.40, 0.075, TerrainFeature.Valley));
Tags.Add((0.50, 0.68, 0.075, TerrainFeature.Valley));
}
/// <summary>鞍部:两座山峰之间相对低洼、俯视轮廓收腰的过渡地带。</summary>
private void BuildSaddle()
{
var min = double.MaxValue; var max = double.MinValue;
for (var y = 0; y < Size; y++)
for (var x = 0; x < Size; x++)
{
var u = (double)x / (Size - 1);
var v = (double)y / (Size - 1);
// 两峰在 v≈0.5 的连线上,u=0.27 与 u=0.73;中间 u=0.5 为垭口
var d1 = Math.Sqrt(Math.Pow((u - 0.27) / 0.30, 2) + Math.Pow((v - 0.52) / 0.28, 2));
var d2 = Math.Sqrt(Math.Pow((u - 0.73) / 0.30, 2) + Math.Pow((v - 0.48) / 0.28, 2));
var p1 = 1140 * Math.Exp(-Math.Pow(d1, 2.2));
var p2 = 1060 * Math.Exp(-Math.Pow(d2, 2.2));
// 南北两侧缓慢降低,把两峰连成一条东西向的山梁
var bench = 330 * Math.Exp(-Math.Pow((v - 0.5) / 0.34, 2));
var h = 65 + bench + Math.Max(p1, p2);
h += 20 * Math.Sin(u * 8.0) * Math.Cos(v * 7.0);
h = Math.Max(0, h);
Heights[y, x] = (float)h;
if (h < min) min = h; if (h > max) max = h;
}
MinHeight = (float)min; MaxHeight = (float)max;
Tags.Clear();
Tags.Add((0.28, 0.50, 0.05, TerrainFeature.Peak));
Tags.Add((0.72, 0.50, 0.05, TerrainFeature.Peak));
Tags.Add((0.50, 0.50, 0.045, TerrainFeature.Saddle));
}
/// <summary>陡崖:一侧近乎直立的高差带,等高线在崖壁处高度密集甚至重合。</summary>
private void BuildCliff()
{
var min = double.MaxValue; var max = double.MinValue;
for (var y = 0; y < Size; y++)
for (var x = 0; x < Size; x++)
{
var u = (double)x / (Size - 1);
var v = (double)y / (Size - 1);
// 西侧低台地、东侧高台地,中间一条近乎直立的高差带形成陡崖
// 崖线略呈波状(真实崖壁不是一条直线),过渡带留出 2~3 个采样格
var edge = SmoothStep(0.50, 0.62, u + 0.045 * Math.Sin(v * 5.2) + 0.02 * Math.Sin(v * 11.0));
var h = 210 + 940 * edge;
// 高台地北高南低、顶面起伏,低台地保持缓坡
h += 170 * (1 - v) * edge;
h += 55 * Math.Sin(v * 5.4) * Math.Cos(u * 4.2) * (0.4 + 0.6 * edge);
h += 26 * Math.Sin(u * 9.0); // 顶面轻微起伏
h = Math.Max(0, h);
Heights[y, x] = (float)h;
if (h < min) min = h; if (h > max) max = h;
}
MinHeight = (float)min; MaxHeight = (float)max;
Tags.Clear();
Tags.Add((0.50, 0.50, 0.035, TerrainFeature.Cliff));
}
private static double SmoothStep(double a, double b, double x)
{
var t = Math.Clamp((x - a) / (b - a), 0, 1);
return t * t * (3 - 2 * t);
}
/// <summary>
/// 教学标注区:把「典型部位」的位置固化成圆形区域,
/// 保证判读结果与地形设计一致(纯几何推断对鞍部/陡崖易误判)。
/// </summary>
public List<(double U, double V, double Radius, TerrainFeature Feature)> Tags { get; } = new()
{
(0.34, 0.34, 0.045, TerrainFeature.Peak), // 主峰
(0.66, 0.52, 0.042, TerrainFeature.Peak), // 次峰
(0.50, 0.44, 0.055, TerrainFeature.Saddle), // 两峰之间的鞍部
(0.90, 0.45, 0.035, TerrainFeature.Cliff), // 东侧陡崖
(0.22, 0.70, 0.045, TerrainFeature.Ridge), // 西南山脊
(0.50, 0.22, 0.040, TerrainFeature.Valley), // 河谷
};
/// <summary>查询标注区;未命中返回 None。</summary>
public TerrainFeature TagAt(double u, double v)
{
foreach (var (tu, tv, r, f) in Tags)
{
var du = u - tu; var dv = v - tv;
if (du * du + dv * dv <= r * r) return f;
}
return TerrainFeature.None;
}
/// <summary>
/// 河流:从最高点出发,沿最陡下降方向流到图边。
/// 教科书上的河流画蓝色线,且**只在河谷(等高线凸向高处的一侧)里流**。
/// </summary>
public List<(double U, double V)> River { get; } = new();
/// <summary>山峰位置(用于画 ▲ 与高程数字):局部最高点。</summary>
public List<(double U, double V, float Height)> Peaks { get; } = new();
/// <summary>陡崖位置(用于画锯齿线):坡度极大处。</summary>
public List<(double U, double V)> Cliffs { get; } = new();
/// <summary>找出山峰、陡崖,并生成河流线。</summary>
private void BuildFeatures()
{
// --- 山峰:局部最高且足够高 ---
const int step = 4;
for (var y = step; y < Size - step; y += step)
{
for (var x = step; x < Size - step; x += step)
{
var u = (double)x / (Size - 1);
var v = (double)y / (Size - 1);
var h = Heights[y, x];
if (h < MaxHeight * 0.55) continue;
var isMax = true;
for (var dy = -step; dy <= step && isMax; dy += step)
for (var dx = -step; dx <= step; dx += step)
{
if (dx == 0 && dy == 0) continue;
if (Heights[y + dy, x + dx] > h) { isMax = false; break; }
}
if (isMax) Peaks.Add((u, v, h));
}
}
Peaks.Sort((a, b) => b.Height.CompareTo(a.Height));
// --- 陡崖:坡度极大 ---
const int cstep = 3;
for (var y = cstep; y < Size - cstep; y += cstep)
{
for (var x = cstep; x < Size - cstep; x += cstep)
{
var u = (double)x / (Size - 1);
var v = (double)y / (Size - 1);
var h = 0.004;
var du = (Heights[y, x + 2] - Heights[y, x - 2]) / (2 * h * (Size - 1)) / 1000;
var dv = (Heights[y + 2, x] - Heights[y - 2, x]) / (2 * h * (Size - 1)) / 1000;
var slope = Math.Sqrt(du * du + dv * dv);
if (slope > 0.11) Cliffs.Add((u, v));
}
}
// --- 河流:从最高点沿最陡下降方向走 ---
if (Peaks.Count > 0)
{
var start = Peaks[0];
var cu = start.U; var cv = start.V;
River.Add((cu, cv));
const int maxSteps = 400;
for (var step2 = 0; step2 < maxSteps; step2++)
{
var h0 = SampleSmooth(cu, cv);
double bestU = 0, bestV = 0; var bestH = h0; var found = false;
for (var a = 0; a < 16; a++)
{
var ang = a * Math.PI * 2 / 16;
var nu = cu + Math.Cos(ang) * 0.012;
var nv = cv + Math.Sin(ang) * 0.012;
if (nu < 0 || nu > 1 || nv < 0 || nv > 1) continue;
var nh = SampleSmooth(nu, nv);
if (nh < bestH) { bestH = nh; bestU = nu; bestV = nv; found = true; }
}
if (!found) break;
cu = bestU; cv = bestV;
River.Add((cu, cv));
if (cu <= 0.001 || cu >= 0.999 || cv <= 0.001 || cv >= 0.999) break;
if (bestH < MinHeight + 20) break;
}
}
}
/// <summary>等高线高度列表:从 MaxHeight 往下按等高距取整。</summary>
public List<float> ContourLevels()
{
var levels = new List<float>();
var iv = EffectiveInterval;
var top = (float)(Math.Floor(MaxHeight / iv) * iv);
var bottom = (float)(Math.Ceiling(MinHeight / iv) * iv);
for (var h = bottom; h <= top + 0.01f; h += iv)
levels.Add(h);
levels.Sort();
return levels;
}
/// <summary>
/// 用 Marching Squares 提取某条等高线,返回若干条折线(归一化坐标)。
/// </summary>
public List<List<(double U, double V)>> ExtractContour(float level)
{
var result = new List<List<(double, double)>>();
var size = Size;
// 记录每条线段,再按端点连通性串成折线
var segments = new List<(double U1, double V1, double U2, double V2)>();
for (var y = 0; y < size - 1; y++)
{
for (var x = 0; x < size - 1; x++)
{
var h00 = Heights[y, x];
var h10 = Heights[y, x + 1];
var h11 = Heights[y + 1, x + 1];
var h01 = Heights[y + 1, x];
var idx = 0;
if (h00 >= level) idx |= 1;
if (h10 >= level) idx |= 2;
if (h11 >= level) idx |= 4;
if (h01 >= level) idx |= 8;
if (idx == 0 || idx == 15) continue;
double u0 = (double)x / (size - 1), u1 = (double)(x + 1) / (size - 1);
double v0 = (double)y / (size - 1), v1 = (double)(y + 1) / (size - 1);
// 四条边上的交点
(double, double) Top() => (Lerp(u0, u1, (level - h00) / (h10 - h00)), v0);
(double, double) Bottom() => (Lerp(u0, u1, (level - h01) / (h11 - h01)), v1);
(double, double) Left() => (u0, Lerp(v0, v1, (level - h00) / (h01 - h00)));
(double, double) Right() => (u1, Lerp(v0, v1, (level - h10) / (h11 - h10)));
void Add((double U, double V) a, (double U, double V) b)
=> segments.Add((a.Item1, a.Item2, b.Item1, b.Item2));
switch (idx)
{
case 1: case 14: Add(Left(), Top()); break;
case 2: case 13: Add(Top(), Right()); break;
case 3: case 12: Add(Left(), Right()); break;
case 4: case 11: Add(Right(), Bottom()); break;
case 6: case 9: Add(Top(), Bottom()); break;
case 7: case 8: Add(Left(), Bottom()); break;
case 5: Add(Left(), Top()); Add(Right(), Bottom()); break;
case 10: Add(Top(), Right()); Add(Left(), Bottom()); break;
}
}
}
return Chain(segments);
}
private static double Lerp(double a, double b, double t)
=> a + (b - a) * Math.Clamp(double.IsNaN(t) ? 0.5 : t, 0, 1);
/// <summary>
/// 把零散线段按端点串成完整折线。
/// 关键点:必须**两端都延伸**。只往尾部延伸时,起点落在曲线中段就会把一条等高线
/// 切成许多短链,渲染出来是断续的虚线(学生看到的就是“虚线等高线”)。
/// </summary>
private static List<List<(double U, double V)>> Chain(
List<(double U1, double V1, double U2, double V2)> segments)
{
// 量化到 1e-4 的网格做端点索引:共享边上的交点由同一次插值算出,
// 端点值完全一致;网格远小于采样间距(1/192≈0.0052),不会误并。
const double Q = 1e4;
static (long, long) Key(double u, double v)
=> ((long)Math.Round(u * Q), (long)Math.Round(v * Q));
var index = new Dictionary<(long, long), List<int>>();
void Register(double u, double v, int seg)
{
var k = Key(u, v);
if (!index.TryGetValue(k, out var list)) index[k] = list = new List<int>();
list.Add(seg);
}
for (var i = 0; i < segments.Count; i++)
{
Register(segments[i].U1, segments[i].V1, i);
Register(segments[i].U2, segments[i].V2, i);
}
var used = new bool[segments.Count];
var result = new List<List<(double, double)>>();
int NextAt(double u, double v)
{
if (!index.TryGetValue(Key(u, v), out var list)) return -1;
foreach (var j in list) if (!used[j]) return j;
return -1;
}
for (var i = 0; i < segments.Count; i++)
{
if (used[i]) continue;
used[i] = true;
var line = new List<(double U, double V)>
{
(segments[i].U1, segments[i].V1),
(segments[i].U2, segments[i].V2)
};
// 向尾部延伸
while (true)
{
var (tu, tv) = line[^1];
var j = NextAt(tu, tv);
if (j < 0) break;
used[j] = true;
var s = segments[j];
line.Add(Key(s.U1, s.V1) == Key(tu, tv) ? (s.U2, s.V2) : (s.U1, s.V1));
}
// 向头部延伸
while (true)
{
var (hu, hv) = line[0];
var j = NextAt(hu, hv);
if (j < 0) break;
used[j] = true;
var s = segments[j];
line.Insert(0, Key(s.U1, s.V1) == Key(hu, hv) ? (s.U2, s.V2) : (s.U1, s.V1));
}
if (line.Count >= 3) result.Add(line);
}
return result;
}
private static bool Near(double u1, double v1, double u2, double v2, double eps)
=> Math.Abs(u1 - u2) < eps && Math.Abs(v1 - v2) < eps;
}
+1 -1
View File
@@ -26,5 +26,5 @@
"frame": "#0A1524"
},
"build": "cc68b8863b",
"updatedAt": "2026-11-19T10:20:00Z"
"updatedAt": "2026-11-21T10:55:36Z"
}
@@ -1,29 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>disable</ImplicitUsings>
<RootNamespace>GC.EarthModels</RootNamespace>
<AssemblyName>EarthGeographyModel</AssemblyName>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<IsPackable>false</IsPackable>
</PropertyGroup>
<!-- 共享引擎源码(模型目录内),只编译需要的部分 -->
<ItemGroup>
<Compile Include="../../_engine/src/ModelJson.cs" />
<Compile Include="../../_engine/src/Geometry.cs" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="Avalonia" Version="$(AvaloniaVersion)" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\_sdk\GC.ModelSdk\GC.ModelSdk.csproj">
<Private>false</Private>
</ProjectReference>
</ItemGroup>
</Project>
-96
View File
@@ -1,96 +0,0 @@
using System.Collections.Generic;
using System.Text.Json.Serialization;
namespace GC.EarthModels;
/// <summary>地球地理模型的数据文件:全部是经纬度折线,只有轮廓没有填色。</summary>
public sealed class GeoData
{
[JsonPropertyName("lines")] public List<List<double[]>> Lines { get; set; } = new();
}
public sealed class PlateEntry
{
[JsonPropertyName("id")] public string Id { get; set; } = "";
[JsonPropertyName("nameI18n")] public Dictionary<string, string>? NameI18n { get; set; }
/// <summary>标签锚点 [lon, lat];缺省时用轮廓质心。</summary>
[JsonPropertyName("label")] public double[]? Label { get; set; }
[JsonPropertyName("lines")] public List<List<double[]>> Lines { get; set; } = new();
}
public sealed class PlateData
{
[JsonPropertyName("plates")] public List<PlateEntry> Plates { get; set; } = new();
}
/// <summary>大陆(六块大陆里的教材五块写法)。结构与板块一致,纯线稿。</summary>
public sealed class ContinentData
{
[JsonPropertyName("continents")] public List<PlateEntry> Continents { get; set; } = new();
}
public sealed class BorderEntry
{
/// <summary>分界的两个大洲,如「亚洲-非洲」。</summary>
[JsonPropertyName("between")] public string Between { get; set; } = "";
/// <summary>分界标志名称,如「苏伊士运河」。</summary>
[JsonPropertyName("name")] public string Name { get; set; } = "";
[JsonPropertyName("nameI18n")] public Dictionary<string, string>? NameI18n { get; set; }
[JsonPropertyName("lines")] public List<List<double[]>> Lines { get; set; } = new();
/// <summary>复合分界的逐段明细(如亚欧分界的六个地理标志)。</summary>
[JsonPropertyName("segments")] public List<BorderSegment>? Segments { get; set; }
}
public sealed class BorderSegment
{
[JsonPropertyName("name")] public string Name { get; set; } = "";
[JsonPropertyName("nameI18n")] public Dictionary<string, string>? NameI18n { get; set; }
[JsonPropertyName("lines")] public List<List<double[]>> Lines { get; set; } = new();
}
public sealed class BorderData
{
[JsonPropertyName("borders")] public List<BorderEntry> Borders { get; set; } = new();
}
/// <summary>七大洲四大洋的标签位置(经纬度 + 名称)。</summary>
public sealed class ZoneLabel
{
[JsonPropertyName("lat")] public double Lat { get; set; }
[JsonPropertyName("lon")] public double Lon { get; set; }
[JsonPropertyName("kind")] public string Kind { get; set; } = "continent";
[JsonPropertyName("nameI18n")] public Dictionary<string, string>? NameI18n { get; set; }
}
public sealed class LabelData
{
[JsonPropertyName("labels")] public List<ZoneLabel> Labels { get; set; } = new();
}
/// <summary>五带:以纬度区间定义的五个温度带。</summary>
public sealed class ClimateZone
{
[JsonPropertyName("id")] public string Id { get; set; } = "";
/// <summary>南边界纬度(可为负)。</summary>
[JsonPropertyName("latMin")] public double LatMin { get; set; }
/// <summary>北边界纬度。</summary>
[JsonPropertyName("latMax")] public double LatMax { get; set; }
[JsonPropertyName("nameI18n")] public Dictionary<string, string>? NameI18n { get; set; }
[JsonPropertyName("descI18n")] public Dictionary<string, string>? DescI18n { get; set; }
}
/// <summary>地理模型场景清单。</summary>
public sealed class GeoScene
{
[JsonPropertyName("schemaVersion")] public int SchemaVersion { get; set; } = 1;
[JsonPropertyName("type")] public string Type { get; set; } = "geography";
[JsonPropertyName("defaultView")] public string DefaultView { get; set; } = "zones";
[JsonPropertyName("views")] public List<string> Views { get; set; } = new();
[JsonPropertyName("nameI18n")] public Dictionary<string, string>? NameI18n { get; set; }
[JsonPropertyName("descriptionI18n")] public Dictionary<string, string>? DescriptionI18n { get; set; }
/// <summary>黄赤交角 / 回归线纬度,教学里统一 23.5°。</summary>
[JsonPropertyName("tropicDeg")] public double TropicDeg { get; set; } = 23.5;
[JsonPropertyName("axialTiltDeg")] public double AxialTiltDeg { get; set; } = 23.5;
[JsonPropertyName("oceanColor")] public string OceanColor { get; set; } = "#0E2A4A";
[JsonPropertyName("zones")] public List<ClimateZone> Zones { get; set; } = new();
}
@@ -1,270 +0,0 @@
using System;
using System.Collections.Generic;
using System.IO;
using Avalonia;
using Avalonia.Controls;
using Avalonia.Layout;
using Avalonia.Media;
using GC.ModelSdk;
namespace GC.EarthModels;
/// <summary>
/// 地球地理模型:五带划分 + 七大洲四大洋轮廓 + 六大板块与洲界,纯线稿。
/// 数据全部来自模型数据目录,启动器不参与渲染。
/// </summary>
public sealed class GeographyRuntime : IModelRuntime
{
private readonly List<IDisposable> _disposables = new();
private GeoScene? _scene;
private GeoData? _coast;
private PlateData? _plates;
private ContinentData? _continents;
private BorderData? _borders;
private LabelData? _labels;
private GeographyView? _view;
public void Prepare(IModelContext context)
{
var dir = context.DataDirectory;
context.ReportProgress(0.10, "读取地理数据");
_scene = ModelJson.Read<GeoScene>(Path.Combine(dir, "scene.json")) ?? new GeoScene();
_coast = ModelJson.Read<GeoData>(Path.Combine(dir, "coastline.json")) ?? new GeoData();
_plates = ModelJson.Read<PlateData>(Path.Combine(dir, "plates.json")) ?? new PlateData();
_continents = ModelJson.Read<ContinentData>(Path.Combine(dir, "continents.json")) ?? new ContinentData();
_borders = ModelJson.Read<BorderData>(Path.Combine(dir, "borders.json")) ?? new BorderData();
context.ReportProgress(0.45, "加载名称标注");
_labels = ModelJson.Read<LabelData>(Path.Combine(dir, "labels.json")) ?? new LabelData();
context.ReportProgress(0.72, "构建轮廓");
context.Log($"[{context.ModelId}] 海岸线 {_coast.Lines.Count} 条,六大板块 {_plates.Plates.Count} 个," +
$"大陆 {_continents.Continents.Count} 块,洲界 {_borders.Borders.Count} 条");
}
public Control CreateView(IModelContext context)
{
_scene ??= new GeoScene();
_coast ??= new GeoData();
_plates ??= new PlateData();
_continents ??= new ContinentData();
_borders ??= new BorderData();
_labels ??= new LabelData();
_view = new GeographyView(context, _scene, _coast, _plates, _continents, _borders, _labels);
context.ReportProgress(1.0, "准备就绪");
return BuildLayout(_scene, _view, context);
}
private Control BuildLayout(GeoScene scene, GeographyView view, IModelContext context)
{
var root = new Grid { RowDefinitions = new RowDefinitions("Auto,*,Auto") };
// 顶栏:模型名 + 图层开关
var top = new Border
{
Background = new SolidColorBrush(Color.Parse("#0C1828")),
Padding = new Thickness(16, 10),
Child = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,*,Auto") }
};
var topGrid = (Grid)top.Child!;
var titlePanel = new StackPanel { Spacing = 2, VerticalAlignment = VerticalAlignment.Center };
titlePanel.Children.Add(new TextBlock
{
Text = Pick(scene.NameI18n, "地球地理"),
Foreground = new SolidColorBrush(Color.Parse("#EAF2FF")),
FontSize = 15,
FontWeight = FontWeight.SemiBold
});
titlePanel.Children.Add(new TextBlock
{
Text = Pick(scene.DescriptionI18n, "五带划分 · 七大洲四大洋 · 六大板块与洲界"),
Foreground = new SolidColorBrush(Color.Parse("#7C93B5")),
FontSize = 10.5
});
topGrid.Children.Add(titlePanel);
var actions = new StackPanel
{
Orientation = Orientation.Horizontal,
Spacing = 8,
VerticalAlignment = VerticalAlignment.Center
};
actions.Children.Add(MakeModeSwitch(view));
actions.Children.Add(MakeToggle("五带", view.ShowZones, on => view.ShowZones = on));
actions.Children.Add(MakeToggle("大洲轮廓", view.ShowCoast, on => view.ShowCoast = on));
actions.Children.Add(MakeToggle("六大板块", view.ShowPlates, on => view.ShowPlates = on));
actions.Children.Add(MakeToggle("五大陆", view.ShowContinents, on => view.ShowContinents = on));
actions.Children.Add(MakeToggle("洲界", view.ShowBorders, on => view.ShowBorders = on));
actions.Children.Add(MakeButton("复位", () => view.ResetView()));
Grid.SetColumn(actions, 2);
topGrid.Children.Add(actions);
root.Children.Add(top);
var stage = new Grid();
stage.Children.Add(view);
stage.Children.Add(BuildLegend(scene));
Grid.SetRow(stage, 1);
root.Children.Add(stage);
// 底部:五带说明
var bottom = new Border
{
Background = new SolidColorBrush(Color.Parse("#0A1524")),
Padding = new Thickness(16, 8),
Child = BuildZoneLegend(scene)
};
Grid.SetRow(bottom, 2);
root.Children.Add(bottom);
return root;
}
/// <summary>右上角图例:说明三种线型分别代表什么。</summary>
private static Control BuildLegend(GeoScene scene)
{
var panel = new StackPanel { Spacing = 6 };
panel.Children.Add(LegendRow(new SolidColorBrush(Color.Parse("#DEEEFF")), "大洲海岸线"));
panel.Children.Add(LegendRow(new SolidColorBrush(Color.Parse("#FF8A5C")), "六大板块边界"));
panel.Children.Add(LegendRow(new SolidColorBrush(Color.Parse("#FFD24A")), "五大陆轮廓"));
panel.Children.Add(LegendRow(new SolidColorBrush(Color.Parse("#FFDC70")), "洲界 / 分界线"));
return new Border
{
Background = new SolidColorBrush(Color.FromArgb(190, 8, 18, 32)),
CornerRadius = new CornerRadius(10),
Padding = new Thickness(12, 10),
HorizontalAlignment = HorizontalAlignment.Right,
VerticalAlignment = VerticalAlignment.Top,
Margin = new Thickness(0, 14, 16, 0),
Child = panel
};
}
private static Control LegendRow(IBrush brush, string text)
{
var row = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 6 };
row.Children.Add(new Border { Width = 14, Height = 2, Background = brush, VerticalAlignment = VerticalAlignment.Center });
row.Children.Add(new TextBlock { Text = text, Foreground = new SolidColorBrush(Color.Parse("#9FB4D4")), FontSize = 10.5 });
return row;
}
private static Control BuildZoneLegend(GeoScene scene)
{
var panel = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 18 };
foreach (var zone in scene.Zones)
{
var row = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 6 };
row.Children.Add(new Border
{
Width = 10, Height = 10, CornerRadius = new CornerRadius(2),
Background = ZoneBrush(zone.Id), VerticalAlignment = VerticalAlignment.Center
});
row.Children.Add(new TextBlock
{
Text = Pick(zone.NameI18n, zone.Id),
Foreground = new SolidColorBrush(Color.Parse("#C2D4EC")),
FontSize = 11
});
panel.Children.Add(row);
}
return panel;
}
private static IBrush ZoneBrush(string id) => id switch
{
"torrid-north" or "torrid-south" => new SolidColorBrush(Color.Parse("#FFA84C")),
"north-temperate" or "south-temperate" => new SolidColorBrush(Color.Parse("#6ED28C")),
_ => new SolidColorBrush(Color.Parse("#96C8FF"))
};
/// <summary>3D 球面 / 平面等经纬 两态切换。</summary>
private static Control MakeModeSwitch(GeographyView view)
{
var sphere = MakeButton("3D 球面", () => { });
var flat = MakeButton("平面", () => { });
void Apply()
{
var isFlat = view.Mode == GeoMode.Flat2D;
sphere.Background = new SolidColorBrush(Color.Parse(isFlat ? "#16263C" : "#1F5BD6"));
sphere.BorderBrush = new SolidColorBrush(Color.Parse(isFlat ? "#263A56" : "#3B7BFF"));
sphere.Foreground = new SolidColorBrush(Color.Parse(isFlat ? "#9FB4D4" : "#FFFFFF"));
flat.Background = new SolidColorBrush(Color.Parse(isFlat ? "#1F5BD6" : "#16263C"));
flat.BorderBrush = new SolidColorBrush(Color.Parse(isFlat ? "#3B7BFF" : "#263A56"));
flat.Foreground = new SolidColorBrush(Color.Parse(isFlat ? "#FFFFFF" : "#9FB4D4"));
}
sphere.Click += (_, _) => { view.Mode = GeoMode.Sphere3D; Apply(); };
flat.Click += (_, _) => { view.Mode = GeoMode.Flat2D; Apply(); };
Apply();
var row = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 4 };
row.Children.Add(sphere);
row.Children.Add(flat);
return row;
}
private static Button MakeButton(string text, Action onClick)
{
var b = new Button
{
Content = text,
FontSize = 12,
Padding = new Thickness(11, 5),
CornerRadius = new CornerRadius(8),
Background = new SolidColorBrush(Color.Parse("#16263C")),
Foreground = new SolidColorBrush(Color.Parse("#D6E4F8")),
BorderBrush = new SolidColorBrush(Color.Parse("#263A56")),
BorderThickness = new Thickness(1),
MinHeight = 30
};
b.Click += (_, _) => onClick();
return b;
}
private static Button MakeToggle(string text, bool initial, Action<bool> onChanged)
{
var state = initial;
var b = new Button
{
Content = text,
FontSize = 12,
Padding = new Thickness(11, 5),
CornerRadius = new CornerRadius(8),
BorderThickness = new Thickness(1),
MinHeight = 30
};
void Apply()
{
b.Background = new SolidColorBrush(Color.Parse(state ? "#1F5BD6" : "#16263C"));
b.BorderBrush = new SolidColorBrush(Color.Parse(state ? "#3B7BFF" : "#263A56"));
b.Foreground = new SolidColorBrush(Color.Parse(state ? "#FFFFFF" : "#9FB4D4"));
}
Apply();
b.Click += (_, _) => { state = !state; Apply(); onChanged(state); };
return b;
}
private static string Pick(Dictionary<string, string>? dict, string fallback)
{
if (dict == null || dict.Count == 0) return fallback;
foreach (var key in new[] { "zh-CN", "en" })
if (dict.TryGetValue(key, out var v) && !string.IsNullOrWhiteSpace(v)) return v;
return fallback;
}
public void Dispose()
{
foreach (var d in _disposables) d.Dispose();
_disposables.Clear();
_view?.StopAnimation();
_view = null;
System.GC.SuppressFinalize(this);
}
}
/// <summary>模型入口。</summary>
public sealed class GeographyModelFactory : IModelFactory
{
public int ApiVersion => 1;
public IModelRuntime Create() => new GeographyRuntime();
}
-916
View File
@@ -1,916 +0,0 @@
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Numerics;
using Avalonia;
using Avalonia.Controls;
using Avalonia.Input;
using Avalonia.Media;
using GC.ModelSdk;
namespace GC.EarthModels;
public enum GeoMode { Sphere3D, Flat2D }
/// <summary>
/// 地球地理画布。两种模式:
/// · 3D 正交球面 —— 拖拽转动、背面自动裁掉;
/// · 平面等经纬矩形 —— 课本地图样式,整幅一次看全。
/// 所有要素都是线稿;五带/板块/洲界各自独立配色,便于区分。
/// </summary>
public sealed class GeographyView : Control
{
private readonly GeoScene _scene;
private readonly GeoData _coast;
private readonly PlateData _plates;
private readonly ContinentData _continents;
private readonly BorderData _borders;
private readonly LabelData _labels;
private double _yawDeg = 10;
private double _pitchDeg = 15;
private double _zoom = 1.0;
private double _zoomTarget = 1.0;
private Avalonia.Threading.DispatcherTimer? _zoomTimer;
private Point _lastPointer;
private bool _dragging;
private bool _showZones = true;
private bool _showCoast = true;
private bool _showPlates;
private bool _showContinents = true;
private bool _showBorders = true;
private bool _showLabels = true;
private GeoMode _mode = GeoMode.Sphere3D;
// ── 平面视图几何缓存:五大陆有 1.3 万点,每帧重建 StreamGeometry 会明显掉帧。
// 尺寸/缩放不变时复用同一份几何,只重画笔刷。
private readonly Dictionary<string, Avalonia.Media.Geometry> _flatCache = new();
private double _flatCacheW = -1, _flatCacheH = -1;
private Avalonia.Media.Geometry? _coastGeo;
private double _coastCacheW = -1, _coastCacheH = -1;
// 单位球坐标缓存:三角运算只算一次,之后每帧只做矩阵乘 + 投影
private readonly Dictionary<string, (Vector3[] Pts, bool[] Valid)> _unitCache = new();
// ── 3D 视图成品几何缓存:旋转/缩放/尺寸都不变时直接复用上一帧的几何,
// 避免每帧重建 2.6 万点的 StreamGeometry 并重新提交给 Skia。
// 用户静止观察时这是绝大多数情况;拖动时按角度量化命中,转动依然跟手。
private Avalonia.Media.Geometry? _s3dCoast, _s3dCont;
private readonly Dictionary<string, Avalonia.Media.Geometry> _s3dBands = new();
private readonly Dictionary<string, Avalonia.Media.Geometry> _s3dPlates = new();
private string _s3dKey = "";
public event Action? StateChanged;
public GeographyView(IModelContext context, GeoScene scene, GeoData coast,
PlateData plates, ContinentData continents, BorderData borders, LabelData labels)
{
_scene = scene;
_coast = coast;
_plates = plates;
_continents = continents;
_borders = borders;
_labels = labels;
ClipToBounds = true;
Focusable = true;
}
public bool ShowZones { get => _showZones; set { _showZones = value; Redraw(); } }
public bool ShowCoast { get => _showCoast; set { _showCoast = value; Redraw(); } }
public bool ShowPlates { get => _showPlates; set { _showPlates = value; Redraw(); } }
public bool ShowContinents { get => _showContinents; set { _showContinents = value; Redraw(); } }
public bool ShowBorders { get => _showBorders; set { _showBorders = value; Redraw(); } }
public bool ShowLabels { get => _showLabels; set { _showLabels = value; Redraw(); } }
public GeoMode Mode { get => _mode; set { _mode = value; InvalidateVisual(); StateChanged?.Invoke(); } }
/// <summary>缩放倍数(0.55–4.0)。文字大小跟随缩放变化。</summary>
/// <summary>
/// 缩放。写入的是**目标值**,由动画计时器平滑逼近,
/// 直接跳变会让滚轮缩放显得生硬。
/// </summary>
public double Zoom
{
get => _zoomTarget;
set
{
_zoomTarget = Math.Clamp(value, 0.55, 4.0);
EnsureAnimating();
}
}
/// <summary>立即生效(贴图生成、复位等场景不该有过渡)。</summary>
public void SetZoomImmediate(double value)
{
_zoomTarget = Math.Clamp(value, 0.55, 4.0);
_zoom = _zoomTarget;
Redraw();
}
private void Redraw() { InvalidateVisual(); StateChanged?.Invoke(); }
/// <summary>
/// 缩放动画:60Hz 逼近目标值,差值小于阈值即停,
/// 避免空转白耗 CPU(一体机上尤其明显)。
/// </summary>
private void EnsureAnimating()
{
_zoomTimer ??= new Avalonia.Threading.DispatcherTimer(
TimeSpan.FromMilliseconds(16), Avalonia.Threading.DispatcherPriority.Render, (_, _) => StepZoom());
if (!_zoomTimer.IsEnabled) _zoomTimer.Start();
}
private void StepZoom()
{
var diff = _zoomTarget - _zoom;
if (Math.Abs(diff) < 0.0015)
{
_zoom = _zoomTarget;
_zoomTimer?.Stop();
Redraw();
return;
}
// 指数逼近:手感接近系统级平滑缩放
_zoom += diff * 0.28;
Redraw();
}
/// <summary>释放动画计时器,避免窗口关闭后还在跑。</summary>
public void StopAnimation() => _zoomTimer?.Stop();
/// <summary>文字缩放系数:跟随缩放一起放大/缩小,放大地球时标签也变大。</summary>
private double TextScale => Math.Clamp(_zoom, 0.85, 2.4);
public void ResetView()
{
_yawDeg = 10;
_pitchDeg = 15;
_zoom = 1.0;
Redraw();
}
// ---------------------------------------------------------------- 交互
protected override void OnPointerPressed(PointerPressedEventArgs e)
{
base.OnPointerPressed(e);
if (!e.GetCurrentPoint(this).Properties.IsLeftButtonPressed) return;
_lastPointer = e.GetPosition(this);
_dragging = true;
e.Pointer.Capture(this);
}
protected override void OnPointerMoved(PointerEventArgs e)
{
base.OnPointerMoved(e);
if (!_dragging || _mode == GeoMode.Flat2D) return;
var p = e.GetPosition(this);
var dx = p.X - _lastPointer.X;
var dy = p.Y - _lastPointer.Y;
_lastPointer = p;
// 跟手方向:向右拖动 => 地表向右移 => 经度增大(原来是 -= 导致方向相反)
_yawDeg += dx * 0.42;
_pitchDeg = Math.Clamp(_pitchDeg - dy * 0.42, -85, 85);
InvalidateVisual();
StateChanged?.Invoke();
}
protected override void OnPointerReleased(PointerReleasedEventArgs e)
{
base.OnPointerReleased(e);
_dragging = false;
e.Pointer.Capture(null);
}
protected override void OnPointerWheelChanged(PointerWheelEventArgs e)
{
base.OnPointerWheelChanged(e);
// 走 Zoom 属性(带平滑动画),不要在事件里直接改 _zoom
Zoom = _zoomTarget * (1 + e.Delta.Y * 0.12);
e.Handled = true;
}
// ---------------------------------------------------------------- 渲染入口
public override void Render(DrawingContext ctx)
{
var size = Bounds.Size;
if (size.Width < 40 || size.Height < 40) return;
ctx.FillRectangle(BgBrush, new Rect(size));
if (_mode == GeoMode.Flat2D) RenderFlat(ctx, size);
else RenderSphere(ctx, size);
}
private static readonly IBrush BgBrush = new LinearGradientBrush
{
StartPoint = new RelativePoint(0, 0, RelativeUnit.Relative),
EndPoint = new RelativePoint(0, 1, RelativeUnit.Relative),
GradientStops =
{
new GradientStop(Color.Parse("#0B1726"), 0),
new GradientStop(Color.Parse("#060D18"), 1)
}
};
// ================================================================ 3D 球面
private void RenderSphere(DrawingContext ctx, Size size)
{
var cx = (float)(size.Width * 0.5);
var cy = (float)(size.Height * 0.52);
var r = (float)(Math.Min(size.Width, size.Height) * 0.40 * Math.Min(_zoom, 1.6));
if (r < 12) return;
var cam = Matrix4x4.CreateRotationX((float)(-_pitchDeg * Math.PI / 180.0));
var planet = Matrix4x4.CreateRotationY((float)(_yawDeg * Math.PI / 180.0));
var m = Matrix4x4.Multiply(planet, cam);
DrawOceanDisc(ctx, cx, cy, r);
// 成品几何缓存 key:旋转 / 缩放 / 尺寸 / 图层只要有一个变了才重建几何。
// 静止观察时命中率 100%,拖动时按 0.5° 量化,仍然跟手。
var key = string.Create(System.Globalization.CultureInfo.InvariantCulture,
$"{Math.Round(_yawDeg * 2) / 2}|{Math.Round(_pitchDeg * 2) / 2}|{Math.Round(_zoom, 3)}|" +
$"{Math.Round(size.Width)}|{Math.Round(size.Height)}|" +
$"{(_showZones ? 1 : 0)}{(_showCoast ? 1 : 0)}{(_showPlates ? 1 : 0)}{(_showContinents ? 1 : 0)}");
var rebuild = key != _s3dKey;
if (rebuild)
{
_s3dKey = key;
_s3dCoast = null; _s3dCont = null;
_s3dBands.Clear();
_s3dPlates.Clear();
}
if (_showZones)
{
// 每个温度带一种颜色,所以按带分别缓存一份几何
foreach (var zone in _scene.Zones)
{
var zkey = "band:" + zone.Id;
if (rebuild || !_s3dBands.TryGetValue(zkey, out var band))
{
var merged = new StreamGeometry();
using (var g = merged.Open())
AppendBand(g, m, cx, cy, r, zone.LatMin, zone.LatMax);
band = merged;
_s3dBands[zkey] = band;
}
ctx.DrawGeometry(ZoneFill(zone.Id), null, band);
}
// 边界线(赤道/回归线/极圈)随旋转变化,直接画
DrawZoneLines3D(ctx, m, cx, cy, r);
}
if (_showCoast)
{
if (rebuild || _s3dCoast == null) _s3dCoast = BuildCoast(m, cx, cy, r);
ctx.DrawGeometry(null, CoastPen, _s3dCoast);
}
if (_showPlates) DrawPlates3D(ctx, m, cx, cy, r);
if (_showContinents)
{
if (rebuild || _s3dCont == null) _s3dCont = BuildContinents(m, cx, cy, r);
ctx.DrawGeometry(null, ContinentPen, _s3dCont);
}
if (_showBorders) DrawBorders3D(ctx, m, cx, cy, r);
if (_showLabels) DrawLabels3D(ctx, m, cx, cy, r);
ctx.DrawEllipse(null, new Pen(new SolidColorBrush(Color.FromArgb(200, 150, 200, 255)), 1.4),
new Point(cx, cy), r, r);
DrawReadout(ctx, size, $"球面 · {Norm(_yawDeg):0}°E {_pitchDeg:0}°");
}
/// <summary>
/// 球体本体:分层绘制提升立体感
/// ① 外层大气光晕(径向渐变,越靠边缘越亮)
/// ② 海洋底色(左上受光的渐变,模拟日光)
/// ③ 高光点 + 阴影弧(明暗对比塑造球感)
/// </summary>
private static void DrawOceanDisc(DrawingContext ctx, float cx, float cy, float r)
{
// ① 大气边缘光:球外一层的柔和蓝晕
var halo = new RadialGradientBrush
{
Center = new RelativePoint(0.5, 0.5, RelativeUnit.Relative),
GradientOrigin = new RelativePoint(0.5, 0.5, RelativeUnit.Relative),
RadiusX = new RelativeScalar(0.5, RelativeUnit.Relative),
RadiusY = new RelativeScalar(0.5, RelativeUnit.Relative),
GradientStops =
{
new GradientStop(Color.FromArgb(0, 90, 160, 255), 0.82),
new GradientStop(Color.FromArgb(70, 90, 170, 255), 0.94),
new GradientStop(Color.FromArgb(0, 90, 170, 255), 1.0)
}
};
ctx.DrawEllipse(halo, null, new Point(cx, cy), r * 1.14, r * 1.14);
// ② 海洋本体:左上亮、右下暗
var ocean = new RadialGradientBrush
{
Center = new RelativePoint(0.34, 0.30, RelativeUnit.Relative),
GradientOrigin = new RelativePoint(0.34, 0.30, RelativeUnit.Relative),
RadiusX = new RelativeScalar(0.95, RelativeUnit.Relative),
RadiusY = new RelativeScalar(0.95, RelativeUnit.Relative),
GradientStops =
{
new GradientStop(Color.Parse("#1B4A78"), 0.0),
new GradientStop(Color.Parse("#123A5E"), 0.35),
new GradientStop(Color.Parse("#0B2440"), 0.68),
new GradientStop(Color.Parse("#05121F"), 1.0)
}
};
ctx.DrawEllipse(ocean, null, new Point(cx, cy), r, r);
// ③ 高光:左上方一个小亮点,强化球面
var spec = new RadialGradientBrush
{
Center = new RelativePoint(0.30, 0.26, RelativeUnit.Relative),
GradientOrigin = new RelativePoint(0.30, 0.26, RelativeUnit.Relative),
RadiusX = new RelativeScalar(0.30, RelativeUnit.Relative),
RadiusY = new RelativeScalar(0.30, RelativeUnit.Relative),
GradientStops =
{
new GradientStop(Color.FromArgb(70, 180, 220, 255), 0.0),
new GradientStop(Color.FromArgb(0, 180, 220, 255), 1.0)
}
};
ctx.DrawEllipse(spec, null, new Point(cx, cy), r, r);
}
// ---- 五带边界线:赤道 / 回归线 / 极圈(随旋转变化,每帧直接画)----
private void DrawZoneLines3D(DrawingContext ctx, Matrix4x4 m, float cx, float cy, float r)
{
foreach (var zone in _scene.Zones)
{
DrawParallel3D(ctx, m, cx, cy, r, zone.LatMin, ZoneEdgePen);
DrawParallel3D(ctx, m, cx, cy, r, zone.LatMax, ZoneEdgePen);
}
DrawParallel3D(ctx, m, cx, cy, r, 0, EquatorPen);
DrawParallel3D(ctx, m, cx, cy, r, _scene.TropicDeg, TropicPen);
DrawParallel3D(ctx, m, cx, cy, r, -_scene.TropicDeg, TropicPen);
DrawParallel3D(ctx, m, cx, cy, r, 90 - _scene.TropicDeg, PolarPen);
DrawParallel3D(ctx, m, cx, cy, r, -(90 - _scene.TropicDeg), PolarPen);
}
private static void DrawParallel3D(DrawingContext ctx, Matrix4x4 m, float cx, float cy, float r,
double lat, IPen pen)
{
var pts = new List<double[]>(145);
for (var i = 0; i < 145; i++) pts.Add(new[] { -180.0 + 360.0 * i / 144.0, lat });
DrawGeo3D(ctx, pts, m, cx, cy, r, pen, false);
}
/// <summary>海岸线合并几何(供成品缓存使用)。</summary>
private Avalonia.Media.Geometry BuildCoast(Matrix4x4 m, float cx, float cy, float r)
{
var merged = new StreamGeometry();
using (var g = merged.Open())
{
for (var i = 0; i < _coast.Lines.Count; i++)
AppendCached(g, "coast:" + i, _coast.Lines[i], m, r, cx, cy, true);
}
return merged;
}
/// <summary>五大陆合并几何(供成品缓存使用)。</summary>
private Avalonia.Media.Geometry BuildContinents(Matrix4x4 m, float cx, float cy, float r)
{
var merged = new StreamGeometry();
using (var g = merged.Open())
{
foreach (var c in _continents.Continents)
for (var i = 0; i < c.Lines.Count; i++)
AppendCached(g, "cont:" + c.Id + ":" + i, c.Lines[i], m, r, cx, cy, true);
}
return merged;
}
/// <summary>把一个纬度带的可见格子追加到几何里(每格独立判断可见性)。</summary>
private static void AppendBand(StreamGeometryContext g, Matrix4x4 m, float cx, float cy, float r,
double latMin, double latMax)
{
const int steps = 180;
const double lonStep = 360.0 / steps;
for (var i = 0; i < steps; i++)
{
var lon0 = -180.0 + lonStep * i;
var lon1 = lon0 + lonStep;
var a = Geometry.ToCamera(Geometry.LatLonToUnit(latMin, lon0), Matrix4x4.Identity, m);
var b = Geometry.ToCamera(Geometry.LatLonToUnit(latMin, lon1), Matrix4x4.Identity, m);
var c = Geometry.ToCamera(Geometry.LatLonToUnit(latMax, lon1), Matrix4x4.Identity, m);
var d = Geometry.ToCamera(Geometry.LatLonToUnit(latMax, lon0), Matrix4x4.Identity, m);
if (a.Z <= 0 || b.Z <= 0 || c.Z <= 0 || d.Z <= 0) continue;
g.BeginFigure(Pt(Geometry.Project(a, r, cx, cy)), true);
g.LineTo(Pt(Geometry.Project(b, r, cx, cy)));
g.LineTo(Pt(Geometry.Project(c, r, cx, cy)));
g.LineTo(Pt(Geometry.Project(d, r, cx, cy)));
g.EndFigure(true);
}
}
/// <summary>把一条缓存折线的所有可见弧段追加到同一个几何里。</summary>
private void AppendCached(StreamGeometryContext g, string key, IReadOnlyList<double[]> latLon,
Matrix4x4 m, float r, float cx, float cy, bool closed)
{
var entry = GetUnit(key, latLon);
foreach (var seg in Geometry.ProjectUnitPolyline(entry.Pts, entry.Valid,
Matrix4x4.Identity, m, r, cx, cy, closed))
{
if (seg.Count < 2) continue;
g.BeginFigure(Pt(seg[0]), false);
for (var i = 1; i < seg.Count; i++) g.LineTo(Pt(seg[i]));
g.EndFigure(false);
}
}
private (Vector3[] Pts, bool[] Valid) GetUnit(string key, IReadOnlyList<double[]> latLon)
{
if (_unitCache.TryGetValue(key, out var entry)) return entry;
var pts = new Vector3[latLon.Count];
var valid = new bool[latLon.Count];
for (var i = 0; i < latLon.Count; i++)
{
var p = latLon[i];
if (p.Length >= 2)
{
pts[i] = Geometry.LatLonToUnit(p[1], p[0]);
valid[i] = true;
}
}
entry = (pts, valid);
_unitCache[key] = entry;
return entry;
}
private void DrawPlates3D(DrawingContext ctx, Matrix4x4 m, float cx, float cy, float r)
{
foreach (var p in _plates.Plates)
{
var pen = PlatePenFor(p.Id);
var merged = new StreamGeometry();
using (var g = merged.Open())
{
for (var i = 0; i < p.Lines.Count; i++)
AppendCached(g, "plate:" + p.Id + ":" + i, p.Lines[i], m, r, cx, cy, true);
}
ctx.DrawGeometry(null, pen, merged);
}
if (_showLabels) DrawPlateLabels3D(ctx, m, cx, cy, r);
}
private void DrawPlateLabels3D(DrawingContext ctx, Matrix4x4 m, float cx, float cy, float r)
{
foreach (var p in _plates.Plates)
{
var at = p.Label is { Length: >= 2 } ? p.Label : Centroid(p.Lines);
if (at == null) continue;
var cam = Geometry.ToCamera(Geometry.LatLonToUnit(at[1], at[0]), Matrix4x4.Identity, m);
if (cam.Z <= 0.2f) continue;
var pos = Geometry.Project(cam, r, cx, cy);
DrawText(ctx, Pick(p.NameI18n, p.Id), pos.X, pos.Y, 10.5 * TextScale,
PlateBrushFor(p.Id), TextAlignment.Center);
}
}
private void DrawBorders3D(DrawingContext ctx, Matrix4x4 m, float cx, float cy, float r)
{
foreach (var b in _borders.Borders)
{
var pen = BorderPenFor(b.Between);
// 复合分界(如亚欧六段)按段分别画,每段标注自己的名称
if (b.Segments is { Count: > 0 })
{
for (var i = 0; i < b.Segments.Count; i++)
{
var seg = b.Segments[i];
if (seg.Lines.Count == 0) continue;
// 同一条分界内相邻段做明度交替,视觉上能数清是几段
var segPen = BorderSegmentPen(pen, i);
foreach (var line in seg.Lines) DrawGeo3D(ctx, line, m, cx, cy, r, segPen.Glow, false);
foreach (var line in seg.Lines) DrawGeo3D(ctx, line, m, cx, cy, r, segPen.Main, false);
var mid = MidPoint(seg.Lines[0]);
if (mid == null) continue;
var cam = Geometry.ToCamera(Geometry.LatLonToUnit(mid[1], mid[0]), Matrix4x4.Identity, m);
if (cam.Z <= 0.05f) continue;
var pos = Geometry.Project(cam, r, cx, cy);
ctx.DrawEllipse(segPen.DotBrush, null, Pt(pos), 3.0, 3.0);
if (_showLabels)
DrawText(ctx, Pick(seg.NameI18n, seg.Name), pos.X + 8, pos.Y - 5, 10 * TextScale,
segPen.DotBrush, TextAlignment.Left);
}
continue;
}
if (b.Lines.Count == 0 || b.Lines[0].Count < 2) continue;
foreach (var line in b.Lines) DrawGeo3D(ctx, line, m, cx, cy, r, pen.Glow, false);
foreach (var line in b.Lines) DrawGeo3D(ctx, line, m, cx, cy, r, pen.Main, false);
var mid2 = MidPoint(b.Lines[0]);
if (mid2 == null) continue;
var cam2 = Geometry.ToCamera(Geometry.LatLonToUnit(mid2[1], mid2[0]), Matrix4x4.Identity, m);
if (cam2.Z <= 0.05f) continue;
var pos2 = Geometry.Project(cam2, r, cx, cy);
ctx.DrawEllipse(pen.DotBrush, null, Pt(pos2), 3.4, 3.4);
if (_showLabels)
{
var text = $"{Pick(b.NameI18n, b.Name)}({b.Between})";
DrawText(ctx, text, pos2.X + 9, pos2.Y - 6, 10.5 * TextScale, pen.DotBrush, TextAlignment.Left);
}
}
}
/// <summary>同一分界的各段用不同明度区分(如亚欧分界六段)。</summary>
private static (IPen Glow, IPen Main, IBrush DotBrush) BorderSegmentPen(
(IPen Glow, IPen Main, IBrush DotBrush) basePen, int index)
=> basePen;
private void DrawLabels3D(DrawingContext ctx, Matrix4x4 m, float cx, float cy, float r)
{
foreach (var lb in _labels.Labels)
{
var cam = Geometry.ToCamera(Geometry.LatLonToUnit(lb.Lat, lb.Lon), Matrix4x4.Identity, m);
if (cam.Z <= 0.12f) continue;
var pos = Geometry.Project(cam, r, cx, cy);
var ocean = lb.Kind == "ocean";
DrawText(ctx, Pick(lb.NameI18n, ""), pos.X, pos.Y, (ocean ? 11 : 12.5) * TextScale,
ocean ? OceanBrush : ContinentBrush, TextAlignment.Center,
ocean ? FontStyle.Italic : FontStyle.Normal);
}
}
/// <summary>把经纬度折线投影成可见弧段(背面自动裁掉)。</summary>
private static void DrawGeo3D(DrawingContext ctx, IReadOnlyList<double[]> latLon,
Matrix4x4 m, float cx, float cy, float r, IPen pen, bool closed)
{
foreach (var seg in Geometry.ProjectPolyline(latLon, Matrix4x4.Identity, m, r, cx, cy, closed))
{
if (seg.Count < 2) continue;
var geo = new StreamGeometry();
using (var g = geo.Open())
{
g.BeginFigure(Pt(seg[0]), false);
for (var i = 1; i < seg.Count; i++) g.LineTo(Pt(seg[i]));
g.EndFigure(false);
}
ctx.DrawGeometry(null, pen, geo);
}
}
/// <summary>
/// 缓存版绘制:单位球坐标按 key 缓存一次,之后每帧只做矩阵乘与投影。
/// 海岸线/大陆共 2.6 万点,这是 3D 视图的主要开销来源。
/// </summary>
private void DrawCached3D(DrawingContext ctx, string key, IReadOnlyList<double[]> latLon,
Matrix4x4 m, float cx, float cy, float r, IPen pen, bool closed)
{
var entry = GetUnit(key, latLon);
foreach (var seg in Geometry.ProjectUnitPolyline(entry.Pts, entry.Valid,
Matrix4x4.Identity, m, r, cx, cy, closed))
{
if (seg.Count < 2) continue;
var geo = new StreamGeometry();
using (var g = geo.Open())
{
g.BeginFigure(Pt(seg[0]), false);
for (var i = 1; i < seg.Count; i++) g.LineTo(Pt(seg[i]));
g.EndFigure(false);
}
ctx.DrawGeometry(null, pen, geo);
}
}
// ================================================================ 平面等经纬
private void RenderFlat(DrawingContext ctx, Size size)
{
var pad = 26.0;
var w = size.Width - pad * 2;
var h = size.Height - pad * 2 - 18;
if (w < 40 || h < 40) return;
// 等经纬投影固定 2:1
if (w / h > 2.0) w = h * 2.0;
else h = w / 2.0;
var x0 = (size.Width - w) / 2;
var y0 = (size.Height - h) / 2 - 6;
var frame = new Rect(x0, y0, w, h);
// 海面
ctx.FillRectangle(new SolidColorBrush(Color.Parse("#0A1E33")), frame);
Point P(double lon, double lat) => new(
x0 + (lon + 180.0) / 360.0 * w,
y0 + (90.0 - lat) / 180.0 * h);
// 五带填充
if (_showZones)
{
foreach (var zone in _scene.Zones)
{
var top = P(-180, zone.LatMax);
var bot = P(180, zone.LatMin);
ctx.FillRectangle(ZoneFill(zone.Id), new Rect(x0, top.Y, w, bot.Y - top.Y));
foreach (var lat in new[] { zone.LatMin, zone.LatMax })
ctx.DrawLine(ZoneEdgePen, P(-180, lat), P(180, lat));
}
ctx.DrawLine(EquatorPen, P(-180, 0), P(180, 0));
foreach (var lat in new[] { _scene.TropicDeg, -_scene.TropicDeg })
ctx.DrawLine(TropicPen, P(-180, lat), P(180, lat));
foreach (var lat in new[] { 90 - _scene.TropicDeg, -(90 - _scene.TropicDeg) })
ctx.DrawLine(PolarPen, P(-180, lat), P(180, lat));
}
// 海岸线
if (_showCoast)
{
var cw = Math.Round(size.Width);
var ch = Math.Round(size.Height);
if (Math.Abs(cw - _coastCacheW) > 0.5 || Math.Abs(ch - _coastCacheH) > 0.5 || _coastGeo == null)
{
var merged = new StreamGeometry();
using (var g = merged.Open())
{
foreach (var line in _coast.Lines)
{
if (line.Count < 2) continue;
g.BeginFigure(P(line[0][0], line[0][1]), false);
for (var i = 1; i < line.Count; i++)
{
var p = line[i];
if (p.Length >= 2) g.LineTo(P(p[0], p[1]));
}
g.EndFigure(false);
}
}
_coastGeo = merged;
_coastCacheW = cw; _coastCacheH = ch;
}
ctx.DrawGeometry(null, CoastPen, _coastGeo);
}
// 板块
if (_showPlates)
{
foreach (var pl in _plates.Plates)
{
var pen = PlatePenFor(pl.Id);
foreach (var line in pl.Lines)
DrawFlatPolyline(ctx, line, P, pen);
if (!_showLabels) continue;
var c = pl.Label is { Length: >= 2 } ? pl.Label : Centroid(pl.Lines);
if (c == null) continue;
var at = P(c[0], c[1]);
DrawText(ctx, Pick(pl.NameI18n, pl.Id), at.X, at.Y, 10.5 * TextScale,
PlateBrushFor(pl.Id), TextAlignment.Center);
}
}
// 五大陆
if (_showContinents)
{
// 用缓存几何:尺寸不变时只画一次构建开销
var fw = Math.Round(size.Width);
var fh = Math.Round(size.Height);
if (Math.Abs(fw - _flatCacheW) > 0.5 || Math.Abs(fh - _flatCacheH) > 0.5 || _flatCache.Count == 0)
{
_flatCache.Clear();
_flatCacheW = fw; _flatCacheH = fh;
}
foreach (var c in _continents.Continents)
{
var key = "cont:" + c.Id;
if (!_flatCache.TryGetValue(key, out var geo))
{
var merged = new StreamGeometry();
using (var g = merged.Open())
{
foreach (var line in c.Lines)
{
if (line.Count < 2) continue;
g.BeginFigure(P(line[0][0], line[0][1]), false);
for (var i = 1; i < line.Count; i++)
{
var p = line[i];
if (p.Length >= 2) g.LineTo(P(p[0], p[1]));
}
g.EndFigure(false);
}
}
geo = merged;
_flatCache[key] = geo;
}
ctx.DrawGeometry(null, ContinentPen, geo);
if (!_showLabels) continue;
var a = c.Label is { Length: >= 2 } ? c.Label : Centroid(c.Lines);
if (a == null) continue;
var at = P(a[0], a[1]);
DrawText(ctx, Pick(c.NameI18n, c.Id), at.X, at.Y, 12 * TextScale,
MainlandBrush, TextAlignment.Center);
}
}
// 洲界
if (_showBorders)
{
foreach (var b in _borders.Borders)
{
var pen = BorderPenFor(b.Between);
foreach (var line in b.Lines) DrawFlatPolyline(ctx, line, P, pen.Glow);
foreach (var line in b.Lines) DrawFlatPolyline(ctx, line, P, pen.Main);
if (b.Lines.Count == 0) continue;
var mid = MidPoint(b.Lines[0]);
if (mid == null) continue;
var at = P(mid[0], mid[1]);
ctx.DrawEllipse(pen.DotBrush, null, at, 3.4, 3.4);
if (_showLabels)
DrawText(ctx, $"{Pick(b.NameI18n, b.Name)}({b.Between})",
at.X + 9, at.Y - 6, 10.5 * TextScale, pen.DotBrush, TextAlignment.Left);
}
}
// 大洲大洋标签
if (_showLabels)
{
foreach (var lb in _labels.Labels)
{
var at = P(lb.Lon, lb.Lat);
var ocean = lb.Kind == "ocean";
DrawText(ctx, Pick(lb.NameI18n, ""), at.X, at.Y, (ocean ? 11 : 12.5) * TextScale,
ocean ? OceanBrush : ContinentBrush, TextAlignment.Center,
ocean ? FontStyle.Italic : FontStyle.Normal);
}
}
// 经纬网 + 外框
for (var lon = -180; lon <= 180; lon += 30)
ctx.DrawLine(GridPen, P(lon, -90), P(lon, 90));
for (var lat = -60; lat <= 60; lat += 30)
ctx.DrawLine(GridPen, P(-180, lat), P(180, lat));
ctx.DrawRectangle(null, new Pen(new SolidColorBrush(Color.FromArgb(180, 150, 200, 255)), 1.3), frame);
DrawReadout(ctx, size, "平面等经纬投影");
}
private static void DrawFlatPolyline(DrawingContext ctx, IReadOnlyList<double[]> latLon,
Func<double, double, Point> proj, IPen pen)
{
if (latLon.Count < 2) return;
var geo = new StreamGeometry();
using (var g = geo.Open())
{
var first = latLon[0];
if (first.Length < 2) return;
g.BeginFigure(proj(first[0], first[1]), false);
for (var i = 1; i < latLon.Count; i++)
{
var p = latLon[i];
if (p.Length >= 2) g.LineTo(proj(p[0], p[1]));
}
g.EndFigure(false);
}
ctx.DrawGeometry(null, pen, geo);
}
// ================================================================ 配色(每类分界独立颜色)
private static IBrush ZoneFill(string id) => id switch
{
"torrid" => new SolidColorBrush(Color.FromArgb(34, 255, 150, 60)),
"north-temperate" or "south-temperate" => new SolidColorBrush(Color.FromArgb(30, 90, 210, 130)),
_ => new SolidColorBrush(Color.FromArgb(34, 140, 195, 255))
};
private static (IPen Glow, IPen Main, IBrush DotBrush) BorderPenFor(string between)
{
// 每条洲界一种颜色,便于区分
var baseColor = between switch
{
"亚洲-非洲" => Color.FromRgb(255, 214, 92), // 金黄
"亚洲-欧洲" => Color.FromRgb(120, 226, 255), // 青
"欧洲-非洲" => Color.FromRgb(168, 148, 255), // 紫
"北美-南美" => Color.FromRgb(120, 255, 176), // 绿
"南美-南极" => Color.FromRgb(96, 232, 222), // 青绿(德雷克海峡)
"亚洲-北美" => Color.FromRgb(255, 140, 220), // 粉
"亚洲-大洋洲" => Color.FromRgb(255, 160, 96), // 橙
"南极洲" => Color.FromRgb(200, 225, 255), // 冰蓝
_ => Color.FromRgb(255, 214, 92)
};
var glow = new Pen(new SolidColorBrush(Color.FromArgb(70, baseColor.R, baseColor.G, baseColor.B)), 5.0);
var main = new Pen(new SolidColorBrush(Color.FromArgb(240, baseColor.R, baseColor.G, baseColor.B)), 1.7,
new DashStyle(new double[] { 6, 3 }, 0)) { LineCap = PenLineCap.Round };
return (glow, main, new SolidColorBrush(Color.FromArgb(245, baseColor.R, baseColor.G, baseColor.B)));
}
private static IPen PlatePenFor(string id)
{
// 教材六大板块,每块一个颜色
var c = id switch
{
"eurasian" => Color.FromRgb(110, 214, 230), // 青
"african" => Color.FromRgb(150, 230, 110), // 绿
"american" => Color.FromRgb(255, 176, 84), // 橙
"pacific" => Color.FromRgb(255, 110, 110), // 红
"indian-ocean" => Color.FromRgb(126, 160, 255), // 蓝紫
"antarctic" => Color.FromRgb(208, 190, 255), // 淡紫
_ => Color.FromRgb(255, 150, 100)
};
return new Pen(new SolidColorBrush(Color.FromArgb(225, c.R, c.G, c.B)), 1.55,
new DashStyle(new double[] { 8, 4 }, 0));
}
private static IBrush PlateBrushFor(string id)
{
var pen = PlatePenFor(id);
return pen.Brush ?? Brushes.White;
}
// ================================================================ 通用画笔
private static readonly IPen CoastPen = new Pen(new SolidColorBrush(Color.FromArgb(250, 236, 246, 255)), 1.75)
{ LineJoin = PenLineJoin.Round, LineCap = PenLineCap.Round };
/// <summary>五大陆轮廓:金黄色实线,与板块虚线明显区分。</summary>
private static readonly IPen ContinentPen = new Pen(new SolidColorBrush(Color.FromArgb(240, 255, 210, 74)), 2.0)
{ LineJoin = PenLineJoin.Round, LineCap = PenLineCap.Round };
private static readonly IBrush MainlandBrush = new SolidColorBrush(Color.FromRgb(255, 218, 110));
private static readonly IPen TropicPen = new Pen(new SolidColorBrush(Color.FromArgb(220, 255, 190, 100)), 1.3);
private static readonly IPen PolarPen = new Pen(new SolidColorBrush(Color.FromArgb(210, 150, 205, 255)), 1.3);
private static readonly IPen ZoneEdgePen = new Pen(new SolidColorBrush(Color.FromArgb(110, 200, 225, 255)), 0.9);
private static readonly IPen EquatorPen = new Pen(new SolidColorBrush(Color.FromArgb(240, 120, 226, 255)), 1.8,
new DashStyle(new double[] { 6, 4 }, 0));
private static readonly IPen GridPen = new Pen(new SolidColorBrush(Color.FromArgb(46, 150, 190, 240)), 0.8);
private static readonly IBrush ContinentBrush = new SolidColorBrush(Color.FromArgb(248, 236, 245, 255));
private static readonly IBrush OceanBrush = new SolidColorBrush(Color.FromArgb(220, 130, 190, 245));
// ================================================================ 工具
private static Point Pt(Vector2 v) => new(v.X, v.Y);
private static void DrawText(DrawingContext ctx, string text, double x, double y, double size,
IBrush brush, TextAlignment align, FontStyle style = FontStyle.Normal)
{
if (string.IsNullOrWhiteSpace(text)) return;
var ft = new FormattedText(text, CultureInfo.CurrentCulture, FlowDirection.LeftToRight,
new Typeface(FontFamily.Default, style, FontWeight.SemiBold), size, brush);
var px = align switch
{
TextAlignment.Center => x - ft.Width / 2,
TextAlignment.Right => x - ft.Width,
_ => x
};
ctx.DrawText(ft, new Point(px, y));
}
private static void DrawReadout(DrawingContext ctx, Size size, string text)
=> DrawText(ctx, text, 18, size.Height - 24, 11,
new SolidColorBrush(Color.FromArgb(150, 160, 190, 230)), TextAlignment.Left);
private static double Norm(double deg)
{
var v = deg % 360;
if (v > 180) v -= 360;
if (v < -180) v += 360;
return Math.Abs(v);
}
private static double[]? MidPoint(List<double[]> line)
{
for (var i = line.Count / 2; i < line.Count; i++)
if (line[i].Length >= 2) return line[i];
return line.Count > 0 && line[0].Length >= 2 ? line[0] : null;
}
private static string Pick(Dictionary<string, string>? dict, string fallback)
{
if (dict == null || dict.Count == 0) return fallback;
foreach (var key in new[] { "zh-CN", "en" })
if (dict.TryGetValue(key, out var v) && !string.IsNullOrWhiteSpace(v)) return v;
foreach (var kv in dict)
if (!string.IsNullOrWhiteSpace(kv.Value)) return kv.Value;
return fallback;
}
private static double[]? Centroid(List<List<double[]>> lines)
{
double sx = 0, sy = 0, sz = 0;
var n = 0;
foreach (var l in lines)
foreach (var p in l)
{
if (p.Length < 2) continue;
var v = Geometry.LatLonToUnit(p[1], p[0]);
sx += v.X; sy += v.Y; sz += v.Z; n++;
}
if (n == 0) return null;
var len = Math.Sqrt(sx * sx + sy * sy + sz * sz);
if (len < 1e-9) return null;
return new[]
{
Math.Atan2(sx / len, sz / len) * 180.0 / Math.PI,
Math.Asin(Math.Clamp(sy / len, -1, 1)) * 180.0 / Math.PI
};
}
}
+1 -1
View File
@@ -32,5 +32,5 @@
"frame": "#0A1524"
},
"build": "53b7a0fbc3",
"updatedAt": "2026-11-19T10:20:00Z"
"updatedAt": "2026-11-21T10:55:36Z"
}
@@ -1,28 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>disable</ImplicitUsings>
<RootNamespace>GC.EarthModels</RootNamespace>
<AssemblyName>EarthRevolutionModel</AssemblyName>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<IsPackable>false</IsPackable>
</PropertyGroup>
<!-- 共享引擎源码就在 model/_engine 里(模型目录内),本模型直接编译进去 -->
<ItemGroup>
<Compile Include="../../_engine/src/**/*.cs" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="Avalonia" Version="$(AvaloniaVersion)" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\_sdk\GC.ModelSdk\GC.ModelSdk.csproj">
<Private>false</Private>
</ProjectReference>
</ItemGroup>
</Project>
@@ -1,11 +0,0 @@
using GC.ModelSdk;
namespace GC.EarthModels;
/// <summary>地球公转模型入口(清单里的 type 指向这里)。</summary>
public sealed class RevolutionModelFactory : IModelFactory
{
public int ApiVersion => EarthModelRuntime.SupportedApiVersion;
public IModelRuntime Create() => new EarthModelRuntime();
}
+1 -1
View File
@@ -32,5 +32,5 @@
"frame": "#0A1524"
},
"build": "ecd52665f9",
"updatedAt": "2026-11-19T10:20:00Z"
"updatedAt": "2026-11-21T10:55:36Z"
}
@@ -1,28 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>disable</ImplicitUsings>
<RootNamespace>GC.EarthModels</RootNamespace>
<AssemblyName>EarthRotationModel</AssemblyName>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<IsPackable>false</IsPackable>
</PropertyGroup>
<!-- 共享引擎源码就在 model/_engine 里(模型目录内),本模型直接编译进去 -->
<ItemGroup>
<Compile Include="../../_engine/src/**/*.cs" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="Avalonia" Version="$(AvaloniaVersion)" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\_sdk\GC.ModelSdk\GC.ModelSdk.csproj">
<Private>false</Private>
</ProjectReference>
</ItemGroup>
</Project>
@@ -1,11 +0,0 @@
using GC.ModelSdk;
namespace GC.EarthModels;
/// <summary>地球自转模型入口(清单里的 type 指向这里)。</summary>
public sealed class RotationModelFactory : IModelFactory
{
public int ApiVersion => EarthModelRuntime.SupportedApiVersion;
public IModelRuntime Create() => new EarthModelRuntime();
}
+1 -1
View File
@@ -33,5 +33,5 @@
"frame": "#F4F6FB"
},
"build": "105653737d",
"updatedAt": "2026-11-19T10:20:00Z"
"updatedAt": "2026-11-21T10:55:36Z"
}
-251
View File
@@ -1,251 +0,0 @@
using System.Collections.Generic;
namespace GC.ScaleCalculator;
/// <summary>内置全量文案兜底:即使模型包里没有语言包也能完整显示。</summary>
internal static class DefaultTexts
{
public static readonly Dictionary<string, string> Zh = new()
{
["app.title"] = "比例尺计算器",
["app.subtitle"] = "把「图上距离 ÷ 实地距离」变成可以拖、可以量的可视化标尺",
["mode.real"] = "求实地距离",
["mode.map"] = "求图上距离",
["mode.scale"] = "求比例尺",
["mode.hint"] = "选择要求什么,蓝色结果卡就是答案",
["input.title"] = "已知量",
["input.map"] = "图上距离",
["input.real"] = "实地距离",
["input.scale"] = "比例尺分母 N",
["input.nPrefix"] = "1 :",
["input.unit"] = "单位",
["input.reset"] = "重置",
["input.presets"] = "常用比例尺",
["input.dragHint"] = "拖动滑块或直接输入数字,读数实时联动",
["result.title"] = "计算结果",
["result.real"] = "实地距离",
["result.map"] = "图上距离",
["result.scale"] = "比例尺",
["result.formula"] = "计算公式",
["forms.title"] = "比例尺的三种写法",
["forms.digital"] = "数字式",
["forms.verbal"] = "文字式",
["forms.segment"] = "线段式",
["forms.verbalTpl"] = "图上 1 厘米代表实地 {0}",
["forms.segmentDesc"] = "每格 {0},共 {1} 格",
["steps.title"] = "解题步骤",
["steps.show"] = "展开步骤",
["steps.hide"] = "收起步骤",
["steps.1.unify"] = "① 统一单位:把实地距离化成厘米(1 km = 100000 cm,去掉 5 个 0)",
["steps.2.formulaReal"] = "② 实地距离 = 图上距离 × 比例尺分母",
["steps.2.formulaMap"] = "② 图上距离 = 实地距离 ÷ 比例尺分母",
["steps.2.formulaScale"] = "② 比例尺分母 = 实地距离 ÷ 图上距离",
["steps.3.substitute"] = "③ 代入数值:{0}",
["steps.4.result"] = "④ 算出结果:{0}",
["steps.5.convert"] = "⑤ 换算成合适单位(cm → m → km)",
["grade.title"] = "大小判读",
["grade.large"] = "大比例尺",
["grade.medium"] = "中比例尺",
["grade.small"] = "小比例尺",
["grade.largeNote"] = "范围小 · 内容详细 · 如校园平面图",
["grade.mediumNote"] = "范围中等 · 如城市交通图",
["grade.smallNote"] = "范围大 · 内容简略 · 如世界地图",
["grade.rule"] = "分母越大 → 比例尺越小 → 范围越大 → 越简略",
["pit.title"] = "易错点",
["pit.1"] = "① 忘记统一单位:km 要 ×100000 才成 cm",
["pit.2"] = "② 「放大 2 倍」是分母 ÷ 2,不是 × 2",
["pit.3"] = "③ 图上距离与实地距离别代反了",
["field.title"] = "实地尺 · 这段距离画到图上多长",
["field.hint"] = "选一个真实距离,改变比例尺看它在图上的长度",
["field.mapLength"] = "图上 {0}",
["field.tooLong"] = "画不下",
["field.tooShort"] = "几乎看不见",
["quiz.title"] = "练习闯关",
["quiz.promptReal"] = "比例尺 1:{0},图上 {1} 厘米,实地距离是多少?(按提示单位填数字)",
["quiz.promptMap"] = "比例尺 1:{0},实地 {1},图上距离是多少厘米?",
["quiz.promptScale"] = "图上 {0} 厘米代表实地 {1},比例尺分母是多少?",
["quiz.answer"] = "输入答案",
["quiz.check"] = "检查",
["quiz.next"] = "下一题",
["quiz.correct"] = "✓ 答对了!",
["quiz.wrong"] = "✗ 再想想,看看解题步骤",
["quiz.streak"] = "连对 {0} 题",
["quiz.showSteps"] = "查看解题步骤",
["quiz.unit"] = "单位:{0}",
["ruler.title"] = "可视化标尺",
["ruler.mapBar"] = "图上距离(真实厘米)",
["ruler.realBar"] = "实地距离(按同一比例尺压缩)",
["ruler.sameWidth"] = "与上方同宽",
["ruler.equals"] = "等于",
["ruler.segment"] = "线段式比例尺",
["ruler.segmentHint"] = "刻度自动换挡",
["ruler.spectrum"] = "比例尺光谱",
["ruler.scopeUp"] = "◀ 范围越大",
["ruler.detailDown"] = "内容越详细 ▶",
["ruler.hint"] = "蓝色是图上真实长度;绿色是同一段实地按比例尺压缩后的长度",
["ruler.overflowMap"] = "这段图上距离超出图幅,需要更小的比例尺",
["ruler.overflowReal"] = "这段实地距离在该比例尺下画不下,需要更小的比例尺",
["unit.cm"] = "厘米",
["unit.m"] = "米",
["unit.km"] = "千米",
["unit.none"] = "(无单位)",
["spec.campus"] = "校园",
["spec.city"] = "城市",
["spec.china"] = "中国",
["spec.world"] = "世界",
["preset.campus"] = "校园 1:1万",
["preset.campusNote"] = "操场、教学楼都画得清",
["preset.town"] = "乡镇 1:5万",
["preset.townNote"] = "村镇与道路",
["preset.city"] = "城市 1:25万",
["preset.cityNote"] = "城区与主干道",
["preset.province"] = "省区 1:100万",
["preset.provinceNote"] = "地级市与河流",
["preset.china"] = "中国 1:1000万",
["preset.chinaNote"] = "省级轮廓",
["preset.world"] = "世界 1:1亿",
["preset.worldNote"] = "大洲大洋",
["lm.classroom"] = "教室 10 m",
["lm.track"] = "操场一圈 400 m",
["lm.marathon"] = "马拉松 42.195 km",
["lm.beijingShanghai"] = "北京—上海 1080 km",
["lm.equator"] = "赤道 4 万 km",
["common.footer"] = "比例尺 = 图上距离 ÷ 实地距离 · 单位统一是第一步 · 分母越大,比例尺越小"
};
public static readonly Dictionary<string, string> En = new()
{
["app.title"] = "Scale Calculator",
["app.subtitle"] = "Turn map-distance ÷ real-distance into a ruler you can drag and measure",
["mode.real"] = "Find real distance",
["mode.map"] = "Find map distance",
["mode.scale"] = "Find scale",
["mode.hint"] = "Pick what to solve; the blue card is the answer",
["input.title"] = "Given",
["input.map"] = "Map distance",
["input.real"] = "Real distance",
["input.scale"] = "Scale denominator N",
["input.nPrefix"] = "1 :",
["input.unit"] = "Unit",
["input.reset"] = "Reset",
["input.presets"] = "Common scales",
["input.dragHint"] = "Drag the slider or type a number — everything updates live",
["result.title"] = "Result",
["result.real"] = "Real distance",
["result.map"] = "Map distance",
["result.scale"] = "Scale",
["result.formula"] = "Formula",
["forms.title"] = "Three ways to write a scale",
["forms.digital"] = "Numeric",
["forms.verbal"] = "Verbal",
["forms.segment"] = "Graphic (bar)",
["forms.verbalTpl"] = "1 cm on the map = {0} on the ground",
["forms.segmentDesc"] = "Each division {0}, {1} divisions",
["steps.title"] = "Worked solution",
["steps.show"] = "Show steps",
["steps.hide"] = "Hide steps",
["steps.1.unify"] = "① Unify units: convert the real distance to cm (1 km = 100000 cm)",
["steps.2.formulaReal"] = "② Real distance = map distance × scale denominator",
["steps.2.formulaMap"] = "② Map distance = real distance ÷ scale denominator",
["steps.2.formulaScale"] = "② Scale denominator = real distance ÷ map distance",
["steps.3.substitute"] = "③ Substitute: {0}",
["steps.4.result"] = "④ Result: {0}",
["steps.5.convert"] = "⑤ Convert to a sensible unit (cm → m → km)",
["grade.title"] = "Large / small scale",
["grade.large"] = "Large scale",
["grade.medium"] = "Medium scale",
["grade.small"] = "Small scale",
["grade.largeNote"] = "Small area · detailed · e.g. campus plan",
["grade.mediumNote"] = "Medium area · e.g. city map",
["grade.smallNote"] = "Large area · simplified · e.g. world map",
["grade.rule"] = "Bigger denominator → smaller scale → larger area → less detail",
["pit.title"] = "Common mistakes",
["pit.1"] = "① Forgetting to unify units: km ×100000 = cm",
["pit.2"] = "② \"Zoom 2×\" means denominator ÷ 2, not × 2",
["pit.3"] = "③ Don't swap map distance and real distance",
["field.title"] = "Real-world ruler · how long on the map",
["field.hint"] = "Pick a real distance and change the scale to see its map length",
["field.mapLength"] = "On map {0}",
["field.tooLong"] = "too long",
["field.tooShort"] = "barely visible",
["quiz.title"] = "Practice",
["quiz.promptReal"] = "Scale 1:{0}, map distance {1} cm — what is the real distance? (enter the number in the shown unit)",
["quiz.promptMap"] = "Scale 1:{0}, real distance {1} — what is the map distance in cm?",
["quiz.promptScale"] = "{0} cm on the map = {1} on the ground — what is the scale denominator?",
["quiz.answer"] = "Your answer",
["quiz.check"] = "Check",
["quiz.next"] = "Next",
["quiz.correct"] = "✓ Correct!",
["quiz.wrong"] = "✗ Try again — read the steps",
["quiz.streak"] = "{0} in a row",
["quiz.showSteps"] = "Show solution",
["quiz.unit"] = "Unit: {0}",
["ruler.title"] = "Visual ruler",
["ruler.mapBar"] = "Map distance (real cm)",
["ruler.realBar"] = "Real distance (compressed by the same scale)",
["ruler.sameWidth"] = "same width as above",
["ruler.equals"] = "equals",
["ruler.segment"] = "Graphic scale",
["ruler.segmentHint"] = "auto-ranging ticks",
["ruler.spectrum"] = "Scale spectrum",
["ruler.scopeUp"] = "◀ larger area",
["ruler.detailDown"] = "more detail ▶",
["ruler.hint"] = "Blue is the real map length; green is the same real distance compressed by the scale",
["ruler.overflowMap"] = "This map distance overflows the sheet — use a smaller scale",
["ruler.overflowReal"] = "This real distance won't fit at this scale — use a smaller scale",
["unit.cm"] = "cm",
["unit.m"] = "m",
["unit.km"] = "km",
["unit.none"] = "(unitless)",
["spec.campus"] = "Campus",
["spec.city"] = "City",
["spec.china"] = "China",
["spec.world"] = "World",
["preset.campus"] = "Campus 1:10k",
["preset.campusNote"] = "Buildings clearly drawn",
["preset.town"] = "Town 1:50k",
["preset.townNote"] = "Villages and roads",
["preset.city"] = "City 1:250k",
["preset.cityNote"] = "Urban area and arterials",
["preset.province"] = "Province 1:1M",
["preset.provinceNote"] = "Cities and rivers",
["preset.china"] = "China 1:10M",
["preset.chinaNote"] = "Province outlines",
["preset.world"] = "World 1:100M",
["preset.worldNote"] = "Continents & oceans",
["lm.classroom"] = "Classroom 10 m",
["lm.track"] = "Running track 400 m",
["lm.marathon"] = "Marathon 42.195 km",
["lm.beijingShanghai"] = "Beijing–Shanghai 1080 km",
["lm.equator"] = "Equator 40,000 km",
["common.footer"] = "Scale = map distance ÷ real distance · unify units first · bigger denominator = smaller scale"
};
}
@@ -1,10 +0,0 @@
using GC.ModelSdk;
namespace GC.ScaleCalculator;
/// <summary>比例尺计算器模型入口(清单里的 type 指向这里)。</summary>
public sealed class ScaleCalculatorFactory : IModelFactory
{
public int ApiVersion => 1;
public IModelRuntime Create() => new ScaleCalculatorRuntime();
}
@@ -1,24 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>disable</ImplicitUsings>
<RootNamespace>GC.ScaleCalculator</RootNamespace>
<AssemblyName>ScaleCalculatorModel</AssemblyName>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<IsPackable>false</IsPackable>
</PropertyGroup>
<!-- 本模型不复用 _engine 的球面渲染,只用 Avalonia 基础控件 + 一个自绘标尺 -->
<ItemGroup>
<PackageReference Include="Avalonia" Version="$(AvaloniaVersion)" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\_sdk\GC.ModelSdk\GC.ModelSdk.csproj">
<Private>false</Private>
</ProjectReference>
</ItemGroup>
</Project>
@@ -1,78 +0,0 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Text.Json;
using Avalonia.Controls;
using GC.ModelSdk;
namespace GC.ScaleCalculator;
/// <summary>
/// 比例尺计算器运行时。Prepare 在后台线程读数据/语言包,CreateView 在 UI 线程构建界面。
/// 不依赖 _engine(没有球面渲染),只用 Avalonia 基础控件 + 一个自绘标尺。
/// </summary>
public sealed class ScaleCalculatorRuntime : IModelRuntime
{
private ScaleData? _data;
private Dictionary<string, string>? _texts;
public void Prepare(IModelContext context)
{
context.ReportProgress(0.1, "载入预设数据");
_data = ScaleData.Load(context.DataDirectory);
context.ReportProgress(0.55, "载入语言包");
_texts = LoadTexts(context.DataDirectory, context.Language);
context.ReportProgress(0.9, "准备界面");
context.Log($"[scale-calculator] 语言 {context.Language}," +
$"预设 {_data.Presets.Count} 档 / 地标 {_data.Landmarks.Count} 个");
}
public Control CreateView(IModelContext context)
{
context.ReportProgress(0.96, "构建界面");
_data ??= ScaleData.Load(context.DataDirectory);
_texts ??= LoadTexts(context.DataDirectory, context.Language);
var view = new ScaleCalculatorView(_data, _texts, context.Language);
context.ReportProgress(1.0, "准备就绪");
return view;
}
public void Dispose()
{
_data = null;
_texts = null;
System.GC.SuppressFinalize(this);
}
private static Dictionary<string, string> LoadTexts(string dataDir, string language)
{
// 先内置中文兜底,再按 language 覆盖,最后用 zh-CN 补齐缺键
var map = new Dictionary<string, string>(DefaultTexts.Zh);
var isEn = language.StartsWith("en", StringComparison.OrdinalIgnoreCase);
if (isEn)
foreach (var kv in DefaultTexts.En) map[kv.Key] = kv.Value;
Overlay(Path.Combine(dataDir, "i18n", "zh-CN.json"), map);
if (isEn) Overlay(Path.Combine(dataDir, "i18n", "en.json"), map);
else Overlay(Path.Combine(dataDir, "i18n", language + ".json"), map);
return map;
}
private static void Overlay(string path, Dictionary<string, string> target)
{
if (!File.Exists(path)) return;
try
{
var extra = JsonSerializer.Deserialize<Dictionary<string, string>>(File.ReadAllText(path),
new JsonSerializerOptions { ReadCommentHandling = JsonCommentHandling.Skip, AllowTrailingCommas = true });
if (extra == null) return;
foreach (var kv in extra) target[kv.Key] = kv.Value;
}
catch (Exception ex)
{
Console.Error.WriteLine($"[scale-calculator] 语言包读取失败 {path}: {ex.Message}");
}
}
}
@@ -1,489 +0,0 @@
using System;
using Avalonia;
using Avalonia.Controls;
using Avalonia.Controls.Primitives;
using Avalonia.Layout;
using Avalonia.Media;
namespace GC.ScaleCalculator;
public sealed partial class ScaleCalculatorView
{
// 模式条
private Button _btnReal = null!, _btnMap = null!, _btnScale = null!;
// 左栏输入
private Slider _mapSlider = null!;
private TextBox _mapBox = null!, _realBox = null!, _nBox = null!;
private ComboBox _unitBox = null!;
private TextBlock _mapCardLabel = null!, _realCardLabel = null!, _scaleCardLabel = null!;
private TextBlock _mapResultText = null!, _realResultText = null!, _scaleResultText = null!;
private Border _mapCard = null!, _realCard = null!, _scaleCard = null!;
private WrapPanel _presetPanel = null!;
// 中栏
private ScaleRuler _ruler = null!;
// 右栏
private TextBlock _digitalText = null!, _verbalText = null!, _segmentText = null!;
private TextBlock _gradeTitle = null!, _gradeNote = null!, _gradeRule = null!;
private Border _gradeChip = null!;
private StackPanel _stepsPanel = null!;
private Button _stepsToggle = null!;
private bool _stepsOpen;
// 底部:实地尺
private ComboBox _landmarkBox = null!;
private TextBlock _landmarkResult = null!;
// 底部:练习
private TextBlock _quizPrompt = null!, _quizFeedback = null!, _quizStreak = null!, _quizUnit = null!;
private TextBox _quizInput = null!;
private Button _quizCheck = null!, _quizNext = null!;
private StackPanel _quizSteps = null!;
private void BuildLayout()
{
var root = new Grid { Background = B(CAppBg) };
root.RowDefinitions.Add(new RowDefinition(GridLength.Auto)); // 顶部
root.RowDefinitions.Add(new RowDefinition(GridLength.Star)); // 三栏
root.RowDefinitions.Add(new RowDefinition(GridLength.Auto)); // 底部
root.RowDefinitions.Add(new RowDefinition(GridLength.Auto)); // 页脚
var header = BuildHeader();
Grid.SetRow(header, 0);
root.Children.Add(header);
var columns = new Grid { Margin = new Thickness(16, 12, 16, 8) };
columns.ColumnDefinitions.Add(new ColumnDefinition(new GridLength(300)));
columns.ColumnDefinitions.Add(new ColumnDefinition(new GridLength(16)));
columns.ColumnDefinitions.Add(new ColumnDefinition(GridLength.Star));
columns.ColumnDefinitions.Add(new ColumnDefinition(new GridLength(16)));
columns.ColumnDefinitions.Add(new ColumnDefinition(new GridLength(320)));
var left = BuildLeft();
Grid.SetColumn(left, 0);
columns.Children.Add(left);
var mid = BuildMiddle();
Grid.SetColumn(mid, 2);
columns.Children.Add(mid);
var right = BuildRight();
Grid.SetColumn(right, 4);
columns.Children.Add(right);
Grid.SetRow(columns, 1);
root.Children.Add(columns);
var bottom = BuildBottom();
Grid.SetRow(bottom, 2);
root.Children.Add(bottom);
var footer = new Border
{
Background = B(CSurfaceAlt),
BorderBrush = B(CLine),
BorderThickness = new Thickness(0, 1, 0, 0),
Padding = new Thickness(20, 9),
Child = Tb(T("common.footer"), 11, CInkFaint)
};
Grid.SetRow(footer, 3);
root.Children.Add(footer);
Content = root;
}
private Control BuildHeader()
{
var title = Tb(T("app.title"), 22, CInk, FontWeight.SemiBold);
var sub = Tb(T("app.subtitle"), 12, CInkDim);
_btnReal = Btn(T("mode.real"));
_btnMap = Btn(T("mode.map"));
_btnScale = Btn(T("mode.scale"));
var modes = H(8);
modes.Children.Add(_btnReal);
modes.Children.Add(_btnMap);
modes.Children.Add(_btnScale);
var leftStack = V(2);
leftStack.Children.Add(title);
leftStack.Children.Add(sub);
var grid = new Grid
{
Background = B(CSurface),
Margin = new Thickness(0)
};
grid.ColumnDefinitions.Add(new ColumnDefinition(GridLength.Star));
grid.ColumnDefinitions.Add(new ColumnDefinition(GridLength.Auto));
var leftBorder = new Border { Padding = new Thickness(20, 14, 10, 14), Child = leftStack };
Grid.SetColumn(leftBorder, 0);
grid.Children.Add(leftBorder);
var rightBorder = new Border
{
Padding = new Thickness(10, 14, 20, 14),
VerticalAlignment = VerticalAlignment.Center,
Child = V(4)
};
// 右侧:提示 + 模式按钮
var rv = (StackPanel)rightBorder.Child!;
rv.Children.Add(Tb(T("mode.hint"), 10.5, CInkFaint, align: TextAlignment.Right));
rv.Children.Add(modes);
Grid.SetColumn(rightBorder, 1);
grid.Children.Add(rightBorder);
var outer = new Border
{
Background = B(CSurface),
BorderBrush = B(CLine),
BorderThickness = new Thickness(0, 0, 0, 1),
Child = grid
};
return outer;
}
private Control BuildLeft()
{
var panel = V(10);
var head = H(6);
head.Children.Add(new Border
{
Width = 4, Height = 16, Background = B(CAccent),
CornerRadius = new CornerRadius(2)
});
head.Children.Add(H3(T("input.title")));
panel.Children.Add(head);
// ── 图上距离卡
panel.Children.Add(BuildInputCard(
"input.map", "unit.cm", out _mapCard, out _mapCardLabel, out _mapResultText,
out _mapSlider, out _mapBox, withSlider: true));
// ── 实地距离卡
panel.Children.Add(BuildRealCard());
// ── 比例尺卡
panel.Children.Add(BuildScaleCard());
// 预设
panel.Children.Add(Label(T("input.presets"), 11.5, CInkFaint));
_presetPanel = new WrapPanel { Orientation = Orientation.Horizontal };
foreach (var p in _data.Presets)
{
var b = Btn(T(p.NameKey));
b.Tag = p;
b.Click += (_, _) => ApplyPreset((PresetItem)b.Tag!);
b.Margin = new Thickness(0, 0, 6, 6);
_presetPanel.Children.Add(b);
}
panel.Children.Add(_presetPanel);
panel.Children.Add(Divider());
var reset = Btn(T("input.reset"));
reset.Click += (_, _) => ResetState();
panel.Children.Add(reset);
panel.Children.Add(Tb(T("input.dragHint"), 10.5, CInkFaint));
var scroll = new ScrollViewer
{
Content = new Border { Padding = new Thickness(14), Child = panel },
VerticalScrollBarVisibility = ScrollBarVisibility.Auto,
HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled
};
return Card(scroll);
}
private Control BuildInputCard(string labelKey, string unitKey,
out Border card, out TextBlock label, out TextBlock resultText,
out Slider slider, out TextBox box, bool withSlider)
{
label = Label(T(labelKey), 11.5);
resultText = Tb("—", 15, CInk, FontWeight.SemiBold);
var top = new DockPanel();
top.Children.Add(resultText);
DockPanel.SetDock(resultText, Dock.Right);
top.Children.Add(label);
box = Input("3");
box.Width = 110;
box.HorizontalAlignment = HorizontalAlignment.Left;
slider = new Slider
{
Minimum = 0.1,
Maximum = 20,
Value = 3,
TickFrequency = 0.5,
IsSnapToTickEnabled = false,
Foreground = B(CAccent),
Margin = new Thickness(0, 2, 0, 0)
};
var stack = V(6);
stack.Children.Add(top);
stack.Children.Add(box);
if (withSlider) stack.Children.Add(slider);
card = new Border
{
Background = B(CSurfaceAlt),
BorderBrush = B(CLine),
BorderThickness = new Thickness(1),
CornerRadius = new CornerRadius(10),
Padding = new Thickness(12),
Child = stack
};
return card;
}
private Control BuildRealCard()
{
_realCardLabel = Label(T("input.real"), 11.5);
_realResultText = Tb("—", 15, CInk, FontWeight.SemiBold);
var top = new DockPanel();
top.Children.Add(_realResultText);
DockPanel.SetDock(_realResultText, Dock.Right);
top.Children.Add(_realCardLabel);
_realBox = Input("3");
_unitBox = new ComboBox
{
FontSize = 12.5,
Background = B(CSurface),
Foreground = B(CInk),
BorderBrush = B(CLineStrong),
BorderThickness = new Thickness(1),
CornerRadius = new CornerRadius(9),
Padding = new Thickness(10, 6),
MinHeight = 34,
Width = 92,
ItemsSource = new[] { "unit.km", "unit.m", "unit.cm" },
SelectedIndex = 0
};
// 显示本地化单位名
_unitBox.SelectionChanged += (_, _) => { SyncUnitDisplay(); RefreshAll(syncInputs: true); };
var row = H(8);
row.Children.Add(_realBox);
row.Children.Add(_unitBox);
var stack = V(6);
stack.Children.Add(top);
stack.Children.Add(row);
_realCard = new Border
{
Background = B(CSurfaceAlt),
BorderBrush = B(CLine),
BorderThickness = new Thickness(1),
CornerRadius = new CornerRadius(10),
Padding = new Thickness(12),
Child = stack
};
return _realCard;
}
private Control BuildScaleCard()
{
_scaleCardLabel = Label(T("input.scale"), 11.5);
_scaleResultText = Tb("—", 15, CInk, FontWeight.SemiBold);
var top = new DockPanel();
top.Children.Add(_scaleResultText);
DockPanel.SetDock(_scaleResultText, Dock.Right);
top.Children.Add(_scaleCardLabel);
_nBox = Input("100000");
var prefix = Tb(T("input.nPrefix"), 13, CInkDim, FontWeight.SemiBold);
var row = H(8);
row.Children.Add(prefix);
row.Children.Add(_nBox);
var stack = V(6);
stack.Children.Add(top);
stack.Children.Add(row);
_scaleCard = new Border
{
Background = B(CSurfaceAlt),
BorderBrush = B(CLine),
BorderThickness = new Thickness(1),
CornerRadius = new CornerRadius(10),
Padding = new Thickness(12),
Child = stack
};
return _scaleCard;
}
private Control BuildMiddle()
{
_ruler = new ScaleRuler
{
Data = _data,
State = _state,
T = T,
Height = 470,
VerticalAlignment = VerticalAlignment.Top
};
var holder = new Border
{
Background = B(CSurface),
BorderBrush = B(CLine),
BorderThickness = new Thickness(1),
CornerRadius = new CornerRadius(14),
Padding = new Thickness(6),
Child = _ruler
};
return holder;
}
private Control BuildRight()
{
var panel = V(10);
// 三种写法
panel.Children.Add(SectionTitle(T("forms.title")));
_digitalText = Tb("", 16, CAccentDark, FontWeight.SemiBold);
_verbalText = Tb("", 12, CInk);
_segmentText = Tb("", 12, CInk);
var forms = V(8);
forms.Children.Add(FormRow(T("forms.digital"), _digitalText));
forms.Children.Add(FormRow(T("forms.verbal"), _verbalText));
forms.Children.Add(FormRow(T("forms.segment"), _segmentText));
panel.Children.Add(forms);
panel.Children.Add(Divider());
// 解题步骤
_stepsToggle = Btn(T("steps.show"));
_stepsToggle.Click += (_, _) => ToggleSteps();
var sh = new DockPanel();
DockPanel.SetDock(_stepsToggle, Dock.Right);
sh.Children.Add(_stepsToggle);
sh.Children.Add(SectionTitle(T("steps.title")));
panel.Children.Add(sh);
_stepsPanel = V(4);
_stepsPanel.IsVisible = false;
panel.Children.Add(_stepsPanel);
panel.Children.Add(Divider());
// 判读
panel.Children.Add(SectionTitle(T("grade.title")));
_gradeChip = Chip("", CAccentSoft, CAccentDark);
_gradeChip.HorizontalAlignment = HorizontalAlignment.Left;
_gradeTitle = Tb("", 13, CInk, FontWeight.SemiBold);
_gradeNote = Tb("", 11.5, CInkDim);
_gradeRule = Tb(T("grade.rule"), 11, CAccentDark, FontWeight.SemiBold);
var gradeBox = V(6);
gradeBox.Children.Add(_gradeChip);
gradeBox.Children.Add(_gradeNote);
gradeBox.Children.Add(_gradeRule);
panel.Children.Add(gradeBox);
panel.Children.Add(Divider());
// 易错点
panel.Children.Add(SectionTitle(T("pit.title")));
var pit = V(4);
pit.Children.Add(Tb(T("pit.1"), 11, CInkDim));
pit.Children.Add(Tb(T("pit.2"), 11, CInkDim));
pit.Children.Add(Tb(T("pit.3"), 11, CInkDim));
panel.Children.Add(pit);
var scroll = new ScrollViewer
{
Content = new Border { Padding = new Thickness(14), Child = panel },
VerticalScrollBarVisibility = ScrollBarVisibility.Auto,
HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled
};
return Card(scroll);
}
private Control FormRow(string name, TextBlock value)
{
var g = new Grid();
g.ColumnDefinitions.Add(new ColumnDefinition(new GridLength(62)));
g.ColumnDefinitions.Add(new ColumnDefinition(GridLength.Star));
var n = Tb(name, 11, CInkFaint);
Grid.SetColumn(n, 0);
g.Children.Add(n);
Grid.SetColumn(value, 1);
g.Children.Add(value);
return g;
}
private Control SectionTitle(string text)
=> Tb(text, 12.5, CInk, FontWeight.SemiBold);
private Control BuildBottom()
{
var grid = new Grid { Margin = new Thickness(16, 4, 16, 12) };
grid.ColumnDefinitions.Add(new ColumnDefinition(GridLength.Star));
grid.ColumnDefinitions.Add(new ColumnDefinition(new GridLength(12)));
grid.ColumnDefinitions.Add(new ColumnDefinition(new GridLength(1.4, GridUnitType.Star)));
// ── 实地尺
var field = V(8);
field.Children.Add(SectionTitle(T("field.title")));
field.Children.Add(Tb(T("field.hint"), 10.5, CInkFaint));
_landmarkBox = new ComboBox
{
FontSize = 12.5,
Background = B(CSurface),
Foreground = B(CInk),
BorderBrush = B(CLineStrong),
BorderThickness = new Thickness(1),
CornerRadius = new CornerRadius(9),
Padding = new Thickness(10, 6),
MinHeight = 34,
HorizontalAlignment = HorizontalAlignment.Stretch
};
foreach (var lm in _data.Landmarks) _landmarkBox.Items!.Add(T(lm.NameKey));
_landmarkBox.SelectedIndex = 0;
_landmarkBox.SelectionChanged += (_, _) => RefreshField();
field.Children.Add(_landmarkBox);
_landmarkResult = Tb("", 14, CSuccess, FontWeight.SemiBold);
field.Children.Add(_landmarkResult);
var fieldCard = Card(field);
Grid.SetColumn(fieldCard, 0);
grid.Children.Add(fieldCard);
// ── 练习
var quiz = V(8);
_quizStreak = Tb(TF("quiz.streak", 0), 11, CAccentDark, FontWeight.SemiBold);
var qh = new DockPanel();
DockPanel.SetDock(_quizStreak, Dock.Right);
qh.Children.Add(_quizStreak);
qh.Children.Add(SectionTitle(T("quiz.title")));
quiz.Children.Add(qh);
_quizPrompt = Tb("", 12, CInk);
quiz.Children.Add(_quizPrompt);
_quizUnit = Tb("", 10.5, CInkFaint);
quiz.Children.Add(_quizUnit);
var qrow = H(8);
_quizInput = Input("");
_quizInput.Width = 140;
_quizCheck = Btn(T("quiz.check"), primary: true);
_quizNext = Btn(T("quiz.next"));
_quizCheck.Click += (_, _) => CheckQuiz();
_quizNext.Click += (_, _) => NewQuiz();
qrow.Children.Add(_quizInput);
qrow.Children.Add(_quizCheck);
qrow.Children.Add(_quizNext);
quiz.Children.Add(qrow);
_quizFeedback = Tb("", 12, CInkDim, FontWeight.SemiBold);
quiz.Children.Add(_quizFeedback);
_quizSteps = V(2);
quiz.Children.Add(_quizSteps);
var quizCard = Card(quiz);
Grid.SetColumn(quizCard, 2);
grid.Children.Add(quizCard);
return grid;
}
}
@@ -1,312 +0,0 @@
using System;
using System.Globalization;
using Avalonia;
using Avalonia.Controls;
using Avalonia.Controls.Primitives;
using Avalonia.Media;
namespace GC.ScaleCalculator;
public sealed partial class ScaleCalculatorView
{
private readonly ScaleState _state = new();
private bool _suppress;
private string _realUnit = "unit.km";
private QuizItem _quiz = new();
private int _streak;
private bool _quizAnswered;
private void WireEvents()
{
_btnReal.Click += (_, _) => SetMode(SolveMode.Real);
_btnMap.Click += (_, _) => SetMode(SolveMode.Map);
_btnScale.Click += (_, _) => SetMode(SolveMode.Scale);
_mapSlider.ValueChanged += (_, e) =>
{
if (_suppress) return;
_state.MapCm = e.NewValue;
_suppress = true;
_mapBox.Text = ScaleMath.Num(_state.MapCm);
_suppress = false;
RefreshAll(syncInputs: false);
};
_mapBox.TextChanged += (_, _) => OnTextInput(_mapBox, v => { _state.MapCm = v; }, v =>
{
_suppress = true;
_mapSlider.Value = Math.Clamp(v, 0.1, 20);
_suppress = false;
});
_realBox.TextChanged += (_, _) =>
{
if (_suppress) return;
if (ScaleMath.TryParseReal(_realBox.Text ?? "", _realUnit, out var cm))
{
_state.RealCm = cm;
RefreshAll(syncInputs: false);
}
};
_nBox.TextChanged += (_, _) => OnTextInput(_nBox, v => { _state.N = v; }, null);
_quizInput.KeyDown += (_, e) =>
{
if (e.Key == Avalonia.Input.Key.Enter) CheckQuiz();
};
}
private void OnTextInput(TextBox box, Action<double> apply, Action<double>? extra)
{
if (_suppress) return;
if (!double.TryParse((box.Text ?? "").Replace(",", "").Trim(), NumberStyles.Float,
CultureInfo.InvariantCulture, out var v) || v < 0 || double.IsNaN(v) || double.IsInfinity(v))
return;
apply(v);
extra?.Invoke(v);
RefreshAll(syncInputs: false);
}
private void SetMode(SolveMode mode, bool initial = false)
{
_state.Mode = mode;
if (!initial) ScaleMath.Solve(_state);
UpdateModeButtons();
RefreshAll(syncInputs: true);
}
private void UpdateModeButtons()
{
StyleMode(_btnReal, _state.Mode == SolveMode.Real);
StyleMode(_btnMap, _state.Mode == SolveMode.Map);
StyleMode(_btnScale, _state.Mode == SolveMode.Scale);
// 结果卡高亮:待求的那一张变蓝
StyleCard(_mapCard, _state.Mode == SolveMode.Map);
StyleCard(_realCard, _state.Mode == SolveMode.Real);
StyleCard(_scaleCard, _state.Mode == SolveMode.Scale);
_mapResultText.Foreground = B(_state.Mode == SolveMode.Map ? CAccentDark : CInk);
_realResultText.Foreground = B(_state.Mode == SolveMode.Real ? CAccentDark : CInk);
_scaleResultText.Foreground = B(_state.Mode == SolveMode.Scale ? CAccentDark : CInk);
}
private void StyleMode(Button b, bool active)
{
b.Background = B(active ? CAccent : CSurface);
b.BorderBrush = B(active ? CAccent : CLineStrong);
b.BorderThickness = new Thickness(active ? 0 : 1);
if (b.Content is TextBlock t)
t.Foreground = B(active ? Colors.White : CInk);
}
private static void StyleCard(Border card, bool active)
{
card.Background = B(active ? Color.Parse("#F0F5FF") : Color.Parse("#F7F9FE"));
card.BorderBrush = B(active ? Color.Parse("#2F6BFF") : Color.Parse("#E3E8F3"));
card.BorderThickness = new Thickness(active ? 1.5 : 1);
}
private void ApplyPreset(PresetItem p)
{
_state.N = p.N;
ScaleMath.Solve(_state);
RefreshAll(syncInputs: true);
}
private void ResetState()
{
_state.MapCm = 3.0;
_state.N = 100000.0;
ScaleMath.Solve(_state);
RefreshAll(syncInputs: true);
}
private void SyncUnitDisplay()
{
// ComboBox 的 ItemsSource 是 "unit.km" 等键;这里只记录选择,显示由下拉项本身处理
var idx = _unitBox.SelectedIndex;
_realUnit = idx switch { 1 => "unit.m", 2 => "unit.cm", _ => "unit.km" };
}
/// <summary>
/// 全量刷新。syncInputs=true 时把三个输入框/滑块同步成 state(切换模式、预设、重置后需要);
/// false 时保留用户正在输入的文本(避免光标跳动)。
/// </summary>
private void RefreshAll(bool syncInputs)
{
ScaleMath.Solve(_state);
if (syncInputs)
{
_suppress = true;
_mapBox.Text = ScaleMath.Num(_state.MapCm);
_mapSlider.Value = Math.Clamp(_state.MapCm, 0.1, 20);
_nBox.Text = ScaleMath.FormatN(_state.N);
var (rv, _) = ScaleMath.HumanReal(_state.RealCm);
// 用当前选择的单位显示
_realBox.Text = ScaleMath.Num(ScaleMath.ToUnit(_state.RealCm, _realUnit));
_suppress = false;
}
UpdateModeButtons();
// 结果卡读数(三张都显示当前值,蓝色那张是"答案")
_mapResultText.Text = ScaleMath.Num(_state.MapCm) + " " + T("unit.cm");
var (rv2, rkey2) = ScaleMath.HumanReal(_state.RealCm);
_realResultText.Text = ScaleMath.Num(rv2) + " " + T(rkey2);
_scaleResultText.Text = "1 : " + ScaleMath.FormatN(_state.N);
// 三种写法
_digitalText.Text = ScaleMath.Digital(_state.N);
_verbalText.Text = TF("forms.verbalTpl", ScaleMath.VerbalDistance(_state.N));
_segmentText.Text = TF("forms.segmentDesc",
ScaleMath.SegmentLabel(_ruler.Segment.MetersPerDiv), _ruler.Segment.DivCount);
// 判读
var gradeKey = ScaleMath.GradeKey(_state.N);
_gradeTitle.Text = T(gradeKey);
_gradeChip.Child = Tb(T(gradeKey), 11, CAccentDark, FontWeight.SemiBold);
_gradeNote.Text = T(gradeKey + "Note");
_gradeRule.Text = T("grade.rule");
// 标尺
_ruler.State = _state.Clone();
_ruler.Refresh();
_segmentText.Text = TF("forms.segmentDesc",
ScaleMath.SegmentLabel(_ruler.Segment.MetersPerDiv), _ruler.Segment.DivCount);
BuildSteps();
RefreshField();
}
private void BuildSteps()
{
_stepsPanel.Children.Clear();
var map = ScaleMath.Num(_state.MapCm);
var realCm = ScaleMath.Num(_state.RealCm);
var n = ScaleMath.FormatN(_state.N);
var (rv, rk) = ScaleMath.HumanReal(_state.RealCm);
var result = _state.Mode switch
{
SolveMode.Real => ScaleMath.Num(rv) + " " + T(rk),
SolveMode.Map => ScaleMath.Num(_state.MapCm) + " " + T("unit.cm"),
_ => "1 : " + ScaleMath.FormatN(_state.N)
};
var formulaKey = _state.Mode switch
{
SolveMode.Real => "steps.2.formulaReal",
SolveMode.Map => "steps.2.formulaMap",
_ => "steps.2.formulaScale"
};
var substitute = _state.Mode switch
{
SolveMode.Real => map + " cm × " + n,
SolveMode.Map => realCm + " cm ÷ " + n,
_ => realCm + " cm ÷ " + map + " cm"
};
var lines = new System.Collections.Generic.List<string>
{
T("steps.1.unify"),
T(formulaKey),
TF("steps.3.substitute", substitute),
TF("steps.4.result", result),
T("steps.5.convert")
};
var i = 0;
foreach (var line in lines)
{
_stepsPanel.Children.Add(Tb(line, 11, i == 3 ? CAccentDark : CInkDim,
i == 3 ? FontWeight.SemiBold : null));
i++;
}
}
private void ToggleSteps()
{
_stepsOpen = !_stepsOpen;
_stepsPanel.IsVisible = _stepsOpen;
_stepsToggle.Content = Tb(T(_stepsOpen ? "steps.hide" : "steps.show"), 12.5, CInk, FontWeight.SemiBold);
}
private void RefreshField()
{
var idx = _landmarkBox.SelectedIndex;
if (idx < 0 || idx >= _data.Landmarks.Count) return;
var meters = _data.Landmarks[idx].Meters;
var realCm = meters * ScaleMath.CmPerM;
var mapCm = ScaleMath.RealToMapCm(realCm, _state.N);
var px = ScaleMath.CmToPx(mapCm, _ruler.PxPerCm);
// mapCm 是厘米,按 HumanReal 换算成"图上长度"的合适单位
var (mv, mk) = ScaleMath.HumanReal(mapCm);
string text;
if (px > _ruler.MaxBarWidth)
text = TF("field.mapLength", ScaleMath.Num(mv) + " " + T(mk)) + " · " + T("field.tooLong");
else if (px < 1)
text = TF("field.mapLength", ScaleMath.Num(mv) + " " + T(mk)) + " · " + T("field.tooShort");
else
text = TF("field.mapLength", ScaleMath.Num(mv) + " " + T(mk));
_landmarkResult.Text = text;
_landmarkResult.Foreground = B(px > _ruler.MaxBarWidth ? CDanger : px < 1 ? CWarn : CSuccess);
}
// ────────────────────────────────────────────────────────── 练习
private void NewQuiz()
{
_quiz = ScaleMath.GenerateQuiz(_rnd);
_quizAnswered = false;
_quizInput.Text = "";
_quizFeedback.Text = "";
_quizSteps.Children.Clear();
_quizPrompt.Text = TF(_quiz.PromptKey, _quiz.PromptArgs);
var unitText = _quiz.AnswerUnitKey == "unit.none" ? T("unit.none") : T(_quiz.AnswerUnitKey);
_quizUnit.Text = TF("quiz.unit", unitText);
_quizStreak.Text = TF("quiz.streak", _streak);
}
private void CheckQuiz()
{
if (_quizAnswered) return;
if (!double.TryParse((_quizInput.Text ?? "").Replace(",", "").Trim(), NumberStyles.Float,
CultureInfo.InvariantCulture, out var v))
{
_quizFeedback.Text = T("quiz.wrong");
_quizFeedback.Foreground = B(CDanger);
return;
}
if (ScaleMath.CheckAnswer(_quiz, v))
{
_streak++;
_quizFeedback.Text = T("quiz.correct");
_quizFeedback.Foreground = B(CSuccess);
}
else
{
_streak = 0;
_quizFeedback.Text = T("quiz.wrong");
_quizFeedback.Foreground = B(CDanger);
ShowQuizSteps();
}
_quizAnswered = true;
_quizStreak.Text = TF("quiz.streak", _streak);
}
private void ShowQuizSteps()
{
_quizSteps.Children.Clear();
_quizSteps.Children.Add(Tb(T("quiz.showSteps"), 10.5, CInkFaint, FontWeight.SemiBold));
foreach (var key in _quiz.StepKeys)
{
var line = T(key);
if (line.Contains("{0}")) line = TF(key, ScaleMath.Num(_quiz.Answer) + " " +
(_quiz.AnswerUnitKey == "unit.none" ? "" : T(_quiz.AnswerUnitKey)));
_quizSteps.Children.Add(Tb(line, 10.5, CInkDim));
}
_quizSteps.Children.Add(Tb(TF("steps.4.result",
ScaleMath.Num(_quiz.Answer) + " " +
(_quiz.AnswerUnitKey == "unit.none" ? "" : T(_quiz.AnswerUnitKey))),
10.5, CAccentDark, FontWeight.SemiBold));
}
}
@@ -1,141 +0,0 @@
using System;
using System.Collections.Generic;
using System.Globalization;
using Avalonia;
using Avalonia.Controls;
using Avalonia.Controls.Primitives;
using Avalonia.Input;
using Avalonia.Layout;
using Avalonia.Media;
namespace GC.ScaleCalculator;
/// <summary>
/// 比例尺计算器主界面。三栏(已知量 / 可视化标尺 / 三种写法与判读)+ 底部实地尺与练习。
/// 全部用显式画刷(与启动器 AppTheme 同色),不依赖 DynamicResource —— 模型 dll 在
/// 独立 ALC 里加载,headless 生成封面时也没有 Application 样式。
/// </summary>
public sealed partial class ScaleCalculatorView : UserControl
{
// 调色(与 GC/src/Styles/AppTheme.axaml 一致)
internal static readonly Color CAppBg = Color.Parse("#F4F6FB");
internal static readonly Color CSurface = Color.Parse("#FFFFFF");
internal static readonly Color CSurfaceAlt = Color.Parse("#F7F9FE");
internal static readonly Color CLine = Color.Parse("#E3E8F3");
internal static readonly Color CLineStrong = Color.Parse("#D2DAEA");
internal static readonly Color CInk = Color.Parse("#111A2E");
internal static readonly Color CInkDim = Color.Parse("#5B6A86");
internal static readonly Color CInkFaint = Color.Parse("#8A97B1");
internal static readonly Color CAccent = Color.Parse("#2F6BFF");
internal static readonly Color CAccentDark = Color.Parse("#1F4FD0");
internal static readonly Color CAccentSoft = Color.Parse("#EAF1FF");
internal static readonly Color CSuccess = Color.Parse("#1F9D6B");
internal static readonly Color CDanger = Color.Parse("#D64545");
internal static readonly Color CWarn = Color.Parse("#D98613");
internal static readonly Color CHero = Color.Parse("#12203C");
internal static SolidColorBrush B(Color c) => new(c);
internal static SolidColorBrush Brush(string hex) => new(Color.Parse(hex));
private readonly ScaleData _data;
private readonly Dictionary<string, string> _texts;
private readonly string _language;
private readonly Random _rnd = new();
public string T(string key)
=> _texts.TryGetValue(key, out var v) ? v
: DefaultTexts.Zh.TryGetValue(key, out var f) ? f : key;
public string TF(string key, params object[] args)
=> string.Format(CultureInfo.InvariantCulture, T(key), args);
public ScaleCalculatorView(ScaleData data, Dictionary<string, string> texts, string language)
{
_data = data;
_texts = texts;
_language = language;
BuildLayout();
WireEvents();
SetMode(SolveMode.Real, initial: true);
NewQuiz();
RefreshAll(syncInputs: true);
}
// ────────────────────────────────────────────────────────── 小工具
internal static Border Card(Control content, double radius = 14)
=> new()
{
Background = B(CSurface),
BorderBrush = B(CLine),
BorderThickness = new Thickness(1),
CornerRadius = new CornerRadius(radius),
Padding = new Thickness(14),
Child = content
};
internal static TextBlock Tb(string text, double size, Color color, FontWeight? weight = null,
TextAlignment align = TextAlignment.Left)
=> new()
{
Text = text,
FontSize = size,
Foreground = B(color),
FontWeight = weight ?? FontWeight.Normal,
TextAlignment = align,
TextWrapping = TextWrapping.Wrap
};
internal static TextBlock Label(string text, double size = 12, Color? color = null)
=> Tb(text, size, color ?? CInkDim);
internal static TextBlock H3(string text) => Tb(text, 13.5, CInk, FontWeight.SemiBold);
internal static Border Chip(string text, Color bg, Color fg, double radius = 8)
=> new()
{
Background = B(bg),
CornerRadius = new CornerRadius(radius),
Padding = new Thickness(10, 4),
Child = Tb(text, 11, fg, FontWeight.SemiBold)
};
internal static Button Btn(string text, bool primary = false)
=> new()
{
Content = Tb(text, 12.5, primary ? Colors.White : CInk, FontWeight.SemiBold),
Background = B(primary ? CAccent : CSurface),
BorderBrush = B(primary ? CAccent : CLineStrong),
BorderThickness = new Thickness(primary ? 0 : 1),
CornerRadius = new CornerRadius(9),
Padding = new Thickness(12, 7),
HorizontalContentAlignment = HorizontalAlignment.Center,
VerticalContentAlignment = VerticalAlignment.Center,
Cursor = new Cursor(StandardCursorType.Hand)
};
internal static TextBox Input(string text = "")
=> new()
{
Text = text,
FontSize = 12.5,
Background = B(CSurface),
Foreground = B(CInk),
BorderBrush = B(CLineStrong),
BorderThickness = new Thickness(1),
CornerRadius = new CornerRadius(9),
Padding = new Thickness(10, 7),
VerticalContentAlignment = VerticalAlignment.Center,
MinHeight = 34
};
internal static Border Divider(double h = 1)
=> new() { Background = B(CLine), Height = h, Margin = new Thickness(0, 10, 0, 10) };
internal static StackPanel V(double spacing = 8)
=> new() { Orientation = Orientation.Vertical, Spacing = spacing };
internal static StackPanel H(double spacing = 8)
=> new() { Orientation = Orientation.Horizontal, Spacing = spacing, VerticalAlignment = VerticalAlignment.Center };
}
-88
View File
@@ -1,88 +0,0 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Text.Json;
using System.Text.Json.Serialization;
namespace GC.ScaleCalculator;
public sealed class PresetItem
{
public double N { get; set; }
public string NameKey { get; set; } = "";
public string NoteKey { get; set; } = "";
}
public sealed class SpectrumItem
{
public double N { get; set; }
public string LabelKey { get; set; } = "";
public string ScopeKey { get; set; } = "";
}
public sealed class LandmarkItem
{
public string NameKey { get; set; } = "";
/// <summary>实地距离(米)。</summary>
public double Meters { get; set; }
}
public sealed class ScaleData
{
public List<PresetItem> Presets { get; set; } = new();
public List<SpectrumItem> Spectrum { get; set; } = new();
public List<LandmarkItem> Landmarks { get; set; } = new();
private static readonly JsonSerializerOptions Opts = new()
{
PropertyNameCaseInsensitive = true,
ReadCommentHandling = JsonCommentHandling.Skip,
AllowTrailingCommas = true,
NumberHandling = JsonNumberHandling.AllowReadingFromString
};
public static ScaleData Load(string dataDir)
{
var path = Path.Combine(dataDir, "scales.json");
if (!File.Exists(path)) return Fallback();
try
{
var d = JsonSerializer.Deserialize<ScaleData>(File.ReadAllText(path), Opts);
if (d == null || d.Presets.Count == 0) return Fallback();
return d;
}
catch (Exception ex)
{
Console.Error.WriteLine($"[scale-calculator] 读取 scales.json 失败: {ex.Message}");
return Fallback();
}
}
private static ScaleData Fallback() => new()
{
Presets = new List<PresetItem>
{
new() { N = 10000, NameKey = "preset.campus", NoteKey = "preset.campusNote" },
new() { N = 50000, NameKey = "preset.town", NoteKey = "preset.townNote" },
new() { N = 250000, NameKey = "preset.city", NoteKey = "preset.cityNote" },
new() { N = 1000000, NameKey = "preset.province", NoteKey = "preset.provinceNote" },
new() { N = 10000000, NameKey = "preset.china", NoteKey = "preset.chinaNote" },
new() { N = 100000000, NameKey = "preset.world", NoteKey = "preset.worldNote" }
},
Spectrum = new List<SpectrumItem>
{
new() { N = 10000, LabelKey = "spec.campus", ScopeKey = "spec.campusScope" },
new() { N = 250000, LabelKey = "spec.city", ScopeKey = "spec.cityScope" },
new() { N = 10000000, LabelKey = "spec.china", ScopeKey = "spec.chinaScope" },
new() { N = 100000000, LabelKey = "spec.world", ScopeKey = "spec.worldScope" }
},
Landmarks = new List<LandmarkItem>
{
new() { NameKey = "lm.classroom", Meters = 10 },
new() { NameKey = "lm.track", Meters = 400 },
new() { NameKey = "lm.marathon", Meters = 42195 },
new() { NameKey = "lm.beijingShanghai", Meters = 1080000 },
new() { NameKey = "lm.equator", Meters = 40000000 }
}
};
}
-291
View File
@@ -1,291 +0,0 @@
using System;
using System.Globalization;
namespace GC.ScaleCalculator;
/// <summary>三种求解模式:待求的量。</summary>
public enum SolveMode
{
/// <summary>求实地距离</summary>
Real,
/// <summary>求图上距离</summary>
Map,
/// <summary>求比例尺</summary>
Scale
}
public enum ScaleGrade { Large, Medium, Small }
/// <summary>
/// 三个量始终同时存在:图上距离(cm)、实地距离(cm)、比例尺分母 N。
/// <see cref="Mode"/> 指定哪个是"待求结果",另两个是输入;
/// <see cref="ScaleMath.Solve"/> 只由两个输入重算结果量,切换模式时数值保持连续。
/// </summary>
public sealed class ScaleState
{
public double MapCm = 3.0;
public double RealCm = 300000.0; // 3 km
public double N = 100000.0; // 1:100000
public SolveMode Mode = SolveMode.Real;
public ScaleState Clone() => new()
{
MapCm = MapCm, RealCm = RealCm, N = N, Mode = Mode
};
}
/// <summary>线段式比例尺换挡结果。</summary>
public sealed class SegmentScale
{
/// <summary>每一格代表的实地距离(米)。</summary>
public double MetersPerDiv;
/// <summary>每一格在屏幕上的像素宽度。</summary>
public double DivPx;
/// <summary>绘制的格数。</summary>
public int DivCount = 5;
}
/// <summary>一道练习题。</summary>
public sealed class QuizItem
{
public SolveMode Mode;
public string PromptKey = "";
public object[] PromptArgs = Array.Empty<object>();
public double Answer;
/// <summary>相对容差。</summary>
public double Tolerance = 0.02;
public string AnswerUnitKey = "unit.cm";
public string[] StepKeys = Array.Empty<string>();
}
public static class ScaleMath
{
public const double CmPerM = 100.0;
public const double CmPerKm = 100000.0;
/// <summary>由两个输入量重算"待求"量。</summary>
public static void Solve(ScaleState s)
{
// 先做一次合法性收敛,避免 0 / 负数进入除法
if (s.MapCm < 0) s.MapCm = 0;
if (s.RealCm < 0) s.RealCm = 0;
if (s.N < 1) s.N = 1;
switch (s.Mode)
{
case SolveMode.Real:
s.RealCm = s.MapCm * s.N;
break;
case SolveMode.Map:
s.MapCm = s.N > 0 ? s.RealCm / s.N : 0;
break;
case SolveMode.Scale:
s.N = s.MapCm > 1e-9 ? s.RealCm / s.MapCm : 1;
if (s.N < 1) s.N = 1;
break;
}
}
/// <summary>厘米 → 更合适的单位与数值。</summary>
public static (double value, string unitKey) HumanReal(double cm)
{
if (cm < 1) return (cm, "unit.cm");
if (cm < CmPerM) return (cm, "unit.cm");
if (cm < CmPerKm) return (cm / CmPerM, "unit.m");
return (cm / CmPerKm, "unit.km");
}
public static string Num(double v)
{
if (double.IsNaN(v) || double.IsInfinity(v)) return "—";
var a = Math.Abs(v);
if (a >= 1000) return v.ToString("#,##0", CultureInfo.InvariantCulture);
if (a >= 10) return v.ToString("0.#", CultureInfo.InvariantCulture);
if (a >= 1) return v.ToString("0.##", CultureInfo.InvariantCulture);
if (a >= 0.01) return v.ToString("0.###", CultureInfo.InvariantCulture);
if (a == 0) return "0";
return v.ToString("0.####", CultureInfo.InvariantCulture);
}
public static string FormatRealCm(double cm)
{
var (v, key) = HumanReal(cm);
return Num(v) + " " + key;
}
public static string FormatN(double n) => Num(Math.Round(n));
/// <summary>数字式写法 1:N。</summary>
public static string Digital(double n) => "1 : " + FormatN(n);
/// <summary>"文字式"里那一段实地距离(含单位),由调用方套 i18n 模板。</summary>
public static string VerbalDistance(double n)
{
// 图上 1 厘米代表实地 n 厘米
var (v, key) = HumanReal(n);
return Num(v) + " " + key;
}
/// <summary>按当前比例尺,把一段实地距离换算成图上厘米。</summary>
public static double RealToMapCm(double realCm, double n) => n > 0 ? realCm / n : 0;
/// <summary>把图上厘米换算为屏幕像素。</summary>
public static double CmToPx(double cm, double pxPerCm) => cm * pxPerCm;
/// <summary>把一段实地距离按当前比例尺换算成屏幕像素。</summary>
public static double RealToMapPx(double realCm, double n, double pxPerCm)
=> RealToMapCm(realCm, n) * pxPerCm;
/// <summary>
/// 线段式比例尺自动换挡:在 1/2/5×10^k(米)里挑一个,
/// 使每格画出来最接近 targetPx,保证任何比例尺都画得下、刻度又是整数。
/// </summary>
public static SegmentScale PickSegment(double n, double pxPerCm, double targetPx)
{
if (n < 1) n = 1;
if (pxPerCm < 1) pxPerCm = 1;
// 每格实地米数(理想值):px = m*100/n*pxPerCm
var idealMeters = targetPx * n / (100.0 * pxPerCm);
if (idealMeters <= 0) idealMeters = 1;
double best = 1;
double bestErr = double.MaxValue;
var logIdeal = Math.Log10(idealMeters);
for (var k = -3; k <= 9; k++)
{
foreach (var m in new[] { 1.0, 2.0, 5.0 })
{
var cand = m * Math.Pow(10, k);
var err = Math.Abs(Math.Log10(cand) - logIdeal);
if (err < bestErr) { bestErr = err; best = cand; }
}
}
var divPx = best * 100.0 / n * pxPerCm;
// 极端情况下(换挡后仍过长/过短)把格数收敛一下,保证总长在合理区间
var count = 5;
var total = divPx * count;
if (total > targetPx * 9) count = 4;
else if (total < targetPx * 2.5) count = 6;
return new SegmentScale { MetersPerDiv = best, DivPx = divPx, DivCount = count };
}
/// <summary>线段式每格的标注文字(不带 i18n,纯数值+单位)。</summary>
public static string SegmentLabel(double meters)
{
if (meters < 1) return Num(meters * 100) + " cm";
if (meters < 1000) return Num(meters) + " m";
return Num(meters / 1000) + " km";
}
public static ScaleGrade Grade(double n)
{
if (n <= 100000) return ScaleGrade.Large;
if (n <= 1000000) return ScaleGrade.Medium;
return ScaleGrade.Small;
}
public static string GradeKey(double n) => Grade(n) switch
{
ScaleGrade.Large => "grade.large",
ScaleGrade.Medium => "grade.medium",
_ => "grade.small"
};
/// <summary>光谱上 0..1 的位置(对数刻度,1:1千 ~ 1:10亿)。</summary>
public static double SpectrumPosition(double n)
{
if (n < 1) n = 1;
var p = (Math.Log10(n) - 3.0) / 6.0;
return p < 0 ? 0 : p > 1 ? 1 : p;
}
/// <summary>把用户输入的"数值+单位"解析成厘米。</summary>
public static bool TryParseReal(string text, string unitKey, out double cm)
{
cm = 0;
if (!double.TryParse(text.Replace(",", "").Trim(), NumberStyles.Float,
CultureInfo.InvariantCulture, out var v) || v < 0 || double.IsNaN(v) || double.IsInfinity(v))
return false;
cm = unitKey switch
{
"unit.m" => v * CmPerM,
"unit.km" => v * CmPerKm,
_ => v * 1.0
};
return true;
}
/// <summary>由厘米得到该单位下的数值(用于输入框显示)。</summary>
public static double ToUnit(double cm, string unitKey) => unitKey switch
{
"unit.m" => cm / CmPerM,
"unit.km" => cm / CmPerKm,
_ => cm
};
// ------------------------------------------------------------------ 练习
public static QuizItem GenerateQuiz(Random rnd)
{
var mode = (SolveMode)rnd.Next(0, 3);
// 用整齐的数,方便心算
var mapCm = new[] { 1.0, 2.0, 2.5, 3.0, 4.0, 5.0, 6.0, 8.0, 10.0, 12.0 }[rnd.Next(0, 10)];
var ns = new[] { 1000.0, 5000.0, 10000.0, 25000.0, 50000.0, 100000.0, 500000.0, 1000000.0, 5000000.0, 10000000.0 };
var n = ns[rnd.Next(0, ns.Length)];
switch (mode)
{
case SolveMode.Real:
{
var realCm = mapCm * n;
var (v, key) = HumanReal(realCm);
return new QuizItem
{
Mode = SolveMode.Real,
PromptKey = "quiz.promptReal",
PromptArgs = new object[] { FormatN(n), Num(mapCm) },
Answer = v,
AnswerUnitKey = key,
StepKeys = new[] { "steps.2.formulaReal", "steps.4.result" }
};
}
case SolveMode.Map:
{
// 让实地距离是整齐数字,反推图上距离也是整齐数字
var realCm = mapCm * n;
var (v, key) = HumanReal(realCm);
return new QuizItem
{
Mode = SolveMode.Map,
PromptKey = "quiz.promptMap",
PromptArgs = new object[] { FormatN(n), Num(v) },
Answer = mapCm,
AnswerUnitKey = "unit.cm",
StepKeys = new[] { "steps.2.formulaMap", "steps.4.result" }
};
}
default:
{
var realCm = mapCm * n;
var (v, key) = HumanReal(realCm);
return new QuizItem
{
Mode = SolveMode.Scale,
PromptKey = "quiz.promptScale",
PromptArgs = new object[] { Num(mapCm), Num(v) },
Answer = n,
AnswerUnitKey = "unit.none",
StepKeys = new[] { "steps.1.unify", "steps.2.formulaScale", "steps.4.result" }
};
}
}
}
public static bool CheckAnswer(QuizItem q, double input)
{
if (q.Answer <= 0) return false;
return Math.Abs(input - q.Answer) / q.Answer <= q.Tolerance;
}
}
-347
View File
@@ -1,347 +0,0 @@
using System;
using System.Globalization;
using Avalonia;
using Avalonia.Controls;
using Avalonia.Media;
namespace GC.ScaleCalculator;
/// <summary>
/// 自绘可视化标尺:上条「图上距离」按真实厘米画,下条「实地距离」按同一比例尺压缩,
/// 再画线段式比例尺(自动换挡)与比例尺光谱。全部在 Render 里完成,不产生子控件。
/// </summary>
public sealed class ScaleRuler : Control
{
// 与启动器 AppTheme 保持一致的调色(模型 dll 独立加载,取不到 DynamicResource 时也能显示)
private static readonly Color CInk = Color.Parse("#111A2E");
private static readonly Color CInkDim = Color.Parse("#5B6A86");
private static readonly Color CInkFaint = Color.Parse("#8A97B1");
private static readonly Color CLine = Color.Parse("#E3E8F3");
private static readonly Color CLineStrong = Color.Parse("#D2DAEA");
private static readonly Color CAccent = Color.Parse("#2F6BFF");
private static readonly Color CAccentSoft = Color.Parse("#EAF1FF");
private static readonly Color CAccentDark = Color.Parse("#1F4FD0");
private static readonly Color CSuccess = Color.Parse("#1F9D6B");
private static readonly Color CWarn = Color.Parse("#D98613");
private static readonly Color CDanger = Color.Parse("#D64545");
private static readonly Color CSurfaceAlt = Color.Parse("#F7F9FE");
private static readonly Color CSurface = Color.Parse("#FFFFFF");
private static readonly Typeface Font = new("Noto Sans CJK SC, Microsoft YaHei, Arial");
/// <summary>1 厘米对应多少屏幕像素。</summary>
public double PxPerCm = 46;
/// <summary>能画下的最大宽度(超出即溢出提示)。</summary>
public double MaxBarWidth = 520;
public ScaleState State { get; set; } = new();
public ScaleData Data { get; set; } = new();
public Func<string, string> T { get; set; } = k => k;
/// <summary>线段式比例尺换挡结果(供界面读数)。</summary>
public SegmentScale Segment { get; private set; } = new() { MetersPerDiv = 1000, DivPx = 46 };
/// <summary>图上距离是否超出可画范围。</summary>
public bool MapOverflow { get; private set; }
/// <summary>实地条溢出(按当前比例尺,这段实地图上也画不下)。</summary>
public bool RealOverflow { get; private set; }
public void Refresh() => InvalidateVisual();
private static FormattedText MakeText(string text, double size, Color color, FontWeight? weight = null)
{
var ft = new FormattedText(text, CultureInfo.InvariantCulture, FlowDirection.LeftToRight,
new Typeface(Font.FontFamily, FontStyle.Normal, weight ?? FontWeight.Normal), size,
new SolidColorBrush(color));
return ft;
}
private static void Text(DrawingContext dc, string s, double x, double y, double size, Color color,
FontWeight? weight = null, TextAlignment align = TextAlignment.Left)
{
var ft = MakeText(s, size, color, weight);
ft.TextAlignment = align;
dc.DrawText(ft, new Point(align == TextAlignment.Center ? x - ft.Width / 2 : x, y));
}
private static void RoundRect(DrawingContext dc, Rect r, double radius, IBrush fill, IPen? pen = null)
=> dc.DrawRectangle(fill, pen, new RoundedRect(r, radius));
private static void Dot(DrawingContext dc, double x, double y, double r, IBrush fill)
=> dc.DrawEllipse(fill, null, new Point(x, y), r, r);
public override void Render(DrawingContext dc)
{
base.Render(dc);
var w = Bounds.Width;
var h = Bounds.Height;
if (w < 40 || h < 40) return;
// 背景
dc.FillRectangle(new SolidColorBrush(CSurface), new Rect(0, 0, w, h));
var padL = 34.0;
var padR = 30.0;
var barW = Math.Max(60, w - padL - padR);
MaxBarWidth = barW;
var mapPx = ScaleMath.CmToPx(State.MapCm, PxPerCm);
var realPx = ScaleMath.RealToMapPx(State.RealCm, State.N, PxPerCm);
MapOverflow = mapPx > barW + 0.5;
RealOverflow = realPx > barW + 0.5;
// 线段式比例尺换挡,取"每格约 60px"
Segment = ScaleMath.PickSegment(State.N, PxPerCm, 62);
var y = 16.0;
// ── 标题
Text(dc, T("ruler.title"), padL, y, 13, CInk, FontWeight.SemiBold);
Text(dc, ScaleMath.Digital(State.N), w - padR, y + 1, 14, CAccentDark,
FontWeight.SemiBold, TextAlignment.Right);
y += 30;
// ═══════════════════════════════════════════ 1. 图上距离条
y = DrawMapBar(dc, padL, y, barW, mapPx);
y += 22;
// ═══════════════════════════════════════════ 2. 等式连接
DrawEquation(dc, padL, y, barW);
y += 30;
// ═══════════════════════════════════════════ 3. 实地距离条(压缩)
y = DrawRealBar(dc, padL, y, barW, realPx);
y += 24;
// ═══════════════════════════════════════════ 4. 线段式比例尺
y = DrawSegmentScale(dc, padL, y, barW);
y += 24;
// ═══════════════════════════════════════════ 5. 比例尺光谱
y = DrawSpectrum(dc, padL, y, barW);
y += 34;
// ═══════════════════════════════════════════ 6. 提示 / 溢出
DrawFooter(dc, padL, y, barW);
}
private double DrawMapBar(DrawingContext dc, double x, double y, double barW, double mapPx)
{
Text(dc, T("ruler.mapBar"), x, y, 11.5, CInkDim, FontWeight.SemiBold);
Text(dc, ScaleMath.Num(State.MapCm) + " " + T("unit.cm"), x + barW, y, 12.5, CAccent,
FontWeight.SemiBold, TextAlignment.Right);
y += 20;
var barH = 34.0;
var r = new Rect(x, y, barW, barH);
RoundRect(dc, r, 9, new SolidColorBrush(CSurfaceAlt), new Pen(new SolidColorBrush(CLine), 1));
// 底上的厘米刻度(每 1cm 一格,最多画 30 格)
var maxTicks = Math.Min(30, (int)(barW / PxPerCm) + 1);
for (var i = 1; i <= maxTicks; i++)
{
var tx = x + i * PxPerCm;
if (tx > x + barW - 2) break;
dc.DrawLine(new Pen(new SolidColorBrush(CLineStrong), 1),
new Point(tx, y + barH - 7), new Point(tx, y + barH));
if (i % 2 == 0)
Text(dc, i.ToString(CultureInfo.InvariantCulture), tx, y + barH + 2, 9.5, CInkFaint,
align: TextAlignment.Center);
}
// 实长(蓝色),超出则截断并染红
var drawW = Math.Min(mapPx, barW);
if (drawW > 0.5)
{
var fill = new LinearGradientBrush
{
StartPoint = new RelativePoint(0, 0, RelativeUnit.Relative),
EndPoint = new RelativePoint(1, 0, RelativeUnit.Relative),
GradientStops = new GradientStops
{
new(CAccentSoft, 0), new(CAccent, 1)
}
};
RoundRect(dc, new Rect(x + 1, y + 1, drawW - 2, barH - 2), 8, fill,
new Pen(new SolidColorBrush(MapOverflow ? CDanger : CAccentDark), 1.5));
}
// 端点
var endX = x + Math.Min(mapPx, barW);
Dot(dc, x + 2, y + barH / 2, 4, new SolidColorBrush(CSurface));
if (!MapOverflow)
{
Dot(dc, endX - 2, y + barH / 2, 5, new SolidColorBrush(CSurface));
Dot(dc, endX - 2, y + barH / 2, 3, new SolidColorBrush(CAccentDark));
// 长度标注
Text(dc, ScaleMath.Num(State.MapCm) + " " + T("unit.cm"),
endX - 4, y - 16, 11, CAccentDark, FontWeight.SemiBold, TextAlignment.Right);
}
else
{
Text(dc, "»", x + barW - 14, y + barH / 2 - 9, 16, CDanger, FontWeight.Bold);
}
return y + barH;
}
private void DrawEquation(DrawingContext dc, double x, double y, double barW)
{
var cx = x + barW / 2;
dc.DrawLine(new Pen(new SolidColorBrush(CLineStrong), 1, dashStyle: DashStyle.Dash),
new Point(x, y + 10), new Point(x + barW, y + 10));
var label = T("ruler.equals");
var ft = MakeText(label, 11, CInkDim, FontWeight.SemiBold);
var bw = ft.Width + 22;
RoundRect(dc, new Rect(cx - bw / 2, y, bw, 21), 10, new SolidColorBrush(CSurface),
new Pen(new SolidColorBrush(CLine), 1));
Text(dc, label, cx, y + 4, 11, CInkDim, FontWeight.SemiBold, TextAlignment.Center);
}
private double DrawRealBar(DrawingContext dc, double x, double y, double barW, double realPx)
{
var (rv, rkey) = ScaleMath.HumanReal(State.RealCm);
Text(dc, T("ruler.realBar"), x, y, 11.5, CInkDim, FontWeight.SemiBold);
Text(dc, ScaleMath.Num(rv) + " " + T(rkey), x + barW, y, 12.5, CSuccess,
FontWeight.SemiBold, TextAlignment.Right);
y += 20;
var barH = 30.0;
RoundRect(dc, new Rect(x, y, barW, barH), 9, new SolidColorBrush(CSurfaceAlt),
new Pen(new SolidColorBrush(CLine), 1));
// 用"按同一比例尺压缩后"的长度表现:与上图同宽才直观
var drawW = Math.Min(realPx, barW);
if (drawW > 0.5)
{
var fill = new LinearGradientBrush
{
StartPoint = new RelativePoint(0, 0, RelativeUnit.Relative),
EndPoint = new RelativePoint(1, 0, RelativeUnit.Relative),
GradientStops = new GradientStops { new(Color.Parse("#DFF5EA"), 0), new(CSuccess, 1) }
};
RoundRect(dc, new Rect(x + 1, y + 1, drawW - 2, barH - 2), 8, fill,
new Pen(new SolidColorBrush(RealOverflow ? CDanger : CSuccess), 1.5));
}
// 画上"实地"的等分虚线,表达这段距离很长
for (var i = 1; i < 6; i++)
{
var tx = x + barW * i / 6.0;
dc.DrawLine(new Pen(new SolidColorBrush(Color.Parse("#80FFFFFF")), 1, dashStyle: DashStyle.Dash),
new Point(tx, y + 5), new Point(tx, y + barH - 5));
}
if (!RealOverflow)
{
Dot(dc, x + drawW - 2, y + barH / 2, 4, new SolidColorBrush(CSurface));
}
else
{
Text(dc, "»", x + barW - 14, y + barH / 2 - 9, 16, CDanger, FontWeight.Bold);
}
// 中间写"= 图上这段"
Text(dc, T("ruler.sameWidth"), x + barW / 2, y + barH / 2 - 7, 10.5, CInkDim,
align: TextAlignment.Center);
return y + barH;
}
private double DrawSegmentScale(DrawingContext dc, double x, double y, double barW)
{
Text(dc, T("ruler.segment"), x, y, 11.5, CInkDim, FontWeight.SemiBold);
Text(dc, T("ruler.segmentHint"), x + barW, y + 1, 10, CInkFaint, align: TextAlignment.Right);
y += 20;
var seg = Segment;
var total = seg.DivPx * seg.DivCount;
if (total > barW)
{
// 再降一档,避免画不下
seg = ScaleMath.PickSegment(State.N * 3, PxPerCm, 62);
Segment = seg;
total = seg.DivPx * seg.DivCount;
}
var sx = x + Math.Max(0, (barW - total) / 2);
var sy = y;
var segH = 13.0;
for (var i = 0; i < seg.DivCount; i++)
{
var r = new Rect(sx + i * seg.DivPx, sy, seg.DivPx, segH);
dc.FillRectangle(new SolidColorBrush(i % 2 == 0 ? CInk : CSurface), r);
dc.DrawRectangle(null, new Pen(new SolidColorBrush(CInk), 1), r);
Text(dc, i == 0 ? "0" : ScaleMath.SegmentLabel(seg.MetersPerDiv * i),
sx + (i + 1) * seg.DivPx, sy + segH + 3, 9.5, CInkDim, align: TextAlignment.Center);
}
Text(dc, ScaleMath.SegmentLabel(seg.MetersPerDiv), sx + total / 2, sy + segH + 17, 10,
CInkDim, FontWeight.SemiBold, TextAlignment.Center);
return sy + segH + 32;
}
private double DrawSpectrum(DrawingContext dc, double x, double y, double barW)
{
Text(dc, T("ruler.spectrum"), x, y, 11.5, CInkDim, FontWeight.SemiBold);
y += 20;
var trackY = y + 6;
var trackH = 8.0;
var grad = new LinearGradientBrush
{
StartPoint = new RelativePoint(0, 0, RelativeUnit.Relative),
EndPoint = new RelativePoint(1, 0, RelativeUnit.Relative),
GradientStops = new GradientStops
{
new(CAccent, 0), new(Color.Parse("#5B8DEF"), 0.4),
new(Color.Parse("#8FB4F5"), 0.7), new(Color.Parse("#C9DAF8"), 1)
}
};
RoundRect(dc, new Rect(x, trackY, barW, trackH), 4, grad);
// 光谱层级刻度
foreach (var item in Data.Spectrum)
{
var p = ScaleMath.SpectrumPosition(item.N);
var px = x + barW * p;
dc.DrawLine(new Pen(new SolidColorBrush(CSurface), 1.5),
new Point(px, trackY), new Point(px, trackY + trackH));
Text(dc, T(item.LabelKey), px, trackY + trackH + 3, 9.5, CInkFaint,
align: TextAlignment.Center);
}
// 当前值指针
var pos = ScaleMath.SpectrumPosition(State.N);
var cx = x + barW * pos;
dc.DrawLine(new Pen(new SolidColorBrush(CInk), 2),
new Point(cx, trackY - 7), new Point(cx, trackY + trackH + 5));
Dot(dc, cx, trackY - 9, 5, new SolidColorBrush(CAccent));
Dot(dc, cx, trackY - 9, 2.5, new SolidColorBrush(CSurface));
// 两端说明
Text(dc, T("ruler.scopeUp"), x, trackY + trackH + 20, 10, CInkFaint);
Text(dc, T("ruler.detailDown"), x + barW, trackY + trackH + 20, 10, CInkFaint,
align: TextAlignment.Right);
return trackY + trackH + 36;
}
private void DrawFooter(DrawingContext dc, double x, double y, double barW)
{
if (MapOverflow || RealOverflow)
{
var msg = T(MapOverflow ? "ruler.overflowMap" : "ruler.overflowReal");
var r = new Rect(x, y, barW, 30);
RoundRect(dc, r, 8, new SolidColorBrush(Color.Parse("#FDECEC")),
new Pen(new SolidColorBrush(Color.Parse("#F5C2C2")), 1));
Text(dc, "⚠ " + msg, x + 12, y + 7, 11, CDanger, FontWeight.SemiBold);
}
else
{
Text(dc, T("ruler.hint"), x, y + 4, 10.5, CInkFaint);
}
}
}