summaryrefslogtreecommitdiffhomepage
path: root/nGenEx/CameraView.h
blob: 493e4f7e11c05ea96ae4c3f69e26684c626a8180 (plain)
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
/*  Project nGenEx
    Destroyer Studios LLC
    Copyright © 1997-2004. All Rights Reserved.

    SUBSYSTEM:    nGenEx.lib
    FILE:         CameraView.h
    AUTHOR:       John DiCamillo


    OVERVIEW
    ========
    3D Projection Camera View class
*/

#ifndef CameraView_h
#define CameraView_h

#include "Types.h"
#include "View.h"
#include "Camera.h"
#include "Projector.h"
#include "Video.h"
#include "List.h"

// +--------------------------------------------------------------------+

class Video;
class Scene;
class Bitmap;

class Graphic;

// +--------------------------------------------------------------------+

class CameraView : public View
{
public:
   static const char* TYPENAME() { return "CameraView"; }

   CameraView(Window* c, Camera* cam, Scene* s);
   virtual ~CameraView();

   // Operations:
   virtual void   Refresh();
   virtual void   OnWindowMove();
   virtual void   UseCamera(Camera* cam);
   virtual void   UseScene(Scene* scene);
   virtual void   LensFlareElements(Bitmap* halo, Bitmap* e1=0, Bitmap* e2=0, Bitmap* e3=0);
   virtual void   LensFlare(int on, double dim = 1);
   virtual void   SetDepthScale(float scale);

   // accessors:
   Camera*        GetCamera()                   const { return camera;      }
   Projector*     GetProjector()                      { return &projector;  }
   Scene*         GetScene()                    const { return scene;       }
   virtual void   SetFieldOfView(double fov);
   virtual double GetFieldOfView()              const;
   virtual void   SetProjectionType(DWORD pt);
   virtual DWORD  GetProjectionType()           const;

   Point          Pos() const { return camera->Pos(); }
   Point          vrt()       { return camera->vrt(); }
   Point          vup()       { return camera->vup(); }
   Point          vpn()       { return camera->vpn(); }
   const Matrix&  Orientation() const { return camera->Orientation(); }

   Point          SceneOffset() const { return camera_loc; }

   // projection and clipping geometry:
   virtual void   TranslateScene();
   virtual void   UnTranslateScene();
   virtual void   MarkVisibleObjects();
   virtual void   MarkVisibleLights(Graphic* g, DWORD flags);

   virtual void   RenderScene();
   virtual void   RenderSceneObjects(bool distant=false);
   virtual void   RenderForeground();
   virtual void   RenderBackground();
   virtual void   RenderSprites();
   virtual void   RenderLensFlare();
   virtual void   Render(Graphic* g, DWORD flags);

   virtual void   FindDepth(Graphic* g);
   virtual int    SetInfinite(int i);

protected:
   Camera*        camera;
   Scene*         scene;
   Video*         video;

   virtual void   WorldPlaneToView(Plane& plane);

   Point          camera_loc;
   Vec3           cvrt;
   Vec3           cvup;
   Vec3           cvpn;

   Projector      projector;
   int            infinite;
   int            width;
   int            height;
   DWORD          projection_type;

   // lens flare:
   int            lens_flare_enable;
   double         lens_flare_dim;
   Bitmap*        halo_bitmap;
   Bitmap*        elem_bitmap[3];

   List<Graphic>  graphics;
};

#endif CameraView_h