void PostProcessing::renderFog()
{
const Track * const track = World::getWorld()->getTrack();
// This function is only called once per frame - thus no need for setters.
const float fogmax = track->getFogMax();
const float startH = track->getFogStartHeight();
const float endH = track->getFogEndHeight();
const float start = track->getFogStart();
const float end = track->getFogEnd();
const SColor tmpcol = track->getFogColor();
core::vector3df col( tmpcol.getRed() / 255.0f,
tmpcol.getGreen() / 255.0f,
tmpcol.getBlue() / 255.0f );
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glUseProgram(FullScreenShader::FogShader::Program);
glBindVertexArray(FullScreenShader::FogShader::vao);
setTexture(0, irr_driver->getDepthStencilTexture(), GL_NEAREST, GL_NEAREST);
FullScreenShader::FogShader::setUniforms(fogmax, startH, endH, start, end, col, 0);
glDrawArrays(GL_TRIANGLES, 0, 3);
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
}
void PostProcessing::renderFog()
{
const Track * const track = World::getWorld()->getTrack();
// This function is only called once per frame - thus no need for setters.
const float fogmax = track->getFogMax();
const float startH = track->getFogStartHeight();
const float endH = track->getFogEndHeight();
const float start = track->getFogStart();
const float end = track->getFogEnd();
const SColor tmpcol = track->getFogColor();
core::vector3df col( tmpcol.getRed() / 255.0f,
tmpcol.getGreen() / 255.0f,
tmpcol.getBlue() / 255.0f );
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
FullScreenShader::FogShader::getInstance()->SetTextureUnits(createVector<GLuint>(irr_driver->getDepthStencilTexture()));
DrawFullScreenEffect<FullScreenShader::FogShader>(fogmax, startH, endH, start, end, col);
glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
}
IImage* createRainbowImage( u32 w, u32 h, u8 transparency, f64 gamma)
{
// create image
core::dimension2du size(w,h);
IImage* img = (IImage*)new CImage(ECF_A8R8G8B8, size);
if (!img) return 0;
size = img->getDimension();
// loop pixels per col
for (u32 y=0; y<size.Height; y++)
{
// calculate rainbow-color
SColor c = createRainbowColor( y, size.Height, gamma);
// set transparency
c.setAlpha(transparency);
// write one row with same color
for (u32 x=0; x<size.Width; x++)
{
// write rainbow-color
img->setPixel(x,y,c,false);
}
}
return img;
}
void CMenuLogin::updateHuds()
{
_gerHud->clear();
if(_loadingStage == LS_PERSONAGENS)
{
_gameCore->_barraLoad = new CHudProgressBar(_gerHud->getRootGUIElement(), _gerHud, rect<s32>( 0+100, _gameCore->sHeight-200, _gameCore->sWidth-100, _gameCore->sHeight-100));
_gameCore->_barraLoad->setProgress(0.00001f);
}
if(_loadingStage > LS_COUNT)
{
IGUIImage *img =_gerHud->addImage(_gerVideo->getTexture("recursos/huds/bg_login.png"), position2d<s32>(/*112, 84*/0,0));
Login = _gerHud->addEditBox(L"fantini", rect<s32>(400,700,500,720), true, 0, 10);
Password = _gerHud->addEditBox(L"wurzelion", rect<s32>(400,730,500,750), true, 0, 20);
Password->setPasswordBox(true);
Login->setMax(15);
Password->setMax(15);
_gerHud->addButton(rect<s32>(520,700,620,750), 0, 101, L"conectar");
//IGUIButton *connect;
//addNewBtn(connect, rect<s32>(550,700,602,752), 0, 101, 0, L"conectar", true, false, H_CONECTAR, H_CONECTAR);
}
for (u32 i=0; i<EGDC_COUNT ; ++i)
{
SColor col = _gerHud->getSkin()->getColor((EGUI_DEFAULT_COLOR)i);
col.setAlpha(255);
_gerHud->getSkin()->setColor((EGUI_DEFAULT_COLOR)i, col);
}
_menuFlag[HUDUPDATED] = true;
}
void RasGouraud::RasterizePixel( SScanLine& scanLine, const SScanLinesData& rasData )
{
#if USE_PERSPEC_CORRECT == 1
//双曲插值最后一步
float inv_w = 1 / scanLine.zw.y;
scanLine.pixelColor.Set(scanLine.curClr.x*inv_w, scanLine.curClr.y*inv_w, scanLine.curClr.z*inv_w);
#else
scanLine.pixelColor = scanLine.curClr;
#endif
scanLine.pixelColor.Saturate();
DWORD& dwDestColor = *scanLine.pFragmeng->finalColor;
#if USE_OIT == 0
SColor destPixelColor;
destPixelColor.SetAsInt(dwDestColor);
DoAlphaBlending(destPixelColor, scanLine.pixelColor, destPixelColor, rasData.pMaterial);
dwDestColor = destPixelColor.GetAsInt();
#else
scanLine.pixelColor.a *= rasData.pMaterial->transparency;
dwDestColor = scanLine.pixelColor.GetAsInt();
#endif
#if USE_PROFILER == 1
g_env.profiler->AddRenderedPixel();
#endif
}
//! sets a pixel
void SImage::setPixel(u32 x, u32 y, const SColor &color )
{
if (x >= (u32)Size.Width || y >= (u32)Size.Height)
return;
switch(Format)
{
case ECF_A1R5G5B5:
{
u16 * dest = (u16*) ((u8*) Data + ( y * Pitch ) + ( x << 1 ));
*dest = video::A8R8G8B8toA1R5G5B5 ( color.color );
} break;
case ECF_R5G6B5:
{
u16 * dest = (u16*) ((u8*) Data + ( y * Pitch ) + ( x << 1 ));
*dest = video::A8R8G8B8toR5G6B5 ( color.color );
} break;
case ECF_R8G8B8:
{
u8* dest = (u8*) Data + ( y * Pitch ) + ( x * 3 );
dest[0] = color.getRed();
dest[1] = color.getGreen();
dest[2] = color.getBlue();
} break;
case ECF_A8R8G8B8:
{
u32 * dest = (u32*) ((u8*) Data + ( y * Pitch ) + ( x << 2 ));
*dest = color.color;
} break;
}
}
//! Constructs a color from 32 bit Color.
SColorf::SColorf(SColor c)
{
const f32 inv = 1.0f / 255.0f;
Red = c.getRed() * inv;
Green = c.getGreen() * inv;
Blue = c.getBlue() * inv;
Alpha = c.getAlpha() * inv;
}
//! fills the surface with given color
void CImage::fill(const SColor &color)
{
u32 c;
switch (Format)
{
case ECF_A1R5G5B5:
{
c = color.toA1R5G5B5();
c |= c << 16;
break;
}
case ECF_R5G6B5:
{
c = SharedColorConverter::getInstance().A8R8G8B8toR5G6B5(
color.color);
c |= c << 16;
break;
}
case ECF_A8R8G8B8:
{
c = color.color;
break;
}
case ECF_R8G8B8:
{
u8 rgb[3];
SharedColorConverter::getInstance().convert_A8R8G8B8toR8G8B8(
&color, 1, rgb);
const u32 size = getImageDataSizeInBytes();
for (u32 i = 0; i < size; i += 3)
{
memcpy(Data + i, rgb, 3);
}
return;
break;
}
case ECF_R16F:
case ECF_G16R16F:
case ECF_A16B16G16R16F:
case ECF_R32F:
case ECF_G32R32F:
case ECF_A32B32G32R32F:
case ECF_UNKNOWN:
default:
{
break;
}
}
if (Format != ECF_A1R5G5B5 && Format != ECF_R5G6B5
&& Format != ECF_A8R8G8B8)
{
return;
}
StaticVideoUtils::memset32(Data, c, getImageDataSizeInBytes());
}
//! fills the surface with given color
void CImage::fill(const SColor &color)
{
u32 c;
switch ( Format )
{
case ECF_A1R5G5B5:
c = color.toA1R5G5B5();
c |= c << 16;
break;
case ECF_R5G6B5:
c = video::A8R8G8B8toR5G6B5( color.color );
c |= c << 16;
break;
case ECF_A8R8G8B8:
c = color.color;
break;
case ECF_R8G8B8:
{
u8 rgb[3];
CColorConverter::convert_A8R8G8B8toR8G8B8(&color, 1, rgb);
const u32 size = getImageDataSizeInBytes();
for (u32 i=0; i<size; i+=3)
{
memcpy(Data+i, rgb, 3);
}
return;
}
break;
default:
// TODO: Handle other formats
return;
}
memset32( Data, c, getImageDataSizeInBytes() );
}
void WxIrrMainWindow::OnSimulationShowZAxisChangeColor(wxCommandEvent &event)
{
wxColourData colorData;
SColor currentIrrColor = OnSimulationZAxisGetColorFunctionPointer();
wxColour currentWxColor(currentIrrColor.getRed(), currentIrrColor.getGreen(), currentIrrColor.getBlue());
colorData.SetColour(currentWxColor);
wxColourDialog colorDiag(this, &colorData);
if (colorDiag.ShowModal() == wxID_OK)
{
wxColourData retData = colorDiag.GetColourData();
wxColour col = retData.GetColour();
OnSimulationZAxisChangeColorFunctionPointer(col);
}
}
RayBuffer RayTracer::traceRays() {
// #pragma omp parallel for
for (uint y = 0; y < HEIGHT; y++) {
// #pragma omp parallel for
for (uint x = 0; x < WIDTH; x++) {
Ray r = computeRay(x, y);
Intersection in = scene->calculateRayIntersection(r);
SColor c = shadeIntersection(in, depth);
PX_Color color;
color.R = (uint8_t) (255 * c.R());
color.G = (uint8_t) (255 * c.G());
color.B = (uint8_t) (255 * c.B());
buffer.setPixel(x, y, color);
}
}
return buffer;
}
void RasNormalMap::FragmentPS( SFragment& frag )
{
SColor texColor(SColor::WHITE), lightColor(SColor::WHITE);
SMaterial* pMaterial = frag.pMaterial;
if(pMaterial->pDiffuseMap && pMaterial->bUseBilinearSampler)
{
pMaterial->pDiffuseMap->Tex2D_Bilinear(frag.uv, texColor, frag.texLod);
}
else if(pMaterial->pDiffuseMap)
{
pMaterial->pDiffuseMap->Tex2D_Point(frag.uv, texColor, frag.texLod);
}
SLightingContext_NormalMap lc;
lc.uv = &frag.uv;
lc.lightDirTS = &frag.lightDirTS;
lc.hVectorTS = &frag.hVectorTS;
DoPerPixelLighting(lightColor, &lc, pMaterial);
// Don't modify alpha [1/19/2014 mavaL]
float alpha = texColor.a;
texColor *= lightColor;
texColor.a = alpha;
texColor.Saturate();
DWORD& dwDestColor = *frag.finalColor;
#if USE_OIT == 0
SColor destPixelColor;
destPixelColor.SetAsInt(dwDestColor);
DoAlphaBlending(destPixelColor, texColor, destPixelColor, pMaterial);
dwDestColor = destPixelColor.GetAsInt();
#else
texColor.a *= pMaterial->transparency;
dwDestColor = texColor.GetAsInt();
#endif
#if USE_PROFILER == 1
g_env.profiler->AddRenderedPixel();
#endif
}
SColor SColor::mult(SColor other) {
SColor c;
c.R(R() * other.R());
c.G(G() * other.G());
c.B(B() * other.B());
return c;
}
void CD3D9Texture::copy16BitMipMap(char* src, char* tgt,
s32 width, s32 height,
s32 pitchsrc, s32 pitchtgt) const
{
for (s32 y=0; y<height; ++y)
{
for (s32 x=0; x<width; ++x)
{
u32 a=0, r=0, g=0, b=0;
for (s32 dy=0; dy<2; ++dy)
{
const s32 tgy = (y*2)+dy;
for (s32 dx=0; dx<2; ++dx)
{
const s32 tgx = (x*2)+dx;
SColor c;
if (ColorFormat == ECF_A1R5G5B5)
c = A1R5G5B5toA8R8G8B8(*(u16*)(&src[(tgx*2)+(tgy*pitchsrc)]));
else
c = R5G6B5toA8R8G8B8(*(u16*)(&src[(tgx*2)+(tgy*pitchsrc)]));
a += c.getAlpha();
r += c.getRed();
g += c.getGreen();
b += c.getBlue();
}
}
a /= 4;
r /= 4;
g /= 4;
b /= 4;
u16 c;
if (ColorFormat == ECF_A1R5G5B5)
c = RGBA16(r,g,b,a);
else
c = A8R8G8B8toR5G6B5(SColor(a,r,g,b).color);
*(u16*)(&tgt[(x*2)+(y*pitchtgt)]) = c;
}
}
}
void EventReceiver::showExitConfirmDialog(){
IGUIEnvironment* env = device->getGUIEnvironment();
IGUIWindow* window = env->addWindow(
rect<s32>(224, 200, 800, 390),true, L"Confirm dialog");
env->addStaticText(L"Do you want to exit the game?",
rect<s32>(35,50,600,150),
false, // border?
false, // wordwrap?
window);
for (u32 i=0; i<EGDC_COUNT ; ++i){
SColor col = env->getSkin()->getColor((EGUI_DEFAULT_COLOR)i);
col.setAlpha(255);
env->getSkin()->setColor((EGUI_DEFAULT_COLOR)i, col);
}
env->addButton(
rect<s32>(15, 100, 285, 170), window, EXIT_OK, L"Ok");
env->addButton(
rect<s32>(300, 100, 555, 170), window, EXIT_CANCEL, L"Cancel");
}
void SceneCharSelection::FillCharlist(void)
{
ZThread::Guard<ZThread::FastMutex> g(mutex);
charlistbox->clear();
WorldSession *ws = instance->GetWSession();
if(ws)
{
uint32 ffaction = racedb->GetFieldId("faction");
for(uint32 i = 0; i < ws->GetCharsCount(); i++)
{
CharacterListExt& c = ws->GetCharFromList(i);
core::stringw entry;
entry += c.p._name.c_str();
entry += L", ";
entry += L"Level ";
entry += c.p._level;
entry += L" ";
entry += c.race.c_str();
entry += L" ";
entry += c.class_.c_str();
entry += L", ";
entry += c.zone.c_str();
entry += L" (";
entry += c.map_.c_str();
entry += L")";
charlistbox->addItem(entry.c_str());
uint32 faction = racedb->GetInt(c.p._race, ffaction);
SColor col;
switch(faction)
{
case 1: col.set(0xFF, 0xFF, 0x30, 0x30); break;
case 7: col.set(0xFF, 0x30, 0x30, 0xFF); break;
default: col.set(0xFFFFFFFF);
}
charlistbox->setItemOverrideColor(i,EGUI_LBC_TEXT,col);
charlistbox->setItemOverrideColor(i,EGUI_LBC_TEXT_HIGHLIGHT,col);
}
}
}
SColor RayTracer::shadeIntersection(Intersection in, uint d) {
if (d <= 0 || in.hasIntersected() == false) {
// terminate recursion
return SColor(0, 0, 0);
}
Vect shade(0, 0, 0);
Material *mat = in.getMaterial();
float kt = mat->getTransparency();
SColor ks = mat->getSpecColor();
SColor ka = mat->getAmbColor();
SColor Cd = mat->getDiffColor();
SColor ambLight = Whitted::AmbientLightning(kt, ka, Cd);
std::vector<Light *> lts = scene->getLights();
for (uint i = 0; i < lts.size(); i++) {
Light *l = lts.at(i);
SColor Sj = calculateShadowScalar(*l, in);
shade = shade + Whitted::Illumination(l, in, Sj);
}
SColor reflection;
if (ks.length() > 0) {
Ray r = in.calculateReflection();
Intersection rin = scene->calculateRayIntersection(r);
reflection = shadeIntersection(rin, d-1).linearMult(ks);
}
SColor refraction;
if (kt > 0) {
Ray r = in.calculateRefraction();
Intersection rin = scene->calculateRayIntersection(r);
refraction = shadeIntersection(rin, d-1).linearMult(kt);
}
shade = ambLight + shade + reflection + refraction;
return shade;
}
MyCharHeaderMsg::MyCharHeaderMsg( ISceneNode* parent,const wchar_t* msg)
{
irr::core::list<ISceneNode*> msglist=parent->getChildren();
irr::core::list<ISceneNode*>::Iterator oper;
for(oper =msglist.begin(); oper !=msglist.end();++oper )
{
//又有新msg要显示,把上次的msg都遍历出来,隐藏..
if((*oper)->getID()==33){
(*oper)->setVisible(false);
//oper=msglist.erase(oper);
}
}
SColor color;
color.setAlpha(255);
color.setRed(255);
color.setBlue(250);
color.setGreen(0);
char tmp[512];
GetWindowsDirectory(tmp,511);
strcat(tmp,"\\fonts\\SIMSUN.TTC"); //SIMSUN.TTC宋体,新宋体 SIMKAI.TTF楷体 \STXIHEI.TTF Fixedsys
IGUIFont* font = getIrrUI()->getFont(tmp,18,true,0);
// IGUIFont* font = getIrrUI()->getDXFont("宋体",true,18,0,500);
ITextSceneNode* textnode= getIrrSmgr()->addTextSceneNode(font,
msg,
color, parent,
vector3df(0,90,0), //text相对坐标
33); //ID
scene::ISceneNodeAnimator* a = 0;
//4.5秒删除
a= getIrrSmgr()->createDeleteAnimator(4500);
textnode->addAnimator(a);//字体节点删除
a->drop();
}
void RenderTarget::getImageData(floatv &data)
{
IImage* img = driver->createImage(target, position2d<s32>(0,0), target->getSize());
uint y = img->getDimension().Height;
uint x = img->getDimension().Width;
for(uint i = 0; i < y; i++)
{
for(uint j = 0; j < x; j++)
{
SColor color = img->getPixel(j,i);
data.push_back((float)(color.getRed()/255.0));
data.push_back((float)(color.getGreen()/255.0));
data.push_back((float)(color.getBlue()/255.0));
}
}
img->drop();
//delete img;
}
// -----------------------------------------------------------------------------
video::ITexture* IconButtonWidget::getDeactivatedTexture(video::ITexture* texture)
{
SColor c;
u32 g;
video::IVideoDriver* driver = irr_driver->getVideoDriver();
video::IImage* image = driver->createImageFromData (texture->getColorFormat(),
texture->getSize(), texture->lock(), false);
texture->unlock();
//Turn the image into grayscale
for (u32 x = 0; x < image->getDimension().Width; x++)
{
for (u32 y = 0; y < image->getDimension().Height; y++)
{
c = image->getPixel(x, y);
g = ((c.getRed() + c.getGreen() + c.getBlue()) / 3);
c.set(std::max (0, (int)c.getAlpha() - 120), g, g, g);
image->setPixel(x, y, c);
}
}
texture = driver->addTexture(texture->getName().getPath() + "_disabled", image);
texture->grab();
return texture;
}
//! get a filtered pixel
inline SColor CImage::getPixelBox( s32 x, s32 y, s32 fx, s32 fy, s32 bias ) const
{
SColor c;
s32 a = 0, r = 0, g = 0, b = 0;
for ( s32 dx = 0; dx != fx; ++dx )
{
for ( s32 dy = 0; dy != fy; ++dy )
{
c = getPixel( core::s32_min ( x + dx, Size.Width - 1 ) ,
core::s32_min ( y + dy, Size.Height - 1 )
);
a += c.getAlpha();
r += c.getRed();
g += c.getGreen();
b += c.getBlue();
}
}
s32 sdiv = s32_log2_s32(fx * fy);
a = core::s32_clamp( ( a >> sdiv ) + bias, 0, 255 );
r = core::s32_clamp( ( r >> sdiv ) + bias, 0, 255 );
g = core::s32_clamp( ( g >> sdiv ) + bias, 0, 255 );
b = core::s32_clamp( ( b >> sdiv ) + bias, 0, 255 );
c.set( a, r, g, b );
return c;
}
inline void SColorHSL::toRGB(SColor &color) const
{
if (core::SharedMath::getInstance().iszero(Saturation)) // grey
{
u8 c = (u8) (Luminance * 255.0);
color.setRed(c);
color.setGreen(c);
color.setBlue(c);
return;
}
f32 rm2;
if (Luminance <= 0.5f)
{
rm2 = Luminance + Luminance * Saturation;
}
else
{
rm2 = Luminance + Saturation - Luminance * Saturation;
}
const f32 rm1 = 2.0f * Luminance - rm2;
color.setRed(
toRGB1(rm1, rm2,
Hue + (120.0f * core::SharedMath::DegToRad)));
color.setGreen(toRGB1(rm1, rm2, Hue));
color.setBlue(
toRGB1(rm1, rm2,
Hue - (120.0f * core::SharedMath::DegToRad)));
}
void CD3D8Texture::copy32BitMipMap(char* src, char* tgt,
s32 width, s32 height,
s32 pitchsrc, s32 pitchtgt) const
{
SColor c;
for (int x=0; x<width; ++x)
{
for (int y=0; y<height; ++y)
{
s32 a=0, r=0, g=0, b=0;
for (int dx=0; dx<2; ++dx)
{
for (int dy=0; dy<2; ++dy)
{
int tgx = (x*2)+dx;
int tgy = (y*2)+dy;
c = *(u32*)((void*)&src[(tgx<<2)+(tgy*pitchsrc)]);
a += c.getAlpha();
r += c.getRed();
g += c.getGreen();
b += c.getBlue();
}
}
a >>= 2;
r >>= 2;
g >>= 2;
b >>= 2;
c = ((a & 0xff)<<24) | ((r & 0xff)<<16) | ((g & 0xff)<<8) | (b & 0xff);
*(u32*)((void*)&tgt[(x*4)+(y*pitchtgt)]) = c.color;
}
}
}
SColor CEnvironment::LerpColorMap( float fRisingRate_, const vector<SColor>& aColorMap_ )
{
SColor ColorReturn;
if( aColorMap_.empty() )
{
ColorReturn = 0xFFFFFFFF;
return ColorReturn;
}
double fR = (aColorMap_.size()-1)*fRisingRate_;
int nColorLeft = floor( fR );
int nColorRight = ceil( fR );
double fRatio = fR - (double)nColorLeft;
SColor ColorLeft = aColorMap_[nColorLeft];
SColor ColorRight = aColorMap_[nColorRight];
ColorReturn.Lerp( ColorLeft, ColorRight, fRatio );
ColorReturn.A = 255;
return ColorReturn;
}
void RasLightMap::RasterizePixel( SScanLine& scanLine, const SScanLinesData& rasData )
{
#if USE_PERSPEC_CORRECT == 1
//双曲插值最后一步
float inv_w = 1 / scanLine.zw.y;
scanLine.finalUV.Set(scanLine.curUV.x*inv_w, scanLine.curUV.y*inv_w);
#else
scanLine.finalUV = scanLine.curUV;
#endif
if(rasData.pMaterial->bUseBilinearSampler)
{
rasData.pMaterial->pDiffuseMap->Tex2D_Bilinear(scanLine.finalUV, scanLine.pixelColor, rasData.texLod);
}
else
{
rasData.pMaterial->pDiffuseMap->Tex2D_Point(scanLine.finalUV, scanLine.pixelColor, rasData.texLod);
}
DWORD& dwDestColor = *(scanLine.pFragmeng->finalColor);
#if USE_OIT == 0
SColor destPixelColor;
destPixelColor.SetAsInt(dwDestColor);
DoAlphaBlending(destPixelColor, scanLine.pixelColor, destPixelColor, rasData.pMaterial);
dwDestColor = destPixelColor.GetAsInt();
#else
scanLine.pixelColor.a *= rasData.pMaterial->transparency;
dwDestColor = scanLine.pixelColor.GetAsInt();
#endif
#if USE_PROFILER == 1
g_env.profiler->AddRenderedPixel();
#endif
}
SColor Scene::getDiffuse(const vector3df& point, const vector3df& normal, const Material* mat)
{
SColor ret = mat->getColor();
SColorf light(0,0,0);
core::list<Light*>::Iterator it;
for (it = lights.begin(); it != lights.end(); it++)
{
float dot = ((*it)->Position - point).normalize().dotProduct(normal);
if (dot < 0)
continue;
SColorf& lightcol = (*it)->Color;
float coef = dot * (*it)->getIntensity(point);
light.r += lightcol.r * coef;
light.g += lightcol.g * coef;
light.b += lightcol.b * coef;
}
ret.set(255,
(u32)(ret.getRed() * light.r),
(u32)(ret.getGreen() * light.g),
(u32)(ret.getBlue() * light.b));
return ret;
}
void PostProcessing::renderFog()
{
const Track * const track = World::getWorld()->getTrack();
// This function is only called once per frame - thus no need for setters.
const float start = track->getFogStart();
const SColor tmpcol = track->getFogColor();
core::vector3df col( tmpcol.getRed() / 255.0f,
tmpcol.getGreen() / 255.0f,
tmpcol.getBlue() / 255.0f );
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_ONE, GL_ONE);
FullScreenShader::FogShader::getInstance()->SetTextureUnits(irr_driver->getDepthStencilTexture());
DrawFullScreenEffect<FullScreenShader::FogShader>(1.f / (40.f * start), col);
glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
}
Universe::Universe(char *serverAddress, char *serverPort)
{
instance = this;
strcpy(this->serverAddress, serverAddress);
strcpy(this->serverPort, serverPort);
render = new Render(1366, 768, true, L"Client");
guienv = render->device->getGUIEnvironment();
gui::IGUIFont* font2 = guienv->getFont("res/font.xml");
guienv->getSkin()->setFont(font2);
SColor color;
color = guienv->getSkin()->getColor(EGDC_3D_FACE);
color.setAlpha(192);
guienv->getSkin()->setColor(EGDC_3D_FACE, color);
color = guienv->getSkin()->getColor(EGDC_3D_SHADOW);
color.setAlpha(192);
guienv->getSkin()->setColor(EGDC_3D_SHADOW, color);
}
// ----------------------------------------------------------------------------
void Terrain::pixelHardBrush(u8* img, int ix, SColor col, bool erase)
{
if (erase)
{
if (col.getBlue() > 0) { img[ix] = 0; return; }
if (col.getGreen() > 0) { img[ix + 1] = 0; return; }
if (col.getRed() > 0) { img[ix + 2] = 0; return; }
return;
}
img[ix + 2] = col.getRed();
img[ix + 1] = col.getGreen();
img[ix + 0] = col.getBlue();
} // vertexHardBrush
// -----------------------------------------------------------------------------
video::ITexture* IconButtonWidget::getDeactivatedTexture(video::ITexture* texture)
{
#if !defined(SERVER_ONLY) && !defined(USE_GLES2)
STKTexture* stk_tex = static_cast<STKTexture*>(texture);
// Compressed texture can't be turned into greyscale
if (stk_tex->isMeshTexture() && CVS->isTextureCompressionEnabled())
return stk_tex;
std::string name = stk_tex->getName().getPtr();
name += "_disabled";
STKTexManager* stkm = STKTexManager::getInstance();
STKTexture* disabled_stk_tex = static_cast<STKTexture*>(stkm->getTexture
(name, NULL/*tc*/, false /*no_upload*/, false/*create_if_unfound*/));
if (disabled_stk_tex == NULL)
{
SColor c;
u32 g;
video::IVideoDriver* driver = irr_driver->getVideoDriver();
video::IImage* image = driver->createImageFromData
(video::ECF_A8R8G8B8, stk_tex->getSize(), stk_tex->lock(),
stk_tex->getTextureImage() == NULL/*ownForeignMemory*/);
texture->unlock();
//Turn the image into grayscale
for (u32 x = 0; x < image->getDimension().Width; x++)
{
for (u32 y = 0; y < image->getDimension().Height; y++)
{
c = image->getPixel(x, y);
g = ((c.getRed() + c.getGreen() + c.getBlue()) / 3);
c.set(std::max (0, (int)c.getAlpha() - 120), g, g, g);
image->setPixel(x, y, c);
}
}
return stkm->addTexture(new STKTexture(image, name));
}
return disabled_stk_tex;
#else
return texture;
#endif // !SERVER_ONLY
}
