bool Depth::operator==(const Depth &other) const {
if (getLevelCount() != other.getLevelCount()) {
return false;
}
for (unsigned int i = 0; i < getLevelCount() &&
i < other.getLevelCount(); i++) {
if (mvDepths[i] != other.mvDepths[i]) {
return false;
}
}
return true;
}
gl::Error TextureStorage9_2D::getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT)
{
ASSERT(index.mipIndex < getLevelCount());
if (!mRenderTargets[index.mipIndex] && isRenderTarget())
{
IDirect3DBaseTexture9 *baseTexture = NULL;
gl::Error error = getBaseTexture(&baseTexture);
if (error.isError())
{
return error;
}
IDirect3DSurface9 *surface = NULL;
error = getSurfaceLevel(GL_TEXTURE_2D, index.mipIndex, false, &surface);
if (error.isError())
{
return error;
}
size_t textureMipLevel = mTopLevel + index.mipIndex;
size_t mipWidth = std::max<size_t>(mTextureWidth >> textureMipLevel, 1u);
size_t mipHeight = std::max<size_t>(mTextureHeight >> textureMipLevel, 1u);
baseTexture->AddRef();
mRenderTargets[index.mipIndex] = new TextureRenderTarget9(
baseTexture, textureMipLevel, surface, mInternalFormat, static_cast<GLsizei>(mipWidth),
static_cast<GLsizei>(mipHeight), 1, 0);
}
void DomainConfigTdpControl_001::checkHWConfigTdpSupport(std::vector<ConfigTdpControl> controls, UIntN domainIndex)
{
m_configTdpLevelsAvailable = getLevelCount(domainIndex);
m_configTdpLock = isLockBitSet(domainIndex);
UIntN currentTdpControl = //ulTdpControl NOT index...
getParticipantServices()->primitiveExecuteGetAsUInt32(
esif_primitive_type::GET_PROC_CTDP_CURRENT_SETTING,
domainIndex);
// Determine the index...
Bool controlIdFound = false;
for (UIntN i = 0; i < controls.size(); i++)
{
if (currentTdpControl == controls.at(i).getControlId())
{
DELETE_MEMORY_TC(m_configTdpControlStatus);
m_configTdpControlStatus = new ConfigTdpControlStatus(i);
controlIdFound = true;
}
}
if (controlIdFound == false)
{
throw dptf_exception("cTDP control not found in set.");
}
}
bool Depth::operator<(const Depth &other) const {
unsigned int i;
for (i = 0; i < getLevelCount() && i < other.getLevelCount(); i++) {
if (mvDepths[i] < other.mvDepths[i]) {
return true;
} else if (mvDepths[i] > other.mvDepths[i]) {
return false;
}
}
if (i < getLevelCount()) {
return true;
} else if (i < other.getLevelCount()) {
return false;
}
return false;
}
TXshLevel *TLevelSet::getLevel(const ToonzScene &scene,
const TFilePath &levelPath) const {
const TFilePath &decodedPath = scene.decodeFilePath(levelPath);
int l, lCount = getLevelCount();
for (l = 0; l != lCount; ++l) {
TXshLevel *level = getLevel(l);
if (decodedPath == scene.decodeFilePath(level->getPath())) return level;
}
return 0;
}
TextureStorage9_2D::TextureStorage9_2D(Renderer9 *renderer, GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, int levels)
: TextureStorage9(renderer, GetTextureUsage(internalformat, renderTarget))
{
mTexture = NULL;
mRenderTarget = NULL;
mInternalFormat = internalformat;
const d3d9::TextureFormat &d3dFormatInfo = d3d9::GetTextureFormatInfo(internalformat);
mTextureFormat = d3dFormatInfo.texFormat;
d3d9::MakeValidSize(false, d3dFormatInfo.texFormat, &width, &height, &mTopLevel);
mTextureWidth = width;
mTextureHeight = height;
mMipLevels = mTopLevel + levels;
initializeSerials(getLevelCount(), 1);
}
gl::Error TextureStorage9_Cube::copyToStorage(TextureStorage *destStorage)
{
ASSERT(destStorage);
TextureStorage9_Cube *dest9 = TextureStorage9_Cube::makeTextureStorage9_Cube(destStorage);
int levels = getLevelCount();
for (int f = 0; f < CUBE_FACE_COUNT; f++)
{
for (int i = 0; i < levels; i++)
{
IDirect3DSurface9 *srcSurf = NULL;
gl::Error error = getCubeMapSurface(GL_TEXTURE_CUBE_MAP_POSITIVE_X + f, i, false, &srcSurf);
if (error.isError())
{
return error;
}
IDirect3DSurface9 *dstSurf = NULL;
error = dest9->getCubeMapSurface(GL_TEXTURE_CUBE_MAP_POSITIVE_X + f, i, true, &dstSurf);
if (error.isError())
{
SafeRelease(srcSurf);
return error;
}
error = mRenderer->copyToRenderTarget(dstSurf, srcSurf, isManaged());
SafeRelease(srcSurf);
SafeRelease(dstSurf);
if (error.isError())
{
return error;
}
}
}
return gl::Error(GL_NO_ERROR);
}
TextureStorage9_Cube::TextureStorage9_Cube(Renderer9 *renderer, GLenum internalformat, bool renderTarget, int size, int levels)
: TextureStorage9(renderer, GetTextureUsage(internalformat, renderTarget))
{
mTexture = NULL;
for (int i = 0; i < CUBE_FACE_COUNT; ++i)
{
mRenderTarget[i] = NULL;
}
mInternalFormat = internalformat;
const d3d9::TextureFormat &d3dFormatInfo = d3d9::GetTextureFormatInfo(internalformat);
mTextureFormat = d3dFormatInfo.texFormat;
int height = size;
d3d9::MakeValidSize(false, d3dFormatInfo.texFormat, &size, &height, &mTopLevel);
mTextureWidth = size;
mTextureHeight = size;
mMipLevels = mTopLevel + levels;
initializeSerials(getLevelCount() * CUBE_FACE_COUNT, CUBE_FACE_COUNT);
}
gl::Error TextureStorage9_2D::copyToStorage(TextureStorage *destStorage)
{
ASSERT(destStorage);
TextureStorage9_2D *dest9 = TextureStorage9_2D::makeTextureStorage9_2D(destStorage);
int levels = getLevelCount();
for (int i = 0; i < levels; ++i)
{
IDirect3DSurface9 *srcSurf = NULL;
gl::Error error = getSurfaceLevel(i, false, &srcSurf);
if (error.isError())
{
return error;
}
IDirect3DSurface9 *dstSurf = NULL;
error = dest9->getSurfaceLevel(i, true, &dstSurf);
if (error.isError())
{
SafeRelease(srcSurf);
return error;
}
error = mRenderer->copyToRenderTarget(dstSurf, srcSurf, isManaged());
SafeRelease(srcSurf);
SafeRelease(dstSurf);
if (error.isError())
{
return error;
}
}
return gl::Error(GL_NO_ERROR);
}
angle::Result TextureStorage9_2D::getRenderTarget(const gl::Context *context,
const gl::ImageIndex &index,
RenderTargetD3D **outRT)
{
ASSERT(index.getLevelIndex() < getLevelCount());
if (!mRenderTargets[index.getLevelIndex()] && isRenderTarget())
{
IDirect3DBaseTexture9 *baseTexture = nullptr;
ANGLE_TRY(getBaseTexture(context, &baseTexture));
IDirect3DSurface9 *surface = nullptr;
ANGLE_TRY(getSurfaceLevel(context, gl::TextureTarget::_2D, index.getLevelIndex(), false,
&surface));
size_t textureMipLevel = mTopLevel + index.getLevelIndex();
size_t mipWidth = std::max<size_t>(mTextureWidth >> textureMipLevel, 1u);
size_t mipHeight = std::max<size_t>(mTextureHeight >> textureMipLevel, 1u);
baseTexture->AddRef();
mRenderTargets[index.getLevelIndex()] = new TextureRenderTarget9(
baseTexture, textureMipLevel, surface, mInternalFormat, static_cast<GLsizei>(mipWidth),
static_cast<GLsizei>(mipHeight), 1, 0);
}
void Wavelet::decompose() {
copyDataToCoeficientArray();
for (int level = 0; level < getLevelCount(); ++level) {
decomposeOneLevel(level);
}
}
TXshLevel *TLevelSet::getLevel(int index) const {
assert(0 <= index && index < getLevelCount());
return m_levels[index];
}
GeometryClipmapLevel& GeometryClipmaps::getLevel( int index )
{
assert( index >= 0 );
assert( index < getLevelCount() );
return levels_[ index ];
}
