Game::Game() :
m_BackGround(NULL),
m_LoadStep(0)
{
if(m_BackGround == NULL)
{
m_BackGround = new OpenGLTexture("images/BackGround");
}
std::vector<OpenGLTexture*> Textures;
for(int i = 0; i < SEGMENT_COUNT; i++)
{
OpenGLTexture* stars = new OpenGLTexture(STAR_LAYER[i]);
Textures.push_back(stars);
}
fillLayers(Textures, 0.3f);
clearTextures(Textures);
for(int i = 0; i < SEGMENT_COUNT; i++)
{
OpenGLTexture* mountains = new OpenGLTexture(MOUNTAIN_LAYER[i]);
Textures.push_back(mountains);
}
fillLayers(Textures, 0.6f);
clearTextures(Textures);
for(int i = 0; i < SEGMENT_COUNT; i++)
{
OpenGLTexture* cloud = new OpenGLTexture(CLOUDS_LAYER[i]);
Textures.push_back(cloud);
}
fillLayers(Textures, 0.5f);
clearTextures(Textures);
for(int i = 0; i < SEGMENT_COUNT; i++)
{
OpenGLTexture* ground = new OpenGLTexture(GROUND_LAYER[i]);
Textures.push_back(ground);
}
fillLayers(Textures, 2.0f);
clearTextures(Textures);
for(int i = 0; i < SEGMENT_COUNT; i++)
{
OpenGLTexture* path = new OpenGLTexture(PATH_LAYER[i]);
Textures.push_back(path);
}
fillLayers(Textures, 4.0f);
clearTextures(Textures);
}
//! Reads attributes of the scene node animator.
void CSceneNodeAnimatorTexture::deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options)
{
TimePerFrame = in->getAttributeAsInt("TimePerFrame");
Loop = in->getAttributeAsBool("Loop");
clearTextures();
for(u32 i=1; true; ++i)
{
core::stringc tname = "Texture";
tname += (int)i;
if (in->existsAttribute(tname.c_str()))
{
video::ITexture* tex = in->getAttributeAsTexture(tname.c_str());
if (tex)
{
tex->grab();
Textures.push_back(tex);
}
}
else
break;
}
}
// For each Direct3D sampler of either the pixel or vertex stage,
// looks up the corresponding OpenGL texture image unit and texture type,
// and sets the texture and its addressing/filtering state (or NULL when inactive).
// Sampler mapping needs to be up-to-date on the program object before this is called.
gl::Error RendererD3D::applyTextures(GLImplFactory *implFactory,
const gl::ContextState &data,
gl::SamplerType shaderType,
const FramebufferTextureArray &framebufferTextures,
size_t framebufferTextureCount)
{
ProgramD3D *programD3D = GetImplAs<ProgramD3D>(data.state->getProgram());
ASSERT(!programD3D->isSamplerMappingDirty());
unsigned int samplerRange = programD3D->getUsedSamplerRange(shaderType);
for (unsigned int samplerIndex = 0; samplerIndex < samplerRange; samplerIndex++)
{
GLenum textureType = programD3D->getSamplerTextureType(shaderType, samplerIndex);
GLint textureUnit = programD3D->getSamplerMapping(shaderType, samplerIndex, *data.caps);
if (textureUnit != -1)
{
gl::Texture *texture = data.state->getSamplerTexture(textureUnit, textureType);
ASSERT(texture);
gl::Sampler *samplerObject = data.state->getSampler(textureUnit);
const gl::SamplerState &samplerState =
samplerObject ? samplerObject->getSamplerState() : texture->getSamplerState();
// TODO: std::binary_search may become unavailable using older versions of GCC
if (texture->getTextureState().isSamplerComplete(samplerState, data) &&
!std::binary_search(framebufferTextures.begin(),
framebufferTextures.begin() + framebufferTextureCount, texture))
{
ANGLE_TRY(setSamplerState(shaderType, samplerIndex, texture, samplerState));
ANGLE_TRY(setTexture(shaderType, samplerIndex, texture));
}
else
{
// Texture is not sampler complete or it is in use by the framebuffer. Bind the incomplete texture.
gl::Texture *incompleteTexture = getIncompleteTexture(implFactory, textureType);
ANGLE_TRY(setSamplerState(shaderType, samplerIndex, incompleteTexture,
incompleteTexture->getSamplerState()));
ANGLE_TRY(setTexture(shaderType, samplerIndex, incompleteTexture));
}
}
else
{
// No texture bound to this slot even though it is used by the shader, bind a NULL texture
ANGLE_TRY(setTexture(shaderType, samplerIndex, nullptr));
}
}
// Set all the remaining textures to NULL
size_t samplerCount = (shaderType == gl::SAMPLER_PIXEL) ? data.caps->maxTextureImageUnits
: data.caps->maxVertexTextureImageUnits;
clearTextures(shaderType, samplerRange, samplerCount);
return gl::NoError();
}
SDLWrapper::~SDLWrapper() {
destroyWindow();
destroyRenderer();
clearTextures();
clearMap();
freeDrawableObjects();
freeTextObjects();
SDL_Quit();
TTF_Quit();
}
// For each Direct3D sampler of either the pixel or vertex stage,
// looks up the corresponding OpenGL texture image unit and texture type,
// and sets the texture and its addressing/filtering state (or NULL when inactive).
gl::Error RendererD3D::applyTextures(const gl::Data &data, gl::SamplerType shaderType,
const FramebufferTextureArray &framebufferTextures, size_t framebufferTextureCount)
{
gl::Program *program = data.state->getProgram();
unsigned int samplerRange = program->getUsedSamplerRange(shaderType);
for (unsigned int samplerIndex = 0; samplerIndex < samplerRange; samplerIndex++)
{
GLenum textureType = program->getSamplerTextureType(shaderType, samplerIndex);
GLint textureUnit = program->getSamplerMapping(shaderType, samplerIndex, *data.caps);
if (textureUnit != -1)
{
gl::Texture *texture = data.state->getSamplerTexture(textureUnit, textureType);
ASSERT(texture);
gl::SamplerState sampler = texture->getSamplerState();
gl::Sampler *samplerObject = data.state->getSampler(textureUnit);
if (samplerObject)
{
samplerObject->getState(&sampler);
}
// TODO: std::binary_search may become unavailable using older versions of GCC
if (texture->isSamplerComplete(sampler, data) &&
!std::binary_search(framebufferTextures.begin(), framebufferTextures.begin() + framebufferTextureCount, texture))
{
gl::Error error = setSamplerState(shaderType, samplerIndex, texture, sampler);
if (error.isError())
{
return error;
}
error = setTexture(shaderType, samplerIndex, texture);
if (error.isError())
{
return error;
}
}
else
{
// Texture is not sampler complete or it is in use by the framebuffer. Bind the incomplete texture.
gl::Texture *incompleteTexture = getIncompleteTexture(textureType);
gl::Error error = setTexture(shaderType, samplerIndex, incompleteTexture);
if (error.isError())
{
return error;
}
}
}
else
{
// No texture bound to this slot even though it is used by the shader, bind a NULL texture
gl::Error error = setTexture(shaderType, samplerIndex, NULL);
if (error.isError())
{
return error;
}
}
}
// Set all the remaining textures to NULL
size_t samplerCount = (shaderType == gl::SAMPLER_PIXEL) ? data.caps->maxTextureImageUnits
: data.caps->maxVertexTextureImageUnits;
clearTextures(shaderType, samplerRange, samplerCount);
return gl::Error(GL_NO_ERROR);
}
//! destructor
CSceneNodeAnimatorTexture::~CSceneNodeAnimatorTexture()
{
clearTextures();
}
DepthImageItem::~DepthImageItem()
{
clearTextures();
}
//----[ destroy ]----------------------------------------------------------
void EvidyonD3DRenderStateManager::destroy() {
resetState();
clearTextures();
SAFE_RELEASE(d3d_device_);
}
void Material::clearTextures()
{
auto ptr = lock();
if ( ptr )
ptr->clearTextures();
}
