Создание заготовки для написания приложений с использованием DirectX 11, DirectX10, DirectX 9 ( три в одном)

[challengerr]

Заготовка на DirectX 9,
DirectX10,
DirectX11

Ждем выхода DirectX 12, выпущенного Microsoft в этом году.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <windows.h>
#include <d3d9.h>
#include <d3dx9.h>
#include <d3d11.h>
#include <d3dx11.h>
#include <xnamath.h>
#include <d3dcompiler.h>
#include <d3d10.h>
#include <d3dx10.h>

#pragma comment(lib, "user32.lib");
#pragma comment(lib, "kernel32.lib");
#pragma comment(lib, "gdi32.lib");
#pragma comment(lib,"d3d9.lib");
#pragma comment(lib,"d3dx9.lib");
#pragma comment(lib,"d3d10.lib");
#pragma comment(lib,"d3dx10.lib");
#pragma comment(lib,"d3d11.lib");
#pragma comment(lib,"d3dx11.lib");

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

struct h_program
{
WNDCLASSEX wc;
MSG msg;
HWND hwnd;

int n;

// DirectX 9
LPDIRECT3D9 d3d;
LPDIRECT3DDEVICE ddev;
LPDIRECT3DVERTEXBUFFER9 vb;

// DirectX 11
ID3D11Device* devdx11;
ID3D11DeviceContext* cdx11;
IDXGISwapChain* sdx11;
ID3D11RenderTargetView* rdx11;
ID3D11VertexShader* vdx11;
ID3D11PixelShader* pdx11;
ID3D11InputLayout* ildx11;
ID3D11Buffer* bufdx11;

D3D10_DRIVER_TYPE dt;
ID3D10Device* DD;
IDXGISwapChain* sch;
ID3D10RenderTargetView* rtv;
ID3D10Effect* eff;
ID3D10EffectTechnique* tech;
ID3D10InputLayout* il;
ID3D10Buffer* bf;
ID3D10DepthStencilView* depth_stencil_view;
ID3D10Texture2D* depth_stencil;
ID3D10EffectTechnique* tech_light;
ID3D10Buffer* vbf;
ID3D10Buffer* ibf;
ID3D10EffectMatrixVariable* world;
ID3D10EffectMatrixVariable* view;
ID3D10EffectMatrixVariable* projection;
ID3D10EffectVectorVariable* light_direction;
ID3D10EffectVectorVariable* light_color;
ID3D10EffectVectorVariable* output_color;
D3DXMATRIX mworld;
D3DXMATRIX mview;
D3DXMATRIX mprojection;
ID3D10Buffer* vbf2;
ID3D10Buffer* ibf2;

// продолжение в следующем сообщении

[challengerr]

Продолжение
DirectX11

UINT width, height;
D3D_DRIVER_TYPE dtype;
D3D_FEATURE_LEVEL flevel;

struct vertexdx11 { XMFLOAT3 pos; };

void getwindowsize() { RECT rc; GetClientRect(hand, &rc); 
width = rc.right - rc.left; height = rc.bottom - rc.top; }
void constructor_directx11() { dtype=D3D_DRIVER_TYPE_NULL; flevel=D3D_FEATURE_LEVEL_11_0;
 devdx11=NULL; cdx11=NULL; 
sdx11=NULL; rdx11=NULL; vdx11=NULL; pdx11=NULL; ildx11=NULL; bufdx11=NULL; }

void initialize_directx11(){ constructor_directx11(); UINT create_device_flags, 
num_driver_types, num_feature_levels, driver_type_index; DXGI_SWAP_CHAIN_DESC sd; D3D_DRIVER_TYPE drivertypes[]={ D3D_DRIVER_TYPE_HARDWARE, 
D3D_DRIVER_TYPE_WARD, D3D_DRIVER_TYPE_REFERENCE };
D3D_FEATURE_LEVEL featurelevels[] = { D3D_FEATURE_LEVEL_11_0, 
D3D_FEATURE_LEVEL_10, D3D_FEATURE_LEVEL_10_0 };
getwindowsize(); create_device_flags = 0;
 num_driver_types = sizeof(drivertypes) / sizeof(drivertypes[0]);
 num_feature_levels = sizeof(featurelevels)/sizeof(featurelevels[0]); ZeroMemory(&sd, sizeof(sd));
 sd.BufferCount =1; sd.BufferDesc.Width = width;
 sd.BufferDesc.Height = height; sd.BufferDesc.Format =DXGI_FORMAT_R8G8B8A8_UNORM; 
sd.BufferDesc.RefreshRate.Numerator = 60; sd.BufferDesc.RefreshRate.Denominator=1; sd.BufferUsage=DXGI_USAGE_RENDER_TARGET_OUTPUT; 
sd.OutputWindow=hwnd; sd.SampleDesc.Count =1;
 sd.SampleDesc.Quality=0; sd.Windowed=TRUE;
for(driver_type_index=0; driver_type_index<num_driver_types;driver_type_index++)
 { dtype=drivertypes[driver_type_index]; if(SUCCEEDED(D3D11CreateDeviceAndSwapChain(NULL, dtype, NULL, 
create_device_flags, featurelevels, num_feature_levels, D3D11_SDK_VERSION, &sd,
 &sdx11, &devdx11, &flevel, &cdx11))){break;}}

ID3D11Texture2D* pBackBuffer; pBackBuffer=NULL;

if(sdx11) sdx11->GetBuffer(0, __uuidof(ID3D11Texture2D),(LPVOID*)&pBackBuffer);
 if(devdx11) devdx11->CreateRenderTargetView(pBackBuffer, NULL, &rdx11);
if(pBackBuffer) pBackBuffer->Release(); if(cdx11) cdx11->OMSetRenderTargets(1,&rdx11, NULL); 
D3D11_VIEWPORT vp; vp.Width =(FLOAT) width; vp.Height =(FLOAT) height;
 vp.MinDepth=0.0f; vp.MaxDepth=1.0f; vp.TopLeftX =0; vp.TopLeftY = 0;
. if(cdx11) cdx11->RSSetViewports(1, &vp); initialize_shader_dx11();}

void shutdown_directx11(){ if(cdx11) cdx11->ClearState();
 if(bufdx11) bufdx11->Release(); if(ildx11) ildx11->Release();
 if(vdx11) vdx11->Release(); if(pdx11) pdx11->Release(); 
 if(rdx11) rdx11->Release(); if(cdx11) cdx11->Release(); if (devdx11) devdx11->Release(); }
// продолжение в следующем сообщении : инициализация пиксельных и вершинных шейдеров из файла

Инициализация пиксельного и вершинного шейдера из файла

void initialize_shader_dx11()
{
UINT num_elements, stride, offset;
D3D11_INPUT_ELEMENT_DESC layout[]={{"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0,0, D3D11_INPUT_PER_VERTEX_DATA, 0}};
 D3D11_BUFFER_DESC bd; D3D11_SUBRESOURCE_DATA idata; ID3DBlob* errblobdx11;
 ID3DBlob* pblobdx11; num_elements=sizeof(layout)/sizeof(layout[0]);
 blobdx11=NULL; errblobdx11=NULL; pblobdx11=NULL; stride=sizeof(vertexdx11); offset=0;


if(devdx11) D3DX11CompileFromFile("effdx11.fx", NULL, NULL, "VS", "vs_4_0", D3DCOMPILE_ENABLE_STRICTNESS, 0, NULL, &blobdx11, &errblobdx11, NULL); 
if(devdx11) devdx11->CreateVertexShader(blobdx11->GetBufferPointer(),
 blobdx11->GetBufferSize(), NULL, &vdx11);
 if(devdx11) devdx11->CreateInputLayout(layout, num_elements, 
blobdx11->GetBufferPointer(), blobdx11->GetBufferSize(), &ildx11);
 if(blobdx11) blobdx11->Release(); blobdx11 =NULL;
 if(errblobdx11) errblobdx11->Release(); errblobdx11 =NULL;
 if(cdx11) cdx11->IASetInputLayout(ildx11); 
if(devdx11) D3DX11CompileFromFile("effdx11.fx",NULL,NULL,"PS","ps_4_0", 
D3DCOMPILE_ENABLE_STRICTNESS, 0, NULL, &pblobdx11,&errblobdx11, NULL);

if(devdx11) devdx11->CreatePixelShader(pblobdx11->GetBufferPointer(),
pblobdx11->GetBufferSize(), NULL,&pdx11);


vertexdx11 vertices[]= {XMFLOAT3(0.0f, 0.0f, 0.5f), XMFLOAT3(0.5f, 0.5f, 0.5f),
 XMFLOAT3(0.5f, 0.0f, 0.5f)};
ZeroMemory(&bd, sizeof(bd)); bd.Usage = D3D11_USAGE_DEFAULT;
 bd,ByteWidth = sizeof(vertexdx11)*3; 
bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
 bd. CPUAccessFlags=0; ZeroMemory(&idata, sizeof(idata));
 idata.pSysMem = vertices; if(devdx11) devdx11->CreateBuffer(&bd,&idata,&bufdx11); if(cdx11)cdx11->IASetVertexBuffers(0,1,&bufdx11,&stride, &offset);
 if(cdx11) cdx11->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
}

void render11(){ float ccolor[4]={0.0f, 0.125f, 0.3f, 1.0f}; if(cdx11)cdx11->ClearRenderTargetView(rdx11, ccolor);
 if(cdx11) cdx11->VSSetShader(vdx11, NULL, 0);
 if(cdx11) cdx11->PSSetShader(pdx11, NULL,0);
 if(cdx11) cdx11->Draw(3,0); if(sdx11) sdx11) sdx->Present(0,0);}

[challengerr]

void initialize_directx10()
{
UINT create_device_flags, num_driver_types, driver_type_index; DXGI_SWAP_CHAIN_DESC sd; dd=0; sch=0; rtv=0; eff=0; tech=0; il=0; bf=0; depth_stencil=0; tech_light=0; vbf=0; ibf=0; world=0; view=0; projection=0; light_direction=0; light_color=0; output_color=0;

getwindowsize();

create_device_flags=0; D3D10_DRIVER_TYPE driver_types[]={D3D10_DRIVER_TYPE_HARDWARE, D3D10_DRIVER_TYPE_REFERENCE};
num_driver_types=sizeof(driver_types)/sizeof(driver_types[0]);

ZeroMemory(&sd, sizeof(sd)); sd.BufferCount=1; sd.BufferDesc.Width= width; sd.BufferDesc.Height = height; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.BufferDesc.RefreshRate.Numerator=60; sd.BufferDesc.RefreshRate.Denominator=1; sd.BufferUsage=DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.OutputWindow=hwnd; sd.SampleDesc.Count=1; sd.SampleDesc.Quality=0; sd.Windowed =TRUE;

for(driver_type_index=0; driver_type_index<num_driver_types; driver_type_index++){ dt= driver_types[driver_type_index]; if(SUCCEEDED(D3D10CreateDeviceAndSwapChain(NULL, dt, NULL, create_device_flags, D3D10_SDK_VERSION, &sd, &sch, &dd))) { break;}}
ID3D10Texture2D* pBackBuffer; if(sch) sch->GetBuffer(0, __uuidof(ID3D10Texture2D), (LPVOID*)&pBackBuffer);
if(dd) dd->CreateRenderTargetView(pBackBuffer, NULL,&rtv); pBackBuffer->Release();

D3D10_TEXTURE2D_DESC descDepth; descDepth.Width =width; descDepth.Height = height; descDepth.MipLevels=1; descDepth.ArraySize=1; desc.Depth.Format = DXGI_FORMAT_D32_FLOAT; descDepth.SampleDesc.Count =1; descDepth.SampleDesc.Quality=0; descDepth.Usage=D3D10_USAGE_DEFAULT; descDepth.BindFlags=D3D10_BIND_DEPTH_STENCIL; descDepth.CPUAccessFlags=0; descDepth.MiscFlags=0; 
if(dd) dd->CreateTexture2D(&descDepth, 0, &depth_stencil);

D3D10_DEPTH_STENCIL_VIEW_DESC desc_dsv; desc_dsv.Format=descDepth.Format; desc_dsv.ViewDimension=D3D10_DSV_DIMENSION_TEXTURE2D; desc_dsv.Texture2D.MipSlice=0; 
if(dd) dd->CreateDepthStencilView(depth_stencil, &desc_dsv, &depth_stencil_view);
if(dd) dd->OMSetRenderTargets(1, &rtv, depth_stencil_view);
D3D10_VIEWPORT vp; vp.Width=width; vp.Height=height; vp.MinDepth=0.0f; vp.MaxDepth=1.0f; vp.TopLeftX=0; vp.TopLedtY=0;
if(dd) dd->RSSetViewports(1, &vp);

initialize_shader();
}

void shutdown_directx10(){ if(dd) dd->ClearState(); if(bf) bf->Release(); if(eff) eff->Release(); if(il) il->Release(); if(rtv) rtv->Release(); if(sch) sch->Release(); if(dd) dd->Release(); }

struct SimpleVertex { D3DXVECTOR3 pos;}

struct vx {D3DXVECTOR3 pos; D3DXVECTOR3 normal;}

// продолжение в следующем сообщении

Инициализация DirectX 10

[challengerr]

Шейдер (файл eff.fx)
Это не С, а HLSL

matrix world;
matrix view;
matrix projection;

float4 vLightDir[2];
float4 vLightColor[2];
float4 vOutputColor;

struct vs_input
{
float4 pos: POSITION;
float3 norm : NORMAL;
};

struct ps_input
{
float4  pos : SV_POSITION;
float3 norm : TEXCOORD0;
};

ps_input vs(vs_input input)
{
ps_input output = (ps_input) 0;
output.pos = mul(input.pos, world);
output.pos = mul(output.pos, view);
output.pos = mul(output.pos, projection);
output.norm = mul(input.norm, world);
return output;
}

float4 ps(ps_input input) : SV_Target
{
float4 finalcolor = 0;

for(int i=0; i<2; i++)
{
finalcolor += saturate(dot((float3)vLightDir[i].input.norm) * vLightColor[i]);
}
finalcolor.a =1;
return finalcolor;
}

float4 ps_light(ps_input input) : SV_Target
{
return vOutputColor;
}

technique10 Render
{
pass P0
{
SetVertexShader(CompileShader(vs_4_0, vs()));
SetGeometryShader(NULL);
SetPixelShader(CompileShader(ps_4_0, ps()));
}
}

technique10 RenderLight
{
pass P0
{
SetVertexShader(CompileShader(vs_4_0, vs()));
SetGeometryShader(NULL);
SetPixelShader(CompileShader(ps_4_0, ps_light()));
}
}

[challengerr]

DirectX10 инициализация шейдера ( продолжение кода на С++)

void initialize_shader()
{
UINT num_elements, stride, offset, offset2;

if(dd) D3DX10CreateEffectFromFile("eff.fx", 0, 0, "fx_4_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, dd, 0, 0, &eff, 0, 0); if(eff) tech = eff->GetTechniqueByName("Render"); if(eff) tech_light = eff->GetTechniqueByName("RenderLight"); if(eff) world=eff->GetVariableByName("world")->AsMatrix(); if(eff) view=eff->GetVariableByName("view")->AsMatrix(); if(eff) projection= eff->GetVariableByName("projection")->AsMatrix(); if(eff) light_direction=eff->GetVariableByName("vLightDir")->AsVector(); if(eff) light_color=eff->GetVariableByName("vLightColor")->AsVector(); if(eff) output_color = eff->GetVariableByName("vOutputColor")->AsVector();

D3D10_INPUT_ELEMENT_DESC layout[] = {{"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0,0,D3D10_INPUT_PER_VERTEX_DATA,0},{"NORMAL",0,DXGI_FORMAT_R32G32B32_FLOAT,0,12,D3D10_INPUT_PER_VERTEX_DATA,0}};
num_elements = sizeof(layout)/sizeof(layout[0]);
D3D10_PASS_DESC pd; if(tech) tech->GetPassByIndex(0)->GetDesc(&pd); if(dd) dd->CreateInputLayout(layout, num_elements, pd.plAInputSignature, pd.IAInputSignatureSize, &il); if(dd) dd->IASeyInputLayout(il);

vx vrt[]=
{

{D3DXVECTOR3(-1.0f, 1.0f, -1.0f), D3DXVECTOR3(0.0f, 1.0f, 0.0f)},
{D3DXVECTOR3(1.0f, 1.0f, -1.0f), D3DXVECTOR3(0.0f, 1.0f, 0.0f)},
{D3DXVECTOR3(1.0f, 1.0f, 1.0f), D3DXVECTOR3(0.0f, 1.0f, 0.0f)},
{D3DXVECTOR3(-1.0f, 1.0f, 1.0f), D3DXVECTOR3(0.0f, 1.0f, 0.0f)},

{D3DXVECTOR3(-1.0f, -1.0f, -1.0f), D3DXVECTOR3(0.0f, -1.0f, 0.0f)},
{D3DXVECTOR3(1.0f, -1.0f, -1.0f), D3DXVECTOR3(0.0f, -1.0f, 0.0f)},
{D3DXVECTOR3(1.0f, 1.0f, 1.0f), D3DXVECTOR3(0.0f, -1.0f, 0.0f)},
{D3DXVECTOR3(-1.0f, -1.0f, 1.0f), D3DXVECTOR3(0.0f, -1.0f, 0.0f)},

{D3DXVECTOR3(-1.0f, 1.0f, 1.0f), D3DXVECTOR3(-1.0f, 0.0f, 0.0f)},
{D3DXVECTOR3(-1.0f, -1.0f, -1.0f), D3DXVECTOR3(-1.0f, 0.0f, 0.0f)},
{D3DXVECTOR3(-1.0f, 1.0f, -1.0f), D3DXVECTOR3(-1.0f, 0.0f, 0.0f)},
{D3DXVECTOR3(-1.0f, 1.0f, 1.0f), D3DXVECTOR3(-1.0f, 0.0f, 0.0f)},

{D3DXVECTOR3(1.0f, -1.0f, 1.0f), D3DXVECTOR3(1.0f, 0.0f, 0.0f)},
{D3DXVECTOR3(1.0f, -1.0f, -1.0f), D3DXVECTOR3(1.0f, 0.0f, 0.0f)},
{D3DXVECTOR3(1.0f, 1.0f, -1.0f), D3DXVECTOR3(1.0f, 0.0f, 0.0f)},
{D3DXVECTOR3(1.0f, 1.0f, 1.0f), D3DXVECTOR3(1.0f, 0.0f, 0.0f)},

{D3DXVECTOR3(-1.0f, -1.0f, -1.0f), D3DXVECTOR3(0.0f, 0.0f, -1.0f)},
{D3DXVECTOR3(1.0f, -1.0f, -1.0f), D3DXVECTOR3(0.0f, 0.0f, -1.0f)},
{D3DXVECTOR3(1.0f, 1.0f, -1.0f), D3DXVECTOR3(0.0f, 0.0f, -1.0f)},
{D3DXVECTOR3(-1.0f, 1.0f, -1.0f), D3DXVECTOR3(0.0f, 0.0f, -1.0f)},

{D3DXVECTOR3(-1.0f, -1.0f, 1.0f), D3DXVECTOR3(0.0f, 0.0f, 1.0f)},
{D3DXVECTOR3(1.0f, -1.0f, 1.0f), D3DXVECTOR3(0.0f, 0.0f, 1.0f)},
{D3DXVECTOR3(1.0f, 1.0f, 1.0f), D3DXVECTOR3(0.0f, 0.0f, 1.0f)},
{D3DXVECTOR3(-1.0f, 1.0f, 1.0f), D3DXVECTOR3(0.0f, 0.0f, 1.0f)},

{D3DXVECTOR3(-2.0f, 1.0f, -1.0f), D3DXVECTOR3(0.0f, 1.0f, 0.0f)},
{D3DXVECTOR3(-2.0f, 1.0f, 1.0f), D3DXVECTOR3(0.0f, 1.0f, 0.0f)},
{D3DXVECTOR3(-1.0f, 1.0f, -1.0f), D3DXVECTOR3(0.0f, 1.0f, 0.0f)},
{D3DXVECTOR3(-1.0f, 1.0f, 1.0f), D3DXVECTOR3(0.0f, 1.0f, 0.0f)}
};

D3D10_BUFFER_DESC bd2; bd2.Usage= D3D10_USAGE_DEFAULT; bd2.ByteWidth = sizeof(vx)*28; bd2.BindFlags=D3D10_BIND_VERTEX_BUFFER; bd2.CPUAccessFlags=0; bd2.MiscFlags=0;

D3D10_SUBRESOURCE_DATA srd2; srd2.pSysMem = vrt; if(dd) dd->CreateBuffer(&bd2,&srd2,&vbf); stride2 = sizeof(vx); offset2=0; if(dd) dd->IASetVertexBuffers(0,1,&vbf, &stride2,&offset2);

DWORD indices[]={3,1,0,2,1,3,6,4,5,7,4,6,11,9,8,10,9,11,14,12,13,15,12,14,19,17,16,18,17,19,22,20,21,23,20,22,25,26,24,27,26,25};
bd2.Usage = D3D10_USAGE_DEFAULT; bd2.ByteWidth=sizeof(DWORD)*42; bd2.BindFlags=D3D10_BIND_INDEX_BUFFER; bd2.CPUAccessFlags=0; bd2.MiscFlags=0; srd2.pSysMem=indices; if(dd) dd->CreateBuffer(&bd2,&srd2,&ibf); if(dd) dd-> IASetIndexBuffer(ibf, DXGI_FORMAT_R32_UINT,0); if(dd) dd->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
D3DXMatrixIdentity(&mworld); D3DXVECTOR3 eye (0.0f, 9.0f, -20.0f); 
D3DXVECTOR3 at(0.0f, 1.0f, 0.0f);
D3DXVECTOR3 up(0.0f, 1.0f, 1.0f);
D3DXMatrixLookAtLH(&mview, &eye, &at,&up);
D3DXMatrixPerspectiveFovLH(&mprojection, (float) D3DX_PI * 0.25f, width / (float) height, 0.1f, 1000.0f);
}

[challengerr]

Рендеринг DirectX 10

void render10()
{
if(dd)
{
static float t= 0.0f; static DWORD dwTimeStart = 0; DWORD  dwTimeCur =GetTickCount();
if(dwTimeStart==0) dwTimeStart=dwTimeCur; t=(dwTimeCur - dwTimeStart)/1000.0f;
D3DXMatrixRotationY(&mworld, t);
D3DXVECTOR4 vLightDirs[2]={D3DXVECTOR4(-0.577f, 0.577f, -0.577f, 1.0f), D3DXVECTOR4(0.0f,0.0f,-1.0f, 1.0f)};
D3DXVECTOR4 vLightColors[2]={D3DXVECTOR4(0.5f,0.5f,0.5f,1.0f),D3DXVECTOR4(0.5f,0.0f,0.0f,1.0f)};
D3DXVECTOR4 vOutDir; D3DXMATRIX mRotate; D3DXMatrixRotationY(&mRotate,-2.0f*t);
D3DXVec3Transform(&vLightDirs[1], (D3DXVECTOR3*)&vLightDirs[1],&mRotate);
UINT p; float cc[4]={0.0f, 0.125f, 0.3f, 0.1f};
if(dd) dd->ClearRenderTargetView(rtv, cc); if(dd) dd->ClearDepthStencilViee(depth_stencil_view, D3D10_CLEAR_DEPTH, 1.0f,0);
world->SetMatrix((float*) &mworld);  view->SetMatrix((float*)&mview); projection->SetMatrix((float*)&mprojection);
light_direction->SetFloatVectorArray ((float*) vLightDirs,0,2); light_color->SetFloatVectorArray((float*) vLightColors,0,2);
D3D10_TECHNIQUE_DESC techdesc;
if(tech) {tech->GetDesc(&techdesc); for(p=0; p< techsesc.Passes; p++){tech->GetPassByIndex(p)->Apply(0); if(dd) dd->DrawIndexed(42,0,0);}}
int m; for(m=0; m<2; m++){ D3DXMATRIX mlight; D3DXMATRIX mlightscale; D3DXVECTOR3 vLightPos=vLightDirs[m]*5.0f; D3DXMatrixTranslation(&mlight, vLightPos.x, vLightPos.y, vLightPos.z); D3DXMatrixScaling(&mlightscale, 0.2f, 0.2f, 0.2f); mlight= mlightscale*mlight; world->SetMatrix((float*)&mlight); output_color->SetFloatVector((float*)&vLightColors[m]); tech->GetDesc(&techdesc); for(p=0; p< techdesc.Passes; p++){ tech_light->GetPassByIndex(p)->Apply(0); if(dd) dd->DrawIndexed(42,0,0);}}
if(sch) sch->Present(0,0);
}
}

//directx 9

struct vdx9 { FLOAT x, y, z, rhw; DWORD color;}
#define vdx9fvf (D3DFVF_XYZRHW|D3DFVF_DIFFUSE)

vdx9 vertices[3];

void render9(){ if(ddev) ddev->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0,0,255), 1.0f, 0);
ddev->BeginScene();
ddev->SetStreamSource(0, vb,0,sizeof(vdx9)); 
ddev->SetFVF(vdx9fvf);
ddev->DrawPrimitive(D3DPT_TRIANGLE_LIST,0,1);
ddev->EndScene();
ddev->Present(0,0,0,0);
}

void initialize_directx9(){
d3d= Direct3DCreate9(D3D_SDK_VERSION);
ZeroMemory(&d3dpp, sizeof(d3dpp));
d3dpp.Windowed = TRUE; d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD; d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;
d3d->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hand, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp,&ddev); init_vertices(); create_vertexbuffer();}

void shutdown_directx9(){ if(ddev) ddev->Release(); if(d3d) d3d->Release();}

void create_vertexbuffer(){ vb=NULL; if(ddev) { ddev->CreateVertexBuffer(3*sizeof(vdx9),0,vdx9fvf, D3DPOOL_DEFAULT, &vb, NULL); VOID* pVertices; vb->Lock(0, sizeof(vertices), (void**) &pVertices, 0); memcpy(pVertices, vertices, sizeof(vertices)); vb->Unlock();} }

void init_vertices(){
vertices[0].x=150.0f;
vertices[0].y=50.0f;
vertices[0].z=0.5f;
vertices[0].rhw=1.0f;
vertices[0].color=0xffff0000;
vertices[1].x=250.0f;
vertices[1].y=250.0f;
vertices[1].z=0.5f;
vertices[1].rhw=1.0f;
vertices[1].color=0xff00ff00;
vertices[2].x=50.0f;
vertices[2].y=250.0f;
vertices[2].z=0.5f;
vertices[2].rhw=1.0f;
vertices[2].color=0xff00ffff;
}

h_program() {}

~h_program(){
//shutdown_directx9();
shutdown_directx10();
//shutdown_directx11();
}

int main() {HINSTANCE hInstance = GetModuleHandle(0); LPSTR CommandLine= GetCommandLine(); return WinMain(hInstance, NULL, CommandLine, SW_SHOWDEFAULT);}

int WINAPI WinMain(HINSTANCE hInsr, HINSTANCE hPrevInst, LPSTR CmdLine, int CmdShow)
{
create_wndclass(hInst);
create_windows(hInst);
//initialize_directx9();
initialize_directx10();
//initialize_directx11();
return message_cycle();
}

void create_wndclass(HINSTANCE hInst){ wc.cbSize=sizeof(WNDCLASSEX); wc.style=CS_HREDRAW|CS_VREDRAW; wc.lpfnWndProc=(WNDPROC)WndProc; wc.cbClsExtra=NULL; wc.cbWndExtra=NULL;wc.hInstance=hInst;wc.hbrBackground=(HBRUSH)GetStockObject(WHITE_BRUSH); wc.lpszMenuName="MainMenu"; wc.lpszClassName="SimpleWinClass"; wc.hIcon=LoadIcon(NULL, IDI_APPLICATION); wc.hIconSm=LoadIcon(NULL, IDI_APPLICATION); wc.hCursor=LoadCursor(NULL, IDC_ARROW);RegisterClassEx(&wc);}
void create_windows(HINSTANCE hInst){ hwnd=CreateWindowEx(NULL, "SimpleWinClass","host",WS_OVERLAPPEDWINDOW, 100,100,1000,1000,NULL,(HMENU) NULL,hInst, NULL); ShowWindow(hwnd, SW_SHOWNORMAL)! UpdateWindow(hwnd);}
int message_cycle(){while(GetMessage(&msg,NULL,0,0)){TranslateMessage(&msg); DispatchMessage(&msg);} return msg.wParam;}

};

h_program z;
int main(int argc, char* argv[]){ return z.main();}

LRESULT CALLBACK WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch(uMsg)
{
case WM_DESTROY: PostQuitMessage(NULL); return 0;
case WM_PAINT: z.render10();
//z.render9();
//z.render11();
 return 0;
default: return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return DefWindowProc(hwnd,uMsg, wParam,lParam);
}

[Пепел Феникса]

опять 25, где форматирование кода?
почему порою по несколько строк код находится на одной строке?

но на этот раз информация более полезная.
правда еще не проверял в действии.

[challengerr]

Объектно-ориентированная обертка

#include <stdio.h>
#include <locale.h>
#include <string.h>
#include <windows.h>
#include <d3d8.h>

#pragma comment(lib,"user32.lib");
#pragma comment(lib,"kernel32.lib");
#pragma comment(lib, "gdi32.lib");
#pragma comment(lib,"d3d8.lib");

LRESULT CALLBACK WndPrpc(HWND hand, UINT uMsg, WPARAM wParam, LPARAM lParam);

void error(int err) { printf("err: %d\n", err); }

struct point1 { float x, y, z; };
struct cv { float x, y, z, rhw; DWORD color; }

// одно связный список вершинных буферов

struct vertex_buffer
{
LPDIRECT3DVERTEXBUFFER8 vb;
VOID* p;
struct vertex_buffer* next;

vertex_buffer(LPDIRECT3DDEVICE8 ddev, int size, DWORD fvf, void* v, int n) { next = NULL; vb = NULL; create(ddev, size, fvf); copy1(v,n);}
~vertex_buffer() { delete1(); if(next) delete next; } // удаление односвязного списка цепочкой деструкторов
void create(LPDIRECT3DDEVICE8 ddev, int a, DWORD fvf) { if(ddev) ddev->CreateVertexBuffer(a, 0, fvd, D3DPOOL_DEFAULT, &vb); else error(9); }
void lock(int b, int a) { if(vb) vb->Lock(b, a, (BYTE**) &p, 0); else error(11); }
void unlock() { if(vb) vb->Unlock(); else error(12); }
void copy2(void* v, int n) { if(vb) memcpy(p,v,n); }
void copy1(void* v, int n) { if(vb) { lock(0,0); copy2(v,n); unlock(); } else error(10); }
void delete1() { if(vb) vb->Release(); else error(13); }
void add_next(LPDIRECT3DDEVICE ddev, int a, DWORD fvf, void* v, int a) { next = new vertex_buffer(ddev, a, fvf, v, n); }
};

[challengerr]

Структура для рендеринга сцены

struct render8
{
int state;
struct vertex_buffer* v;

render8() { state = 0; v = NULL; }
~render8() { delete_buffer(v); }
void delete_buffer(struct vertex_buffer* p) { if(p) delete p; }
// создание буфера вручную 
void create_buffer(LPDIRECT3DDEVICE8 ddev) { if(ddev) { cv* v1 = new cv[3]; 
v1[0].x = 150.0f; v1[0].y = 150.0f; v1[0].z = 0.5f; v1[0].rhw = 1.0f; v1[0].color = 0xffff0000;
v1[1].x = 250.0f; v1[1].y = 250.0f; v1[1].z = 0.5f; v1[1].rhw = 1.0f; v1[1].color = 0xff00ff00;
v1[2].x = 150.0f; v1[2].y = 250.0f; v1[2].z = 0.5f; v1[2].rhw = 1.0f; v1[2].color = 0xff00ffff;
if(ddev) v = new vertex_buffer(ddev, 3*sizeof(cv), D3DFVF_XYZRHW|D3DFVF_DIFFUSE, v1, 3*sizeof(cv)); delete [] v1; }
if(ddev) { point1* v1 = new point1[2];
v1[0].x = 20.0f; v1[0].y = 20.0f; v1[0].z = 0.5f;
v1[1].x = 20.0f; v1[1].y = 40.0f; v1[1].z = 0.5f;
if (ddev) v->add_next(ddev, 2*sizeof(point1), D3DFVF_XYZRHW|D3DFVF_DIFFUSE, v1,2*sizeof(point1)); delete [] v1; }
if(ddev) { point1* v1 = new point1[2];
v1[0].x = 60.0f; v1[0].y = 80.0f; v1[0].z = 0.5f;
v1[1].x = 60.0f; v1[1].y = 70.0f; v1[1].z = 0.5f;
if (ddev) v->next->add_next(ddev, 2*sizeof(point1), D3DFVF_XYZRHW|D3DFVF_DIFFUSE, v1,2*sizeof(point1)); delete [] v1; }
}

// создать буферы
void create(LPDIRECT3DDEVICE8 ddev) { if(ddev) { state = 1; create_buffer(ddev); }}

// начать рендеринг сцены
void begin(LPDIRECT3DDEVICE8 ddev) { if(ddev) ddev->BeginScene(); }

// рендерить сцену
void render_scene(LPDIRECT3DDEVICE8 ddev) { if(ddev) render_buffers(ddev); }

// от рисовать все буферы
void render_buffers(LPDIRECT3DDEVICE8 ddev) {
if(ddev) { 
// в первом буфере треугольник
if(v) render_buffer(ddev, v, D3DPT_TRIANGLELIST, sizeof(cv), D3DFVF_XYZRHW|D3DFVF_DIFFUSE, 1);
// во втором буфере линия
if(v->next) render_buffer(ddev, v->next, D3DPT_LINELIST, sizeof(point1), D3DFVF_XYZRHW|D3DFVF_DIFFUSE, 1);
// во третьем буфере линия
if(v->next->next) render_buffer(ddev, v->next->next, D3DPT_LINELIST, sizeof(point1), D3DFVF_XYZRHW|D3DFVF_DIFFUSE, 1);
// в последующих буферах точки, которые добавляются при движении мыши
if(v->next->next) { vertex_buffer* pv = v->next->next; while(pv->next) { if(pv->next) render_buffer(ddev, pv->next, D3DPT_POINTLIST, sizeof(point1), D3DFVF_XYZRHW|D3DFVF_DIFFUSE, 1); pv = pv-> next; }}}}

// рендеринг буфера
void render_buffer(LPDIRECT3DDEVICE8 ddev, vertex_buffer* v, D3DPRIMITIVETYPE t, int n, DWORD s, int y) { if(ddev) { if(v) { set_stream(ddev, v, n); set_shader(ddev, s); draw_primitive(ddev, t, y); }}}

void set_stream(LPDIRECT3DDEVICE8 ddev, vertex_buffer* v, int n) { if(ddev) ddev->SetStreamSource(0, v->vb, n); }

void set_shader(LPDIRECT3DDEVICE8 ddev, DWORD s) { if(ddev) ddev->SetVertexShader(s); }

void draw_primitive(LPDIRECT3DDEVICE8 ddev, D3DPRIMITIVETYPE t, int y) { if(ddev) ddev->DrawPrimitive(t, 0,y); }

// закончить рендеринг сцены
void end(LPDIRECT3DDEVICE8 ddev) { if(ddev) { ddev->EndScene(); }}
void present(LPDIRECT3DDEVICE8 ddev) { if(ddev) ddev->Present(0,0,0,0); }

// обработать сцену

void scene(LPDIRECT3DDEVICE8 ddev) { if(ddev) { begin(ddev); render_scene(ddev); end(ddev); present(ddev); }}

// очистить сцену
void clear(LPDIRECT3DDEVICE8 ddev) { if(ddev) { ddev->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0,255,255),1.0f, 0); } else error(8); }

void render_internal(LPDIRECT3DDEVICE8 ddev) { if(ddev) if(!state) create(ddev); }

// вход в структуру
void render(LPDIRECT3DDEVICE8 ddev) { if(ddev) { check_state(ddev); render_internal(ddev); } else error(6); }

// добавление нового буфера при каждом движении мыши
void l(LPDIRECT3DDEVICE8 ddev, LPARAM lp) { if(ddev) { if(v) { if(v->next) { if(v->next->next) { vertex_buffer* pv = v->next->next; while(pv->next) pv= pv->next; point1* v1 = new point1; v1->x = (float) LOWORD(lp); v1->y = (float) HIWORD(lp); v1->z = 0.5f; printf("%f %f\n", v1->x,v1->y); pv->add_next(ddev, sizeof(point1), D3DFVF_XYZ, v1, sizeof(point1)); delete [] v1; }}}}}

};

[waleri]

Гениально!
Теперь вместо того, чтоб проверить создался ли DIRECTDRAWDEVICE один раз мы будем проверять это каждый раз.

assert? Не, не слышал...