Eagle517/tge
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added everything

Browse Source
This commit is contained in:
Metario
2017-04-17 06:17:10 -06:00
commit 9c6ff74f19
6121 changed files with 1625704 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

270
engine/lightingSystem/sgLightingModel.h Executable file
View File

@@ -0,0 +1,270 @@
//-----------------------------------------------
// Synapse Gaming - Lighting System
// Copyright <20> Synapse Gaming 2003
// Written by John Kabus
//-----------------------------------------------
#ifndef _SGLIGHTINGMODEL_H_
#define _SGLIGHTINGMODEL_H_
#ifndef _MMATH_H_
#include "math/mMath.h"
#endif
#ifndef _COLOR_H_
#include "core/color.h"
#endif
#ifndef _TVECTOR_H_
#include "core/tVector.h"
#endif
#ifndef _DATACHUNKER_H_
#include "core/dataChunker.h"
#endif
#include "console/console.h"
#include "console/consoleTypes.h"
#include "lightingSystem/sgLightManager.h"
#include "core/stringTable.h"
#include "core/tVector.h"
#define SG_LIGHTINGMODEL_NAME "SG - %s (Lighting Pack)"
#define SG_DYNAMICLIGHTING_TYPE2
class sgLightingModel
{
protected:
bool sgStateSet;
bool sgStateInitLM;
LightInfo *sgLight;
public:
char sgLightingModelName[64];
sgLightingModel();
void sgRegisterLightingModel();
virtual void sgSetState(LightInfo *light)
{
AssertFatal((sgStateSet == false), "sgLightingModel: State not properly reset.");
sgStateSet = true;
sgStateInitLM = false;
sgLight = light;
}
virtual void sgLightingGL(S32 gllight)
{
AssertFatal((sgStateSet == true), "sgLightingModel: State not properly set.");
}
virtual void sgInitStateLM()
{
AssertFatal((sgStateSet == true), "sgLightingModel: State not properly set.");
sgStateInitLM = true;
}
virtual void sgLightingLM(const Point3F &point, VectorF normal, ColorF &diffuse, ColorF &ambient, Point3F &lightingnormal)
{
AssertFatal((sgStateInitLM == true), "sgLightingModel: State not properly init.");
}
virtual void sgResetState()
{
sgStateSet = false;
sgStateInitLM = false;
sgLight = NULL;
}
virtual F32 sgScoreLight(LightInfo *light, const SphereF &sphere)
{
AssertFatal((sgStateSet == true), "sgLightingModel: State not properly set.");
return 0.0f;
}
virtual bool sgCanIlluminate(const Box3F &box) = 0;
virtual F32 sgGetMaxRadius(bool speedoverquality=false, bool glstyle=false) = 0;
virtual Point3F sgGetModelInfo() = 0;
};
class sgLightingModelGLBase : public sgLightingModel
{
protected:
F32 sgConstantAttenuation;
F32 sgLinearAttenuation;
F32 sgQuadraticAttenuation;
F32 spotanglecos;
F32 spotamountinner;
F32 spotamountouter;
Point4F sgLightParamDiffuse;
Point4F sgLightParamAmbient;
Point4F sgLightParamPosition;
Point4F sgLightParamDirection;
public:
virtual void sgSetState(LightInfo *light);
virtual void sgLightingGL(S32 gllight);
virtual void sgInitStateLM();
virtual void sgLightingLM(const Point3F &point, VectorF normal, ColorF &diffuse, ColorF &ambient, Point3F &lightingnormal);
virtual F32 sgScoreLight(LightInfo *light, const SphereF &sphere);
virtual bool sgCanIlluminate(const Box3F &box);
virtual F32 sgGetMaxRadius(bool speedoverquality=false, bool glstyle=false);
virtual Point3F sgGetModelInfo()
{
return Point3F(sgConstantAttenuation,
sgLinearAttenuation, sgQuadraticAttenuation);
}
};
class sgLightingModelAdvanced : public sgLightingModelGLBase
{
protected:
F32 maxlightdistancesquared;
public:
sgLightingModelAdvanced()
{
dSprintf(sgLightingModelName, sizeof(sgLightingModelName),
SG_LIGHTINGMODEL_NAME, "Original Advanced");
}
virtual void sgSetState(LightInfo *light);
virtual void sgInitStateLM();
virtual void sgLightingLM(const Point3F &point, VectorF normal, ColorF &diffuse, ColorF &ambient, Point3F &lightingnormal);
// only for TSE's consistent lighting models...
// TGE's vertex lighting requires the base
// class method sgLightingModelGLBase::sgScoreLight...
//virtual F32 sgScoreLight(LightInfo *light, const SphereF &sphere);
virtual bool sgCanIlluminate(const Box3F &box);
virtual F32 sgGetMaxRadius(bool speedoverquality=false, bool glstyle=false)
{
AssertFatal((sgStateSet == true), "sgLightingModel: State not properly set.");
if(glstyle)
return sgLightingModelGLBase::sgGetMaxRadius(speedoverquality, glstyle);
return sgLight->mRadius;
}
};
class sgLightingModelStock : public sgLightingModelGLBase
{
public:
sgLightingModelStock()
{
dSprintf(sgLightingModelName, sizeof(sgLightingModelName),
SG_LIGHTINGMODEL_NAME, "Original Stock");
}
void sgSetState(LightInfo *light)
{
sgLightingModelGLBase::sgSetState(light);
if(sgLight->mRadius > 0.0f)
sgQuadraticAttenuation = (1.0f / (sgLight->mRadius * sgLight->mRadius));
else
sgQuadraticAttenuation = 0.0f;
}
};
class sgLightingModelInverseSquare : public sgLightingModelGLBase
{
public:
sgLightingModelInverseSquare()
{
dSprintf(sgLightingModelName, sizeof(sgLightingModelName),
SG_LIGHTINGMODEL_NAME, "Inverse Square");
}
void sgSetState(LightInfo *light)
{
sgLightingModelGLBase::sgSetState(light);
sgConstantAttenuation = 1.0f;
if(sgLight->mRadius > 0.0f)
sgQuadraticAttenuation = (1.0f / (sgLight->mRadius * sgLight->mRadius));
else
sgQuadraticAttenuation = 0.0f;
}
};
class sgLightingModelInverseSquareFastFalloff : public sgLightingModelGLBase
{
public:
sgLightingModelInverseSquareFastFalloff()
{
dSprintf(sgLightingModelName, sizeof(sgLightingModelName),
SG_LIGHTINGMODEL_NAME, "Inverse Square Fast Falloff");
}
void sgSetState(LightInfo *light)
{
sgLightingModelGLBase::sgSetState(light);
sgConstantAttenuation = 1.0f;
if(sgLight->mRadius > 0.0f)
sgQuadraticAttenuation = (10.0f / (sgLight->mRadius * sgLight->mRadius));
else
sgQuadraticAttenuation = 0.0f;
}
};
class sgLightingModelNearLinear : public sgLightingModelGLBase
{
public:
sgLightingModelNearLinear()
{
dSprintf(sgLightingModelName, sizeof(sgLightingModelName),
SG_LIGHTINGMODEL_NAME, "Near Linear");
}
void sgSetState(LightInfo *light)
{
sgLightingModelGLBase::sgSetState(light);
sgConstantAttenuation = 1.0f;
if(sgLight->mRadius > 0.0f)
sgLinearAttenuation = (1.0f / sgLight->mRadius);
else
sgLinearAttenuation = 0.0f;
}
};
class sgLightingModelNearLinearFastFalloff : public sgLightingModelGLBase
{
public:
sgLightingModelNearLinearFastFalloff()
{
dSprintf(sgLightingModelName, sizeof(sgLightingModelName),
SG_LIGHTINGMODEL_NAME, "Near Linear Fast Falloff");
}
void sgSetState(LightInfo *light)
{
sgLightingModelGLBase::sgSetState(light);
sgConstantAttenuation = 1.0f;
if(sgLight->mRadius > 0.0f)
sgLinearAttenuation = (10.0f / sgLight->mRadius);
else
sgLinearAttenuation = 0.0f;
}
};
class sgLightingModelManager
{
private:
static Vector<sgLightingModel *> sgLightingModels;
static sgLightingModelStock sgDefaultModel;
static sgLightingModelAdvanced sgAdvancedModel;
static sgLightingModelInverseSquare sgInverseSquare;
static sgLightingModelInverseSquareFastFalloff sgInverseSquareFastFalloff;
static sgLightingModelNearLinear sgNearLinear;
static sgLightingModelNearLinearFastFalloff sgNearLinearFastFalloff;
static sgLightingModel *sgSunlightModel;
public:
sgLightingModelManager() {}
static void sgRegisterLightingModel(sgLightingModel *model) {sgLightingModels.push_back(model);}
static sgLightingModel &sgGetLightingModel() {return sgDefaultModel;}
static sgLightingModel &sgGetLightingModel(const char *name)
{
if((name == NULL) || (name[0] == 0))
return sgDefaultModel;
for(U32 i=0; i<sgLightingModels.size(); i++)
{
if(dStrcmp(sgLightingModels[i]->sgLightingModelName, name) == 0)
return *(sgLightingModels[i]);
}
return sgDefaultModel;
}
static U32 sgGetLightingModelCount() {return sgLightingModels.size();}
static char *sgGetLightingModelName(U32 index)
{
if((index < 0) || (index >= sgLightingModels.size()))
return "";
return sgLightingModels[index]->sgLightingModelName;
}
static const char *sgGetSunlightLightingModelName()
{
if(sgSunlightModel)
return sgSunlightModel->sgLightingModelName;
return NULL;
}
static char *sgGetAdvancedLightingModelName() {return sgAdvancedModel.sgLightingModelName;}
static char *sgGetStockLightingModelName() {return sgDefaultModel.sgLightingModelName;}
};
#endif//_SGLIGHTINGMODEL_H_