//----------------------------------------------------------------------------
bool WireMeshWindow::CreateScene()
{
std::string path = mEnvironment.GetPath("WireMesh.hlsl");
std::shared_ptr<VertexShader> vshader(ShaderFactory::CreateVertex(path));
if (!vshader)
{
return false;
}
std::shared_ptr<GeometryShader> gshader(ShaderFactory::CreateGeometry(
path));
if (!gshader)
{
return false;
}
std::shared_ptr<PixelShader> pshader(ShaderFactory::CreatePixel(path));
if (!pshader)
{
return false;
}
std::shared_ptr<ConstantBuffer> parameters(
new ConstantBuffer(3 * sizeof(Vector4<float>), false));
Vector4<float>* data = parameters->Get<Vector4<float>>();
data[0] = Vector4<float>(0.0f, 0.0f, 1.0f, 1.0f); // mesh color
data[1] = Vector4<float>(0.0f, 0.0f, 0.0f, 1.0f); // edge color
data[2] = Vector4<float>((float)mXSize, (float)mYSize, 0.0f, 0.0f);
vshader->Set("WireParameters", parameters);
gshader->Set("WireParameters", parameters);
pshader->Set("WireParameters", parameters);
std::shared_ptr<ConstantBuffer> cbuffer(
new ConstantBuffer(sizeof(Matrix4x4<float>), true));
vshader->Set("PVWMatrix", cbuffer);
std::shared_ptr<VisualEffect> effect(new VisualEffect(vshader, pshader,
gshader));
VertexFormat vformat;
vformat.Bind(VA_POSITION, DF_R32G32B32_FLOAT, 0);
MeshFactory mf;
mf.SetVertexFormat(vformat);
mMesh = mf.CreateSphere(16, 16, 1.0f);
mMesh->SetEffect(effect);
mMesh->Update();
SubscribeCW(mMesh, cbuffer);
return true;
}
bool MultipleRenderTargetsWindow::CreateScene()
{
// Create a visual effect that populates the draw target.
std::string filename = mEnvironment.GetPath("MultipleRenderTargets.hlsl");
std::shared_ptr<VisualProgram> program =
mProgramFactory.CreateFromFiles(filename, filename, "");
if (!program)
{
return false;
}
std::shared_ptr<ConstantBuffer> cbuffer(new ConstantBuffer(
sizeof(Matrix4x4<float>), true));
program->GetVShader()->Set("PVWMatrix", cbuffer);
std::shared_ptr<PixelShader> pshader = program->GetPShader();
std::shared_ptr<ConstantBuffer> farNearRatio(new ConstantBuffer(
sizeof(float), false));
pshader->Set("FarNearRatio", farNearRatio);
farNearRatio->SetMember("farNearRatio",
mCamera->GetDMax() / mCamera->GetDMin());
std::string path = mEnvironment.GetPath("StoneWall.png");
std::shared_ptr<Texture2> baseTexture(WICFileIO::Load(path, true));
baseTexture->AutogenerateMipmaps();
pshader->Set("baseTexture", baseTexture);
std::shared_ptr<SamplerState> baseSampler(new SamplerState());
baseSampler->filter = SamplerState::MIN_L_MAG_L_MIP_L;
baseSampler->mode[0] = SamplerState::CLAMP;
baseSampler->mode[1] = SamplerState::CLAMP;
pshader->Set("baseSampler", baseSampler);
std::shared_ptr<VisualEffect> effect =
std::make_shared<VisualEffect>(program);
// Create a vertex buffer for a two-triangle square. The PNG is stored
// in left-handed coordinates. The texture coordinates are chosen to
// reflect the texture in the y-direction.
struct Vertex
{
Vector3<float> position;
Vector2<float> tcoord;
};
VertexFormat vformat;
vformat.Bind(VA_POSITION, DF_R32G32B32_FLOAT, 0);
vformat.Bind(VA_TEXCOORD, DF_R32G32_FLOAT, 0);
std::shared_ptr<VertexBuffer> vbuffer(new VertexBuffer(vformat, 4));
Vertex* vertex = vbuffer->Get<Vertex>();
vertex[0].position = { -1.0f, -1.0f, 0.0f };
vertex[0].tcoord = { 0.0f, 1.0f };
vertex[1].position = { 1.0f, -1.0f, 0.0f };
vertex[1].tcoord = { 1.0f, 1.0f };
vertex[2].position = { -1.0f, 1.0f, 0.0f };
vertex[2].tcoord = { 0.0f, 0.0f };
vertex[3].position = { 1.0f, 1.0f, 0.0f };
vertex[3].tcoord = { 1.0f, 0.0f };
// Create an indexless buffer for a triangle mesh with two triangles.
std::shared_ptr<IndexBuffer> ibuffer(new IndexBuffer(IP_TRISTRIP, 2));
// Create the geometric object for drawing and enable automatic updates
// of pvw-matrices and w-matrices.
mSquare = std::make_shared<Visual>(vbuffer, ibuffer, effect);
mTrackball.Attach(mSquare);
mTrackball.Update();
mCameraRig.Subscribe(mSquare->worldTransform, cbuffer);
return true;
}
operator boost::asio::const_buffer() const {
return cbuffer();
}
//----------------------------------------------------------------------------
bool StructuredBuffersWindow::CreateScene()
{
// Create the shaders and associated resources
HLSLDefiner definer;
definer.SetInt("WINDOW_WIDTH", mXSize);
std::shared_ptr<VertexShader> vshader(ShaderFactory::CreateVertex(
mEnvironment.GetPath("StructuredBuffers.hlsl"), definer));
if (!vshader)
{
return false;
}
std::shared_ptr<PixelShader> pshader(ShaderFactory::CreatePixel(
mEnvironment.GetPath("StructuredBuffers.hlsl"), definer));
if (!pshader)
{
return false;
}
std::shared_ptr<ConstantBuffer> cbuffer(new ConstantBuffer(
sizeof(Matrix4x4<float>), true));
vshader->Set("PVWMatrix", cbuffer);
// Create the pixel shader and associated resources.
std::string path = mEnvironment.GetPath("StoneWall.png");
std::shared_ptr<Texture2> baseTexture(WICFileIO::Load(path, false));
pshader->Set("baseTexture", baseTexture);
std::shared_ptr<SamplerState> baseSampler(new SamplerState());
baseSampler->filter = SamplerState::MIN_L_MAG_L_MIP_P;
baseSampler->mode[0] = SamplerState::CLAMP;
baseSampler->mode[1] = SamplerState::CLAMP;
pshader->Set("baseSampler", baseSampler);
mDrawnPixels.reset(new StructuredBuffer(mXSize*mYSize,
sizeof(Vector4<float>)));
mDrawnPixels->SetUsage(Resource::SHADER_OUTPUT);
mDrawnPixels->SetCopyType(Resource::COPY_BIDIRECTIONAL);
memset(mDrawnPixels->GetData(), 0, mDrawnPixels->GetNumBytes());
pshader->Set("drawnPixels", mDrawnPixels);
// Create the visual effect for the square.
std::shared_ptr<VisualEffect> effect(new VisualEffect(vshader, pshader));
// Create a vertex buffer for a single triangle. The PNG is stored in
// left-handed coordinates. The texture coordinates are chosen to reflect
// the texture in the y-direction.
struct Vertex
{
Vector3<float> position;
Vector2<float> tcoord;
};
VertexFormat vformat;
vformat.Bind(VA_POSITION, DF_R32G32B32_FLOAT, 0);
vformat.Bind(VA_TEXCOORD, DF_R32G32_FLOAT, 0);
std::shared_ptr<VertexBuffer> vbuffer(new VertexBuffer(vformat, 4));
Vertex* vertex = vbuffer->Get<Vertex>();
vertex[0].position = Vector3<float>(0.0f, 0.0f, 0.0f);
vertex[0].tcoord = Vector2<float>(0.0f, 1.0f);
vertex[1].position = Vector3<float>(1.0f, 0.0f, 0.0f);
vertex[1].tcoord = Vector2<float>(1.0f, 1.0f);
vertex[2].position = Vector3<float>(0.0f, 1.0f, 0.0f);
vertex[2].tcoord = Vector2<float>(0.0f, 0.0f);
vertex[3].position = Vector3<float>(1.0f, 1.0f, 0.0f);
vertex[3].tcoord = Vector2<float>(1.0f, 0.0f);
// Create an indexless buffer for a triangle mesh with two triangles.
std::shared_ptr<IndexBuffer> ibuffer(new IndexBuffer(IP_TRISTRIP, 2));
// Create the geometric object for drawing. Translate it so that its
// center of mass is at the origin. This supports virtual trackball
// motion about the object "center".
mSquare.reset(new Visual(vbuffer, ibuffer, effect));
mSquare->localTransform.SetTranslation(-0.5f, -0.5f, 0.0f);
mSquare->Update();
// Enable automatic updates of pvw-matrices and w-matrices.
SubscribeCW(mSquare, cbuffer);
// The structured buffer is written in the pixel shader. This texture
// will receive a copy of it so that we can write the results to disk
// as a PNG file.
mDrawnPixelsTexture = new Texture2(DF_R8G8B8A8_UNORM, mXSize, mYSize);
return true;
}
int Layer_D3D::renderAllProps(int layerIndex)
{
assertmsg( viewport != nullptr, "no viewport in a layer id:%d setViewport missed?", id );
m_layerIndex = layerIndex;
if( viewport->dimension == DIMENSION_2D )
{
XMMATRIX orthoProjMatrix = XMMatrixOrthographicLH(viewport->scl.x, viewport->scl.y, 0.0f, 1000.0f);
XMMATRIX identityMatrix = XMMatrixIdentity();
CBufferMVP cbuffer(identityMatrix, orthoProjMatrix);
D3D11_MAPPED_SUBRESOURCE map;
g_context.m_pDeviceContext->Map(m_pMatrixConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &map);
memcpy(map.pData, &cbuffer, sizeof(CBufferMVP));
g_context.m_pDeviceContext->Unmap(m_pMatrixConstantBuffer, 0);
g_context.m_pDeviceContext->VSSetConstantBuffers(0, 1, &m_pMatrixConstantBuffer);
g_context.m_pDeviceContext->PSSetConstantBuffers(0, 1, &m_pMatrixConstantBuffer);
static SorterEntry tosort[1024*32];
int cnt = 0;
Prop *cur = prop_top;
Vec2 minv, maxv;
viewport->getMinMax(&minv, &maxv);
while(cur)
{
Prop2D_D3D *cur2d = (Prop2D_D3D*)cur;
assert( cur2d->dimension == viewport->dimension );
// culling
float camx=0,camy=0;
if(camera)
{
camx = camera->loc.x;
camy = camera->loc.y;
}
float scr_maxx = cur2d->loc.x - camx + cur2d->scl.x/2 + cur2d->max_rt_cache.x;
float scr_minx = cur2d->loc.x - camx - cur2d->scl.x/2 + cur2d->min_lb_cache.x;
float scr_maxy = cur2d->loc.y - camy + cur2d->scl.y/2 + cur2d->max_rt_cache.y;
float scr_miny = cur2d->loc.y - camy - cur2d->scl.y/2 + cur2d->min_lb_cache.y;
if( scr_maxx >= minv.x && scr_minx <= maxv.x && scr_maxy >= minv.y && scr_miny <= maxv.y )
{
tosort[cnt].val = cur2d->priority;
tosort[cnt].ptr = cur2d;
cnt++;
if(cnt>= elementof(tosort))
{
print("WARNING: too many props in a layer : %d", cnt );
break;
}
}
cur = cur->next;
}
quickSortF( tosort, 0, cnt-1 );
for(int i=0;i<cnt;i++)
{
Prop2D_D3D *p = (Prop2D_D3D*) tosort[i].ptr;
if(p->visible)
{
p->render(camera);
}
}
return sendDrawCalls();
}
else // 3D
{
return 0;
}
}
bool TextureArraysWindow::CreateScene()
{
// Create the shaders and associated resources.
std::string filename = mEnvironment.GetPath("TextureArrays.hlsl");
std::shared_ptr<VisualProgram> program =
mProgramFactory.CreateFromFiles(filename, filename, "");
if (!program)
{
return false;
}
// Create a vertex buffer for a single triangle. The PNG is stored in
// left-handed coordinates. The texture coordinates are chosen to reflect
// the texture in the y-direction.
struct Vertex
{
Vector3<float> position;
Vector2<float> tcoord;
};
VertexFormat vformat;
vformat.Bind(VA_POSITION, DF_R32G32B32_FLOAT, 0);
vformat.Bind(VA_TEXCOORD, DF_R32G32_FLOAT, 0);
std::shared_ptr<VertexBuffer> vbuffer(new VertexBuffer(vformat, 4));
Vertex* vertex = vbuffer->Get<Vertex>();
vertex[0].position = { 0.0f, 0.0f, 0.0f };
vertex[0].tcoord = { 0.0f, 1.0f };
vertex[1].position = { 1.0f, 0.0f, 0.0f };
vertex[1].tcoord = { 1.0f, 1.0f };
vertex[2].position = { 0.0f, 1.0f, 0.0f };
vertex[2].tcoord = { 0.0f, 0.0f };
vertex[3].position = { 1.0f, 1.0f, 0.0f };
vertex[3].tcoord = { 1.0f, 0.0f };
// Create an indexless buffer for a triangle mesh with two triangles.
std::shared_ptr<IndexBuffer> ibuffer(new IndexBuffer(IP_TRISTRIP, 2));
// Create an effect for the vertex and pixel shaders. The texture is
// bilinearly filtered and the texture coordinates are clamped to [0,1]^2.
std::shared_ptr<ConstantBuffer> cbuffer(new ConstantBuffer(
sizeof(Matrix4x4<float>), true));
program->GetVShader()->Set("PVWMatrix", cbuffer);
std::shared_ptr<PixelShader> pshader = program->GetPShader();
std::shared_ptr<Texture1Array> t1array(new Texture1Array(2,
DF_R8G8B8A8_UNORM, 2));
unsigned int* t1data = t1array->Get<unsigned int>();
t1data[0] = 0xFF000000;
t1data[1] = 0xFFFFFFFF;
pshader->Set("myTexture1", t1array);
Texture2* stoneTexture = WICFileIO::Load(
mEnvironment.GetPath("StoneWall.png"), false);
std::shared_ptr<Texture2Array> t2array(new Texture2Array(2,
DF_R8G8B8A8_UNORM, 256, 256));
unsigned char* t2data = t2array->Get<unsigned char>();
size_t const numBytes = stoneTexture->GetNumBytes();
Memcpy(t2data, stoneTexture->GetData(), numBytes);
t2data += numBytes;
delete stoneTexture;
for (size_t i = 0; i < numBytes; ++i)
{
*t2data++ = static_cast<unsigned char>(rand() % 256);
}
pshader->Set("myTexture2", t2array);
std::shared_ptr<SamplerState> samplerState(new SamplerState());
samplerState->filter = SamplerState::MIN_L_MAG_L_MIP_P;
samplerState->mode[0] = SamplerState::CLAMP;
samplerState->mode[1] = SamplerState::CLAMP;
pshader->Set("mySampler", samplerState);
std::shared_ptr<VisualEffect> effect =
std::make_shared<VisualEffect>(program);
// Create the geometric object for drawing. Translate it so that its
// center of mass is at the origin. This supports virtual trackball
// motion about the object "center".
mSquare = std::make_shared<Visual>(vbuffer, ibuffer, effect);
mSquare->localTransform.SetTranslation(-0.5f, -0.5f, 0.0f);
// Enable automatic updates of pvw-matrices and w-matrices.
mCameraRig.Subscribe(mSquare->worldTransform, cbuffer);
mTrackball.Attach(mSquare);
mTrackball.Update();
return true;
}
