1
0
Fork 0
flightgear/src/Model/panelnode.hxx

71 lines
2.4 KiB
C++
Raw Normal View History

3D panel support from Andy Ross: + The panel(s) are now an first-class SSG node inside the aircraft scene graph. There's a little code added to model.cxx to handle the parsing, but most of the changes are inside the new FGPanelNode class (Model/panelnode.[ch]xx). + The old FGPanel source changed a lot, but mostly cosmetically. The virtual-cockpit code moved out into FGPanelNode, and the core rendering has been abstracted into a draw() method that doesn't try to set any OpenGL state. I also replaced the old inter-layer offset code with glPolygonOffset, as calculating the right Z values is hard across the funky modelview matrix I need to use. The older virtual panel code got away with it by disabling depth test, thus the "panel draws on top of yoke" bug. PolygonOffset is really the appropriate solution for this sort of task anyway. + The /sim/virtual-cockpit property is no more. The 2D panels are still specified in the -set.xml file, but 3D panels are part of the model file. + You can have as many 3D panels as you like. Problems: + The mouse support isn't ready yet, so the 3D panels still aren't interactive. Soon to come. + Being part of the same scene graph as the model, the 3D panels now "jitter" in exactly the same way. While this makes the jitter of the attitude gyro less noticeable, it's still *very* noticeable and annoying. I looked hard for this, and am at this point convinced that the problem is with the two orientation computations. We have one in FGLocation that is used by the model code, and one in FGViewer that is used at the top of the scene graph. My suspicion is that they don't agree exactly, so the final orientation matrix is the right answer plus the difference. I did rule out the FDMs though. None of them show more than about 0.0001 degree of orientation change between frames for a stopped aircraft. That's within an order of magnitude of what you'd expect for the orientation change due to the rotation of the earth (which we don't model -- I cite it only as evidence of how small this is); far, far less than one pixel on the screen. [and later] OK, this is fixed by the attached panel.cxx file. What's happened is that the winding order for the text layer's polygons is wrong, so I reverse it before drawing. That's largely a hatchet job to make things work for now, though. We should figure out why the winding order is wrong for only text layers and fix it. I checked the plib sources -- they're definitely doing things CCW, as is all the rest of the panel code. Odd. I'm also not sure why the 2D panel doesn't care (it works in both winding orders). But this will allow you to check in working code, anyway. There's a big comment to this effect in there.
2002-06-28 14:17:40 +00:00
#include <plib/ssg.h>
class FGPanel;
class SGPropertyNode;
// PanelNode defines an SSG leaf object that draws a FGPanel object
// into the scene graph. Note that this is an incomplete SSG object,
// many methods, mostly involved with modelling and runtime
// inspection, are unimplemented.
class FGPanelNode : public ssgLeaf
{
protected:
virtual void draw_geometry();
public:
FGPanelNode(SGPropertyNode* props);
virtual ~FGPanelNode();
virtual void draw();
void mouseEvent(int button, int updown, int x, int y);
virtual void recalcBSphere() { bsphere_is_invalid = 0; }
//
// A bunch of Plib functions that aren't implemented. I don't
// even know what many of them do, but they're pure virtual and
// require implementation.
//
virtual int getNumTriangles() { die(); return 0; }
virtual void getTriangle(int n, short* v1, short* v2, short* v3) { die(); }
virtual int getNumLines() { die(); return 0; }
virtual void getLine(int n, short* v1, short* v2) { die(); }
virtual void drawHighlight(sgVec4 colour) { die(); }
virtual void drawHighlight(sgVec4 colour, int i) { die(); }
virtual float* getVertex(int i) { die(); return 0; }
virtual float* getNormal(int i) { die(); return 0; }
virtual float* getColour(int i) { die(); return 0; }
virtual float* getTexCoord(int i) { die(); return 0; }
virtual void pick(int baseName) { die(); }
virtual void isect_triangles(sgSphere* s, sgMat4 m, int testNeeded) { die(); }
virtual void hot_triangles(sgVec3 s, sgMat4 m, int testNeeded) { die(); }
virtual void los_triangles(sgVec3 s, sgMat4 m, int testNeeded) { die(); }
virtual void transform(const sgMat4 m) { die(); }
private:
// Handler for all the unimplemented methods above
void die();
FGPanel* _panel;
// Panel corner coordinates
float _bottomLeft[3], _topLeft[3], _bottomRight[3];
// The input range expected in the panel definition. These x/y
// coordinates will map to the right/top sides.
float _xmax, _ymax;
// The matrix that results, which transforms 2D x/y panel
// coordinates into 3D coordinates of the panel quadrilateral.
GLfloat _xform[16];
// The matrix transformation state that was active the last time
// we were rendered. Used by the mouse code to compute
// intersections.
GLfloat _lastModelview[16];
GLfloat _lastProjection[16];
GLint _lastViewport[4];
};