/usr/include/oglappth/ogl_objects.h is in liboglappth-dev 1.0.0-2ubuntu1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 | // OGL_OBJECTS.H : base classes for different OpenGL-objects.
// Copyright (C) 1998 Tommi Hassinen.
// This package is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
// This package is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this package; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/*################################################################################################*/
//#include "config.h"
#ifndef OGL_OBJECTS_H
#define OGL_OBJECTS_H
/*################################################################################################*/
#ifdef WIN32
#include <windows.h> // need to have this before the GL stuff...
#endif // WIN32
#include <GL/gl.h>
#include <GL/glu.h>
#include <list>
#include <vector>
using namespace std;
/*################################################################################################*/
struct ogl_obj_loc_data;
class ogl_dummy_object;
class ogl_smart_object;
class ogl_object_location;
class ogl_ol_static;
class ogl_ol_dynamic_l1;
#include "oglv3d.h"
class ogl_camera; // ogl_camera.h
/*################################################################################################*/
/** This function can be used to modify a 3D-vector object using a 4x4 transformation
matrix. Will first make a [1*4]x[4x4]-type matrix product and after that bring the
result back to 3D.
For more complete documentation search for "##homogeneous coordinates"...
*/
void TransformVector(oglv3d<GLfloat> &, const GLfloat *);
/** This sets the current modelview-matrix equivalent to the location and orientation
of the object without making any persistent changes to the matrix stack state.
*/
void SetModelView(const ogl_obj_loc_data *);
/*################################################################################################*/
/** Object location data is stored here.
Directions are similar to those in OpenGL:
"zdir" -> positive direction is to the forward.
"ydir" -> positive direction is to the upward.
"xdir" -> positive direction is to the left.
All vectors are supposed to be unit vectors !!!
Only lights will use the fourth component !!!
*/
struct ogl_obj_loc_data
{
GLfloat crd[4];
oglv3d<GLfloat> zdir;
oglv3d<GLfloat> ydir;
int lock_count;
};
/*################################################################################################*/
/** The "##ogl_dummy_object" is a base class for many internally used objects (like cameras,
lights, clippers and transformers), and contains interfaces for transformations,
simple modifications and rendering.
Some objects (like ribbons) are fixed so not all objects necessarily have object_location...
*/
class ogl_dummy_object
{
protected:
ogl_object_location * ol;
int my_id_number;
public:
ogl_dummy_object(bool);
ogl_dummy_object(const ogl_object_location &);
virtual ~ogl_dummy_object(void);
void SetModelView(void) const;
const ogl_obj_loc_data * GetSafeLD(void) const; // read access only.
ogl_obj_loc_data * GetLD(void) const; // read/write access.
public:
virtual const char * GetObjectName(void) = 0;
virtual void OrbitObject(const GLfloat *, const ogl_camera &);
virtual void RotateObject(const GLfloat *, const ogl_camera &);
virtual void TranslateObject(const GLfloat *, const ogl_obj_loc_data *);
virtual bool BeginTransformation(void) = 0;
virtual bool EndTransformation(void) = 0;
virtual void Render(void) = 0;
};
/*################################################################################################*/
// UNDER CONSTRUCTION!!!!! UNDER CONSTRUCTION!!!!! UNDER CONSTRUCTION!!!!!
// UNDER CONSTRUCTION!!!!! UNDER CONSTRUCTION!!!!! UNDER CONSTRUCTION!!!!!
// UNDER CONSTRUCTION!!!!! UNDER CONSTRUCTION!!!!! UNDER CONSTRUCTION!!!!!
//struct smart_client
//{
// graphics_view * client;
// void * custom_data;
//};
// vector<smart_client> client_vector;
/** The "##smart_object" is used to implement complex visualization objects (like colored
3D-planes and surfaces, and ribbon models of peptides/proteins).
A "##smart_object" can respond to connectivity/geometry changes and can have other
customized properties. Clippers can be used to clip smart_objects (AND ONLY THOSE?????).
BAD NEWS: the clipper objects does not exist yet.
"##new connectivity" means that some atoms/bonds have been added/removed.
"##new geometry" means that some atom coordinates have been modified.
THIS IS STILL A BIT UNDER CONSTRUCTION!!!
*/
class ogl_smart_object :
public ogl_dummy_object
{
private:
list<ogl_camera *> cam_list;
public:
bool transparent; // why public???
public:
ogl_smart_object(void);
ogl_smart_object(const ogl_object_location &);
virtual ~ogl_smart_object(void);
void ConnectCamera(ogl_camera &);
virtual void CameraEvent(const ogl_camera &) = 0;
/*##############################################*/
/*##############################################*/
// virtual bool AddClient(some_view *, void *) = 0;
// virtual bool RemoveClient(some_view *) = 0;
// virtual void NewConnectivity(void) = 0;
// virtual void NewGeometry(void) = 0;
};
/*################################################################################################*/
/** The "##ogl_object_location" is an abstract base class for all objects(???). It contains
information about the position and orientation of the object and is also able to write
that information into the OpenGL modelview matrix.
Idea is to create derived classes that can have different (also dynamic) ways to
determine the location...
*/
class ogl_object_location
{
protected: // FC3 compiler does not accept this?
// public: // this is the obvious fix to the above...
ogl_obj_loc_data * data;
friend const ogl_obj_loc_data * ogl_dummy_object::GetSafeLD(void) const;
friend ogl_obj_loc_data * ogl_dummy_object::GetLD(void) const;
public:
ogl_object_location(void);
ogl_object_location(const ogl_object_location &);
virtual ~ogl_object_location(void);
void SetModelView(void) const;
const ogl_obj_loc_data * GetSafeLD(void) const;
virtual void UpdateLocation(void) const = 0;
virtual ogl_object_location * MakeCopy(void) const = 0;
};
/*################################################################################################*/
/// A simple static object location - seems to work, just use this...
class ogl_ol_static :
public ogl_object_location
{
protected:
// this is just an interface definition -> there is no relevant common data?!?!?
// this is just an interface definition -> there is no relevant common data?!?!?
// this is just an interface definition -> there is no relevant common data?!?!?
public:
ogl_ol_static(void);
ogl_ol_static(const ogl_obj_loc_data *);
~ogl_ol_static(void);
void UpdateLocation(void) const;
ogl_object_location * MakeCopy(void) const;
};
/** A dynamic object location (UNDER CONSTRUCTION).
The idea here is, that we could make objects that are automatically located using
some external data; for example we could have a camera or a light that is always
focused on a target, no matter how the target moves. We would have here pointers
to the target coordinates, and we would update the object location dynamically
using those...
*/
class ogl_ol_dynamic_l1 :
public ogl_object_location
{
private:
// bring the points and weights here?!?!?!?!?
// bring the points and weights here?!?!?!?!?
// bring the points and weights here?!?!?!?!?
public:
ogl_ol_dynamic_l1(void);
~ogl_ol_dynamic_l1(void);
void UpdateLocation(void) const;
ogl_object_location * MakeCopy(void) const;
};
/*################################################################################################*/
#endif // OGL_OBJECTS_H
// eof
|