void SSAO::reloadShaders() {
ukn::ShaderPtr vertexShader;
ukn::ShaderPtr fragmentShader;
vertexShader = mEffect->createShader(MIST_LOAD_RESOURCE(L"deferred/ssao_vert.cg"),
VERTEX_SHADER_DESC("VertexProgram"));
fragmentShader = mEffect->createShader(MIST_LOAD_RESOURCE(L"deferred/ssao_frag.cg"),
FRAGMENT_SHADER_DESC("FragmentProgram"));
mSSAOTechnique->clear();
mSSAOTechnique->appendPass(fragmentShader, vertexShader, ShaderPtr());
vertexShader = mEffect->createShader(MIST_LOAD_RESOURCE(L"deferred/ssao_blur_vert.cg"),
VERTEX_SHADER_DESC("VertexProgram"));
fragmentShader = mEffect->createShader(MIST_LOAD_RESOURCE(L"deferred/ssao_blur_frag.cg"),
FRAGMENT_SHADER_DESC("FragmentProgram"));
mSSAOBlurTechnique->clear();
mSSAOBlurTechnique->appendPass(fragmentShader, vertexShader, ShaderPtr());
vertexShader = mEffect->createShader(MIST_LOAD_RESOURCE(L"deferred/ssao_composite_vert.cg"),
VERTEX_SHADER_DESC("VertexProgram"));
fragmentShader = mEffect->createShader(MIST_LOAD_RESOURCE(L"deferred/ssao_composite_frag.cg"),
FRAGMENT_SHADER_DESC("FragmentProgram"));
mCompositeTechnique->clear();
mCompositeTechnique->appendPass(fragmentShader, vertexShader, ShaderPtr());
}
bool ETHShaderManager::EndHaloPass()
{
m_video->SetPixelShader(ShaderPtr());
m_video->SetVertexShader(ShaderPtr());
m_video->SetAlphaMode(m_lastAM);
return true;
}
ShaderPtr CgDxEffect::createShader(const ResourcePtr& resource, const ShaderDesc& desc) {
CgDxShader* shader = new CgDxShader(mContext);
if(shader->initialize(mDevice, resource, desc)) {
return ShaderPtr(shader);
}
return ShaderPtr();
}
bool ETHPixelLightDiffuseSpecular::EndLightPass()
{
m_video->SetPixelShader(ShaderPtr());
m_video->SetVertexShader(ShaderPtr());
m_video->SetAlphaMode(m_lastAM);
return true;
}
bool EditorBase::DrawTab(VideoPtr video, InputPtr input, const Vector2 &v2Pos, const float width, const wstring &text, Color color)
{
video->SetAlphaMode(Video::AM_PIXEL);
video->SetVertexShader(ShaderPtr());
video->SetPixelShader(ShaderPtr());
video->SetZBuffer(false);
video->SetZWrite(false);
const Vector2 v2Cam = video->GetCameraPos();
video->SetCameraPos(Vector2(0,0));
bool mouseOver = false;
if (mouseOver = ETHGlobal::PointInRect(input->GetCursorPositionF(video), v2Pos+Vector2(width/2, m_menuSize), Vector2(width, m_menuSize)))
{
if (color.a < 200)
color.a = 200;
}
const Vector2 v2CurveSize = m_curve->GetBitmapSizeF();
const float rectWidth = width-v2CurveSize.x*2;
m_curve->FlipX();
m_curve->Draw(v2Pos, color);
const Vector2 v2RectPos = v2Pos+Vector2(v2CurveSize.x, 0);
video->DrawRectangle(v2RectPos, Vector2(rectWidth, m_menuSize*2), color);
m_curve->FlipX();
m_curve->Draw(v2Pos+Vector2(v2CurveSize.x+rectWidth, 0), color);
ShadowPrint(v2RectPos+Vector2(v2CurveSize.x, m_menuSize/2), text.c_str(), L"Verdana14_shadow.fnt", Color(color.a,255,255,255));
video->SetCameraPos(v2Cam);
return (mouseOver && input->GetKeyState(GSK_LMOUSE) == GSKS_HIT);
}
ShaderPtr ShaderLoader::Load(const Path & vertex_file_name, const Path & fragment_file_name, bool replaceCached)
{
Path resourceName = vertex_file_name.filename().generic_string() + fragment_file_name.filename().generic_string();
Resource<Shader> existingResource = this->GetResource(resourceName);
if (existingResource.resource && !replaceCached)
{
GetContext().GetLogger()->log(LOG_LOG, "Shader returned from cache.");
return existingResource.resource;
}
FilePtr vertexFile = GetContext().GetFileSystem()->OpenRead(vertex_file_name);
FilePtr fragmentFile = GetContext().GetFileSystem()->OpenRead(fragment_file_name);
if (!vertexFile->IsOpen() || !fragmentFile->IsOpen())
{
return ShaderPtr();
}
GetContext().GetLogger()->log(LOG_LOG, "Shader resource name: %s", resourceName.generic_string().c_str());
ByteBufferPtr vertexBuffer = vertexFile->ReadText();
ByteBufferPtr fragmentBuffer = fragmentFile->ReadText();
Shader * shader = new Shader(resourceName.generic_string(), (char*)vertexBuffer->data(), (char*)fragmentBuffer->data(), "");
shader->Compile();
if (shader->IsCompiledAndLinked())
{
if (existingResource.resource)
{
RemoveResource(existingResource.path);
GetContext().GetLogger()->log(LOG_LOG, "Removed cached shader: '%s'.", resourceName.c_str());
}
GetContext().GetLogger()->log(LOG_LOG, "Shader loaded: '%s'.", resourceName.c_str());
Resource<Shader> res(ShaderPtr(shader), resourceName);
this->AddResource(res);
return res.resource;
}
else
{
delete shader;
if (existingResource.resource)
GetContext().GetLogger()->log(LOG_ERROR, "Shader failed to load: '%s', using cached version.", resourceName.generic_string().c_str());
else
GetContext().GetLogger()->log(LOG_ERROR, "Shader failed to load: '%s'.", resourceName.generic_string().c_str());
return existingResource.resource;
}
}
ShaderPtr CgGLEffect::createShader(const ResourcePtr& resource, const ShaderDesc& desc) {
if(resource) {
CgGLShader* shader = new CgGLShader(mContext);
if(shader->initialize(resource, desc)) {
return ShaderPtr(shader);
}
} else {
log_error("CgGLEffect::createShader: invalid resource");
}
return ShaderPtr();
}
ShaderPtr Shader::compile(const char* vertexSource, const char* fragmentSource)
{
if (getEngineMode() != EngineMode::Normal)
{
return ShaderPtr(new Shader(0, 0, 0));
}
bool ok = true;
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertexSource, NULL);
glCompileShader(vertexShader);
GLint status;
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &status);
if (status != GL_TRUE)
{
ok = false;
char buffer[512];
glGetShaderInfoLog(vertexShader, 512, NULL, buffer);
std::cout << "Vertex shader compile error:" << std::endl;
std::cout << "\t" << buffer << std::endl;
}
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentSource, NULL);
glCompileShader(fragmentShader);
glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &status);
if (status != GL_TRUE)
{
ok = false;
char buffer[512];
glGetShaderInfoLog(fragmentShader, 512, NULL, buffer);
std::cout << "Fragment shader compile error:" << std::endl;
std::cout << "\t" << buffer << std::endl;
}
if (!ok)
{
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
return nullptr;
}
GLuint shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glLinkProgram(shaderProgram);
return ShaderPtr(new Shader(shaderProgram, vertexShader, fragmentShader));
}
bool ETHParticleDrawer::Draw(const unsigned long lastFrameElapsedTimeMS)
{
m_particleManager->UpdateParticleSystem(m_pos, Vector3(m_pos, 0.0f), m_angle, lastFrameElapsedTimeMS);
m_provider->GetVideo()->SetVertexShader(ShaderPtr());
m_provider->GetVideo()->SetPixelShader(ShaderPtr());
m_particleManager->DrawParticleSystem(
Vector3(1.0f, 1.0f, 1.0f),
1.0f,
0.0f,
ETHParticleManager::LAYERABLE,
Vector2(0.0f, 0.0f),
Vector2(0.5f, 0.5f),
0.0f);
return true;
}
Shader::ShaderLoader::operator ShaderPtr()
{
// if shader has no id yet, create one from shader sources
if( m_shader->m_shaderIdentifier == "" )
{
std::string id = "";
//m_shader->m_objects
for( std::vector<Shader::ShaderObjectPtr>::iterator it = m_shader->m_objects.begin(), end = m_shader->m_objects.end(); it != end; ++it )
{
Shader::ShaderObjectPtr so = *it;
for( std::vector< std::pair<int, std::string> >::const_iterator it = so->m_src->m_inputs.begin(); it != so->m_src->m_inputs.end(); ++it )
{
int type = it->first;
const std::string &str = it->second;
if( type == 1 )
{
// file
id = str;
break;
}
}
if( id != "" )
break;
}
m_shader->m_shaderIdentifier = id;
}
m_shader->finalize();
if( m_shader->isOk() )
return m_shader;
return ShaderPtr();
}
void MD5ModelNode::constructRemaps() {
// greebo: Acquire the ModelSkin reference from the SkinCache
// Note: This always returns a valid reference
ModelSkin& skin = GlobalModelSkinCache().capture(_skin);
// Iterate over all surfaces and remaps
_surfaceRemaps.resize(_model->size());
MD5ModelNode::SurfaceRemaps::iterator j = _surfaceRemaps.begin();
for (MD5Model::const_iterator i = _model->begin(); i != _model->end(); ++i,++j) {
// Get the replacement shadername
std::string remap = skin.getRemap((*i)->getShader());
if (!remap.empty()) {
// We have a valid remap, store it
j->name = remap;
j->shader = GlobalRenderSystem().capture(remap);
} else {
// No remap, leave the name as it is
j->shader = ShaderPtr();
}
}
// Refresh the scene
GlobalSceneGraph().sceneChanged();
}
void ETHRenderEntity::DrawCollisionBox(SpritePtr pOutline, const Color& dwColor, const Vector2 &zAxisDirection) const
{
VideoPtr video = m_provider->GetVideo();
const bool collidable = (m_properties.collision);
const Vector3 v3Size = (collidable) ? m_properties.collision->size : Vector3(32,32,32);
const Vector3 v3Pos = (collidable) ? (m_properties.collision->pos + GetPosition()) : GetPosition();
const Vector2 v2Pos = ETHGlobal::ToScreenPos(v3Pos, zAxisDirection)/* + Vector2(0, v3Size.y/2)*/;
pOutline->SetOrigin(Sprite::EO_CENTER);
const Video::ALPHA_MODE alphaMode = video->GetAlphaMode();
video->SetAlphaMode(Video::AM_PIXEL);
const bool zBuffer = video->GetZBuffer();
video->SetZBuffer(false);
const bool zWrite = video->GetZWrite();
video->SetZWrite(false);
ShaderPtr pVS = video->GetVertexShader();
video->SetVertexShader(ShaderPtr());
const Color dwH = ARGB(150,dwColor.r,dwColor.g,dwColor.b);
const float depth = video->GetSpriteDepth();
// base
video->SetSpriteDepth(1.0f);
pOutline->DrawShaped(v2Pos, Vector2(v3Size.x, v3Size.y), dwH, dwH, dwH, dwH, GetAngle());
video->SetZBuffer(zBuffer);
video->SetZBuffer(zWrite);
video->SetAlphaMode(alphaMode);
video->SetVertexShader(pVS);
video->SetSpriteDepth(depth);
}
ShaderPtr CShaderManager::_LoadShader(SHADER_TYPE eType, xst_castring& strFileName, xst_castring& strShaderName, xst_castring& strEntryPoint, SHADER_PROFILE eProfile, xst_castring& strGroupName)
{
this->m_eShaderType = eType;
this->m_strEntryPoint = strEntryPoint;
this->m_eShaderProfile = eProfile;
ResourcePtr pRes = this->LoadResource( strShaderName, strGroupName, strFileName, strGroupName );
if( pRes.IsNull() )
{
return ShaderPtr();
}
//ShaderPtr pShader( pRes );
//pShader->m_eShaderType = eType;
/*if( XST_FAILED( this->AddResource( strShaderName, pShader, strGroupName ) ) )
{
this->DestroyResource( pShader );
return ShaderPtr();
}*/
this->m_eShaderType = ( SHADER_TYPE )0;
this->m_strEntryPoint.clear();
this->m_eShaderProfile = ( SHADER_PROFILE )0;
return pRes;
}
bool ETHSpriteDrawer::Draw(const unsigned long lastFrameElapsedTimeMS)
{
GS2D_UNUSED_ARGUMENT(lastFrameElapsedTimeMS);
if (sprite)
{
provider->GetVideo()->SetVertexShader(ShaderPtr());
provider->GetVideo()->SetPixelShader(ShaderPtr());
const Vector2 size(v2Size == Vector2(-1,-1) ? sprite->GetFrameSize() : v2Size);
sprite->SetOrigin(v2Origin);
sprite->SetRect(frame);
return sprite->DrawShaped(v2Pos, size, color0, color1, color2, color3, angle);
}
else
{
return false;
}
}
void Program::attach(ShaderPtr shader) {
DEBUG_M("Attaching shader '%d' to program '%d'", shader->getShaderId(), program_id_);
if(shader == ShaderPtr()) {
ERROR("Tried to attach NULL shader.");
return;
}
glAttachShader(program_id_, shader->getShaderId());
shaders_.insert(shader);
}
Shader::ShaderLoader::operator ShaderPtr()
{
m_shader->finalize();
if( m_shader->isOk() )
return m_shader;
return ShaderPtr();
}
ShaderPtr ShaderLoader::GetShaderByName(const Path & name)
{
for (Resource<Shader> & res : m_resources)
{
if (res.resource->GetName() == name)
return res.resource;
}
return ShaderPtr();
}
Space::Space() {
offset = 0;
// Z of 1 means back as there is no perspective projection applied during render
position.z = 1;
// Initialize static resources if needed
if (!shader) shader = ShaderPtr(new Shader{space_vert, space_frag});
if (!texture) texture = TexturePtr(new Texture{"stars.rgb", 512, 512});
if (!mesh) mesh = MeshPtr(new Mesh{shader, "quad.obj"});
}
void MD5ModelNode::destroyRemaps() {
// Iterate over all remaps and NULLify the shader pointers
for (MD5ModelNode::SurfaceRemaps::iterator i = _surfaceRemaps.begin();
i != _surfaceRemaps.end(); ++i)
{
if (i->shader) {
i->shader = ShaderPtr();
}
}
}
bool ETHShaderManager::BeginHaloPass(const ETHLight* light)
{
if (!light || light->haloBitmap == GS_L(""))
return false;
m_lastAM = m_video->GetAlphaMode();
m_video->SetAlphaMode(Video::AM_ADD);
m_video->SetVertexShader(m_defaultVS);
m_video->SetPixelShader(ShaderPtr());
return true;
}
bool ETHShaderManager::BeginHaloPass(const ETHLight* light, const float maxHeight, const ETHSpriteEntity *pParent)
{
GS2D_UNUSED_ARGUMENT(maxHeight);
GS2D_UNUSED_ARGUMENT(pParent);
if (!light || light->haloBitmap == GS_L(""))
return false;
m_lastAM = m_video->GetAlphaMode();
m_video->SetAlphaMode(GSAM_ADD);
m_video->SetVertexShader(m_defaultVS);
m_video->SetPixelShader(ShaderPtr());
return true;
}
Projectile::Projectile() {
// Initialize age to 0
age = 0;
// Set default speed
speed = glm::vec3(0.0f, 3.0f, 0.0f);
rotMomentum = glm::vec3(0.0f, 0.0f, Rand(-PI/4.0f, PI/4.0f));
// Initialize static resources if needed
if (!shader) shader = ShaderPtr(new Shader{object_vert, object_frag});
if (!texture) texture = TexturePtr(new Texture{"missile.rgb", 512, 512});
if (!mesh) mesh = MeshPtr(new Mesh{shader, "missile.obj"});
}
void MaskSubSkin::doRender(MyGUI::IRenderTarget* _target) {
if (!mVisible)
return;
if (mRenderItem) {
{
RenderTargetImpl* target = static_cast<RenderTargetImpl*>(_target);
MyGUI::Widget* widget_p = static_cast<MyGUI::Widget*>(mCroppedParent);
MaskImageWidget* widget = widget_p->castType<MaskImageWidget>(false);
ShaderPtr shader;
Image fill_image;
if (widget) {
ImagePtr img = widget->getImage();
if (img && img->GetTexture()) {
fill_image = *img;
}
shader = widget->getShader();
}
if (!fill_image.GetTexture()) {
MyGUI::ISubWidgetRect* main = widget_p->getSubWidgetMain();
if (main) {
MaskSetSubSkin* sub = main->castType<MaskSetSubSkin>(false);
if (sub) {
get_sub_image(fill_image,sub);
}
}
}
if (!fill_image.GetTexture()) {
Base::doRender(_target);
return;
}
Graphics* g = target->graphics();
if (g) {
g->SetShader(shader);
setMask(*g, fill_image);
Base::doRender(_target);
g->SetMask(MASK_MODE_NONE, TexturePtr(), Transform2d());
g->SetShader(ShaderPtr());
//
} else {
sb_assert(false);
}
}
}
}
/**
*
* @param vert Path to vertex shader
* @param frag Path to fragment shader
*/
ShaderPtr loadShader( QString vert, QString frag )
{
qDebug() << "loadShader("<< vert << "|" << frag << ")";
ShaderPtr program = std::make_shared<Shader>();
QByteArray defs = "#define USE_DESKTOP_BLEND "
#ifdef USE_DESKTOP_BLEND
"1"
#else
"0"
#endif
;
if( !program->addShaderFromSourceCode( QGLShader::Vertex,
loadShaderSource(vert, defs) ) )
{
qWarning() << "Failed to load vertex shader (" << vert << ")\n"
<< program->log();
return ShaderPtr();
}
if( !program->addShaderFromSourceCode( QGLShader::Fragment,
loadShaderSource(frag, defs) ) )
{
qWarning() << "Failed to load fragment shader (" << frag << ")\n"
<< program->log();
return ShaderPtr();
}
if( !program->link() )
{
qWarning() << "Failed to link shader (" << vert << "|" << frag << ")\n"
<< program->log();
return ShaderPtr();
}
return program;
}
bool ETHShaderManager::BeginShadowPass(const ETHSpriteEntity *pRender, const ETHLight* light, const float maxHeight, const float minHeight)
{
if (!light || !light->castShadows || !pRender->IsCastShadow()/* || pRender->GetType() != ETH_VERTICAL*/)
return false;
m_lastAM = m_video->GetAlphaMode();
m_video->SetAlphaMode(GSAM_PIXEL);
m_video->SetVertexShader(m_shadowVS);
m_shadowVS->SetConstant(GS_L("lightRange"), light->range);
m_video->SetSpriteDepth(((pRender->GetPosition().z + _ETH_SMALL_NUMBER-minHeight)/(maxHeight-minHeight)));
m_video->SetPixelShader(ShaderPtr());
return true;
}
Asteroid::Asteroid() {
// Reset the age to 0
age = 0;
// Set random scale speed and rotation
scale *= Rand(1.0f, 3.0f);
speed = glm::vec3(Rand(-2.0f, 2.0f), Rand(-5.0f, -10.0f), 0.0f);
rotation = glm::vec3(Rand(-PI, PI), Rand(-PI, PI), Rand(-PI, PI));
rotMomentum = glm::vec3(Rand(-PI, PI), Rand(-PI, PI), Rand(-PI, PI));
// Initialize static resources if needed
if (!shader) shader = ShaderPtr(new Shader{object_vert, object_frag});
if (!texture) texture = TexturePtr(new Texture{"asteroid.rgb", 512, 512});
if (!mesh) mesh = MeshPtr(new Mesh{shader, "asteroid.obj"});
}
void ETHRenderEntity::DrawCollisionBox(const bool drawBase, SpritePtr pOutline, const GS_COLOR dwColor, const Vector2 &zAxisDirection) const
{
VideoPtr video = m_provider->GetVideo();
const bool collidable = (m_properties.collision);
const Vector3 v3Size = (collidable) ? m_properties.collision->size : Vector3(32,32,32);
const Vector3 v3Pos = (collidable) ? (m_properties.collision->pos + GetPosition()) : GetPosition();
const Vector2 v2Pos = ETHGlobal::ToScreenPos(v3Pos, zAxisDirection) + Vector2(0, v3Size.y/2);
pOutline->SetOrigin(GSEO_CENTER_BOTTOM);
const GS_ALPHA_MODE alphaMode = video->GetAlphaMode();
video->SetAlphaMode(GSAM_PIXEL);
const bool zBuffer = video->GetZBuffer();
video->SetZBuffer(false);
const bool zWrite = video->GetZWrite();
video->SetZWrite(false);
ShaderPtr pVS = video->GetVertexShader();
video->SetVertexShader(ShaderPtr());
const GS_COLOR dwH = ARGB(150,dwColor.r,dwColor.g,dwColor.b);
const float depth = video->GetSpriteDepth();
if (drawBase)
{
// base
video->SetSpriteDepth(1.0f);
pOutline->DrawShaped(v2Pos, Vector2(v3Size.x, v3Size.y), dwH, dwH, dwH, dwH);
}
else
{
video->SetSpriteDepth(0.0f);
const GS_COLOR dwV = ARGB(50,dwColor.r,dwColor.g,dwColor.b);
// front face
pOutline->DrawShaped(v2Pos, Vector2(v3Size.x, v3Size.z), dwV, dwV, dwV, dwV);
// upper face
pOutline->DrawShaped(v2Pos-Vector2(0,v3Size.z), Vector2(v3Size.x, v3Size.y), dwH, dwH, dwH, dwH);
}
video->SetZBuffer(zBuffer);
video->SetZBuffer(zWrite);
video->SetAlphaMode(alphaMode);
video->SetVertexShader(pVS);
video->SetSpriteDepth(depth);
}
ShaderPtr Shader::loadResource(const string &name)
{
FileReader *fileReader;
fileReader = new FileReader(util::getAbsoluteFilePath(name + ".vert"));
string vertexSource = fileReader->readAll();
fileReader->close();
delete fileReader;
fileReader = new FileReader(util::getAbsoluteFilePath(name + ".frag"));
string fragmentSource = fileReader->readAll();
fileReader->close();
delete fileReader;
LOG("Compiling shader program: %s", name.c_str());
return ShaderPtr(new Shader(vertexSource, fragmentSource));
}
bool ETHShaderManager::BeginAmbientPass(const ETHSpriteEntity *pRender, const float maxHeight, const float minHeight)
{
m_video->SetPixelShader(ShaderPtr());
if (pRender->GetType() == ETH_VERTICAL)
{
m_verticalStaticAmbientVS->SetConstant(GS_L("spaceLength"), (maxHeight-minHeight));
m_video->SetVertexShader(m_verticalStaticAmbientVS);
}
else
{
m_video->SetVertexShader(m_defaultStaticAmbientVS);
}
m_parallaxManager.SetShaderParameters(m_video, m_video->GetVertexShader(), pRender->GetPosition(), false);
m_lastAM = m_video->GetAlphaMode();
return true;
}
bool ETHVertexLightDiffuse::BeginLightPass(ETHSpriteEntity *pRender, Vector3 &v3LightPos, const Vector2 &v2Size,
const ETHLight* light, const float maxHeight, const float minHeight, const float lightIntensity,
const bool drawToTarget)
{
GS2D_UNUSED_ARGUMENT(drawToTarget);
const Vector2 &v2Origin = pRender->ComputeOrigin(v2Size);
const Vector3 &v3EntityPos = pRender->GetPosition();
m_video->SetPixelShader(ShaderPtr());
ShaderPtr pLightShader;
if (pRender->GetType() == ETH_VERTICAL)
{
m_vVertexLightVS->SetConstant(GS_L("spaceLength"), (maxHeight-minHeight));
m_vVertexLightVS->SetConstant(GS_L("topLeft3DPos"), v3EntityPos-(Vector3(v2Origin.x, 0, -v2Origin.y)));
pLightShader = m_vVertexLightVS;
}
else
{
m_hVertexLightVS->SetConstant(GS_L("topLeft3DPos"), v3EntityPos-Vector3(v2Origin, 0));
pLightShader = m_hVertexLightVS;
}
m_video->SetVertexShader(pLightShader);
m_lastAM = m_video->GetAlphaMode();
m_video->SetAlphaMode(GSAM_ADD);
// Set a depth value depending on the entity type
pRender->SetDepth(maxHeight, minHeight);
pLightShader->SetConstant(GS_L("pivotAdjust"), pRender->GetProperties()->pivotAdjust);
pLightShader->SetConstant(GS_L("lightPos"), v3LightPos);
pLightShader->SetConstant(GS_L("lightRange"), light->range);
pLightShader->SetConstant(GS_L("lightColor"), light->color);
pLightShader->SetConstant(GS_L("lightIntensity"), lightIntensity);
return true;
}
