CreateIndexBuffer()

最新推荐文章于 2023-03-10 13:28:27 发布
最新推荐文章于 2023-03-10 13:28:27 发布
阅读量3.2k 收藏 1
点赞数
分类专栏： Direct3D API 文章标签： null class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yaoxinchao/article/details/7987271
版权 
创建索引缓冲  
HRESULT CreateIndexBuffer(  
  
     UINT Length,                             //索引缓冲区大小，按字节数计算  
  
     DWORD Usage,                             //索引缓冲区属性，和顶点缓冲区相同  
  
     D3DFORMAT Format,               //索引数组的元素格式，可以使16位或者32位  
  
     D3DPOOL Pool,                            //索引缓冲区内存位置  
  
     IDirect3DIndexBuffer9** ppIndexBuffer,            //索引缓冲区指针地址  
  
     HANDLE* pSharedHandle                    //保留参数，设为0  
);  




 
 
  
  Format：表示索引数组中的元素格式，他可以是16位整数或者32位的整数
 
 
 
 

  
  [in] Member of the 
  
  D3DFORMAT enumerated type, describing the format of the index buffer. For more information, see Remarks. The valid settings are the following:

  
  

   
   
    
    D3DFMT_INDEX16
   
   
   
   

    
    Indices are 16 bits each. 
   
   

   
   
    
    D3DFMT_INDEX32
   
   
   
   

    
    Indices are 32 bits each. 
   
   

  
  


 
 

 
 
  
  Pool
 
 
 
 

  
  [in] Member of the 
  
  D3DPOOL enumerated type, describing a valid memory class into which to place the resource

  
  


  
  


  
  
 //创建顶点缓冲区  
  
    if(FAILED(g_pd3dDevice->CreateVertexBuffer(9*sizeof(CUSTOMVERTEX),  
  
                                                  0, D3DFVF_CUSTOMVERTEX,  
  
                                                  D3DPOOL_DEFAULT,&g_pVB,NULL) ))  
  
    {  
  
                                 

  
        returnE_FAIL;  
  
    } 
  
    //创建索引缓冲区  
  
    if( FAILED(g_pd3dDevice->CreateIndexBuffer(24*sizeof(WORD),  
  
                                                0, D3DFMT_INDEX16, //索引类型  
  
                                                D3DPOOL_DEFAULT,&g_pIB,NULL) ))  
  
    {  
  
        returnE_FAIL;  
  
    } 



  
  


 
 

 
 

  
  
保存顶点索引值  
  
    //填充顶点缓冲区  
  
    VOID*pVertices;  
  
    if(FAILED(g_pVB->Lock(0, sizeof(g_Vertices),(void**)&pVertices,0) ) )  
  
        return E_FAIL;  
  
    memcpy(pVertices,g_Vertices,sizeof(g_Vertices));  
  
    g_pVB->Unlock();  
  
    //填充索引缓冲区  
  
    VOID*pIndices;  
  
    if(FAILED(g_pIB->Lock(0, sizeof(g_Indices),(void**)&pIndices,0 )) )  
  
        return E_FAIL;  
  
    memcpy(pIndices,g_Indices,sizeof(g_Indices));  
  
    g_pIB->Unlock(); 


  
  





  
  


  
  


  
  
 


 
 

                

        

        

    

  


    

      

        

            

              
                
                  yaoxinchao
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
OpenGL相机空间

				
			

			

				

					希望我的博客，能帮上你解决学习中工作中所遇到的问题
				

				

					03-20
					
					419
					
				

			

		

		

			
				
OpenGL相机空间OpenGL相机空间简介源代码剖析主要源代码
OpenGL相机空间简介
在上一系列课程中，我们看到了两种类型的转换。第一种类型更改了对象的位置（运动）、方向（旋转）或大小（缩放）。这些转换允许我们将对象放置在 3D 空间的任意位置。第二种类型是这些透视投影，它接受顶点在 3D 空间中的位置，并将其投影到 2D（即平面上）。当坐标转换为 2D 时，将坐标转换为屏幕空间非常容易。这些坐标用于栅格化由对象（点、线或三角形）组成的原始要素。
马赛克的最后一个元素是相机的位置。在前面的所有课程中，

			
		

	



                

              
                



	

		

			

				
					
OpenGL索引呈现

				
			

			

				

					希望我的博客，能帮上你解决学习中工作中所遇到的问题
				

				

					03-20
					
					271
					
				

			

		

		

			
				
OpenGL索引呈现OpenGL索引呈现简介源代码剖析主要源代码
OpenGL索引呈现简介
OpenGL 提供多种呈现功能。本课之前使用的 glDrawArrays（） 属于"顺序呈现"类别。这意味着从指定偏移的开始位置扫描顶点缓冲区，并且每 X 个顶点（点 1 个，线 2 个，依次）成为原始缓冲区。此方法易于使用，但缺点是，如果顶点涉及多个原始值，则顶点缓冲区中应多次包含顶点缓冲区。也就是说，没有交换的概念。交换提供"索引呈现"类别中的呈现功能。顶点缓冲区的附加组件使用索引缓冲区，其中包含顶点缓冲区中的顶

			
		

	



                


  
              

                


	

		

			

				
					
CreateVertexBuffer问题的代码

				
			

			

				

					10-15
				

			

		

		

			
				
CreateVertexBufferd的问题 很郁闷的问题 希望帮忙解决一下

			
		

	





	

		

			

				
					
CreateVertexBuffer和CreateIndexBuffer

				
			

			

				

					weixin_33728268的博客
				

				

					11-07
					
					262
					
				

			

		

		

			
				
CreateVertexBuffer的形参说明
HRESULT CreateVertexBuffer(  UINT Length,  DWORD Usage,  DWORD FVF,  D3DPOOL Pool,  IDirect3DVertexBuffer9** ppVertexBuffer,  HANDLE* pSharedHandle);­length：指定缓冲区的大小，以字节为单位。
...

			
		

	



		

			
		



	

		

			

				
					
创建Index Buffer(索引缓冲区)--索引缓冲区包含索引数据，为渲染做好准备

				
			

			

				

					qq_15821883的博客
				

				

					03-22
					
					854
					
				

			

		

		

			
				
一、创建一个索引缓冲区Buffer  


ID3D11Buffer*g_pIndexBuffer = nullptr;
unsigned int indices[] = {0, 1, 2};

二、初始化D3D11_BUFFER_DESC，BindFlags传递D3D11_BIND_INDEX_BUFFER


 // 填充D3D11_BUFFER_DESC 
 D3D11_BUFFER_DESC bufferDesc;
 bufferDesc.Usage           = D3D11_...

			
		

	





	

		

			

				
					
IDirect3DDevice9::CreateIndexBuffer

				
			

			

				

					vivianke的专栏
				

				

					10-25
					
					420
					
				

			

		

		

			
				
电子书《精通DirectX.3D图形与动画程序设计.王德才.pdf》p53

HRESULT CreateVertexBuffer(
  UINT Length,
  DWORD Usage,
  DWORD FVF,
  D3DPOOL Pool,
  IDirect3DVertexBuffer9** ppVertexBuffer,
  HANDLE* pSharedHandle
);
L

			
		

	





	

		

			

				
					
VC，DirectX8开发实例（index buffer）

				
			

			

				

					新宾二亮子
				

				

					12-05
					
					944
					
				

			

		

		

			
				
 // VC，DirectX8开发实例（index buffer）// http://wisdom.sakura.ne.jp/system/directx/dxg10.html//画出复杂颜色的图形 #include #include #include  #define TITLE TEXT("Kitty on your lap")#define D3D

			
		

	





	

		

			

				
					
OpenGL点光源

				
			

			

				

					希望我的博客，能帮上你解决学习中工作中所遇到的问题
				

				

					03-20
					
					877
					
				

			

		

		

			
				
OpenGL点光源OpenGL点光源简介源代码剖析主要源代码
OpenGL点光源简介
我们研究了代表定向光的三种主要照明模式（背景、散射和反射）。这是一个以方向为特征的光，但它没有任何位置。因此，它不会在远处减弱（事实上，您无法找到从这种光源到物体的距离）。现在，我们将考虑一个点光源，当远离对象时，该光源具有位置和衰减效果。点光的一个经典例子是灯泡。当你在一个小房间里发光时，你没有注意到衰弱的效果，但如果你把它带到外面，你就会立即看到它闪耀的距离的局限性。请注意，定向光的光方向对于点光是动态的。这是因为点光

			
		

	





	

		

			

				
					
OpenGL相机控制之一

				
			

			

				

					希望我的博客，能帮上你解决学习中工作中所遇到的问题
				

				

					03-20
					
					460
					
				

			

		

		

			
				
OpenGL相机控制OpenGL相机控制简介源代码剖析主要源代码
OpenGL相机控制简介
在上一课中，我们研究了如何将相机安装在 3D 空间的任意位置。下一步是允许用户管理它。控制将是免费的 - 用户可以向四面八方移动它。摄像机将由两个输入设备控制：键盘将更改位置，鼠标将更改浏览方向。这与第一人称射击游戏提供的东西非常相似。本课将重点放在键盘上，下一课将放在鼠标上。
我们将以熟悉的方式添加对 4 个键的支持。请记住，我们的相机由其位置、方向向量和顶部向量决定。当我们使用键盘时，只有位置会改变。我们不能倾斜

			
		

	





	

		

			

				
					
OpenGL合并转换

				
			

			

				

					希望我的博客，能帮上你解决学习中工作中所遇到的问题
				

				

					03-20
					
					364
					
				

			

		

		

			
				
OpenGL合并转换OpenGL合并转换简介源代码剖析主要源代码
OpenGL合并转换简介
在上一课中，我们发现了一些转换，这些转换在 3D 空间中灵活地移动对象。我们还有许多要研究的（相机控制和透视投影），但正如您可能已经猜到的，我们需要结合转换。在大多数情况下，您希望缩放对象以匹配实际纵横比、旋转以获得正确的方向、移动到某处等。为了执行上述转换，我们需要将第一个转换矩阵乘以向量，然后将第二个矩阵乘以第一个操作的结果，然后将第三个矩阵乘以先前计算的结果。这将继续，直到所有矩阵乘以向量。最简单的方法就是将所

			
		

	





	

		

			

				
					
Vertex buffers/Index buffer

				
			

			

				

					J__yaoyao  的博客
				

				

					03-10
					
					373
					
				

			

		

		

			
				
Vulkan Tutorial 阅读记录（机翻）

			
		

	





	

		

			

				
					
[OpenGL] 使用Index Buffers 绘制一个Square，源代码详细注释

				
			

			

				

					...
				

				

					05-18
					
					569
					
				

			

		

		

			
				
使用Index Buffer技术可以实现顶点复用，极大降低数据的冗余度





// main.cpp
#include <GL/glew.h>
#include <iostream>
#include <GLFW/glfw3.h>

#include <fstream>
#include <string>
#include <sstream>

struct ShaderProgramSource
{
	std::string V.

			
		

	





	

		

			

				
					
使用IndexBuffer（索引）

				
			

			

				

					Shutely@Xu.Dening的专栏
				

				

					10-24
					
					1516
					
				

			

		

		

			
				
今前面我们使用VertexBuffer渲染了一个立方体，我用的是TriangleStrip,共用了18个顶点。而事实上，我们的立方本只有8个顶点，以前的渲染方法尽足足多了10个顶点，对于像立方体这像一个小的实体来说，这并不会降低我们的执行效率和占用太大的空间，但是，如果对于一个成千上万的顶点的实体来说，重复使用顶点可是一个不大的开销！如何减小开销呢？可以使用IndexBuffer。它为每个顶点建立

			
		

	





	

		

			

				
					
Lucene学习笔记--创建索引(Create Index)

				
			

			

				

					cgfish的专栏
				

				

					06-29
					
					196
					
				

			

		

		

			
				
 
public void createIndex() {
		try {
			File file = new File(FILE_PATH);	//FILE_PATH为所要创建索引的文件的绝对地址，在地址完全可以用String来代替
			Document doc = new Document();
			IndexWriter indexWriter = new IndexWrit...

			
		

	





	

		

			

				
					
CreateVertexBuffer()

				
			

			

				

					假装狠牛逼
				

				

					09-17
					
					4425
					
				

			

		

		

			
				
HRESULT CreateVertexBuffer(  
  
    UINT Length,                                //顶点缓冲区的大小，按字节数算  
  
    DWORD Usage,                                //顶点缓冲区属性  
  
    DWORD FVF,

			
		

	





	

		

			

				
					
跟我一起学OpenGL-矩形之index buffer的使用

				
			

			

				

					xiadidi的专栏
				

				

					05-01
					
					1969
					
				

			

		

		

			
				
上一篇文章讲述了如何画一个三角形， 这篇文章讲如何画一个矩形。 大家肯定会想到两个三角形拼起来以后不就是个矩形吗， 思路就是这样的。


但是从上面可以看出使用glDrawArrays画矩形需要六个顶点， 有的顶点重复定义了两次，这样浪费了资源。实际上矩形只需要定义4个顶点就可以了，下面就是index buffer的使用
使用glDrawElements来画。

			
		

	





	

		

			

				
					
Vulkan学习（十）: Staging Buffer & Index Buffer

				
			

			

				

					jiamada的博客
				

				

					06-07
					
					999
					
				

			

		

		

			
				
目录Staging BufferTransfer QueueAbstracting Buffer CreationUsing a staging bufferConclusionIndex BufferIndex buffer creationUsing an index bufferCode
Staging Buffer
Transfer Queue
  缓冲区复制命令需要一个支持传输操作的队列族，使用 VK_QUEUE_TRANSFER_BIT 表示。 好消息是，任何具有 VK_QUEUE_GRAPHI

			
		

	





	

		

			

				
					
Direct学习3：CreateVertexBuffer

				
			

			

				

					
				

				

					03-17
					
					3838
					
				

			

		

		

			
				
在环境初始化后，我们要做到就是画简单图形了HRESULT CreateVertexBuffer(  UINT Length,  DWORD Usage,  DWORD FVF,  D3DPOOL Pool,  IDirect3DVertexBuffer9** ppVertexBuffer,  HANDLE* pSharedHandle);此函数是用来创建一段VertexBuffer的，就是在D3D

			
		

	





	

		

			

				
					
OpenGL ES2.0的IndexBuffer注意事项

				
			

			

				

					zhanyong168的专栏
				

				

					12-11
					
					1434
					
				

			

		

		

			
				
OpenGL ES2.0的IndexBuffer注意事项
void glDrawElements( GLenum mode,

GLsizei count, 
GLenum type, 
  const GLvoid * indices);
 
Parameters
mode     Specifies what kind of primitives to render. Symb

			
		

	





	

		

			

				
					
visual studio 1.实现三维图形的坐标系之间的变换（世界坐标、物坐标、屏幕坐标）以及三维图形几何变换。修改示例图形为给定的模型，将立方体顶点的三维坐标（x，y，z）及变量改为三棱锥顶点的三维坐标及变量相关代码

					
最新发布

				
			

			

				

					05-10
				

			

		

		

			
				
在 Visual Studio 中实现三维图形的坐标系之间的变换和三维图形几何变换，可以使用 DirectX API。以下是修改示例图形为给定的三棱锥模型的代码示例：

```c++
#include <Windows.h>
#include <d3d11.h>
#include <d3dcompiler.h>
#include <DirectXMath.h>
#include <iostream>

#pragma comment(lib, "d3d11.lib")
#pragma comment(lib, "d3dcompiler.lib")

using namespace DirectX;

// 定义三棱锥顶点数据类型
struct Vertex
{
    XMFLOAT3 position;
    XMFLOAT4 color;
};

// 定义矩阵缓冲区数据类型
struct MatrixBuffer
{
    XMMATRIX world;
    XMMATRIX view;
    XMMATRIX projection;
};

// 定义全局变量
HWND hwnd = NULL;
const int Width = 800;
const int Height = 600;
IDXGISwapChain* swapChain;
ID3D11Device* d3d11Device;
ID3D11DeviceContext* d3d11DeviceContext;
ID3D11RenderTargetView* renderTargetView;
ID3D11DepthStencilView* depthStencilView;
ID3D11Texture2D* depthStencilBuffer;
ID3D11InputLayout* inputLayout;
ID3D11VertexShader* vertexShader;
ID3D11PixelShader* pixelShader;
ID3D11Buffer* vertexBuffer;
ID3D11Buffer* indexBuffer;
ID3D11Buffer* matrixBuffer;
XMMATRIX worldMatrix;
XMMATRIX viewMatrix;
XMMATRIX projectionMatrix;

// 创建交换链
bool CreateSwapChain()
{
    DXGI_SWAP_CHAIN_DESC swapChainDesc = {};
    swapChainDesc.BufferCount = 1;
    swapChainDesc.BufferDesc.Width = Width;
    swapChainDesc.BufferDesc.Height = Height;
    swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    swapChainDesc.BufferDesc.RefreshRate.Numerator = 60;
    swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
    swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
    swapChainDesc.OutputWindow = hwnd;
    swapChainDesc.SampleDesc.Count = 1;
    swapChainDesc.SampleDesc.Quality = 0;
    swapChainDesc.Windowed = TRUE;

    D3D_FEATURE_LEVEL featureLevel = D3D_FEATURE_LEVEL_11_0;
    HRESULT hr = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, &featureLevel, 1, D3D11_SDK_VERSION, &swapChainDesc, &swapChain, &d3d11Device, NULL, &d3d11DeviceContext);
    if (FAILED(hr))
    {
        std::cout << "Failed to create swap chain" << std::endl;
        return false;
    }

    return true;
}

// 创建渲染目标视图
bool CreateRenderTargetView()
{
    ID3D11Texture2D* backBuffer;
    HRESULT hr = swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&backBuffer);
    if (FAILED(hr))
    {
        std::cout << "Failed to get back buffer" << std::endl;
        return false;
    }

    hr = d3d11Device->CreateRenderTargetView(backBuffer, NULL, &renderTargetView);
    if (FAILED(hr))
    {
        std::cout << "Failed to create render target view" << std::endl;
        return false;
    }

    backBuffer->Release();

    return true;
}

// 创建深度模板缓冲区和深度模板视图
bool CreateDepthStencilBufferAndView()
{
    D3D11_TEXTURE2D_DESC depthStencilDesc = {};
    depthStencilDesc.Width = Width;
    depthStencilDesc.Height = Height;
    depthStencilDesc.MipLevels = 1;
    depthStencilDesc.ArraySize = 1;
    depthStencilDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
    depthStencilDesc.SampleDesc.Count = 1;
    depthStencilDesc.SampleDesc.Quality = 0;
    depthStencilDesc.Usage = D3D11_USAGE_DEFAULT;
    depthStencilDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
    depthStencilDesc.CPUAccessFlags = 0;
    depthStencilDesc.MiscFlags = 0;

    HRESULT hr = d3d11Device->CreateTexture2D(&depthStencilDesc, NULL, &depthStencilBuffer);
    if (FAILED(hr))
    {
        std::cout << "Failed to create depth stencil buffer" << std::endl;
        return false;
    }

    hr = d3d11Device->CreateDepthStencilView(depthStencilBuffer, NULL, &depthStencilView);
    if (FAILED(hr))
    {
        std::cout << "Failed to create depth stencil view" << std::endl;
        return false;
    }

    return true;
}

// 创建顶点着色器
bool CreateVertexShader()
{
    ID3DBlob* vertexShaderBlob;
    HRESULT hr = D3DCompileFromFile(L"VertexShader.hlsl", NULL, NULL, "main", "vs_5_0", 0, 0, &vertexShaderBlob, NULL);
    if (FAILED(hr))
    {
        std::cout << "Failed to compile vertex shader" << std::endl;
        return false;
    }

    hr = d3d11Device->CreateVertexShader(vertexShaderBlob->GetBufferPointer(), vertexShaderBlob->GetBufferSize(), NULL, &vertexShader);
    if (FAILED(hr))
    {
        std::cout << "Failed to create vertex shader" << std::endl;
        return false;
    }

    // 定义顶点输入布局
    D3D11_INPUT_ELEMENT_DESC inputElementDesc[] =
    {
        {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0},
        {"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0}
    };

    hr = d3d11Device->CreateInputLayout(inputElementDesc, 2, vertexShaderBlob->GetBufferPointer(), vertexShaderBlob->GetBufferSize(), &inputLayout);
    if (FAILED(hr))
    {
        std::cout << "Failed to create input layout" << std::endl;
        return false;
    }

    vertexShaderBlob->Release();

    return true;
}

// 创建像素着色器
bool CreatePixelShader()
{
    ID3DBlob* pixelShaderBlob;
    HRESULT hr = D3DCompileFromFile(L"PixelShader.hlsl", NULL, NULL, "main", "ps_5_0", 0, 0, &pixelShaderBlob, NULL);
    if (FAILED(hr))
    {
        std::cout << "Failed to compile pixel shader" << std::endl;
        return false;
    }

    hr = d3d11Device->CreatePixelShader(pixelShaderBlob->GetBufferPointer(), pixelShaderBlob->GetBufferSize(), NULL, &pixelShader);
    if (FAILED(hr))
    {
        std::cout << "Failed to create pixel shader" << std::endl;
        return false;
    }

    pixelShaderBlob->Release();

    return true;
}

// 创建顶点缓冲区
bool CreateVertexBuffer()
{
    // 定义三棱锥的顶点数据
    Vertex vertices[] =
    {
        {XMFLOAT3(0.0f, 0.0f, 0.0f), XMFLOAT4(1.0f, 0.0f, 0.0f, 1.0f)},  // A
        {XMFLOAT3(1.0f, 0.0f, 0.0f), XMFLOAT4(0.0f, 1.0f, 0.0f, 1.0f)},  // B
        {XMFLOAT3(1.0f, 0.0f, 1.0f), XMFLOAT4(0.0f, 0.0f, 1.0f, 1.0f)},  // C
        {XMFLOAT3(0.0f, 0.0f, 1.0f), XMFLOAT4(1.0f, 1.0f, 0.0f, 1.0f)},  // D
        {XMFLOAT3(0.5f, 1.0f, 0.5f), XMFLOAT4(1.0f, 1.0f, 1.0f, 1.0f)}   // E
    };

    D3D11_BUFFER_DESC vertexBufferDesc = {};
    vertexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    vertexBufferDesc.ByteWidth = sizeof(Vertex) * 5;
    vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    vertexBufferDesc.CPUAccessFlags = 0;
    vertexBufferDesc.MiscFlags = 0;

    D3D11_SUBRESOURCE_DATA vertexBufferData = {};
    vertexBufferData.pSysMem = vertices;

    HRESULT hr = d3d11Device->CreateBuffer(&vertexBufferDesc, &vertexBufferData, &vertexBuffer);
    if (FAILED(hr))
    {
        std::cout << "Failed to create vertex buffer" << std::endl;
        return false;
    }

    return true;
}

// 创建索引缓冲区
bool CreateIndexBuffer()
{
    // 定义三棱锥的索引数据
    unsigned int indices[] =
    {
        0, 1, 2,   // 底面三角形 ABC
        0, 2, 3,   // 底面三角形 ACD
        0, 1, 4,   // 侧面三角形 ABE
        1, 2, 4,   // 侧面三角形 BCE
        2, 3, 4,   // 侧面三角形 CDE
        3, 0, 4    // 侧面三角形 DAE
    };

    D3D11_BUFFER_DESC indexBufferDesc = {};
    indexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    indexBufferDesc.ByteWidth = sizeof(unsigned int) * 18;
    indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
    indexBufferDesc.CPUAccessFlags = 0;
    indexBufferDesc.MiscFlags = 0;

    D3D11_SUBRESOURCE_DATA indexBufferData = {};
    indexBufferData.pSysMem = indices;

    HRESULT hr = d3d11Device->CreateBuffer(&indexBufferDesc, &indexBufferData, &indexBuffer);
    if (FAILED(hr))
    {
        std::cout << "Failed to create index buffer" << std::endl;
        return false;
    }

    return true;
}

// 创建矩阵缓冲区
bool CreateMatrixBuffer()
{
    D3D11_BUFFER_DESC matrixBufferDesc = {};
    matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
    matrixBufferDesc.ByteWidth = sizeof(MatrixBuffer);
    matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    matrixBufferDesc.MiscFlags = 0;

    HRESULT hr = d3d11Device->CreateBuffer(&matrixBufferDesc, NULL, &matrixBuffer);
    if (FAILED(hr))
    {
        std::cout << "Failed to create matrix buffer" << std::endl;
        return false;
    }

    return true;
}

// 初始化 DirectX
bool InitDirectX()
{
    if (!CreateSwapChain())
    {
        return false;
    }

    if (!CreateRenderTargetView())
    {
        return false;
    }

    if (!CreateDepthStencilBufferAndView())
    {
        return false;
    }

    d3d11DeviceContext->OMSetRenderTargets(1, &renderTargetView, depthStencilView);

    D3D11_VIEWPORT viewport = {};
    viewport.TopLeftX = 0;
    viewport.TopLeftY = 0;
    viewport.Width = Width;
    viewport.Height = Height;
    viewport.MinDepth = 0.0f;
    viewport.MaxDepth = 1.0f;

    d3d11DeviceContext->RSSetViewports(1, &viewport);

    if (!CreateVertexShader())
    {
        return false;
    }

    if (!CreatePixelShader())
    {
        return false;
    }

    if (!CreateVertexBuffer())
    {
        return false;
    }

    if (!CreateIndexBuffer())
    {
        return false;
    }

    if (!CreateMatrixBuffer())
    {
        return false;
    }

    return true;
}

// 渲染场景
void RenderScene()
{
    // 设置顶点缓冲区和索引缓冲区
    unsigned int stride = sizeof(Vertex);
    unsigned int offset = 0;
    d3d11DeviceContext->IASetVertexBuffers(0, 1, &vertexBuffer, &stride, &offset);
    d3d11DeviceContext->IASetIndexBuffer(indexBuffer, DXGI_FORMAT_R32_UINT, 0);

    // 设置输入布局
    d3d11DeviceContext->IASetInputLayout(inputLayout);

    // 设置基本图元类型
    d3d11DeviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

    // 更新矩阵缓冲区
    MatrixBuffer matrixBufferData = {};
    matrixBufferData.world = worldMatrix;
    matrixBufferData.view = viewMatrix;
    matrixBufferData.projection = projectionMatrix;

    D3D11_MAPPED_SUBRESOURCE mappedResource = {};
    HRESULT hr = d3d11DeviceContext->Map(matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
    if (FAILED(hr))
    {
        std::cout << "Failed to map matrix buffer" << std::endl;
        return;
    }

    memcpy(mappedResource.pData, &matrixBufferData, sizeof(MatrixBuffer));

    d3d11DeviceContext->Unmap(matrixBuffer, 0);

    d3d11DeviceContext->VSSetConstantBuffers(0, 1, &matrixBuffer);

    // 设置顶点着色器和像素着色器
    d3d11DeviceContext->VSSetShader(vertexShader, NULL, 0);
    d3d11DeviceContext->PSSetShader(pixelShader, NULL, 0);

    // 绘制图形
    d3d11DeviceContext->DrawIndexed(18, 0, 0);

    // 切换缓冲区，显示渲染结果
    swapChain->Present(0, 0);
}

// 释放资源
void Release()
{
    if (matrixBuffer)
    {
        matrixBuffer->Release();
    }

    if (indexBuffer)
    {
        indexBuffer->Release();
    }

    if (vertexBuffer)
    {
        vertexBuffer->Release();
    }

    if (pixelShader)
    {
        pixelShader->Release();
    }

    if (vertexShader)
    {
        vertexShader->Release();
    }

    if (inputLayout)
    {
        inputLayout->Release();
    }

    if (depthStencilView)
    {
        depthStencilView->Release();
    }

    if (depthStencilBuffer)
    {
        depthStencilBuffer->Release();
    }

    if (renderTargetView)
    {
        renderTargetView->Release();
    }

    if (swapChain)
    {
        swapChain->Release();
    }

    if (d3d11DeviceContext)
    {
        d3d11DeviceContext->Release();
    }

    if (d3d11Device)
    {
        d3d11Device->Release();
    }
}

// 窗口过程函数
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg)
    {
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    }

    return DefWindowProc(hwnd, msg, wParam, lParam);
}

int main()
{
    // 注册窗口类
    HINSTANCE hInstance = GetModuleHandle(NULL);

    WNDCLASSEX wc = {};
    wc.cbSize = sizeof(WNDCLASSEX);
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = WndProc;
    wc.hInstance = hInstance;
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.lpszClassName = L"DirectXWindowClass";

    RegisterClassEx(&wc);

    // 创建窗口
    hwnd = CreateWindowEx(0, L"DirectXWindowClass", L"DirectX Window", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, Width, Height, NULL, NULL, hInstance, NULL);
    if (hwnd == NULL)
    {
        std::cout << "Failed to create window" << std::endl;
        return 0;
    }

    ShowWindow(hwnd, SW_SHOW);

    // 初始化 DirectX
    if (!InitDirectX())
    {
        Release();
        return 0;
    }

    // 设置世界坐标系、物坐标系和屏幕坐标系的变换矩阵
    worldMatrix = XMMatrixIdentity();
    viewMatrix = XMMatrixLookAtLH(XMVectorSet(0.0f, 1.5f, -3.0f, 0.0f), XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f), XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f));
    projectionMatrix = XMMatrixPerspectiveFovLH(XM_PIDIV4,

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值