const Stonepair Gamefield::NextStones()
{
sf::Sprite sprite(myResourcemanager->Get<sf::Texture>(mySettings.GetSettings("Resource", "Bubbles")));
sprite.setScale(mySettings.GetScaleFactor());
return Stonepair(Stone(sf::Vector2i(2, -1), myOrigin, GetRandomColor(), sprite),
Stone(sf::Vector2i(2, -2), myOrigin, GetRandomColor(), sprite));
}
void SegmenterLightTest::ConvertPCLCloud2CvVec(const pcl::PointCloud<pcl::PointXYZRGBL>::Ptr &pcl_cloud,
std::vector<cv::Vec4f> &cvCloud/*,
bool random_colors*/)
{
int pcWidth = pcl_cloud->width;
int pcHeight = pcl_cloud->height;
unsigned position = 0;
unsigned max_label = 0;
for(unsigned i=0; i<pcl_cloud->points.size(); i++)
if(pcl_cloud->points[i].label > max_label)
max_label = pcl_cloud->points[i].label;
RGBValue color[max_label];
for(unsigned i=0; i<max_label; i++)
color[i].float_value = GetRandomColor();
for (int row = 0; row < pcHeight; row++) {
for (int col = 0; col < pcWidth; col++) {
cv::Vec4f p;
position = row * pcWidth + col;
p[0] = pcl_cloud->points[position].x;
p[1] = pcl_cloud->points[position].y;
p[2] = pcl_cloud->points[position].z;
p[3] = color[pcl_cloud->points[position].label].float_value;
cvCloud.push_back(p);
}
}
}
void SnowModel::SetRandomEGFColors()
{
for (std::vector<EdgeGroup*>::iterator it = edge_groups.begin();
it != edge_groups.end(); ++it) {
point3f clr = GetRandomColor();
(*it)->SetEdgeGroupFaceColor( clr );
}
}
void GetNextBlock()
{ for(int x=0; x<4; x++)
for(int y=0; y<4; y++)
if(BlockMatrix[x][y] != BLANK)
ScreenBackgroundLayout[BlockX+x][BlockY+y] = BlockMatrix[x][y]; //stop the block moving down
CheckForLine(); //checking if lines are filled
AssignShape(NextShape, NextColor); //assign new block
NextShape = GetRandomShape(); //assign next shape
NextColor = GetRandomColor(); //assign next color
DisplayNextShape(); //display next block
BlockX = 7; //restore value of BlockX & BlockY
BlockY = 0;
if(MoveBlock(LEFT)) //if block collides with something return 1
{ GameOver=1;
}
}
void D3D12PipelineStateCache::LoadAssets()
{
// Create the root signature.
{
D3D12_FEATURE_DATA_ROOT_SIGNATURE featureData = {};
// This is the highest version the sample supports. If CheckFeatureSupport succeeds, the HighestVersion returned will not be greater than this.
featureData.HighestVersion = D3D_ROOT_SIGNATURE_VERSION_1_1;
if (FAILED(m_device->CheckFeatureSupport(D3D12_FEATURE_ROOT_SIGNATURE, &featureData, sizeof(featureData))))
{
featureData.HighestVersion = D3D_ROOT_SIGNATURE_VERSION_1_0;
}
CD3DX12_DESCRIPTOR_RANGE1 ranges[RootParametersCount];
ranges[RootParameterSRV].Init(D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 1, 0, 0, D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC);
CD3DX12_ROOT_PARAMETER1 rootParameters[RootParametersCount];
rootParameters[RootParameterUberShaderCB].InitAsConstantBufferView(0, 0, D3D12_ROOT_DESCRIPTOR_FLAG_DATA_STATIC, D3D12_SHADER_VISIBILITY_ALL);
rootParameters[RootParameterCB].InitAsConstantBufferView(1, 0, D3D12_ROOT_DESCRIPTOR_FLAG_DATA_STATIC, D3D12_SHADER_VISIBILITY_ALL);
rootParameters[RootParameterSRV].InitAsDescriptorTable(1, &ranges[RootParameterSRV]);
D3D12_STATIC_SAMPLER_DESC sampler = {};
sampler.Filter = D3D12_FILTER_MIN_MAG_MIP_POINT;
sampler.AddressU = D3D12_TEXTURE_ADDRESS_MODE_BORDER;
sampler.AddressV = D3D12_TEXTURE_ADDRESS_MODE_BORDER;
sampler.AddressW = D3D12_TEXTURE_ADDRESS_MODE_BORDER;
sampler.MipLODBias = 0;
sampler.MaxAnisotropy = 0;
sampler.ComparisonFunc = D3D12_COMPARISON_FUNC_NEVER;
sampler.BorderColor = D3D12_STATIC_BORDER_COLOR_TRANSPARENT_BLACK;
sampler.MinLOD = 0.0f;
sampler.MaxLOD = 9999.0f;
sampler.ShaderRegister = 0;
sampler.RegisterSpace = 0;
sampler.ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL;
CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC rootSignatureDesc;
rootSignatureDesc.Init_1_1(_countof(rootParameters), rootParameters, 1, &sampler, D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT);
ComPtr<ID3DBlob> signature;
ComPtr<ID3DBlob> error;
ThrowIfFailed(D3DX12SerializeVersionedRootSignature(&rootSignatureDesc, featureData.HighestVersion, &signature, &error));
ThrowIfFailed(m_device->CreateRootSignature(0, signature->GetBufferPointer(), signature->GetBufferSize(), IID_PPV_ARGS(&m_rootSignature)));
NAME_D3D12_OBJECT(m_rootSignature);
}
// Create the command list.
ThrowIfFailed(m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, m_commandAllocators[m_frameIndex].Get(), nullptr, IID_PPV_ARGS(&m_commandList)));
NAME_D3D12_OBJECT(m_commandList);
// Note: ComPtr's are CPU objects but this resource needs to stay in scope until
// the command list that references it has finished executing on the GPU.
// We will flush the GPU at the end of this method to ensure the resource is not
// prematurely destroyed.
ComPtr<ID3D12Resource> vertexIndexBufferUpload;
// Vertex and Index Buffer.
{
const VertexPositionColor cubeVertices[] = {
{ { -1.0f, 1.0f, -1.0f, 1.0f }, { GetRandomColor(),GetRandomColor(), GetRandomColor() } }, // Back Top Left
{ { 1.0f, 1.0f, -1.0f, 1.0f }, { GetRandomColor(), GetRandomColor(), GetRandomColor() } }, // Back Top Right
{ { 1.0f, 1.0f, 1.0f, 1.0f }, { GetRandomColor(), GetRandomColor(), GetRandomColor() } }, // Front Top Right
{ { -1.0f, 1.0f, 1.0f, 1.0f }, { GetRandomColor(), GetRandomColor(), GetRandomColor() } }, // Front Top Left
{ { -1.0f, -1.0f, -1.0f, 1.0f }, { GetRandomColor(),GetRandomColor(), GetRandomColor() } }, // Back Bottom Left
{ { 1.0f, -1.0f, -1.0f, 1.0f }, { GetRandomColor(),GetRandomColor(), GetRandomColor() } }, // Back Bottom Right
{ { 1.0f, -1.0f, 1.0f, 1.0f }, { GetRandomColor(),GetRandomColor(), GetRandomColor() } }, // Front Bottom Right
{ { -1.0f, -1.0f, 1.0f, 1.0f }, { GetRandomColor(),GetRandomColor(), GetRandomColor() } }, // Front Bottom Left
};
const UINT cubeIndices[] =
{
0, 1, 3,
1, 2, 3,
3, 2, 7,
6, 7, 2,
2, 1, 6,
5, 6, 1,
1, 0, 5,
4, 5, 0,
0, 3, 4,
7, 4, 3,
7, 6, 4,
5, 4, 6,
};
static const VertexPositionUV quadVertices[] =
{
{ { -1.0f, -1.0f, 0.0f, 1.0f }, { 0.0f, 1.0f } }, // Bottom Left
{ { -1.0f, 1.0f, 0.0f, 1.0f }, { 0.0f, 0.0f } }, // Top Left
{ { 1.0f, -1.0f, 0.0f, 1.0f }, { 1.0f, 1.0f } }, // Bottom Right
{ { 1.0f, 1.0f, 0.0f, 1.0f }, { 1.0f, 0.0f } }, // Top Right
};
const UINT vertexIndexBufferSize = sizeof(cubeIndices) + sizeof(cubeVertices) + sizeof(quadVertices);
ThrowIfFailed(m_device->CreateCommittedResource(
&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT),
D3D12_HEAP_FLAG_NONE,
&CD3DX12_RESOURCE_DESC::Buffer(vertexIndexBufferSize),
D3D12_RESOURCE_STATE_COPY_DEST,
nullptr,
IID_PPV_ARGS(&m_vertexIndexBuffer)));
ThrowIfFailed(m_device->CreateCommittedResource(
&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD),
D3D12_HEAP_FLAG_NONE,
&CD3DX12_RESOURCE_DESC::Buffer(vertexIndexBufferSize),
D3D12_RESOURCE_STATE_GENERIC_READ,
nullptr,
IID_PPV_ARGS(&vertexIndexBufferUpload)));
NAME_D3D12_OBJECT(m_vertexIndexBuffer);
UINT8* mappedUploadHeap = nullptr;
CD3DX12_RANGE readRange(0, 0); // We do not intend to read from this resource on the CPU.
ThrowIfFailed(vertexIndexBufferUpload->Map(0, &readRange, reinterpret_cast<void**>(&mappedUploadHeap)));
// Fill in part of the upload heap with our index and vertex data.
UINT8* heapLocation = static_cast<UINT8*>(mappedUploadHeap);
memcpy(heapLocation, cubeVertices, sizeof(cubeVertices));
heapLocation += sizeof(cubeVertices);
memcpy(heapLocation, cubeIndices, sizeof(cubeIndices));
heapLocation += sizeof(cubeIndices);
memcpy(heapLocation, quadVertices, sizeof(quadVertices));
// Pack the vertices and indices into their destination by copying from the upload heap.
m_commandList->CopyBufferRegion(m_vertexIndexBuffer.Get(), 0, vertexIndexBufferUpload.Get(), 0, vertexIndexBufferSize);
m_commandList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(m_vertexIndexBuffer.Get(), D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER | D3D12_RESOURCE_STATE_INDEX_BUFFER));
// Create the index and vertex buffer views.
m_cubeVbv.BufferLocation = m_vertexIndexBuffer.Get()->GetGPUVirtualAddress();
m_cubeVbv.SizeInBytes = sizeof(cubeVertices);
m_cubeVbv.StrideInBytes = sizeof(VertexPositionColor);
m_cubeIbv.BufferLocation = m_cubeVbv.BufferLocation + sizeof(cubeVertices);
m_cubeIbv.SizeInBytes = sizeof(cubeIndices);
m_cubeIbv.Format = DXGI_FORMAT_R32_UINT;
m_quadVbv.BufferLocation = m_cubeIbv.BufferLocation + sizeof(cubeIndices);
m_quadVbv.SizeInBytes = sizeof(quadVertices);
m_quadVbv.StrideInBytes = sizeof(VertexPositionUV);
}
// Create the constant buffer.
m_dynamicCB.Init(m_device.Get());
// Close the command list and execute it to begin the vertex/index buffer copy
// into the default heap.
ThrowIfFailed(m_commandList->Close());
ID3D12CommandList* ppCommandLists[] = { m_commandList.Get() };
m_commandQueue->ExecuteCommandLists(_countof(ppCommandLists), ppCommandLists);
// Create synchronization objects and wait until assets have been uploaded to the GPU.
{
ThrowIfFailed(m_device->CreateFence(m_fenceValues[m_frameIndex], D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&m_fence)));
m_fenceValues[m_frameIndex]++;
// Create an event handle to use for frame synchronization.
m_fenceEvent = CreateEvent(nullptr, FALSE, FALSE, nullptr);
if (m_fenceEvent == nullptr)
{
ThrowIfFailed(HRESULT_FROM_WIN32(GetLastError()));
}
// Wait for the command list to execute; we are reusing the same command
// list in our main loop but for now, we just want to wait for setup to
// complete before continuing.
WaitForGpu();
}
m_psoLibrary.Build(m_device.Get(), m_rootSignature.Get());
UpdateWindowTextPso();
}
void SetPlayerColors()
{
j1Color = GetRandomColor();
if( j1Color == ECblue ){ j2Color = ECred; }
else{ j2Color = ECblue; }
}
/*
=============
FinalLightFace
Add the indirect lighting on top of the direct
lighting and save into final map format
=============
*/
void FinalLightFace( int iThread, int facenum )
{
dface_t *f;
int i, j, k;
facelight_t *fl;
float minlight;
int lightstyles;
LightingValue_t lb[NUM_BUMP_VECTS + 1], v[NUM_BUMP_VECTS + 1];
unsigned char *pdata[NUM_BUMP_VECTS + 1];
int bumpSample;
radial_t *rad = NULL;
radial_t *prad = NULL;
f = &g_pFaces[facenum];
// test for non-lit texture
if ( texinfo[f->texinfo].flags & TEX_SPECIAL)
return;
fl = &facelight[facenum];
for (lightstyles=0; lightstyles < MAXLIGHTMAPS; lightstyles++ )
{
if ( f->styles[lightstyles] == 255 )
break;
}
if ( !lightstyles )
return;
//
// sample the triangulation
//
minlight = FloatForKey (face_entity[facenum], "_minlight") * 128;
bool needsBumpmap = ( texinfo[f->texinfo].flags & SURF_BUMPLIGHT ) ? true : false;
int bumpSampleCount = needsBumpmap ? NUM_BUMP_VECTS + 1 : 1;
bool bDisp = ( f->dispinfo != -1 );
//#define RANDOM_COLOR
#ifdef RANDOM_COLOR
unsigned char randomColor[3];
GetRandomColor( randomColor );
#endif
// NOTE: I'm using these RB trees to sort all the illumination values
// to compute median colors. Turns out that this is a somewhat better
// method that using the average; usually if there are surfaces
// with a large light intensity variation, the extremely bright regions
// have a very small area and tend to influence the average too much.
CUtlRBTree< float, int > m_Red( 0, 256, FloatLess );
CUtlRBTree< float, int > m_Green( 0, 256, FloatLess );
CUtlRBTree< float, int > m_Blue( 0, 256, FloatLess );
for (k=0 ; k < lightstyles; k++ )
{
m_Red.RemoveAll();
m_Green.RemoveAll();
m_Blue.RemoveAll();
if (!do_fast)
{
if( !bDisp )
{
rad = BuildLuxelRadial( facenum, k );
}
else
{
rad = StaticDispMgr()->BuildLuxelRadial( facenum, k, needsBumpmap );
}
}
if (numbounce > 0 && k == 0)
{
// currently only radiosity light non-displacement surfaces!
if( !bDisp )
{
prad = BuildPatchRadial( facenum );
}
else
{
prad = StaticDispMgr()->BuildPatchRadial( facenum, needsBumpmap );
}
}
// pack the nonbump texture and the three bump texture for the given
// lightstyle right next to each other.
// NOTE: Even though it's building positions for all bump-mapped data,
// it isn't going to use those positions (see loop over bumpSample below)
// The file offset is correctly computed to only store space for 1 set
// of light data if we don't have bumped lighting.
for( bumpSample = 0; bumpSample < bumpSampleCount; ++bumpSample )
{
pdata[bumpSample] = &(*pdlightdata)[f->lightofs + (k * bumpSampleCount + bumpSample) * fl->numluxels*4];
}
// Compute the average luxel color, but not for the bump samples
Vector avg( 0.0f, 0.0f, 0.0f );
int avgCount = 0;
for (j=0 ; j<fl->numluxels; j++)
{
// garymct - direct lighting
bool baseSampleOk = true;
if (!do_fast)
{
if( !bDisp )
{
baseSampleOk = SampleRadial( rad, fl->luxel[j], lb, bumpSampleCount );
}
else
{
baseSampleOk = StaticDispMgr()->SampleRadial( facenum, rad, fl->luxel[j], j, lb, bumpSampleCount, false );
}
}
else
{
for ( int iBump = 0 ; iBump < bumpSampleCount; iBump++ )
{
lb[iBump] = fl->light[0][iBump][j];
}
}
if (prad)
{
// garymct - bounced light
// v is indirect light that is received on the luxel.
if( !bDisp )
{
SampleRadial( prad, fl->luxel[j], v, bumpSampleCount );
}
else
{
StaticDispMgr()->SampleRadial( facenum, prad, fl->luxel[j], j, v, bumpSampleCount, true );
}
for( bumpSample = 0; bumpSample < bumpSampleCount; ++bumpSample )
{
lb[bumpSample].AddLight( v[bumpSample] );
}
}
if ( bDisp && g_bDumpPatches )
{
for( bumpSample = 0; bumpSample < bumpSampleCount; ++bumpSample )
{
DumpDispLuxels( facenum, lb[bumpSample].m_vecLighting, j, bumpSample );
}
}
if (fl->numsamples == 0)
{
for( i = 0; i < bumpSampleCount; i++ )
{
lb[i].Init( 255, 0, 0 );
}
baseSampleOk = false;
}
int bumpSample;
for( bumpSample = 0; bumpSample < bumpSampleCount; bumpSample++ )
{
// clip from the bottom first
// garymct: minlight is a per entity minimum light value?
for( i=0; i<3; i++ )
{
lb[bumpSample].m_vecLighting[i] = max( lb[bumpSample].m_vecLighting[i], minlight );
}
// Do the average light computation, I'm assuming (perhaps incorrectly?)
// that all luxels in a particular lightmap have the same area here.
// Also, don't bother doing averages for the bump samples. Doing it here
// because of the minlight clamp above + the random color testy thingy.
// Also have to do it before Vec3toColorRGBExp32 because it
// destructively modifies lb[bumpSample] (Feh!)
if ((bumpSample == 0) && baseSampleOk)
{
++avgCount;
ApplyMacroTextures( facenum, fl->luxel[j], lb[0].m_vecLighting );
// For median computation
m_Red.Insert( lb[bumpSample].m_vecLighting[0] );
m_Green.Insert( lb[bumpSample].m_vecLighting[1] );
m_Blue.Insert( lb[bumpSample].m_vecLighting[2] );
}
#ifdef RANDOM_COLOR
pdata[bumpSample][0] = randomColor[0] / ( bumpSample + 1 );
pdata[bumpSample][1] = randomColor[1] / ( bumpSample + 1 );
pdata[bumpSample][2] = randomColor[2] / ( bumpSample + 1 );
pdata[bumpSample][3] = 0;
#else
// convert to a 4 byte r,g,b,signed exponent format
VectorToColorRGBExp32( Vector( lb[bumpSample].m_vecLighting.x, lb[bumpSample].m_vecLighting.y,
lb[bumpSample].m_vecLighting.z ), *( ColorRGBExp32 *)pdata[bumpSample] );
#endif
pdata[bumpSample] += 4;
}
}
FreeRadial( rad );
if (prad)
{
FreeRadial( prad );
prad = NULL;
}
// Compute the median color for this lightstyle
// Remember, the data goes *before* the specified light_ofs, in *reverse order*
ColorRGBExp32 *pAvgColor = dface_AvgLightColor( f, k );
if (avgCount == 0)
{
Vector median( 0, 0, 0 );
VectorToColorRGBExp32( median, *pAvgColor );
}
else
{
unsigned int r, g, b;
r = m_Red.FirstInorder();
g = m_Green.FirstInorder();
b = m_Blue.FirstInorder();
avgCount >>= 1;
while (avgCount > 0)
{
r = m_Red.NextInorder(r);
g = m_Green.NextInorder(g);
b = m_Blue.NextInorder(b);
--avgCount;
}
Vector median( m_Red[r], m_Green[g], m_Blue[b] );
VectorToColorRGBExp32( median, *pAvgColor );
}
}
}
int main(){
int gd=DETECT, gm;
int Return=0;
char Key, ScanCode;
int Counter=0; //Divide total delay & take multiple input
initgraph(&gd, &gm,"c:\\tc\\bgi"); //initialize graphics mode
randomize(); //Randomize block's shapes & color
cleardevice(); //clear screen
InitPalette(); //for setting color pallete
InitMatrix(); //Initialize Matrix
GetImages(); //Saving the images
StartScreen(); //for start screen
cleardevice(); //clear screen
AssignShape(GetRandomShape(), GetRandomColor()); //for the falling block
NextShape=GetRandomShape();
NextColor=GetRandomColor(); DisplayScreen(); //Show main screen
DisplayNextShape(); //show next brick
MoveBlock(LEFT); //keep the block on center & check game over
while(kbhit()) getch(); //empty the keyboard input
while (!Quit && !GameOver) { //Moving the blocks down
if(++Counter >= Speed) //For controling the speed
{ Counter=0;
MoveBlock(DOWN);
SoundDrop();
}
if(kbhit()) //For the arrow keys
{ Key = getch();
if(Key == 0)
{ ScanCode = getch();
if(ScanCode == KEY_UP)
RotateBlock();
else if(ScanCode == KEY_LEFT)
MoveBlock(LEFT);
else if(ScanCode == KEY_RIGHT)
MoveBlock(RIGHT);
else if(ScanCode == KEY_DOWN)
{ Score++; //increase score
PrintScore();
MoveBlock(DOWN);
}
if(!Return)
SoundDrop();
Return = 0;
}
else if(Key == KEY_ENTER || Key == KEY_SPACE) //Rotating bricks
RotateBlock();
else if(Key == 'P' || Key == 'p') //For pause
{ MessageBox(" Paused");
while(kbhit()) getch(); //clear the keyboard input
for(int x=0; x<COLS; x++)
for(int y=0; y<ROWS; y++)
PreviousScreenLayout[x][y] -= 1; //Clear the present screen layout to refresh the whole screen
UpdateScreen(); //refresh screen
}
else if(Key == KEY_ESC) //For quit
{ char ret = MessageBox("Are you sure, you want to Quit?", 563, 2);
if(ret == 'y' || ret == 'Y' || ret == KEY_ENTER)
{ Quit = 1;
break;
}
cleardevice(); //Clear the message box
while(kbhit()) getch(); //Clear the keyboard input
for(int x=0; x<COLS; x++)
for(int y=0; y<ROWS; y++)
PreviousScreenLayout[x][y] -= 1; // Clear the present screen layout to refresh the whole screen
UpdateScreen(); //refresh screen
DisplayScreen(); //show the main screen again
DisplayNextShape(); //show next brick box
}
else if(Key == 's' || Key == 'S') //For sound on/off
{
SoundOn = !SoundOn;
}
else if(Key=='a' || Key=='A') //For author
{ MessageBox("Author: Aguntuk Group",450);
cleardevice(); //Clear the message box
while(kbhit()) getch(); //Clear the keyboard input
for(int x=0;x<COLS;x++)
for(int y=0;y<ROWS;y++)
PreviousScreenLayout[x][y] -=1; //Clear the present screen layout to refresh the whole screen
UpdateScreen(); //refresh screen
DisplayScreen(); //show the main screen again
DisplayNextShape(); //show next brick box
}
}
delay(6); //For moving down the blocks slowly
}
if(GameOver) //For game over option
{ DisplayBlock(6,0); //For display the top most brick
ShowGameOver(); //For display game over message box
}
restorecrtmode(); //For closing graphicg mode
return 0;
}
