Surface::Surface ( Uint16 _sizeX, Uint16 _sizeY, Uint16 _splitSections ) { if ( _splitSections > 64 ) _splitSections = 64; m_sizeXY = std::max ( nearestPowerOfTwo ( _sizeX ), nearestPowerOfTwo ( _sizeY ) ); m_sqrtN = _splitSections; ARCDebugAssert ( isPowerOfTwo ( _splitSections ) ); if ( !isPowerOfTwo ( _splitSections ) ) { _splitSections = nearestPowerOfTwo ( _splitSections ); m_nWays = _splitSections * _splitSections; m_sqrtN = _splitSections; } // We want to force it to use the nicest texture size possible without // compromising performance. Uint16 maxTexSize = std::min ( g_graphics->GetMaximumTextureSize() / 2, 1024 ); m_pixelWH = m_sizeXY / m_sqrtN; while ( m_pixelWH > maxTexSize ) { m_sqrtN *= 2; m_pixelWH = m_sizeXY / m_sqrtN; } m_nWays = m_sqrtN * m_sqrtN; m_sectionIDs.setSize ( m_nWays ); m_srcRects = new SDL_Rect[m_nWays]; m_destRects = new SDL_Rect[m_nWays]; }
void OpenglES2Device::generateMipMapFor2DTexture(int width, int height){ // Opengl ES 2 requiere que para aplicar mipmap las texturas sean potencias de 2 if(VideoConfiguration::getInstance()->isMipMapActive() && isPowerOfTwo(width) && isPowerOfTwo(height) ){ glGenerateMipmap(GL_TEXTURE_2D); this->evaluateErrorsAndLog("generateMipMapFor2DTexture"); } }
unsigned char* imageIO::squareImage(unsigned char origImage[], int imageWidth, int imageHeight, int imageBytes) { int newImageWidth = 0; int newImageHeight = 0; if (std::max(imageWidth, imageHeight) == imageWidth) { if (!isPowerOfTwo(imageWidth)) { newImageWidth = pow(2, ceil(log(imageWidth) / log(2))); newImageHeight = newImageWidth; } else { newImageWidth = imageWidth; newImageHeight = imageWidth; } } else { if (!isPowerOfTwo(imageHeight)) { newImageHeight = pow(2, ceil(log(imageHeight) / log(2)));; newImageWidth = newImageHeight; } else { newImageHeight = imageHeight; newImageWidth = imageHeight; } } unsigned char* squareImage = new unsigned char[newImageWidth*newImageHeight*imageBytes]; for (int y = 0; y < newImageHeight; y++) { for (int x = 0; x < newImageWidth; x++) { int oldIndex = ((y * imageWidth * imageBytes) + (x * imageBytes)); int newIndex = ((y * newImageWidth * imageBytes) + (x * imageBytes)); if (x < imageWidth && y < imageHeight) { squareImage[newIndex] = origImage[oldIndex]; squareImage[newIndex + 1] = origImage[oldIndex + 1]; squareImage[newIndex + 2] = origImage[oldIndex + 2]; squareImage[newIndex + 3] = origImage[oldIndex + 3]; } else { squareImage[newIndex] = 255; squareImage[newIndex + 1] = 255; squareImage[newIndex + 2] = 255; squareImage[newIndex + 3] = 255; } } } setImageWidth(newImageWidth); setImageHeight(newImageHeight); return squareImage; }
ModifiableTexture::ModifiableTexture(int width, int height) { if(!isPowerOfTwo(width) || !isPowerOfTwo(height)) gdt_fatal(TAG, "ModifiableTexture sizes has to be a power of 2."); mWidth = width; mHeight = height; //mData = new pixel[width*height]; //(pixel *) calloc(width*height, sizeof(pixel)); mData = (pixel *) calloc(width*height, sizeof(pixel)); uploadAndCreateTexture(); sTextures.push_back(this); }
bool ProgramHeader::verify(){ if (GET(p_type) == PT_LOAD){ if (GET(p_filesz) > GET(p_memsz)){ PRINT_ERROR("File size (%d) may not be greater than memory size (%d) for a loadable segment", GET(p_filesz), GET(p_memsz)); return false; } } if (!isPowerOfTwo(GET(p_align)) && GET(p_align) != 0){ PRINT_ERROR("Segment alignment must be 0 or a positive power of 2"); return false; } if (GET(p_align) > 1){ if (GET(p_vaddr) % GET(p_align) != GET(p_offset) % GET(p_align)){ PRINT_ERROR("Segment(%d) virtual address(%016llx) and offset(%016llx) do not conform to alignment(%016llx)", index, GET(p_vaddr), GET(p_offset), GET(p_align)); return false; } } if (GET(p_vaddr) % DEFAULT_PAGE_ALIGNMENT != GET(p_paddr) % DEFAULT_PAGE_ALIGNMENT){ PRINT_ERROR("Physical and virtual address must be congruent mod pagesize for program header %d", index); return false; } return true; }
PageAllocationAligned PageAllocationAligned::allocate(size_t size, size_t alignment, OSAllocator::Usage usage, bool writable) { ASSERT(isPageAligned(size)); ASSERT(isPageAligned(alignment)); ASSERT(isPowerOfTwo(alignment)); ASSERT(size >= alignment); size_t alignmentMask = alignment - 1; #if OS(DARWIN) int flags = VM_FLAGS_ANYWHERE; if (usage != OSAllocator::UnknownUsage) flags |= usage; int protection = PROT_READ; if (writable) protection |= PROT_WRITE; vm_address_t address = 0; vm_map(current_task(), &address, size, alignmentMask, flags, MEMORY_OBJECT_NULL, 0, FALSE, protection, PROT_READ | PROT_WRITE, VM_INHERIT_DEFAULT); return PageAllocationAligned(reinterpret_cast<void*>(address), size); #else size_t alignmentDelta = alignment - pageSize(); // Resererve with suffcient additional VM to correctly align. size_t reservationSize = size + alignmentDelta; void* reservationBase = OSAllocator::reserveUncommitted(reservationSize, usage, writable, false); // Select an aligned region within the reservation and commit. void* alignedBase = reinterpret_cast<uintptr_t>(reservationBase) & alignmentMask ? reinterpret_cast<void*>((reinterpret_cast<uintptr_t>(reservationBase) & ~alignmentMask) + alignment) : reservationBase; OSAllocator::commit(alignedBase, size, writable, false); return PageAllocationAligned(alignedBase, size, reservationBase, reservationSize); #endif }
void Texture::resize(const unsigned int _width, const unsigned int _height) { m_width = _width; m_height = _height; if (!(Hardware::supportsTextureNPOT) && !(isPowerOfTwo(m_width) && isPowerOfTwo(m_height)) && (m_generateMipmaps || isRepeatWrapping(m_options.wrapping))) { LOGW("OpenGL ES doesn't support texture repeat wrapping for NPOT textures nor mipmap textures"); LOGW("Falling back to LINEAR Filtering"); m_options.filtering = {GL_LINEAR, GL_LINEAR}; m_generateMipmaps = false; } m_shouldResize = true; m_dirtyRanges.clear(); }
bool FFT::init(UINT fftWindowSize,UINT hopSize,UINT numDimensions,UINT fftWindowFunction,bool computeMagnitude,bool computePhase,DataType inputType,DataType outputType){ //Clear any previous setup clear(); if( !isPowerOfTwo(fftWindowSize) ){ errorLog << "init(UINT fftWindowSize,UINT hopSize,UINT numDimensions,UINT fftWindowFunction,bool computeMagnitude,bool computePhase) - fftWindowSize is not a power of two!" << std::endl; return false; } if( !validateFFTWindowFunction( fftWindowFunction ) ){ errorLog << "init(UINT fftWindowSize,UINT hopSize,UINT numDimensions,UINT fftWindowFunction,bool computeMagnitude,bool computePhase) - Unkown Window Function!" << std::endl; return false; } this->dataBufferSize = fftWindowSize; this->fftWindowSize = fftWindowSize; this->hopSize = hopSize; this->fftWindowFunction = fftWindowFunction; this->computeMagnitude = computeMagnitude; this->computePhase = computePhase; this->inputType = inputType; this->outputType = outputType; hopCounter = 0; featureDataReady = false; numInputDimensions = numDimensions; //Set the output size, the fftWindowSize is divided by 2 because the FFT is symmetrical so only half the actual FFT is returned numOutputDimensions = 0; if( computePhase ) numOutputDimensions += fftWindowSize/2 * numInputDimensions; if( computeMagnitude ) numOutputDimensions += fftWindowSize/2 * numInputDimensions; //Resize the output feature vector featureVector.resize( numOutputDimensions, 0); dataBuffer.resize( dataBufferSize ); tempBuffer.resize( dataBufferSize ); for(UINT i=0; i<dataBufferSize; i++){ dataBuffer[i].resize( numInputDimensions, 0 ); } for(UINT i=0; i<dataBufferSize; i++){ dataBuffer[i].resize( numInputDimensions, 0 ); } //Setup the fft for each dimension fft.resize(numInputDimensions); for(unsigned int i=0; i<numInputDimensions; i++){ if( !fft[i].init(fftWindowSize,fftWindowFunction,computeMagnitude,computePhase) ){ errorLog << "init(UINT fftWindowSize,UINT hopSize,UINT numDimensions,UINT fftWindowFunction,bool computeMagnitude,bool computePhase) - Failed to initialize fft!" << std::endl; clear(); return false; } } initialized = true; return true; }
bool howPartition( int rLen, int maxNumThread, int* info ) { int maxNumElePerBlock = maxNumThread*2; int numBlock = (int)ceil((float)rLen/(maxNumElePerBlock)); bool isMul = (rLen%maxNumElePerBlock == 0)?true:false; if( isMul ) { info[0] = numBlock; info[1] = maxNumThread; } else { info[0] = numBlock - 1; int remainer = rLen - (numBlock - 1)*maxNumElePerBlock; if( isPowerOfTwo(remainer) ) { info[1] = remainer/2; } else { info[1] = floorPow2( remainer ); } } return isMul; }
bool isPowerOfTwo(int n) { if(n==1) return true; if(n==0) return false; int res = n % 2; if(res==0) return isPowerOfTwo(n/2); else return false; }
int main(int argc, char* argv[]) { output = fopen("final", "wb"); argc--; path = malloc(MAX_PATH * sizeof(char)); isMaster = 1; //only works with number of files that are a power of two! if(!isPowerOfTwo(argc)) { printf("# of args(%i) not power of 2\n", argc); return 0; } filenames = malloc(sizeof(char*) * argc); //stores files into global array for(int i = 0; i < argc; i++) { filenames[i] = argv[i + 1]; } //number of levels in the tree, discluding the master node max_levels = (int)(log(argc) / log(2)); spawnChildren(max_levels); free(filenames); fclose(output); sleep(1); return 0; }
LargeObject FreeList::take(Owner owner, size_t alignment, size_t size, size_t unalignedSize) { BASSERT(isPowerOfTwo(alignment)); size_t alignmentMask = alignment - 1; LargeObject candidate; size_t candidateIndex; size_t begin = m_vector.size() > freeListSearchDepth ? m_vector.size() - freeListSearchDepth : 0; for (size_t i = begin; i < m_vector.size(); ++i) { LargeObject largeObject(LargeObject::DoNotValidate, m_vector[i].begin()); if (!largeObject.isValidAndFree(owner, m_vector[i].size())) { m_vector.pop(i--); continue; } if (largeObject.size() < size) continue; if (test(largeObject.begin(), alignmentMask) && largeObject.size() < unalignedSize) continue; if (!!candidate && candidate.begin() < largeObject.begin()) continue; candidate = largeObject; candidateIndex = i; } if (!!candidate) m_vector.pop(candidateIndex); return candidate; }
int main(void) { int count,i,ans; long long int a, q,z; char dummy; freopen("in.txt","r",stdin); freopen("out.txt","w",stdout); scanf("%d",&count); for(i=1;i<=count;i++) { scanf("%lld%c%lld",&a,&dummy,&q); z=gcd(a,q); a=a/z; q=q/z; if(isPowerOfTwo(q)) { // power= log10(q)/log10(2); // printf("%d\n",power); // if(((float)a/q)>1/2.0) // { // printf("Case #%d: %d\n",i,power); // } // else // printf("Case #%d: %d\n",i,power+1); ans=rec(a,q); printf("Case #%d: %d\n",i,ans); } else printf("Case #%d: impossible\n",i); } return 0; }
void* Heap::allocateLarge(std::lock_guard<StaticMutex>& lock, size_t alignment, size_t size, size_t unalignedSize) { BASSERT(size <= largeMax); BASSERT(size >= largeMin); BASSERT(size == roundUpToMultipleOf<largeAlignment>(size)); BASSERT(unalignedSize <= largeMax); BASSERT(unalignedSize >= largeMin); BASSERT(unalignedSize == roundUpToMultipleOf<largeAlignment>(unalignedSize)); BASSERT(alignment <= largeChunkSize / 2); BASSERT(alignment >= largeAlignment); BASSERT(isPowerOfTwo(alignment)); LargeObject largeObject = m_largeObjects.take(alignment, size, unalignedSize); if (!largeObject) { m_isAllocatingPages = true; largeObject = m_vmHeap.allocateLargeObject(alignment, size, unalignedSize); } size_t alignmentMask = alignment - 1; if (test(largeObject.begin(), alignmentMask)) { size_t prefixSize = roundUpToMultipleOf(alignment, largeObject.begin() + largeMin) - largeObject.begin(); std::pair<LargeObject, LargeObject> pair = largeObject.split(prefixSize); m_largeObjects.insert(pair.first); largeObject = pair.second; } return allocateLarge(lock, largeObject, size); }
size_t pageSize() { if (!s_pageSize) s_pageSize = systemPageSize(); ASSERT(isPowerOfTwo(s_pageSize)); return s_pageSize; }
void MFNHashTypePlain::createArbitraryBitmap(uint8_t startWord, std::vector<std::vector<uint8_t> > &hashList, std::vector<uint8_t> &bitmap, uint32_t bitmapSizeBytes) { uint32_t bitmapIndex; uint8_t bitmapByte; uint64_t passwordIndex; uint32_t bitmapMask; if (!isPowerOfTwo(bitmapSizeBytes)) { printf("Error! Bitmap size not a power of 2!\n"); exit(1); } // Set the bitmap mask - size - 1 for and masking. bitmapMask = (bitmapSizeBytes - 1); // Step 1: Set the vector to whatever is specified. bitmap.resize(bitmapSizeBytes); // Step 2: Clear the vector memset(&bitmap[0], 0, bitmapSizeBytes); for (passwordIndex = 0; passwordIndex < hashList.size(); passwordIndex++) { if (this->HashIsBigEndian) { // Big endian hash - read in as a big endian value bitmapIndex = ((uint32_t)hashList.at(passwordIndex).at((startWord * 4) + 0) << 24) + ((uint32_t)hashList.at(passwordIndex).at((startWord * 4) + 1) << 16) + ((uint32_t)hashList.at(passwordIndex).at((startWord * 4) + 2) << 8) + ((uint32_t)hashList.at(passwordIndex).at((startWord * 4) + 3) << 0); } else { // Little endian hash - take bytes 0 & 1 in the word as the low value (swapped). bitmapIndex = ((uint32_t)hashList.at(passwordIndex).at((startWord * 4) + 0) << 0) + ((uint32_t)hashList.at(passwordIndex).at((startWord * 4) + 1) << 8) + ((uint32_t)hashList.at(passwordIndex).at((startWord * 4) + 2) << 16) + ((uint32_t)hashList.at(passwordIndex).at((startWord * 4) + 3) << 24); } //printf("bitmapIndex: %08x\n", bitmapIndex); // Set the byte by shifting left by the lower 3 bits in the index bitmapByte = 0x01 << (bitmapIndex & 0x0007); // Determine the byte offset by shifting right 3 bits. bitmapIndex = bitmapIndex >> 3; // Mask off the lower 27 bits bitmapIndex &= bitmapMask; //printf("bitmapByte: %02x\n", bitmapByte); //printf("bitmapIndex: %08x\n", bitmapIndex); if (bitmapIndex >= bitmapSizeBytes) { printf("FATAL ERROR: Bitmap index beyond bound of bitmap!\n"); exit(1); } // Add the bit into the bitmap bitmap[bitmapIndex] |= bitmapByte; } }
int main(void){ int test = 38; //whatever you like bool result = isPowerOfTwo(test); printf("%d\n",result); return 0; }
bool canUseMipmaps(const QSize &size) { static bool initialized = false; static bool supportsNonPowerOfTwoMipmaps = true; if (!initialized) { printf("VENDOR string: %s\n", glGetString(GL_VENDOR)); printf("RENDERER string: %s\n", glGetString(GL_RENDERER)); supportsNonPowerOfTwoMipmaps = !QByteArray(reinterpret_cast<const char *>(glGetString(GL_RENDERER))).contains("Tegra 3"); initialized = true; printf("Supports non-power-of-two mipmaps: %d\n", int(supportsNonPowerOfTwoMipmaps)); } return supportsNonPowerOfTwoMipmaps || (isPowerOfTwo(size.width()) && isPowerOfTwo(size.height())); }
//----------------------------------------------------------------------------- UserSuppliedHeapBuffer* UserSuppliedHeapBuffer_Alloc( int bufSize, int alignment ) //----------------------------------------------------------------------------- { UserSuppliedHeapBuffer* p = ( UserSuppliedHeapBuffer* )calloc( 1, sizeof( UserSuppliedHeapBuffer ) ); p->bufSize_ = bufSize; p->alignment_ = alignment; if( bufSize > 0 ) { assert( isPowerOfTwo( alignment ) ); p->pBuf_ = ( char* )calloc( 1, bufSize + alignment ); #if defined(_MSC_VER) && (_MSC_VER < 1400) // is older then Microsoft VS 2005 compiler? p->pBufAligned_ = ( char* )( ( ( ( UINT_PTR )( p->pBuf_ ) + alignment - 1 ) & ( UINT_MAX - ( alignment - 1 ) ) ) ); #elif defined(_WIN32) && defined(__BORLANDC__) // is Borland C++ Builder? p->pBufAligned_ = ( char* )( ( ( ( UINT_PTR )( p->pBuf_ ) + alignment - 1 ) & ( UINT_MAX - ( alignment - 1 ) ) ) ); #else p->pBufAligned_ = ( char* )( ( ( ( UINT_PTR )( p->pBuf_ ) + alignment - 1 ) & ( SIZE_MAX - ( alignment - 1 ) ) ) ); #endif // #if defined(_MSC_VER) && (_MSC_VER < 1300) // is 'old' Microsoft VC6 compiler? } else { p->pBuf_ = 0; p->pBufAligned_ = 0; } p->pNext_ = 0; p->pPrev_ = 0; return p; }
void global_sum(double* result, int rank, int size, double my_value){ // error checking code if(!isPowerOfTwo(size)){ printf("The number of processors must be power of 2!\n"); MPI_Finalize(); exit(1); } double recvbuf; MPI_Status status; *result=my_value; // add my_value to result while(0!=(size=size/2)){ if(rank%(size*2)<size){ MPI_Sendrecv(result, 1, MPI_DOUBLE, rank+size, size, &recvbuf, 1, MPI_DOUBLE, rank+size, size, MPI_COMM_WORLD, &status); } else { MPI_Sendrecv(result, 1, MPI_DOUBLE, rank-size, size, &recvbuf, 1, MPI_DOUBLE, rank-size, size, MPI_COMM_WORLD, &status); } *result+=recvbuf; } return; }
UnlockQueue::UnlockQueue(unsigned int size) : m_size(size) { if (!isPowerOfTwo(size)) { m_size = roundupPowerOfTwo(size); } }
static void initTexture(const char* filename) { FILE* imageFile; int lat, lon; unsigned char buffer[4]; unsigned char* image; int dx, dy; /* initialize texture coordinates */ for (lat = 0; lat <= LAT_GRID; lat++) { const float y = (float)lat / (float)LAT_GRID; for (lon = 0; lon <= LON_GRID; lon++) { uv[lat][lon][0] = (float)lon / (float)LON_GRID; uv[lat][lon][1] = y; } } /* open image file */ imageFile = fopen(filename, "rb"); if (!imageFile) { fprintf(stderr, "cannot open image file %s for reading\n", filename); exit(1); } /* read image size */ fread(buffer, 1, 4, imageFile); dx = (int)((buffer[0] << 8) | buffer[1]); dy = (int)((buffer[2] << 8) | buffer[3]); if (!isPowerOfTwo(dx) || !isPowerOfTwo(dy)) { fprintf(stderr, "image %s has an illegal size: %dx%d\n", filename, dx, dy); exit(1); } /* read image */ image = (unsigned char*)malloc(3 * dx * dy * sizeof(unsigned char)); fread(image, 3 * dx, dy, imageFile); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, 3, dx, dy, 0, GL_RGB, GL_UNSIGNED_BYTE, image); /* tidy up */ free(image); fclose(imageFile); }
int Mymain() { vector<int> nums = {0, 1, 65536, 93728, 32, 999, -3893}; cout << std::boolalpha; for (int i : nums){ cout << i << ": \t" << isPowerOfTwo(i) << endl; } }
int MathUtilities::nearestPowerOfTwo(int x) { if (isPowerOfTwo(x)) return x; int n0 = previousPowerOfTwo(x), n1 = nextPowerOfTwo(x); if (x - n0 < n1 - x) return n0; else return n1; }
int main(int argc, char **argv) { int n; while (scanf("%d", &n) != EOF) { printf("%d\n", isPowerOfTwo(n)); } return 0; }
int MathUtilities::nextPowerOfTwo(int x) { if (isPowerOfTwo(x)) return x; if (x < 1) return 1; int n = 1; while (x) { x >>= 1; n <<= 1; } return n; }
int main() { int N; scanf("%d",N); if(isPowerOfTwo(N)) printf("Yes\n",N); else printf("No\n"); }
int main() { int num; int a; while (1) { scanf("%d", &num); a = isPowerOfTwo(num); printf("%d\n", a); } }
void ContentLayerChromium::updateTextureRect(void* pixels, const IntSize& bitmapSize, const IntSize& requiredTextureSize, const IntRect& updateRect, unsigned textureId, MipmapUse requestMipmap) { if (!pixels) return; GraphicsContext3D* context = layerRendererContext(); context->bindTexture(GraphicsContext3D::TEXTURE_2D, textureId); bool generateMipmap = (requestMipmap == useMipmap) && (layerRenderer()->contentLayerSharedValues()->npotSupported() || (isPowerOfTwo(updateRect.width()) && isPowerOfTwo(updateRect.height()))); // If the texture id or size changed since last time then we need to tell GL // to re-allocate a texture. if (m_contentsTexture != textureId || requiredTextureSize != m_allocatedTextureSize) { ASSERT(bitmapSize == requiredTextureSize); GLC(context, context->texImage2D(GraphicsContext3D::TEXTURE_2D, 0, GraphicsContext3D::RGBA, requiredTextureSize.width(), requiredTextureSize.height(), 0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, pixels)); if (generateMipmap) { GLC(context, context->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MIN_FILTER, GraphicsContext3D::LINEAR_MIPMAP_LINEAR)); GLC(context, context->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MAG_FILTER, GraphicsContext3D::LINEAR)); } else { GLC(context, context->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MIN_FILTER, GraphicsContext3D::LINEAR)); GLC(context, context->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MAG_FILTER, GraphicsContext3D::LINEAR)); } m_contentsTexture = textureId; m_allocatedTextureSize = requiredTextureSize; } else { ASSERT(updateRect.width() <= m_allocatedTextureSize.width() && updateRect.height() <= m_allocatedTextureSize.height()); ASSERT(updateRect.width() == bitmapSize.width() && updateRect.height() == bitmapSize.height()); GLC(context, context->texSubImage2D(GraphicsContext3D::TEXTURE_2D, 0, updateRect.x(), updateRect.y(), updateRect.width(), updateRect.height(), GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, pixels)); } if (generateMipmap) GLC(context, context->generateMipmap(GraphicsContext3D::TEXTURE_2D)); m_dirtyRect.setSize(FloatSize()); m_contentsDirty = false; }
bool checkCompatibility( const Vector3ui& volumeDim, const Vector3ui& blockSize ) { if( volumeDim.x() % blockSize.x() ) return false; if( volumeDim.y() % blockSize.y() ) return false; if( volumeDim.z() % blockSize.z() ) return false; if( !isPowerOfTwo( volumeDim.x() / blockSize.x() ) ) return false; if( !isPowerOfTwo( volumeDim.y() / blockSize.y() ) ) return false; if( !isPowerOfTwo( volumeDim.z() / blockSize.z() ) ) return false; return true; }