← Back to branch summary

~om26er/ubuntu/oneiric/nux/sru-819721

« back to all changes in this revision

Viewing changes to NuxGraphics/GLTextureStates.h

  • Committer: Bazaar Package Importer
  • Author(s): Didier Roche
  • Date: 2010-11-18 19:17:32 UTC
  • Revision ID: james.westby@ubuntu.com-20101118191732-rn35790vekj6o4my
Tags: upstream-0.9.4
Import upstream version 0.9.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
NuxGraphics/GLTextureStates.h
 
1
/*
 
2
 * Copyright 2010 Inalogic Inc.
 
3
 *
 
4
 * This program is free software: you can redistribute it and/or modify it
 
5
 * under the terms of the GNU Lesser General Public License version 3, as
 
6
 * published by the  Free Software Foundation.
 
7
 *
 
8
 * This program is distributed in the hope that it will be useful, but
 
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of
 
10
 * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
 
11
 * PURPOSE.  See the applicable version of the GNU Lesser General Public
 
12
 * License for more details.
 
13
 *
 
14
 * You should have received a copy of both the GNU Lesser General Public
 
15
 * License version 3 along with this program.  If not, see
 
16
 * <http://www.gnu.org/licenses/>
 
17
 *
 
18
 * Authored by: Jay Taoko <jay.taoko_AT_gmail_DOT_com>
 
19
 *
 
20
 */
 
21
 
 
22
 
 
23
#ifndef GLTEXTURESTATES_H
 
24
#define GLTEXTURESTATES_H
 
25
 
 
26
#include "NuxCore/NuxCore.h"
 
27
 
 
28
namespace nux
 
29
{
 
30
 
 
31
  enum
 
32
  {
 
33
    GFXTS_ADDRESSU,                          // GL_REPEAT
 
34
    GFXTS_ADDRESSV,                          // GL_REPEAT
 
35
    GFXTS_ADDRESSW,                          // GL_REPEAT
 
36
 
 
37
    GFXTS_MINFILTER,                         // GL_NEAREST
 
38
    GFXTS_MAGFILTER,                         // GL_NEAREST
 
39
    GFXTS_MIPFILTER,                         // GL_NEAREST
 
40
 
 
41
    GFXTS_MIP_BASE_LEVEL,                    // 0
 
42
    GFXTS_MIP_MAX_LEVEL,                     // 1000
 
43
    GFXTS_MIN_LOD,                           // -1000
 
44
    GFXTS_MAX_LOD,                           // +1000
 
45
 
 
46
    GFXTS_BORDERCOLOR,                       // 0x00000000
 
47
 
 
48
 
 
49
    GFXTS_MAX_TEXTURESTATES,
 
50
  };
 
51
 
 
52
  struct TextureStateMap
 
53
  {
 
54
    bool           Checked;
 
55
    unsigned int    State;
 
56
    unsigned int    Dirty;
 
57
    unsigned int    iValue;
 
58
    float           fValue;
 
59
    TextureStateMap()
 
60
    {
 
61
      Dirty = true;
 
62
    }
 
63
  };
 
64
 
 
65
  class GpuDevice;
 
66
  class GLTextureStates
 
67
  {
 
68
  public:
 
69
    GLTextureStates (GLuint Type = GL_TEXTURE_2D);
 
70
    ~GLTextureStates();
 
71
 
 
72
    void ResetDefault();
 
73
    void ResetStateChangeToDefault();
 
74
    void SetRenderStates();
 
75
 
 
76
    void SetType (GLuint Type);
 
77
 
 
78
    void SetFiltering (
 
79
      unsigned int MIN = GL_NEAREST,
 
80
      unsigned int MAG = GL_NEAREST/*,
 
81
        unsigned int MIP = GL_NEAREST*/);
 
82
 
 
83
    void SetWrap (
 
84
      unsigned int U = GL_REPEAT,
 
85
      unsigned int V = GL_REPEAT,
 
86
      unsigned int W = GL_REPEAT);
 
87
 
 
88
    void SetLOD (
 
89
      float MinLod = -1000.0f,
 
90
      float MaxLod = +1000.0f);
 
91
 
 
92
    void SetMipLevel (
 
93
      unsigned int MinMip = 0,
 
94
      unsigned int MaxMip = 1000);
 
95
 
 
96
    void SetBorderColor (
 
97
      float R,
 
98
      float G,
 
99
      float B,
 
100
      float A);
 
101
 
 
102
  private:
 
103
    void HW_SetFiltering();
 
104
    void HW_SetWrap();
 
105
    void HW_SetLOD();
 
106
    void HW_SetMipLevel();
 
107
    void HW_SetBorderColor();
 
108
 
 
109
    GLuint m_Type;
 
110
    TextureStateMap m_TextureStateChanges[GFXTS_MAX_TEXTURESTATES];
 
111
 
 
112
    friend class GpuDevice;
 
113
  };
 
114
 
 
115
// #define SET_TS_VALUE(a, b)  (a).iValue = (b); (a).Dirty = true;
 
116
// #define TS_VALUE(a, b)      (a).iValue
 
117
//
 
118
// #define SET_TS_VALUE_FLOAT(a, b)  (a).fValue = (b); (a).Dirty = true;
 
119
// #define TS_VALUE_FLOAT(a, b)      (a).fValue
 
120
//
 
121
//
 
122
// inline void GLTextureStates::SetFiltering(
 
123
//                          unsigned int MIN,
 
124
//                          unsigned int MAG
 
125
//                          /*,unsigned int MIP*/)
 
126
// {
 
127
//     nuxAssertMsg(
 
128
//         (MIN == GL_LINEAR) ||
 
129
//         (MIN == GL_NEAREST) ||
 
130
//         (MIN == GL_NEAREST_MIPMAP_NEAREST) ||
 
131
//         (MIN == GL_LINEAR_MIPMAP_NEAREST) ||
 
132
//         (MIN == GL_NEAREST_MIPMAP_LINEAR) ||
 
133
//         (MIN == GL_LINEAR_MIPMAP_LINEAR),
 
134
//         TEXT("Error[GLTextureStates::SetFiltering]: Invalid Min. Filter State"));
 
135
//
 
136
//     nuxAssertMsg(
 
137
//         (MAG == GL_LINEAR) ||
 
138
//         (MAG == GL_NEAREST),
 
139
//         TEXT("Error[GLTextureStates::SetFiltering]: Invalid Mag. Filter State"));
 
140
//
 
141
// //    nuxAssertMsg(
 
142
// //        (MIP == GL_LINEAR) ||
 
143
// //        (MIP == GL_NEAREST),
 
144
// //        TEXT("Error[GLTextureStates::SetFiltering]: Invalid Mipmap Filter State"));
 
145
//
 
146
//     SET_TS_VALUE(m_TextureStateChanges[GFXTS_MINFILTER], MIN);
 
147
//     SET_TS_VALUE(m_TextureStateChanges[GFXTS_MAGFILTER], MAG);
 
148
//     //SET_TS_VALUE(m_TextureStateChanges[GFXTS_MIPFILTER], MIP);
 
149
// }
 
150
//
 
151
// inline void GLTextureStates::SetWrap(
 
152
//                     unsigned int U,
 
153
//                     unsigned int V,
 
154
//                     unsigned int W)
 
155
// {
 
156
//     nuxAssertMsg(
 
157
//         (U == GL_CLAMP) ||
 
158
//         (U == GL_CLAMP_TO_EDGE) ||
 
159
//         (U == GL_REPEAT),
 
160
//         TEXT("Error[GLTextureStates::SetWrap]: Invalid U Wrap State"));
 
161
//     nuxAssertMsg(
 
162
//         (V == GL_CLAMP) ||
 
163
//         (V == GL_CLAMP_TO_EDGE) ||
 
164
//         (V == GL_REPEAT),
 
165
//         TEXT("Error[GLTextureStates::SetWrap]: Invalid V Wrap State"));
 
166
//     nuxAssertMsg(
 
167
//         (W == GL_CLAMP) ||
 
168
//         (W == GL_CLAMP_TO_EDGE) ||
 
169
//         (W == GL_REPEAT),
 
170
//         TEXT("Error[GLTextureStates::SetWrap]: Invalid W Wrap State"));
 
171
//
 
172
//     SET_TS_VALUE(m_TextureStateChanges[GFXTS_ADDRESSU], U);
 
173
//     SET_TS_VALUE(m_TextureStateChanges[GFXTS_ADDRESSV], V);
 
174
//     SET_TS_VALUE(m_TextureStateChanges[GFXTS_ADDRESSW], W);
 
175
//
 
176
//
 
177
// }
 
178
//
 
179
// inline void GLTextureStates::SetLOD(float MinLod,
 
180
//                                     float MaxLod)
 
181
// {
 
182
//     SET_TS_VALUE_FLOAT(m_TextureStateChanges[GFXTS_MIN_LOD], MinLod);
 
183
//     SET_TS_VALUE_FLOAT(m_TextureStateChanges[GFXTS_MAX_LOD], MaxLod);
 
184
// }
 
185
//
 
186
// inline void GLTextureStates::SetMipLevel(
 
187
//                         unsigned int MinMip,
 
188
//                         unsigned int MaxMip)
 
189
// {
 
190
//     SET_TS_VALUE(m_TextureStateChanges[GFXTS_MIP_BASE_LEVEL], MinMip);
 
191
//     SET_TS_VALUE(m_TextureStateChanges[GFXTS_MIP_MAX_LEVEL], MaxMip);
 
192
// }
 
193
//
 
194
// inline void GLTextureStates::SetBorderColor(
 
195
//                            float R,
 
196
//                            float G,
 
197
//                            float B,
 
198
//                            float A)
 
199
// {
 
200
//     unsigned int r, g, b, a;
 
201
//     r = 255 * Clamp(R, 0.0f, 1.0f);
 
202
//     g = 255 * Clamp(G, 0.0f, 1.0f);
 
203
//     b = 255 * Clamp(B, 0.0f, 1.0f);
 
204
//     a = 255 * Clamp(A, 0.0f, 1.0f);
 
205
//     unsigned int color = (unsigned int) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b));
 
206
//
 
207
//     SET_TS_VALUE(m_TextureStateChanges[GFXTS_BORDERCOLOR], color);
 
208
// }
 
209
//
 
210
// #undef SET_TS_VALUE
 
211
// #undef TS_VALUE
 
212
//
 
213
// #undef SET_TS_VALUE_FLOAT
 
214
// #undef TS_VALUE_FLOAT
 
215
 
 
216
}
 
217
 
 
218
#endif // GLTEXTURESTATES_H
 
219