1 // RenderArea2D.cxx - a class to manage 2D polygon-based drawing
2 // for a complex instrument (eg. GPS).
4 // Written by David Luff, started 2005.
6 // Copyright (C) 2005 - David C Luff - daveluff AT ntlworld.com
8 // This program is free software; you can redistribute it and/or
9 // modify it under the terms of the GNU General Public License as
10 // published by the Free Software Foundation; either version 2 of the
11 // License, or (at your option) any later version.
13 // This program is distributed in the hope that it will be useful, but
14 // WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 // General Public License for more details.
18 // You should have received a copy of the GNU General Public License
19 // along with this program; if not, write to the Free Software
20 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
29 #include "render_area_2d.hxx"
31 RA2DPrimitive::RA2DPrimitive() {
36 RenderArea2D::RenderArea2D(int logx, int logy, int sizex, int sizey, int posx, int posy) {
48 _backgroundColor[0] = 0.0;
49 _backgroundColor[1] = 0.0;
50 _backgroundColor[2] = 0.0;
51 _backgroundColor[3] = 1.0;
60 void RenderArea2D::Draw(osg::State& state) {
62 static osg::ref_ptr<osg::StateSet> renderArea2DStateSet;
63 if(!renderArea2DStateSet.valid()) {
64 renderArea2DStateSet = new osg::StateSet;
65 renderArea2DStateSet->setTextureMode(0, GL_TEXTURE_2D, osg::StateAttribute::OFF);
66 renderArea2DStateSet->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
69 state.pushStateSet(renderArea2DStateSet.get());
71 state.setActiveTextureUnit(0);
72 state.setClientActiveTextureUnit(0);
74 // DCL - the 2 lines below are copied verbatim from the hotspot drawing code.
75 // I am not sure if they are needed here or not.
76 glPushAttrib(GL_ENABLE_BIT);
77 glDisable(GL_COLOR_MATERIAL);
79 // FIXME - disabling all clip planes causes bleed-through through the splash screen.
80 glDisable(GL_CLIP_PLANE0);
81 glDisable(GL_CLIP_PLANE1);
82 glDisable(GL_CLIP_PLANE2);
83 glDisable(GL_CLIP_PLANE3);
87 for(unsigned int i = 0; i < drawing_list.size(); ++i) {
88 RA2DPrimitive prim = drawing_list[i];
91 DoDrawLine(prim.x1, prim.y1, prim.x2, prim.y2);
95 //cout << "Clipping = " << _clipx1 << ", " << _clipy1 << " to " << _clipx2 << ", " << _clipy2 << '\n';
96 //cout << "Drawing quad " << prim.x1 << ", " << prim.y1 << " to " << prim.x2 << ", " << prim.y2 << '\n';
98 DoDrawQuad(prim.x1, prim.y1, prim.x2, prim.y2, prim.invert);
101 DoDrawPixel(prim.x1, prim.y1, prim.invert);
106 drawing_list.clear();
112 state.setActiveTextureUnit(0);
113 state.setClientActiveTextureUnit(0);
116 void RenderArea2D::Flush() {
117 drawing_list.clear();
120 // Set clipping region in logical units
121 void RenderArea2D::SetClipRegion(int x1, int y1, int x2, int y2) {
126 //cout << "Set clip region, clip region = " << _clipx1 << ", " << _clipy1 << " to " << _clipx2 << ", " << _clipy2 << '\n';
129 // Set clip region to be the same as the rendered area (default)
130 void RenderArea2D::ResetClipRegion() {
135 //cout << "Reset clip region, clip region = " << _clipx1 << ", " << _clipy1 << " to " << _clipx2 << ", " << _clipy2 << '\n';
138 void RenderArea2D::SetPosition(int posx, int posy) {
143 void RenderArea2D::SetLogicalSize(int logx, int logy) {
148 void RenderArea2D::SetActualSize(int sizex, int sizey) {
153 void RenderArea2D::DrawPixel(int x, int y, bool invert) {
155 if(x < _clipx1 || x > _clipx2 || y < _clipy1 || y > _clipy2) return;
162 prim.type = RA2D_PIXEL;
163 prim.invert = invert;
164 drawing_list.push_back(prim);
167 void RenderArea2D::DoDrawPixel(int x, int y, bool invert) {
168 // Clip. In theory this shouldn't be necessary, since all input is clipped before adding
169 // to the drawing list, but it ensures that any errors in clipping lines etc will only
170 // spill over the clip area within the instrument, and still be clipped from straying
171 // outside the instrument.
172 if(x < _clipx1 || x > _clipx2 || y < _clipy1 || y > _clipy2) return;
174 // Scale to position within background
175 float fx1 = (float)x, fy1 = (float)y;
176 float rx = (float)_sizex / (float)_logx;
177 float ry = (float)_sizey / (float)_logy;
180 float fx2 = fx1 + rx;
181 float fy2 = fy1 + ry;
183 // Translate to final position
189 //cout << "DP: " << fx1 << ", " << fy1 << " ... " << fx2 << ", " << fy2 << '\n';
191 SetRenderColor(invert ? _backgroundColor : _pixelColor);
192 SGVec2f corners[4] = {
201 void RenderArea2D::DrawLine(int x1, int y1, int x2, int y2) {
202 // We need to clip the line to the current region before storing it in the drawing
203 // list, since when we come to actually draw it the clip region may have changed.
205 // Liang-Barsky clipping algorithm
207 float u1 = 0.0f, u2 = 1.0f;
208 p[0] = -(x2 - x1); q[0] = (x1 - _clipx1);
209 p[1] = (x2 - x1); q[1] = (_clipx2 - x1);
210 p[2] = -(y2 - y1); q[2] = (y1 - _clipy1);
211 p[3] = (y2 - y1); q[3] = (_clipy2 - y1);
213 for(int i=0; i<4; ++i) {
216 // Then we have a trivial rejection of a line parallel to a clip plane
217 // completely outside the clip region.
220 } else if(p[i] < 0) {
221 float r = (float)q[i]/(float)p[i];
222 u1 = (u1 > r ? u1 : r);
224 float r = (float)q[i]/(float)p[i];
225 u2 = (u2 < r ? u2 : r);
228 // Then the line is completely outside the clip area.
233 float fx1 = x1 + u1 * (float)(x2 - x1);
234 float fy1 = y1 + u1 * (float)(y2 - y1);
235 float fx2 = x1 + u2 * (float)(x2 - x1);
236 float fy2 = y1 + u2 * (float)(y2 - y1);
237 x1 = (int)(fx1 + 0.5);
238 y1 = (int)(fy1 + 0.5);
239 x2 = (int)(fx2 + 0.5);
240 y2 = (int)(fy2 + 0.5);
247 prim.type = RA2D_LINE;
249 drawing_list.push_back(prim);
252 void RenderArea2D::DoDrawLine(int x1, int y1, int x2, int y2) {
253 // Crude implementation of Bresenham line drawing algorithm.
255 // Our lines are non directional, so first order the points x-direction-wise to leave only 4 octants to consider.
265 bool flip_y = (y1 > y2 ? true : false);
267 int dy = (flip_y ? y1 - y2 : y2 - y1);
272 for(int x=x1; x<=x2; ++x) {
277 y = (flip_y ? y - 1 : y + 1);
284 // Must be a more elegant way to roll the next two cases into one!
286 for(int y=y1; y>=y2; --y) {
295 for(int y=y1; y<=y2; ++y) {
307 void RenderArea2D::DrawQuad(int x1, int y1, int x2, int y2, bool invert) {
308 // Force the input to be ordered with x1 < x2 and y1 < y2.
320 // Clip the input to the current drawing region.
321 x1 = x1 < _clipx1 ? _clipx1 : x1;
322 if(x1 > _clipx2) { return; }
323 x2 = x2 > _clipx2 ? _clipx2 : x2;
324 if(x2 < _clipx1) { return; }
325 y1 = y1 < _clipy1 ? _clipy1 : y1;
326 if(y1 > _clipy2) { return; }
327 y2 = y2 > _clipy2 ? _clipy2 : y2;
328 if(y2 < _clipy1) { return; }
335 prim.type = RA2D_QUAD;
336 prim.invert = invert;
337 if(_ra2d_debug) prim.debug = true;
338 drawing_list.push_back(prim);
341 void RenderArea2D::DoDrawQuad(int x1, int y1, int x2, int y2, bool invert) {
342 // Scale to position within background
343 float fx1 = (float)x1, fy1 = (float)y1;
344 float fx2 = (float)x2, fy2 = (float)y2;
345 float rx = (float)_sizex / (float)_logx;
346 float ry = (float)_sizey / (float)_logy;
355 // Translate to final position
361 //cout << "DP: " << fx1 << ", " << fy1 << " ... " << fx2 << ", " << fy2 << '\n';
363 SetRenderColor(invert ? _backgroundColor : _pixelColor);
364 SGVec2f corners[4] = {
373 void RenderArea2D::DrawBackground() {
377 void RenderArea2D::DoDrawBackground() {
378 SetRenderColor(_backgroundColor);
379 SGVec2f corners[4] = {
380 SGVec2f(_posx, _posy),
381 SGVec2f(_posx + _sizex, _posy),
382 SGVec2f(_posx + _sizex, _posy + _sizey),
383 SGVec2f(_posx, _posy + _sizey)
389 // -----------------------------------------
391 // Actual drawing routines copied from Atlas
393 // -----------------------------------------
395 void RenderArea2D::SetRenderColor( const float *rgba ) {
396 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, rgba);
400 void RenderArea2D::RenderQuad( const SGVec2f *p) {
402 glNormal3f(0.0f, 0.0f, 0.0f);
403 glVertex2fv( p[0].data() );
404 glVertex2fv( p[1].data() );
405 glVertex2fv( p[2].data() );
406 glVertex2fv( p[3].data() );
410 void RenderArea2D::RenderQuad( const SGVec2f *p, const SGVec4f *color ) {
412 glNormal3f(0.0f, 0.0f, 0.0f);
413 glColor4fv( color[0].data() ); glVertex2fv( p[0].data() );
414 glColor4fv( color[1].data() ); glVertex2fv( p[1].data() );
415 glColor4fv( color[2].data() ); glVertex2fv( p[2].data() );
416 glColor4fv( color[3].data() ); glVertex2fv( p[3].data() );