blob: cc8adc6397591d1a4fa96b37ec4649eb1e1d9485 (
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
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
|
// Copyright (C) 2002-2012 Nikolaus Gebhardt / Thomas Alten
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#ifndef __C_SOFTWARE_2_TEXTURE_H_INCLUDED__
#define __C_SOFTWARE_2_TEXTURE_H_INCLUDED__
#include "SoftwareDriver2_compile_config.h"
#include "ITexture.h"
#include "CImage.h"
namespace irr
{
namespace video
{
/*!
interface for a Video Driver dependent Texture.
*/
class CSoftwareTexture2 : public ITexture
{
public:
//! constructor
enum eTex2Flags
{
GEN_MIPMAP = 1,
IS_RENDERTARGET = 2,
NP2_SIZE = 4,
HAS_ALPHA = 8
};
CSoftwareTexture2(IImage* surface, const io::path& name, u32 flags, void* mipmapData=0);
//! destructor
virtual ~CSoftwareTexture2();
//! lock function
virtual void* lock(E_TEXTURE_LOCK_MODE mode=ETLM_READ_WRITE, u32 mipmapLevel=0)
{
if (Flags & GEN_MIPMAP)
MipMapLOD=mipmapLevel;
return MipMap[MipMapLOD]->lock();
}
//! unlock function
virtual void unlock()
{
MipMap[MipMapLOD]->unlock();
}
//! Returns original size of the texture.
virtual const core::dimension2d<u32>& getOriginalSize() const
{
//return MipMap[0]->getDimension();
return OrigSize;
}
//! Returns the size of the largest mipmap.
f32 getLODFactor( const f32 texArea ) const
{
return OrigImageDataSizeInPixels * texArea;
//return MipMap[0]->getImageDataSizeInPixels () * texArea;
}
//! Returns (=size) of the texture.
virtual const core::dimension2d<u32>& getSize() const
{
return MipMap[MipMapLOD]->getDimension();
}
//! returns unoptimized surface
virtual CImage* getImage() const
{
return MipMap[0];
}
//! returns texture surface
virtual CImage* getTexture() const
{
return MipMap[MipMapLOD];
}
//! returns driver type of texture (=the driver, who created the texture)
virtual E_DRIVER_TYPE getDriverType() const
{
return EDT_BURNINGSVIDEO;
}
//! returns color format of texture
virtual ECOLOR_FORMAT getColorFormat() const
{
return BURNINGSHADER_COLOR_FORMAT;
}
//! returns pitch of texture (in bytes)
virtual u32 getPitch() const
{
return MipMap[MipMapLOD]->getPitch();
}
//! Regenerates the mip map levels of the texture. Useful after locking and
//! modifying the texture
virtual void regenerateMipMapLevels(void* mipmapData=0);
//! support mipmaps
virtual bool hasMipMaps() const
{
return (Flags & GEN_MIPMAP ) != 0;
}
//! Returns if the texture has an alpha channel
virtual bool hasAlpha() const
{
return (Flags & HAS_ALPHA ) != 0;
}
//! is a render target
virtual bool isRenderTarget() const
{
return (Flags & IS_RENDERTARGET) != 0;
}
private:
f32 OrigImageDataSizeInPixels;
core::dimension2d<u32> OrigSize;
CImage * MipMap[SOFTWARE_DRIVER_2_MIPMAPPING_MAX];
u32 MipMapLOD;
u32 Flags;
ECOLOR_FORMAT OriginalFormat;
};
} // end namespace video
} // end namespace irr
#endif
|
