C4FoWAmbient Class Reference

#include <C4FoWAmbient.h>

Public Member Functions
	C4FoWAmbient ()
	~C4FoWAmbient ()
void	Clear ()
void	SetBrightness (double brightness)
double	GetBrightness () const
void	CreateFromLandscape (const C4Landscape &landscape, double resolution, double radius, double full_coverage)
void	UpdateFromLandscape (const C4Landscape &landscape, const C4Rect &update)
void	GetFragTransform (const struct FLOAT_RECT &vpRect, const C4Rect &clipRect, const C4Rect &outRect, float ambientTransform[6]) const
unsigned int	GetLandscapeWidth () const
unsigned int	GetLandscapeHeight () const

Public Attributes
GLuint	Tex {0}

Detailed Description

This class manages a texture that holds the ambient light intensity

Definition at line 29 of file C4FoWAmbient.h.

Constructor & Destructor Documentation

C4FoWAmbient()

C4FoWAmbient::C4FoWAmbient ( )

default

~C4FoWAmbient()

C4FoWAmbient::~C4FoWAmbient

(

)

Definition at line 90 of file C4FoWAmbient.cpp.

{
    Clear();
}

References Clear().

Here is the call graph for this function:

Member Function Documentation

Clear()

void C4FoWAmbient::Clear

(

)

Definition at line 95 of file C4FoWAmbient.cpp.

{
#ifndef USE_CONSOLE
    if(Tex != 0) glDeleteTextures(1, &Tex);
    Tex = 0;
#endif
    Resolution = Radius = FullCoverage = 0.;
    SizeX = SizeY = 0;
    LandscapeX = LandscapeY = 0;
    Brightness = 1.;
}

References Tex.

Referenced by CreateFromLandscape(), and ~C4FoWAmbient().

Here is the caller graph for this function:

CreateFromLandscape()

void C4FoWAmbient::CreateFromLandscape	(	const C4Landscape &	landscape,
		double	resolution,
		double	radius,
		double	full_coverage
	)

Definition at line 107 of file C4FoWAmbient.cpp.

{
    assert(resolution >= 1.);
    assert(radius >= 1.);
    assert(full_coverage > 0 && full_coverage <= 1.);
 
    // Clear old map
    Clear();
 
    Resolution = resolution;
    Radius = radius;
    FullCoverage = full_coverage;
 
    // Number of zoomed pixels
    LandscapeX = Landscape.GetWidth();
    LandscapeY = Landscape.GetHeight();
    SizeX = std::min<unsigned int>(static_cast<unsigned int>(ceil(LandscapeX / resolution)), pDraw->MaxTexSize);
    SizeY = std::min<unsigned int>(static_cast<unsigned int>(ceil(LandscapeY / resolution)), pDraw->MaxTexSize);
 
#ifndef USE_CONSOLE
    glGenTextures(1, &Tex);
    glBindTexture(GL_TEXTURE_2D, Tex);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, SizeX, SizeY, 0, GL_RED, GL_FLOAT, nullptr);
 
    const C4TimeMilliseconds begin = C4TimeMilliseconds::Now();
    UpdateFromLandscape(landscape, C4Rect(0, 0, Landscape.GetWidth(), Landscape.GetHeight()));
    uint32_t dt = C4TimeMilliseconds::Now() - begin;
    LogF("Created %ux%u ambient map in %g secs", SizeX, SizeY, dt / 1000.);
#endif
}

References Clear(), C4Landscape::GetHeight(), C4Landscape::GetWidth(), Landscape, LogF(), C4Draw::MaxTexSize, C4TimeMilliseconds::Now(), pDraw, Tex, and UpdateFromLandscape().

Here is the call graph for this function:

GetBrightness()

double C4FoWAmbient::GetBrightness ( ) const

inline

Definition at line 56 of file C4FoWAmbient.h.

{ return Brightness; }

Referenced by C4LandscapeRenderGL::Draw(), and CStdGL::SetupMultiBlt().

Here is the caller graph for this function:

GetFragTransform()

void C4FoWAmbient::GetFragTransform	(	const struct FLOAT_RECT &	vpRect,
		const C4Rect &	clipRect,
		const C4Rect &	outRect,
		float	ambientTransform[6]
	)		const

Definition at line 199 of file C4FoWAmbient.cpp.

{
    C4FragTransform trans;
    // Invert Y coordinate
    trans.Scale(1, -1);
    trans.Translate(0, outRect.Hgt);
    // Clip offset
    trans.Translate(-clipRect.x, -clipRect.y);
    // Clip normalization (0,0 -> 1,1)
    trans.Scale(1.0f / clipRect.Wdt, 1.0f / clipRect.Hgt);
    // Viewport normalization
    trans.Scale(vpRect.right - vpRect.left, vpRect.bottom - vpRect.top);
    // Viewport offset
    trans.Translate(vpRect.left, vpRect.top);
    // Landscape normalization
    trans.Scale(1.0f / LandscapeX, 1.0f / LandscapeY);
 
    // Extract matrix
    trans.Get2x3(ambientTransform);
}

References FLOAT_RECT::bottom, C4FragTransform::Get2x3(), C4Rect::Hgt, FLOAT_RECT::left, FLOAT_RECT::right, C4FragTransform::Scale(), FLOAT_RECT::top, C4FragTransform::Translate(), C4Rect::Wdt, C4Rect::x, and C4Rect::y.

Referenced by C4LandscapeRenderGL::Draw(), and CStdGL::SetupMultiBlt().

Here is the call graph for this function:

Here is the caller graph for this function:

GetLandscapeHeight()

unsigned int C4FoWAmbient::GetLandscapeHeight ( ) const

inline

Definition at line 73 of file C4FoWAmbient.h.

{ return LandscapeY; }

GetLandscapeWidth()

unsigned int C4FoWAmbient::GetLandscapeWidth ( ) const

inline

Definition at line 72 of file C4FoWAmbient.h.

{ return LandscapeX; }

SetBrightness()

void C4FoWAmbient::SetBrightness ( double  brightness )

inline

Definition at line 55 of file C4FoWAmbient.h.

{ Brightness = brightness; }

UpdateFromLandscape()

void C4FoWAmbient::UpdateFromLandscape	(	const C4Landscape &	landscape,
		const C4Rect &	update
	)

Definition at line 142 of file C4FoWAmbient.cpp.

{
#ifndef USE_CONSOLE
    // Nothing to do?
    if(update.Wdt == 0 || update.Hgt == 0) return;
 
    assert(Tex != 0);
 
    // Factor to go from zoomed to landscape coordinates
    const double zoom_x = static_cast<double>(Landscape.GetWidth()) / SizeX;
    const double zoom_y = static_cast<double>(Landscape.GetHeight()) / SizeY;
    // Update region in zoomed coordinates
    const unsigned int left = std::max(static_cast<int>( (update.x - Radius) / zoom_x), 0);
    const unsigned int right = std::min(static_cast<unsigned int>( (update.x + update.Wdt + Radius) / zoom_x), SizeX - 1) + 1;
    const unsigned int top = std::max(static_cast<int>( (update.y - Radius) / zoom_y), 0);
    const unsigned int bottom = std::min(static_cast<unsigned int>( (update.y + update.Hgt + Radius) / zoom_y), SizeY - 1) + 1;
    assert(right > left);
    assert(bottom > top);
    // Zoomed radius
    const double R = Radius / sqrt(zoom_x * zoom_y);
    // Normalization factor with the full circle
    // The analytic result is 2*R*M_PI, and this number is typically close to it
    const double norm = AmbientForPix(0, 0, R, LightMapFull()) * FullCoverage;
    // Create the ambient map
    LightMapZoom light_mapZoom(landscape, zoom_x, zoom_y);
    float* ambient = new float[(right - left) * (bottom - top)];
    for(unsigned int y = top; y < bottom; ++y)
    {
        for(unsigned int x = left; x < right; ++x)
        {
            ambient[(y - top) * (right - left) + (x - left)] = std::min(AmbientForPix(x, y, R, light_mapZoom) / norm, 1.0);
        }
    }
 
#if 0
    CSurface8 debug(SizeX, SizeY);
    for(unsigned int y = 0; y < SizeY; ++y)
    {
        for(unsigned int x = 0; x < SizeX; ++x)
        {
            debug.SetPix(x, y, int(ambient[y * SizeX + x] * 255. + 0.5));
        }
    }
 
    CStdPalette pal;
    for(int i = 0; i < 256; ++i)
        pal.Colors[i] = i + (i << 8) + (i << 16);
    debug.Save("Ambient.bmp", &pal);
#endif
 
    // Update the texture
    glBindTexture(GL_TEXTURE_2D, Tex);
    glTexSubImage2D(GL_TEXTURE_2D, 0, left, top, (right - left), (bottom - top), GL_RED, GL_FLOAT, ambient);
    delete[] ambient;
#endif
}

References C4ScriptGuiWindowPropertyName::bottom, CStdPalette::Colors, C4Landscape::GetHeight(), C4Landscape::GetWidth(), C4Rect::Hgt, Landscape, C4ScriptGuiWindowPropertyName::left, C4ScriptGuiWindowPropertyName::right, CSurface8::Save(), CSurface8::SetPix(), Tex, C4ScriptGuiWindowPropertyName::top, C4Rect::Wdt, C4Rect::x, and C4Rect::y.

Referenced by CreateFromLandscape().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

Tex

GLuint C4FoWAmbient::Tex {0}

Definition at line 36 of file C4FoWAmbient.h.

Referenced by Clear(), CreateFromLandscape(), C4LandscapeRenderGL::Draw(), CStdGL::SetupMultiBlt(), and UpdateFromLandscape().

---

The documentation for this class was generated from the following files:

• C4FoWAmbient.h
• C4FoWAmbient.cpp