1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
/*
* Copyright (C) 2005-2013 Team XBMC
* http://xbmc.org
*
* This Program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This Program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with XBMC; see the file COPYING. If not, see
* <http://www.gnu.org/licenses/>.
*
*/
#ifndef RENDER_SYSTEM_H
#define RENDER_SYSTEM_H
#pragma once
#include "guilib/Geometry.h"
#include "guilib/TransformMatrix.h"
#include "guilib/DirtyRegion.h"
#include "utils/StdString.h"
#include <stdint.h>
typedef enum _RenderingSystemType
{
RENDERING_SYSTEM_OPENGL,
RENDERING_SYSTEM_DIRECTX,
RENDERING_SYSTEM_OPENGLES
} RenderingSystemType;
/*
* CRenderSystemBase interface allows us to create the rendering engine we use.
* We currently have two engines: OpenGL and DirectX
* This interface is very basic since a lot of the actual details will go in to the derived classes
*/
typedef uint32_t color_t;
enum
{
RENDER_CAPS_DXT = (1 << 0),
RENDER_CAPS_NPOT = (1 << 1),
RENDER_CAPS_DXT_NPOT = (1 << 2),
RENDER_CAPS_BGRA = (1 << 3),
RENDER_CAPS_BGRA_APPLE = (1 << 4)
};
enum
{
RENDER_QUIRKS_MAJORMEMLEAK_OVERLAYRENDERER = 1 << 0,
RENDER_QUIRKS_YV12_PREFERED = 1 << 1,
RENDER_QUIRKS_BROKEN_OCCLUSION_QUERY = 1 << 2,
};
enum RENDER_STEREO_VIEW
{
RENDER_STEREO_VIEW_OFF,
RENDER_STEREO_VIEW_LEFT,
RENDER_STEREO_VIEW_RIGHT,
};
enum RENDER_STEREO_MODE
{
RENDER_STEREO_MODE_OFF,
RENDER_STEREO_MODE_SPLIT_HORIZONTAL,
RENDER_STEREO_MODE_SPLIT_VERTICAL,
RENDER_STEREO_MODE_ANAGLYPH_RED_CYAN,
RENDER_STEREO_MODE_ANAGLYPH_GREEN_MAGENTA,
RENDER_STEREO_MODE_INTERLACED,
RENDER_STEREO_MODE_HARDWAREBASED,
RENDER_STEREO_MODE_MONO,
RENDER_STEREO_MODE_COUNT,
};
class CRenderSystemBase
{
public:
CRenderSystemBase();
virtual ~CRenderSystemBase();
// Retrieve
RenderingSystemType GetRenderingSystemType() { return m_enumRenderingSystem; }
virtual bool InitRenderSystem() = 0;
virtual bool DestroyRenderSystem() = 0;
virtual bool ResetRenderSystem(int width, int height, bool fullScreen, float refreshRate) = 0;
virtual bool BeginRender() = 0;
virtual bool EndRender() = 0;
virtual bool PresentRender(const CDirtyRegionList& dirty) = 0;
virtual bool ClearBuffers(color_t color) = 0;
virtual bool IsExtSupported(const char* extension) = 0;
virtual void SetVSync(bool vsync) = 0;
bool GetVSync() { return m_bVSync; }
virtual void SetViewPort(CRect& viewPort) = 0;
virtual void GetViewPort(CRect& viewPort) = 0;
virtual void SetScissors(const CRect &rect) = 0;
virtual void ResetScissors() = 0;
virtual void CaptureStateBlock() = 0;
virtual void ApplyStateBlock() = 0;
virtual void SetCameraPosition(const CPoint &camera, int screenWidth, int screenHeight) = 0;
virtual void ApplyHardwareTransform(const TransformMatrix &matrix) = 0;
virtual void RestoreHardwareTransform() = 0;
virtual void SetStereoMode(RENDER_STEREO_MODE mode, RENDER_STEREO_VIEW view)
{
m_stereoMode = mode;
m_stereoView = view;
}
virtual bool TestRender() = 0;
/**
* Project (x,y,z) 3d scene coordinates to (x,y) 2d screen coordinates
*/
virtual void Project(float &x, float &y, float &z) { }
void GetRenderVersion(unsigned int& major, unsigned int& minor) const;
const CStdString& GetRenderVendor() const { return m_RenderVendor; }
const CStdString& GetRenderRenderer() const { return m_RenderRenderer; }
const CStdString& GetRenderVersionString() const { return m_RenderVersion; }
bool SupportsDXT() const;
bool SupportsBGRA() const;
bool SupportsBGRAApple() const;
bool SupportsNPOT(bool dxt) const;
bool SupportsStereo(RENDER_STEREO_MODE mode) const;
unsigned int GetMaxTextureSize() const { return m_maxTextureSize; }
unsigned int GetMinDXTPitch() const { return m_minDXTPitch; }
unsigned int GetRenderQuirks() const { return m_renderQuirks; }
protected:
bool m_bRenderCreated;
RenderingSystemType m_enumRenderingSystem;
bool m_bVSync;
unsigned int m_maxTextureSize;
unsigned int m_minDXTPitch;
CStdString m_RenderRenderer;
CStdString m_RenderVendor;
CStdString m_RenderVersion;
int m_RenderVersionMinor;
int m_RenderVersionMajor;
unsigned int m_renderCaps;
unsigned int m_renderQuirks;
RENDER_STEREO_VIEW m_stereoView;
RENDER_STEREO_MODE m_stereoMode;
};
#endif // RENDER_SYSTEM_H
|
