Celestia/Celx 脚本/CELX Lua 方法/CEL 命令 gotoloc

gotoloc

gotoloc { time <duration> position <vector> xrot <xrot> yrot <yrot> zrot <zrot> }

-- 或者 --

gotoloc { time <duration> x <xbase64> y <ybase64> z <zbase64> ow <ownumber> ox <oxnumber> oy <oynumber> oz <oznumber> }

将相机移动到当前选定的物体，花费<duration>秒，移动到指定的位置（或来自 Cell://URL 的 Base64 值 x、y 和 z），使用通过 xrot、yrot 和 zrot（或 ow、ox、oy 和 oz）指定的方位。

参数

time <duration>

将物体居中所需的时间（秒）。默认值为 1.0 秒。

position <vector>

在当前坐标系中定义一个点，以公里为单位。默认值为 [0 1 0]。
对于除通用坐标系之外的所有坐标系，position 为 [ 0 0 0 ] 是物体的中心。
您指定的公里值必须包含物体的半径。

• 第一个值 <xnumber> 表示相机位置，以公里为单位，沿着 X 轴。
• 第二个值 <ynumber> 表示相机位置，以公里为单位，沿着 Y 轴。
• 第三个值 <znumber> 表示相机位置，以公里为单位，沿着 Z 轴。

xrot <xrot>

相机方位，以度为单位的“欧拉角”或“角度-轴”表示。默认值为 0。
可以把它想象成航空中的俯仰。

yrot <yrot>

相机方位，以度为单位的“欧拉角”或“角度-轴”表示。默认值为 0。
可以把它想象成航空中的偏航。

zrot <zrot>

相机方位，以度为单位的“欧拉角”或“角度-轴”表示。默认值为 0。
可以把它想象成航空中的滚转。

-- 或者 --

参数

time <duration>

将物体居中所需的时间（秒）。没有默认值。

x <xbase64>

此值表示 CelURL 中存储的 X 位置。没有默认值。
该值可以从 CelURL 值之后获取：?x=

y <ybase64>

此值表示 CelURL 中存储的 Y 位置。没有默认值。
该值可以从 CelURL 值之后获取：&y=

z <zbase64>

此值表示 CelURL 中存储的 Z 位置。没有默认值。
该值可以从 CelURL 值之后获取：&z=

ow <ownumber>

此值表示 CelURL 中存储的 OW 方位。没有默认值。
该值可以从 CelURL 值之后获取：&ow=

ox <oxnumber>

此值表示 CelURL 中存储的 OW 方位。没有默认值。
该值可以从 CelURL 值之后获取：&ox=

oy <oynumber>

此值表示 CelURL 中存储的 OW 方位。没有默认值。
该值可以从 CelURL 值之后获取：&oy=

oz <oznumber>

此值表示 CelURL 中存储的 OW 方位。没有默认值。
该值可以从 CelURL 值之后获取：&oz=

CELX 等效-1

基于参数列表-1和observer:setorientation()和observer:gotolocation()方法。

注意：这种方法组合的缺点是这些方法的顺序执行，新的观察者方位是立即设置的，而不是在 goto 期间平滑地设置。

• 从 <xnumber>、<ynumber> 和 <znumber> 创建新的位置对象，并存储在 "pos" 中。
  位置对象的组件单位是光年的百万分之一，因此您必须将 km 转换为光年的百万分之一，使用 "uly_to_km" 常量。

uly_to_km = 9460730.4725808
pos = celestia:newposition( <xnumber>/uly_to_km, <ynumber>/uly_to_km, <znumber>/uly_to_km )

• 指定并创建此旋转的轴 [<xrot> , <yrot> , <zrot> ]，并将其存储在 "vec" 中。
  <xrot> 、<yrot> 和 <zrot> 是相机方位的“欧拉角”或“角度-轴”表示，以度为单位。
  可以把它想象成航空中的俯仰、偏航和滚转。

vec = celestia:newvector( <xrot> , <yrot> , <zrot> )

• 创建绕指定轴的新旋转（即四元数），并将其存储在 "rot" 中。
  "angle" = math.pi / 180 (= 3.14159265 / 180)，用于从度数获得弧度。

angle = math.pi/180
rot = celestia:newrotation(vec, angle)

• 获取活动视图实例的观察者实例，并根据创建的新旋转 "rot" 旋转观察者。

obs = celestia:getobserver()
obs:setorientation(rot)

• 在 <duration> 秒内移动到目标位置 "pos"。

obs:gotolocation(pos, <duration> )

• 等待 <duration> 秒。

wait( <duration> )

总结

uly_to_km = 9460730.4725808
pos = celestia:newposition( <xnumber>/uly_to_km, <ynumber>/uly_to_km, <znumber>/uly_to_km )
vec = celestia:newvector( <xrot> , <yrot> , <zrot> )
angle = math.pi/180
rot = celestia:newrotation(vec, angle)
obs = celestia:getobserver()
obs:setorientation(rot)
obs:gotolocation(pos, <duration> )
wait( <duration> )

CELX 等效-2

基于参数列表-2和observer:setorientation()和observer:gotolocation()方法。

注意：这种方法组合的缺点是这些方法的顺序执行，新的观察者方位是立即设置的，而不是在 goto 期间平滑地设置。

• 从 URL 样式的 Base64 编码值创建新的位置对象，并将其存储在 "pos" 中。
  <xbase64>: 新向量的 X 分量，作为从 cel 样式 URL ?x= 获取的字符串值。
  <ybase64>: 新向量的 Y 分量，作为从 cel 样式 URL &y= 获取的字符串值。
  <zbase64>: 新向量的 Z 分量，作为从 cel 样式 URL &z= 获取的字符串值。

pos = celestia:newposition( <xbase64>, <ybase64>, <zbase64> )

• 从四个标量值（CEL://URL 中使用的值）创建新的旋转（即四元数），并将其存储在 "rot" 中。
  <ownumber>: 新旋转的 OW 分量，作为从 cel 样式 URL &ow= 获取的数字值。
  <oxnumber>: 新旋转的 OX 分量，作为从 cel 样式 URL &ox= 获取的数字值。
  <oynumber>: 新旋转的 OY 分量，作为从 cel 样式 URL &oy= 获取的数字值。
  <oznumber>: 新旋转的 OZ 分量，作为从 cel 样式 URL &oz= 获取的数字值。

rot = celestia:newrotation( <ownumber>, <oxnumber>, <oynumber>, <oznumber> )

• 获取活动视图的观察者实例，并根据创建的新旋转 "rot" 旋转观察者。

obs = celestia:getobserver()
obs:setorientation(rot)

• 在 <duration> 秒内移动到目标位置 “pos”。

obs:gotolocation(pos, <duration> )

• 等待 <duration> 秒。

wait( <duration> )

总结

pos = celestia:newposition( <xbase64>, <ybase64>, <zbase64> )
rot = celestia:newrotation( <ownumber>, <oxnumber>, <oynumber>, <oznumber> )
obs = celestia:getobserver()
obs:setorientation(rot)
obs:gotolocation(pos, <duration> )
wait( <duration> )

CELX 等效-3

基于observer:goto(table)方法。

使用此方法，可以执行许多不同类型的 goto。此方法的优势是可以对观察者方位进行编程和插值，因此可以在 goto 期间改变观察者的方位。

此方法使用位置对象进行 goto，并使用旋转对象设置观察者方位。位置和旋转都可以从参数列表-1和参数列表-2参数中提取。goto 的参数必须在表中给出

• • parameters.duration: 持续时间（数字）
  • parameters.from: 源位置
  • parameters.to: 目标位置
  • parameters.initialOrientation: 源方位
  • parameters.finalOrientation: 目标方位
  • parameters.startInterpolation
  • parameters.endInterpolation
  • parameters.accelTime

• 获取活动视图的观察者实例，并将其存储在 "obs" 中。

obs = celestia:getobserver()

• 定义并初始化参数表如下
  • 确定 goto 应该花费的时间（秒）。
  • 获取观察者的当前位置。
  • 创建新的位置对象。关于最初使用的 CEL 参数列表，有两种可能性
    • 从 <xnumber>、<ynumber> 和 <znumber> 创建，并将其存储在 "parameters.to" 中。位置对象的组件单位是光年的百万分之一，因此您必须将 km 转换为光年的百万分之一，使用 “uly_to_km”。
      注意：给定的位置预计是相对于通用参考系，而非基于表的 goto 使用相对于当前参考系的位置。因此，根据使用的参考系，您必须先将位置转换为通用！
    • 从 URL 样式的 Base64 编码值创建，并将其存储在 "parameters.to" 中
      <xbase64>: 新向量的 X 分量，作为从 cel 样式 URL ?x= 获取的字符串值。
      <ybase64>: 新向量的 Y 分量，作为从 cel 样式 URL &y= 获取的字符串值。
      <zbase64>: 新向量的 Z 分量，作为从 cel 样式 URL &z= 获取的字符串值。
  • 获取观察者的当前方位。
  • 创建新的旋转对象。关于最初使用的 CEL 参数列表，有两种可能性
    • 指定并创建观察者旋转的轴 [<xrot> , <yrot> , <zrot> ]，并将其存储在 "vec" 中。<xrot> 、<yrot> 和 <zrot> 是观察者方位的“欧拉角”或“角度-轴”表示，以度为单位。可以把它想象成航空中的俯仰、偏航和滚转。然后创建绕指定轴的新旋转（即四元数），并使用 "angle" = math.pi/180 (= 3.14159265 / 180)，从度数获得弧度。将此新的旋转存储在 "parameters.finalOrientation" 中。
    • 从四个标量值（CEL://URL 中使用的值）创建，并将其存储在 "parameters.finalOrientation" 中。
      <ownumber>: 新旋转的 OW 分量，作为从 cel 样式 URL &ow= 获取的数字值。
      <oxnumber>: 新旋转的 OX 分量，作为从 cel 样式 URL &ox= 获取的数字值。
      <oynumber>: 新旋转的 OY 分量，作为从 cel 样式 URL &oy= 获取的数字值。
      <oznumber>: 新旋转的 OZ 分量，作为从 cel 样式 URL &oz= 获取的数字值。
  • 在 goto 的 20% 时间之后开始调整观察者方位。
  • 在 goto 的 80% 时间之后结束调整观察者方位。
  • 花费 10% 的时间进行加速和减速

parameters={}
parameters.duration = <duration>
parameters.from = obs:getposition()
uly_to_km = 9460730.4725808
parameters.to = celestia:newposition( <xnumber>/uly_to_km, <ynumber>/uly_to_km, <znumber>/uly_to_km )
parameters.initialOrientation = obs:getorientation()
vec = celestia:newvector( <xrot> , <yrot> , <zrot> )
angle = math.pi/180
parameters.finalOrientation = celestia:newrotation(vec, angle)
parameters.startInterpolation = 0.2
parameters.endInterpolation = 0.8
parameters. accelTime = 0.1

-- 或者 --

parameters={}
parameters.duration = <duration>
parameters.from = obs:getposition()
parameters.to = celestia:newposition( <xbase64>, <ybase64>, <zbase64> )
parameters.initialOrientation = obs:getorientation()
parameters.finalOrientation = celestia:newrotation( <ownumber>, <oxnumber>, <oynumber>, <oznumber> )
parameters.startInterpolation = 0.2
parameters.endInterpolation = 0.8
parameters. accelTime = 0.1

• 在 <duration> 秒内以目标方位移动到目标位置。

obs:goto(parameters)

• 等待 <duration> 秒。

wait(parameters.duration)

总结

-- Use the following block of code for target positions
-- relative to the universal frame-of-reference:
obs = celestia:getobserver()
parameters={}
parameters.duration = <duration>
parameters.from = obs:getposition()
uly_to_km = 9460730.4725808
parameters.to = celestia:newposition( <xnumber>/uly_to_km, <ynumber>/uly_to_km, <znumber>/uly_to_km )
parameters.initialOrientation = obs:getorientation()
vec = celestia:newvector( <xrot> , <yrot> , <zrot> )
angle = math.pi/180
parameters.finalOrientation = celestia:newrotation(vec, angle)
parameters.startInterpolation = 0.2
parameters.endInterpolation = 0.8
parameters.accelTime = 0.1
obs:goto(parameters)
wait(parameters.duration)

-- 或者 --

–- Use the following block of code for target positions
-- relative to the ecliptic (follow) frame of reference,
-- with "objectname" as reference object.
obs = celestia:getobserver()
objectname = celestia:find( <string> )
obs:follow(objectname)
parameters={}
parameters.duration = <duration>
parameters.from = obs:getposition()
uly_to_km = 9460730.4725808
vector = celestia:newvector( <xnumber>/uly_to_km, <ynumber>/uly_to_km, <znumber>/ uly_to_km )
objectpos = objectname:getposition()
parameters.to = objectpos + vector
parameters.initialOrientation = obs:getorientation()
vec = celestia:newvector( <xrot> , <yrot> , <zrot> )
angle = math.pi/180
parameters.finalOrientation = celestia:newrotation(vec, angle)
parameters.startInterpolation = 0.2
parameters.endInterpolation = 0.8
parameters.accelTime = 0.1
obs:goto(parameters)
wait(parameters.duration)

-- 或者 --

obs = celestia:getobserver()
parameters={}
parameters.duration = <duration>
parameters.from = obs:getposition()
parameters.to = celestia:newposition( <xbase64>, <ybase64>, <zbase64> )
parameters.initialOrientation = obs:getorientation()
parameters.finalOrientation = celestia:newrotation( <ownumber>, <oxnumber>,  <oynumber>, <oznumber> )
parameters.startInterpolation = 0.2
parameters.endInterpolation = 0.8
parameters.accelTime = 0.1
obs:goto(parameters)
wait(parameters.duration)

示例
以下示例演示了两种gotoloc方法。它移动到地球，设置一个位置，这样您就可以看到美国上空的灯光，在显示器的左上角看到太阳，在右上角看到月亮。

注意： 以“#” (CEL) 和 “--” (CELX) 开头的代码行是用于进一步解释的注释行

注意： 此示例中的 CelURL 值与 Celestia 版本 1.6.0 兼容。

CEL

# Pause time and set the date and time to 2003 Aug 23 04:37:24 UTC
  timerate  { rate 0 }
  time      { jd 2452874.692638889 }
# Activate markers, clear all existing markers and
# place a blue square marker around the Moon...
  renderflags { set "markers" }
  unmarkall { }
  mark      { object "Sol/Earth/Moon" size 20.0 color [0 0 1] symbol "square" }
# Set the Field Of View value to 47.0 degrees...
  set       { name "FOV" value 47.0 }
# Select, follow and center Earth (so the coordinate system
# of the frame of reference is set to ecliptic).
  select    { object "Sol/Earth" }
  follow    { }
  center    { }
  wait      { duration 1 }
# Goto location: X = +7000km, Y = +9000km, Z = +11000km.
# Pitch Up +13 degrees (down = -), Yaw Left -32 degrees (right = +),
# Roll 0 degrees (left = - , right = +)
  gotoloc   { time 5 position [7000 9000 11000] xrot 13 yrot -32 zrot 0 }
  wait      { duration 5 }
  print     { text "Blue square is the Moon ---" duration 4 row -24 column 32 }
  wait      { duration 6 }
  print { text "First result done." duration 3 row -3 column 2 }
  wait { duration 3 }
  cancel { }
# Goto location using URL-style Base64-encoded values.
  gotoloc { time 5 x "AAAAbtdBM3XLDA" y "aG/b0Q34Pw" z "AABiyVOKuxUI"
            ow 0.703773 ox 0.068516 oy -0.703786 oz 0.068514 }
  wait { duration 5 }
  print { text "Second result done." duration 4  row -3 column 2 }
  wait { duration 4 }

CELX-1 使用 observer:gotolocation() 方法

-- Pause time and set the date and time to 2003 Aug 23 04:37:24 UTC.
-- First convert UTC to TDB date/time:
--    UTC is used in the Celestia's Set Time dialog and it's also
--    the time displayed in the upper right of the screen.
--    TDB = Barycentric Dynamical Time.
--    When using scripts for Celestia, the time scale is TDB !!!
celestia:settimescale(0)
dt=celestia:utctotdb(2003, 08, 23, 04, 37, 24)
celestia:settime(dt)
-- Activate markers, clear all existing markers and
-- place a blue square marker around the Moon...
celestia:setrenderflags{markers=true}
celestia:unmarkall()
moon = celestia:find("Sol/Earth/Moon")
moon:mark("blue", "square", 20.0)
-- Set the Field Of View value to 47.0 degrees.
-- In CELX, angles are stored in radians, instead of degrees, so you have to convert
-- degrees to radians by multiplying degrees with math.pi (= 3.14159265) and divide
-- by 180. The LUA "math.rad()" function can also be used for this.
obs = celestia:getobserver()
obs:setfov(47*math.pi/180)
-- Select, follow and center Earth (so the coordinate system
-- of the frame of reference is set to ecliptic).
earth = celestia:find("Sol/Earth")
celestia:select(earth)
obs:follow(earth)
obs:center(earth, 1.0)
wait(1.0)
-- Goto location: X = +7000km, Y = +9000km, Z = +11000km.
-- Pitch Up +13 degrees (down = -),
-- Yaw Left -32 degrees (right = +),
-- Roll 0 degrees (left = - , right = +)
obs = celestia:getobserver()
-- In CELX, angles are stored in radians, instead of degrees, so you have to convert
-- degrees to radians by multiplying degrees with math.pi (= 3.14159265) and divide
-- by 180. The LUA "math.rad()" function can also be used for this.
vec = celestia:newvector(13, -32, 0)
angle = math.pi/180
-- Set the observer orientation:
rot = celestia:newrotation(vec, angle)
obs:setorientation(rot)
-- In CELX, positions are stored in millionths of a light year,
-- so you have to convert km to millionths of a light year, using "uly_to_km".
uly_to_km = 9460730.4725808
pos = celestia:newposition(7000/uly_to_km, 9000/uly_to_km, 11000/uly_to_km)
-- Goto target position.
obs:gotolocation(pos, 5.0 )
wait(5.0)
celestia:print("Blue square is the Moon ---" , 4.0, -1, -1, 32, 24)
wait(6.0)
celestia:print("First result done.", 3.0, -1, -1, 2, 3)
wait(3.0)
-- Cancel GOTO and TRACK commands, and reset the Coordinate System to universal.
obs:cancelgoto()
obs:track(nil)
obs:setframe(celestia:newframe("universal"))
-- Goto target position, using URL-style Base64-encoded values.
obs = celestia:getobserver()
rot = celestia:newrotation(0.703773, 0.068516, -0.703786, 0.068514)
obs:setorientation(rot)
pos = celestia:newposition("AAAAbtdBM3XLDA", "aG/b0Q34Pw", "AABiyVOKuxUI")
obs:gotolocation(pos, 5.0 )
wait(5.0)
celestia:print("Second result done.", 4.0, -1, -1, 2, 3)
wait(4.0)

CELX-2 使用 observer:goto(table) 方法

-- Pause time and set the date and time to 2003 Aug 23 04:37:24 UTC.
-- First convert UTC to TDB date/time:
--    UTC is used in the Celestia's Set Time dialog and it's also
--    the time displayed in the upper right of the screen.
--    TDB = Barycentric Dynamical Time.
--    When using scripts for Celestia, the time scale is TDB !!!
celestia:settimescale(0)
dt=celestia:utctotdb(2003, 08, 23, 04, 37, 24)
celestia:settime(dt)
-- Activate markers, clear all existing markers and
-- place a blue square marker around the Moon...
celestia:setrenderflags{markers=true}
celestia:unmarkall()
moon = celestia:find("Sol/Earth/Moon")
moon:mark("blue", "square", 20.0)
-- Set the Field Of View value to 47.0 degrees.
-- In CELX, angles are stored in radians, instead of degrees, so you have to convert
-- degrees to radians by multiplying degrees with math.pi (= 3.14159265) and divide
-- by 180. The LUA "math.rad()" function can also be used for this.
obs = celestia:getobserver()
obs:setfov(47*math.pi/180)
-- Select, follow and center Earth (so the coordinate system
-- of the frame of reference is set to ecliptic).
earth = celestia:find("Sol/Earth")
celestia:select(earth)
obs:follow(earth)
obs:center(earth, 1.0)
wait(1.0)
-- Goto location: X = +7000km, Y = +9000km, Z = +11000km, relative to Earth !!!!
-- Pitch Up +13 degrees (down = -),
-- Yaw Left -32 degrees (right = +),
-- Roll 0 degrees (left = - , right = +)
obs = celestia:getobserver()
parameters={}
parameters.duration = 5.0
parameters.from = obs:getposition()
-- In CELX, positions are stored in millionths of a light year,
-- so you have to convert km to millionths of a light year, using "uly_to_km".
uly_to_km = 9460730.4725808
vec = celestia:newvector(7000/uly_to_km, 9000/uly_to_km, 11000/uly_to_km)
earthpos = earth:getposition()
parameters.to = earthpos + vec
parameters.initialOrientation = obs:getorientation()
-- In CELX, angles are stored in radians, instead of degrees, so you have to convert
-- degrees to radians by multiplying degrees with math.pi (= 3.14159265) and divide
-- by 180. The LUA "math.rad()" function can also be used for this.
vec = celestia:newvector(13, -32, 0)
angle = math.pi/180
-- Set the observer orientation:
parameters.finalOrientation = celestia:newrotation(vec, angle)
parameters.startInterpolation = 0.2
parameters.endInterpolation = 0.8
parameters.accelTime = 0.1
-- Goto target position.
obs:goto(parameters)
wait(parameters.duration)
celestia:print("Blue square is the Moon ---" , 4.0, -1, -1, 32, 24)
wait(6.0)
celestia:print("First result done.", 3.0, -1, -1, 2, 3)
wait(3.0)
-- Cancel GOTO and TRACK commands, and reset the Coordinate System to universal.
obs:cancelgoto()
obs:track(nil)
obs:setframe(celestia:newframe("universal"))
-- Goto target position, using URL-style Base64-encoded values.
parameters={}
parameters.duration = 5.0
parameters.from = obs:getposition()
parameters.to = celestia:newposition("AAAAbtdBM3XLDA", "aG/b0Q34Pw", "AABiyVOKuxUI")
parameters.initialOrientation = obs:getorientation()
parameters.finalOrientation = celestia:newrotation(0.703773, 0.068516, -0.703786, 0.068514)
parameters.startInterpolation = 0.2
parameters.endInterpolation = 0.8
parameters.accelTime = 0.1
-- Goto target position.
obs:goto(parameters)
wait(parameters.duration)
celestia:print("Second result done.", 4.0, -1, -1, 2, 3)
wait(4.0)

返回 CEL 命令索引