← Back to branch summary

~hikiko/nux/arb-srgba-shader

« back to all changes in this revision

Viewing changes to NuxGraphics/GLTextureStates.cpp

  • Committer: Neil Jagdish Patel
  • Date: 2010-09-02 03:28:11 UTC
  • Revision ID: neil.patel@canonical.com-20100902032811-i2m18tfb6pkasnvt
Remove Win EOL chars

Show diffs side-by-side

added added

removed removed

Lines of Context:
NuxGraphics/GLTextureStates.cpp
20
20
 */
21
21
 
22
22
 
23
 
#include "GLResource.h"
24
 
#include "GLTextureStates.h"
25
 
 
26
 
NAMESPACE_BEGIN_OGL
27
 
 
28
 
const struct TextureStateLookUpTable
29
 
{
30
 
    TextureStateLookUpTable()
31
 
    {
32
 
        // setup render state map
33
 
#define UL_MAP(state__, default_value__, checked__)                          \
34
 
        default_texture_state[GFXTS_##state__].iValue     = default_value__;  \
35
 
        default_texture_state[GFXTS_##state__].Checked   = checked__;
36
 
 
37
 
#define UL_MAP_FLOAT(state__, default_value__, checked__)                    \
38
 
    default_texture_state[GFXTS_##state__].fValue     = default_value__;      \
39
 
    default_texture_state[GFXTS_##state__].Checked   = checked__;
40
 
 
41
 
        UL_MAP(ADDRESSU               ,           GL_REPEAT       ,       1);
42
 
        UL_MAP(ADDRESSV               ,           GL_REPEAT       ,       1);
43
 
        UL_MAP(ADDRESSW               ,           GL_REPEAT       ,       1);
44
 
 
45
 
        UL_MAP(MINFILTER              ,           GL_NEAREST      ,       1);
46
 
        UL_MAP(MAGFILTER              ,           GL_NEAREST      ,       1);
47
 
        UL_MAP(MIPFILTER              ,           GL_NEAREST      ,       1);
48
 
 
49
 
        UL_MAP(MIP_BASE_LEVEL         ,           0               ,       1);
50
 
        UL_MAP(MIP_MAX_LEVEL          ,           1000            ,       1);
51
 
        UL_MAP_FLOAT(MIN_LOD          ,           -1000           ,       1);
52
 
        UL_MAP_FLOAT(MAX_LOD          ,           +1000           ,       1);
53
 
 
54
 
        UL_MAP(BORDERCOLOR            ,           0x0             ,       1);
55
 
        
56
 
#undef UL_MAP
57
 
#undef UL_MAP_FLOAT
58
 
    };
59
 
 
60
 
    TextureStateMap default_texture_state[GFXTS_MAX_TEXTURESTATES];
61
 
} s_TextureStateLUT;
62
 
 
63
 
 
64
 
GLTextureStates::GLTextureStates(GLuint Type)
65
 
{
66
 
    SetType(Type);
67
 
    Memcpy(&m_TextureStateChanges, &s_TextureStateLUT.default_texture_state, sizeof(m_TextureStateChanges));
68
 
}
69
 
 
70
 
GLTextureStates::~GLTextureStates()
71
 
{
72
 
 
73
 
}
74
 
 
75
 
void GLTextureStates::SetType(GLuint Type)
76
 
{
77
 
    nuxAssertMsg(
78
 
        (Type == GL_TEXTURE_1D) ||
79
 
        (Type == GL_TEXTURE_2D) ||
80
 
        (Type == GL_TEXTURE_RECTANGLE_ARB) ||
81
 
        (Type == GL_TEXTURE_3D) ||
82
 
        (Type == GL_TEXTURE_CUBE_MAP_ARB),
83
 
        TEXT("Error[GLTextureStates::GLTextureStates]: Invalid texture type."));
84
 
 
85
 
    m_Type = Type;
86
 
}
87
 
 
88
 
void GLTextureStates::ResetDefault()
89
 
{
90
 
 
91
 
}
92
 
 
93
 
void GLTextureStates::ResetStateChangeToDefault()
94
 
{
95
 
 
96
 
}
97
 
 
98
 
void GLTextureStates::SetRenderStates()
99
 
{
100
 
    HW_SetFiltering();
101
 
    HW_SetWrap();
102
 
    HW_SetLOD();
103
 
    HW_SetMipLevel();
104
 
}
105
 
 
106
 
#define SET_TS_VALUE(a, b)  if(a.iValue != b){(a).iValue = (b); (a).Dirty = true;}
107
 
#define TS_VALUE(a, b)      (a).iValue
108
 
 
109
 
#define SET_TS_VALUE_FLOAT(a, b)  if(a.fValue != b){(a).fValue = (b); (a).Dirty = true;}
110
 
#define TS_VALUE_FLOAT(a, b)      (a).fValue
111
 
 
112
 
 
113
 
void GLTextureStates::HW_SetFiltering()
114
 
{
115
 
    if(m_TextureStateChanges[GFXTS_MINFILTER].Dirty || m_TextureStateChanges[GFXTS_MAGFILTER].Dirty)
116
 
    {
117
 
        CHECKGL( glTexParameteri(m_Type, GL_TEXTURE_MIN_FILTER,   m_TextureStateChanges[GFXTS_MINFILTER].iValue ) );
118
 
        CHECKGL( glTexParameteri(m_Type, GL_TEXTURE_MAG_FILTER,   m_TextureStateChanges[GFXTS_MAGFILTER].iValue) );
119
 
        m_TextureStateChanges[GFXTS_MINFILTER].Dirty = false;
120
 
        m_TextureStateChanges[GFXTS_MAGFILTER].Dirty = false;
121
 
    }
122
 
}
123
 
 
124
 
void GLTextureStates::HW_SetWrap()
125
 
{
126
 
    if(m_TextureStateChanges[GFXTS_ADDRESSU].Dirty ||
127
 
        m_TextureStateChanges[GFXTS_ADDRESSV].Dirty ||
128
 
        m_TextureStateChanges[GFXTS_ADDRESSW].Dirty)
129
 
    {
130
 
        CHECKGL( glTexParameteri(m_Type, GL_TEXTURE_WRAP_S,       m_TextureStateChanges[GFXTS_ADDRESSU].iValue) );
131
 
        CHECKGL( glTexParameteri(m_Type, GL_TEXTURE_WRAP_T,       m_TextureStateChanges[GFXTS_ADDRESSV].iValue) );
132
 
        CHECKGL( glTexParameteri(m_Type, GL_TEXTURE_WRAP_R,       m_TextureStateChanges[GFXTS_ADDRESSW].iValue) );
133
 
        m_TextureStateChanges[GFXTS_ADDRESSU].Dirty = false;
134
 
        m_TextureStateChanges[GFXTS_ADDRESSV].Dirty = false;
135
 
        m_TextureStateChanges[GFXTS_ADDRESSW].Dirty = false;
136
 
    }
137
 
}
138
 
 
139
 
void GLTextureStates::HW_SetLOD()
140
 
{
141
 
    if(m_Type == GL_TEXTURE_RECTANGLE_ARB)
142
 
    {
143
 
        // No support for mip LOP on rectangle texture.
144
 
        // ATI seems to not generate and Error.
145
 
        // Nvidia generates an error
146
 
        m_TextureStateChanges[GFXTS_MIN_LOD].Dirty = false;
147
 
        m_TextureStateChanges[GFXTS_MAX_LOD].Dirty = false;
148
 
        return;
149
 
    }
150
 
    if(m_TextureStateChanges[GFXTS_MIN_LOD].Dirty || m_TextureStateChanges[GFXTS_MAX_LOD].Dirty)
151
 
    {
152
 
        CHECKGL( glTexParameteri(m_Type, GL_TEXTURE_MIN_LOD,  m_TextureStateChanges[GFXTS_MIN_LOD].fValue) );
153
 
        CHECKGL( glTexParameteri(m_Type, GL_TEXTURE_MAX_LOD,  m_TextureStateChanges[GFXTS_MAX_LOD].fValue) );
154
 
        m_TextureStateChanges[GFXTS_MIN_LOD].Dirty = false;
155
 
        m_TextureStateChanges[GFXTS_MAX_LOD].Dirty = false;
156
 
    }
157
 
}
158
 
 
159
 
void GLTextureStates::HW_SetMipLevel()
160
 
{
161
 
    if(m_TextureStateChanges[GFXTS_MIN_LOD].Dirty || m_TextureStateChanges[GFXTS_MAX_LOD].Dirty)
162
 
    {
163
 
        CHECKGL( glTexParameteri(m_Type, GL_TEXTURE_MIN_LOD,  m_TextureStateChanges[GFXTS_MIN_LOD].fValue) );
164
 
        CHECKGL( glTexParameteri(m_Type, GL_TEXTURE_MAX_LOD,  m_TextureStateChanges[GFXTS_MAX_LOD].fValue) );
165
 
        m_TextureStateChanges[GFXTS_MIN_LOD].Dirty = false;
166
 
        m_TextureStateChanges[GFXTS_MAX_LOD].Dirty = false;
167
 
    }
168
 
}
169
 
 
170
 
void GLTextureStates::HW_SetBorderColor()
171
 
{
172
 
 
173
 
}
174
 
 
175
 
void GLTextureStates::SetFiltering(
176
 
    unsigned int MinFilter,
177
 
    unsigned int MagFilter
178
 
    /*,unsigned int MIP*/)
179
 
{
180
 
    nuxAssertMsg(
181
 
        (MinFilter == GL_LINEAR) ||
182
 
        (MinFilter == GL_NEAREST) ||
183
 
        (MinFilter == GL_NEAREST_MIPMAP_NEAREST) ||
184
 
        (MinFilter == GL_LINEAR_MIPMAP_NEAREST) ||
185
 
        (MinFilter == GL_NEAREST_MIPMAP_LINEAR) ||
186
 
        (MinFilter == GL_LINEAR_MIPMAP_LINEAR),
187
 
        TEXT("Error[GLTextureStates::SetFiltering]: Invalid MinFilter state"));
188
 
 
189
 
    nuxAssertMsg(
190
 
        (MagFilter == GL_LINEAR) ||
191
 
        (MagFilter == GL_NEAREST),
192
 
        TEXT("Error[GLTextureStates::SetFiltering]: Invalid MagFilter state"));
193
 
 
194
 
    //    nuxAssertMsg(
195
 
    //        (MIP == GL_LINEAR) ||
196
 
    //        (MIP == GL_NEAREST),
197
 
    //        TEXT("Error[GLTextureStates::SetFiltering]: Invalid Mipmap Filter State"));
198
 
 
199
 
    if(m_Type == GL_TEXTURE_RECTANGLE_ARB)
200
 
    {
201
 
        if((MinFilter != GL_NEAREST) && (MinFilter != GL_LINEAR))
202
 
        {
203
 
            nuxError(TEXT("[GLTextureStates::SetFiltering] Incorrect MinFilter for rectangle texture."));
204
 
            SET_TS_VALUE(m_TextureStateChanges[GFXTS_MINFILTER], GL_LINEAR);
205
 
        }
206
 
        else
207
 
        {
208
 
            SET_TS_VALUE(m_TextureStateChanges[GFXTS_MINFILTER], MinFilter);
209
 
        }
210
 
 
211
 
        if((MagFilter != GL_NEAREST) && (MagFilter != GL_LINEAR))
212
 
        {
213
 
            nuxError(TEXT("[GLTextureStates::SetFiltering] Incorrect MagFilter for rectangle texture."));
214
 
            SET_TS_VALUE(m_TextureStateChanges[GFXTS_MAGFILTER], GL_LINEAR);
215
 
        }
216
 
        else
217
 
        {
218
 
            SET_TS_VALUE(m_TextureStateChanges[GFXTS_MAGFILTER], MagFilter);
219
 
        }
220
 
    }
221
 
    else
222
 
    {
223
 
        SET_TS_VALUE(m_TextureStateChanges[GFXTS_MINFILTER], MinFilter);
224
 
        SET_TS_VALUE(m_TextureStateChanges[GFXTS_MAGFILTER], MagFilter);
225
 
    }
226
 
    //SET_TS_VALUE(m_TextureStateChanges[GFXTS_MIPFILTER], MIP);
227
 
}
228
 
 
229
 
void GLTextureStates::SetWrap(
230
 
                                     unsigned int U,
231
 
                                     unsigned int V,
232
 
                                     unsigned int W)
233
 
{
234
 
    nuxAssertMsg(
235
 
        (U == GL_CLAMP) ||
236
 
        (U == GL_CLAMP_TO_EDGE) ||
237
 
        (U == GL_CLAMP_TO_BORDER) ||
238
 
        (U == GL_MIRRORED_REPEAT) ||
239
 
        (U == GL_MIRROR_CLAMP_EXT) ||
240
 
        (U == GL_MIRROR_CLAMP_TO_EDGE_EXT) ||
241
 
        (U == GL_MIRROR_CLAMP_TO_BORDER_EXT) ||
242
 
        (U == GL_REPEAT),
243
 
        TEXT("Error[GLTextureStates::SetWrap]: Invalid U Wrap State"));
244
 
 
245
 
    nuxAssertMsg(
246
 
        (V == GL_CLAMP) ||
247
 
        (V == GL_CLAMP_TO_EDGE) ||
248
 
        (V == GL_CLAMP_TO_BORDER) ||
249
 
        (V == GL_MIRRORED_REPEAT) ||
250
 
        (V == GL_MIRROR_CLAMP_EXT) ||
251
 
        (V == GL_MIRROR_CLAMP_TO_EDGE_EXT) ||
252
 
        (V == GL_MIRROR_CLAMP_TO_BORDER_EXT) ||
253
 
        (V == GL_REPEAT),
254
 
        TEXT("Error[GLTextureStates::SetWrap]: Invalid V Wrap State"));
255
 
    nuxAssertMsg(
256
 
        (W == GL_CLAMP) ||
257
 
        (W == GL_CLAMP_TO_EDGE) ||
258
 
        (W == GL_CLAMP_TO_BORDER) ||
259
 
        (W == GL_MIRRORED_REPEAT) ||
260
 
        (W == GL_MIRROR_CLAMP_EXT) ||
261
 
        (W == GL_MIRROR_CLAMP_TO_EDGE_EXT) ||
262
 
        (W == GL_MIRROR_CLAMP_TO_BORDER_EXT) ||
263
 
        (W == GL_REPEAT),
264
 
        TEXT("Error[GLTextureStates::SetWrap]: Invalid W Wrap State"));
265
 
 
266
 
    if(m_Type == GL_TEXTURE_RECTANGLE_ARB)
267
 
    {
268
 
        if((U != GL_CLAMP) && (U != GL_CLAMP_TO_BORDER) && (U != GL_CLAMP_TO_EDGE))
269
 
        {
270
 
            nuxError(TEXT("[GLTextureStates::SetFiltering] Incorrect warp for rectangle texture."));
271
 
            SET_TS_VALUE(m_TextureStateChanges[GFXTS_ADDRESSU], GL_CLAMP_TO_EDGE);
272
 
        }
273
 
        else
274
 
        {
275
 
            SET_TS_VALUE(m_TextureStateChanges[GFXTS_ADDRESSU], U);
276
 
        }
277
 
 
278
 
        if((V != GL_CLAMP) && (V != GL_CLAMP_TO_BORDER) && (V != GL_CLAMP_TO_EDGE))
279
 
        {
280
 
            nuxError(TEXT("[GLTextureStates::SetFiltering] Incorrect warp for rectangle texture."));
281
 
            SET_TS_VALUE(m_TextureStateChanges[GFXTS_ADDRESSV], GL_CLAMP_TO_EDGE);
282
 
        }
283
 
        else
284
 
        {
285
 
            SET_TS_VALUE(m_TextureStateChanges[GFXTS_ADDRESSV], V);
286
 
        }
287
 
 
288
 
        if((W != GL_CLAMP) && (W != GL_CLAMP_TO_BORDER) && (W != GL_CLAMP_TO_EDGE))
289
 
        {
290
 
            nuxError(TEXT("[GLTextureStates::SetFiltering] Incorrect warp for rectangle texture."));
291
 
            SET_TS_VALUE(m_TextureStateChanges[GFXTS_ADDRESSW], GL_CLAMP_TO_EDGE);
292
 
        }
293
 
        else
294
 
        {
295
 
            SET_TS_VALUE(m_TextureStateChanges[GFXTS_ADDRESSW], W);
296
 
        }
297
 
    }
298
 
    else
299
 
    {
300
 
        SET_TS_VALUE(m_TextureStateChanges[GFXTS_ADDRESSU], U);
301
 
        SET_TS_VALUE(m_TextureStateChanges[GFXTS_ADDRESSV], V);
302
 
        SET_TS_VALUE(m_TextureStateChanges[GFXTS_ADDRESSW], W);
303
 
    }
304
 
}
305
 
 
306
 
void GLTextureStates::SetLOD(float MinLod,
307
 
                                    float MaxLod)
308
 
{
309
 
    SET_TS_VALUE_FLOAT(m_TextureStateChanges[GFXTS_MIN_LOD], MinLod);
310
 
    SET_TS_VALUE_FLOAT(m_TextureStateChanges[GFXTS_MAX_LOD], MaxLod);
311
 
}
312
 
 
313
 
void GLTextureStates::SetMipLevel(
314
 
    unsigned int MinMip,
315
 
    unsigned int MaxMip)
316
 
{
317
 
    SET_TS_VALUE(m_TextureStateChanges[GFXTS_MIP_BASE_LEVEL], MinMip);
318
 
    SET_TS_VALUE(m_TextureStateChanges[GFXTS_MIP_MAX_LEVEL], MaxMip);
319
 
}
320
 
 
321
 
void GLTextureStates::SetBorderColor(
322
 
    float R,
323
 
    float G,
324
 
    float B,
325
 
    float A)
326
 
{
327
 
    unsigned int r, g, b, a;
328
 
    r = 255 * Clamp(R, 0.0f, 1.0f);
329
 
    g = 255 * Clamp(G, 0.0f, 1.0f);
330
 
    b = 255 * Clamp(B, 0.0f, 1.0f);
331
 
    a = 255 * Clamp(A, 0.0f, 1.0f);
332
 
    unsigned int color = (unsigned int) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b));
333
 
 
334
 
    SET_TS_VALUE(m_TextureStateChanges[GFXTS_BORDERCOLOR], color);
335
 
}
336
 
 
337
 
#undef SET_TS_VALUE
338
 
#undef TS_VALUE
339
 
 
340
 
#undef SET_TS_VALUE_FLOAT
341
 
#undef TS_VALUE_FLOAT
342
 
 
343
 
NAMESPACE_END_OGL
 
23
#include "GLResource.h"
 
24
#include "GLTextureStates.h"
 
25
 
 
26
NAMESPACE_BEGIN_OGL
 
27
 
 
28
const struct TextureStateLookUpTable
 
29
{
 
30
    TextureStateLookUpTable()
 
31
    {
 
32
        // setup render state map
 
33
#define UL_MAP(state__, default_value__, checked__)                          \
 
34
        default_texture_state[GFXTS_##state__].iValue     = default_value__;  \
 
35
        default_texture_state[GFXTS_##state__].Checked   = checked__;
 
36
 
 
37
#define UL_MAP_FLOAT(state__, default_value__, checked__)                    \
 
38
    default_texture_state[GFXTS_##state__].fValue     = default_value__;      \
 
39
    default_texture_state[GFXTS_##state__].Checked   = checked__;
 
40
 
 
41
        UL_MAP(ADDRESSU               ,           GL_REPEAT       ,       1);
 
42
        UL_MAP(ADDRESSV               ,           GL_REPEAT       ,       1);
 
43
        UL_MAP(ADDRESSW               ,           GL_REPEAT       ,       1);
 
44
 
 
45
        UL_MAP(MINFILTER              ,           GL_NEAREST      ,       1);
 
46
        UL_MAP(MAGFILTER              ,           GL_NEAREST      ,       1);
 
47
        UL_MAP(MIPFILTER              ,           GL_NEAREST      ,       1);
 
48
 
 
49
        UL_MAP(MIP_BASE_LEVEL         ,           0               ,       1);
 
50
        UL_MAP(MIP_MAX_LEVEL          ,           1000            ,       1);
 
51
        UL_MAP_FLOAT(MIN_LOD          ,           -1000           ,       1);
 
52
        UL_MAP_FLOAT(MAX_LOD          ,           +1000           ,       1);
 
53
 
 
54
        UL_MAP(BORDERCOLOR            ,           0x0             ,       1);
 
55
        
 
56
#undef UL_MAP
 
57
#undef UL_MAP_FLOAT
 
58
    };
 
59
 
 
60
    TextureStateMap default_texture_state[GFXTS_MAX_TEXTURESTATES];
 
61
} s_TextureStateLUT;
 
62
 
 
63
 
 
64
GLTextureStates::GLTextureStates(GLuint Type)
 
65
{
 
66
    SetType(Type);
 
67
    Memcpy(&m_TextureStateChanges, &s_TextureStateLUT.default_texture_state, sizeof(m_TextureStateChanges));
 
68
}
 
69
 
 
70
GLTextureStates::~GLTextureStates()
 
71
{
 
72
 
 
73
}
 
74
 
 
75
void GLTextureStates::SetType(GLuint Type)
 
76
{
 
77
    nuxAssertMsg(
 
78
        (Type == GL_TEXTURE_1D) ||
 
79
        (Type == GL_TEXTURE_2D) ||
 
80
        (Type == GL_TEXTURE_RECTANGLE_ARB) ||
 
81
        (Type == GL_TEXTURE_3D) ||
 
82
        (Type == GL_TEXTURE_CUBE_MAP_ARB),
 
83
        TEXT("Error[GLTextureStates::GLTextureStates]: Invalid texture type."));
 
84
 
 
85
    m_Type = Type;
 
86
}
 
87
 
 
88
void GLTextureStates::ResetDefault()
 
89
{
 
90
 
 
91
}
 
92
 
 
93
void GLTextureStates::ResetStateChangeToDefault()
 
94
{
 
95
 
 
96
}
 
97
 
 
98
void GLTextureStates::SetRenderStates()
 
99
{
 
100
    HW_SetFiltering();
 
101
    HW_SetWrap();
 
102
    HW_SetLOD();
 
103
    HW_SetMipLevel();
 
104
}
 
105
 
 
106
#define SET_TS_VALUE(a, b)  if(a.iValue != b){(a).iValue = (b); (a).Dirty = true;}
 
107
#define TS_VALUE(a, b)      (a).iValue
 
108
 
 
109
#define SET_TS_VALUE_FLOAT(a, b)  if(a.fValue != b){(a).fValue = (b); (a).Dirty = true;}
 
110
#define TS_VALUE_FLOAT(a, b)      (a).fValue
 
111
 
 
112
 
 
113
void GLTextureStates::HW_SetFiltering()
 
114
{
 
115
    if(m_TextureStateChanges[GFXTS_MINFILTER].Dirty || m_TextureStateChanges[GFXTS_MAGFILTER].Dirty)
 
116
    {
 
117
        CHECKGL( glTexParameteri(m_Type, GL_TEXTURE_MIN_FILTER,   m_TextureStateChanges[GFXTS_MINFILTER].iValue ) );
 
118
        CHECKGL( glTexParameteri(m_Type, GL_TEXTURE_MAG_FILTER,   m_TextureStateChanges[GFXTS_MAGFILTER].iValue) );
 
119
        m_TextureStateChanges[GFXTS_MINFILTER].Dirty = false;
 
120
        m_TextureStateChanges[GFXTS_MAGFILTER].Dirty = false;
 
121
    }
 
122
}
 
123
 
 
124
void GLTextureStates::HW_SetWrap()
 
125
{
 
126
    if(m_TextureStateChanges[GFXTS_ADDRESSU].Dirty ||
 
127
        m_TextureStateChanges[GFXTS_ADDRESSV].Dirty ||
 
128
        m_TextureStateChanges[GFXTS_ADDRESSW].Dirty)
 
129
    {
 
130
        CHECKGL( glTexParameteri(m_Type, GL_TEXTURE_WRAP_S,       m_TextureStateChanges[GFXTS_ADDRESSU].iValue) );
 
131
        CHECKGL( glTexParameteri(m_Type, GL_TEXTURE_WRAP_T,       m_TextureStateChanges[GFXTS_ADDRESSV].iValue) );
 
132
        CHECKGL( glTexParameteri(m_Type, GL_TEXTURE_WRAP_R,       m_TextureStateChanges[GFXTS_ADDRESSW].iValue) );
 
133
        m_TextureStateChanges[GFXTS_ADDRESSU].Dirty = false;
 
134
        m_TextureStateChanges[GFXTS_ADDRESSV].Dirty = false;
 
135
        m_TextureStateChanges[GFXTS_ADDRESSW].Dirty = false;
 
136
    }
 
137
}
 
138
 
 
139
void GLTextureStates::HW_SetLOD()
 
140
{
 
141
    if(m_Type == GL_TEXTURE_RECTANGLE_ARB)
 
142
    {
 
143
        // No support for mip LOP on rectangle texture.
 
144
        // ATI seems to not generate and Error.
 
145
        // Nvidia generates an error
 
146
        m_TextureStateChanges[GFXTS_MIN_LOD].Dirty = false;
 
147
        m_TextureStateChanges[GFXTS_MAX_LOD].Dirty = false;
 
148
        return;
 
149
    }
 
150
    if(m_TextureStateChanges[GFXTS_MIN_LOD].Dirty || m_TextureStateChanges[GFXTS_MAX_LOD].Dirty)
 
151
    {
 
152
        CHECKGL( glTexParameteri(m_Type, GL_TEXTURE_MIN_LOD,  m_TextureStateChanges[GFXTS_MIN_LOD].fValue) );
 
153
        CHECKGL( glTexParameteri(m_Type, GL_TEXTURE_MAX_LOD,  m_TextureStateChanges[GFXTS_MAX_LOD].fValue) );
 
154
        m_TextureStateChanges[GFXTS_MIN_LOD].Dirty = false;
 
155
        m_TextureStateChanges[GFXTS_MAX_LOD].Dirty = false;
 
156
    }
 
157
}
 
158
 
 
159
void GLTextureStates::HW_SetMipLevel()
 
160
{
 
161
    if(m_TextureStateChanges[GFXTS_MIN_LOD].Dirty || m_TextureStateChanges[GFXTS_MAX_LOD].Dirty)
 
162
    {
 
163
        CHECKGL( glTexParameteri(m_Type, GL_TEXTURE_MIN_LOD,  m_TextureStateChanges[GFXTS_MIN_LOD].fValue) );
 
164
        CHECKGL( glTexParameteri(m_Type, GL_TEXTURE_MAX_LOD,  m_TextureStateChanges[GFXTS_MAX_LOD].fValue) );
 
165
        m_TextureStateChanges[GFXTS_MIN_LOD].Dirty = false;
 
166
        m_TextureStateChanges[GFXTS_MAX_LOD].Dirty = false;
 
167
    }
 
168
}
 
169
 
 
170
void GLTextureStates::HW_SetBorderColor()
 
171
{
 
172
 
 
173
}
 
174
 
 
175
void GLTextureStates::SetFiltering(
 
176
    unsigned int MinFilter,
 
177
    unsigned int MagFilter
 
178
    /*,unsigned int MIP*/)
 
179
{
 
180
    nuxAssertMsg(
 
181
        (MinFilter == GL_LINEAR) ||
 
182
        (MinFilter == GL_NEAREST) ||
 
183
        (MinFilter == GL_NEAREST_MIPMAP_NEAREST) ||
 
184
        (MinFilter == GL_LINEAR_MIPMAP_NEAREST) ||
 
185
        (MinFilter == GL_NEAREST_MIPMAP_LINEAR) ||
 
186
        (MinFilter == GL_LINEAR_MIPMAP_LINEAR),
 
187
        TEXT("Error[GLTextureStates::SetFiltering]: Invalid MinFilter state"));
 
188
 
 
189
    nuxAssertMsg(
 
190
        (MagFilter == GL_LINEAR) ||
 
191
        (MagFilter == GL_NEAREST),
 
192
        TEXT("Error[GLTextureStates::SetFiltering]: Invalid MagFilter state"));
 
193
 
 
194
    //    nuxAssertMsg(
 
195
    //        (MIP == GL_LINEAR) ||
 
196
    //        (MIP == GL_NEAREST),
 
197
    //        TEXT("Error[GLTextureStates::SetFiltering]: Invalid Mipmap Filter State"));
 
198
 
 
199
    if(m_Type == GL_TEXTURE_RECTANGLE_ARB)
 
200
    {
 
201
        if((MinFilter != GL_NEAREST) && (MinFilter != GL_LINEAR))
 
202
        {
 
203
            nuxError(TEXT("[GLTextureStates::SetFiltering] Incorrect MinFilter for rectangle texture."));
 
204
            SET_TS_VALUE(m_TextureStateChanges[GFXTS_MINFILTER], GL_LINEAR);
 
205
        }
 
206
        else
 
207
        {
 
208
            SET_TS_VALUE(m_TextureStateChanges[GFXTS_MINFILTER], MinFilter);
 
209
        }
 
210
 
 
211
        if((MagFilter != GL_NEAREST) && (MagFilter != GL_LINEAR))
 
212
        {
 
213
            nuxError(TEXT("[GLTextureStates::SetFiltering] Incorrect MagFilter for rectangle texture."));
 
214
            SET_TS_VALUE(m_TextureStateChanges[GFXTS_MAGFILTER], GL_LINEAR);
 
215
        }
 
216
        else
 
217
        {
 
218
            SET_TS_VALUE(m_TextureStateChanges[GFXTS_MAGFILTER], MagFilter);
 
219
        }
 
220
    }
 
221
    else
 
222
    {
 
223
        SET_TS_VALUE(m_TextureStateChanges[GFXTS_MINFILTER], MinFilter);
 
224
        SET_TS_VALUE(m_TextureStateChanges[GFXTS_MAGFILTER], MagFilter);
 
225
    }
 
226
    //SET_TS_VALUE(m_TextureStateChanges[GFXTS_MIPFILTER], MIP);
 
227
}
 
228
 
 
229
void GLTextureStates::SetWrap(
 
230
                                     unsigned int U,
 
231
                                     unsigned int V,
 
232
                                     unsigned int W)
 
233
{
 
234
    nuxAssertMsg(
 
235
        (U == GL_CLAMP) ||
 
236
        (U == GL_CLAMP_TO_EDGE) ||
 
237
        (U == GL_CLAMP_TO_BORDER) ||
 
238
        (U == GL_MIRRORED_REPEAT) ||
 
239
        (U == GL_MIRROR_CLAMP_EXT) ||
 
240
        (U == GL_MIRROR_CLAMP_TO_EDGE_EXT) ||
 
241
        (U == GL_MIRROR_CLAMP_TO_BORDER_EXT) ||
 
242
        (U == GL_REPEAT),
 
243
        TEXT("Error[GLTextureStates::SetWrap]: Invalid U Wrap State"));
 
244
 
 
245
    nuxAssertMsg(
 
246
        (V == GL_CLAMP) ||
 
247
        (V == GL_CLAMP_TO_EDGE) ||
 
248
        (V == GL_CLAMP_TO_BORDER) ||
 
249
        (V == GL_MIRRORED_REPEAT) ||
 
250
        (V == GL_MIRROR_CLAMP_EXT) ||
 
251
        (V == GL_MIRROR_CLAMP_TO_EDGE_EXT) ||
 
252
        (V == GL_MIRROR_CLAMP_TO_BORDER_EXT) ||
 
253
        (V == GL_REPEAT),
 
254
        TEXT("Error[GLTextureStates::SetWrap]: Invalid V Wrap State"));
 
255
    nuxAssertMsg(
 
256
        (W == GL_CLAMP) ||
 
257
        (W == GL_CLAMP_TO_EDGE) ||
 
258
        (W == GL_CLAMP_TO_BORDER) ||
 
259
        (W == GL_MIRRORED_REPEAT) ||
 
260
        (W == GL_MIRROR_CLAMP_EXT) ||
 
261
        (W == GL_MIRROR_CLAMP_TO_EDGE_EXT) ||
 
262
        (W == GL_MIRROR_CLAMP_TO_BORDER_EXT) ||
 
263
        (W == GL_REPEAT),
 
264
        TEXT("Error[GLTextureStates::SetWrap]: Invalid W Wrap State"));
 
265
 
 
266
    if(m_Type == GL_TEXTURE_RECTANGLE_ARB)
 
267
    {
 
268
        if((U != GL_CLAMP) && (U != GL_CLAMP_TO_BORDER) && (U != GL_CLAMP_TO_EDGE))
 
269
        {
 
270
            nuxError(TEXT("[GLTextureStates::SetFiltering] Incorrect warp for rectangle texture."));
 
271
            SET_TS_VALUE(m_TextureStateChanges[GFXTS_ADDRESSU], GL_CLAMP_TO_EDGE);
 
272
        }
 
273
        else
 
274
        {
 
275
            SET_TS_VALUE(m_TextureStateChanges[GFXTS_ADDRESSU], U);
 
276
        }
 
277
 
 
278
        if((V != GL_CLAMP) && (V != GL_CLAMP_TO_BORDER) && (V != GL_CLAMP_TO_EDGE))
 
279
        {
 
280
            nuxError(TEXT("[GLTextureStates::SetFiltering] Incorrect warp for rectangle texture."));
 
281
            SET_TS_VALUE(m_TextureStateChanges[GFXTS_ADDRESSV], GL_CLAMP_TO_EDGE);
 
282
        }
 
283
        else
 
284
        {
 
285
            SET_TS_VALUE(m_TextureStateChanges[GFXTS_ADDRESSV], V);
 
286
        }
 
287
 
 
288
        if((W != GL_CLAMP) && (W != GL_CLAMP_TO_BORDER) && (W != GL_CLAMP_TO_EDGE))
 
289
        {
 
290
            nuxError(TEXT("[GLTextureStates::SetFiltering] Incorrect warp for rectangle texture."));
 
291
            SET_TS_VALUE(m_TextureStateChanges[GFXTS_ADDRESSW], GL_CLAMP_TO_EDGE);
 
292
        }
 
293
        else
 
294
        {
 
295
            SET_TS_VALUE(m_TextureStateChanges[GFXTS_ADDRESSW], W);
 
296
        }
 
297
    }
 
298
    else
 
299
    {
 
300
        SET_TS_VALUE(m_TextureStateChanges[GFXTS_ADDRESSU], U);
 
301
        SET_TS_VALUE(m_TextureStateChanges[GFXTS_ADDRESSV], V);
 
302
        SET_TS_VALUE(m_TextureStateChanges[GFXTS_ADDRESSW], W);
 
303
    }
 
304
}
 
305
 
 
306
void GLTextureStates::SetLOD(float MinLod,
 
307
                                    float MaxLod)
 
308
{
 
309
    SET_TS_VALUE_FLOAT(m_TextureStateChanges[GFXTS_MIN_LOD], MinLod);
 
310
    SET_TS_VALUE_FLOAT(m_TextureStateChanges[GFXTS_MAX_LOD], MaxLod);
 
311
}
 
312
 
 
313
void GLTextureStates::SetMipLevel(
 
314
    unsigned int MinMip,
 
315
    unsigned int MaxMip)
 
316
{
 
317
    SET_TS_VALUE(m_TextureStateChanges[GFXTS_MIP_BASE_LEVEL], MinMip);
 
318
    SET_TS_VALUE(m_TextureStateChanges[GFXTS_MIP_MAX_LEVEL], MaxMip);
 
319
}
 
320
 
 
321
void GLTextureStates::SetBorderColor(
 
322
    float R,
 
323
    float G,
 
324
    float B,
 
325
    float A)
 
326
{
 
327
    unsigned int r, g, b, a;
 
328
    r = 255 * Clamp(R, 0.0f, 1.0f);
 
329
    g = 255 * Clamp(G, 0.0f, 1.0f);
 
330
    b = 255 * Clamp(B, 0.0f, 1.0f);
 
331
    a = 255 * Clamp(A, 0.0f, 1.0f);
 
332
    unsigned int color = (unsigned int) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b));
 
333
 
 
334
    SET_TS_VALUE(m_TextureStateChanges[GFXTS_BORDERCOLOR], color);
 
335
}
 
336
 
 
337
#undef SET_TS_VALUE
 
338
#undef TS_VALUE
 
339
 
 
340
#undef SET_TS_VALUE_FLOAT
 
341
#undef TS_VALUE_FLOAT
 
342
 
 
343
NAMESPACE_END_OGL