PNPatches学习

最新推荐文章于 2018-11-23 17:26:52 发布
最新推荐文章于 2018-11-23 17:26:52 发布
阅读量759 收藏
点赞数
分类专栏： 游戏开发 C++ 文章标签： 3D
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/lixiaomin_235/article/details/8873477
版权

                                                                                                             PNPatches学习

2013/5/1                    Simon&Lee

理论学习

通常，为了在游戏中更加丰富模型细节，AMD提出了一种Tessellation的网格拆分技术。经过若干年的发展，微软在DirectX11中引入了这一技术。在基于DirectX11的渲染管线中，增加了Hull-Shader Stage、Tessellator Stage和Domain-Shader Stage三个阶段。

Hull-Shader Stage阶段

Hull-ShaderStage是一个可编程管线阶段，通过对输入的控制点进行计算，生成输出控制点和一些常量数据供tessellation阶段和demain shader阶段使用。

Tessellator Stage阶段

TessellatorStage是一个固定管线阶段，对于开发者一般不需要太多关注该阶段。该阶段主要是根据hull shader阶段的输出数据进行网格拆分，并将细分数据输出到domain shader阶段，以便进行后处理。

Domain-Shader Stage阶段

Domain-ShaderStage也是一个可编程管线阶段，主要是根据tessellator阶段的输出数据和hull shader阶段的ConstantData进行计算，将最终的顶点数据传给PixelShader阶段。

实现细节

1.   C++部分代码

（1）Load资源

首先，读取法线纹理和位移纹理作为网格细分资源。

    ID3D11ShaderResourceView*pDisplacementTextureSRV = NULL;

    ID3D11ShaderResourceView*pNormalTextureSRV = NULL;

 

    // Try toload displacement and normal maps from cache

    {

        D3DX11_IMAGE_INFO imageInfo;

        ID3D11Texture2D*pDisplacementTexture = NULL;

        ID3D11Texture2D*pNormalTexture = NULL;

        WCHAR path[1024];

 

        if(DXUTFindDXSDKMediaFileCch(path, MAX_PATH, L"PNPatches/cache/displacement_map.dds") == S_OK)

        {

            if (D3DX11GetImageInfoFromFile(path, NULL,&imageInfo, NULL) == S_OK)

            {

                D3DX11_IMAGE_LOAD_INFOimageLoadInfo;

               memset(&imageLoadInfo, 0, sizeof(imageLoadInfo));

               imageLoadInfo.Width = imageInfo.Width;

               imageLoadInfo.Height = imageInfo.Height;

               imageLoadInfo.MipLevels = 1;

               imageLoadInfo.Format = imageInfo.Format;

               imageLoadInfo.BindFlags = D3D11_BIND_SHADER_RESOURCE;

                V_RETURN(D3DX11CreateTextureFromFile(pDevice, path,&imageLoadInfo, NULL, (ID3D11Resource**)&pDisplacementTexture, NULL));

 

                D3D11_SHADER_RESOURCE_VIEW_DESC descSRV;

               memset(&descSRV, 0, sizeof(descSRV));

               descSRV.Format = imageInfo.Format;

               descSRV.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;

               descSRV.Texture2D.MipLevels = 1;

                pDevice->CreateShaderResourceView(pDisplacementTexture,&descSRV, &pDisplacementTextureSRV);

 

               pDisplacementTexture->Release();

            }

        }

 

        if(DXUTFindDXSDKMediaFileCch(path, MAX_PATH, L"PNPatches/cache/normal_map.dds") == S_OK)

        {

            if (D3DX11GetImageInfoFromFile(path, NULL,&imageInfo, NULL) == S_OK)

            {

                D3DX11_IMAGE_LOAD_INFOimageLoadInfo;

               memset(&imageLoadInfo, 0, sizeof(imageLoadInfo));

               imageLoadInfo.Width = imageInfo.Width;

               imageLoadInfo.Height = imageInfo.Height;

               imageLoadInfo.MipLevels = 1;

               imageLoadInfo.Format = imageInfo.Format;

               imageLoadInfo.BindFlags = D3D11_BIND_SHADER_RESOURCE;

                V_RETURN(D3DX11CreateTextureFromFile(pDevice, path,&imageLoadInfo, NULL, (ID3D11Resource**)&pNormalTexture, NULL));

 

                D3D11_SHADER_RESOURCE_VIEW_DESC descSRV;

               memset(&descSRV, 0, sizeof(descSRV));

               descSRV.Format = imageInfo.Format;

               descSRV.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;

               descSRV.Texture2D.MipLevels = 1;

                pDevice->CreateShaderResourceView(pNormalTexture,&descSRV, &pNormalTextureSRV);

 

               pNormalTexture->Release();

            }

        }

    }

（2）Render函数

然后，提交Shader寄存器数据，并进行渲染。

void MyMesh::RenderAnimated(ID3D11DeviceContext *pd3dDeviceContext, D3DXMATRIX& mView, D3DXMATRIX& mProj, D3DXVECTOR3& cameraPos, float time)

{

    UpdateView(mView, mProj, cameraPos);

 

    ID3DX11EffectPass*pOverridePass = NULL;

 

    ...

 

    // Constants

    D3DXMATRIX mViewProj =mView * mProj;

g_pEffect->GetVariableByName("g_ModelViewProjectionMatrix")->AsMatrix()->SetMatrix(mViewProj);

   g_pEffect->GetVariableByName("g_CameraPosition")->AsVector()->SetFloatVector(cameraPos);

   g_pEffect->GetVariableByName("g_DisplacementScale")->AsScalar()->SetFloat(m_DisplacementScale);

   

    // Buffers& resources

g_pEffect->GetVariableByName("g_PositionsBuffer")->AsShaderResource()->SetResource(g_pMeshVertexBufferSRV);

g_pEffect->GetVariableByName("g_CoordinatesBuffer")->AsShaderResource()->SetResource(g_pMeshCoordinatesBufferSRV);

g_pEffect->GetVariableByName("g_IndicesBuffer")->AsShaderResource()->SetResource(g_pMeshTrgsIndexBufferSRV);

g_pEffect->GetVariableByName("g_NormalsBuffer")->AsShaderResource()->SetResource(g_pMeshNormalsBufferSRV);

   g_pEffect->GetVariableByName("g_TangentsBuffer")->AsShaderResource()->SetResource(g_pMeshTangentsBufferSRV);

g_pEffect->GetVariableByName("g_CornerCoordinatesBuffer")->AsShaderResource()->SetResource(g_pMeshCornerCoordinatesBufferSRV);

    g_pEffect->GetVariableByName("g_EdgeCoordinatesBuffer")->AsShaderResource()->SetResource(g_pMeshTriEdgeCoordinatesBufferSRV);

   

   g_pEffect->GetVariableByName("g_DisplacementTexture")->AsShaderResource()->SetResource(g_pDisplacementMapSRV);

   g_pEffect->GetVariableByName("g_WSNormalMap")->AsShaderResource()->SetResource(g_pNormalMapSRV);

 

    // Animationstuff

    int bonesNum =m_pCharacterAnimation->GetBonesNum();

    D3DXMATRIX* pFrame =m_pCharacterAnimation->GetFrame(time);

   g_pEffect->GetVariableByName("mAnimationMatrixArray")->AsMatrix()->SetMatrixArray((float*)pFrame, 0,bonesNum);

 

   g_pEffect->GetVariableByName("g_BoneIndicesBuffer")->AsShaderResource()->SetResource(m_pBoneIndicesBufferSRV);

   g_pEffect->GetVariableByName("g_BoneWeightsBuffer")->AsShaderResource()->SetResource(m_pBoneWeightsBufferSRV);

 

    if(m_TessellationFactor != 1.0f)

    {

        g_pEffect->GetVariableByName("g_TessellationFactor")->AsScalar()->SetFloat(m_TessellationFactor* g_TessellationFactorResScale);

        pd3dDeviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST);

       g_pEffect->GetTechniqueByName("RenderTessellatedTrianglesAnimated")->GetPassByIndex(0)->Apply(0,pd3dDeviceContext);

    }

    else

    {

       g_pEffect->GetVariableByName("g_TessellationFactor")->AsScalar()->SetFloat(1.0f);

        pd3dDeviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

       g_pEffect->GetTechniqueByName("RenderTrianglesAnimated")->GetPassByIndex(0)->Apply(0,pd3dDeviceContext);

    }

   

    if(pOverridePass) pOverridePass->Apply(0, pd3dDeviceContext);

   

    pd3dDeviceContext->Draw(g_MeshTrgIndicesNum,0);

 

    ...

}

 

2.   Shader部分代码

（1）Technique和pass设置

 

technique11 RenderTessellatedTrianglesAnimated

{

    pass p0

    {

        SetRasterizerState(CullBackMS);

        SetDepthStencilState(DepthNormal, 0);

        SetBlendState(NoBlending, float4(0.0f, 0.0f,0.0f, 0.0f), 0xFFFFFFFF);

 

        SetVertexShader(CompileShader(vs_4_0, RenderTessellatedDiffuseVS(true)));

        SetHullShader(CompileShader(hs_5_0, DiffuseHS()));

        SetDomainShader(CompileShader(ds_5_0, DiffuseDS()));

        SetGeometryShader(NULL);

        SetPixelShader(CompileShader(ps_4_0, RenderTessellatedDiffusePS()));

    }

}

（2）VertexShader

 

HSIn_Diffuse RenderTessellatedDiffuseVS(uint vertexID : SV_VertexID, uniform bool renderAnimated = false)

{

    HSIn_Diffuse output;

   

    int2 indices = g_IndicesBuffer.Load(vertexID);

 

    output.position = g_PositionsBuffer.Load(indices.x).xyz;

    output.texCoord = g_CoordinatesBuffer.Load(indices.xy);

   

    float4 normalData = g_NormalsBuffer.Load(indices.x);

    output.normal = normalData.xyz;

 

    float4 tangentData = g_TangentsBuffer.Load(indices.x);

    output.tangent = tangentData.xyz;

 

    if (renderAnimated)

    {

        int4 boneIndices = g_BoneIndicesBuffer.Load(indices.x);

        float4 boneWeights = g_BoneWeightsBuffer.Load(indices.x);

 

        float4x4 combinedAnimMatrix = 0;

 

        [unroll]

        for (int iBone=0; iBone<4; ++iBone)

        {

            combinedAnimMatrix += mAnimationMatrixArray[boneIndices[iBone]] * boneWeights[iBone];

        }

 

        float3 animatedPosition = mul(float4(output.position, 1), combinedAnimMatrix).xyz;

        output.position = mul(animatedPosition, MAnimatedScale);

 

        float3x3 rotationMatrix = (float3x3)combinedAnimMatrix;

 

        float3 animatedNormal = mul(float4(output.normal, 1), rotationMatrix).xyz;

        output.normal = normalize(mul(animatedNormal, MAnimatedScale));

 

        float3 animatedTangent = mul(float4(output.tangent, 1), rotationMatrix).xyz;

        output.tangent = normalize(mul(animatedTangent, MAnimatedScale));

    }

 

#ifdef FIX_THE_SEAMS

    output.cornerCoord = g_CornerCoordinatesBuffer.Load(indices.x);

    output.edgeCoord = g_EdgeCoordinatesBuffer.Load(vertexID);

#endif

 

    return output;

}

（3）HullShader

 

struct HS_CONSTANT_DATA_OUTPUT

{

    float Edges[3]  : SV_TessFactor;

    float Inside    : SV_InsideTessFactor;

#ifdef PN_TRIANGLES

    // Geometrycubic generated control points

    float3 f3B210   : POSITION3;

    float3 f3B120   : POSITION4;

    float3 f3B021   : POSITION5;

    float3 f3B012   : POSITION6;

    float3 f3B102   : POSITION7;

    float3 f3B201   : POSITION8;

    float3 f3B111   : CENTER;

#endif

 

    float sign      : SIGN;

};

 

[domain("tri")]

[partitioning("integer")]

[outputtopology("triangle_cw")]

[outputcontrolpoints(3)]

[patchconstantfunc("DiffuseConstantHS")]

[maxtessfactor(64.0)]

HSIn_Diffuse DiffuseHS( InputPatch<HSIn_Diffuse, 3> inputPatch, uint i : SV_OutputControlPointID)

{

    return inputPatch[i];

}

 

HS_CONSTANT_DATA_OUTPUT DiffuseConstantHS( InputPatch<HSIn_Diffuse, 3> inputPatch)

{   

    HS_CONSTANT_DATA_OUTPUT output;

 

    //tessellation factors are proportional to model space edge length

    for (uint ie = 0; ie < 3; ++ie)

    {

#ifdef MESH_CONSTANT_LOD

       output.Edges[ie] = g_TessellationFactor / (float)512 * (float)64;

#else

       float3 edge = inputPatch[(ie + 1) % 3].position - inputPatch[ie].position;

       float3 vec = (inputPatch[(ie + 1) % 3].position + inputPatch[ie].position) / 2 - g_FrustumOrigin;

       float len = sqrt(dot(edge, edge) / dot(vec, vec));

       output.Edges[(ie + 1) % 3] =max(1,len* g_TessellationFactor);

#endif

    }

 

    // culling

    int culled[4];

    for (int ip = 0; ip < 4; ++ip)

    {

        culled[ip] = 1;

        culled[ip] &= dot(inputPatch[0].position - g_FrustumOrigin, g_FrustumNormals[ip].xyz) > 0;

        culled[ip] &= dot(inputPatch[1].position - g_FrustumOrigin, g_FrustumNormals[ip].xyz) > 0;

        culled[ip] &= dot(inputPatch[2].position - g_FrustumOrigin, g_FrustumNormals[ip].xyz) > 0;

    }

    if (culled[0] || culled[1] || culled[2] || culled[3]) output.Edges[0] = 0;

 

#ifdef PN_TRIANGLES

    // computethe cubic geometry control points

    // edgecontrol points

    output.f3B210 = ( ( 2.0f* inputPatch[0].position ) + inputPatch[1].position - ( dot( ( inputPatch[1].position - inputPatch[0].position ), inputPatch[0].normal ) * inputPatch[0].normal ) ) / 3.0f;

    output.f3B120 = ( ( 2.0f* inputPatch[1].position ) + inputPatch[0].position - ( dot( ( inputPatch[0].position - inputPatch[1].position ), inputPatch[1].normal ) * inputPatch[1].normal ) ) / 3.0f;

    output.f3B021 = ( ( 2.0f* inputPatch[1].position ) + inputPatch[2].position - ( dot( ( inputPatch[2].position - inputPatch[1].position ), inputPatch[1].normal ) * inputPatch[1].normal ) ) / 3.0f;

    output.f3B012 = ( ( 2.0f* inputPatch[2].position ) + inputPatch[1].position - ( dot( ( inputPatch[1].position - inputPatch[2].position ), inputPatch[2].normal ) * inputPatch[2].normal ) ) / 3.0f;

    output.f3B102 = ( ( 2.0f* inputPatch[2].position ) + inputPatch[0].position - ( dot( ( inputPatch[0].position - inputPatch[2].position ), inputPatch[2].normal ) * inputPatch[2].normal ) ) / 3.0f;

    output.f3B201 = ( ( 2.0f* inputPatch[0].position ) + inputPatch[2].position - ( dot( ( inputPatch[2].position - inputPatch[0].position ), inputPatch[0].normal ) * inputPatch[0].normal ) ) / 3.0f;

    // centercontrol point

    float3 f3E = ( output.f3B210 + output.f3B120 + output.f3B021 + output.f3B012 + output.f3B102 + output.f3B201 ) / 6.0f;

    float3 f3V = ( inputPatch[0].position + inputPatch[1].position + inputPatch[2].position ) / 3.0f;

    output.f3B111 = f3E + ( ( f3E - f3V ) / 2.0f );

#endif

 

    output.Inside = (output.Edges[0] + output.Edges[1] + output.Edges[2]) / 3;

 

    float2 t01 = inputPatch[1].texCoord - inputPatch[0].texCoord;

    float2 t02 = inputPatch[2].texCoord - inputPatch[0].texCoord;

    output.sign = t01.x * t02.y - t01.y * t02.x > 0.0f ?1 : -1;

 

    return output;

}

 

（4）DomainShader

 

[domain("tri")]

PSIn_TessellatedDiffuse DiffuseDS( HS_CONSTANT_DATA_OUTPUT input,

                      float3 barycentricCoords : SV_DomainLocation,

                      OutputPatch<HSIn_Diffuse, 3> inputPatch )

{

    PSIn_TessellatedDiffuse output;

 

    float3 coordinates = barycentricCoords;

 

    // Thebarycentric coordinates

    float fU = barycentricCoords.x;

    float fV = barycentricCoords.y;

    float fW = barycentricCoords.z;

 

    //Precompute squares and squares * 3

    float fUU = fU * fU;

    float fVV = fV * fV;

    float fWW = fW * fW;

    float fUU3 = fUU * 3.0f;

    float fVV3 = fVV * 3.0f;

    float fWW3 = fWW * 3.0f;

 

    // Computeposition from cubic control points and barycentric coords

    float3 position = inputPatch[0].position * fWW * fW + inputPatch[1].position * fUU * fU + inputPatch[2].position * fVV * fV +

                    input.f3B210 * fWW3 * fU + input.f3B120 * fW * fUU3 + input.f3B201 * fWW3 * fV + input.f3B021 * fUU3 * fV +

                    input.f3B102 * fW * fVV3 + input.f3B012 * fU * fVV3 + input.f3B111 * 6.0f * fW * fU * fV;

 

    // Computenormal from quadratic control points and barycentric coords

    float3 normal = inputPatch[0].normal * coordinates.z + inputPatch[1].normal * coordinates.x + inputPatch[2].normal * coordinates.y;

    normal = normalize(normal);

 

    float2 texCoord = inputPatch[0].texCoord * coordinates.z + inputPatch[1].texCoord * coordinates.x + inputPatch[2].texCoord * coordinates.y;

 

    float2 displacementTexCoord = texCoord;

 

#ifdef FIX_THE_SEAMS

    // Edgepoint

    if(coordinates.z == 0)

        displacementTexCoord = lerp(inputPatch[1].edgeCoord.xy, inputPatch[1].edgeCoord.zw, coordinates.y);

    else if(coordinates.x == 0)

        displacementTexCoord = lerp(inputPatch[2].edgeCoord.xy, inputPatch[2].edgeCoord.zw, coordinates.z);

    else if(coordinates.y == 0)

        displacementTexCoord = lerp(inputPatch[0].edgeCoord.xy, inputPatch[0].edgeCoord.zw, coordinates.x);

 

    // Cornerpoint

    if(coordinates.z == 1)

        displacementTexCoord = inputPatch[0].cornerCoord;

    else if(coordinates.x == 1)

        displacementTexCoord = inputPatch[1].cornerCoord;

    else if(coordinates.y == 1)

        displacementTexCoord = inputPatch[2].cornerCoord;

#endif

 

#ifndef IGNORE_DISPLACEMENT

    float offset = g_DisplacementTexture.SampleLevel(SamplerLinearClamp, displacementTexCoord, 0).x;

    position += normal * offset;

#endif

 

    float3 tangent = inputPatch[0].tangent * coordinates.z + inputPatch[1].tangent * coordinates.x + inputPatch[2].tangent * coordinates.y;

    tangent = normalize(tangent);

 

    output.position = mul(float4(position, 1.0f), g_ModelViewProjectionMatrix);

#ifdef SMOOTH_TCOORDS

    output.texCoord = displacementTexCoord;

#else

    output.texCoord = texCoord;

#endif

    output.positionWS = position;

    output.normal = normal;

    output.tangent = tangent;

   

    output.sign = input.sign;//inputPatch[0].sign;

 

    return output;

}

（5）PixelShader

 

float4 RenderTessellatedDiffusePS(PSIn_TessellatedDiffuse input) : SV_Target

{

#ifdef FLAT_NORMAL

    float3 dir_x = ddx(input.positionWS);

    float3 dir_y = ddy(input.positionWS);

    float3 normal = normalize(cross(dir_x, dir_y));

    float3 lightDir = normalize(g_CameraPosition - input.positionWS);

#else   

    float3 normal = normalize(input.normal);

    float3 tangent = normalize(input.tangent);

    float3 bitangent = cross(normal, tangent) * input.sign;

    float3x3 tangentBasis = float3x3(tangent, bitangent, normal);

   

    float3 lightDir = normalize(g_CameraPosition - input.positionWS);

    lightDir = normalize(mul(tangentBasis, lightDir));

  

    normal = normalize(g_WSNormalMap.Sample(SamplerLinearClamp, input.texCoord).xyz);

#endif

   

    float dotNL = max(dot(normal, lightDir), 0.0f);

    float diffuse = dotNL * 0.75f +0.25f;

    float specular = pow(dotNL, 100.0f);

 

    float3 diffuseColor = float3(1.0, 0.5,0.35) * 0.75;//* 0.75 + (input.sign * 0.5 + 0.5) * 0.25;

 

    float3 color = diffuseColor * diffuse + specular * 0.25;

   

    return float4(color, 0);

}

 

3.   实时渲染截图

上图为初始的模型，下图为根据法线贴图和位移贴图进行细分得到的模型。

 

 

 

 

 

 

 

 

 

 

（1）正常渲染模式

 

 

 

 

 

 

 

 

 

 

 

（2）网格渲染模式

基于PhotoScan的模型生成技术
08-04 2264
基于图片生成模型的技术早已存在，也有若干软件可以模拟。俄毛子的PhotoScan软件，可以基于一组360度照片，生成逼真的高精度模型。从FoxEngine的实现上，不难看出，未来几年的次时代制作将是高度逼真的模型。所以，基于照片生成高模的技术可以作为次时代美术必不可少的辅助软件。 下面，我进行了简单的尝试，并附以简单效果截图。这里先是一组各个角度的照片素材。   通过PhotoScan，
一个用Windows SDK实现的时钟
10-20 642
为了更好的熟悉window程序设计，特编写了下面的小示例（参照Windows程序设计第二版），现将程序实现总结如下：程序运行图：程序代码如下：// header files#include "windows.h"#include "math.h"  // defines#define WINDOW_CLASS_NAME "3D Game" #defi
Nvidia SDK11 之 PNPatches（细化算法技术学习）
magr_lemon的专栏
08-10 858
PN-Triangles (也称作N-patches)是比较流行的处理粗糙模型细分算法技术，PN-Triangles算法能够将低分辨率模型转化为弯曲表面，该表面然后可以被重新绘制成由“高精曲面细分”的三角形所组成的网格，经常借助于Tessellation (曲面细分)技术创建外观更加平滑的模型。 在当今游戏中，我们认为理所当然的大量视觉假象都可以借助此类算法来消除。这些视觉假象包括人物...
Introduction to 3D Game Programming with DirectX 12 学习笔记之 --- 第十四章：曲面细分阶段
weixin_42441849的博客
11-23 875
代码工程地址： https://github.com/jiabaodan/Direct12BookReadingNotes 学习目标 使用曲面细分；
OpenSSL初学总结
热门推荐
12-29 1万+
OpenSSL初学总结2008年12月29日星期一最近一段时间看些关于OpenSSL加密函数的使用，现将一些使用总结如下：1、  OpenSSL简介：openssl是一个功能丰富且自包含的开源安全工具箱。它提供的主要功能有：SSL协议实现(包括SSLv2、SSLv3和TLSv1)、大量软算法(对称/非对称/摘要)、大数运算、非对称算法密钥生成、ASN.1编解码库、证书请求(PKCS
二进制、八进制、十进制、十六进制数的转换方法
03-25 9139
 二进制、八进制、十进制、十六进制数的转换方法一)、数制 计算机中采用的是二进制，因为二进制具有运算简单，易实现且可靠，为逻辑设计提供了有利的途径、节省设备等优点，为了便于描述，又常用八、十六进制作为二进制的缩写。 一般计数都采用进位计数，其特点是： (1)逢N进一，N是每种进位计数制表示一位数所需要的符号数目为基数。 (2)采用位置表示法，处在不同位置的数字所代表的值不同，而在固定位置上
关于几种排序方法的MFC程序
08-04 2786
最近复习了一下数据结构的课本，看了一下关于排序的算法，并编写了下面的小程序以练习。其中排序的算法主要包括：直接插入排序、希尔排序、冒泡排序、快速排序、简单选择排序和堆排序等几个。1、  直接插入排序（Straight Insertion Sort）直接插入排序是稳定的排序方法，它的基本操作是将一个记录插入到已排好的有序表中，从而得到一个新的、记录数增1的有序表。通常为了防止越界，常设r[0
使用DSkinLite美化界面
11-08 2731
           相信已经有很多人用过QQ2009了，自然也对其中的UI设计很感兴趣，觉得设计很是完美。但是这是怎么设计的呢？下面我介绍一个用来实现这种效果的设计库——DSkinLite（源于CodeProject）。下面通过一个演示程序来介绍使用过程：程序中，我主要对主窗口和两个通用对话框（打开对话框和浏览对话框）进行了换肤，这里我所有的窗口都使用了同一个皮肤（定义在XML文件中），
计算机软硬件信息获取程序实现
04-21 2618
计算机软硬件信息获取程序实现2008年9月22日星期一最近从msdn上看到了获取系统软硬件信息的API和操作注册表的API，所以就编写了一个小的演示程序来实现，主要实现过程：通过一个登录框登录，其中用户名（默认Administrator）是在程序运行时自动在注册表中生成的，并在登录按钮中查询用户密码是否有效。当成功登录后，再初始化函数中实现系统软硬件信息获取并以树控件视图的形式显示出来。可
打印系统日志（使用API）
04-14 1847
 打印系统日志（使用API）2009年4月13日星期一通常，我们在编写小型软件时，不太注重使用系统的日志维护功能，而是自己定义日志文件。但当我们的软件变的庞大时，为了更好的维护日志，最好的办法就是使用系统提供的日志功能，系统会自动帮我们进行维护。下面介绍几个打印日志的API：RegisterEventSource函数原型：HANDLE RegisterEventSource
解析从INI配置文件读取到操作命令
02-23 807
解析从INI配置文件读取到操作命令2009年2月23日星期一由于工作中遇到文件更新到开发，自然涉及到从配置文件中读取操作命令，以便中更新过程中进行操作。下面以工作中的Demo为示例：[Setting]Version=1.2.3.0[Files]umini_console.exe={desktop}install_driver.exe={thisdir}umini_o
各种数据类型的sizeof值
08-19 736
详细结果如下程序及运行结果：// SizeOfClass.cpp : 定义控制台应用程序的入口点。//#include "stdafx.h"#include using namespace std; int _tmain(int argc, _TCHAR* argv[]){     // int     short int a=15;     cout"
关于代码相关性的一点理解
10-25 669
关于代码相关性的一点理解2009-10-25通常在程序设计中，为了提高代码的重用，都尽量要减少代码之间的相关性。按照关联的强弱程度，可以分为以下几种：1、 硬关联如果A与B之间有关联，且B与A之间有强关联，那么A与B之间就存在这硬关联。如：// B.h#include “A.h”class B{           A   m_A;}; // A.h
一种较好的Singleton设计
01-17 595
  Normal 0 7.8 磅 0 2 false false false EN-US ZH-CN X-NONE
基于数据共享进行通信的服务编程
04-14 590
基于数据共享进行通信的服务编程2009年4月14日星期二通常为了提高程序的运行权限，如在系统启动是进行启动运行，就需要用到服务，这里简单的给出基于Win32应用程序框架的服务（和控制台类似），详细不再介绍，见代码注释。 void Init();                             // 初始化函数BOOL IsInstalled();            
现代C++的智能指针
04-06 581
为了更加高效安全的使用指针，智能指针应运而生。 1. unique_ptr （原auto_ptr，由于不够高效，已被否决）：动态分配对象以及当对象不再需要时自动执行清理，并且指针无法复制，只能通过std::move移动；     auto ptrA = unique_ptr(new Song(L"T", L"A"));     auto ptrB = ptrA;    // wrong!!!
cmd脚本-bat批处理-AdobeRemovePanel.zip
05-22
cmd脚本-bat批处理-AdobeRemovePanel.zip
HTML、CSS与JavaScript构建学生信息管理系统
最新发布
05-22
好的，以下是重新表述后的内容： 本次学生信息管理系统的效果页面代码较为复杂，主要涉及HTML、JS和CSS。在实现过程中，遇到了以下难点： 页面中有一个复选框，通过它的checked属性可以判断是否被选中。当点击该复选框时，需要将当前页面的这一列所有复选框的checked属性设置为相同的值，从而实现全选功能。 要实现仅选择当前页的功能，首先需要获取当前页面的页码，记为page。由于每一页设定只显示10条内容，因此可以通过以下规则计算当前页的起始条目索引：当前页的开始条数为(page - 1) * 10。 如果还有其他问题，可以评论或者通过邮箱（1079349989@qq.com）联系我。完整的代码可以在我的GitHub中找到，GitHub链接在本页面。
基于滑模观测器的无位置传感器控制Simulink永磁同步电机（PMSM）仿真模型 附资料 · 滑模观测器
05-22
内容概要：本文详细介绍了基于Simulink仿真平台的永磁同步电机(PMSM)滑模观测器无位置传感器控制策略的建模方法和技术细节。主要内容涵盖滑模观测器的工作原理，即通过电流观测反电动势并从中提取转子位置信息，以及具体实现步骤如滑模面设计、坐标变换、反电动势观测器和锁相环(PLL)设计等。文中还提供了MATLAB代码片段，帮助理解和实现关键部分。此外，针对常见的数值稳定性和参数调整问题给出了实用建议。 适合人群：从事电机控制系统设计的研究人员、工程师及高校相关专业师生。 使用场景及目标：①掌握PMSM无位置传感器控制的基本理论；②学会利用Simulink构建高效的滑模观测器控制模型；③解决实际工程中遇到的技术难题，提高系统性能。 其他说明：文章不仅提供理论指导，还包括大量实践经验分享，有助于读者快速上手并在实践中不断优化模型。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值