开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > OpenGL > 查看源码
axisarrow.cpp
资源名称：celestia-1.6.0.tar.gz　[点击查看]
上传用户：center1979
上传日期：2022-07-26
资源大小：50633k
文件大小：14k
源码类别：

OpenGL

开发平台：

Visual C++

axisarrow.cpp：源码内容
  1. // axisarrow.cpp
  2. //
  3. // Copyright (C) 2007, Celestia Development Team
  4. //
  5. // This program is free software; you can redistribute it and/or
  6. // modify it under the terms of the GNU General Public License
  7. // as published by the Free Software Foundation; either version 2
  8. // of the License, or (at your option) any later version.
  10. #include <algorithm>
  11. #include <celmath/mathlib.h>
  12. #include "gl.h"
  13. #include "vecgl.h"
  14. #include "axisarrow.h"
  15. #include "selection.h"
  16. #include "frame.h"
  17. #include "body.h"
  18. #include "timelinephase.h"
  20. using namespace std;
  22. static const unsigned int MaxArrowSections = 100;
  24. static void RenderArrow(float shaftLength,
  25.                         float headLength,
  26.                         float shaftRadius,
  27.                         float headRadius,
  28.                         unsigned int nSections)
  29. {
  30.     float sintab[MaxArrowSections];
  31.     float costab[MaxArrowSections];
  33.     unsigned int i;
  35.     nSections = min(MaxArrowSections, nSections);
  37.     // Initialize the trig tables
  38.     for (i = 0; i < nSections; i++)
  39.     {
  40.         double theta = (i * 2.0 * PI) / nSections;
  41.         sintab[i] = (float) sin(theta);
  42.         costab[i] = (float) cos(theta);
  43.     }
  45.     // Render the circle at the botton of the arrow shaft
  46.     glBegin(GL_TRIANGLE_FAN);
  47.     glVertex3f(0.0f, 0.0f, 0.0f);
  48.     for (i = 0; i <= nSections; i++)
  49.     {
  50.         unsigned int n = (nSections - i) % nSections;
  51.         glVertex3f(shaftRadius * costab[n], shaftRadius * sintab[n], 0.0f);
  52.     }
  53.     glEnd();
  55.     // Render the arrow shaft
  56.     glBegin(GL_QUAD_STRIP);
  57.     for (i = 0; i <= nSections; i++)
  58.     {
  59.         unsigned int n = i % nSections;
  60.         glVertex3f(shaftRadius * costab[n], shaftRadius * sintab[n], shaftLength);
  61.         glVertex3f(shaftRadius * costab[n], shaftRadius * sintab[n], 0.0f);
  62.     }
  63.     glEnd();
  65.     // Render the annulus
  66.     glBegin(GL_QUAD_STRIP);
  67.     for (i = 0; i <= nSections; i++)
  68.     {
  69.         unsigned int n = i % nSections;
  70.         glVertex3f(headRadius * costab[n],  headRadius * sintab[n], shaftLength);
  71.         glVertex3f(shaftRadius * costab[n], shaftRadius * sintab[n], shaftLength);
  72.     }
  73.     glEnd();
  75.     // Render the head of the arrow
  76.     glBegin(GL_TRIANGLE_FAN);
  77.     glVertex3f(0.0f, 0.0f, shaftLength + headLength);
  78.     for (i = 0; i <= nSections; i++)
  79.     {
  80.         unsigned int n = i % nSections;
  81.         glVertex3f(headRadius * costab[n], headRadius * sintab[n], shaftLength);
  82.     }
  83.     glEnd();
  84. }
  87. // Draw letter x in xz plane
  88. static void RenderX()
  89. {
  90.     glBegin(GL_LINES);
  91.     glVertex3f(0, 0, 0);
  92.     glVertex3f(1, 0, 1);
  93.     glVertex3f(1, 0, 0);
  94.     glVertex3f(0, 0, 1);
  95.     glEnd();
  96. }
  99. // Draw letter y in xz plane
  100. static void RenderY()
  101. {
  102.     glBegin(GL_LINES);
  103.     glVertex3f(0, 0, 1);
  104.     glVertex3f(0.5f, 0, 0.5f);
  105.     glVertex3f(1, 0, 1);
  106.     glVertex3f(0.5f, 0, 0.5f);
  107.     glVertex3f(0.5f, 0, 0);
  108.     glVertex3f(0.5f, 0, 0.5f);
  109.     glEnd();
  110. }
  113. // Draw letter z in xz plane
  114. static void RenderZ()
  115. {
  116.     glBegin(GL_LINE_STRIP);
  117.     glVertex3f(0, 0, 1);
  118.     glVertex3f(1, 0, 1);
  119.     glVertex3f(0, 0, 0);
  120.     glVertex3f(1, 0, 0);
  121.     glEnd();
  122. }
  125. #if 0
  126. void RenderAxisArrows(const Quatf& orientation, float scale, float opacity)
  127. {
  128.     glPushMatrix();
  129.     glRotate(orientation);
  130.     glScalef(scale, scale, scale);
  132.     glDisable(GL_LIGHTING);
  134. #if 0
  135.     // Simple line axes
  136.     glBegin(GL_LINES);
  138.     glColor4f(1.0f, 0.0f, 0.0f, 1.0f);
  139.     glVertex3f(0.0f, 0.0f, 0.0f);
  140.     glVertex3f(-1.0f, 0.0f, 0.0f);
  142.     glColor4f(0.0f, 1.0f, 0.0f, 1.0f);
  143.     glVertex3f(0.0f, 0.0f, 0.0f);
  144.     glVertex3f(0.0f, 0.0f, 1.0f);
  146.     glColor4f(0.0f, 0.0f, 1.0f, 1.0f);
  147.     glVertex3f(0.0f, 0.0f, 0.0f);
  148.     glVertex3f(0.0f, 1.0f, 0.0f);
  150.     glEnd();
  151. #endif
  153.     float shaftLength = 0.85f;
  154.     float headLength = 0.10f;
  155.     float shaftRadius = 0.010f;
  156.     float headRadius = 0.025f;
  157.     unsigned int nSections = 30;
  158.     float labelScale = 0.1f;
  160.     // x-axis
  161.     glPushMatrix();
  162.     glRotatef(90.0f, 0.0f, 1.0f, 0.0f);
  163.     glColor4f(1.0f, 0.0f, 0.0f, opacity);
  164.     RenderArrow(shaftLength, headLength, shaftRadius, headRadius, nSections);
  165.     glTranslatef(0.1f, 0.0f, 0.75f);
  166.     glScalef(labelScale, labelScale, labelScale);
  167.     RenderX();
  168.     glPopMatrix();
  170.     // y-axis
  171.     glPushMatrix();
  172.     glRotatef(180.0f, 0.0f, 1.0f, 0.0f);
  173.     glColor4f(0.0f, 1.0f, 0.0f, opacity);
  174.     RenderArrow(shaftLength, headLength, shaftRadius, headRadius, nSections);
  175.     glTranslatef(0.1f, 0.0f, 0.75f);
  176.     glScalef(labelScale, labelScale, labelScale);
  177.     RenderY();
  178.     glPopMatrix();
  180.     // z-axis
  181.     glPushMatrix();
  182.     glRotatef(-90.0f, 1.0f, 0.0f, 0.0f);
  183.     glColor4f(0.0f, 0.0f, 1.0f, opacity);
  184.     RenderArrow(shaftLength, headLength, shaftRadius, headRadius, nSections);
  185.     glTranslatef(0.1f, 0.0f, 0.75f);
  186.     glScalef(labelScale, labelScale, labelScale);
  187.     RenderZ();
  188.     glPopMatrix();
  190.     glPopMatrix();
  191. }
  192. #endif
  195. void RenderSunDirectionArrow(const Vec3f& direction, float scale, float opacity)
  196. {
  197.     glPushMatrix();
  198.     glRotate(Quatf::vecToVecRotation(Vec3f(0.0f, 0.0f, 1.0f), direction));
  199.     glScalef(scale, scale, scale);
  201.     glDisable(GL_LIGHTING);
  203.     float shaftLength = 0.85f;
  204.     float headLength = 0.10f;
  205.     float shaftRadius = 0.010f;
  206.     float headRadius = 0.025f;
  207.     unsigned int nSections = 30;
  209.     glColor4f(1.0f, 1.0f, 0.0f, opacity);
  210.     RenderArrow(shaftLength, headLength, shaftRadius, headRadius, nSections);
  212.     glPopMatrix();
  213. }
  216. void RenderVelocityArrow(const Vec3f& direction, float scale, float opacity)
  217. {
  218.     glPushMatrix();
  219.     glRotate(Quatf::vecToVecRotation(Vec3f(0.0f, 0.0f, 1.0f), direction));
  220.     glScalef(scale, scale, scale);
  222.     glDisable(GL_LIGHTING);
  224.     float shaftLength = 0.85f;
  225.     float headLength = 0.10f;
  226.     float shaftRadius = 0.010f;
  227.     float headRadius = 0.025f;
  228.     unsigned int nSections = 30;
  230.     glColor4f(0.6f, 0.6f, 0.9f, opacity);
  231.     RenderArrow(shaftLength, headLength, shaftRadius, headRadius, nSections);
  233.     glPopMatrix();
  234. }
  237. /****** ArrowReferenceMark base class ******/
  239. ArrowReferenceMark::ArrowReferenceMark(const Body& _body) :
  240.     body(_body),
  241.     size(1.0),
  242.     color(1.0f, 1.0f, 1.0f),
  243. #ifdef USE_HDR
  244.     opacity(0.0f)
  245. #else
  246.     opacity(1.0f)
  247. #endif
  248. {
  249. }
  252. void
  253. ArrowReferenceMark::setSize(float _size)
  254. {
  255.     size = _size;
  256. }
  259. void
  260. ArrowReferenceMark::setColor(Color _color)
  261. {
  262.     color = _color;
  263. }
  266. void
  267. ArrowReferenceMark::render(Renderer* /* renderer */,
  268.                            const Point3f& /* position */,
  269.                            float /* discSize */,
  270.                            double tdb) const
  271. {
  272.     Vec3d v = getDirection(tdb);
  273.     if (v.length() < 1.0e-12)
  274.     {
  275.         // Skip rendering of zero-length vectors
  276.         return;
  277.     }
  279.     v.normalize();
  280.     Quatd q = Quatd::vecToVecRotation(Vec3d(0.0, 0.0, 1.0), v);
  282.     if (opacity == 1.0f)
  283.     {
  284.         // Enable depth buffering
  285.         glEnable(GL_DEPTH_TEST);
  286.         glDepthMask(GL_TRUE);
  287.         glDisable(GL_BLEND);
  288.     }
  289.     else
  290.     {
  291.         glEnable(GL_DEPTH_TEST);
  292.         glDepthMask(GL_FALSE);
  293.         glEnable(GL_BLEND);
  294. #ifdef USE_HDR
  295.         glBlendFunc(GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA);
  296. #else
  297.         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  298. #endif
  299.     }
  301.     glPushMatrix();
  302.     glRotate(Quatf((float) q.w, (float) q.x, (float) q.y, (float) q.z));
  303.     glScalef(size, size, size);
  304.     glDisable(GL_LIGHTING);
  305.     glDisable(GL_TEXTURE_2D);
  307.     float shaftLength = 0.85f;
  308.     float headLength = 0.10f;
  309.     float shaftRadius = 0.010f;
  310.     float headRadius = 0.025f;
  311.     unsigned int nSections = 30;
  313.     glColor4f(color.red(), color.green(), color.blue(), opacity);
  314.     RenderArrow(shaftLength, headLength, shaftRadius, headRadius, nSections);
  316.     glPopMatrix();
  318.     glDisable(GL_DEPTH_TEST);
  319.     glDepthMask(GL_FALSE);
  320.     glEnable(GL_TEXTURE_2D);
  321.     glEnable(GL_BLEND);
  322.     glBlendFunc(GL_SRC_ALPHA, GL_ONE);
  323. }
  326. /****** AxesReferenceMark base class ******/
  328. AxesReferenceMark::AxesReferenceMark(const Body& _body) :
  329.     body(_body),
  330.     size(),
  331. #ifdef USE_HDR
  332.     opacity(0.0f)
  333. #else
  334.     opacity(1.0f)
  335. #endif
  336. {
  337. }
  340. void
  341. AxesReferenceMark::setSize(float _size)
  342. {
  343.     size = _size;
  344. }
  347. void
  348. AxesReferenceMark::setOpacity(float _opacity)
  349. {
  350.     opacity = _opacity;
  351. #ifdef USE_HDR
  352.     opacity = 1.0f - opacity;
  353. #endif
  354. }
  357. void
  358. AxesReferenceMark::render(Renderer* /* renderer */,
  359.                           const Point3f& /* position */,
  360.                           float /* discSize */,
  361.                           double tdb) const
  362. {
  363.     Quatd q = getOrientation(tdb);
  365.     if (opacity == 1.0f)
  366.     {
  367.         // Enable depth buffering
  368.         glEnable(GL_DEPTH_TEST);
  369.         glDepthMask(GL_TRUE);
  370.         glDisable(GL_BLEND);
  371.     }
  372.     else
  373.     {
  374.         glEnable(GL_DEPTH_TEST);
  375.         glDepthMask(GL_FALSE);
  376.         glEnable(GL_BLEND);
  377. #ifdef USE_HDR
  378.         glBlendFunc(GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA);
  379. #else
  380.         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  381. #endif
  382.     }
  384.     glDisable(GL_TEXTURE_2D);
  386.     glPushMatrix();
  387.     glRotate(Quatf((float) q.w, (float) q.x, (float) q.y, (float) q.z));
  388.     glScalef(size, size, size);
  390.     glDisable(GL_LIGHTING);
  392. #if 0
  393.     // Simple line axes
  394.     glBegin(GL_LINES);
  396.     glColor4f(1.0f, 0.0f, 0.0f, 1.0f);
  397.     glVertex3f(0.0f, 0.0f, 0.0f);
  398.     glVertex3f(-1.0f, 0.0f, 0.0f);
  400.     glColor4f(0.0f, 1.0f, 0.0f, 1.0f);
  401.     glVertex3f(0.0f, 0.0f, 0.0f);
  402.     glVertex3f(0.0f, 0.0f, 1.0f);
  404.     glColor4f(0.0f, 0.0f, 1.0f, 1.0f);
  405.     glVertex3f(0.0f, 0.0f, 0.0f);
  406.     glVertex3f(0.0f, 1.0f, 0.0f);
  408.     glEnd();
  409. #endif
  411.     float shaftLength = 0.85f;
  412.     float headLength = 0.10f;
  413.     float shaftRadius = 0.010f;
  414.     float headRadius = 0.025f;
  415.     unsigned int nSections = 30;
  416.     float labelScale = 0.1f;
  418.     // x-axis
  419.     glPushMatrix();
  420.     glRotatef(90.0f, 0.0f, 1.0f, 0.0f);
  421.     glColor4f(1.0f, 0.0f, 0.0f, opacity);
  422.     RenderArrow(shaftLength, headLength, shaftRadius, headRadius, nSections);
  423.     glTranslatef(0.1f, 0.0f, 0.75f);
  424.     glScalef(labelScale, labelScale, labelScale);
  425.     RenderX();
  426.     glPopMatrix();
  428.     // y-axis
  429.     glPushMatrix();
  430.     glRotatef(180.0f, 0.0f, 1.0f, 0.0f);
  431.     glColor4f(0.0f, 1.0f, 0.0f, opacity);
  432.     RenderArrow(shaftLength, headLength, shaftRadius, headRadius, nSections);
  433.     glTranslatef(0.1f, 0.0f, 0.75f);
  434.     glScalef(labelScale, labelScale, labelScale);
  435.     RenderY();
  436.     glPopMatrix();
  438.     // z-axis
  439.     glPushMatrix();
  440.     glRotatef(-90.0f, 1.0f, 0.0f, 0.0f);
  441.     glColor4f(0.0f, 0.0f, 1.0f, opacity);
  442.     RenderArrow(shaftLength, headLength, shaftRadius, headRadius, nSections);
  443.     glTranslatef(0.1f, 0.0f, 0.75f);
  444.     glScalef(labelScale, labelScale, labelScale);
  445.     RenderZ();
  446.     glPopMatrix();
  448.     glPopMatrix();
  450.     glDisable(GL_DEPTH_TEST);
  451.     glDepthMask(GL_FALSE);
  452.     glEnable(GL_TEXTURE_2D);
  453.     glEnable(GL_BLEND);
  454.     glBlendFunc(GL_SRC_ALPHA, GL_ONE);
  455. }
  458. /****** VelocityVectorArrow implementation ******/
  460. VelocityVectorArrow::VelocityVectorArrow(const Body& _body) :
  461.     ArrowReferenceMark(_body)
  462. {
  463.     setTag("velocity vector");
  464.     setColor(Color(0.6f, 0.6f, 0.9f));
  465.     setSize(body.getRadius() * 2.0f);
  466. }
  468. Vec3d
  469. VelocityVectorArrow::getDirection(double tdb) const
  470. {
  471.     const TimelinePhase* phase = body.getTimeline()->findPhase(tdb);
  472.     return phase->orbit()->velocityAtTime(tdb) *
  473.         phase->orbitFrame()->getOrientation(tdb).toMatrix3();
  474. }
  477. /****** SunDirectionArrow implementation ******/
  479. SunDirectionArrow::SunDirectionArrow(const Body& _body) :
  480.     ArrowReferenceMark(_body)
  481. {
  482.     setTag("sun direction");
  483.     setColor(Color(1.0f, 1.0f, 0.4f));
  484.     setSize(body.getRadius() * 2.0f);
  485. }
  487. Vec3d
  488. SunDirectionArrow::getDirection(double tdb) const
  489. {
  490.     const Body* b = &body;
  491.     Star* sun = NULL;
  492.     while (b != NULL)
  493.     {
  494.         Selection center = b->getOrbitFrame(tdb)->getCenter();
  495.         if (center.star() != NULL)
  496.             sun = center.star();
  497.         b = center.body();
  498.     }
  500.     if (sun != NULL)
  501.     {
  502.         return Selection(sun).getPosition(tdb) - body.getPosition(tdb);
  503.     }
  504.     else
  505.     {
  506.         return Vec3d(0.0, 0.0, 0.0);
  507.     }
  508. }
  511. /****** SpinVectorArrow implementation ******/
  513. SpinVectorArrow::SpinVectorArrow(const Body& _body) :
  514.     ArrowReferenceMark(_body)
  515. {
  516.     setTag("spin vector");
  517.     setColor(Color(0.6f, 0.6f, 0.6f));
  518.     setSize(body.getRadius() * 2.0f);
  519. }
  521. Vec3d
  522. SpinVectorArrow::getDirection(double tdb) const
  523. {
  524.     const TimelinePhase* phase = body.getTimeline()->findPhase(tdb);
  525.     return phase->rotationModel()->angularVelocityAtTime(tdb) *
  526.         phase->bodyFrame()->getOrientation(tdb).toMatrix3();
  527. #if 0
  528.     return body.getRotationModel(tdb)->angularVelocityAtTime(tdb) *
  529.         body.getEclipticToFrame(tdb).toMatrix3();
  530. #endif
  531. }
  534. /****** BodyToBodyDirectionArrow implementation ******/
  536. /*! Create a new body-to-body direction arrow pointing from the origin body toward
  537.  *  the specified target object.
  538.  */
  539. BodyToBodyDirectionArrow::BodyToBodyDirectionArrow(const Body& _body, const Selection& _target) :
  540.     ArrowReferenceMark(_body),
  541.     target(_target)
  542. {
  543.     setTag("body to body");
  544.     setColor(Color(0.0f, 0.5f, 0.0f));
  545.     setSize(body.getRadius() * 2.0f);
  546. }
  549. Vec3d
  550. BodyToBodyDirectionArrow::getDirection(double tdb) const
  551. {
  552.     return target.getPosition(tdb) - body.getPosition(tdb);
  553. }
  556. /****** BodyAxisArrows implementation ******/
  558. BodyAxisArrows::BodyAxisArrows(const Body& _body) :
  559.     AxesReferenceMark(_body)
  560. {
  561.     setTag("body axes");
  562.     setOpacity(1.0);
  563.     setSize(body.getRadius() * 2.0f);
  564. }
  566. Quatd
  567. BodyAxisArrows::getOrientation(double tdb) const
  568. {
  569.     return ~(Quatd::yrotation(PI) * body.getEclipticToBodyFixed(tdb));
  570. }
  573. /****** FrameAxisArrows implementation ******/
  575. FrameAxisArrows::FrameAxisArrows(const Body& _body) :
  576.     AxesReferenceMark(_body)
  577. {
  578.     setTag("frame axes");
  579.     setOpacity(0.5);
  580.     setSize(body.getRadius() * 2.0f);
  581. }
  583. Quatd
  584. FrameAxisArrows::getOrientation(double tdb) const
  585. {
  586.     return ~body.getEclipticToFrame(tdb);
  587. }