should I learn DirectX?

Miscellaneous Forums/General Discussion/should I learn DirectX?

I'm wondering if I should bother learning DirectX. I already know basic C++, and, for gaming programming, should I learn DirectX?? At the moment, I am simply failing to learn DirectX. The commands are all just so needlessly complex and hard to remember, just look at this:

/*
   Demo Name:  World Matrix
      Author:  Allen Sherrod
     Chapter:  Ch 1
*/


#include<d3d9.h>
#include<d3dx9.h>

#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "d3dx9.lib")

#define WINDOW_CLASS    "UGPDX"
#define WINDOW_NAME     "World Matrix"
#define WINDOW_WIDTH    640
#define WINDOW_HEIGHT   480

// Function Prototypes...
bool InitializeD3D(HWND hWnd, bool fullscreen);
bool InitializeObjects();
void RenderScene();
void Shutdown();


// Direct3D object and device.
LPDIRECT3D9 g_D3D = NULL;
LPDIRECT3DDEVICE9 g_D3DDevice = NULL;

D3DXMATRIX g_projection;
D3DXMATRIX g_worldMatrix;
D3DXMATRIX g_translation;
D3DXMATRIX g_rotation;

float g_angle = 0.0f;

// Vertex buffer to hold the geometry.
LPDIRECT3DVERTEXBUFFER9 g_VertexBuffer = NULL;

// A structure for our custom vertex type
struct stD3DVertex
{
    float x, y, z;
    unsigned long color;
};

// Our custom FVF, which describes our custom vertex structure
#define D3DFVF_VERTEX (D3DFVF_XYZ | D3DFVF_DIFFUSE)


LRESULT WINAPI MsgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
   switch(msg)
      {
         case WM_DESTROY:
            PostQuitMessage(0);
            return 0;
            break;

         case WM_KEYUP:
            if(wParam == VK_ESCAPE) PostQuitMessage(0);
            break;
      }

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


int WINAPI WinMain(HINSTANCE hInst, HINSTANCE prevhInst, LPSTR cmdLine, int show)
{
   // Register the window class
   WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L,
                     GetModuleHandle(NULL), NULL, NULL, NULL, NULL,
                     WINDOW_CLASS, NULL };
   RegisterClassEx(&wc);

   // Create the application's window
   HWND hWnd = CreateWindow(WINDOW_CLASS, WINDOW_NAME, WS_OVERLAPPEDWINDOW,
                            100, 100, WINDOW_WIDTH, WINDOW_HEIGHT, GetDesktopWindow(),
                            NULL, wc.hInstance, NULL);

   // Initialize Direct3D
   if(InitializeD3D(hWnd, false))
      {
         // Show the window
         ShowWindow(hWnd, SW_SHOWDEFAULT);
         UpdateWindow(hWnd);

         // Enter the message loop
         MSG msg;
         ZeroMemory(&msg, sizeof(msg));

         while(msg.message != WM_QUIT)
            {
               if(PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
                  {
                     TranslateMessage(&msg);
                     DispatchMessage(&msg);
                  }
               else
                  RenderScene();
            }
      }

   // Release any and all resources.
   Shutdown();

   // Unregister our window.
   UnregisterClass(WINDOW_CLASS, wc.hInstance);
   return 0;
}


bool InitializeD3D(HWND hWnd, bool fullscreen)
{
   D3DDISPLAYMODE displayMode;

   // Create the D3D object.
   g_D3D = Direct3DCreate9(D3D_SDK_VERSION);
   if(g_D3D == NULL) return false;

   // Get the desktop display mode.
   if(FAILED(g_D3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &displayMode)))
      return false;

   // Set up the structure used to create the D3DDevice
   D3DPRESENT_PARAMETERS d3dpp;
   ZeroMemory(&d3dpp, sizeof(d3dpp));

   if(fullscreen)
      {
         d3dpp.Windowed = FALSE;
         d3dpp.BackBufferWidth = WINDOW_WIDTH;
         d3dpp.BackBufferHeight = WINDOW_HEIGHT;
      }
   else
      d3dpp.Windowed = TRUE;
   d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
   d3dpp.BackBufferFormat = displayMode.Format;

   // Create the D3DDevice
   if(FAILED(g_D3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
             D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &g_D3DDevice)))
      {
         return false;
      }

   // Initialize any objects we will be displaying.
   if(!InitializeObjects()) return false;

   return true;
}


bool InitializeObjects()
{
   // Set the projection matrix.
   D3DXMatrixPerspectiveFovLH(&g_projection, D3DX_PI / 4,
      WINDOW_WIDTH/WINDOW_HEIGHT, 0.1f, 1000.0f);

   g_D3DDevice->SetTransform(D3DTS_PROJECTION, &g_projection);

   // Set default rendering states.
   g_D3DDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
	g_D3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);

   // Fill in our structure to draw an object.
   // x, y, z, color.
   stD3DVertex objData[] =
      {
         {-0.3f, -0.3f, 1.0f, D3DCOLOR_XRGB(255,255,0)},
         {0.3f, -0.3f, 1.0f, D3DCOLOR_XRGB(255,0,0)},
	      {0.0f, 0.3f, 1.0f, D3DCOLOR_XRGB(0,0,255)}
      };

   // Create the vertex buffer.
   if(FAILED(g_D3DDevice->CreateVertexBuffer(3 * sizeof(stD3DVertex), 0,
             D3DFVF_VERTEX, D3DPOOL_DEFAULT, &g_VertexBuffer, NULL))) return false;

   // Fill the vertex buffer.
   void *ptr;
   if(FAILED(g_VertexBuffer->Lock(0, sizeof(objData), (void**)&ptr, 0))) return false;
   memcpy(ptr, objData, sizeof(objData));
   g_VertexBuffer->Unlock();

   return true;
}


void RenderScene()
{
   // Clear the backbuffer.
   g_D3DDevice->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0,0,0), 1.0f, 0);

   // Begin the scene.  Start rendering.
   g_D3DDevice->BeginScene();

      // Build translation and rotation matrices.
      D3DXMatrixTranslation(&g_translation, 0.0f, 0.0f, 3.0f);
      D3DXMatrixRotationY(&g_rotation, g_angle);

      // Build the world matrix and update angle.
      g_worldMatrix = g_rotation * g_translation;
      g_angle += 0.01f;
      if(g_angle >= 360) g_angle = 0.0f;
   
      // Set the world matrix.
      g_D3DDevice->SetTransform(D3DTS_WORLD, &g_worldMatrix);

      // Draw the object.
      g_D3DDevice->SetStreamSource(0, g_VertexBuffer, 0, sizeof(stD3DVertex));
      g_D3DDevice->SetFVF(D3DFVF_VERTEX);
      g_D3DDevice->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 1);

   // End the scene.  Stop rendering.
   g_D3DDevice->EndScene();

   // Display the scene.
   g_D3DDevice->Present(NULL, NULL, NULL, NULL);
}


void Shutdown()
{
   if(g_D3DDevice != NULL) g_D3DDevice->Release();
   if(g_D3D != NULL) g_D3D->Release();
   if(g_VertexBuffer != NULL) g_VertexBuffer->Release();

   g_D3DDevice = NULL;
   g_D3D = NULL;
   g_VertexBuffer = NULL;
}

Anyways, I was wondering if there is any real need to ever learn DirectX, in both a profession and hobby environment? Also, other than DirectX, are there any good, easy to learn, well-documented, free, and DirectX-version-recent engines out there? I'd like to code in C++, as it's a vital language, but using functions from a easily usable engine (quick-commands, like in blitz).

(the main reason I want to use something other than blitz is the fact that it's dx7 and the shaders are terrible and slow)

thanks

Gabriel

As for whether you should learn DirectX for your profession and/or hobby I guess that depends what you want to do as a profession and a hobby. If you want to write 3d engines and/or low level games engines, then you're going to need to learn DirectX if you plan on supporting Windows. If you're going to write games, on the other hand, then it's entirely up to you. Some people do, some people don't. Ultimately you need to decide what level of programming you're most comfortable with. I'm a big fan of high level programming. I only ever go to low level code when it's essential. But I don't discourage people from being low level guys because someone has to write the low level stuff I use in my games.

The shaders in DX7 are non-existant. They didn't exist until DX8. I know one or two people confuse the issue by calling certain effects shaders, but they're just needlessly confusing the issue.

DavidDC

If you're writing something like this:

The commands are all just so needlessly complex and hard to remember

then a high level engine is probably the way to go. The higher the better as far as I'm concerned. If I ever go back to 3d it will be via something like Unity3d. I'm very much over low-level 3d programming - there's just so much work required to keep up with ongoing developments.

Having said that, Gabriel is spot on with this:

But I don't discourage people from being low level guys because someone has to write the low level stuff I use in my games.

Naughty Alien

..very good and very very clean code 3D engine, opensource and free, with pretty much all next gen features should be Horde3D..give it a try..it will be nice to see this engine nailed on to B3D or Bmax..

http://www.nextgen-engine.net/