← Back to branch summary

~baltix/+junk/irrlicht-test

« back to all changes in this revision

Viewing changes to source/Irrlicht/IBurningShader.h

  • Committer: Mantas Kriaučiūnas
  • Date: 2011-07-18 13:06:25 UTC
  • Revision ID: mantas@akl.lt-20110718130625-c5pvifp61e7kj1ol
Included whole irrlicht SVN libraries to work around launchpad recipe issue with quilt, see https://answers.launchpad.net/launchpad/+question/165193

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/Irrlicht/IBurningShader.h
 
1
// Copyright (C) 2002-2011 Nikolaus Gebhardt / Thomas Alten
 
2
// This file is part of the "Irrlicht Engine".
 
3
// For conditions of distribution and use, see copyright notice in irrlicht.h
 
4
 
 
5
#ifndef __I_BURNING_SHADER_H_INCLUDED__
 
6
#define __I_BURNING_SHADER_H_INCLUDED__
 
7
 
 
8
#include "SoftwareDriver2_compile_config.h"
 
9
#include "IReferenceCounted.h"
 
10
#include "irrMath.h"
 
11
#include "IImage.h"
 
12
#include "S2DVertex.h"
 
13
#include "rect.h"
 
14
#include "CDepthBuffer.h"
 
15
#include "S4DVertex.h"
 
16
#include "irrArray.h"
 
17
#include "SLight.h"
 
18
#include "SMaterial.h"
 
19
#include "os.h"
 
20
 
 
21
 
 
22
namespace irr
 
23
{
 
24
 
 
25
namespace video
 
26
{
 
27
 
 
28
        struct SBurningShaderLight
 
29
        {
 
30
                //SLight org;
 
31
                bool LightIsOn;
 
32
 
 
33
                E_LIGHT_TYPE Type;
 
34
                f32 radius;
 
35
                f32 linearAttenuation;
 
36
                f32 constantAttenuation;
 
37
                f32 quadraticAttenuation;
 
38
                sVec4 pos;
 
39
 
 
40
                sVec3 AmbientColor;
 
41
                sVec3 DiffuseColor;
 
42
                sVec3 SpecularColor;
 
43
                sVec4 pos_objectspace;
 
44
        };
 
45
 
 
46
        enum eLightFlags
 
47
        {
 
48
                ENABLED         = 0x01,
 
49
                POINTLIGHT      = 0x02,
 
50
                SPECULAR        = 0x04,
 
51
                FOG                     = 0x08,
 
52
                NORMALIZE       = 0x10,
 
53
                VERTEXTRANSFORM = 0x20,
 
54
        };
 
55
 
 
56
        struct SBurningShaderLightSpace
 
57
        {
 
58
                void reset ()
 
59
                {
 
60
                        Light.set_used ( 0 );
 
61
                        Global_AmbientLight.set ( 0.f, 0.f, 0.f );
 
62
                        Flags = 0;
 
63
                }
 
64
                core::array<SBurningShaderLight> Light;
 
65
                sVec3 Global_AmbientLight;
 
66
                sVec4 FogColor;
 
67
                sVec4 campos;
 
68
                sVec4 vertex;
 
69
                sVec4 normal;
 
70
                u32 Flags;
 
71
        };
 
72
 
 
73
        struct SBurningShaderMaterial
 
74
        {
 
75
                SMaterial org;
 
76
 
 
77
                sVec3 AmbientColor;
 
78
                sVec3 DiffuseColor;
 
79
                sVec3 SpecularColor;
 
80
                sVec3 EmissiveColor;
 
81
 
 
82
        };
 
83
 
 
84
        enum EBurningFFShader
 
85
        {
 
86
                ETR_FLAT = 0,
 
87
                ETR_FLAT_WIRE,
 
88
                ETR_GOURAUD,
 
89
                ETR_GOURAUD_WIRE,
 
90
                ETR_TEXTURE_FLAT,
 
91
                ETR_TEXTURE_FLAT_WIRE,
 
92
                ETR_TEXTURE_GOURAUD,
 
93
                ETR_TEXTURE_GOURAUD_WIRE,
 
94
                ETR_TEXTURE_GOURAUD_NOZ,
 
95
                ETR_TEXTURE_GOURAUD_ADD,
 
96
                ETR_TEXTURE_GOURAUD_ADD_NO_Z,
 
97
 
 
98
                ETR_TEXTURE_GOURAUD_VERTEX_ALPHA,
 
99
 
 
100
                ETR_TEXTURE_GOURAUD_LIGHTMAP_M1,
 
101
                ETR_TEXTURE_GOURAUD_LIGHTMAP_M2,
 
102
                ETR_TEXTURE_GOURAUD_LIGHTMAP_M4,
 
103
                ETR_TEXTURE_LIGHTMAP_M4,
 
104
 
 
105
                ETR_TEXTURE_GOURAUD_DETAIL_MAP,
 
106
                ETR_TEXTURE_GOURAUD_LIGHTMAP_ADD,
 
107
        
 
108
                ETR_GOURAUD_ALPHA,
 
109
                ETR_GOURAUD_ALPHA_NOZ,
 
110
 
 
111
                ETR_TEXTURE_GOURAUD_ALPHA,
 
112
                ETR_TEXTURE_GOURAUD_ALPHA_NOZ,
 
113
 
 
114
                ETR_NORMAL_MAP_SOLID,
 
115
                ETR_STENCIL_SHADOW,
 
116
 
 
117
                ETR_TEXTURE_BLEND,
 
118
                ETR_REFERENCE,
 
119
                ETR_INVALID,
 
120
 
 
121
                ETR2_COUNT
 
122
        };
 
123
 
 
124
 
 
125
        class CBurningVideoDriver;
 
126
        class IBurningShader : public virtual IReferenceCounted
 
127
        {
 
128
        public:
 
129
                IBurningShader(CBurningVideoDriver* driver);
 
130
 
 
131
                //! destructor
 
132
                virtual ~IBurningShader();
 
133
 
 
134
                //! sets a render target
 
135
                virtual void setRenderTarget(video::IImage* surface, const core::rect<s32>& viewPort);
 
136
 
 
137
                //! sets the Texture
 
138
                virtual void setTextureParam( u32 stage, video::CSoftwareTexture2* texture, s32 lodLevel);
 
139
                virtual void drawTriangle ( const s4DVertex *a,const s4DVertex *b,const s4DVertex *c ) = 0;
 
140
                virtual void drawLine ( const s4DVertex *a,const s4DVertex *b) {};
 
141
 
 
142
                virtual void setParam ( u32 index, f32 value) {};
 
143
                virtual void setZCompareFunc ( u32 func) {};
 
144
 
 
145
                virtual void setMaterial ( const SBurningShaderMaterial &material ) {};
 
146
 
 
147
        protected:
 
148
 
 
149
                CBurningVideoDriver *Driver;
 
150
 
 
151
                video::CImage* RenderTarget;
 
152
                CDepthBuffer* DepthBuffer;
 
153
                CStencilBuffer * Stencil;
 
154
                tVideoSample ColorMask;
 
155
 
 
156
                sInternalTexture IT[ BURNING_MATERIAL_MAX_TEXTURES ];
 
157
 
 
158
                static const tFixPointu dithermask[ 4 * 4];
 
159
        };
 
160
 
 
161
 
 
162
        IBurningShader* createTriangleRendererTextureGouraud2(CBurningVideoDriver* driver);
 
163
        IBurningShader* createTriangleRendererTextureLightMap2_M1(CBurningVideoDriver* driver);
 
164
        IBurningShader* createTriangleRendererTextureLightMap2_M2(CBurningVideoDriver* driver);
 
165
        IBurningShader* createTriangleRendererTextureLightMap2_M4(CBurningVideoDriver* driver);
 
166
        IBurningShader* createTriangleRendererGTextureLightMap2_M4(CBurningVideoDriver* driver);
 
167
        IBurningShader* createTriangleRendererTextureLightMap2_Add(CBurningVideoDriver* driver);
 
168
        IBurningShader* createTriangleRendererTextureDetailMap2(CBurningVideoDriver* driver);
 
169
        IBurningShader* createTriangleRendererTextureVertexAlpha2(CBurningVideoDriver* driver);
 
170
 
 
171
 
 
172
        IBurningShader* createTriangleRendererTextureGouraudWire2(CBurningVideoDriver* driver);
 
173
        IBurningShader* createTriangleRendererGouraud2(CBurningVideoDriver* driver);
 
174
        IBurningShader* createTriangleRendererGouraudAlpha2(CBurningVideoDriver* driver);
 
175
        IBurningShader* createTRGouraudAlphaNoZ2(CBurningVideoDriver* driver);
 
176
        IBurningShader* createTriangleRendererGouraudWire2(CBurningVideoDriver* driver);
 
177
        IBurningShader* createTriangleRendererTextureFlat2(CBurningVideoDriver* driver);
 
178
        IBurningShader* createTriangleRendererTextureFlatWire2(CBurningVideoDriver* driver);
 
179
        IBurningShader* createTRFlat2(CBurningVideoDriver* driver);
 
180
        IBurningShader* createTRFlatWire2(CBurningVideoDriver* driver);
 
181
        IBurningShader* createTRTextureGouraudNoZ2(CBurningVideoDriver* driver);
 
182
        IBurningShader* createTRTextureGouraudAdd2(CBurningVideoDriver* driver);
 
183
        IBurningShader* createTRTextureGouraudAddNoZ2(CBurningVideoDriver* driver);
 
184
 
 
185
        IBurningShader* createTRTextureGouraudAlpha(CBurningVideoDriver* driver);
 
186
        IBurningShader* createTRTextureGouraudAlphaNoZ(CBurningVideoDriver* driver);
 
187
        IBurningShader* createTRTextureBlend(CBurningVideoDriver* driver);
 
188
        IBurningShader* createTRTextureInverseAlphaBlend(CBurningVideoDriver* driver);
 
189
 
 
190
        IBurningShader* createTRNormalMap(CBurningVideoDriver* driver);
 
191
        IBurningShader* createTRStencilShadow(CBurningVideoDriver* driver);
 
192
 
 
193
        IBurningShader* createTriangleRendererReference(CBurningVideoDriver* driver);
 
194
 
 
195
 
 
196
 
 
197
} // end namespace video
 
198
} // end namespace irr
 
199
 
 
200
#endif
 
201