source/Irrlicht/OpenGL/FixedPipelineRenderer.cpp

   1 // Copyright (C) 2014 Patryk Nadrowski
   2 // This file is part of the "Irrlicht Engine".
   3 // For conditions of distribution and use, see copyright notice in Irrlicht.h
   4
   5 #include "FixedPipelineRenderer.h"
   6
   7 #include "IVideoDriver.h"
   8
   9 namespace irr
  10 {
  11 namespace video
  12 {
  13
  14 // Base callback
  15
  16 COpenGL3MaterialBaseCB::COpenGL3MaterialBaseCB() :
  17         FirstUpdateBase(true), WVPMatrixID(-1), WVMatrixID(-1), NMatrixID(-1), GlobalAmbientID(-1), MaterialAmbientID(-1), MaterialDiffuseID(-1), MaterialEmissiveID(-1), MaterialSpecularID(-1), MaterialShininessID(-1),
  18         FogEnableID(-1), FogTypeID(-1), FogColorID(-1), FogStartID(-1),
  19         FogEndID(-1), FogDensityID(-1), ThicknessID(-1), LightEnable(false), MaterialAmbient(SColorf(0.f, 0.f, 0.f)), MaterialDiffuse(SColorf(0.f, 0.f, 0.f)), MaterialEmissive(SColorf(0.f, 0.f, 0.f)), MaterialSpecular(SColorf(0.f, 0.f, 0.f)),
  20         MaterialShininess(0.f), FogEnable(0), FogType(1), FogColor(SColorf(0.f, 0.f, 0.f, 1.f)), FogStart(0.f), FogEnd(0.f), FogDensity(0.f), Thickness(1.f)
  21 {
  22 }
  23
  24 void COpenGL3MaterialBaseCB::OnSetMaterial(const SMaterial& material)
  25 {
  26         LightEnable = material.Lighting;
  27         MaterialAmbient = SColorf(material.AmbientColor);
  28         MaterialDiffuse = SColorf(material.DiffuseColor);
  29         MaterialEmissive = SColorf(material.EmissiveColor);
  30         MaterialSpecular = SColorf(material.SpecularColor);
  31         MaterialShininess = material.Shininess;
  32
  33         FogEnable = material.FogEnable ? 1 : 0;
  34
  35         Thickness = (material.Thickness > 0.f) ? material.Thickness : 1.f;
  36 }
  37
  38 void COpenGL3MaterialBaseCB::OnSetConstants(IMaterialRendererServices* services, s32 userData)
  39 {
  40         IVideoDriver* driver = services->getVideoDriver();
  41
  42         if (FirstUpdateBase)
  43         {
  44                 WVPMatrixID = services->getVertexShaderConstantID("uWVPMatrix");
  45                 WVMatrixID = services->getVertexShaderConstantID("uWVMatrix");
  46                 NMatrixID = services->getVertexShaderConstantID("uNMatrix");
  47                 GlobalAmbientID = services->getVertexShaderConstantID("uGlobalAmbient");
  48                 MaterialAmbientID = services->getVertexShaderConstantID("uMaterialAmbient");
  49                 MaterialDiffuseID = services->getVertexShaderConstantID("uMaterialDiffuse");
  50                 MaterialEmissiveID = services->getVertexShaderConstantID("uMaterialEmissive");
  51                 MaterialSpecularID = services->getVertexShaderConstantID("uMaterialSpecular");
  52                 MaterialShininessID = services->getVertexShaderConstantID("uMaterialShininess");
  53                 FogEnableID = services->getVertexShaderConstantID("uFogEnable");
  54                 FogTypeID = services->getVertexShaderConstantID("uFogType");
  55                 FogColorID = services->getVertexShaderConstantID("uFogColor");
  56                 FogStartID = services->getVertexShaderConstantID("uFogStart");
  57                 FogEndID = services->getVertexShaderConstantID("uFogEnd");
  58                 FogDensityID = services->getVertexShaderConstantID("uFogDensity");
  59                 ThicknessID = services->getVertexShaderConstantID("uThickness");
  60
  61                 FirstUpdateBase = false;
  62         }
  63
  64         const core::matrix4 W = driver->getTransform(ETS_WORLD);
  65         const core::matrix4 V = driver->getTransform(ETS_VIEW);
  66         const core::matrix4 P = driver->getTransform(ETS_PROJECTION);
  67
  68         core::matrix4 Matrix = P * V * W;
  69         services->setPixelShaderConstant(WVPMatrixID, Matrix.pointer(), 16);
  70
  71         Matrix = V * W;
  72         services->setPixelShaderConstant(WVMatrixID, Matrix.pointer(), 16);
  73
  74         Matrix.makeInverse();
  75         services->setPixelShaderConstant(NMatrixID, Matrix.getTransposed().pointer(), 16);
  76
  77         services->setPixelShaderConstant(FogEnableID, &FogEnable, 1);
  78
  79         if (FogEnable)
  80         {
  81                 SColor TempColor(0);
  82                 E_FOG_TYPE TempType = EFT_FOG_LINEAR;
  83                 bool TempPerFragment = false;
  84                 bool TempRange = false;
  85
  86                 driver->getFog(TempColor, TempType, FogStart, FogEnd, FogDensity, TempPerFragment, TempRange);
  87
  88                 FogType = (s32)TempType;
  89                 FogColor = SColorf(TempColor);
  90
  91                 services->setPixelShaderConstant(FogTypeID, &FogType, 1);
  92                 services->setPixelShaderConstant(FogColorID, reinterpret_cast<f32*>(&FogColor), 4);
  93                 services->setPixelShaderConstant(FogStartID, &FogStart, 1);
  94                 services->setPixelShaderConstant(FogEndID, &FogEnd, 1);
  95                 services->setPixelShaderConstant(FogDensityID, &FogDensity, 1);
  96         }
  97
  98         services->setPixelShaderConstant(ThicknessID, &Thickness, 1);
  99 }
 100
 101 // EMT_SOLID + EMT_TRANSPARENT_ADD_COLOR + EMT_TRANSPARENT_ALPHA_CHANNEL + EMT_TRANSPARENT_VERTEX_ALPHA
 102
 103 COpenGL3MaterialSolidCB::COpenGL3MaterialSolidCB() :
 104         FirstUpdate(true), TMatrix0ID(-1), AlphaRefID(-1), TextureUsage0ID(-1), TextureUnit0ID(-1), AlphaRef(0.5f), TextureUsage0(0), TextureUnit0(0)
 105 {
 106 }
 107
 108 void COpenGL3MaterialSolidCB::OnSetMaterial(const SMaterial& material)
 109 {
 110         COpenGL3MaterialBaseCB::OnSetMaterial(material);
 111
 112         AlphaRef = material.MaterialTypeParam;
 113         TextureUsage0 = (material.TextureLayer[0].Texture) ? 1 : 0;
 114 }
 115
 116 void COpenGL3MaterialSolidCB::OnSetConstants(IMaterialRendererServices* services, s32 userData)
 117 {
 118         COpenGL3MaterialBaseCB::OnSetConstants(services, userData);
 119
 120         IVideoDriver* driver = services->getVideoDriver();
 121
 122         if (FirstUpdate)
 123         {
 124                 TMatrix0ID = services->getVertexShaderConstantID("uTMatrix0");
 125                 AlphaRefID = services->getVertexShaderConstantID("uAlphaRef");
 126                 TextureUsage0ID = services->getVertexShaderConstantID("uTextureUsage0");
 127                 TextureUnit0ID = services->getVertexShaderConstantID("uTextureUnit0");
 128
 129                 FirstUpdate = false;
 130         }
 131
 132         core::matrix4 Matrix = driver->getTransform(ETS_TEXTURE_0);
 133         services->setPixelShaderConstant(TMatrix0ID, Matrix.pointer(), 16);
 134
 135         services->setPixelShaderConstant(AlphaRefID, &AlphaRef, 1);
 136         services->setPixelShaderConstant(TextureUsage0ID, &TextureUsage0, 1);
 137         services->setPixelShaderConstant(TextureUnit0ID, &TextureUnit0, 1);
 138 }
 139
 140 // EMT_SOLID_2_LAYER + EMT_DETAIL_MAP
 141
 142 COpenGL3MaterialSolid2CB::COpenGL3MaterialSolid2CB() :
 143         FirstUpdate(true), TMatrix0ID(-1), TMatrix1ID(-1), TextureUsage0ID(-1), TextureUsage1ID(-1), TextureUnit0ID(-1), TextureUnit1ID(-1),
 144         TextureUsage0(0), TextureUsage1(0), TextureUnit0(0), TextureUnit1(1)
 145 {
 146 }
 147
 148 void COpenGL3MaterialSolid2CB::OnSetMaterial(const SMaterial& material)
 149 {
 150         COpenGL3MaterialBaseCB::OnSetMaterial(material);
 151
 152         TextureUsage0 = (material.TextureLayer[0].Texture) ? 1 : 0;
 153         TextureUsage1 = (material.TextureLayer[1].Texture) ? 1 : 0;
 154 }
 155
 156 void COpenGL3MaterialSolid2CB::OnSetConstants(IMaterialRendererServices* services, s32 userData)
 157 {
 158         COpenGL3MaterialBaseCB::OnSetConstants(services, userData);
 159
 160         IVideoDriver* driver = services->getVideoDriver();
 161
 162         if (FirstUpdate)
 163         {
 164                 TMatrix0ID = services->getVertexShaderConstantID("uTMatrix0");
 165                 TMatrix1ID = services->getVertexShaderConstantID("uTMatrix1");
 166                 TextureUsage0ID = services->getVertexShaderConstantID("uTextureUsage0");
 167                 TextureUsage1ID = services->getVertexShaderConstantID("uTextureUsage1");
 168                 TextureUnit0ID = services->getVertexShaderConstantID("uTextureUnit0");
 169                 TextureUnit1ID = services->getVertexShaderConstantID("uTextureUnit1");
 170
 171                 FirstUpdate = false;
 172         }
 173
 174         core::matrix4 Matrix = driver->getTransform(ETS_TEXTURE_0);
 175         services->setPixelShaderConstant(TMatrix0ID, Matrix.pointer(), 16);
 176
 177         Matrix = driver->getTransform(E_TRANSFORMATION_STATE(ETS_TEXTURE_0 + 1));
 178         services->setPixelShaderConstant(TMatrix1ID, Matrix.pointer(), 16);
 179
 180         services->setPixelShaderConstant(TextureUsage0ID, &TextureUsage0, 1);
 181         services->setPixelShaderConstant(TextureUsage1ID, &TextureUsage1, 1);
 182         services->setPixelShaderConstant(TextureUnit0ID, &TextureUnit0, 1);
 183         services->setPixelShaderConstant(TextureUnit1ID, &TextureUnit1, 1);
 184 }
 185
 186 // EMT_LIGHTMAP + EMT_LIGHTMAP_ADD + EMT_LIGHTMAP_M2 + EMT_LIGHTMAP_M4
 187
 188 COpenGL3MaterialLightmapCB::COpenGL3MaterialLightmapCB(float modulate) :
 189         FirstUpdate(true), TMatrix0ID(-1), TMatrix1ID(-1), ModulateID(-1), TextureUsage0ID(-1), TextureUsage1ID(-1), TextureUnit0ID(-1), TextureUnit1ID(-1),
 190         Modulate(modulate), TextureUsage0(0), TextureUsage1(0), TextureUnit0(0), TextureUnit1(1)
 191 {
 192 }
 193
 194 void COpenGL3MaterialLightmapCB::OnSetMaterial(const SMaterial& material)
 195 {
 196         COpenGL3MaterialBaseCB::OnSetMaterial(material);
 197
 198         TextureUsage0 = (material.TextureLayer[0].Texture) ? 1 : 0;
 199         TextureUsage1 = (material.TextureLayer[1].Texture) ? 1 : 0;
 200 }
 201
 202 void COpenGL3MaterialLightmapCB::OnSetConstants(IMaterialRendererServices* services, s32 userData)
 203 {
 204         COpenGL3MaterialBaseCB::OnSetConstants(services, userData);
 205
 206         IVideoDriver* driver = services->getVideoDriver();
 207
 208         if (FirstUpdate)
 209         {
 210                 TMatrix0ID = services->getVertexShaderConstantID("uTMatrix0");
 211                 TMatrix1ID = services->getVertexShaderConstantID("uTMatrix1");
 212                 ModulateID = services->getVertexShaderConstantID("uModulate");
 213                 TextureUsage0ID = services->getVertexShaderConstantID("uTextureUsage0");
 214                 TextureUsage1ID = services->getVertexShaderConstantID("uTextureUsage1");
 215                 TextureUnit0ID = services->getVertexShaderConstantID("uTextureUnit0");
 216                 TextureUnit1ID = services->getVertexShaderConstantID("uTextureUnit1");
 217
 218                 FirstUpdate = false;
 219         }
 220
 221         core::matrix4 Matrix = driver->getTransform(ETS_TEXTURE_0);
 222         services->setPixelShaderConstant(TMatrix0ID, Matrix.pointer(), 16);
 223
 224         Matrix = driver->getTransform(E_TRANSFORMATION_STATE(ETS_TEXTURE_0 + 1));
 225         services->setPixelShaderConstant(TMatrix1ID, Matrix.pointer(), 16);
 226
 227         services->setPixelShaderConstant(ModulateID, &Modulate, 1);
 228         services->setPixelShaderConstant(TextureUsage0ID, &TextureUsage0, 1);
 229         services->setPixelShaderConstant(TextureUsage1ID, &TextureUsage1, 1);
 230         services->setPixelShaderConstant(TextureUnit0ID, &TextureUnit0, 1);
 231         services->setPixelShaderConstant(TextureUnit1ID, &TextureUnit1, 1);
 232 }
 233
 234 // EMT_SPHERE_MAP + EMT_REFLECTION_2_LAYER + EMT_TRANSPARENT_REFLECTION_2_LAYER
 235
 236 COpenGL3MaterialReflectionCB::COpenGL3MaterialReflectionCB() :
 237         FirstUpdate(true), TMatrix0ID(-1), TextureUsage0ID(-1), TextureUsage1ID(-1), TextureUnit0ID(-1), TextureUnit1ID(-1),
 238         TextureUsage0(0), TextureUsage1(0), TextureUnit0(0), TextureUnit1(1)
 239 {
 240 }
 241
 242 void COpenGL3MaterialReflectionCB::OnSetMaterial(const SMaterial& material)
 243 {
 244         COpenGL3MaterialBaseCB::OnSetMaterial(material);
 245
 246         TextureUsage0 = (material.TextureLayer[0].Texture) ? 1 : 0;
 247         TextureUsage1 = (material.TextureLayer[1].Texture) ? 1 : 0;
 248 }
 249
 250 void COpenGL3MaterialReflectionCB::OnSetConstants(IMaterialRendererServices* services, s32 userData)
 251 {
 252         COpenGL3MaterialBaseCB::OnSetConstants(services, userData);
 253
 254         IVideoDriver* driver = services->getVideoDriver();
 255
 256         if (FirstUpdate)
 257         {
 258                 TMatrix0ID = services->getVertexShaderConstantID("uTMatrix0");
 259                 TextureUsage0ID = services->getVertexShaderConstantID("uTextureUsage0");
 260                 TextureUsage1ID = services->getVertexShaderConstantID("uTextureUsage1");
 261                 TextureUnit0ID = services->getVertexShaderConstantID("uTextureUnit0");
 262                 TextureUnit1ID = services->getVertexShaderConstantID("uTextureUnit1");
 263
 264                 FirstUpdate = false;
 265         }
 266
 267         core::matrix4 Matrix = driver->getTransform(ETS_TEXTURE_0);
 268         services->setPixelShaderConstant(TMatrix0ID, Matrix.pointer(), 16);
 269
 270         services->setPixelShaderConstant(TextureUsage0ID, &TextureUsage0, 1);
 271         services->setPixelShaderConstant(TextureUsage1ID, &TextureUsage1, 1);
 272         services->setPixelShaderConstant(TextureUnit0ID, &TextureUnit0, 1);
 273         services->setPixelShaderConstant(TextureUnit1ID, &TextureUnit1, 1);
 274 }
 275
 276 // EMT_ONETEXTURE_BLEND
 277
 278 COpenGL3MaterialOneTextureBlendCB::COpenGL3MaterialOneTextureBlendCB() :
 279         FirstUpdate(true), TMatrix0ID(-1), BlendTypeID(-1), TextureUsage0ID(-1), TextureUnit0ID(-1), BlendType(0), TextureUsage0(0), TextureUnit0(0)
 280 {
 281 }
 282
 283 void COpenGL3MaterialOneTextureBlendCB::OnSetMaterial(const SMaterial& material)
 284 {
 285         COpenGL3MaterialBaseCB::OnSetMaterial(material);
 286
 287         BlendType = 0;
 288
 289         E_BLEND_FACTOR srcRGBFact,dstRGBFact,srcAlphaFact,dstAlphaFact;
 290         E_MODULATE_FUNC modulate;
 291         u32 alphaSource;
 292         unpack_textureBlendFuncSeparate(srcRGBFact, dstRGBFact, srcAlphaFact, dstAlphaFact, modulate, alphaSource, material.MaterialTypeParam);
 293
 294         if (textureBlendFunc_hasAlpha(srcRGBFact) || textureBlendFunc_hasAlpha(dstRGBFact) || textureBlendFunc_hasAlpha(srcAlphaFact) || textureBlendFunc_hasAlpha(dstAlphaFact))
 295         {
 296                 if (alphaSource == EAS_VERTEX_COLOR)
 297                 {
 298                         BlendType = 1;
 299                 }
 300                 else if (alphaSource == EAS_TEXTURE)
 301                 {
 302                         BlendType = 2;
 303                 }
 304         }
 305
 306         TextureUsage0 = (material.TextureLayer[0].Texture) ? 1 : 0;
 307 }
 308
 309 void COpenGL3MaterialOneTextureBlendCB::OnSetConstants(IMaterialRendererServices* services, s32 userData)
 310 {
 311         COpenGL3MaterialBaseCB::OnSetConstants(services, userData);
 312
 313         IVideoDriver* driver = services->getVideoDriver();
 314
 315         if (FirstUpdate)
 316         {
 317                 TMatrix0ID = services->getVertexShaderConstantID("uTMatrix0");
 318                 BlendTypeID = services->getVertexShaderConstantID("uBlendType");
 319                 TextureUsage0ID = services->getVertexShaderConstantID("uTextureUsage0");
 320                 TextureUnit0ID = services->getVertexShaderConstantID("uTextureUnit0");
 321
 322                 FirstUpdate = false;
 323         }
 324
 325         core::matrix4 Matrix = driver->getTransform(ETS_TEXTURE_0);
 326         services->setPixelShaderConstant(TMatrix0ID, Matrix.pointer(), 16);
 327
 328         services->setPixelShaderConstant(BlendTypeID, &BlendType, 1);
 329         services->setPixelShaderConstant(TextureUsage0ID, &TextureUsage0, 1);
 330         services->setPixelShaderConstant(TextureUnit0ID, &TextureUnit0, 1);
 331 }
 332
 333 }
 334 }