void TextComponent::DrawTextUI(){
if (!impl->mModel){
impl->mModel = gameObject->GetComponent<TextureModelComponent>();
}
Game::AddDrawList(DrawStage::UI, [&](){
if (!impl->mModel)return;
impl->mModel->SetMatrix();
Model& model = *impl->mModel->mModel;
ID3D11DepthStencilState* pBackDS;
UINT ref;
Device::mpImmediateContext->OMGetDepthStencilState(&pBackDS, &ref);
D3D11_DEPTH_STENCIL_DESC descDS = CD3D11_DEPTH_STENCIL_DESC(CD3D11_DEFAULT());
descDS.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
//descDS.DepthFunc = D3D11_COMPARISON_LESS_EQUAL;
descDS.DepthFunc = D3D11_COMPARISON_ALWAYS;
ID3D11DepthStencilState* pDS_tex = NULL;
Device::mpd3dDevice->CreateDepthStencilState(&descDS, &pDS_tex);
Device::mpImmediateContext->OMSetDepthStencilState(pDS_tex, 0);
D3D11_RASTERIZER_DESC descRS = CD3D11_RASTERIZER_DESC(CD3D11_DEFAULT());
descRS.CullMode = D3D11_CULL_BACK;
descRS.FillMode = D3D11_FILL_SOLID;
ID3D11RasterizerState* pRS = NULL;
Device::mpd3dDevice->CreateRasterizerState(&descRS, &pRS);
Device::mpImmediateContext->RSSetState(pRS);
model.Draw(impl->mTexMaterial);
Device::mpImmediateContext->RSSetState(NULL);
if (pRS)pRS->Release();
Device::mpImmediateContext->OMSetDepthStencilState(NULL, 0);
pDS_tex->Release();
Device::mpImmediateContext->OMSetDepthStencilState(pBackDS, ref);
if (pBackDS)pBackDS->Release();
});
}
std::shared_ptr<GraphicsPipelineState> Device::createGraphicsPipelineState(const GraphicsPipelineStateParams& params)
{
ID3D11VertexShader* vertexShader = nullptr;
if (SUCCEEDED(m_device->CreateVertexShader(params.m_vsParams.m_shaderBytecode, params.m_vsParams.m_bytecodeLength, nullptr, &vertexShader)))
{
ID3D11ShaderReflection* vertexShaderReflector = nullptr;
if (SUCCEEDED(D3DReflect(params.m_vsParams.m_shaderBytecode, params.m_vsParams.m_bytecodeLength, IID_ID3D11ShaderReflection, (void**)&vertexShaderReflector)))
{
ID3D11PixelShader* pixelShader = nullptr;
if (SUCCEEDED(m_device->CreatePixelShader(params.m_psParams.m_shaderBytecode, params.m_psParams.m_bytecodeLength, nullptr, &pixelShader)))
{
ID3D11ShaderReflection* pixelShaderReflector = nullptr;
if (SUCCEEDED(D3DReflect(params.m_psParams.m_shaderBytecode, params.m_psParams.m_bytecodeLength, IID_ID3D11ShaderReflection, (void**)&pixelShaderReflector)))
{
CD3D11_DEPTH_STENCIL_DESC depthStencilDesc(D3D11_DEFAULT);
depthStencilDesc.DepthEnable = params.m_depthStencilParams.m_depthEnable;
ID3D11DepthStencilState* depthStencilState = nullptr;
if (SUCCEEDED(m_device->CreateDepthStencilState(&depthStencilDesc, &depthStencilState)))
{
D3D11_INPUT_ELEMENT_DESC layout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
ID3D11InputLayout* inputLayout = nullptr;
if (SUCCEEDED(m_device->CreateInputLayout(layout, ARRAYSIZE(layout), params.m_vsParams.m_shaderBytecode, params.m_vsParams.m_bytecodeLength, &inputLayout)))
{
return std::make_shared<GraphicsPipelineState>(vertexShader, vertexShaderReflector, pixelShader, pixelShaderReflector, depthStencilState, params.m_stencilRef, inputLayout, params.m_primitiveTopologyType);
}
depthStencilState->Release();
}
pixelShaderReflector->Release();
}
pixelShader->Release();
}
vertexShaderReflector->Release();
}
vertexShader->Release();
}
return nullptr;
}
void DeferredRendering::Debug_AlbedoOnly_Rendering(RenderTarget* rt){
Model::mForcedMaterialUseTexture = NULL;
rt->SetRendererTarget();
mModelTexture.Update();
ID3D11DepthStencilState* pBackDS;
UINT ref;
Device::mpImmediateContext->OMGetDepthStencilState(&pBackDS, &ref);
D3D11_DEPTH_STENCIL_DESC descDS = CD3D11_DEPTH_STENCIL_DESC(CD3D11_DEFAULT());
descDS.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
descDS.DepthFunc = D3D11_COMPARISON_ALWAYS;
ID3D11DepthStencilState* pDS_tex = NULL;
Device::mpd3dDevice->CreateDepthStencilState(&descDS, &pDS_tex);
Device::mpImmediateContext->OMSetDepthStencilState(pDS_tex, 0);
D3D11_RASTERIZER_DESC descRS = CD3D11_RASTERIZER_DESC(CD3D11_DEFAULT());
descRS.CullMode = D3D11_CULL_NONE;
descRS.FillMode = D3D11_FILL_SOLID;
ID3D11RasterizerState* pRS = NULL;
Device::mpd3dDevice->CreateRasterizerState(&descRS, &pRS);
Device::mpImmediateContext->RSSetState(pRS);
mModelTexture.Draw(mMaterialDebugDraw);
Device::mpImmediateContext->RSSetState(NULL);
if (pRS)pRS->Release();
Device::mpImmediateContext->OMSetDepthStencilState(NULL, 0);
pDS_tex->Release();
Device::mpImmediateContext->OMSetDepthStencilState(pBackDS, ref);
if (pBackDS)pBackDS->Release();
RenderTarget::NullSetRendererTarget();
mMaterialPostEffect.PSSetShaderResources();
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR cmdLine, int cmdShow)
{
DXTInputHandlerDefault inputHandler;
DXTWindowEventHandlerDefault eventHandler;
DXTWindow window(hInstance, &inputHandler, &eventHandler);
DXTRenderParams params;
params.Extent = { 800, 600 };
params.UseVSync = true;
params.Windowed = true;
HRESULT result;
result = window.Initialize(params, "DXT Example (DirectX 11)");
if (SUCCEEDED(result))
{
ID3D11Device* device;
ID3D11DeviceContext* context;
IDXGISwapChain* swapChain;
result = DXTInitDevice(params, &window, &swapChain, &device, &context);
if (SUCCEEDED(result))
{
eventHandler.SetSwapChain(swapChain);
FLOAT clearColor[] = { 0.5f, 0.5f, 1.0f, 1.0f };
D3D11_INPUT_ELEMENT_DESC inputDesc[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, sizeof(float) * 3, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, sizeof(float) * 5, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
UINT elementCount = 3;
UINT stride = 8 * sizeof(FLOAT);
UINT offset = 0;
UINT indexCount = 0;
FLOAT deltaTime = 0.016f;
DXTSphericalCamera camera;
DXTFirstPersonCameraController cameraController(&camera, &inputHandler);
inputHandler.AddInputInterface(&cameraController);
cameraController.Velocity = 40.0f;
cameraController.RotationVelocity = 0.005f;
camera.Position = DirectX::XMFLOAT3(20.0f, 20.0f, 20.0f);
camera.LookAt(DirectX::XMFLOAT3(0.0f, 0.0f, 0.0f));
ID3D11RenderTargetView* renderTargetView;
ID3D11Texture2D* depthBuffer;
ID3D11DepthStencilView* depthBufferView;
ID3D11VertexShader* vertexShader;
ID3D11PixelShader* pixelShader;
DXTBytecodeBlob vertexBytecode;
ID3D11DepthStencilState* depthState;
ID3D11RasterizerState* rasterizerState;
ID3D11Buffer* vertexBuffer;
ID3D11Buffer* indexBuffer;
ID3D11InputLayout* inputLayout;
ID3D11Buffer* transformBuffer;
DXTCreateRenderTargetFromBackBuffer(swapChain, device, &renderTargetView);
DXTCreateDepthStencilBuffer(device, params.Extent.Width, params.Extent.Height, DXGI_FORMAT_D24_UNORM_S8_UINT, &depthBuffer, &depthBufferView);
DXTVertexShaderFromFile(device, "VertexShader.cso", &vertexShader, &vertexBytecode);
DXTPixelShaderFromFile(device, "PixelShader.cso", &pixelShader);
DXTCreateDepthStencilStateDepthTestEnabled(device, &depthState);
DXTCreateRasterizerStateSolid(device, &rasterizerState);
DXTLoadStaticMeshFromFile(device, "mesh.ase", DXTVertexAttributePosition | DXTVertexAttributeUV | DXTVertexAttributeNormal,
DXTIndexTypeShort, &vertexBuffer, &indexBuffer, &indexCount);
DXTCreateBuffer(device, sizeof(DirectX::XMFLOAT4X4) * 2, D3D11_BIND_CONSTANT_BUFFER, D3D11_CPU_ACCESS_WRITE, D3D11_USAGE_DYNAMIC, &transformBuffer);
device->CreateInputLayout(inputDesc, elementCount, vertexBytecode.Bytecode, vertexBytecode.BytecodeLength, &inputLayout);
vertexBytecode.Destroy();
window.Present(false);
while (!window.QuitMessageReceived())
{
window.MessagePump();
if (inputHandler.IsKeyDown(VK_ESCAPE))
break;
cameraController.Update(deltaTime);
XMFLOAT4X4 ViewProj;
XMFLOAT4X4 World;
camera.GetViewProjectionMatrix(&ViewProj, params.Extent);
XMStoreFloat4x4(&World, XMMatrixIdentity());
D3D11_MAPPED_SUBRESOURCE subres;
context->Map(transformBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &subres);
XMFLOAT4X4* ptr = (XMFLOAT4X4*)subres.pData;
ptr[0] = World;
ptr[1] = ViewProj;
context->Unmap(transformBuffer, 0);
D3D11_VIEWPORT viewport = { 0.0f, 0.0f, (FLOAT)params.Extent.Width, (FLOAT)params.Extent.Height, 0.0f, 1.0f };
context->ClearRenderTargetView(renderTargetView, clearColor);
context->ClearDepthStencilView(depthBufferView, D3D11_CLEAR_DEPTH, 1.0f, 0);
context->OMSetDepthStencilState(depthState, 0);
context->OMSetRenderTargets(1, &renderTargetView, depthBufferView);
context->RSSetState(rasterizerState);
context->RSSetViewports(1, &viewport);
context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
context->IASetVertexBuffers(0, 1, &vertexBuffer, &stride, &offset);
context->IASetIndexBuffer(indexBuffer, DXGI_FORMAT_R16_UINT, 0);
context->IASetInputLayout(inputLayout);
context->VSSetShader(vertexShader, nullptr, 0);
context->PSSetShader(pixelShader, nullptr, 0);
context->VSSetConstantBuffers(0, 1, &transformBuffer);
context->DrawIndexed(indexCount, 0, 0);
swapChain->Present(1, 0);
}
swapChain->SetFullscreenState(false, nullptr);
transformBuffer->Release();
depthBufferView->Release();
depthBuffer->Release();
inputLayout->Release();
vertexBuffer->Release();
indexBuffer->Release();
depthState->Release();
rasterizerState->Release();
vertexShader->Release();
pixelShader->Release();
renderTargetView->Release();
swapChain->Release();
context->Release();
device->Release();
}
window.Destroy();
}
}
// Depth test and stencil
HRESULT displayDevice::InitDepthStencil()
{
HRESULT hr;
ID3D11Texture2D* pDepthStencil = NULL;
D3D11_TEXTURE2D_DESC descDepth;
descDepth.Width = screenWidth;
descDepth.Height = screenHeight;
descDepth.MipLevels = 1;
descDepth.ArraySize = 1;
descDepth.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
descDepth.SampleDesc.Count = 1;
descDepth.SampleDesc.Quality = 0;
descDepth.Usage = D3D11_USAGE_DEFAULT;
descDepth.BindFlags = D3D11_BIND_DEPTH_STENCIL;
descDepth.CPUAccessFlags = 0;
descDepth.MiscFlags = 0;
hr = dev->CreateTexture2D(&descDepth, NULL, &pDepthStencil);
D3D11_DEPTH_STENCIL_DESC dsDesc;
// Depth test parameters
dsDesc.DepthEnable = true;
dsDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
dsDesc.DepthFunc = D3D11_COMPARISON_LESS_EQUAL;
// Stencil test parameters
dsDesc.StencilEnable = false;
dsDesc.StencilReadMask = 0xFF;
dsDesc.StencilWriteMask = 0xFF;
// Stencil operations if pixel is front-facing
dsDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
dsDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
dsDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
dsDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// Stencil operations if pixel is back-facing
dsDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
dsDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
dsDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
dsDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// Create depth stencil state
ID3D11DepthStencilState * pDSState;
dev->CreateDepthStencilState(&dsDesc, &pDSState);
// Bind depth stencil state
devContext->OMSetDepthStencilState(pDSState, 1);
pDSState->Release();
D3D11_DEPTH_STENCIL_VIEW_DESC descDSV;
descDSV.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
descDSV.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
descDSV.Flags = 0;
descDSV.Texture2D.MipSlice = 0;
// Create the depth stencil view
hr = dev->CreateDepthStencilView(pDepthStencil, // Depth stencil texture
&descDSV, // Depth stencil desc
&depthStencilView); // [out] Depth stencil view
if (FAILED(hr)) return hr;
pDepthStencil->Release();
return S_OK;
}
/* Initialize DirectX11 Graphics */
void nlInitD3D11( HWND hWnd, bool isFullScreen, nlEngineContext& cxt )
{
cxt.hwnd = hWnd;
IDXGIAdapter* pAdapter = NULL;
IDXGIDevice1* pDXGI = NULL;
IDXGIFactory* pDXGIFactory = NULL;
D3D_FEATURE_LEVEL fl;
/* FeatureLevelは10.1(SM4.0)で固定する */
const D3D_FEATURE_LEVEL featureLevel = D3D_FEATURE_LEVEL_10_0;
NL_HR_VALID( D3D11CreateDevice( NULL, D3D_DRIVER_TYPE_HARDWARE,(HMODULE)0,0,&featureLevel,1, D3D11_SDK_VERSION, &cxt.d3dDevice, &fl, &cxt.d3dContext ) );
NL_HR_ASSSERT( fl == D3D_FEATURE_LEVEL_10_0 );
/* create DXGI */
NL_HR_VALID( cxt.d3dDevice->QueryInterface(__uuidof(IDXGIDevice1), (void**)&pDXGI) );
/* get adapter info */
NL_HR_VALID( pDXGI->GetAdapter(&pAdapter) );
NL_HR_ASSSERT( pAdapter != NULL );
/* get factory */
NL_HR_VALID( pAdapter->GetParent( __uuidof(IDXGIFactory), (void**)&pDXGIFactory) );
NL_HR_ASSSERT( pDXGIFactory != NULL );
{/* create swap chain */
DXGI_SWAP_CHAIN_DESC swapChainDesc =
{
/* DXGI_MODE_DESC */
{cxt.rendertargets[0].width_, cxt.rendertargets[0].height_, {60,1}, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED, DXGI_MODE_SCALING_UNSPECIFIED },
/* DXGI_SAMPLE_DESC */
{1, 0},
/* BufferUsage */
DXGI_USAGE_RENDER_TARGET_OUTPUT,
/* BufferCount */
3,
/* OutputWindow */
hWnd,
/* Windowed */
!isFullScreen,
/* DXGI_SWAP_EFFECT */
DXGI_SWAP_EFFECT_DISCARD,
/* Flags */
DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH,
};
NL_HR_VALID( pDXGIFactory->CreateSwapChain(cxt.d3dDevice, &swapChainDesc, &cxt.dxgiSwpChain) );
}
/* Disalbe "Alt+Enter" and so on. must call this after CreateSwapChain() call MakeWindowAssociation(). */
NL_HR_VALID( pDXGIFactory->MakeWindowAssociation(hWnd, DXGI_MWA_NO_WINDOW_CHANGES | DXGI_MWA_NO_ALT_ENTER | DXGI_MWA_NO_PRINT_SCREEN ));
{/* get backbuffer view */
D3D11_TEXTURE2D_DESC desc;
cxt.rendertargets[0].renderTargetShaderResource_ = NULL;
NL_HR_VALID( cxt.dxgiSwpChain->GetBuffer( 0, __uuidof(ID3D11Texture2D), (void**)(&cxt.rendertargets[0].renderTarget_) ) );
NL_HR_VALID( cxt.d3dDevice->CreateRenderTargetView( cxt.rendertargets[0].renderTarget_, NULL, &cxt.rendertargets[0].renderTargetView_ ) );
cxt.rendertargets[0].renderTarget_->GetDesc( &desc );
cxt.rendertargets[0].width_ = desc.Width;
cxt.rendertargets[0].height_ = desc.Height;
}
{/* create and set depthStencil */
D3D11_TEXTURE2D_DESC depthDesc =
{
/*UINT Width;*/
cxt.rendertargets[0].width_,
/*UINT Height;*/
cxt.rendertargets[0].height_,
/*UINT MipLevels;*/
1,
/*UINT ArraySize;*/
1,
/*DXGI_FORMAT Format;*/
DXGI_FORMAT_D24_UNORM_S8_UINT,
/*DXGI_SAMPLE_DESC SampleDesc;*/
{1,0},
/*D3D11_USAGE Usage;*/
D3D11_USAGE_DEFAULT,
/*UINT BindFlags;*/
D3D11_BIND_DEPTH_STENCIL,
/*UINT CPUAccessFlags;*/
0,
/*UINT MiscFlags;*/
0,
};
D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc =
{
/* DXGI_FORMAT Format; */
DXGI_FORMAT_D24_UNORM_S8_UINT,
/* D3D11_DSV_DIMENSION ViewDimension; */
D3D11_DSV_DIMENSION_TEXTURE2DMS,
/* UINT Flags; */
0,
/* D3D11_TEX2D_DSV */
{0}
};
cxt.depthStencils[0].width = depthDesc.Width;
cxt.depthStencils[0].height = depthDesc.Height;
NL_HR_VALID( cxt.d3dDevice->CreateTexture2D(&depthDesc, NULL, &cxt.depthStencils[0].tex ) );
NL_HR_VALID( cxt.d3dDevice->CreateDepthStencilView(cxt.depthStencils[0].tex, &dsvDesc, &cxt.depthStencils[0].view) );
}
cxt.d3dContext->OMSetRenderTargets(1, &cxt.rendertargets[0].renderTargetView_, cxt.depthStencils[0].view );
/* デフォルトの設定 */
D3D11_VIEWPORT viewportDesc =
{
/* FLOAT TopLeftX; */
0.0f,
/* FLOAT TopLeftY; */
0.0f,
/* FLOAT Width; */
(FLOAT)cxt.rendertargets[0].width_,
/* FLOAT Height; */
(FLOAT)cxt.rendertargets[0].height_,
/* FLOAT MinDepth; */
0.0f,
/* FLOAT MaxDepth; */
1.0f,
};
cxt.viewportDesc = viewportDesc;
nlUpdateViewPortSetting(cxt);
/**/
D3D11_RASTERIZER_DESC rasterDesc =
{
/* D3D11_FILL_MODE FillMode; */
D3D11_FILL_SOLID,
/* D3D11_CULL_MODE CullMode; */
D3D11_CULL_NONE,
/* BOOL FrontCounterClockwise; */
0,
/* INT DepthBias; */
0,
/* FLOAT DepthBiasClamp; */
0,
/* FLOAT SlopeScaledDepthBias; */
0,
/* BOOL DepthClipEnable; */
TRUE,
/* BOOL ScissorEnable; */
0,
/* BOOL MultisampleEnable; */
0,
/* BOOL AntialiasedLineEnable; */
0
};
cxt.rasterDesc = rasterDesc;
nlUpdateRasterizeSetting(cxt);
/**/
D3D11_DEPTH_STENCIL_DESC depthStencilDesc =
{
/* BOOL DepthEnable; */
TRUE,
/* D3D11_DEPTH_WRITE_MASK DepthWriteMask; */
D3D11_DEPTH_WRITE_MASK_ALL,
/* D3D11_COMPARISON_FUNC DepthFunc; */
D3D11_COMPARISON_LESS,
/* BOOL StencilEnable; */
FALSE,
/* UINT8 StencilReadMask; */
0,
/* UINT8 StencilWriteMask; */
0,
/* D3D11_DEPTH_STENCILOP_DESC FrontFace; ダミーデータであることに注意*/
{ D3D11_STENCIL_OP_KEEP, D3D11_STENCIL_OP_KEEP, D3D11_STENCIL_OP_KEEP, D3D11_COMPARISON_NEVER },
/* D3D11_DEPTH_STENCILOP_DESC BackFace; */
{ D3D11_STENCIL_OP_KEEP, D3D11_STENCIL_OP_KEEP, D3D11_STENCIL_OP_KEEP, D3D11_COMPARISON_NEVER },
};
ID3D11DepthStencilState* depthStencilState;
cxt.d3dDevice->CreateDepthStencilState(&depthStencilDesc, &depthStencilState );
cxt.d3dContext->OMSetDepthStencilState(depthStencilState, 0);
depthStencilState->Release();
/**/
D3D11_SAMPLER_DESC samplerDesc =
{
/*D3D11_FILTER Filter;*/
D3D11_FILTER_MIN_MAG_MIP_LINEAR,
/* D3D11_TEXTURE_ADDRESS_MODE AddressU;*/
D3D11_TEXTURE_ADDRESS_WRAP,
/* D3D11_TEXTURE_ADDRESS_MODE AddressV;*/
D3D11_TEXTURE_ADDRESS_WRAP,
/* D3D11_TEXTURE_ADDRESS_MODE AddressW;*/
D3D11_TEXTURE_ADDRESS_WRAP,
/* FLOAT MipLODBias;*/
0.0f,
/* UINT MaxAnisotropy;*/
1,
/* D3D11_COMPARISON_FUNC ComparisonFunc;*/
D3D11_COMPARISON_ALWAYS,
/* FLOAT BorderColor[ 4 ];*/
{0.0f,0.0f,0.0f,0.0f},
/* FLOAT MinLOD;*/
0,
/* FLOAT MaxLOD;*/
D3D11_FLOAT32_MAX,
};
cxt.samplerDesc = samplerDesc;
/**/
nlUpdateSamplerState(cxt);
}
