// This will happen in each step of the generation of the cave. void CellularAutomata::StepInGeneration() { for (int i = 0; i < GetSizeY(); i++) { for (int j = 0; j < GetSizeX(); j++) { int livingNeighbours = CountLivingNeighbours(j, i); //if (i == 1 && j == 2) // std::cout << livingNeighbours << "\n"; if (cave[i][j] == FLOOR) { // If current node is a live but too many neighbours are dead, kill it. if (livingNeighbours < GetDeathLimit()) cave2[i][j] = WALL; else cave2[i][j] = FLOOR; // } else// if(cave[i][j] == '#') { if(livingNeighbours > GetBirthLimit()) cave2[i][j] = FLOOR; // else cave2[i][j] = WALL; } } } for (int i = 0; i < GetSizeY(); i++) for (int j = 0; j < GetSizeX(); j++) cave[i][j] = cave2[i][j]; }
void CellularAutomata::Init(int sizeX, int sizeY, int birthLimit, int deathLimit, int generations, int changeToStayAlive, int numOfCavesToGenerate, unsigned int seed) { // Do we have a specified seed or will we randomize? if (seed != 0) std::srand(seed); else // Randomize if we don't have a seed std::srand((unsigned int)time(NULL)); // Set values for various things. SetSizeX(sizeX); SetSizeY(sizeY); SetBirthLimit(birthLimit); SetDeathLimit(deathLimit); SetGenerations(generations); SetChanceToStayAlive(changeToStayAlive); SetCavesToGenerate(numOfCavesToGenerate); SetCavesGenerated(0); SetFloorTiles(0); // Allocate memory for the map. ////////////// cave = new char*[GetSizeY()]; cave2 = new char*[GetSizeY()]; for (int y = 0; y < GetSizeY(); y++) { cave[y] = new char[GetSizeX()]; cave2[y] = new char[GetSizeX()]; } ///////////////////////////////////////////// }
int UiText::GetPositionY2() const { if (m_anchor == BOT_LEFT || m_anchor == BOT_RIGHT) return m_posY + GetSizeY() - 1; if (m_anchor == TOP_LEFT || m_anchor == TOP_RIGHT) return m_posY; return m_posY + GetSizeY() / 2; }
// Create walls on all edges of the map. void CellularAutomata::FrameCave() { for (int i = 0; i < GetSizeY(); i++) { cave[i][0] = cave[i][GetSizeX() - 1] = '#'; cave2[i][0] = cave2[i][GetSizeX() - 1] = '#'; } for (int i = 0; i < GetSizeX(); i++) { cave[0][i] = cave[GetSizeY() - 1][i] = '#'; cave2[0][i] = cave2[GetSizeY() - 1][i] = '#'; } }
void Margolus::PrintParameters() const { cout << "\n------------------------------\n---Output field parameters:---\n------------------------------\n"; cout << "Size X:\t" << GetSizeX() << endl; cout << "Size Y:\t" << GetSizeY() << endl; cout << "Size Z:\t" << GetSizeZ() << endl; cout << "Temperature:\t" << *T << endl; cout << "Steam energy:\t" << *steamEnergy_ << endl; cout << "Substances count:\t" << subs.size() << endl; for (const pSub & sub : subs) { cout << sub->GetName() << "\t" << sub->GetFillCount() << endl; } cout << "Energy count:\t" << energy.size() << endl; for (const Energy & en : energy) { cout << en.name1 << "-" << en.name2 << " E=" << en.energy << " H=" << *en.energyH << " S=" << *en.energyS << endl; } cout << "Energy cell count:\t" << energyCell.size() << endl; for (const Energy & en : energyCell) { cout << en.name1 << "-" << en.name2 << " E=" << en.energy << " H=" << *en.energyH << " S=" << *en.energyS << endl; } cout << "------------------------------\n---Output field parameters:---\n------------------------------\n"; cout << "Press any key to continue ... \n"; string s; cin >> s; }
/** Called when the resource is initialized. This is only called by the rendering thread. */ void FTexture2DDynamicResource::InitRHI() { // Create the sampler state RHI resource. FSamplerStateInitializerRHI SamplerStateInitializer ( GSystemSettings.TextureLODSettings.GetSamplerFilter( Owner ), AM_Wrap, AM_Wrap, AM_Wrap ); SamplerStateRHI = RHICreateSamplerState( SamplerStateInitializer ); uint32 Flags = 0; if ( Owner->bIsResolveTarget ) { Flags |= TexCreate_ResolveTargetable; bIgnoreGammaConversions = true; // Note, we're ignoring Owner->SRGB (it should be false). } else if ( Owner->SRGB ) { Flags |= TexCreate_SRGB; } if ( Owner->bNoTiling ) { Flags |= TexCreate_NoTiling; } FRHIResourceCreateInfo CreateInfo; Texture2DRHI = RHICreateTexture2D(GetSizeX(), GetSizeY(), Owner->Format, Owner->NumMips, 1, Flags, CreateInfo); TextureRHI = Texture2DRHI; RHIUpdateTextureReference(Owner->TextureReference.TextureReferenceRHI,TextureRHI); }
FString UTextureCube::GetDesc() { return FString::Printf(TEXT("Cube: %dx%d [%s]"), GetSizeX(), GetSizeY(), GPixelFormats[GetPixelFormat()].Name ); }
// Reset the cave to only contain floors. void CellularAutomata::EmptyCave() { for (int y = 0; y < GetSizeY(); y++) for (int x = 0; x < GetSizeX(); x++) { cave[y][x] = WALL; cave2[y][x] = WALL; } }
void CellularAutomata::CountFloorTiles() { mDigged = 0; for (int i = 0; i < GetSizeY() - 1; i++) for (int j = 0; j < GetSizeX() - 1; j++) if (cave2[i][j] == '.') mDigged++; std::cout << "mDigged == " << mDigged << "\n"; }
// Debug-function to display the cave. void CellularAutomata::PrintCave() { for (int y = 0; y < GetSizeY(); y++) { for (int x = 0; x < GetSizeX(); x++) std::cout << cave[y][x]; std::cout << "\n"; } }
// Randomize the initial layout of the cave. void CellularAutomata::RandomizeCave() { for (int y = 0; y < GetSizeY(); y++) for (int x = 0; x < GetSizeX(); x++) { if ((std::rand() % 101 < GetChanceToStayAlive())) { cave[y][x] = FLOOR; // } } }
void World::MakeExample() { for (int x = 0; x < GetSizeX(); x ++) { for ( int y = 0; y < GetSizeY(); y++) { if (x > 10 && x < 20 && y > 5 && y <25) { SetTile(x, y, tileManager->GetId("clay")); } else { SetTile(x, y, tileManager->GetId("grass")); } } } }
double Margolus::CalculationBlockEnergy(const Block& block, cuint& ix, cuint& iy) { double sumEnergy = 0.0; Cell cellIn, cellOut; //x gran 1 if (ix > 0) { cellIn = block.cells[0][1]; cellOut = cells[ix - 1][iy + 1][0]; PareEnergy(cellIn, cellOut, sumEnergy); cellIn = block.cells[0][0]; cellOut = cells[ix - 1][iy][0]; PareEnergy(cellIn, cellOut, sumEnergy); } //x gran 2 if (ix < GetSizeX() - 2) { cellIn = block.cells[1][1]; cellOut = cells[ix + 2][iy + 1][0]; PareEnergy(cellIn, cellOut, sumEnergy); cellIn = block.cells[1][0]; cellOut = cells[ix + 2][iy][0]; PareEnergy(cellIn, cellOut, sumEnergy); } //y gran 1 if (iy > 0) { cellIn = block.cells[1][0]; cellOut = cells[ix + 1][iy - 1][0]; PareEnergy(cellIn, cellOut, sumEnergy); cellIn = block.cells[0][0]; cellOut = cells[ix][iy - 1][0]; PareEnergy(cellIn, cellOut, sumEnergy); } //y gran 2 if (iy < GetSizeY() - 2) { cellIn = block.cells[1][1]; cellOut = cells[ix + 1][iy + 2][0]; PareEnergy(cellIn, cellOut, sumEnergy); cellIn = block.cells[0][1]; cellOut = cells[ix][iy + 2][0]; PareEnergy(cellIn, cellOut, sumEnergy); } //inside block for (uint i = 0; i < 4; ++i) { cellIn = block.cells[indexF[i][0]][indexF[i][1]]; cellOut = block.cells[indexF[i + 1][0]][indexF[i + 1][1]]; PareEnergyFull(cellIn, cellOut, sumEnergy); } if (!moveForward || block.move[movement] > 0) { sumEnergy += block.move[movement] * *steamEnergy_; } return sumEnergy; }
void CellularAutomata::LifeCycle() { FILETIME prevSysKernel, prevSysUser, prevProcKernel, prevProcUser; double usage = 0.0; MessyClass::GetInstance().Init(GetSizeX(), GetSizeY()); for (int i = 0; i < FileReader::GetInstance().FetchIntData(6); i++) // How many caves shall we generate? { ///////////////////////////////////////////// // Set all locations in the map to walls //// // This is just to remove junk-values. EmptyCave(); ///////////////////////////////////////////// // Randomize the initial map //////////////// RandomizeCave(); ///////////////////////////////////////////// // Generate the cave(s) ///////////////////// CPUUsage c; usage = c.GetCPUUsage(&prevSysKernel, &prevSysUser, &prevProcKernel, &prevProcUser, true); GenerateCave(); usage = c.GetCPUUsage(&prevSysKernel, &prevSysUser, &prevProcKernel, &prevProcUser); FileReader::GetInstance().WriteToFile(std::to_string(GetSizeX()) + "x" + std::to_string(GetSizeY()) + "_CPUUsage.txt", "", usage, 8); //PrintCave(); ///////////////////////////////////////////// // Save the cave(s) in seperate files /////// SaveCave(); // MessyClass::GetInstance().SaveImage(GetCavesGenerated(), GetCave()); CountFloorTiles(); system("CLS"); std::cout << "[ CAVE " << GetCavesGenerated() << " / " << GetCavesToGenerate() << " COMPLETED ]\n"; std::cout << "Floor tiles: " << GetFloorTiles() << " / " << GetSizeX() * GetSizeY() << "\n"; } CPUUsage c; c.FindUsage("Data/"+std::to_string(GetSizeX()) + "x" + std::to_string(GetSizeY()) + "_CPUUsage.txt", GetSizeX(), GetSizeY(), GetCavesToGenerate()); std::cout << "Generation completed!\n\nPress enter to exit program...\n"; }
void SampleImageDlg::EnableBasedOnConstraint() { GetTextToFile()->Enable(m_bToFile); GetDotDotDot()->Enable(m_bToFile); GetConstrain()->Enable(true); GetSmaller()->Enable(m_bConstraint); GetBigger()->Enable(m_bConstraint); GetSizeX()->SetEditable(!m_bConstraint); GetSizeY()->SetEditable(!m_bConstraint); GetSpacingX()->SetEditable(!m_bConstraint); GetSpacingY()->SetEditable(!m_bConstraint); }
void SampleImageDlg::OnSpacingXY( wxCommandEvent &event ) { if (m_bSetting) return; TransferDataFromWindow(); m_Size.x = (int) (m_fAreaX / m_fSpacingX); m_Size.y = (int) (m_fAreaY / m_fSpacingY); m_bSetting = true; GetSizeX()->GetValidator()->TransferToWindow(); GetSizeY()->GetValidator()->TransferToWindow(); m_bSetting = false; }
void ComboBox::Draw(const Point2i &mousePosition) { Surface& window = GetMainWindow(); // the computed positions are to center on the image part of the widget // 1. first draw the torus torus->Draw(*this); // 2. then draw buttons #define IMG_BUTTONS_W 5 #define IMG_BUTTONS_H 12 Point2i center = GetPosition() + torus->GetCenter(); if (m_index > 0) { if (Contains(mousePosition) && mousePosition.x < center.x) torus->m_minus->SetCurrentFrame(1); else torus->m_minus->SetCurrentFrame(0); torus->m_minus->Blit(window, GetPositionX() + IMG_BUTTONS_W, GetPositionY() + IMG_BUTTONS_H); } if (m_index < m_choices.size() - 1) { if (Contains(mousePosition) && mousePosition.x > center.x) torus->m_plus->SetCurrentFrame(1); else torus->m_plus->SetCurrentFrame(0); torus->m_plus->Blit(window, GetPositionX() + GetSizeX() - torus->m_plus->GetWidth() - IMG_BUTTONS_W, GetPosition().y + IMG_BUTTONS_H); } // 3. add in the value image uint tmp_x = GetPositionX() + GetSizeX()/2; uint tmp_y = center.y + SMALL_R - 3; uint value_h = Font::GetInstance(Font::FONT_MEDIUM)->GetHeight(); txt_value_black->DrawCenterTop(Point2i(tmp_x + 1, tmp_y + 1 - value_h/2)); txt_value_white->DrawCenterTop(Point2i(tmp_x, tmp_y - value_h/2)); // 7. and finally the label image txt_label->DrawCenterTop(Point2i(tmp_x, GetPositionY() + GetSizeY() - txt_label->GetHeight())); }
//gets the ref of a specific cell from a given position out of the region_array const CCellTypeWorld& CDungeon::GetCell(const C2DPosition<>& pos) const { C2DPosition<> region = pos / C2DPosition<>(CRegion::GetSizeX(),CRegion::GetSizeY()); //int regionX = pos[0] / CRegion::GetSizeX(); //int regionY = pos[1] / CRegion::GetSizeY(); const CCellTypeWorld* ret = 0; if (pos[0] >= 0 && GetSizeX() > pos[0] && pos[1] >= 0 && GetSizeY() > pos[1] && region[0] >= 0 && region[0] < AMOUNT_REGION_X && region[1] >= 0 && region[1] < AMOUNT_REGION_Y) ret = _regions[region[0]][region[1]].GetCell(pos); if (!ret) ret = _standardCellType; return *ret; }
void PictureTextCBox::Draw(const Point2i &/*mousePosition*/) { Surface & video_window = GetMainWindow(); if (m_value) { uint enabled_x = GetPositionX() + (GetSizeX() - m_enabled.GetWidth())/2 ; uint enabled_y = GetPositionY(); uint outside_x = std::max(uint(0), GetPositionX() - enabled_x); uint outside_y = std::max(uint(0), GetPositionY() - enabled_y); enabled_x += outside_x; enabled_y += outside_y; Rectanglei srcRect(outside_x, outside_y, m_enabled.GetWidth() - outside_x, m_enabled.GetHeight() - outside_y); video_window.Blit(m_enabled, srcRect, Point2i(enabled_x, enabled_y)); } else { uint disabled_x = GetPositionX() + (GetSizeX() - m_disabled_back.GetWidth())/2 ; uint disabled_y = GetPositionY(); uint outside_x = std::max(uint(0), GetPositionX() - disabled_x); uint outside_y = std::max(uint(0), GetPositionY() - disabled_y); disabled_x += outside_x; disabled_y += outside_y; Rectanglei srcRect(outside_x, outside_y, m_disabled_back.GetWidth() - outside_x, m_disabled_back.GetHeight() - outside_y); video_window.Blit(m_disabled_back, srcRect, Point2i(disabled_x, disabled_y)); } // center the image uint tmp_x = GetPositionX() + (GetSizeX() - m_image.GetWidth())/2 ; uint tmp_y = GetPositionY() + (m_enabled.GetHeight() - m_image.GetHeight())/2; video_window.Blit(m_image, Point2i(tmp_x, tmp_y)); Text::DrawCenterTop(GetPosition() + Point2i(GetSizeX()/2, GetSizeY() - Text::GetHeight())); if (!m_value) { uint disabled_x = GetPositionX() + (GetSizeX() - m_disabled_front.GetWidth())/2 ; uint disabled_y = GetPositionY() + (m_enabled.GetHeight() - m_disabled_front.GetHeight())/2; video_window.Blit(m_disabled_front, Point2i(disabled_x, disabled_y)); } }
void cBlockArea::CropNibbles(NIBBLEARRAY & a_Array, int a_AddMinX, int a_SubMaxX, int a_AddMinY, int a_SubMaxY, int a_AddMinZ, int a_SubMaxZ) { int NewSizeX = GetSizeX() - a_AddMinX - a_SubMaxX; int NewSizeY = GetSizeY() - a_AddMinY - a_SubMaxY; int NewSizeZ = GetSizeZ() - a_AddMinZ - a_SubMaxZ; NIBBLETYPE * NewNibbles = new NIBBLETYPE[NewSizeX * NewSizeY * NewSizeZ]; int idx = 0; for (int y = 0; y < NewSizeY; y++) { for (int z = 0; z < NewSizeZ; z++) { for (int x = 0; x < NewSizeX; x++) { NewNibbles[idx++] = a_Array[MakeIndex(x + a_AddMinX, y + a_AddMinY, z + a_AddMinZ)]; } // for x } // for z } // for y delete a_Array; a_Array = NewNibbles; }
void ButtonPic::Draw(const Point2i &mousePosition) { Surface& surf = AppWarmux::GetInstance()->video->window; // center the image horizontally uint tmp_x = GetPositionX() + (GetSizeX() - m_img_normal.GetWidth())/2 ; uint tmp_y = GetPositionY(); surf.Blit(m_img_normal, Point2i(tmp_x, tmp_y)); if (Contains(mousePosition)) { surf.RectangleColor(*this, c_red, 1); txt_label->SetColor(black_color); } else { txt_label->SetColor(dark_gray_color); } txt_label->DrawCenterTop(GetPosition() + Point2i(GetSizeX()/2, GetSizeY() - txt_label->GetHeight())); }
void cBlockArea::CropBlockTypes(int a_AddMinX, int a_SubMaxX, int a_AddMinY, int a_SubMaxY, int a_AddMinZ, int a_SubMaxZ) { int NewSizeX = GetSizeX() - a_AddMinX - a_SubMaxX; int NewSizeY = GetSizeY() - a_AddMinY - a_SubMaxY; int NewSizeZ = GetSizeZ() - a_AddMinZ - a_SubMaxZ; BLOCKTYPE * NewBlockTypes = new BLOCKTYPE[NewSizeX * NewSizeY * NewSizeZ]; int idx = 0; for (int y = 0; y < NewSizeY; y++) { for (int z = 0; z < NewSizeZ; z++) { for (int x = 0; x < NewSizeX; x++) { int OldIndex = MakeIndex(x + a_AddMinX, y + a_AddMinY, z + a_AddMinZ); NewBlockTypes[idx++] = m_BlockTypes[OldIndex]; } // for x } // for z } // for y delete m_BlockTypes; m_BlockTypes = NewBlockTypes; }
uint32 UTextureCube::CalcTextureMemorySize( int32 MipCount ) const { uint32 Size = 0; if (PlatformData) { int32 SizeX = GetSizeX(); int32 SizeY = GetSizeY(); int32 NumMips = GetNumMips(); EPixelFormat Format = GetPixelFormat(); ensureMsgf(SizeX == SizeY, TEXT("Cubemap faces expected to be square. Actual sizes are: %i, %i"), SizeX, SizeY); // Figure out what the first mip to use is. int32 FirstMip = FMath::Max( 0, NumMips - MipCount ); FIntPoint MipExtents = CalcMipMapExtent(SizeX, SizeY, Format, FirstMip); uint32 TextureAlign = 0; uint64 TextureSize = RHICalcTextureCubePlatformSize(MipExtents.X, Format, NumMips, 0, TextureAlign); Size = (uint32)TextureSize; } return Size; }
void cBlockArea::Merge(const cBlockArea & a_Src, int a_RelX, int a_RelY, int a_RelZ, eMergeStrategy a_Strategy) { // Block types are compulsory, block metas are voluntary if (!HasBlockTypes() || !a_Src.HasBlockTypes()) { LOGWARNING("%s: cannot merge because one of the areas doesn't have blocktypes.", __FUNCTION__); return; } // Dst is *this, Src is a_Src int SrcOffX = std::max(0, -a_RelX); // Offset in Src where to start reading int DstOffX = std::max(0, a_RelX); // Offset in Dst where to start writing int SizeX = std::min(a_Src.GetSizeX() - SrcOffX, GetSizeX() - DstOffX); // How many blocks to copy int SrcOffY = std::max(0, -a_RelY); // Offset in Src where to start reading int DstOffY = std::max(0, a_RelY); // Offset in Dst where to start writing int SizeY = std::min(a_Src.GetSizeY() - SrcOffY, GetSizeY() - DstOffY); // How many blocks to copy int SrcOffZ = std::max(0, -a_RelZ); // Offset in Src where to start reading int DstOffZ = std::max(0, a_RelZ); // Offset in Dst where to start writing int SizeZ = std::min(a_Src.GetSizeZ() - SrcOffZ, GetSizeZ() - DstOffZ); // How many blocks to copy const NIBBLETYPE * SrcMetas = a_Src.GetBlockMetas(); NIBBLETYPE * DstMetas = m_BlockMetas; bool IsDummyMetas = ((SrcMetas == NULL) || (DstMetas == NULL)); if (IsDummyMetas) { SrcMetas = new NIBBLETYPE[a_Src.GetBlockCount()]; DstMetas = new NIBBLETYPE[GetBlockCount()]; } switch (a_Strategy) { case msOverwrite: { InternalMergeBlocks( m_BlockTypes, a_Src.GetBlockTypes(), DstMetas, SrcMetas, SizeX, SizeY, SizeZ, SrcOffX, SrcOffY, SrcOffZ, DstOffX, DstOffY, DstOffZ, a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(), m_SizeX, m_SizeY, m_SizeZ, MergeCombinatorOverwrite ); break; } // case msOverwrite case msFillAir: { InternalMergeBlocks( m_BlockTypes, a_Src.GetBlockTypes(), DstMetas, SrcMetas, SizeX, SizeY, SizeZ, SrcOffX, SrcOffY, SrcOffZ, DstOffX, DstOffY, DstOffZ, a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(), m_SizeX, m_SizeY, m_SizeZ, MergeCombinatorFillAir ); break; } // case msFillAir case msImprint: { InternalMergeBlocks( m_BlockTypes, a_Src.GetBlockTypes(), DstMetas, SrcMetas, SizeX, SizeY, SizeZ, SrcOffX, SrcOffY, SrcOffZ, DstOffX, DstOffY, DstOffZ, a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(), m_SizeX, m_SizeY, m_SizeZ, MergeCombinatorImprint ); break; } // case msImprint case msLake: { InternalMergeBlocks( m_BlockTypes, a_Src.GetBlockTypes(), DstMetas, SrcMetas, SizeX, SizeY, SizeZ, SrcOffX, SrcOffY, SrcOffZ, DstOffX, DstOffY, DstOffZ, a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(), m_SizeX, m_SizeY, m_SizeZ, MergeCombinatorLake ); break; } // case msLake default: { LOGWARNING("Unknown block area merge strategy: %d", a_Strategy); ASSERT(!"Unknown block area merge strategy"); break; } } // switch (a_Strategy) if (IsDummyMetas) { delete[] SrcMetas; delete[] DstMetas; } }
void FShadowMapPendingTexture::StartEncoding(UWorld* InWorld) { // Create the shadow-map texture. UShadowMapTexture2D* Texture = new(Outer) UShadowMapTexture2D(FPostConstructInitializeProperties()); Texture->Filter = GUseBilinearLightmaps ? TF_Default : TF_Nearest; // Signed distance field textures get stored in linear space, since they need more precision near .5. Texture->SRGB = false; Texture->LODGroup = TEXTUREGROUP_Shadowmap; Texture->ShadowmapFlags = ShadowmapFlags; Texture->Source.Init2DWithMipChain(GetSizeX(), GetSizeY(), TSF_BGRA8); Texture->MipGenSettings = TMGS_LeaveExistingMips; Texture->CompressionNone = true; int32 TextureSizeX = Texture->Source.GetSizeX(); int32 TextureSizeY = Texture->Source.GetSizeY(); { // Create the uncompressed top mip-level. TArray< TArray<FFourDistanceFieldSamples> > MipData; FShadowMap2D::EncodeSingleTexture(*this, Texture, MipData); // Copy the mip-map data into the UShadowMapTexture2D's mip-map array. for(int32 MipIndex = 0;MipIndex < MipData.Num();MipIndex++) { FColor* DestMipData = (FColor*)Texture->Source.LockMip(MipIndex); uint32 MipSizeX = FMath::Max(1,TextureSizeX >> MipIndex); uint32 MipSizeY = FMath::Max(1,TextureSizeY >> MipIndex); for(uint32 Y = 0;Y < MipSizeY;Y++) { for(uint32 X = 0;X < MipSizeX;X++) { const FFourDistanceFieldSamples& SourceSample = MipData[MipIndex][Y * MipSizeX + X]; DestMipData[ Y * MipSizeX + X ] = FColor(SourceSample.Samples[0].Distance, SourceSample.Samples[1].Distance, SourceSample.Samples[2].Distance, SourceSample.Samples[3].Distance); } } Texture->Source.UnlockMip(MipIndex); } } // Update stats. int32 TextureSize = Texture->CalcTextureMemorySizeEnum( TMC_AllMips ); GNumShadowmapTotalTexels += TextureSizeX * TextureSizeY; GNumShadowmapTextures++; GShadowmapTotalSize += TextureSize; GShadowmapTotalStreamingSize += (ShadowmapFlags & SMF_Streamed) ? TextureSize : 0; UPackage* TexturePackage = Texture->GetOutermost(); for ( int32 LevelIndex=0; TexturePackage && LevelIndex < InWorld->GetNumLevels(); LevelIndex++ ) { ULevel* Level = InWorld->GetLevel(LevelIndex); UPackage* LevelPackage = Level->GetOutermost(); if ( TexturePackage == LevelPackage ) { Level->ShadowmapTotalSize += float(TextureSize) / 1024.0f; break; } } // Update the texture resource. Texture->BeginCachePlatformData(); Texture->FinishCachePlatformData(); Texture->UpdateResource(); }
// Describes how to set the sizes of all the buffers static void SetSizes(Arguments<T> &args) { args.x_size = GetSizeX(args); args.y_size = GetSizeY(args); args.scalar_size = GetSizeDot(args); }
const C2DPosition<> CDungeon::GetSize() { return C2DPosition<>(GetSizeX(), GetSizeY()); }
void Margolus::Calculation(cuint& dx, cuint& dy, cuint& dz) { //#pragma omp parallel for for (uint ix = dx; ix < GetSizeX() - 1; ix += 2) { for (uint iy = dy; iy < GetSizeY() - 1; iy += 2) { for (uint iz = dz; iz < GetSizeZ() - 1; iz += 2) { if (CheckEmpty(ix, iy, iz)) { continue; } blockSize3D = 1; CreateRotateNotBlock3D(blocks3D[0], ix, iy, iz); if (modifierMove && CheckMod(ix, iy, iz)) { if (CheckActive (ix, iy)) { if (CheckCanRotate3D(ClockWiceX, ix, iy, iz)) { CreateRotateBlock3D(blocks3D[blockSize3D], ClockWiceX, ix, iy, iz, false, true); ++blockSize3D; CreateRotateBlock3D(blocks3D[blockSize3D], ClockWiceX, ix, iy, iz, true, true); ++blockSize3D; CreateRotateBlock3D(blocks3D[blockSize3D], ClockWiceX, ix, iy, iz); ++blockSize3D; } if (CheckCanRotate3D(CounterClockWiceX, ix, iy, iz)) { CreateRotateBlock3D(blocks3D[blockSize3D], CounterClockWiceX, ix, iy, iz, false, true); ++blockSize3D; CreateRotateBlock3D(blocks3D[blockSize3D], CounterClockWiceX, ix, iy, iz, true, true); ++blockSize3D; CreateRotateBlock3D(blocks3D[blockSize3D], CounterClockWiceX, ix, iy, iz); ++blockSize3D; } if (CheckCanRotate3D(ClockWiceY, ix, iy, iz)) { CreateRotateBlock3D(blocks3D[blockSize3D], ClockWiceY, ix, iy, iz, false, true); ++blockSize3D; CreateRotateBlock3D(blocks3D[blockSize3D], ClockWiceY, ix, iy, iz, true, true); ++blockSize3D; CreateRotateBlock3D(blocks3D[blockSize3D], ClockWiceY, ix, iy, iz); ++blockSize3D; } if (CheckCanRotate3D(CounterClockWiceY, ix, iy, iz)) { CreateRotateBlock3D(blocks3D[blockSize3D], CounterClockWiceY, ix, iy, iz, false, true); ++blockSize3D; CreateRotateBlock3D(blocks3D[blockSize3D], CounterClockWiceY, ix, iy, iz, true, true); ++blockSize3D; CreateRotateBlock3D(blocks3D[blockSize3D], CounterClockWiceY, ix, iy, iz); ++blockSize3D; } if (CheckCanRotate3D(ClockWiceZ, ix, iy, iz)) { CreateRotateBlock3D(blocks3D[blockSize3D], ClockWiceZ, ix, iy, iz, false, true); ++blockSize3D; CreateRotateBlock3D(blocks3D[blockSize3D], ClockWiceZ, ix, iy, iz, true, true); ++blockSize3D; CreateRotateBlock3D(blocks3D[blockSize3D], ClockWiceZ, ix, iy, iz); ++blockSize3D; } if (CheckCanRotate3D(CounterClockWiceZ, ix, iy, iz)) { CreateRotateBlock3D(blocks3D[blockSize3D], CounterClockWiceZ, ix, iy, iz, false, true); ++blockSize3D; CreateRotateBlock3D(blocks3D[blockSize3D], CounterClockWiceZ, ix, iy, iz, true, true); ++blockSize3D; CreateRotateBlock3D(blocks3D[blockSize3D], CounterClockWiceZ, ix, iy, iz); ++blockSize3D; } } else { CreateRotateBlock3D(blocks3D[blockSize3D], ClockWiceX, ix, iy, iz, false, true); ++blockSize3D; CreateRotateBlock3D(blocks3D[blockSize3D], CounterClockWiceX, ix, iy, iz, false, true); ++blockSize3D; CreateRotateBlock3D(blocks3D[blockSize3D], ClockWiceY, ix, iy, iz, false, true); ++blockSize3D; CreateRotateBlock3D(blocks3D[blockSize3D], CounterClockWiceY, ix, iy, iz, false, true); ++blockSize3D; CreateRotateBlock3D(blocks3D[blockSize3D], ClockWiceZ, ix, iy, iz, false, true); ++blockSize3D; CreateRotateBlock3D(blocks3D[blockSize3D], CounterClockWiceZ, ix, iy, iz, false, true); ++blockSize3D; } } else { if (CheckCanRotate3D(ClockWiceX, ix, iy, iz)) { CreateRotateBlock3D(blocks3D[blockSize3D], ClockWiceX, ix, iy, iz); ++blockSize3D; } if (CheckCanRotate3D(CounterClockWiceX, ix, iy, iz)) { CreateRotateBlock3D(blocks3D[blockSize3D], CounterClockWiceX, ix, iy, iz); ++blockSize3D; } if (CheckCanRotate3D(ClockWiceY, ix, iy, iz)) { CreateRotateBlock3D(blocks3D[blockSize3D], ClockWiceY, ix, iy, iz); ++blockSize3D; } if (CheckCanRotate3D(CounterClockWiceY, ix, iy, iz)) { CreateRotateBlock3D(blocks3D[blockSize3D], CounterClockWiceY, ix, iy, iz); ++blockSize3D; } if (CheckCanRotate3D(ClockWiceZ, ix, iy, iz)) { CreateRotateBlock3D(blocks3D[blockSize3D], ClockWiceZ, ix, iy, iz); ++blockSize3D; } if (CheckCanRotate3D(CounterClockWiceZ, ix, iy, iz)) { CreateRotateBlock3D(blocks3D[blockSize3D], CounterClockWiceZ, ix, iy, iz); ++blockSize3D; } } double Z = 0.0; // + Energy for (uint i = 0; i < blockSize3D; ++i) { double energy = CalculationBlockEnergy(blocks3D[i], ix, iy, iz); //кДж/моль blocks3D[i].energy = exp(-energy / (R * *T)); Z += blocks3D[i].energy; } //normalization double sumProbability = 0.0; double rnd = (double)(rand()) / RAND_MAX; for (uint i = 0; i < blockSize3D; ++i) { sumProbability += blocks3D[i].energy / Z; if (rnd <= sumProbability) { ChangeBlock(blocks3D[i], ix, iy, iz); break; } } } } } }
// Describes how to set the sizes of all the buffers static void SetSizes(Arguments<T> &args) { args.a_size = GetSizeA(args); args.x_size = GetSizeX(args); args.y_size = GetSizeY(args); }
void cBlockArea::MergeByStrategy(const cBlockArea & a_Src, int a_RelX, int a_RelY, int a_RelZ, eMergeStrategy a_Strategy, const NIBBLETYPE * SrcMetas, NIBBLETYPE * DstMetas) { // Block types are compulsory, block metas are voluntary if (!HasBlockTypes() || !a_Src.HasBlockTypes()) { LOGWARNING("%s: cannot merge because one of the areas doesn't have blocktypes.", __FUNCTION__); return; } // Dst is *this, Src is a_Src int SrcOffX = std::max(0, -a_RelX); // Offset in Src where to start reading int DstOffX = std::max(0, a_RelX); // Offset in Dst where to start writing int SizeX = std::min(a_Src.GetSizeX() - SrcOffX, GetSizeX() - DstOffX); // How many blocks to copy int SrcOffY = std::max(0, -a_RelY); // Offset in Src where to start reading int DstOffY = std::max(0, a_RelY); // Offset in Dst where to start writing int SizeY = std::min(a_Src.GetSizeY() - SrcOffY, GetSizeY() - DstOffY); // How many blocks to copy int SrcOffZ = std::max(0, -a_RelZ); // Offset in Src where to start reading int DstOffZ = std::max(0, a_RelZ); // Offset in Dst where to start writing int SizeZ = std::min(a_Src.GetSizeZ() - SrcOffZ, GetSizeZ() - DstOffZ); // How many blocks to copy switch (a_Strategy) { case cBlockArea::msOverwrite: { InternalMergeBlocks<MetasValid, MergeCombinatorOverwrite<MetasValid> >( m_BlockTypes, a_Src.GetBlockTypes(), DstMetas, SrcMetas, SizeX, SizeY, SizeZ, SrcOffX, SrcOffY, SrcOffZ, DstOffX, DstOffY, DstOffZ, a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(), m_Size.x, m_Size.y, m_Size.z ); return; } // case msOverwrite case cBlockArea::msFillAir: { InternalMergeBlocks<MetasValid, MergeCombinatorFillAir<MetasValid> >( m_BlockTypes, a_Src.GetBlockTypes(), DstMetas, SrcMetas, SizeX, SizeY, SizeZ, SrcOffX, SrcOffY, SrcOffZ, DstOffX, DstOffY, DstOffZ, a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(), m_Size.x, m_Size.y, m_Size.z ); return; } // case msFillAir case cBlockArea::msImprint: { InternalMergeBlocks<MetasValid, MergeCombinatorImprint<MetasValid> >( m_BlockTypes, a_Src.GetBlockTypes(), DstMetas, SrcMetas, SizeX, SizeY, SizeZ, SrcOffX, SrcOffY, SrcOffZ, DstOffX, DstOffY, DstOffZ, a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(), m_Size.x, m_Size.y, m_Size.z ); return; } // case msImprint case cBlockArea::msLake: { InternalMergeBlocks<MetasValid, MergeCombinatorLake<MetasValid> >( m_BlockTypes, a_Src.GetBlockTypes(), DstMetas, SrcMetas, SizeX, SizeY, SizeZ, SrcOffX, SrcOffY, SrcOffZ, DstOffX, DstOffY, DstOffZ, a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(), m_Size.x, m_Size.y, m_Size.z ); return; } // case msLake case cBlockArea::msSpongePrint: { InternalMergeBlocks<MetasValid, MergeCombinatorSpongePrint<MetasValid> >( m_BlockTypes, a_Src.GetBlockTypes(), DstMetas, SrcMetas, SizeX, SizeY, SizeZ, SrcOffX, SrcOffY, SrcOffZ, DstOffX, DstOffY, DstOffZ, a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(), m_Size.x, m_Size.y, m_Size.z ); return; } // case msSpongePrint case cBlockArea::msDifference: { InternalMergeBlocks<MetasValid, MergeCombinatorDifference<MetasValid> >( m_BlockTypes, a_Src.GetBlockTypes(), DstMetas, SrcMetas, SizeX, SizeY, SizeZ, SrcOffX, SrcOffY, SrcOffZ, DstOffX, DstOffY, DstOffZ, a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(), m_Size.x, m_Size.y, m_Size.z ); return; } // case msDifference case cBlockArea::msMask: { InternalMergeBlocks<MetasValid, MergeCombinatorMask<MetasValid> >( m_BlockTypes, a_Src.GetBlockTypes(), DstMetas, SrcMetas, SizeX, SizeY, SizeZ, SrcOffX, SrcOffY, SrcOffZ, DstOffX, DstOffY, DstOffZ, a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(), m_Size.x, m_Size.y, m_Size.z ); return; } // case msMask } // switch (a_Strategy) LOGWARNING("Unknown block area merge strategy: %d", a_Strategy); ASSERT(!"Unknown block area merge strategy"); return; }