void ShaderCompiler::parseConstantBuffers(ID3D12ShaderReflection* reflect, const D3D12_SHADER_DESC& progDesc, std::weak_ptr<DX12DeviceContext> context)
    {
        for (uint_fast32_t i = 0; i < progDesc.ConstantBuffers; ++i) {
            auto cb = reflect->GetConstantBufferByIndex(i);
            D3D12_SHADER_BUFFER_DESC cbDesc;

            cb->GetDesc(&cbDesc);

            LOGS << "Constant buffer : " << cbDesc.Name;

            auto& cbuffer = context.lock()->CreateConstanBuffer(cbDesc.Name);

            for (uint_fast32_t j = 0; j < cbDesc.Variables; ++j) {
                auto var = cb->GetVariableByIndex(j);
                D3D12_SHADER_VARIABLE_DESC vardesc;

                var->GetDesc(&vardesc);

                auto fmt = boost::format("CB var : %1%, Offset: %2%, Size: %3%") % vardesc.Name % vardesc.StartOffset % vardesc.Size;
                LOGS << boost::str(fmt);

                cbuffer.addVariable(vardesc.Name, vardesc.StartOffset, vardesc.Size);
            }
        }
    }

void RenderTarget::CreateDepthRenderbuffer()
{
	assert(!GetDesc().allowDepthTexture);
	assert(m_active);
	m_depthRenderBuffer.Reset(new RenderBuffer());
	m_depthRenderBuffer->Bind();
	glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, GetDesc().width, GetDesc().height);
	m_depthRenderBuffer->Attach(GL_DEPTH_ATTACHMENT_EXT);
	m_depthRenderBuffer->Unbind();
}

	PooledTextureRef ImageBasedLensFlare::Setup(const Ptr<Texture> & brightPassTex)
	{
		auto setupTexRef = TexturePool::Instance().FindFree({ TEXTURE_2D, brightPassTex->GetDesc() });
		auto setupTex = setupTexRef->Get()->Cast<Texture>();

		Global::GetRenderEngine()->GetRenderContext()->ClearRenderTarget(setupTex->GetRenderTargetView(0, 0, 1), 0.0f);

		auto ps = Shader::FindOrCreate<LensFlareSetupPS>();

		Global::GetRenderEngine()->GetRenderContext()->SetBlendState(
			BlendStateTemplate<false, false, true, BLEND_PARAM_ONE, BLEND_PARAM_ONE, BLEND_OP_ADD>::Get());

		int2 texSize = int2(setupTex->GetDesc().width / 2, setupTex->GetDesc().height / 2);
		int2 center = texSize;

		for (int i = 0; i < 3; ++i)
		{
			int2 xy = center - texSize / 2;

			ps->SetSRV("brightPassTex", brightPassTex->GetShaderResourceView());
			ps->SetSampler("linearSampler", SamplerTemplate<>::Get());
			ps->Flush();

			DrawQuad({ setupTex->GetRenderTargetView(0, 0, 1) }, 
				(float)xy.x(), (float)xy.y(), (float)texSize.x(), (float)texSize.y());

			texSize /= 2;
		}

		for (int i = 0; i < 5; ++i)
		{
			int2 xy = center - texSize / 2;

			ps->SetSRV("brightPassTex", brightPassTex->GetShaderResourceView());
			ps->SetSampler("linearSampler", SamplerTemplate<>::Get());
			ps->Flush();

			DrawQuad({ setupTex->GetRenderTargetView(0, 0, 1) }, 
				(float)xy.x(), (float)xy.y(), (float)texSize.x(), (float)texSize.y(),
				1.0f, 1.0f, -1.0f, -1.0f);

			texSize *= 2;
		}

		Global::GetRenderEngine()->GetRenderContext()->SetBlendState(nullptr);

		return setupTexRef;
	}

void CProfiler::BuildTree(HWND m_hTree,IProfileNode *pNode,HTREEITEM hItem)
{
    if(!pNode)return;

    char szMsg[256];
    GetDesc(szMsg,pNode);

    char szItem[512];
    char *pName = (char*)pNode->GetName();
    if(!pName)return;

    int iSize = strlen(pName);
    strcpy(szItem,pNode->GetName());
    for(int k = 0; k < 32 - iSize; k++)
    {
        strcat(szItem," ");
    }
    strcat(szItem,szMsg);

    HTREEITEM hNow = InsertItem(m_hTree,hItem,szItem);

    TreeView_Expand(m_hTree,hItem,TVE_EXPAND);

    IProfileNode *pChild = pNode->GetChild();
    if(pChild)
    {
        while(pChild)
        {
            BuildTree(m_hTree,pChild,hNow);
            pChild = pChild->GetSibling();
        }
    }
}

void
FontFace::GetDesc(nsCSSFontDesc aDescID,
                  nsCSSProperty aPropID,
                  nsString& aResult) const
{
  MOZ_ASSERT(aDescID == eCSSFontDesc_UnicodeRange ||
             aPropID != eCSSProperty_UNKNOWN,
             "only pass eCSSProperty_UNKNOWN for eCSSFontDesc_UnicodeRange");

  nsCSSValue value;
  GetDesc(aDescID, value);

  aResult.Truncate();

  // Fill in a default value for missing descriptors.
  if (value.GetUnit() == eCSSUnit_Null) {
    if (aDescID == eCSSFontDesc_UnicodeRange) {
      aResult.AssignLiteral("U+0-10FFFF");
    } else if (aDescID != eCSSFontDesc_Family &&
               aDescID != eCSSFontDesc_Src) {
      aResult.AssignLiteral("normal");
    }
    return;
  }

  if (aDescID == eCSSFontDesc_UnicodeRange) {
    // Since there's no unicode-range property, we can't use
    // nsCSSValue::AppendToString to serialize this descriptor.
    nsStyleUtil::AppendUnicodeRange(value, aResult);
  } else {
    value.AppendToString(aPropID, aResult, nsCSSValue::eNormalized);
  }
}

	void Transform(
		const Ptr<ShaderResourceView> & src,
		const Ptr<RenderTargetView> & dst,
		const Vector<ColorWriteMask, 4> & colorWriteMask,
		const float4 & srcRect,
		const float4 & dstRect,
		const Ptr<class Sampler> & sampler,
		const Ptr<DepthStencilView> & dsv )
	{
		auto rc = Global::GetRenderEngine()->GetRenderContext();

		std::map<String, String> macros;
		for (int32_t i = 0; i < 4; ++i)
		{
			auto & writeMask = colorWriteMask[i];
			String writeChannel = std::to_string(static_cast<uint32_t>(std::log2(static_cast<uint32_t>(writeMask))));
			macros["COLOR_CHANNEL_" + std::to_string(i)] = writeChannel;
		}

		auto transformPS = Shader::FindOrCreate<TransformPS>(macros);
		transformPS->SetSampler("transformSampler", sampler ? sampler : SamplerTemplate<>::Get());
		transformPS->SetSRV("srcTex", src);
		transformPS->Flush();

		auto srcTex = src->GetResource()->Cast<Texture>();
		float topLeftU = srcRect.x() / static_cast<float>(srcTex->GetDesc().width);
		float topLeftV = srcRect.y() / static_cast<float>(srcTex->GetDesc().height);
		float uvWidth  = srcRect.z() / static_cast<float>(srcTex->GetDesc().width);
		float uvHeight = srcRect.w() / static_cast<float>(srcTex->GetDesc().height);

		if (uvWidth == 0.0f)
			uvWidth = 1.0f;
		if (uvHeight == 0.0f)
			uvHeight = 1.0f;

		DrawQuad({ dst },
			dstRect.x(),
			dstRect.y(),
			dstRect.z(),
			dstRect.w(),
			topLeftU,
			topLeftV,
			uvWidth,
			uvHeight, 
			dsv);
	}

void GetTextureSizeD3D( ID3D11Resource* res, unsigned int* width, unsigned int* height )
{

    DebugAssert( res != 0, "Tried to get size of texture on a null ID3D11Resource (the texture resource bound to graphics card)");

    // This is the most generic solution. you can make it a lot
    // simpler if you know it will always be a 2D texture file
    D3D11_RESOURCE_DIMENSION dim;
    res->GetType( &dim );
    switch(dim)
    {
        case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
            { 
                 auto txt = reinterpret_cast<ID3D11Texture1D*>( res );
                 D3D11_TEXTURE1D_DESC desc;
                 txt->GetDesc( &desc );
                 if ( width ) *width = desc.Width;
                 if ( height ) *height = 1;
            }
            break;
        case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
            {
                 auto txt = reinterpret_cast<ID3D11Texture2D*>( res );
                 D3D11_TEXTURE2D_DESC desc;
                 txt->GetDesc( &desc );
                 if ( width ) *width = desc.Width;
                 if ( height ) *height = desc.Height;
            }
            break;
        case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
            {
                 auto txt = reinterpret_cast<ID3D11Texture3D*>( res );
                 D3D11_TEXTURE3D_DESC desc;
                 txt->GetDesc( &desc );
                 if ( width ) *width = desc.Width;
                 if ( height ) *height = desc.Height;
            }
            break;
        default:
             if ( width ) *width = 0;
             if ( height ) *height = 0;
            break;
    }
}

void VertexBuffer::BufferData(const size_t size, void *data)
{
	PROFILE_SCOPED()
	assert(m_mapMode == BUFFER_MAP_NONE); //must not be currently mapped
	if (GetDesc().usage == BUFFER_USAGE_DYNAMIC) {
		glBindVertexArray(m_vao);
		glBindBuffer(GL_ARRAY_BUFFER, m_buffer);
		glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)size, (GLvoid*)data, GL_DYNAMIC_DRAW);
	}
}

///////////////////////////////////////////////////////////////////////
// CChart::Convert
// Create CChart with input record string; Return NULL if invalid
//
BOOL CChart::Convert( const char* pszChartFileRecord )
{
    ASSERT_VALID( this );
    BOOL match, done;
    int field, sidx, slen;

    CString s = CString( pszChartFileRecord );
    slen = s.GetLength();
    done = FALSE;
    sidx = 0;

    for( field=0; done == FALSE; field++ )
    {
	match = FALSE;
	switch( field )
	{
	case 0: /* "a," */
	    if ( s.Left(2) == "a," ) match = TRUE;
	    sidx += 2;
	    break;

	case 1: /* account no. - X, XX, or XXX, */
	    match = SetChartAcct( (s.Mid( sidx )).SpanExcluding(","));
	    sidx += m_ChartAcct.GetLength() + 1;
	    break;

	case 2: /* description - XX...X, or XX...X\n */
	    match = SetDesc( (s.Mid( sidx )).SpanExcluding(",\n") );
	    sidx += GetDesc().GetLength() + 1;
	    if ( sidx-1 >= slen || s[sidx-1] == '\n' ) done = TRUE;
	    break;

	case 3: /* Old account - NULL X XX XXX followed by , or \n */
	    match = SetOldAcct( (s.Mid( sidx )).SpanExcluding(",\n") );
	    sidx += m_OldAcct.GetLength() + 1;
	    if( sidx-1 >= slen || s[sidx-1] == '\n' ) done = TRUE;
	    break;

	case 4: /* Summary Account Flag - NULL\n or s\n */
	    //cerr << "\"" << (s.Mid( sidx )).SpanExcluding("\n") "\"\n";
	    match = SetSummaryAcct( (s.Mid( sidx )).SpanExcluding("\n") );
	    if ( sidx >= slen || s[sidx] == '\n' || s[sidx+1] == '\n' ) done = TRUE;
	    break;

	} // switch
	if( match == FALSE ) {
	    cerr << pszChartFileRecord
		 << "Invalid Chart Record\n";
	    done = TRUE;
	}
    } // for
    return match;
} // function

void DX11Engine::createSwapChainRenderTargets(IUnknown** ppRTV, IUnknown** ppRTVsRGB, 
    IUnknown** ppDSV, IUnknown* pNativeDevice, IUnknown* pSwapChainIn, 
    size_t length, const char* debugName) const
{
    auto pSwapChain = reinterpret_cast<IDXGISwapChain*>(pSwapChainIn);
    auto pDevice = reinterpret_cast<ID3D11Device*>(pNativeDevice);
        
    HRESULT hr = S_OK;
    std::unique_ptr<ID3D11Texture2D, COMDeleter> pD3D11Texture;
        
    // rtv
    DXGI_SWAP_CHAIN_DESC desc;
    V(pSwapChain->GetDesc(&desc));
    V(pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), ref(pD3D11Texture)));
    STAR_SET_DEBUG_NAME(pD3D11Texture, length, debugName);

    CD3D11_RENDER_TARGET_VIEW_DESC rtvDesc(D3D11_RTV_DIMENSION_TEXTURE2D);

    rtvDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
    ID3D11RenderTargetView* pRTV;
    V(pDevice->CreateRenderTargetView(pD3D11Texture.get(), &rtvDesc, &pRTV));
    *ppRTV = pRTV;
    STAR_SET_DEBUG_NAME(pRTV, length, debugName);

    rtvDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;
    V(pDevice->CreateRenderTargetView(pD3D11Texture.get(), &rtvDesc, &pRTV));
    *ppRTVsRGB = pRTV;
    STAR_SET_DEBUG_STRING(pRTV, (debugName + std::string("_sRGB")));
    
    // dsv
    if(ppDSV) {
        D3D11_TEXTURE2D_DESC descTex2D = {
            desc.BufferDesc.Width,
            desc.BufferDesc.Height,
            1, 1, DXGI_FORMAT_D32_FLOAT,{ 1, 0 },
            D3D11_USAGE_DEFAULT, D3D11_BIND_DEPTH_STENCIL,
            0, 0
        };
        
        
        std::unique_ptr<ID3D11Texture2D, COMDeleter> pDST;
        V(pDevice->CreateTexture2D(&descTex2D, nullptr, ref(pDST)));
        STAR_SET_DEBUG_NAME(pDST, length, debugName);

        D3D11_DEPTH_STENCIL_VIEW_DESC descV = {
            DXGI_FORMAT_D32_FLOAT, D3D11_DSV_DIMENSION_TEXTURE2D, 0,{ 0 }
        };
        ID3D11DepthStencilView* pDSV;
        V(pDevice->CreateDepthStencilView(pDST.get(), &descV, &pDSV));
        *ppDSV = pDSV;
        STAR_SET_DEBUG_NAME(pDSV, length, debugName);
    }
}

TError TNlLink::WaitAddress(int timeout_s) {
    struct nl_cache *cache;
    int ret;

    L() << "Wait for autoconf at " << GetDesc() << std::endl;

    ret = rtnl_addr_alloc_cache(GetSock(), &cache);
    if (ret < 0)
        return Nl->Error(ret, "Cannot allocate addr cache");

    do {
        for (auto obj = nl_cache_get_first(cache); obj; obj = nl_cache_get_next(obj)) {
            auto addr = (struct rtnl_addr *)obj;

            if (!rtnl_addr_get_local(addr) ||
                    rtnl_addr_get_ifindex(addr) != GetIndex() ||
                    rtnl_addr_get_family(addr) != AF_INET6 ||
                    rtnl_addr_get_scope(addr) >= RT_SCOPE_LINK ||
                    (rtnl_addr_get_flags(addr) &
                     (IFA_F_TENTATIVE | IFA_F_DEPRECATED)))
                continue;

            L() << "Got " << TNlAddr(rtnl_addr_get_local(addr)).Format()
                << " at " << GetDesc() << std::endl;

            nl_cache_free(cache);
            return TError::Success();
        }

        usleep(1000000);
        ret = nl_cache_refill(GetSock(), cache);
        if (ret < 0)
            return Nl->Error(ret, "Cannot refill address cache");
    } while (--timeout_s > 0);

    nl_cache_free(cache);
    return TError(EError::Unknown, "Network autoconf timeout");
}

int HostIO_CyUSB::OpenEx(CameraID cID)
{
	int		numDevs;
	USHORT	VID;
	USHORT	PID;
	bool	bFoundDevice = false;

	m_log->Write(2, _T("OpenEx name: %s"), cID.SerialToOpen.c_str());
	
	numDevs = cyusb_open();

	for (int i = 0; i < (int)numDevs; i++) 
	{
		h = cyusb_gethandle(i);
		VID = cyusb_getvendor(h);
		PID = cyusb_getproduct(h);

		std::string SerialNum = std::string("None");
		GetSerialNumber(SerialNum);
		std::string SerialToOpen = SerialNum;
		
		std::string Desc = std::string("None");
		GetDesc(Desc);

		m_log->Write(2, _T("Dev %d:"), i);
		m_log->Write(2, _T(" SerialNumber=%s"), SerialNum.c_str());
		m_log->Write(2, _T(" Description=%s"), Desc.c_str());

		if (VID == QSICyVID && PID == QSICyPID && SerialNum == cID.SerialToOpen )
		{
			m_log->Write(2, _T("USB Open found QSI Cy device at index: %d, Serial: %s, Description: %s"), 
							i, SerialNum.c_str(), Desc.c_str());
			bFoundDevice = true;
			break;
		}
	}
	
	if (bFoundDevice && cyusb_kernel_driver_active(h, 0) == 0 && cyusb_claim_interface(h, 0) == 0)
	{
		SetTimeouts(READ_TIMEOUT, WRITE_TIMEOUT);		
	}
	else
	{
		m_log->Write(2, "No devices matched");
	}

	m_log->Write(2, _T("OpenEx Done."));

	return bFoundDevice ? ALL_OK : ERR_USB_OpenFailed;
}

Uint8 *VertexBuffer::MapInternal(BufferMapMode mode, size_t length)
{
	assert(mode != BUFFER_MAP_NONE); //makes no sense
	assert(m_mapMode == BUFFER_MAP_NONE); //must not be currently mapped
	m_mapMode = mode;
	if (GetDesc().usage == BUFFER_USAGE_STATIC) {
		glBindBuffer(GL_ARRAY_BUFFER, m_buffer);
		if (mode == BUFFER_MAP_READ)
			return reinterpret_cast<Uint8*>(glMapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY));
		else if (mode == BUFFER_MAP_WRITE)
			return reinterpret_cast<Uint8*>(glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY));
	}

	return m_data;
}

static void ReflectShaderConstantBuffer(
    ID3D12ShaderReflection*             reflection,
    ShaderReflectionDescriptor&         reflectionDesc,
    const D3D12_SHADER_DESC&            shaderDesc,
    const D3D12_SHADER_INPUT_BIND_DESC& inputBindDesc,
    long                                stageFlags,
    UINT&                               cbufferIdx)
{
    /* Initialize resource view descriptor for constant buffer */
    auto resourceView = FetchOrInsertResource(reflectionDesc, inputBindDesc.Name, ResourceType::Buffer, inputBindDesc.BindPoint);
    {
        resourceView->bindFlags     |= BindFlags::ConstantBuffer;
        resourceView->stageFlags    |= stageFlags;
        resourceView->arraySize     = inputBindDesc.BindCount;
    }

    /* Determine constant buffer size */
    if (cbufferIdx < shaderDesc.ConstantBuffers)
    {
        auto cbufferReflection = reflection->GetConstantBufferByIndex(cbufferIdx++);

        D3D12_SHADER_BUFFER_DESC shaderBufferDesc;
        auto hr = cbufferReflection->GetDesc(&shaderBufferDesc);
        DXThrowIfFailed(hr, "failed to retrieve D3D12 shader buffer descriptor");

        if (shaderBufferDesc.Type == D3D_CT_CBUFFER)
        {
            /* Store constant buffer size in output descriptor */
            resourceView->constantBufferSize = shaderBufferDesc.Size;
        }
        else
        {
            /* Type mismatch in descriptors */
            throw std::runtime_error(
                "failed to match D3D12 shader buffer descriptor \"" + std::string(shaderBufferDesc.Name) +
                "\" with input binding descriptor for constant buffer \"" + std::string(inputBindDesc.Name) + "\""
            );
        }
    }
    else
    {
        /* Resource index mismatch in descriptor */
        throw std::runtime_error(
            "failed to find D3D12 shader buffer descriptor for input binding descriptor \"" +
            std::string(inputBindDesc.Name) + "\""
        );
    }
}

//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
MStatus CVsSkinnerCmd::redoIt()
{
	if ( m_undo.ArgDatabase().isFlagSet( kOptHelp ) )
	{
		GetSyntaxHelp()->PrintHelp( GetName(), GetDesc() );
		return MS::kSuccess;
	}

	m_undo.SaveCurrentSelection();

	if ( m_undo.ArgDatabase().isFlagSet( kOptCreate ) )
	{
		return DoCreate();
	}
	else if ( m_undo.ArgDatabase().isFlagSet( kOptNewVolume ) )
	{
		MSelectionList optSelectionList;
		m_undo.ArgDatabase().getObjects( optSelectionList );
		MSelectionList volumeList( DoNewVolumes( GetSpecifiedSkinnerNode(), optSelectionList ) );
		if ( volumeList.length() == 0 )
		{
			merr << "Couldn't create new volumes" << std::endl;
			return MS::kFailure;
		}
		MGlobal::setActiveSelectionList( volumeList, MGlobal::kReplaceList );
		MStringArray vA;
		volumeList.getSelectionStrings( vA );
		setResult( vA );

		return MS::kSuccess;
	}
	else if ( m_undo.ArgDatabase().isFlagSet( kOptAttachMesh ) )
	{
		return DoAttachMesh( GetSpecifiedSkinnerNode(), GetSpecifiedMesh() );
	}
	else if ( m_undo.ArgDatabase().isFlagSet( kOptDetachMesh ) )
	{
		return DoDetachMesh( GetSpecifiedSkinnerNode() );
	}
	else if ( m_undo.ArgDatabase().isFlagSet( kOptLs ) )
	{
		return DoLs();
	}

	merr << GetName() << ": No action specified" << std::endl;

	return MS::kFailure;
}

VertexBuffer::VertexBuffer(const VertexBufferDesc &desc)
{
	m_desc = desc;
	//update offsets in desc
	for (Uint32 i = 0; i < MAX_ATTRIBS; i++) {
		if (m_desc.attrib[i].offset == 0)
			m_desc.attrib[i].offset = VertexBufferDesc::CalculateOffset(m_desc, m_desc.attrib[i].semantic);
	}

	//update stride in desc (respecting offsets)
	if (m_desc.stride == 0)
	{
		Uint32 lastAttrib = 0;
		while (lastAttrib < MAX_ATTRIBS) {
			if (m_desc.attrib[lastAttrib].semantic == ATTRIB_NONE)
				break;
			lastAttrib++;
		}

		m_desc.stride = m_desc.attrib[lastAttrib].offset + VertexBufferDesc::GetAttribSize(m_desc.attrib[lastAttrib].format);
	}
	assert(m_desc.stride > 0);
	assert(m_desc.numVertices > 0);

	SetVertexCount(m_desc.numVertices);

	glGenBuffers(1, &m_buffer);

	//Allocate initial data store
	//Using zeroed m_data is not mandatory, but otherwise contents are undefined
	glBindBuffer(GL_ARRAY_BUFFER, m_buffer);
	const Uint32 dataSize = m_desc.numVertices * m_desc.stride;
	m_data = new Uint8[dataSize];
	memset(m_data, 0, dataSize);
	const GLenum usage = (m_desc.usage == BUFFER_USAGE_STATIC) ? GL_STATIC_DRAW : GL_DYNAMIC_DRAW;
	glBufferData(GL_ARRAY_BUFFER, dataSize, m_data, usage);
	glBindBuffer(GL_ARRAY_BUFFER, 0);

	//Don't keep client data around for static buffers
	if (GetDesc().usage == BUFFER_USAGE_STATIC) {
		delete[] m_data;
		m_data = nullptr;
	}

	//If we had VAOs could set up the pointers already
}

	PooledTextureRef SSR::BuildHZB(const Ptr<Texture> & depthTex)
	{
		auto texDesc = depthTex->GetDesc();
		texDesc.format = RENDER_FORMAT_R16_FLOAT;
		texDesc.bindFlag = TEXTURE_BIND_SHADER_RESOURCE | TEXTURE_BIND_RENDER_TARGET;
		texDesc.mipLevels = 0;

		auto hzb0Ref = TexturePool::Instance().FindFree({ TEXTURE_2D, texDesc });
		auto hzb1Ref = TexturePool::Instance().FindFree({ TEXTURE_2D, texDesc });

		auto hzb0 = hzb0Ref->Get()->Cast<Texture>();
		auto hzb1 = hzb1Ref->Get()->Cast<Texture>();

		Transform(
			depthTex->GetShaderResourceView(0, 1, 0, 1, false, RENDER_FORMAT_R24_UNORM_X8_TYPELESS), 
			hzb0Ref->Get()->Cast<Texture>()->GetRenderTargetView(0, 0, 1));

		auto rc = Global::GetRenderEngine()->GetRenderContext();

		auto ps = Shader::FindOrCreate<HZBBuildPS>();

		for (int32_t mipLevel = 1; mipLevel < hzb0->GetDesc().mipLevels; ++mipLevel)
		{
			auto & mipSize = hzb0->GetMipSize(mipLevel - 1);
			auto w = mipSize.x();
			auto h = mipSize.y();
			float4 screenSize = float4((float)w, (float)h, 1.0f / (float)w, 1.0f / (float)h);

			ps->SetScalar("screenSize", screenSize);
			ps->SetScalar("mipLevel", (float)(mipLevel - 1));
			ps->SetSRV("depthTex", hzb0->GetShaderResourceView());
			ps->SetSampler("pointSampler", SamplerTemplate<FILTER_MIN_MAG_MIP_POINT>::Get());

			ps->Flush();

			auto & targetMipSize = hzb0->GetMipSize(mipLevel);

			DrawQuad({ hzb1->GetRenderTargetView(mipLevel, 0, 1) });

			hzb1->CopyTo(hzb0, mipLevel, 0, 0, 0, 0, mipLevel, 0);
		}

		return hzb0Ref;
	}

void CHARACTER::ClearAffect(bool bSave)
{
	TAffectFlag afOld = m_afAffectFlag;
	WORD	wMovSpd = GetPoint(POINT_MOV_SPEED);
	WORD	wAttSpd = GetPoint(POINT_ATT_SPEED);

	itertype(m_list_pkAffect) it = m_list_pkAffect.begin();

	while (it != m_list_pkAffect.end())
	{
		CAffect * pkAff = *it;

		if (bSave)
		{
			if ( IS_NO_CLEAR_ON_DEATH_AFFECT(pkAff->dwType) || IS_NO_SAVE_AFFECT(pkAff->dwType) )
			{
				++it;
				continue;
			}

			if (IsPC())
			{
				SendAffectRemovePacket(GetDesc(), GetPlayerID(), pkAff->dwType, pkAff->bApplyOn);
			}
		}

		ComputeAffect(pkAff, false);

		it = m_list_pkAffect.erase(it);
		CAffect::Release(pkAff);
	}

	if (afOld != m_afAffectFlag ||
			wMovSpd != GetPoint(POINT_MOV_SPEED) ||
			wAttSpd != GetPoint(POINT_ATT_SPEED))
		UpdatePacket();

	CheckMaximumPoints();

	if (m_list_pkAffect.empty())
		event_cancel(&m_pkAffectEvent);
}

ProxyImplSurface::ProxyImplSurface(IBase *pimpl)
    : ProxyBase<IBase>(pimpl)
{
    D3DSURFACE_DESC desc;
    HRESULT res = GetDesc(&desc);
    assert(SUCCEEDED(res));
    if (SUCCEEDED(res))
    {
        static set<D3DFORMAT> unsupported;
        
        size_t b = bytesPerPixel(desc.Format);
        if (b == 0 && !unsupported.count(desc.Format))
        {
            unsupported.insert(desc.Format);
            char letters[5];
            letters[4] = 0;
            memcpy(letters, &desc.Format, 4);
            LOG("Unsupported surface format: " << desc.Format << ": " << letters);
        }
    }
}

bool CHARACTER::DragonSoul_RefineWindow_Open(LPENTITY pEntity)
{
	if (NULL == m_pointsInstant.m_pDragonSoulRefineWindowOpener)
	{
		m_pointsInstant.m_pDragonSoulRefineWindowOpener = pEntity;
	}

	TPacketGCDragonSoulRefine PDS;
	PDS.header = HEADER_GC_DRAGON_SOUL_REFINE;
	PDS.bSubType = DS_SUB_HEADER_OPEN;
	LPDESC d = GetDesc();

	if (NULL == d)
	{
		sys_err ("User(%s)'s DESC is NULL POINT.", GetName());
		return false;
	}

	d->Packet(&PDS, sizeof(PDS));
	return true;
}