1412104461 2 2 12 libp3distort 4 2YN4 10 panda3d.fx 65 64 15 CylindricalLens 0 4 129 32 CylindricalLens::CylindricalLens 0 1 1 946 // Filename: cylindricalLens.I // Created by: drose (12Dec01) // //////////////////////////////////////////////////////////////////// // // PANDA 3D SOFTWARE // Copyright (c) Carnegie Mellon University. All rights reserved. // // All use of this software is subject to the terms of the revised BSD // license. You should have received a copy of this license along // with this source code in a file named "LICENSE." // //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// // Function: CylindricalLens::Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// // Function: CylindricalLens::Copy Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// 46 inline CylindricalLens::CylindricalLens(void); 65 14 get_class_type 0 4 129 31 CylindricalLens::get_class_type 0 1 2 0 56 static TypeHandle CylindricalLens::get_class_type(void); 66 16 ~CylindricalLens 0 4 129 33 CylindricalLens::~CylindricalLens 0 0 0 40 CylindricalLens::~CylindricalLens(void); 67 11 FisheyeLens 0 4 131 24 FisheyeLens::FisheyeLens 0 1 3 934 // Filename: fisheyeLens.I // Created by: drose (12Dec01) // //////////////////////////////////////////////////////////////////// // // PANDA 3D SOFTWARE // Copyright (c) Carnegie Mellon University. All rights reserved. // // All use of this software is subject to the terms of the revised BSD // license. You should have received a copy of this license along // with this source code in a file named "LICENSE." // //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// // Function: FisheyeLens::Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// // Function: FisheyeLens::Copy Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// 38 inline FisheyeLens::FisheyeLens(void); 68 14 get_class_type 0 4 131 27 FisheyeLens::get_class_type 0 1 4 0 52 static TypeHandle FisheyeLens::get_class_type(void); 69 12 ~FisheyeLens 0 4 131 25 FisheyeLens::~FisheyeLens 0 0 0 32 FisheyeLens::~FisheyeLens(void); 70 16 ProjectionScreen 0 4 132 34 ProjectionScreen::ProjectionScreen 0 2 5 6 465 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::Constructor // Access: Published // Description: //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::Copy Constructor // Access: Protected // Description: //////////////////////////////////////////////////////////////////// 76 ProjectionScreen::ProjectionScreen(basic_string< char > const &name = ("")); 71 13 set_projector 0 4 132 31 ProjectionScreen::set_projector 0 1 7 681 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::set_projector // Access: Published // Description: Specifies the LensNode that is to serve as the // projector for this screen. The relative position of // the LensNode to the ProjectionScreen, as well as the // properties of the lens associated with the LensNode, // determines the UV's that will be assigned to the // geometry within the ProjectionScreen. // // The NodePath must refer to a LensNode (or a Camera). //////////////////////////////////////////////////////////////////// 64 void ProjectionScreen::set_projector(NodePath const &projector); 72 13 get_projector 0 4 132 31 ProjectionScreen::get_projector 0 1 8 884 // Filename: projectionScreen.I // Created by: drose (11Dec01) // //////////////////////////////////////////////////////////////////// // // PANDA 3D SOFTWARE // Copyright (c) Carnegie Mellon University. All rights reserved. // // All use of this software is subject to the terms of the revised BSD // license. You should have received a copy of this license along // with this source code in a file named "LICENSE." // //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::get_projector // Access: Published // Description: Returns the NodePath to the LensNode that is to serve // as the projector for this screen, or empty if no // projector is associated. //////////////////////////////////////////////////////////////////// 67 inline NodePath const &ProjectionScreen::get_projector(void) const; 73 16 clear_undist_lut 0 4 132 34 ProjectionScreen::clear_undist_lut 0 1 9 320 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::clear_undist_lut // Access: Published // Description: Removes the distortion lookup table from the // projector, if specified. //////////////////////////////////////////////////////////////////// 53 inline void ProjectionScreen::clear_undist_lut(void); 74 14 set_undist_lut 0 4 132 32 ProjectionScreen::set_undist_lut 0 1 10 625 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::set_undist_lut // Access: Published // Description: Applies a distortion lookup table to the // projector. This mapping warps the lens effect by // passing each ray through an indirection table: the // point (u,v) in the indicated lookup table stores the // actual (u,v) that the lens produces. // // This does not affect the operation of // generate_screen(). //////////////////////////////////////////////////////////////////// 72 inline void ProjectionScreen::set_undist_lut(PfmFile const &undist_lut); 75 14 has_undist_lut 0 4 132 32 ProjectionScreen::has_undist_lut 0 1 11 348 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::has_undist_lut // Access: Published // Description: Returns true if a valid distortion lookup table was // provided via set_undist_lut(), false otherwise. //////////////////////////////////////////////////////////////////// 57 inline bool ProjectionScreen::has_undist_lut(void) const; 76 14 get_undist_lut 0 4 132 32 ProjectionScreen::get_undist_lut 0 1 12 323 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::get_undist_lut // Access: Published // Description: Returns the distortion lookup table provided via // set_undist_lut(), if any. //////////////////////////////////////////////////////////////////// 67 inline PfmFile const &ProjectionScreen::get_undist_lut(void) const; 77 15 generate_screen 0 4 132 33 ProjectionScreen::generate_screen 0 1 13 1745 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::generate_screen // Access: Published // Description: Synthesizes a polygon mesh based on the projection // area of the indicated projector. This generates and // returns a new GeomNode but does not automatically // parent it to the ProjectionScreen node; see // regenerate_screen(). // // The specified projector need not be the same as the // projector given to the ProjectionScreen with // set_projector() (although this is often what you // want). // // num_x_verts and num_y_verts specify the number of // vertices to make in the grid across the horizontal // and vertical dimension of the projector, // respectively; distance represents the approximate // distance of the screen from the lens center. // // The fill_ratio parameter specifies the fraction of // the image to cover. If it is 1.0, the entire image // is shown full-size; if it is 0.9, 10% of the image // around the edges is not part of the grid (and the // grid is drawn smaller by the same 10%). This is // intended to work around graphics drivers that tend to // show dark edges or other unsatisfactory artifacts // around the edges of textures: render the texture // larger than necessary by a certain fraction, and make // the screen smaller by the inverse fraction. //////////////////////////////////////////////////////////////////// 192 PointerTo< GeomNode > ProjectionScreen::generate_screen(NodePath const &projector, basic_string< char > const &screen_name, int num_x_verts, int num_y_verts, float distance, float fill_ratio); 78 17 regenerate_screen 0 4 132 35 ProjectionScreen::regenerate_screen 0 1 14 391 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::regenerate_screen // Access: Published // Description: Removes all the children from the ProjectionScreen // node, and adds the newly generated child returned by // generate_screen(). //////////////////////////////////////////////////////////////////// 177 void ProjectionScreen::regenerate_screen(NodePath const &projector, basic_string< char > const &screen_name, int num_x_verts, int num_y_verts, float distance, float fill_ratio); 79 14 make_flat_mesh 0 4 132 32 ProjectionScreen::make_flat_mesh 0 1 15 1049 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::make_flat_mesh // Access: Published // Description: Generates a deep copy of the hierarchy at the // ProjectionScreen node and below, with vertices // flattened into two dimensions as if they were seen by // the indicated camera node. // // This is useful for rendering an image as seen through // a non-linear lens. The resulting mesh will have // vertices in the range [-1, 1] in both x and y, and // may be then rendered with an ordinary orthographic // lens, to generate the effect of seeing the image // through the specified non-linear lens. // // The returned node has no parent; it is up to the // caller to parent it somewhere or store it so that it // does not get dereferenced and deleted. //////////////////////////////////////////////////////////////////// 105 PointerTo< PandaNode > ProjectionScreen::make_flat_mesh(NodePath const &this_np, NodePath const &camera); 80 17 set_texcoord_name 0 4 132 35 ProjectionScreen::set_texcoord_name 0 1 16 551 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::set_texcoord_name // Access: Published // Description: Specifies the name of the texture coordinates that // are generated by this particular ProjectionScreen. // This can be used in the presence of multitexturing to // compute the UV's for just a subset of all of the // active stages of the multitexture pipeline. //////////////////////////////////////////////////////////////////// 91 inline void ProjectionScreen::set_texcoord_name(basic_string< char > const &texcoord_name); 81 17 get_texcoord_name 0 4 132 35 ProjectionScreen::get_texcoord_name 0 1 17 403 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::get_texcoord_name // Access: Published // Description: Returns the name of the texture coordinates that // will be generated by this particular // ProjectionScreen, as set by set_texcoord_name(). //////////////////////////////////////////////////////////////////// 76 inline basic_string< char > ProjectionScreen::get_texcoord_name(void) const; 82 14 set_invert_uvs 0 4 132 32 ProjectionScreen::set_invert_uvs 0 1 18 777 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::set_invert_uvs // Access: Published // Description: Some OpenGL graphics drivers are known to invert the // framebuffer image when they copy it to texture. // (This is arguably a problem with the OpenGL spec, // which seems to be unclear about the proper ordering // of pixels in this operation.) // // In any case, set this true to compensate for this // effect by inverting the UV's of the projection // screen. The default is taken from the Configrc // variable project-invert-uvs. //////////////////////////////////////////////////////////////////// 62 inline void ProjectionScreen::set_invert_uvs(bool invert_uvs); 83 14 get_invert_uvs 0 4 132 32 ProjectionScreen::get_invert_uvs 0 1 19 387 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::get_invert_uvs // Access: Published // Description: Returns whether this screen is compensating for a // graphics driver inverting the framebuffer image. See // set_invert_uvs(). //////////////////////////////////////////////////////////////////// 57 inline bool ProjectionScreen::get_invert_uvs(void) const; 84 15 set_texcoord_3d 0 4 132 33 ProjectionScreen::set_texcoord_3d 0 1 20 617 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::set_texcoord_3d // Access: Published // Description: Set this true to force 3-D texture coordinates to be // created for the geometry. When this is true and the // geometry has only 2-D texture coordinates, those // texture coordinates are dumped in favor of 3-D // coordinates. When this is false, whatever texture // coordinates already exist are preserved as-is. //////////////////////////////////////////////////////////////////// 64 inline void ProjectionScreen::set_texcoord_3d(bool texcoord_3d); 85 15 get_texcoord_3d 0 4 132 33 ProjectionScreen::get_texcoord_3d 0 1 21 255 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::get_texcoord_3d // Access: Published // Description: See set_texcoord_3d(). //////////////////////////////////////////////////////////////////// 58 inline bool ProjectionScreen::get_texcoord_3d(void) const; 86 15 set_vignette_on 0 4 132 33 ProjectionScreen::set_vignette_on 0 1 22 811 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::set_vignette_on // Access: Published // Description: Specifies whether vertex-based vignetting should be // on. When this is enabled, vertex color will be set // on the screen vertices to color the screen two // distinct colors, usually white and black, for the // parts of the screen in front of and outside the lens' // frustum, respectively. When this is not enabled, the // screen color will be left alone. // // This effect generally looks terrible, but it does // at least make the boundaries of the lens clear. //////////////////////////////////////////////////////////////////// 64 inline void ProjectionScreen::set_vignette_on(bool vignette_on); 87 15 get_vignette_on 0 4 132 33 ProjectionScreen::get_vignette_on 0 1 23 337 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::get_vignette_on // Access: Published // Description: Returns true if vertex-based vignetting is on, false // otherwise. See set_vignette_on(). //////////////////////////////////////////////////////////////////// 58 inline bool ProjectionScreen::get_vignette_on(void) const; 88 18 set_vignette_color 0 4 132 36 ProjectionScreen::set_vignette_color 0 1 24 528 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::set_vignette_color // Access: Published // Description: Specifies the color the screen will be painted at the // portions outside of the lens' frustum; i.e. where the // lens can't see it or illuminate it. This color is // only used if the vignette_on flag is true; see // set_vignette_on(). //////////////////////////////////////////////////////////////////// 83 inline void ProjectionScreen::set_vignette_color(LVecBase4f const &vignette_color); 89 18 get_vignette_color 0 4 132 36 ProjectionScreen::get_vignette_color 0 1 25 387 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::get_vignette_color // Access: Published // Description: Returns the color the screen will be painted at the // portions outside of the lens' frustum. See // set_vignette_color(). //////////////////////////////////////////////////////////////////// 74 inline LVecBase4f const &ProjectionScreen::get_vignette_color(void) const; 90 15 set_frame_color 0 4 132 33 ProjectionScreen::set_frame_color 0 1 26 525 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::set_frame_color // Access: Published // Description: Specifies the color the screen will be painted at the // portions outside of the lens' frustum; i.e. where the // lens can't see it or illuminate it. This color is // only used if the vignette_on flag is true; see // set_vignette_on(). //////////////////////////////////////////////////////////////////// 77 inline void ProjectionScreen::set_frame_color(LVecBase4f const &frame_color); 91 15 get_frame_color 0 4 132 33 ProjectionScreen::get_frame_color 0 1 27 381 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::get_frame_color // Access: Published // Description: Returns the color the screen will be painted at the // portions outside of the lens' frustum. See // set_frame_color(). //////////////////////////////////////////////////////////////////// 71 inline LVecBase4f const &ProjectionScreen::get_frame_color(void) const; 92 18 set_auto_recompute 0 4 132 36 ProjectionScreen::set_auto_recompute 0 1 28 516 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::set_auto_recompute // Access: Published // Description: Sets the auto_recompute flag. When this is true, // the ProjectionScreen will always be recomputed if // necessary before the frame is drawn; when it is // false, an explicit call to recompute_if_stale() may // be required. //////////////////////////////////////////////////////////////////// 70 inline void ProjectionScreen::set_auto_recompute(bool auto_recompute); 93 18 get_auto_recompute 0 4 132 36 ProjectionScreen::get_auto_recompute 0 1 29 519 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::set_auto_recompute // Access: Published // Description: Returns the auto_recompute flag. When this is true, // the ProjectionScreen will always be recomputed if // necessary before the frame is drawn; when it is // false, an explicit call to recompute_if_stale() may // be required. //////////////////////////////////////////////////////////////////// 61 inline bool ProjectionScreen::get_auto_recompute(void) const; 94 9 recompute 0 4 132 27 ProjectionScreen::recompute 0 1 30 697 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::recompute // Access: Published // Description: Recomputes all the UV's for geometry below the // ProjectionScreen node, as if the texture were // projected from the associated projector. // // This function is normally called automatically // whenever the relevant properties change, so it should // not normally need to be called directly by the user. // However, it does no harm to call this if there is any // doubt. //////////////////////////////////////////////////////////////////// 39 void ProjectionScreen::recompute(void); 95 15 get_last_screen 0 4 132 33 ProjectionScreen::get_last_screen 0 1 31 587 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::get_last_screen // Access: Published // Description: Returns an UpdateSeq corresponding to the last time a // screen mesh was generated for the ProjectionScreen. // Each time generate_screen() is called, this number is // incremented; this allows other objects (like // NonlinearImager) to know when they need to recompute // themselves. //////////////////////////////////////////////////////////////////// 70 inline UpdateSeq const &ProjectionScreen::get_last_screen(void) const; 96 18 recompute_if_stale 0 4 132 36 ProjectionScreen::recompute_if_stale 0 2 32 33 1012 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::recompute_if_stale // Access: Published // Description: Calls recompute() only if the relative transform // between the ProjectionScreen and the projector has // changed, or if any other relevant property has // changed. Returns true if recomputed, false // otherwise. //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::recompute_if_stale // Access: Published // Description: Calls recompute() only if the relative transform // between the ProjectionScreen and the projector has // changed, or if any other relevant property has // changed. Returns true if recomputed, false // otherwise. //////////////////////////////////////////////////////////////////// 116 bool ProjectionScreen::recompute_if_stale(void); bool ProjectionScreen::recompute_if_stale(NodePath const &this_np); 97 14 get_class_type 0 4 132 32 ProjectionScreen::get_class_type 0 1 34 0 57 static TypeHandle ProjectionScreen::get_class_type(void); 98 15 NonlinearImager 0 4 134 32 NonlinearImager::NonlinearImager 0 1 35 228 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::Constructor // Access: Published // Description: //////////////////////////////////////////////////////////////////// 39 NonlinearImager::NonlinearImager(void); 99 16 ~NonlinearImager 0 4 134 33 NonlinearImager::~NonlinearImager 0 0 227 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::Destructor // Access: Published // Description: //////////////////////////////////////////////////////////////////// 40 NonlinearImager::~NonlinearImager(void); 100 10 add_screen 0 4 134 27 NonlinearImager::add_screen 0 2 36 37 1402 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::add_screen // Access: Published // This version of this method is deprecated and will // soon be removed. Use the version that takes two // parameters instead. //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::add_screen // Access: Published // Description: Adds a new ProjectionScreen to the list of screens // that will be processed by the NonlinearImager. Each // ProjectionScreen represents a view into the world. // It must be based on a linear camera (or whatever kind // of camera is respected by the graphics engine). // // Each ProjectionScreen object should already have some // screen geometry created. // // As each frame is rendered, an offscreen image will be // rendered from the source camera associated with each // ProjectionScreen, and the resulting image will be // applied to the screen geometry. // // The return value is the index number of the new // screen. //////////////////////////////////////////////////////////////////// 149 int NonlinearImager::add_screen(ProjectionScreen *screen); int NonlinearImager::add_screen(NodePath const &screen, basic_string< char > const &name); 101 11 find_screen 0 4 134 28 NonlinearImager::find_screen 0 1 38 389 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::find_screen // Access: Published // Description: Returns the index number of the first appearance of // the indicated screen within the imager's list, or -1 // if it does not appear. //////////////////////////////////////////////////////////////////// 63 int NonlinearImager::find_screen(NodePath const &screen) const; 102 13 remove_screen 0 4 134 30 NonlinearImager::remove_screen 0 1 39 314 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::remove_screen // Access: Published // Description: Removes the screen with the indicated index number // from the imager. //////////////////////////////////////////////////////////////////// 47 void NonlinearImager::remove_screen(int index); 103 18 remove_all_screens 0 4 134 35 NonlinearImager::remove_all_screens 0 1 40 271 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::remove_all_screens // Access: Published // Description: Removes all screens from the imager. //////////////////////////////////////////////////////////////////// 47 void NonlinearImager::remove_all_screens(void); 104 15 get_num_screens 0 4 134 32 NonlinearImager::get_num_screens 0 1 41 314 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::get_num_screens // Access: Published // Description: Returns the number of screens that have been added to // the imager. //////////////////////////////////////////////////////////////////// 49 int NonlinearImager::get_num_screens(void) const; 105 10 get_screen 0 4 134 27 NonlinearImager::get_screen 0 1 42 301 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::get_screen // Access: Published // Description: Returns the nth screen that has been added to the // imager. //////////////////////////////////////////////////////////////////// 54 NodePath NonlinearImager::get_screen(int index) const; 106 10 get_buffer 0 4 134 27 NonlinearImager::get_buffer 0 1 43 451 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::get_buffer // Access: Published // Description: Returns the offscreen buffer that is automatically // created for the nth projection screen. This may // return NULL if the screen is inactive or if it has // not been rendered yet. //////////////////////////////////////////////////////////////////// 61 GraphicsOutput *NonlinearImager::get_buffer(int index) const; 107 16 set_texture_size 0 4 134 33 NonlinearImager::set_texture_size 0 1 44 580 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::set_texture_size // Access: Published // Description: Sets the width and height of the texture used to // render the scene for the indicated screen. This must // be less than or equal to the window size, and it // should be a power of two. // // In general, the larger the texture, the greater the // detail of the rendered scene. //////////////////////////////////////////////////////////////////// 73 void NonlinearImager::set_texture_size(int index, int width, int height); 108 17 set_source_camera 0 4 134 34 NonlinearImager::set_source_camera 0 1 45 511 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::set_source_camera // Access: Published // Description: Specifies the camera that will be used to render the // image for this particular screen. // // The parameter must be a NodePath whose node is a // Camera. The camera itself indicates the scene that // is to be rendered. //////////////////////////////////////////////////////////////////// 82 void NonlinearImager::set_source_camera(int index, NodePath const &source_camera); 109 17 set_screen_active 0 4 134 34 NonlinearImager::set_screen_active 0 1 46 398 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::set_screen_active // Access: Published // Description: Sets the active flag on the indicated screen. If the // active flag is true, the screen will be used; // otherwise, it will not appear. //////////////////////////////////////////////////////////////////// 64 void NonlinearImager::set_screen_active(int index, bool active); 110 17 get_screen_active 0 4 134 34 NonlinearImager::get_screen_active 0 1 47 282 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::get_screen_active // Access: Published // Description: Returns the active flag on the indicated screen. //////////////////////////////////////////////////////////////////// 57 bool NonlinearImager::get_screen_active(int index) const; 111 10 add_viewer 0 4 134 27 NonlinearImager::add_viewer 0 1 48 995 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::add_viewer // Access: Published // Description: Adds the indicated DisplayRegion as a viewer into the // NonlinearImager room. The camera associated with the // DisplayRegion at the time add_viewer() is called is // used as the initial viewer camera; it may have a // nonlinear lens, like a fisheye or cylindrical lens. // // This sets up a special scene graph for this // DisplayRegion alone and sets up the DisplayRegion // with a specialty camera. If future changes to the // camera are desired, you should use the // set_viewer_camera() interface. // // All viewers must share the same GraphicsEngine. // // The return value is the index of the new viewer. //////////////////////////////////////////////////////////////////// 51 int NonlinearImager::add_viewer(DisplayRegion *dr); 112 11 find_viewer 0 4 134 28 NonlinearImager::find_viewer 0 1 49 371 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::find_viewer // Access: Published // Description: Returns the index number of the indicated // DisplayRegion within the list of viewers, or -1 if it // is not found. //////////////////////////////////////////////////////////////////// 58 int NonlinearImager::find_viewer(DisplayRegion *dr) const; 113 13 remove_viewer 0 4 134 30 NonlinearImager::remove_viewer 0 1 50 314 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::remove_viewer // Access: Published // Description: Removes the viewer with the indicated index number // from the imager. //////////////////////////////////////////////////////////////////// 47 void NonlinearImager::remove_viewer(int index); 114 18 remove_all_viewers 0 4 134 35 NonlinearImager::remove_all_viewers 0 1 51 271 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::remove_all_viewers // Access: Published // Description: Removes all viewers from the imager. //////////////////////////////////////////////////////////////////// 47 void NonlinearImager::remove_all_viewers(void); 115 17 set_viewer_camera 0 4 134 34 NonlinearImager::set_viewer_camera 0 1 52 956 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::set_viewer_camera // Access: Published // Description: Specifies the LensNode that is to serve as the // viewer for this screen. The relative position of // the LensNode to the NonlinearImager, as well as the // properties of the lens associated with the LensNode, // determines the UV's that will be assigned to the // geometry within the NonlinearImager. // // It is not necessary to call this except to change the // camera after a viewer has been added, since the // default is to use whatever camera is associated with // the DisplayRegion at the time the viewer is added. // // The NodePath must refer to a LensNode (or a Camera). //////////////////////////////////////////////////////////////////// 82 void NonlinearImager::set_viewer_camera(int index, NodePath const &viewer_camera); 116 17 get_viewer_camera 0 4 134 34 NonlinearImager::get_viewer_camera 0 1 53 335 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::get_viewer_camera // Access: Published // Description: Returns the NodePath to the LensNode that is to serve // as nth viewer for this screen. //////////////////////////////////////////////////////////////////// 61 NodePath NonlinearImager::get_viewer_camera(int index) const; 117 16 get_viewer_scene 0 4 134 33 NonlinearImager::get_viewer_scene 0 1 54 794 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::get_viewer_scene // Access: Published // Description: Returns a pointer to the root node of the internal // scene graph for the nth viewer, which is used to // render all of the screen meshes for this viewer. // // This is the scene graph in which the screen meshes // within the dark room have been flattened into the // appropriate transformation according to the viewer's // lens properties (and position relative to the // screens). It is this scene graph that is finally // rendered to the window. //////////////////////////////////////////////////////////////////// 60 NodePath NonlinearImager::get_viewer_scene(int index) const; 118 15 get_num_viewers 0 4 134 32 NonlinearImager::get_num_viewers 0 1 55 314 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::get_num_viewers // Access: Published // Description: Returns the number of viewers that have been added to // the imager. //////////////////////////////////////////////////////////////////// 49 int NonlinearImager::get_num_viewers(void) const; 119 10 get_viewer 0 4 134 27 NonlinearImager::get_viewer 0 1 56 317 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::get_viewer // Access: Published // Description: Returns the nth viewer's DisplayRegion that has been // added to the imager. //////////////////////////////////////////////////////////////////// 60 DisplayRegion *NonlinearImager::get_viewer(int index) const; 120 13 get_dark_room 0 4 134 30 NonlinearImager::get_dark_room 0 1 57 933 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::get_dark_room // Access: Published // Description: Returns the NodePath to the root of the dark room // scene. This is the scene in which all of the // ProjectionScreens and the viewer cameras reside. // It's a standalone scene with a few projection screens // arranged artfully around one or more viewers; it's so // named because it's a little virtual theater. // // Normally this scene is not rendered directly; it only // exists as an abstract concept, and to define the // relation between the ProjectionScreens and the // viewers. But it may be rendered to help visualize // the NonlinearImager's behavior. //////////////////////////////////////////////////////////////////// 52 NodePath NonlinearImager::get_dark_room(void) const; 121 19 get_graphics_engine 0 4 134 36 NonlinearImager::get_graphics_engine 0 1 58 348 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::get_graphics_engine // Access: Published // Description: Returns the GraphicsEngine that all of the viewers // added to the NonlinearImager have in common. //////////////////////////////////////////////////////////////////// 65 GraphicsEngine *NonlinearImager::get_graphics_engine(void) const; 122 9 recompute 0 4 134 26 NonlinearImager::recompute 0 1 59 277 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::recompute // Access: Published // Description: Forces a regeneration of all the mesh objects, etc. //////////////////////////////////////////////////////////////////// 38 void NonlinearImager::recompute(void); 123 11 OSphereLens 0 4 135 24 OSphereLens::OSphereLens 0 1 60 934 // Filename: oSphereLens.I // Created by: drose (25Feb11) // //////////////////////////////////////////////////////////////////// // // PANDA 3D SOFTWARE // Copyright (c) Carnegie Mellon University. All rights reserved. // // All use of this software is subject to the terms of the revised BSD // license. You should have received a copy of this license along // with this source code in a file named "LICENSE." // //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// // Function: OSphereLens::Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// // Function: OSphereLens::Copy Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// 38 inline OSphereLens::OSphereLens(void); 124 14 get_class_type 0 4 135 27 OSphereLens::get_class_type 0 1 61 0 52 static TypeHandle OSphereLens::get_class_type(void); 125 12 ~OSphereLens 0 4 135 25 OSphereLens::~OSphereLens 0 0 0 32 OSphereLens::~OSphereLens(void); 126 11 PSphereLens 0 4 136 24 PSphereLens::PSphereLens 0 1 62 934 // Filename: pSphereLens.I // Created by: drose (12Dec01) // //////////////////////////////////////////////////////////////////// // // PANDA 3D SOFTWARE // Copyright (c) Carnegie Mellon University. All rights reserved. // // All use of this software is subject to the terms of the revised BSD // license. You should have received a copy of this license along // with this source code in a file named "LICENSE." // //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// // Function: PSphereLens::Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// // Function: PSphereLens::Copy Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// 38 inline PSphereLens::PSphereLens(void); 127 14 get_class_type 0 4 136 27 PSphereLens::get_class_type 0 1 63 0 52 static TypeHandle PSphereLens::get_class_type(void); 128 12 ~PSphereLens 0 4 136 25 PSphereLens::~PSphereLens 0 0 0 32 PSphereLens::~PSphereLens(void); 63 1 14 Dtool_2YN4c_uw 0 7 3 137 66 14 Dtool_2YN4c_uw 715 // Filename: cylindricalLens.I // Created by: drose (12Dec01) // //////////////////////////////////////////////////////////////////// // // PANDA 3D SOFTWARE // Copyright (c) Carnegie Mellon University. All rights reserved. // // All use of this software is subject to the terms of the revised BSD // license. You should have received a copy of this license along // with this source code in a file named "LICENSE." // //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// // Function: CylindricalLens::Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// 0 2 14 Dtool_2YN4XUqH 0 7 4 139 0 14 Dtool_2YN4XUqH 0 0 3 14 Dtool_2YN41U_J 0 7 7 140 69 14 Dtool_2YN41U_J 707 // Filename: fisheyeLens.I // Created by: drose (12Dec01) // //////////////////////////////////////////////////////////////////// // // PANDA 3D SOFTWARE // Copyright (c) Carnegie Mellon University. All rights reserved. // // All use of this software is subject to the terms of the revised BSD // license. You should have received a copy of this license along // with this source code in a file named "LICENSE." // //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// // Function: FisheyeLens::Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// 0 4 14 Dtool_2YN4JEaS 0 7 8 139 0 14 Dtool_2YN4JEaS 0 0 5 14 Dtool_2YN4VUBz 0 7 12 142 0 14 Dtool_2YN4VUBz 229 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::Constructor // Access: Published // Description: //////////////////////////////////////////////////////////////////// 1 4 name 1 141 6 14 Dtool_2YN4FAAN 0 7 12 142 0 14 Dtool_2YN4FAAN 229 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::Constructor // Access: Published // Description: //////////////////////////////////////////////////////////////////// 0 7 14 Dtool_2YN4KtME 0 4 13 146 0 14 Dtool_2YN4KtME 681 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::set_projector // Access: Published // Description: Specifies the LensNode that is to serve as the // projector for this screen. The relative position of // the LensNode to the ProjectionScreen, as well as the // properties of the lens associated with the LensNode, // determines the UV's that will be assigned to the // geometry within the ProjectionScreen. // // The NodePath must refer to a LensNode (or a Camera). //////////////////////////////////////////////////////////////////// 2 4 this 3 142 9 projector 1 143 8 14 Dtool_2YN4qx3t 0 6 14 143 0 14 Dtool_2YN4qx3t 884 // Filename: projectionScreen.I // Created by: drose (11Dec01) // //////////////////////////////////////////////////////////////////// // // PANDA 3D SOFTWARE // Copyright (c) Carnegie Mellon University. All rights reserved. // // All use of this software is subject to the terms of the revised BSD // license. You should have received a copy of this license along // with this source code in a file named "LICENSE." // //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::get_projector // Access: Published // Description: Returns the NodePath to the LensNode that is to serve // as the projector for this screen, or empty if no // projector is associated. //////////////////////////////////////////////////////////////////// 1 4 this 3 147 9 14 Dtool_2YN4sze7 0 4 15 146 0 14 Dtool_2YN4sze7 320 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::clear_undist_lut // Access: Published // Description: Removes the distortion lookup table from the // projector, if specified. //////////////////////////////////////////////////////////////////// 1 4 this 3 142 10 14 Dtool_2YN4_oAd 0 4 16 146 0 14 Dtool_2YN4_oAd 625 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::set_undist_lut // Access: Published // Description: Applies a distortion lookup table to the // projector. This mapping warps the lens effect by // passing each ray through an indirection table: the // point (u,v) in the indicated lookup table stores the // actual (u,v) that the lens produces. // // This does not affect the operation of // generate_screen(). //////////////////////////////////////////////////////////////////// 2 4 this 3 142 10 undist_lut 1 149 11 14 Dtool_2YN4S1_H 0 6 17 152 0 14 Dtool_2YN4S1_H 348 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::has_undist_lut // Access: Published // Description: Returns true if a valid distortion lookup table was // provided via set_undist_lut(), false otherwise. //////////////////////////////////////////////////////////////////// 1 4 this 3 147 12 14 Dtool_2YN4a2UB 0 6 18 149 0 14 Dtool_2YN4a2UB 323 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::get_undist_lut // Access: Published // Description: Returns the distortion lookup table provided via // set_undist_lut(), if any. //////////////////////////////////////////////////////////////////// 1 4 this 3 147 13 14 Dtool_2YN4DKPY 0 7 19 156 0 14 Dtool_2YN4DKPY 1745 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::generate_screen // Access: Published // Description: Synthesizes a polygon mesh based on the projection // area of the indicated projector. This generates and // returns a new GeomNode but does not automatically // parent it to the ProjectionScreen node; see // regenerate_screen(). // // The specified projector need not be the same as the // projector given to the ProjectionScreen with // set_projector() (although this is often what you // want). // // num_x_verts and num_y_verts specify the number of // vertices to make in the grid across the horizontal // and vertical dimension of the projector, // respectively; distance represents the approximate // distance of the screen from the lens center. // // The fill_ratio parameter specifies the fraction of // the image to cover. If it is 1.0, the entire image // is shown full-size; if it is 0.9, 10% of the image // around the edges is not part of the grid (and the // grid is drawn smaller by the same 10%). This is // intended to work around graphics drivers that tend to // show dark edges or other unsatisfactory artifacts // around the edges of textures: render the texture // larger than necessary by a certain fraction, and make // the screen smaller by the inverse fraction. //////////////////////////////////////////////////////////////////// 7 4 this 3 142 9 projector 1 143 11 screen_name 1 141 11 num_x_verts 1 154 11 num_y_verts 1 154 8 distance 1 155 10 fill_ratio 1 155 14 14 Dtool_2YN4asPG 0 4 20 146 0 14 Dtool_2YN4asPG 391 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::regenerate_screen // Access: Published // Description: Removes all the children from the ProjectionScreen // node, and adds the newly generated child returned by // generate_screen(). //////////////////////////////////////////////////////////////////// 7 4 this 3 142 9 projector 1 143 11 screen_name 1 141 11 num_x_verts 1 154 11 num_y_verts 1 154 8 distance 1 155 10 fill_ratio 1 155 15 14 Dtool_2YN4G914 0 7 21 157 0 14 Dtool_2YN4G914 1049 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::make_flat_mesh // Access: Published // Description: Generates a deep copy of the hierarchy at the // ProjectionScreen node and below, with vertices // flattened into two dimensions as if they were seen by // the indicated camera node. // // This is useful for rendering an image as seen through // a non-linear lens. The resulting mesh will have // vertices in the range [-1, 1] in both x and y, and // may be then rendered with an ordinary orthographic // lens, to generate the effect of seeing the image // through the specified non-linear lens. // // The returned node has no parent; it is up to the // caller to parent it somewhere or store it so that it // does not get dereferenced and deleted. //////////////////////////////////////////////////////////////////// 3 4 this 3 142 7 this_np 1 143 6 camera 1 143 16 14 Dtool_2YN4ilGE 0 4 22 146 0 14 Dtool_2YN4ilGE 551 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::set_texcoord_name // Access: Published // Description: Specifies the name of the texture coordinates that // are generated by this particular ProjectionScreen. // This can be used in the presence of multitexturing to // compute the UV's for just a subset of all of the // active stages of the multitexture pipeline. //////////////////////////////////////////////////////////////////// 2 4 this 3 142 13 texcoord_name 1 141 17 14 Dtool_2YN4d3gx 0 6 23 141 0 14 Dtool_2YN4d3gx 403 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::get_texcoord_name // Access: Published // Description: Returns the name of the texture coordinates that // will be generated by this particular // ProjectionScreen, as set by set_texcoord_name(). //////////////////////////////////////////////////////////////////// 1 4 this 3 147 18 14 Dtool_2YN4xsWS 0 4 24 146 0 14 Dtool_2YN4xsWS 777 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::set_invert_uvs // Access: Published // Description: Some OpenGL graphics drivers are known to invert the // framebuffer image when they copy it to texture. // (This is arguably a problem with the OpenGL spec, // which seems to be unclear about the proper ordering // of pixels in this operation.) // // In any case, set this true to compensate for this // effect by inverting the UV's of the projection // screen. The default is taken from the Configrc // variable project-invert-uvs. //////////////////////////////////////////////////////////////////// 2 4 this 3 142 10 invert_uvs 1 152 19 14 Dtool_2YN4SQ8g 0 6 25 152 0 14 Dtool_2YN4SQ8g 387 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::get_invert_uvs // Access: Published // Description: Returns whether this screen is compensating for a // graphics driver inverting the framebuffer image. See // set_invert_uvs(). //////////////////////////////////////////////////////////////////// 1 4 this 3 147 20 14 Dtool_2YN4Z7uB 0 4 26 146 0 14 Dtool_2YN4Z7uB 617 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::set_texcoord_3d // Access: Published // Description: Set this true to force 3-D texture coordinates to be // created for the geometry. When this is true and the // geometry has only 2-D texture coordinates, those // texture coordinates are dumped in favor of 3-D // coordinates. When this is false, whatever texture // coordinates already exist are preserved as-is. //////////////////////////////////////////////////////////////////// 2 4 this 3 142 11 texcoord_3d 1 152 21 14 Dtool_2YN4t75B 0 6 27 152 0 14 Dtool_2YN4t75B 255 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::get_texcoord_3d // Access: Published // Description: See set_texcoord_3d(). //////////////////////////////////////////////////////////////////// 1 4 this 3 147 22 14 Dtool_2YN4dO6S 0 4 28 146 0 14 Dtool_2YN4dO6S 811 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::set_vignette_on // Access: Published // Description: Specifies whether vertex-based vignetting should be // on. When this is enabled, vertex color will be set // on the screen vertices to color the screen two // distinct colors, usually white and black, for the // parts of the screen in front of and outside the lens' // frustum, respectively. When this is not enabled, the // screen color will be left alone. // // This effect generally looks terrible, but it does // at least make the boundaries of the lens clear. //////////////////////////////////////////////////////////////////// 2 4 this 3 142 11 vignette_on 1 152 23 14 Dtool_2YN4VhFT 0 6 29 152 0 14 Dtool_2YN4VhFT 337 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::get_vignette_on // Access: Published // Description: Returns true if vertex-based vignetting is on, false // otherwise. See set_vignette_on(). //////////////////////////////////////////////////////////////////// 1 4 this 3 147 24 14 Dtool_2YN4CmW1 0 4 30 146 0 14 Dtool_2YN4CmW1 528 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::set_vignette_color // Access: Published // Description: Specifies the color the screen will be painted at the // portions outside of the lens' frustum; i.e. where the // lens can't see it or illuminate it. This color is // only used if the vignette_on flag is true; see // set_vignette_on(). //////////////////////////////////////////////////////////////////// 2 4 this 3 142 14 vignette_color 1 158 25 14 Dtool_2YN4SAXj 0 6 31 158 0 14 Dtool_2YN4SAXj 387 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::get_vignette_color // Access: Published // Description: Returns the color the screen will be painted at the // portions outside of the lens' frustum. See // set_vignette_color(). //////////////////////////////////////////////////////////////////// 1 4 this 3 147 26 14 Dtool_2YN4Tjpi 0 4 32 146 0 14 Dtool_2YN4Tjpi 525 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::set_frame_color // Access: Published // Description: Specifies the color the screen will be painted at the // portions outside of the lens' frustum; i.e. where the // lens can't see it or illuminate it. This color is // only used if the vignette_on flag is true; see // set_vignette_on(). //////////////////////////////////////////////////////////////////// 2 4 this 3 142 11 frame_color 1 158 27 14 Dtool_2YN4ViMC 0 6 33 158 0 14 Dtool_2YN4ViMC 381 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::get_frame_color // Access: Published // Description: Returns the color the screen will be painted at the // portions outside of the lens' frustum. See // set_frame_color(). //////////////////////////////////////////////////////////////////// 1 4 this 3 147 28 14 Dtool_2YN4VAVi 0 4 34 146 0 14 Dtool_2YN4VAVi 516 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::set_auto_recompute // Access: Published // Description: Sets the auto_recompute flag. When this is true, // the ProjectionScreen will always be recomputed if // necessary before the frame is drawn; when it is // false, an explicit call to recompute_if_stale() may // be required. //////////////////////////////////////////////////////////////////// 2 4 this 3 142 14 auto_recompute 1 152 29 14 Dtool_2YN4ulgE 0 6 35 152 0 14 Dtool_2YN4ulgE 519 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::set_auto_recompute // Access: Published // Description: Returns the auto_recompute flag. When this is true, // the ProjectionScreen will always be recomputed if // necessary before the frame is drawn; when it is // false, an explicit call to recompute_if_stale() may // be required. //////////////////////////////////////////////////////////////////// 1 4 this 3 147 30 14 Dtool_2YN49AIQ 0 4 36 146 0 14 Dtool_2YN49AIQ 697 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::recompute // Access: Published // Description: Recomputes all the UV's for geometry below the // ProjectionScreen node, as if the texture were // projected from the associated projector. // // This function is normally called automatically // whenever the relevant properties change, so it should // not normally need to be called directly by the user. // However, it does no harm to call this if there is any // doubt. //////////////////////////////////////////////////////////////////// 1 4 this 3 142 31 14 Dtool_2YN4rlzx 0 6 37 161 0 14 Dtool_2YN4rlzx 587 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::get_last_screen // Access: Published // Description: Returns an UpdateSeq corresponding to the last time a // screen mesh was generated for the ProjectionScreen. // Each time generate_screen() is called, this number is // incremented; this allows other objects (like // NonlinearImager) to know when they need to recompute // themselves. //////////////////////////////////////////////////////////////////// 1 4 this 3 147 32 14 Dtool_2YN4LVVZ 0 6 38 152 0 14 Dtool_2YN4LVVZ 505 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::recompute_if_stale // Access: Published // Description: Calls recompute() only if the relative transform // between the ProjectionScreen and the projector has // changed, or if any other relevant property has // changed. Returns true if recomputed, false // otherwise. //////////////////////////////////////////////////////////////////// 1 4 this 3 142 33 14 Dtool_2YN4KXUR 0 6 38 152 0 14 Dtool_2YN4KXUR 505 //////////////////////////////////////////////////////////////////// // Function: ProjectionScreen::recompute_if_stale // Access: Published // Description: Calls recompute() only if the relative transform // between the ProjectionScreen and the projector has // changed, or if any other relevant property has // changed. Returns true if recomputed, false // otherwise. //////////////////////////////////////////////////////////////////// 2 4 this 3 142 7 this_np 1 143 34 14 Dtool_2YN4k7Q4 0 7 39 139 0 14 Dtool_2YN4k7Q4 0 0 35 14 Dtool_2YN4_PCJ 0 7 41 164 99 14 Dtool_2YN4_PCJ 228 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::Constructor // Access: Published // Description: //////////////////////////////////////////////////////////////////// 0 36 14 Dtool_2YN4Id7Z 0 6 43 154 0 14 Dtool_2YN4Id7Z 1020 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::add_screen // Access: Published // Description: Adds a new ProjectionScreen to the list of screens // that will be processed by the NonlinearImager. Each // ProjectionScreen represents a view into the world. // It must be based on a linear camera (or whatever kind // of camera is respected by the graphics engine). // // Each ProjectionScreen object should already have some // screen geometry created. // // As each frame is rendered, an offscreen image will be // rendered from the source camera associated with each // ProjectionScreen, and the resulting image will be // applied to the screen geometry. // // The return value is the index number of the new // screen. //////////////////////////////////////////////////////////////////// 3 4 this 3 164 6 screen 1 143 4 name 1 141 37 14 Dtool_2YN4nWhU 0 6 43 154 0 14 Dtool_2YN4nWhU 380 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::add_screen // Access: Published // This version of this method is deprecated and will // soon be removed. Use the version that takes two // parameters instead. //////////////////////////////////////////////////////////////////// 2 4 this 3 164 6 screen 1 142 38 14 Dtool_2YN40gaK 0 6 44 154 0 14 Dtool_2YN40gaK 389 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::find_screen // Access: Published // Description: Returns the index number of the first appearance of // the indicated screen within the imager's list, or -1 // if it does not appear. //////////////////////////////////////////////////////////////////// 2 4 this 3 165 6 screen 1 143 39 14 Dtool_2YN4LstH 0 4 45 146 0 14 Dtool_2YN4LstH 314 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::remove_screen // Access: Published // Description: Removes the screen with the indicated index number // from the imager. //////////////////////////////////////////////////////////////////// 2 4 this 3 164 5 index 1 154 40 14 Dtool_2YN40pJi 0 4 46 146 0 14 Dtool_2YN40pJi 271 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::remove_all_screens // Access: Published // Description: Removes all screens from the imager. //////////////////////////////////////////////////////////////////// 1 4 this 3 164 41 14 Dtool_2YN42sj0 0 6 47 154 0 14 Dtool_2YN42sj0 314 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::get_num_screens // Access: Published // Description: Returns the number of screens that have been added to // the imager. //////////////////////////////////////////////////////////////////// 1 4 this 3 165 42 14 Dtool_2YN44h98 0 7 48 167 0 14 Dtool_2YN44h98 301 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::get_screen // Access: Published // Description: Returns the nth screen that has been added to the // imager. //////////////////////////////////////////////////////////////////// 2 4 this 3 165 5 index 1 154 43 14 Dtool_2YN4MN_0 0 7 49 169 0 14 Dtool_2YN4MN_0 451 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::get_buffer // Access: Published // Description: Returns the offscreen buffer that is automatically // created for the nth projection screen. This may // return NULL if the screen is inactive or if it has // not been rendered yet. //////////////////////////////////////////////////////////////////// 2 4 this 3 165 5 index 1 154 44 14 Dtool_2YN4Rw3d 0 4 50 146 0 14 Dtool_2YN4Rw3d 580 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::set_texture_size // Access: Published // Description: Sets the width and height of the texture used to // render the scene for the indicated screen. This must // be less than or equal to the window size, and it // should be a power of two. // // In general, the larger the texture, the greater the // detail of the rendered scene. //////////////////////////////////////////////////////////////////// 4 4 this 3 164 5 index 1 154 5 width 1 154 6 height 1 154 45 14 Dtool_2YN4k8BW 0 4 51 146 0 14 Dtool_2YN4k8BW 511 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::set_source_camera // Access: Published // Description: Specifies the camera that will be used to render the // image for this particular screen. // // The parameter must be a NodePath whose node is a // Camera. The camera itself indicates the scene that // is to be rendered. //////////////////////////////////////////////////////////////////// 3 4 this 3 164 5 index 1 154 13 source_camera 1 143 46 14 Dtool_2YN40keX 0 4 52 146 0 14 Dtool_2YN40keX 398 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::set_screen_active // Access: Published // Description: Sets the active flag on the indicated screen. If the // active flag is true, the screen will be used; // otherwise, it will not appear. //////////////////////////////////////////////////////////////////// 3 4 this 3 164 5 index 1 154 6 active 1 152 47 14 Dtool_2YN4QBpp 0 6 53 152 0 14 Dtool_2YN4QBpp 282 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::get_screen_active // Access: Published // Description: Returns the active flag on the indicated screen. //////////////////////////////////////////////////////////////////// 2 4 this 3 165 5 index 1 154 48 14 Dtool_2YN4eOfi 0 6 54 154 0 14 Dtool_2YN4eOfi 995 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::add_viewer // Access: Published // Description: Adds the indicated DisplayRegion as a viewer into the // NonlinearImager room. The camera associated with the // DisplayRegion at the time add_viewer() is called is // used as the initial viewer camera; it may have a // nonlinear lens, like a fisheye or cylindrical lens. // // This sets up a special scene graph for this // DisplayRegion alone and sets up the DisplayRegion // with a specialty camera. If future changes to the // camera are desired, you should use the // set_viewer_camera() interface. // // All viewers must share the same GraphicsEngine. // // The return value is the index of the new viewer. //////////////////////////////////////////////////////////////////// 2 4 this 3 164 2 dr 1 170 49 14 Dtool_2YN4bheq 0 6 55 154 0 14 Dtool_2YN4bheq 371 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::find_viewer // Access: Published // Description: Returns the index number of the indicated // DisplayRegion within the list of viewers, or -1 if it // is not found. //////////////////////////////////////////////////////////////////// 2 4 this 3 165 2 dr 1 170 50 14 Dtool_2YN4Tqe9 0 4 56 146 0 14 Dtool_2YN4Tqe9 314 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::remove_viewer // Access: Published // Description: Removes the viewer with the indicated index number // from the imager. //////////////////////////////////////////////////////////////////// 2 4 this 3 164 5 index 1 154 51 14 Dtool_2YN4mtgF 0 4 57 146 0 14 Dtool_2YN4mtgF 271 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::remove_all_viewers // Access: Published // Description: Removes all viewers from the imager. //////////////////////////////////////////////////////////////////// 1 4 this 3 164 52 14 Dtool_2YN4r03_ 0 4 58 146 0 14 Dtool_2YN4r03_ 956 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::set_viewer_camera // Access: Published // Description: Specifies the LensNode that is to serve as the // viewer for this screen. The relative position of // the LensNode to the NonlinearImager, as well as the // properties of the lens associated with the LensNode, // determines the UV's that will be assigned to the // geometry within the NonlinearImager. // // It is not necessary to call this except to change the // camera after a viewer has been added, since the // default is to use whatever camera is associated with // the DisplayRegion at the time the viewer is added. // // The NodePath must refer to a LensNode (or a Camera). //////////////////////////////////////////////////////////////////// 3 4 this 3 164 5 index 1 154 13 viewer_camera 1 143 53 14 Dtool_2YN4m1Ke 0 7 59 167 0 14 Dtool_2YN4m1Ke 335 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::get_viewer_camera // Access: Published // Description: Returns the NodePath to the LensNode that is to serve // as nth viewer for this screen. //////////////////////////////////////////////////////////////////// 2 4 this 3 165 5 index 1 154 54 14 Dtool_2YN4GLn8 0 7 60 167 0 14 Dtool_2YN4GLn8 794 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::get_viewer_scene // Access: Published // Description: Returns a pointer to the root node of the internal // scene graph for the nth viewer, which is used to // render all of the screen meshes for this viewer. // // This is the scene graph in which the screen meshes // within the dark room have been flattened into the // appropriate transformation according to the viewer's // lens properties (and position relative to the // screens). It is this scene graph that is finally // rendered to the window. //////////////////////////////////////////////////////////////////// 2 4 this 3 165 5 index 1 154 55 14 Dtool_2YN4DQFt 0 6 61 154 0 14 Dtool_2YN4DQFt 314 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::get_num_viewers // Access: Published // Description: Returns the number of viewers that have been added to // the imager. //////////////////////////////////////////////////////////////////// 1 4 this 3 165 56 14 Dtool_2YN4C4VF 0 7 62 170 0 14 Dtool_2YN4C4VF 317 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::get_viewer // Access: Published // Description: Returns the nth viewer's DisplayRegion that has been // added to the imager. //////////////////////////////////////////////////////////////////// 2 4 this 3 165 5 index 1 154 57 14 Dtool_2YN4oAhd 0 7 63 167 0 14 Dtool_2YN4oAhd 933 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::get_dark_room // Access: Published // Description: Returns the NodePath to the root of the dark room // scene. This is the scene in which all of the // ProjectionScreens and the viewer cameras reside. // It's a standalone scene with a few projection screens // arranged artfully around one or more viewers; it's so // named because it's a little virtual theater. // // Normally this scene is not rendered directly; it only // exists as an abstract concept, and to define the // relation between the ProjectionScreens and the // viewers. But it may be rendered to help visualize // the NonlinearImager's behavior. //////////////////////////////////////////////////////////////////// 1 4 this 3 165 58 14 Dtool_2YN4jAJ5 0 7 64 173 0 14 Dtool_2YN4jAJ5 348 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::get_graphics_engine // Access: Published // Description: Returns the GraphicsEngine that all of the viewers // added to the NonlinearImager have in common. //////////////////////////////////////////////////////////////////// 1 4 this 3 165 59 14 Dtool_2YN4nMhO 0 4 65 146 0 14 Dtool_2YN4nMhO 277 //////////////////////////////////////////////////////////////////// // Function: NonlinearImager::recompute // Access: Published // Description: Forces a regeneration of all the mesh objects, etc. //////////////////////////////////////////////////////////////////// 1 4 this 3 164 60 14 Dtool_2YN4Ad0P 0 7 67 174 125 14 Dtool_2YN4Ad0P 707 // Filename: oSphereLens.I // Created by: drose (25Feb11) // //////////////////////////////////////////////////////////////////// // // PANDA 3D SOFTWARE // Copyright (c) Carnegie Mellon University. All rights reserved. // // All use of this software is subject to the terms of the revised BSD // license. You should have received a copy of this license along // with this source code in a file named "LICENSE." // //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// // Function: OSphereLens::Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// 0 61 14 Dtool_2YN4ZnTK 0 7 68 139 0 14 Dtool_2YN4ZnTK 0 0 62 14 Dtool_2YN4ggVT 0 7 71 175 128 14 Dtool_2YN4ggVT 707 // Filename: pSphereLens.I // Created by: drose (12Dec01) // //////////////////////////////////////////////////////////////////// // // PANDA 3D SOFTWARE // Copyright (c) Carnegie Mellon University. All rights reserved. // // All use of this software is subject to the terms of the revised BSD // license. You should have received a copy of this license along // with this source code in a file named "LICENSE." // //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// // Function: PSphereLens::Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// 0 63 14 Dtool_2YN4SRVK 0 7 72 139 0 14 Dtool_2YN4SRVK 0 0 47 129 15 CylindricalLens 0 141313 15 CylindricalLens 15 CylindricalLens 0 0 0 1 64 66 0 1 65 0 0 1 0 130 0 0 0 0 1051 //////////////////////////////////////////////////////////////////// // Class : CylindricalLens // Description : A cylindrical lens. This is the kind of lens // generally used for extremely wide panoramic shots. // It behaves like a normal perspective lens in the // vertical direction, but it is non-linear in the // horizontal dimension: a point on the film corresponds // to a point in space in linear proportion to its angle // to the camera, not to its straight-line distance from // the center. // // This allows up to 360 degree lenses in the horizontal // dimension, with relatively little distortion. The // distortion is not very apparent between two // relatively nearby points on the film, but it becomes // increasingly evident as you compare points widely // spaced on the film. //////////////////////////////////////////////////////////////////// 130 4 Lens 0 2049 4 Lens 4 Lens 0 0 0 0 0 0 0 0 0 0 0 0 668 //////////////////////////////////////////////////////////////////// // Class : Lens // Description : A base class for any number of different kinds of // lenses, linear and otherwise. Presently, this // includes perspective and orthographic lenses. // // A Lens object is the main part of a Camera node, // which defines the fundamental interface to // point-of-view for rendering. Lenses are also used in // other contexts, however; for instance, a Spotlight is // also defined using a lens. //////////////////////////////////////////////////////////////////// 131 11 FisheyeLens 0 141313 11 FisheyeLens 11 FisheyeLens 0 0 0 1 67 69 0 1 68 0 0 1 0 130 0 0 0 0 476 //////////////////////////////////////////////////////////////////// // Class : FisheyeLens // Description : A fisheye lens. This nonlinear lens introduces a // spherical distortion to the image, which is minimal // at small angles from the lens, and increases at // larger angles from the lens. The field of view may // extend to 360 degrees. //////////////////////////////////////////////////////////////////// 132 16 ProjectionScreen 0 75777 16 ProjectionScreen 16 ProjectionScreen 0 0 0 1 70 0 0 27 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 0 0 1 0 133 0 0 0 0 1378 //////////////////////////////////////////////////////////////////// // Class : ProjectionScreen // Description : A ProjectionScreen implements a simple system for // projective texturing. The ProjectionScreen node is // the parent of a hierarchy of geometry that is // considered a "screen"; the ProjectionScreen will // automatically recompute all the UV's (for a // particular texture stage) on its subordinate geometry // according to the relative position and lens // parameters of the indicated LensNode. // // All this does is recompute UV's; the caller is // responsible for applying the appropriate texture(s) // to the geometry. // // This does not take advantage of any hardware-assisted // projective texturing; all of the UV's are computed in // the CPU. (Use NodePath::project_texture() to enable // hardware-assisted projective texturing.) However, // the ProjectionScreen interface does support any kind // of lens, linear or nonlinear, that might be defined // using the Lens interface, including fisheye and // cylindrical lenses. //////////////////////////////////////////////////////////////////// 133 9 PandaNode 0 2049 9 PandaNode 9 PandaNode 0 0 0 0 0 0 0 0 0 0 0 0 374 //////////////////////////////////////////////////////////////////// // Class : PandaNode // Description : A basic node of the scene graph or data graph. This // is the base class of all specialized nodes, and also // serves as a generic node with no special properties. //////////////////////////////////////////////////////////////////// 134 15 NonlinearImager 0 26625 15 NonlinearImager 15 NonlinearImager 0 0 0 1 98 99 0 23 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 3 176 177 178 0 0 0 0 3171 //////////////////////////////////////////////////////////////////// // Class : NonlinearImager // Description : This class object combines the rendered output of a // 3-d from one or more linear (e.g. perspective) // cameras, as seen through a single, possibly nonlinear // camera. // // This can be used to generate real-time imagery of a // 3-d scene using a nonlinear camera, for instance a // fisheye camera, even though the underlying graphics // engine may only support linear cameras. It can also // pre-distort imagery to compensate for off-axis // projectors, and/or curved screens of any complexity. // // // A NonlinearImager may be visualized as a dark room // into which a number of projection screens have been // placed, of arbitrary size and shape and at any // arbitrary position and orientation to each other. // Onto each of these screens is projected the view as // seen by a normal perspective camera that exists in // the world (that is, under render). // // There also exist in the room one or more (possibly // nonlinear) cameras, called viewers, that observe // these screens. The image of the projection screens // seen by each viewer is finally displayed on the // viewer's associated DisplayRegion. By placing the // viewer(s) appropriately relative to the screens, and // by choosing suitable lens properties for the // viewer(s), you can achieve a wide variety of // distortion effects. // // // There are several different LensNode (Camera) objects // involved at each stage in the process. To help keep // them all straight, different words are used to refer // to each different kind of Camera used within this // object. The camera(s) under render, that capture the // original view of the world to be projected onto the // screens, are called source cameras, and are set per // screen via set_source_camera(). The LensNode that is // associated with each screen to project the image as // seen from the screen's source camera is called a // projector; these are set via the // ProjectionScreen::set_projector() interface. // Finally, the cameras that view the whole // configuration of screens are called viewers; each of // these is associated with a DisplayRegion, and they // are set via set_viewer_camera(). // // Of all these lenses, only the source cameras must use // linear (that is, perspective or orthographic) lenses. // The projectors and viewers may be any arbitrary lens, // linear or otherwise. //////////////////////////////////////////////////////////////////// 135 11 OSphereLens 0 141313 11 OSphereLens 11 OSphereLens 0 0 0 1 123 125 0 1 124 0 0 1 0 130 0 0 0 0 651 //////////////////////////////////////////////////////////////////// // Class : OSphereLens // Description : A OSphereLens is a special nonlinear lens that // doesn't correspond to any real physical lenses. It's // primarily useful for generating 360-degree wraparound // images while avoiding the distortion associated with // fisheye images. // // A OSphereLens is similar to a Cylindrical lens and // PSphereLens, except that it is orthographic in the // vertical direction. //////////////////////////////////////////////////////////////////// 136 11 PSphereLens 0 141313 11 PSphereLens 11 PSphereLens 0 0 0 1 126 128 0 1 127 0 0 1 0 130 0 0 0 0 938 //////////////////////////////////////////////////////////////////// // Class : PSphereLens // Description : A PSphereLens is a special nonlinear lens that // doesn't correspond to any real physical lenses. It's // primarily useful for generating 360-degree wraparound // images while avoiding the distortion associated with // fisheye images. // // A PSphereLens is similar to a cylindrical lens, // except it is also curved in the vertical direction. // This allows it to extend to both poles in the // vertical direction. The mapping is similar to what // many modeling packages call a sphere mapping: the x // coordinate is proportional to azimuth, while the y // coordinate is proportional to altitude. //////////////////////////////////////////////////////////////////// 137 17 CylindricalLens * 0 8576 17 CylindricalLens * 17 CylindricalLens * 0 0 129 0 0 0 0 0 0 0 0 0 0 138 10 TypeHandle 0 2048 10 TypeHandle 10 TypeHandle 0 0 0 0 0 0 0 0 0 0 0 0 1098 //////////////////////////////////////////////////////////////////// // Class : TypeHandle // Description : TypeHandle is the identifier used to differentiate // C++ class types. Any C++ classes that inherit from // some base class, and must be differentiated at run // time, should store a static TypeHandle object that // can be queried through a static member function // named get_class_type(). Most of the time, it is also // desirable to inherit from TypedObject, which provides // some virtual functions to return the TypeHandle for a // particular instance. // // At its essence, a TypeHandle is simply a unique // identifier that is assigned by the TypeRegistry. The // TypeRegistry stores a tree of TypeHandles, so that // ancestry of a particular type may be queried, and the // type name may be retrieved for run-time display. //////////////////////////////////////////////////////////////////// 139 12 TypeHandle * 0 8576 12 TypeHandle * 12 TypeHandle * 0 0 138 0 0 0 0 0 0 0 0 0 0 140 13 FisheyeLens * 0 8576 13 FisheyeLens * 13 FisheyeLens * 0 0 131 0 0 0 0 0 0 0 0 0 0 141 13 atomic string 0 2 13 atomic string 13 atomic string 0 7 0 0 0 0 0 0 0 0 0 0 0 142 18 ProjectionScreen * 0 8576 18 ProjectionScreen * 18 ProjectionScreen * 0 0 132 0 0 0 0 0 0 0 0 0 0 143 16 NodePath const * 0 8576 16 NodePath const * 16 NodePath const * 0 0 144 0 0 0 0 0 0 0 0 0 0 144 14 NodePath const 0 8832 14 NodePath const 14 NodePath const 0 0 145 0 0 0 0 0 0 0 0 0 0 145 8 NodePath 0 2048 8 NodePath 8 NodePath 0 0 0 0 0 0 0 2 179 180 0 0 0 0 4938 // // A NodePath is the fundamental unit of high-level interaction with // the scene graph. It encapsulates the complete path down to a node // from some other node, usually the root of the scene graph. This is // used to resolve ambiguities associated with instancing. // // NodePath also contains a number of handy high-level methods for // common scene-graph manipulations, such as reparenting, and common // state changes, such as repositioning. // // There are also a number of NodePath methods for finding nodes deep // within the tree by name or by type. These take a path string, // which at its simplest consists of a series of node names separated // by slashes, like a directory pathname. // // Each component of the path string may optionally consist of one of // the following special names, instead of a node name: // // * -- matches exactly one node, with any name. // ** -- matches any sequence of zero or more nodes. // +typename -- matches any node that is or derives from the given type. // -typename -- matches any node that is the given type exactly. // =tag -- matches any node that has the indicated tag. // =tag=value -- matches any node whose tag matches the indicated value. // // Furthermore, a node name may itself contain standard filename // globbing characters, like *, ?, and [a-z], that will be accepted as // a partial match. (In fact, the '*' special name may be seen as // just a special case of this.) The globbing characters may not be // used with the typename matches or with tag matches, but they may // be used to match a tag's value in the =tag=value syntax. // // The special characters "@@", appearing at the beginning of a node // name, indicate a stashed node. Normally, stashed nodes are not // returned by a find (but see the special flags, below), but a // stashed node may be found if it is explicitly named with its // leading @@ characters. By extension, "@@*" may be used to identify // any stashed node. // // Examples: // // "room//graph" will look for a node named "graph", which is a child // of an unnamed node, which is a child of a node named "room", which // is a child of the starting path. // // "**/red*" will look for any node anywhere in the tree (below the // starting path) with a name that begins with "red". // // "**/+PartBundleNode/**/head" will look for a node named "head", // somewhere below a PartBundleNode anywhere in the tree. // // // The search is always potentially ambiguous, even if the special // wildcard operators are not used, because there may be multiple // nodes in the tree with the same name. In general, in the case of // an ambiguity, the shortest path is preferred; when a method (such // as extend_by) must choose only only one of several possible paths, // it will choose the shortest available; on the other hand, when a // method (such as find_all_matches) is to return all of the matching // paths, it will sort them so that the shortest paths appear first in // the output. // // // Special flags. The entire string may optionally be followed by the // ";" character, followed by one or more of the following special // control flags, with no intervening spaces or punctuation: // // -h Do not return hidden nodes. // +h Do return hidden nodes. // -s Do not return stashed nodes unless explicitly referenced with @@. // +s Return stashed nodes even without any explicit @@ characters. // -i Node name comparisons are not case insensitive: case must match // exactly. // +i Node name comparisons are case insensitive: case is not important. // This affects matches against the node name only; node type // and tag strings are always case sensitive. // // The default flags are +h-s-i. // //////////////////////////////////////////////////////////////////// // Class : NodePath // Description : NodePath is the fundamental system for disambiguating // instances, and also provides a higher-level interface // for manipulating the scene graph. // // A NodePath is a list of connected nodes from the root // of the graph to any sub-node. Each NodePath // therefore uniquely describes one instance of a node. // // NodePaths themselves are lightweight objects that may // easily be copied and passed by value. Their data is // stored as a series of NodePathComponents that are // stored on the nodes. Holding a NodePath will keep a // reference count to all the nodes in the path. // However, if any node in the path is removed or // reparented (perhaps through a different NodePath), // the NodePath will automatically be updated to reflect // the changes. //////////////////////////////////////////////////////////////////// 146 4 void 0 8194 4 void 4 void 0 6 0 0 0 0 0 0 0 0 0 0 0 147 24 ProjectionScreen const * 0 8576 24 ProjectionScreen const * 24 ProjectionScreen const * 0 0 148 0 0 0 0 0 0 0 0 0 0 148 22 ProjectionScreen const 0 8832 22 ProjectionScreen const 22 ProjectionScreen const 0 0 132 0 0 0 0 0 0 0 0 0 0 149 15 PfmFile const * 0 8576 15 PfmFile const * 15 PfmFile const * 0 0 150 0 0 0 0 0 0 0 0 0 0 150 13 PfmFile const 0 8832 13 PfmFile const 13 PfmFile const 0 0 151 0 0 0 0 0 0 0 0 0 0 151 7 PfmFile 0 2048 7 PfmFile 7 PfmFile 0 0 0 0 0 0 0 0 0 0 0 0 355 //////////////////////////////////////////////////////////////////// // Class : PfmFile // Description : Defines a pfm file, a 2-d table of floating-point // numbers, either 3-component or 1-component, or with a // special extension, 2- or 4-component. //////////////////////////////////////////////////////////////////// 152 4 bool 0 8194 4 bool 4 bool 0 4 0 0 0 0 0 0 0 0 0 0 0 153 8 GeomNode 0 2048 8 GeomNode 8 GeomNode 0 0 0 0 0 0 0 2 181 182 0 0 0 0 423 //////////////////////////////////////////////////////////////////// // Class : GeomNode // Description : A node that holds Geom objects, renderable pieces of // geometry. This is the primary kind of leaf node in // the scene graph; almost all visible objects will be // contained in a GeomNode somewhere. //////////////////////////////////////////////////////////////////// 154 3 int 0 8194 3 int 3 int 0 1 0 0 0 0 0 0 0 0 0 0 0 155 5 float 0 8194 5 float 5 float 0 2 0 0 0 0 0 0 0 0 0 0 0 156 10 GeomNode * 0 8576 10 GeomNode * 10 GeomNode * 0 0 153 0 0 0 0 0 0 0 0 0 0 157 11 PandaNode * 0 8576 11 PandaNode * 11 PandaNode * 0 0 133 0 0 0 0 0 0 0 0 0 0 158 18 LVecBase4f const * 0 8576 18 LVecBase4f const * 18 LVecBase4f const * 0 0 159 0 0 0 0 0 0 0 0 0 0 159 16 LVecBase4f const 0 8832 16 LVecBase4f const 16 LVecBase4f const 0 0 160 0 0 0 0 0 0 0 0 0 0 160 10 LVecBase4f 0 2048 10 LVecBase4f 10 LVecBase4f 0 0 0 0 0 0 0 0 0 0 0 0 265 //////////////////////////////////////////////////////////////////// // Class : LVecBase4 // Description : This is the base class for all three-component // vectors and points. //////////////////////////////////////////////////////////////////// 161 17 UpdateSeq const * 0 8576 17 UpdateSeq const * 17 UpdateSeq const * 0 0 162 0 0 0 0 0 0 0 0 0 0 162 15 UpdateSeq const 0 8832 15 UpdateSeq const 15 UpdateSeq const 0 0 163 0 0 0 0 0 0 0 0 0 0 163 9 UpdateSeq 0 2048 9 UpdateSeq 9 UpdateSeq 0 0 0 0 0 0 0 0 0 0 0 0 1140 //////////////////////////////////////////////////////////////////// // Class : UpdateSeq // Description : This is a sequence number that increments // monotonically. It can be used to track cache // updates, or serve as a kind of timestamp for any // changing properties. // // A special class is used instead of simply an int, so // we can elegantly handle such things as wraparound and // special cases. There are two special cases. // Firstly, a sequence number is 'initial' when it is // first created. This sequence is older than any other // sequence number. Secondly, a sequence number may be // explicitly set to 'old'. This is older than any // other sequence number except 'initial'. Finally, we // have the explicit number 'fresh', which is newer // than any other sequence number. All other sequences // are numeric and are monotonically increasing. //////////////////////////////////////////////////////////////////// 164 17 NonlinearImager * 0 8576 17 NonlinearImager * 17 NonlinearImager * 0 0 134 0 0 0 0 0 0 0 0 0 0 165 23 NonlinearImager const * 0 8576 23 NonlinearImager const * 23 NonlinearImager const * 0 0 166 0 0 0 0 0 0 0 0 0 0 166 21 NonlinearImager const 0 8832 21 NonlinearImager const 21 NonlinearImager const 0 0 134 0 0 0 0 0 0 0 0 0 0 167 10 NodePath * 0 8576 10 NodePath * 10 NodePath * 0 0 145 0 0 0 0 0 0 0 0 0 0 168 14 GraphicsOutput 0 2048 14 GraphicsOutput 14 GraphicsOutput 0 0 0 0 0 0 0 2 183 184 0 0 0 0 1111 //////////////////////////////////////////////////////////////////// // Class : GraphicsOutput // Description : This is a base class for the various different // classes that represent the result of a frame of // rendering. The most common kind of GraphicsOutput is // a GraphicsWindow, which is a real-time window on the // desktop, but another example is GraphicsBuffer, which // is an offscreen buffer. // // The actual rendering, and anything associated with // the graphics context itself, is managed by the // associated GraphicsStateGuardian (which might output // to multiple GraphicsOutput objects). // // GraphicsOutputs are not actually writable to bam // files, of course, but they may be passed as event // parameters, so they inherit from // TypedWritableReferenceCount instead of // TypedReferenceCount for that convenience. //////////////////////////////////////////////////////////////////// 169 16 GraphicsOutput * 0 8576 16 GraphicsOutput * 16 GraphicsOutput * 0 0 168 0 0 0 0 0 0 0 0 0 0 170 15 DisplayRegion * 0 8576 15 DisplayRegion * 15 DisplayRegion * 0 0 171 0 0 0 0 0 0 0 0 0 0 171 13 DisplayRegion 0 2048 13 DisplayRegion 13 DisplayRegion 0 0 0 0 0 0 0 0 0 0 0 0 677 //////////////////////////////////////////////////////////////////// // Class : DisplayRegion // Description : A rectangular subregion within a window for rendering // into. Typically, there is one DisplayRegion that // covers the whole window, but you may also create // smaller DisplayRegions for having different regions // within the window that represent different scenes. // You may also stack up DisplayRegions like panes of // glass, usually for layering 2-d interfaces on top of // a 3-d scene. //////////////////////////////////////////////////////////////////// 172 14 GraphicsEngine 0 2048 14 GraphicsEngine 14 GraphicsEngine 0 0 0 0 0 0 0 1 185 0 0 0 0 823 //////////////////////////////////////////////////////////////////// // Class : GraphicsEngine // Description : This class is the main interface to controlling the // render process. There is typically only one // GraphicsEngine in an application, and it synchronizes // rendering to all all of the active windows; although // it is possible to have multiple GraphicsEngine // objects if multiple synchronicity groups are // required. // // The GraphicsEngine is responsible for managing the // various cull and draw threads. The application // simply calls engine->render_frame() and considers it // done. //////////////////////////////////////////////////////////////////// 173 16 GraphicsEngine * 0 8576 16 GraphicsEngine * 16 GraphicsEngine * 0 0 172 0 0 0 0 0 0 0 0 0 0 174 13 OSphereLens * 0 8576 13 OSphereLens * 13 OSphereLens * 0 0 135 0 0 0 0 0 0 0 0 0 0 175 13 PSphereLens * 0 8576 13 PSphereLens * 13 PSphereLens * 0 0 136 0 0 0 0 0 0 0 0 0 0 0 0 10 176 0 0 40 11 get_screens 15 get_num_screens 10 get_screen 177 0 0 40 11 get_buffers 15 get_num_screens 10 get_buffer 178 0 0 40 11 get_viewers 15 get_num_viewers 10 get_viewer 179 0 0 89 9 get_nodes 13 get_num_nodes 8 get_node 180 0 0 89 13 get_ancestors 13 get_num_nodes 12 get_ancestor 181 0 0 102 9 get_geoms 13 get_num_geoms 8 get_geom 182 0 0 102 15 get_geom_states 13 get_num_geoms 14 get_geom_state 183 0 0 147 19 get_display_regions 23 get_num_display_regions 18 get_display_region 184 0 0 147 26 get_active_display_regions 30 get_num_active_display_regions 25 get_active_display_region 185 0 0 166 11 get_windows 15 get_num_windows 10 get_window