//----------------------------------------------------------------------------
PerformanceAMDWindow::PerformanceAMDWindow(Parameters& parameters)
:
Window(parameters),
mTextColor({ 0.0f, 0.0f, 0.0f, 1.0f }),
mPerformance(mEngine->GetDevice())
{
if (!SetEnvironment())
{
parameters.created = false;
return;
}
CreateCamera();
CreateTextureGenerator();
CreateScene();
// Disable back-face culling.
mNoCullingState.reset(new RasterizerState());
mNoCullingState->cullMode = RasterizerState::CULL_NONE;
mEngine->SetRasterizerState(mNoCullingState);
mPerformance.SaveCounterInformation("AMD7970Counters.txt");
mPerformance.Register(Listener);
mPerformance.SetAllCounters();
UpdateCW();
}
GeometryShadersWindow::GeometryShadersWindow(Parameters& parameters)
:
Window3(parameters)
{
if (!SetEnvironment() || !CreateScene())
{
parameters.created = false;
return;
}
mEngine->SetClearColor({ 1.0f, 1.0f, 1.0f, 1.0f });
InitializeCamera();
mCamera->SetFrustum(60.0f, GetAspectRatio(), 0.1f, 100.0f);
Vector4<float> camPosition{ 2.8f, 0.0f, 0.0f, 1.0f };
Vector4<float> camDVector{ -1.0f, 0.0f, 0.0f, 0.0f };
Vector4<float> camUVector{ 0.0f, 0.0f, 1.0f, 0.0f };
Vector4<float> camRVector = Cross(camDVector, camUVector);
mCamera->SetFrame(camPosition, camDVector, camUVector, camRVector);
#if defined(SAVE_RENDERING_TO_DISK)
mTarget = std::make_shared<DrawTarget>(1, DF_R8G8B8A8_UNORM, mXSize,
mYSize);
mTarget->GetRTTexture(0)->SetCopyType(Resource::COPY_STAGING_TO_CPU);
#endif
}
void Process::_SetEnvironment(const ValueList& args, KValueRef result)
{
if (args.size() >= 2 && args.at(0)->IsString() && args.at(1)->IsString())
{
SetEnvironment(args.at(0)->ToString(), args.at(1)->ToString());
}
}
Playground::Playground(QWidget *parent, int _numberAgents, int _numberObstacles, bool gpu)
: QWidget(parent)
{
numberAgents = _numberAgents;
numberObstacles = _numberObstacles;
if(numberObstacles > MAX_TRIANGLE)
numberObstacles = MAX_TRIANGLE;
countingTimeText = NULL;
SetEnvironment();
QGraphicsView * view = new QGraphicsView(&scene);
QHBoxLayout * layout = new QHBoxLayout();
layout->addWidget(view);
this->setLayout(layout);
timer = new QTimer(this);
connect(timer, SIGNAL(timeout()), this, SLOT(Tick()));
timer->start(0);
worker = new PotentialFieldWorker(&agent, &obstacle, gpu);
worker->start();
time.start();
}
BSplineSurfaceFitterWindow::BSplineSurfaceFitterWindow(Parameters& parameters)
:
Window3(parameters)
{
if (!SetEnvironment())
{
parameters.created = false;
return;
}
mNoCullState = std::make_shared<RasterizerState>();
mNoCullState->cullMode = RasterizerState::CULL_NONE;
mNoCullWireState = std::make_shared<RasterizerState>();
mNoCullWireState->cullMode = RasterizerState::CULL_NONE;
mNoCullWireState->fillMode = RasterizerState::FILL_WIREFRAME;
mBlendState = std::make_shared<BlendState>();
mBlendState->target[0].enable = true;
mBlendState->target[0].srcColor = BlendState::BM_SRC_ALPHA;
mBlendState->target[0].dstColor = BlendState::BM_INV_SRC_ALPHA;
mBlendState->target[0].srcAlpha = BlendState::BM_SRC_ALPHA;
mBlendState->target[0].dstAlpha = BlendState::BM_INV_SRC_ALPHA;
mEngine->SetRasterizerState(mNoCullState);
mEngine->SetClearColor({ 0.0f, 0.5f, 0.75f, 1.0f });
CreateScene();
InitializeCamera();
}
AI::ActionState::Enum A_OpenDoor::Update(AI::ActionInstance* inst, double time)
{
if (GetBrain()->GetMemory()->IsGoToIdle())
{
GetBrain()->GetFSM()->ChangeState("GoNear");
GetBrain()->GetMemory()->SetGoToGoing();
}
else if (GetBrain()->GetMemory()->IsGoToArrived())
{
auto gtc = GetBrain()->GetOwner()->GetLayer()
->FindEntity("terrain")->GetC<GridTerrainComponent>();
gtc->SetEnvironment(
_doorLocation.first, _doorLocation.second, Environment::NONE);
GetBrain()->GetMemory()->Remove(
_doorType, _doorLocation.first, _doorLocation.second);
GetBrain()->GetMemory()->UseKey(
Environment::Enum(Environment::KEY_S +
(_doorType - Environment::DOOR_S)));
return AI::ActionState::SUCCEED;
}
else if (GetBrain()->GetMemory()->IsGoToFailed())
{
return AI::ActionState::FAILED;
}
return AI::ActionState::RUN;
}
Delaunay3DWindow::Delaunay3DWindow(Parameters& parameters)
:
Window3(parameters),
mLightGray({ 0.75f, 0.75f, 0.75f, 1.0f })
{
if (!SetEnvironment() || !CreateScene())
{
parameters.created = false;
return;
}
InitializeCamera();
mNoCullState = std::make_shared<RasterizerState>();
mNoCullState->cullMode = RasterizerState::CULL_NONE;
mNoCullWireState = std::make_shared<RasterizerState>();
mNoCullWireState->cullMode = RasterizerState::CULL_NONE;
mNoCullWireState->fillMode = RasterizerState::FILL_WIREFRAME;
mBlendState = std::make_shared<BlendState>();
mBlendState->target[0].enable = true;
mBlendState->target[0].srcColor = BlendState::BM_SRC_ALPHA;
mBlendState->target[0].dstColor = BlendState::BM_INV_SRC_ALPHA;
mBlendState->target[0].srcAlpha = BlendState::BM_SRC_ALPHA;
mBlendState->target[0].dstAlpha = BlendState::BM_INV_SRC_ALPHA;
}
Fluids3DWindow::Fluids3DWindow(Parameters& parameters)
:
Window3(parameters),
mFluid(mEngine, mProgramFactory, GRID_SIZE, GRID_SIZE, GRID_SIZE, 0.002f)
{
if (!SetEnvironment() || !CreateNestedBoxes())
{
parameters.created = false;
return;
}
// Use blending for the visualization.
mAlphaState = std::make_shared<BlendState>();
mAlphaState->target[0].enable = true;
mAlphaState->target[0].srcColor = BlendState::BM_SRC_ALPHA;
mAlphaState->target[0].dstColor = BlendState::BM_INV_SRC_ALPHA;
mAlphaState->target[0].srcAlpha = BlendState::BM_SRC_ALPHA;
mAlphaState->target[0].dstAlpha = BlendState::BM_INV_SRC_ALPHA;
mEngine->SetBlendState(mAlphaState);
// The alpha channel must be zero for the blending of density to work
// correctly through the fluid region.
mEngine->SetClearColor({ 1.0f, 1.0f, 1.0f, 0.0f });
// The geometric proxies for volume rendering are concentric boxes. They
// are drawn from inside to outside for correctly sorted drawing, so depth
// buffering is not needed.
mNoDepthState = std::make_shared<DepthStencilState>();
mNoDepthState->depthEnable = false;
mEngine->SetDepthStencilState(mNoDepthState);
mFluid.Initialize();
InitializeCamera();
UpdateConstants();
}
StructuredBuffersWindow::StructuredBuffersWindow(Parameters& parameters)
:
Window3(parameters)
{
if (!SetEnvironment() || !CreateScene())
{
parameters.created = false;
return;
}
InitializeCamera();
}
void
FeatureState::Disable(FeatureStatus aStatus, const char* aMessage,
const nsACString& aFailureId)
{
AssertInitialized();
// We should never bother setting an environment status to "enabled," since
// it could override an explicit user decision to disable it.
MOZ_ASSERT(IsFeatureStatusFailure(aStatus));
SetEnvironment(aStatus, aMessage);
SetFailureId(aFailureId);
}
TexturingWindow::TexturingWindow(Parameters& parameters)
:
Window3(parameters)
{
if (!SetEnvironment())
{
parameters.created = false;
return;
}
CreateScene();
InitializeCamera();
}
BlendedAnimationsWindow::BlendedAnimationsWindow(Parameters& parameters)
:
Window3(parameters),
mUpArrowPressed(false),
mShiftPressed(false)
{
if (!SetEnvironment())
{
parameters.created = false;
return;
}
std::string gtePath = mEnvironment.GetVariable("GTE_PATH");
std::string rootPath = gtePath + "/Samples/Graphics/BlendedAnimations/Data/";
SkinController::Updater postUpdate =
[this](std::shared_ptr<VertexBuffer> const& vbuffer)
{
mEngine->Update(vbuffer);
};
mManager = std::make_unique<BipedManager>(rootPath, "Biped", mProgramFactory, postUpdate);
// Set animation information. The counts differ in debug and release
// builds because of the differing frame rates of those builds.
#if defined(_DEBUG)
int idleWalkCount = 100;
int walkCount = 10;
int walkRunCount = 100;
mApplicationTime = 0.0;
mApplicationTimeDelta = 0.01;
#else
int idleWalkCount = 1000;
int walkCount = 100;
int walkRunCount = 1000;
mApplicationTime = 0.0;
mApplicationTimeDelta = 0.001;
#endif
// The idle head turning occurs too frequently (frequency = 1 in the
// original model). Reduce the turning by half.
mManager->SetIdle(0.5, 0.0);
// The walk and run cycles must be aligned properly for blending. A
// phase of 0.2 for the run cycle aligns the biped feet.
mManager->SetRun(1.0, 0.2);
// The initial state is 'idle'.
mManager->Initialize(idleWalkCount, walkCount, walkRunCount);
CreateScene();
InitializeCamera();
}
PickingWindow::PickingWindow(Parameters& parameters)
:
Window3(parameters),
mNumActiveSpheres(0)
{
if (!SetEnvironment())
{
parameters.created = false;
return;
}
CreateScene();
InitializeCamera();
}
MultipleRenderTargetsWindow::MultipleRenderTargetsWindow(Parameters& parameters)
:
Window3(parameters),
mActiveOverlay(0)
{
if (!SetEnvironment() || !CreateScene())
{
parameters.created = false;
return;
}
mEngine->SetClearColor({ 0.75f, 0.75f, 0.75f, 1.0f });
InitializeCamera();
CreateOverlays();
}
MassSprings3DWindow::MassSprings3DWindow(Parameters& parameters)
:
Window3(parameters),
mSimulationTime(0.0f),
mSimulationDelta(0.001f)
{
if (!SetEnvironment() || !CreateMassSpringSystem())
{
parameters.created = false;
return;
}
mWireState = std::make_shared<RasterizerState>();
mWireState->fillMode = RasterizerState::FILL_WIREFRAME;
CreateBoxFaces();
InitializeCamera();
}
//----------------------------------------------------------------------------
PlaneMeshIntersectionWindow::PlaneMeshIntersectionWindow(Parameters& parameters)
:
Window(parameters),
mTextColor(0.0f, 0.0f, 0.0f, 1.0f)
{
if (!SetEnvironment() || !CreateScene())
{
parameters.created = false;
return;
}
mCamera.SetFrustum(60.0f, GetAspectRatio(), 0.1f, 100.0f);
Vector4<float> camPosition(0.0f, 0.0f, -2.5f, 1.0f);
Vector4<float> camDVector(0.0f, 0.0f, 1.0f, 0.0f);
Vector4<float> camUVector(0.0f, 1.0f, 0.0f, 0.0f);
Vector4<float> camRVector = Cross(camDVector, camUVector);
mCamera.SetFrame(camPosition, camDVector, camUVector, camRVector);
mPSTarget.reset(new DrawTarget(2, DF_R32G32B32A32_FLOAT, mXSize, mYSize,
true, false, DF_D24_UNORM_S8_UINT, false));
mPSColor = mPSTarget->GetRTTexture(0);
mPSPlaneConstant = mPSTarget->GetRTTexture(1);
mScreen.reset(new Texture2(DF_R32G32B32A32_FLOAT, mXSize, mYSize));
mScreen->SetUsage(Resource::SHADER_OUTPUT);
mScreen->SetCopyType(Resource::COPY_STAGING_TO_CPU);
mOverlay.reset(new OverlayEffect(mXSize, mYSize, mXSize, mYSize,
SamplerState::MIN_P_MAG_P_MIP_P, SamplerState::CLAMP,
SamplerState::CLAMP, true));
mOverlay->SetTexture(mScreen);
mEngine->SetClearColor(Vector4<float>(1.0f, 1.0f, 1.0f,
std::numeric_limits<float>::max()));
mDrawIntersections->Set("color", mPSColor);
mDrawIntersections->Set("planeConstant", mPSPlaneConstant);
mDrawIntersections->Set("output", mScreen);
EnableCameraMotion(0.01f, 0.001f, 2.0f, 2.0f);
EnableObjectMotion();
}
/**
*******************************************************************************
* @brief Initialize OS
* @param[in] None
* @param[out] None
* @retval None
*
* @par Description
* @details This function is called to initialize OS.
*
* @note You must call this function first,before any other OS API function
*
* @code There is a example for useage of this function,as follows:
* e.g.
* ... // Your target initial code.
*
* OsInit(); // Initial OS.
* CreateTask(...); // Create tasks.
* ...
* OsStart(); // Start multitask.
* @endcode
*******************************************************************************
*/
void CoInitOS(void) {
InitSysTick(); /* Initialize system tick. */
InitInt(); /* Initialize PendSV,SVC,SysTick interrupt */
CreateTCBList(); /* Create TCB list. */
#if CFG_EVENT_EN > 0
CreateEventList(); /* Create event control list. */
#endif
#if CFG_KHEAP_EN > 0
CoCreateKheap(); /* Create kernel heap within user define */
#endif
OsSchedLock(); /* Lock Schedule */
/* Create first task -- IDLE task. */
CoCreateTask( CoIdleTask,
Co_NULL,
CFG_LOWEST_PRIO,
&idle_stk[CFG_IDLE_STACK_SIZE-1],
CFG_IDLE_STACK_SIZE
);
/* Set PSP for CoIdleTask coming in */
SetEnvironment(&idle_stk[CFG_IDLE_STACK_SIZE-1]);
}
//----------------------------------------------------------------------------
StructuredBuffersWindow::StructuredBuffersWindow(Parameters& parameters)
:
Window(parameters),
mTextColor(0.0f, 0.0f, 0.0f, 1.0f)
{
if (!SetEnvironment() || !CreateScene())
{
parameters.created = false;
return;
}
mCamera.SetFrustum(60.0f, GetAspectRatio(), 0.1f, 100.0f);
Vector4<float> camPosition(0.0f, 0.0f, 1.25f, 1.0f);
Vector4<float> camDVector(0.0f, 0.0f, -1.0f, 0.0f);
Vector4<float> camUVector(0.0f, 1.0f, 0.0f, 0.0f);
Vector4<float> camRVector = Cross(camDVector, camUVector);
mCamera.SetFrame(camPosition, camDVector, camUVector, camRVector);
EnableCameraMotion(0.001f, 0.001f, 2.0f, 2.0f);
EnableObjectMotion();
UpdateCW();
}
ConvexHull3DWindow::ConvexHull3DWindow(Parameters& parameters)
:
Window3(parameters),
mFileQuantity(46),
mCurrentFile(1)
{
if (!SetEnvironment())
{
parameters.created = false;
return;
}
mEffect = std::make_shared<VertexColorEffect>(mProgramFactory);
if (!LoadData())
{
parameters.created = false;
return;
}
mWireState = std::make_shared<RasterizerState>();
mWireState->cullMode = RasterizerState::CULL_NONE;
mWireState->fillMode = RasterizerState::FILL_WIREFRAME;
}
void
TestEnvironment( void )
{
DumpEnvironment();
SetEnvironment( "aaaa", "12345" );
SetEnvironment( "aaaa", "1234567890" );
SetEnvironment( "aaaa", "1" );
SetEnvironment( "aaaa", "" );
SetEnvironment( "aaaa", NULL );
SetEnvironment( "AAAA", "12345" );
SetEnvironment( "AAAA", "1234567890" );
SetEnvironment( "AAAA", "1" );
SetEnvironment( "AAAA", "" );
SetEnvironment( "AAAA", NULL );
SetEnvironment( "MMMM", "12345" );
SetEnvironment( "MMMM", "1234567890" );
SetEnvironment( "MMMM", "1" );
SetEnvironment( "MMMM", "" );
SetEnvironment( "MMMM", NULL );
SetEnvironment( "ZZZZ", "12345" );
SetEnvironment( "ZZZZ", "1234567890" );
SetEnvironment( "ZZZZ", "1" );
SetEnvironment( "ZZZZ", "" );
SetEnvironment( "ZZZZ", NULL );
return;
}
