803 lines
20 KiB
C++
803 lines
20 KiB
C++
#include "defines.h"
|
|
#include "globals.h"
|
|
#include "intrin.h"
|
|
#include "city.h"
|
|
|
|
float g_fBlocksX[ 24 ];
|
|
float g_fBlocksY[ 24 ];
|
|
int g_iStreetCountX;
|
|
float g_fStreetX[ 24 ];
|
|
int g_iStreetCountY;
|
|
float g_fStreetY[ 24 ];
|
|
|
|
void GenerateMap()
|
|
{
|
|
g_iStreetCountX= 0;
|
|
float fMinStep= 17.0f;
|
|
float fMinStreet= 6.0f;
|
|
float fMaxStreet= 16.0f;
|
|
{
|
|
float fPosX[ 2 ];
|
|
fPosX[ 0 ]= fMinStep / 2.0f;
|
|
fPosX[ 1 ]= -fMinStep / 2.0f;
|
|
int iWait[ 2 ];
|
|
iWait[ 0 ] = 0;
|
|
iWait[ 1 ] = 0;
|
|
|
|
for( int i= 0; i < 12; ++i )
|
|
{
|
|
g_fBlocksX[ 12 + i ]= fPosX[ 0 ];
|
|
g_fBlocksX[ 11 - i ]= fPosX[ 1 ];
|
|
fPosX[ 0 ]+= fMinStep;
|
|
fPosX[ 1 ]-= fMinStep;
|
|
iWait[ 0 ]--;
|
|
iWait[ 1 ]--;
|
|
if( iWait[ 0 ] < 0 )
|
|
{
|
|
fPosX[ 0 ]+= g_Random.genFloat( fMinStreet, fMaxStreet );
|
|
iWait[ 0 ]= g_Random.genInteger( 1, 3 );
|
|
g_fStreetX[ g_iStreetCountX ]= ( g_fBlocksX[ 12 + i ] + fPosX[ 0 ] ) / 2.0f;
|
|
g_iStreetCountX++;
|
|
}
|
|
if( iWait[ 1 ] < 0 )
|
|
{
|
|
fPosX[ 1 ]-= g_Random.genFloat( fMinStreet, fMaxStreet );
|
|
iWait[ 1 ]= g_Random.genInteger( 1, 3 );
|
|
g_fStreetX[ g_iStreetCountX ]= ( g_fBlocksX[ 11 - i ] + fPosX[ 1 ] ) / 2.0f;
|
|
g_iStreetCountX++;
|
|
}
|
|
}
|
|
}
|
|
|
|
g_iStreetCountY= 0;
|
|
{
|
|
float fPosY[ 2 ];
|
|
fPosY[ 0 ]= fMinStep / 2.0f;
|
|
fPosY[ 1 ]= -fMinStep / 2.0f;
|
|
for( int i= 0; i < 12; ++i )
|
|
{
|
|
g_fBlocksY[ 12 + i ]= fPosY[ 0 ];
|
|
g_fBlocksY[ 11 - i ]= fPosY[ 1 ];
|
|
fPosY[ 0 ]+= fMinStep;
|
|
fPosY[ 1 ]-= fMinStep;
|
|
if( i % 2 == 0 )
|
|
{
|
|
fPosY[ 0 ]+= g_Random.genFloat( fMinStreet, fMaxStreet );
|
|
fPosY[ 1 ]-= g_Random.genFloat( fMinStreet, fMaxStreet );
|
|
g_fStreetY[ g_iStreetCountY ]= ( g_fBlocksY[ 12 + i ] + fPosY[ 0 ] ) / 2.0f;
|
|
g_iStreetCountY++;
|
|
g_fStreetY[ g_iStreetCountY ]= ( g_fBlocksY[ 11 - i ] + fPosY[ 1 ] ) / 2.0f;
|
|
g_iStreetCountY++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CreateAllBuildings()
|
|
{
|
|
g_Random.setSeed( 5 );
|
|
GenerateMap();
|
|
|
|
int iIndex= OI_BuildingFirst;
|
|
int iBuilding= 0;
|
|
bool bUnlock= false;
|
|
for( int iX= 0; iX < 24; ++iX )
|
|
{
|
|
for( int iY= 0; iY < 24; ++iY )
|
|
{
|
|
float fY= g_fBlocksY[ iY ];
|
|
float fX= g_fBlocksX[ iX ];
|
|
float fHeight= GetCityHeight( fX, fY );
|
|
if( fHeight <= 0.0f )
|
|
{
|
|
continue;
|
|
}
|
|
if( iBuilding % 5 == 0 )
|
|
{
|
|
if( bUnlock )
|
|
{
|
|
g_pEditObject->Unlock();
|
|
}
|
|
g_pEditObject= g_Objects + iIndex;
|
|
assert( iIndex <= OI_BuildingLast );
|
|
g_pEditObject->Create( 24 * 1000, 36 * 1000 );
|
|
g_pEditObject->m_iUsedPreShader= PreDepth;
|
|
g_pEditObject->m_iUsedShader[0]= Wall;
|
|
g_pEditObject->Lock();
|
|
bUnlock= true;
|
|
iIndex++;
|
|
}
|
|
|
|
iBuilding++;
|
|
if( g_Random.genInteger( 0, 5 ) == 0 )
|
|
{
|
|
CreateBuilding00( D3DXVECTOR3( fX, 0.0f, fY), fHeight * 1.0f );
|
|
}
|
|
else
|
|
{
|
|
CreateBuilding01( D3DXVECTOR3( fX, 0.0f, fY), fHeight * 1.0f );
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
if( bUnlock )
|
|
{
|
|
g_pEditObject->Unlock();
|
|
}
|
|
|
|
}
|
|
|
|
float GetCityHeight( float fX, float fY )
|
|
{
|
|
if( fabs( fX ) + fabs( fY ) < 32.0f )
|
|
{
|
|
return -1.0f;
|
|
}
|
|
float fBase= 2048.0f / sqrt( 2.5f * fX * fX + fY * fY ) - 10.0f;
|
|
fBase-= 2.0f * ( cos( fX / 23.7f + 4.6f * cos( fY / 97.3f ) ) + cos( fY / 27.7f + 2.1f * cos( fX / 43.0f ) ) );
|
|
|
|
return fBase;
|
|
}
|
|
|
|
void CreateSlicesX( const D3DXVECTOR3& vecCenter,
|
|
const D3DXVECTOR3& vecExtent,
|
|
const D3DXVECTOR3& vecRot,
|
|
DWORD dwColor,
|
|
int Slices, int SliceMode, float fSliceFac )
|
|
{
|
|
if( Slices > -1 )
|
|
{
|
|
int iSliceCount= Slices;
|
|
float fSliceSize= 2.0f * fSliceFac * vecExtent.x / (float)( Slices + 1 );
|
|
float fSliceApart= ( vecExtent.x * 2.0f - fSliceSize ) / (float)( Slices + 1 );
|
|
float fSliceStart= - vecExtent.x + fSliceSize * 0.5f;
|
|
|
|
int iStart= ( SliceMode & 1 ) ? 0 : 1;
|
|
int iEnd= iSliceCount + ( ( SliceMode & 2 ) ? 1 : 0 );
|
|
|
|
for( int i= iStart; i <= iEnd; ++i )
|
|
{
|
|
D3DXVECTOR3 v( fSliceStart + (float)i * fSliceApart, 0.0f, 0.0f );
|
|
|
|
D3DXMATRIX m1;
|
|
D3DXMatrixRotationYawPitchRoll( &m1, vecRot.x, vecRot.y, vecRot.z );
|
|
|
|
D3DXVec3TransformCoord( &v, &v, &m1 );
|
|
|
|
g_pEditObject->AddBox(
|
|
D3DXVECTOR3( vecCenter + v ),
|
|
D3DXVECTOR3( fSliceSize * 0.5f, vecExtent.y, vecExtent.z),
|
|
D3DXVECTOR3( vecRot.x, vecRot.y, vecRot.z),
|
|
dwColor);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CreateSlicesY( const D3DXVECTOR3& vecCenter,
|
|
const D3DXVECTOR3& vecExtent,
|
|
const D3DXVECTOR3& vecRot,
|
|
DWORD dwColor,
|
|
int Slices, int SliceMode, float fSliceFac )
|
|
{
|
|
if( Slices > -1 )
|
|
{
|
|
int iSliceCount= Slices;
|
|
float fSliceSize= 2.0f * fSliceFac * vecExtent.y / (float)( Slices + 1 );
|
|
float fSliceApart= ( vecExtent.y * 2.0f - fSliceSize ) / (float)( Slices + 1 );
|
|
float fSliceStart= - vecExtent.y + fSliceSize * 0.5f;
|
|
|
|
int iStart= ( SliceMode & 1 ) ? 0 : 1;
|
|
int iEnd= iSliceCount + ( ( SliceMode & 2 ) ? 1 : 0 );
|
|
|
|
for( int i= iStart; i <= iEnd; ++i )
|
|
{
|
|
D3DXVECTOR3 v( 0.0f, fSliceStart + (float)i * fSliceApart, 0.0f );
|
|
|
|
D3DXMATRIX m1;
|
|
D3DXMatrixRotationYawPitchRoll( &m1, vecRot.x, vecRot.y, vecRot.z );
|
|
|
|
D3DXVec3TransformCoord( &v, &v, &m1 );
|
|
|
|
g_pEditObject->AddBox(
|
|
D3DXVECTOR3( vecCenter + v ),
|
|
D3DXVECTOR3( vecExtent.x, fSliceSize * 0.5f, vecExtent.z),
|
|
D3DXVECTOR3( vecRot.x, vecRot.y, vecRot.z),
|
|
dwColor);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CreateSlicesZ( const D3DXVECTOR3& vecCenter,
|
|
const D3DXVECTOR3& vecExtent,
|
|
const D3DXVECTOR3& vecRot,
|
|
DWORD dwColor,
|
|
int Slices, int SliceMode, float fSliceFac )
|
|
{
|
|
if( Slices > -1 )
|
|
{
|
|
int iSliceCount= Slices;
|
|
float fSliceSize= 2.0f * fSliceFac * vecExtent.z / (float)( Slices + 1 );
|
|
float fSliceApart= ( vecExtent.z * 2.0f - fSliceSize ) / (float)( Slices + 1 );
|
|
float fSliceStart= -vecExtent.z + fSliceSize * 0.5f;
|
|
|
|
int iStart= ( SliceMode & 1 ) ? 0 : 1;
|
|
int iEnd= iSliceCount + ( ( SliceMode & 2 ) ? 1 : 0 );
|
|
|
|
for( int i= iStart; i <= iEnd; ++i )
|
|
{
|
|
D3DXVECTOR3 v( 0.0f, 0.0f, fSliceStart + (float)i * fSliceApart );
|
|
|
|
D3DXMATRIX m1;
|
|
D3DXMatrixRotationYawPitchRoll( &m1, vecRot.x, vecRot.y, vecRot.z );
|
|
|
|
D3DXVec3TransformCoord( &v, &v, &m1 );
|
|
|
|
g_pEditObject->AddBox(
|
|
D3DXVECTOR3( vecCenter + v ),
|
|
D3DXVECTOR3( vecExtent.x, vecExtent.y, fSliceSize * 0.5f),
|
|
D3DXVECTOR3( vecRot.x, vecRot.y, vecRot.z),
|
|
dwColor);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CreateRoof( const D3DXVECTOR3& vecCenter,
|
|
const D3DXVECTOR3& vecExtent,
|
|
const D3DXVECTOR3& vecRot,
|
|
DWORD dwColor,
|
|
int Type,
|
|
float fParams[ 4 ] )
|
|
{
|
|
if( Type == 0 )
|
|
{
|
|
float fHeight= 0.25f + fParams[ 0 ] * 0.25f;
|
|
float fSub= 0.25f + fParams[ 1 ] * 0.25f;
|
|
|
|
g_pEditObject->AddBox(
|
|
D3DXVECTOR3( vecCenter.x, vecCenter.y + 2.0f * vecExtent.y + fHeight, vecCenter.z ),
|
|
D3DXVECTOR3( vecExtent.x - fSub, fHeight, vecExtent.z - fSub),
|
|
D3DXVECTOR3( vecRot.x, vecRot.y, vecRot.z ),
|
|
dwColor);
|
|
}
|
|
if( Type == 1 )
|
|
{
|
|
float fHeight= 0.05f + fParams[ 0 ] * 0.1f;
|
|
float fFrac= 0.05f + fParams[ 1 ] * 0.1f;
|
|
float fSub= 0.0f;
|
|
|
|
CreateSlicesX(
|
|
D3DXVECTOR3( vecCenter.x, vecCenter.y + 2.0f * vecExtent.y + fHeight, vecCenter.z ),
|
|
D3DXVECTOR3( vecExtent.x - fSub, fHeight, vecExtent.z - fSub),
|
|
vecRot,
|
|
dwColor,
|
|
0, 3, fFrac );
|
|
CreateSlicesZ(
|
|
D3DXVECTOR3( vecCenter.x, vecCenter.y + 2.0f * vecExtent.y + fHeight, vecCenter.z ),
|
|
D3DXVECTOR3( vecExtent.x - fSub, fHeight, vecExtent.z - fSub),
|
|
vecRot,
|
|
dwColor,
|
|
0, 3, fFrac );
|
|
|
|
}
|
|
if( Type == 2 )
|
|
{
|
|
float fHeight= 0.25f + fParams[ 0 ] * 0.25f;
|
|
float fFrac= 0.05f + fParams[ 1 ] * 0.025f;
|
|
float fSub= 0.5f + fParams[ 2 ] * 0.5f;
|
|
|
|
CreateSlicesX(
|
|
D3DXVECTOR3( vecCenter.x, vecCenter.y + 2.0f * vecExtent.y + fHeight, vecCenter.z ),
|
|
D3DXVECTOR3( vecExtent.x - fSub, fHeight, vecExtent.z - fSub),
|
|
vecRot,
|
|
dwColor,
|
|
0, 3, fFrac );
|
|
CreateSlicesZ(
|
|
D3DXVECTOR3( vecCenter.x, vecCenter.y + 2.0f * vecExtent.y + fHeight, vecCenter.z ),
|
|
D3DXVECTOR3( vecExtent.x - fSub, fHeight, vecExtent.z - fSub),
|
|
vecRot,
|
|
dwColor,
|
|
0, 3, fFrac );
|
|
|
|
}
|
|
}
|
|
|
|
void CreateTower( const D3DXVECTOR3& vecCenter,
|
|
const D3DXVECTOR3& vecExtent,
|
|
const D3DXVECTOR3& vecRot,
|
|
DWORD dwColor,
|
|
float fInner1X, float fInner2X, float fInner1Z, float fInner2Z,
|
|
int SlicesX, int SlicesZ, int SlicesY,
|
|
float fSliceFacX, float fSliceFacZ, float fSliceFacY )
|
|
{
|
|
g_pEditObject->AddBox(
|
|
D3DXVECTOR3( vecCenter.x, vecCenter.y + vecExtent.y, vecCenter.z),
|
|
D3DXVECTOR3( vecExtent.x - fInner2X, vecExtent.y, vecExtent.z - fInner2Z),
|
|
vecRot,
|
|
dwColor);
|
|
|
|
CreateSlicesX(
|
|
D3DXVECTOR3( vecCenter.x, vecCenter.y + vecExtent.y, vecCenter.z),
|
|
D3DXVECTOR3( vecExtent.x - fInner2X, vecExtent.y, vecExtent.z - fInner1Z),
|
|
vecRot,
|
|
dwColor,
|
|
SlicesX, 0, fSliceFacX );
|
|
CreateSlicesZ(
|
|
D3DXVECTOR3( vecCenter.x, vecCenter.y + vecExtent.y, vecCenter.z),
|
|
D3DXVECTOR3( vecExtent.x - fInner1X, vecExtent.y, vecExtent.z - fInner2Z ),
|
|
vecRot,
|
|
dwColor,
|
|
SlicesZ, 0, fSliceFacZ );
|
|
CreateSlicesY(
|
|
D3DXVECTOR3( vecCenter.x, vecCenter.y + vecExtent.y + 1.0f / 64.0f , vecCenter.z),
|
|
D3DXVECTOR3( vecExtent.x, vecExtent.y, vecExtent.z),
|
|
vecRot,
|
|
dwColor,
|
|
SlicesY, 2, fSliceFacY );
|
|
}
|
|
|
|
void CreateAdd( const D3DXVECTOR3& vecCenter,
|
|
const D3DXVECTOR3& vecExtent,
|
|
const D3DXVECTOR3& vecRot,
|
|
DWORD dwColor )
|
|
{
|
|
}
|
|
|
|
void MakeRoundPoint( float fAngle, float fHeightFac, D3DXVECTOR3& v, float MainSize[ 3 ], float fReduce )
|
|
{
|
|
v.x= -sin( fAngle ) * ( MainSize[ 0 ] - fReduce );
|
|
v.y= fHeightFac * MainSize[ 2 ];
|
|
v.z= cos( fAngle ) * ( MainSize[ 1 ] - fReduce );
|
|
}
|
|
|
|
void CreateBuilding00( const D3DXVECTOR3& vecPos, float fAddHeight )
|
|
{
|
|
float fHeight= g_Random.genFloat();
|
|
fHeight= fHeight * fHeight * 12.0f + 10.0f + fAddHeight;
|
|
int iStories= (int)( fHeight / 2.6f );
|
|
float fStoryFrac= g_Random.genFloat( 2.0f / 64.0f, 5.0f / 64.0f ) / (float)iStories;
|
|
|
|
const float fMaxSize= 8.0f;
|
|
float MainSize[ 3 ]= { fMaxSize, fMaxSize, fHeight };
|
|
MainSize[ g_Random.genInteger( 0, 1 ) ]= fMaxSize * g_Random.genFloat( 0.66f, 1.0f );
|
|
|
|
int iWindowCount= g_Random.genInteger( 16, 28 );
|
|
|
|
float fWindowPart= g_Random.genFloat( 0.125f, 0.1875f );
|
|
float fWindowDepth[ 2 ]=
|
|
{
|
|
g_Random.genFloat( 0.0625f, 0.125f ),
|
|
g_Random.genFloat( 0.375f, 0.5f )
|
|
};
|
|
|
|
if( g_Random.genInteger( 0, 1 ) == 1 )
|
|
{
|
|
fWindowPart= 1.0f - fWindowPart;
|
|
}
|
|
|
|
for( int i= 0; i < iWindowCount; ++i )
|
|
{
|
|
float fAngle[ 3 ]=
|
|
{
|
|
(float)i / (float)iWindowCount * c_2PI,
|
|
0.0f,
|
|
(float)(i + 1 )/ (float)iWindowCount * c_2PI
|
|
};
|
|
fAngle[ 1 ] = fAngle[ 0 ] * fWindowPart + fAngle[ 2 ] * ( 1.0f - fWindowPart );
|
|
float fHeightFac[ 2 ]= { 0.0f, 1.0f };
|
|
|
|
float fReduce= fWindowDepth[ 0 ];
|
|
for( int j= 0; j < 2; ++j )
|
|
{
|
|
{
|
|
D3DXVECTOR3 v1;
|
|
MakeRoundPoint( fAngle[ j ], fHeightFac[ 0 ], v1, MainSize, fReduce );
|
|
D3DXVECTOR3 v2;
|
|
MakeRoundPoint( fAngle[ j ], fHeightFac[ 1 ], v2, MainSize, fReduce );
|
|
D3DXVECTOR3 v3;
|
|
MakeRoundPoint( fAngle[ j + 1], fHeightFac[ 0 ], v3, MainSize, fReduce );
|
|
D3DXVECTOR3 v4;
|
|
MakeRoundPoint( fAngle[ j + 1], fHeightFac[ 1 ], v4, MainSize, fReduce );
|
|
|
|
g_pEditObject->AddQuadFlat(
|
|
v1 + vecPos,
|
|
v2 + vecPos,
|
|
v3 + vecPos,
|
|
v4 + vecPos,
|
|
0xffc0c0c0 );
|
|
}
|
|
|
|
{
|
|
D3DXVECTOR3 v1;
|
|
MakeRoundPoint( fAngle[ j + 1], fHeightFac[ 0 ], v1, MainSize, fReduce );
|
|
D3DXVECTOR3 v2;
|
|
MakeRoundPoint( fAngle[ j + 1], fHeightFac[ 1 ], v2, MainSize, fReduce );
|
|
fReduce= fabs( fReduce - fWindowDepth[ 1 ] );
|
|
D3DXVECTOR3 v3;
|
|
MakeRoundPoint( fAngle[ j + 1], fHeightFac[ 0 ], v3, MainSize, fReduce );
|
|
D3DXVECTOR3 v4;
|
|
MakeRoundPoint( fAngle[ j + 1], fHeightFac[ 1 ], v4, MainSize, fReduce );
|
|
|
|
g_pEditObject->AddQuadFlat(
|
|
v1 + vecPos,
|
|
v2 + vecPos,
|
|
v3 + vecPos,
|
|
v4 + vecPos,
|
|
0xffc0c0c0 );
|
|
}
|
|
}
|
|
}
|
|
|
|
float fAngleOffset= 0.0f;
|
|
if( fWindowPart < 0.5f )
|
|
{
|
|
fAngleOffset= fWindowPart / (float)iWindowCount * c_PI;
|
|
}
|
|
else
|
|
{
|
|
fAngleOffset= ( - 1.0f + fWindowPart ) / (float)iWindowCount * c_PI;
|
|
}
|
|
|
|
float fAngleStep= 1.0f / (float)iWindowCount * c_2PI;
|
|
float fReduce= g_Random.genFloat( -0.125f, 0.0625f );
|
|
float fReduceInner= 1.0f;
|
|
for( int iStory= 0; iStory < iStories; ++iStory )
|
|
{
|
|
float fHeightFac= (float)(iStory) / (float)iStories;
|
|
|
|
for( int i= 0; i < iWindowCount; ++i )
|
|
{
|
|
float fAngle= (float)i * fAngleStep - fAngleOffset;
|
|
{
|
|
D3DXVECTOR3 v1;
|
|
MakeRoundPoint( fAngle, fHeightFac - fStoryFrac, v1, MainSize, fReduce );
|
|
D3DXVECTOR3 v2;
|
|
MakeRoundPoint( fAngle, fHeightFac + fStoryFrac, v2, MainSize, fReduce );
|
|
D3DXVECTOR3 v3;
|
|
MakeRoundPoint( fAngle + fAngleStep, fHeightFac - fStoryFrac, v3, MainSize, fReduce );
|
|
D3DXVECTOR3 v4;
|
|
MakeRoundPoint( fAngle + fAngleStep, fHeightFac + fStoryFrac, v4, MainSize, fReduce );
|
|
|
|
g_pEditObject->AddQuadFlat(
|
|
v1 + vecPos,
|
|
v2 + vecPos,
|
|
v3 + vecPos,
|
|
v4 + vecPos,
|
|
0xffc0c0c0 );
|
|
}
|
|
{
|
|
D3DXVECTOR3 v1;
|
|
MakeRoundPoint( fAngle, fHeightFac - fStoryFrac, v1, MainSize, fReduceInner );
|
|
D3DXVECTOR3 v2;
|
|
MakeRoundPoint( fAngle, fHeightFac - fStoryFrac, v2, MainSize, fReduce );
|
|
D3DXVECTOR3 v3;
|
|
MakeRoundPoint( fAngle + fAngleStep, fHeightFac - fStoryFrac, v3, MainSize, fReduceInner );
|
|
D3DXVECTOR3 v4;
|
|
MakeRoundPoint( fAngle + fAngleStep, fHeightFac - fStoryFrac, v4, MainSize, fReduce );
|
|
|
|
g_pEditObject->AddQuadFlat(
|
|
v1 + vecPos,
|
|
v2 + vecPos,
|
|
v3 + vecPos,
|
|
v4 + vecPos,
|
|
0xffc0c0c0 );
|
|
}
|
|
{
|
|
D3DXVECTOR3 v1;
|
|
MakeRoundPoint( fAngle, fHeightFac + fStoryFrac, v1, MainSize, fReduce );
|
|
D3DXVECTOR3 v2;
|
|
MakeRoundPoint( fAngle, fHeightFac + fStoryFrac, v2, MainSize, fReduceInner );
|
|
D3DXVECTOR3 v3;
|
|
MakeRoundPoint( fAngle + fAngleStep, fHeightFac + fStoryFrac, v3, MainSize, fReduce );
|
|
D3DXVECTOR3 v4;
|
|
MakeRoundPoint( fAngle + fAngleStep, fHeightFac + fStoryFrac, v4, MainSize, fReduceInner );
|
|
|
|
g_pEditObject->AddQuadFlat(
|
|
v1 + vecPos,
|
|
v2 + vecPos,
|
|
v3 + vecPos,
|
|
v4 + vecPos,
|
|
0xffc0c0c0 );
|
|
}
|
|
}
|
|
}
|
|
|
|
float fRoofBorderHeight= g_Random.genFloat( 0.5f, 1.0f );
|
|
float fRoofBorderWidth= g_Random.genFloat( 0.8f, 0.9f );
|
|
|
|
float fRoofHeights[ 24 ];
|
|
float fRoofSize[ 24 ];
|
|
int iRoofCount= 0;
|
|
fRoofHeights[ iRoofCount ]= fHeight;
|
|
fRoofSize[ iRoofCount ]= 0.75f;
|
|
iRoofCount++;
|
|
fRoofHeights[ iRoofCount ]= fHeight;
|
|
fRoofSize[ iRoofCount ]= 1.0f;
|
|
iRoofCount++;
|
|
fHeight+= fRoofBorderHeight;
|
|
fRoofHeights[ iRoofCount ]= fHeight;
|
|
fRoofSize[ iRoofCount ]= 1.0f;
|
|
iRoofCount++;
|
|
|
|
if( g_Random.genInteger( 0, 1 ) == 0 )
|
|
{
|
|
fRoofHeights[ iRoofCount ]= fHeight;
|
|
fRoofSize[ iRoofCount ]= fRoofBorderWidth;
|
|
iRoofCount++;
|
|
fHeight-= fRoofBorderHeight * g_Random.genFloat( 0.1f, 0.5f );
|
|
fRoofHeights[ iRoofCount ]= fHeight;
|
|
fRoofSize[ iRoofCount ]= fRoofBorderWidth;
|
|
iRoofCount++;
|
|
}
|
|
|
|
fRoofHeights[ iRoofCount ]= fHeight;
|
|
fRoofSize[ iRoofCount ]= 0.0f;
|
|
iRoofCount++;
|
|
|
|
for( int Roof= 1; Roof < iRoofCount; ++Roof )
|
|
{
|
|
for( int i= 0; i < iWindowCount; ++i )
|
|
{
|
|
float fAngle= (float)i * fAngleStep - fAngleOffset;
|
|
{
|
|
D3DXVECTOR3 v1;
|
|
MakeRoundPoint( fAngle, 0.0f, v1, MainSize, 0.0f );
|
|
D3DXVECTOR3 v2;
|
|
MakeRoundPoint( fAngle, 0.0f, v2, MainSize, 0.0f );
|
|
D3DXVECTOR3 v3;
|
|
MakeRoundPoint( fAngle + fAngleStep, 0.0f, v3, MainSize, 0.0f );
|
|
D3DXVECTOR3 v4;
|
|
MakeRoundPoint( fAngle + fAngleStep, 0.0f, v4, MainSize, 0.0f );
|
|
v1*= fRoofSize[ Roof -1];
|
|
v1.y= fRoofHeights[ Roof -1];
|
|
v2*= fRoofSize[ Roof ];
|
|
v2.y= fRoofHeights[ Roof ];
|
|
v3*= fRoofSize[ Roof -1];
|
|
v3.y= fRoofHeights[ Roof -1];
|
|
v4*= fRoofSize[ Roof ];
|
|
v4.y= fRoofHeights[ Roof ];
|
|
|
|
g_pEditObject->AddQuadFlat(
|
|
v1 + vecPos,
|
|
v2 + vecPos,
|
|
v3 + vecPos,
|
|
v4 + vecPos,
|
|
0xffc0c0c0 );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CreateBuilding01( const D3DXVECTOR3& vecPos, float fAddHeight )
|
|
{
|
|
float fHeight= g_Random.genFloat();
|
|
fHeight= fHeight * fHeight * 12.0f + 10.0f + fAddHeight;
|
|
int iStories= (int)( fHeight / 2.6f );
|
|
float fStoryFrac= g_Random.genFloat( 2.0f / 64.0f, 5.0f / 64.0f );
|
|
|
|
int iXZMode= g_Random.genInteger( 0, 1 );
|
|
|
|
const float fMaxSize= 8.0f;
|
|
float MainSize[2]= {fMaxSize, fMaxSize };
|
|
|
|
MainSize[ iXZMode ]-= g_Random.genFloat( 1.5f, 4.0f );
|
|
MainSize[ 1 - iXZMode ]-= g_Random.genFloat( 0.5f, 1.75f );
|
|
|
|
int iRoofType= g_Random.genInteger( -2, 2 );
|
|
float fRoofParam[ 4 ]=
|
|
{
|
|
g_Random.genFloat(),
|
|
g_Random.genFloat(),
|
|
g_Random.genFloat(),
|
|
g_Random.genFloat(),
|
|
};
|
|
|
|
float fInner[ 4 ]=
|
|
{
|
|
g_Random.genFloat( 0.125f, 0.5f ),
|
|
g_Random.genFloat( 0.375f, 0.875f ),
|
|
g_Random.genFloat( 0.125f, 0.5f ),
|
|
g_Random.genFloat( 0.375f, 0.875f ),
|
|
};
|
|
fInner[ iXZMode * 2 ]*= 0.625f;
|
|
fInner[ iXZMode * 2 + 1 ]*= 0.625f;
|
|
|
|
if( g_Random.genInteger( 0, 4 ) == 4 )
|
|
{
|
|
fInner[ 2 - iXZMode * 2 ]*= -1.0f;
|
|
}
|
|
|
|
int iWindowSlices[ 2 ]=
|
|
{ -1, -1 };
|
|
|
|
for( int i= 0; i < 2; ++i )
|
|
{
|
|
int iSliceMode= g_Random.genInteger( 0, 6 );
|
|
if( iSliceMode > 1 )
|
|
{
|
|
iWindowSlices[ i ]= (int)MainSize[ i ] - g_Random.genInteger( 0, 3 );
|
|
}
|
|
else if( iSliceMode == 1 )
|
|
{
|
|
iWindowSlices[ i ]= g_Random.genInteger( 1, 2 );
|
|
}
|
|
}
|
|
|
|
int iModes[ 20 ]=
|
|
{
|
|
0, 0,
|
|
0, 0,
|
|
1, 0,
|
|
0, 1,
|
|
0, 2,
|
|
2, 0,
|
|
2, 2,
|
|
2, 2,
|
|
2, 1,
|
|
1, 2,
|
|
};
|
|
int iTowerMode= g_Random.genInteger( 0, 9 ) * 2;
|
|
|
|
if( iModes[ iTowerMode ] == 1 || iModes[ iTowerMode + 1 ] == 1 )
|
|
{
|
|
if( g_Random.genInteger( 0, 1 ) == 1 )
|
|
{
|
|
fInner[ iXZMode * 2 ]*= -1.0f;
|
|
}
|
|
|
|
MainSize[ 1 - iXZMode ]= fMaxSize - g_Random.genFloat( 1.5f, 2.5f );
|
|
}
|
|
|
|
|
|
for( int i= 0; i < 2; ++i )
|
|
{
|
|
int iCurMode= iModes[ iTowerMode + i ];
|
|
|
|
if( iCurMode == 1 )
|
|
{
|
|
float fSize= g_Random.genFloat( fMaxSize * 0.375f, fMaxSize * 0.625f );
|
|
float fInner[ 4 ]=
|
|
{
|
|
g_Random.genFloat( 0.125f, 0.5f ),
|
|
g_Random.genFloat( 0.375f, 0.875f ),
|
|
g_Random.genFloat( 0.125f, 0.5f ),
|
|
g_Random.genFloat( 0.375f, 0.875f ),
|
|
};
|
|
|
|
int iWindowSlice= (int)fSize - g_Random.genInteger( 0, 2 );
|
|
|
|
float fOffset[ 2 ]=
|
|
{
|
|
( fMaxSize - fSize ),
|
|
( fMaxSize - fSize )
|
|
};
|
|
|
|
if( i == 1 )
|
|
{
|
|
fOffset[ iXZMode ]*= -1.0f;
|
|
}
|
|
|
|
if( g_Random.genInteger( 0, 1 ) == 1 )
|
|
{
|
|
fOffset[ 1 - iXZMode ]*= -1.0f;
|
|
}
|
|
|
|
CreateTower(
|
|
D3DXVECTOR3( vecPos.x + fOffset[ 0 ] , vecPos.y, vecPos.z + fOffset[ 1 ] ),
|
|
D3DXVECTOR3( fSize, fHeight * 0.5f, fSize ),
|
|
D3DXVECTOR3( 0.0f, 0.0f, 0.0f ),
|
|
0xffc0c0c0,
|
|
fInner[ 0 ], fInner[ 1 ], fInner[ 2 ], fInner[ 3 ],
|
|
iWindowSlice, iWindowSlice, iStories,
|
|
g_Random.genFloat( 0.125f, 0.875f ),
|
|
g_Random.genFloat( 0.125f, 0.875f ),
|
|
fStoryFrac );
|
|
|
|
if( iRoofType == 0 )
|
|
{
|
|
CreateRoof(
|
|
D3DXVECTOR3( vecPos.x + fOffset[ 0 ] , vecPos.y, vecPos.z + fOffset[ 1 ] ),
|
|
D3DXVECTOR3( fSize, fHeight * 0.5f, fSize ),
|
|
D3DXVECTOR3( 0.0f, 0.0f, 0.0f ),
|
|
0xffc0c0c0,
|
|
iRoofType,
|
|
fRoofParam );
|
|
}
|
|
}
|
|
|
|
if( iCurMode == 2 )
|
|
{
|
|
float fSizeLeft= minimum( fMaxSize - MainSize[ 0 ], fMaxSize - MainSize[ 1 ] );
|
|
|
|
float fAngle= 0.0f;
|
|
|
|
float fInnerConfigs[ 6 ]=
|
|
{
|
|
0.0625f, 0.0625f,
|
|
g_Random.genFloat( 0.0625f, 0.125f ), g_Random.genFloat( 0.25f, 0.5f ),
|
|
g_Random.genFloat( -0.125f, -0.25f ), g_Random.genFloat( 0.125f, 0.25f ),
|
|
};
|
|
int SliceConfig[ 3 ]=
|
|
{
|
|
-1,
|
|
2,
|
|
g_Random.genInteger( 1, 3 ),
|
|
};
|
|
float fFracConfig[ 3 ]=
|
|
{
|
|
0.0f,
|
|
g_Random.genFloat( 0.125f, 0.25f ),
|
|
g_Random.genFloat( 0.25f, 0.5f ),
|
|
};
|
|
int ConfigX= g_Random.genInteger( 0, 2 );
|
|
int ConfigZ= g_Random.genInteger( 0, 2 );
|
|
|
|
float fOffset[ 2 ]=
|
|
{
|
|
MainSize[ 0 ],
|
|
MainSize[ 1 ],
|
|
};
|
|
|
|
|
|
if( fSizeLeft > 1.4f )
|
|
{
|
|
fAngle= c_PI / 4;
|
|
|
|
fSizeLeft/= 1.5f;
|
|
}
|
|
else
|
|
{
|
|
float fAdd= g_Random.genFloat( 0.125f, 0.75f );
|
|
fSizeLeft+= fAdd;
|
|
fOffset[ 0 ]= minimum( fOffset[ 0 ], fMaxSize - fSizeLeft );
|
|
fOffset[ 1 ]= minimum( fOffset[ 1 ], fMaxSize - fSizeLeft );
|
|
if( g_Random.genInteger( 0, 1 ) == 1 )
|
|
{
|
|
fOffset[ 1 - iXZMode ]*= g_Random.genFloat( 0.0f, 0.6f );
|
|
}
|
|
|
|
}
|
|
|
|
if( i == 1 )
|
|
{
|
|
fOffset[ iXZMode ]*= -1.0f;
|
|
}
|
|
if( g_Random.genInteger( 0, 1 ) == 1 )
|
|
{
|
|
fOffset[ 1 - iXZMode ]*= -1.0f;
|
|
}
|
|
|
|
CreateTower(
|
|
D3DXVECTOR3( vecPos.x + fOffset[ 0 ] , vecPos.y, vecPos.z + fOffset[ 1 ] ),
|
|
D3DXVECTOR3( fSizeLeft, fHeight * 0.5f, fSizeLeft),
|
|
D3DXVECTOR3( fAngle, 0.0f, 0.0f ),
|
|
0xffc0c0c0,
|
|
fInnerConfigs[ ConfigX * 2 ],fInnerConfigs[ ConfigX * 2 + 1 ],
|
|
fInnerConfigs[ ConfigZ * 2 ],fInnerConfigs[ ConfigZ * 2 + 1 ],
|
|
SliceConfig[ ConfigX ], SliceConfig[ ConfigZ ], iStories,
|
|
fFracConfig[ ConfigX ],
|
|
fFracConfig[ ConfigZ ],
|
|
fStoryFrac );
|
|
}
|
|
}
|
|
|
|
CreateTower(
|
|
D3DXVECTOR3( vecPos.x , vecPos.y , vecPos.z ),
|
|
D3DXVECTOR3( MainSize[ 0 ], fHeight * 0.5f, MainSize[ 1 ]),
|
|
D3DXVECTOR3( 0.0f, 0.0f, 0.0f ),
|
|
0xffc0c0c0,
|
|
fInner[ 0 ], fInner[ 1 ], fInner[ 2 ], fInner[ 3 ],
|
|
iWindowSlices[ 0 ], iWindowSlices[ 1 ], iStories,
|
|
g_Random.genFloat( 0.125f, 0.875f ),
|
|
g_Random.genFloat( 0.125f, 0.875f ),
|
|
fStoryFrac );
|
|
CreateRoof(
|
|
D3DXVECTOR3( vecPos.x , vecPos.y , vecPos.z ),
|
|
D3DXVECTOR3( MainSize[ 0 ], fHeight * 0.5f, MainSize[ 1 ]),
|
|
D3DXVECTOR3( 0.0f, 0.0f, 0.0f ),
|
|
0xffc0c0c0,
|
|
iRoofType,
|
|
fRoofParam );
|
|
}
|