Re[5]: Демонстрационный код - О работе

Я начинающий программист на С++, ищу работу. Часто просят отослать пример кода. Вот только, после того как я пересылаю его, на другой стороне полная тишина. Я каждый раз объяснял, что сложных, хорошо написанных и спроектированных программ у меня нет (мои проекты связаны с 3D графикой, я акцентировал усилия только на ней, к сожалению) и просил тестовое задание, но не помогало. Посмотрите, пожалуйста, кто-нибудь код и укажите на самые фатальные ошибки, из-за которых меня сразу же посылали в черный список. Всего два класса. Все действия, которые там есть, это: инициализировать нужные ресурсы, установить различные состояния для отрисовки, посчитать и отрендерить, что нужно, затем удалить навсегда.

Fluid.h

#ifndef __Fluid_H__
#define __Fluid_H__
//-------------------------------------------------------------------------


#include <d3dx9.h>
#include <math.h>
#include <string>
#include "..\..\- Mein\GameApp.h"
#include "..\..\Service\Service.h"

using std::string;
//-------------------------------------------------------------------------



//---------------------------------------------
//Fluid Navie-Stocks 3D Solver on GPU
//---------------------------------------------
class Fluid3D
{
public:

    //Create and Clean
    Fluid3D    ();
    ~Fluid3D();

    
    //Setup
    void SetEffectValues    (float TimeScale);
    void InitTextures        ();
    void InitVertexBuffers    ();

    
    //Computation
    void Update                (float TimeScale);
    void ComputeStep        (IDirect3DTexture9* renderTarget, string technique);
    void ComputeBorders        (IDirect3DTexture9* renderTarget, string technique);


    //Service
    void CopyTexture                (IDirect3DTexture9* destinationTex, IDirect3DTexture9* sourceTex);
    void ClearTexture                (IDirect3DTexture9* texture);
    void SetScreenFillingTransform    (bool set);
    void RenderTextureToScreen        (IDirect3DTexture9* texture, D3DXVECTOR3 pos);
    void ChechTechnique                (HRESULT Result, string& technique);
    void ChechTextureValues            (IDirect3DTexture9* texture);
    void Debug                        ();


    //Get
    IDirect3DTexture9*    GetVelocity()    {return Velocity;}
    IDirect3DTexture9*    GetDensity()    {return Density;}
    IDirect3DTexture9*    GetPreassure()    {return Pressure;}
    IDirect3DTexture9*    GetDivergence()    {return Divergence;}
    IDirect3DTexture9*    GetVorticity()    {return Vorticity;}
    IDirect3DTexture9*    GetZLookup()    {return ZLookup;}


private:

    //Effect
    ID3DXEffect* FluidEffect;


    //Textures
    IDirect3DTexture9* Velocity;
    IDirect3DTexture9* Pressure;
    IDirect3DTexture9* Density;
    IDirect3DTexture9* Divergence;
    IDirect3DTexture9* Vorticity;

    IDirect3DTexture9* TemporaryRenderTarget;
    IDirect3DSurface9* RenderSurface;
    IDirect3DSurface9* BackBuffer;
    IDirect3DTexture9* ZLookup;


    //Geometry
    IDirect3DVertexBuffer9* QuadVB;
    IDirect3DVertexBuffer9* QuadsArrayVB;
    IDirect3DVertexBuffer9* BorderLinesVB;
    IDirect3DVertexBuffer9* BorderLinesArrayVB;

    
    //Parameters
    static const int GridSize3D = 64;
    static const int GridSize2D = 512; 
    static const int JacobiIterations = 20;
    float VolumeSize;
    float Viscosity;
    float GridScale;
    float SqrGridScale;

};




//---------------------------------------------
//Fluid Volume Render
//---------------------------------------------
class RayCasting
{
public:

    //Create and Clean
    RayCasting();
    ~RayCasting();


    //Render all
    void Render(float TimeScale);
    void RenderTexture(IDirect3DTexture9* texture, D3DXVECTOR3 Position, float timeDelta);


private:

    //Render It
    Fluid3D Fluid;


    //Effects
    ID3DXEffect* RayCastingEffect;


    //Position of Fluid
    D3DXVECTOR3 Position;


    //Textures 
    LPDIRECT3DSURFACE9 BackBuffer;
    LPDIRECT3DTEXTURE9 BackfacesTexture;
    LPDIRECT3DSURFACE9 BackfacesSurface;
    LPDIRECT3DTEXTURE9 FluidTexture;
    LPDIRECT3DSURFACE9 FluidSurface;
    

    //Volumes
    IDirect3DVertexBuffer9* BoundingBoxVB;
    IDirect3DIndexBuffer9*  BoundingBoxIB;
    IDirect3DVertexBuffer9* QuadVB;
    
};




//---------------------------------------------
//Vertecies Strucutres
//---------------------------------------------

//VertexColored Structure
struct VertexColored
{
    VertexColored(float x, float y, float z, float u, float v, D3DCOLOR c)
    {
        _x = x;     _y = y;  _z = z;  
        _color = c;
    }

    float _x, _y, _z;
    D3DCOLOR _color;        
    

    static const DWORD FVF = D3DFVF_XYZ | D3DFVF_DIFFUSE ; 
};


//VertexTextured Structure
struct VertexTextured 
{ 
 
    VertexTextured(float x, float y, float z, float u, float v) 
    { 
      _x = x; _y = y; _z = z; 
      _u = u, _v = v; 
    } 

    float _x, _y, _z; 
    float _u, _v; 

    static const DWORD FVF = D3DFVF_XYZ | D3DFVF_TEX1; 
}; 



//VertexTextured Structure
struct Vertex3DTextured 
{ 
 
    Vertex3DTextured(float x, float y, float z, float u, float v, float w) 
    { 
      _x = x; _y = y; _z = z; 
      _u = u, _v = v; _w = w;
    } 

    float _x, _y, _z; 
    float _u, _v, _w;

    static const DWORD FVF = D3DFVF_XYZ | D3DFVF_TEX1 | D3DFVF_TEXCOORDSIZE3(0); 
}; 


#endif // __Fluid_H__

Fluid.cpp

#include "Fluid.h"

using GameApp::Device;




//-------------------------------------------------------------------------
//
//        Fluid3D Solver
//
//-------------------------------------------------------------------------


//-------------------------------------------------------------------------
//    Fluid class Constructor
//-------------------------------------------------------------------------
Fluid3D::Fluid3D()
{
    //Attributes
    Viscosity        = 50.0f;
    VolumeSize        = 2.0f; //Change ?
    GridScale        = 1.0f;
    SqrGridScale    = pow( GridScale /*VolumeSize / GridSize*/, 2.0f);


    //Effect Setup     
    HRESULT Result = 0;
    ID3DXBuffer* errorBuffer = 0; 

    Result = D3DXCreateEffectFromFile(Device,"- Sources/Mechanic/Fluid/Fluid.fx", 0, 0, D3DXSHADER_DEBUG, 0, &FluidEffect, &errorBuffer);  

    if(errorBuffer) 
    { 
        ::MessageBox(0, (char*)errorBuffer->GetBufferPointer(),0, 0); 
        GameApp::Release<ID3DXBuffer*>(errorBuffer); 
    } 
    
    if(FAILED(Result)) 
    { 
        ::MessageBox(0, "D3DXCreateEffectFromFile() - FAILED", 0, 0); 
        return;
    } 


    //Init Vertex Buffers
    InitVertexBuffers();


    //Init Textures
    InitTextures();

}



//-------------------------------------------------------------------------
//    Init Vertex Buffers
//-------------------------------------------------------------------------
void Fluid3D::InitVertexBuffers()
{

    //-----------------------------------
    //Textured Quad Verticies
    //-----------------------------------
    Device->CreateVertexBuffer(6 * sizeof(VertexTextured), D3DUSAGE_WRITEONLY, VertexTextured::FVF, D3DPOOL_MANAGED, &QuadVB, 0);
    VertexTextured* verticesTex;
    QuadVB->Lock(0, 0, (void**)&verticesTex, 0);

    float x = 1.0f;
    float y = 1.0f;
    verticesTex[0] = VertexTextured(-x, -y, 0.0f, 0.0f, 1.0f);
    verticesTex[1] = VertexTextured(-x,  y, 0.0f, 0.0f, 0.0f);
    verticesTex[2] = VertexTextured( x,  y, 0.0f, 1.0f, 0.0f);
    verticesTex[3] = VertexTextured(-x, -y, 0.0f, 0.0f, 1.0f);
    verticesTex[4] = VertexTextured( x,  y, 0.0f, 1.0f, 0.0f);
    verticesTex[5] = VertexTextured( x, -y, 0.0f, 1.0f, 1.0f);
    
    QuadVB->Unlock();




    //-----------------------------------
    //Textured Quads Array Verticies 64x64 for Flat3D Texture
    //-----------------------------------
    Device->CreateVertexBuffer( 6 * GridSize3D * sizeof(Vertex3DTextured), D3DUSAGE_WRITEONLY, Vertex3DTextured::FVF, D3DPOOL_MANAGED, &QuadsArrayVB, 0 );
    Vertex3DTextured* verticesTex3D;

    float quadSize = 1.0f;
    float pixelSize = quadSize / GridSize3D;
    float sliceSize = sqrt((float)GridSize3D);
    
    float sliceOffset = quadSize / sliceSize;
    float sliceOffsetX = sliceOffset;
    float sliceOffsetY = sliceOffset;
    float sliceOffsetZ = 0.5f / GridSize3D;
    
    int index = 0;
    x = -0.5f;
    y = -0.5f;
    float xT = 0.0f;
    float yT = 0.0f;
    
    
    QuadsArrayVB->Lock(0, 0, (void**)&verticesTex3D, 0);
    for (int i = 0; i < sliceSize; i++)
    {
        for (int j = 0; j < sliceSize; j++)
        {
            verticesTex3D[index++] = Vertex3DTextured( x,                    y,                    0.0f, xT,                    yT,                        sliceOffsetZ );
            verticesTex3D[index++] = Vertex3DTextured( x,                    y + sliceOffsetY,    0.0f, xT,                    yT + sliceOffsetY,        sliceOffsetZ );
            verticesTex3D[index++] = Vertex3DTextured( x + sliceOffsetX,    y,                    0.0f, xT + sliceOffsetX,    yT,                        sliceOffsetZ );
            verticesTex3D[index++] = Vertex3DTextured( x + sliceOffsetX,    y,                    0.0f, xT + sliceOffsetX,    yT,                        sliceOffsetZ );
            verticesTex3D[index++] = Vertex3DTextured( x,                    y + sliceOffsetY,    0.0f, xT,                    yT + sliceOffsetY,        sliceOffsetZ );
            verticesTex3D[index++] = Vertex3DTextured( x + sliceOffsetX,    y + sliceOffsetY,    0.0f, xT + sliceOffsetX,    yT + sliceOffsetY,        sliceOffsetZ );

            //Next quad in Row
            x += quadSize / sliceSize;
            xT += quadSize / sliceSize;
            sliceOffsetZ += quadSize / GridSize3D;
        }

        //Next Column
        x = -0.5f;
        xT = 0.0f;
        y += quadSize / sliceSize;
        yT += quadSize / sliceSize;
        
    }
    QuadsArrayVB->Unlock();




    //-----------------------------------
    //Border Lines Verticies
    //-----------------------------------
    Device->CreateVertexBuffer(8 * sizeof(VertexTextured), D3DUSAGE_WRITEONLY, VertexTextured::FVF, D3DPOOL_MANAGED, &BorderLinesVB, 0);
    BorderLinesVB->Lock(0, 0, (void**)&verticesTex, 0);

    //Left
    verticesTex[0] = VertexTextured(-1.0f, -1.0f, 0.0f,    1.0f, 0.0f);
    verticesTex[1] = VertexTextured(-1.0f,  1.0f, 0.0f,    1.0f, 0.0f);
    
    //Right
    verticesTex[2] = VertexTextured(1.0f,  1.0f, 0.0f, -1.0f, 0.0f);
    verticesTex[3] = VertexTextured(1.0f, -1.0f, 0.0f, -1.0f, 0.0f);

    ////Botttom
    verticesTex[6] = VertexTextured( 1.0f, -1.0f, 0.0f, 0.0f, 1.0f);
    verticesTex[7] = VertexTextured(-1.0f, -1.0f, 0.0f, 0.0f, 1.0f);

    ////Top
    verticesTex[4] = VertexTextured(-1.0f, 1.0f, 0.0f, 0.0f, -1.0f);
    verticesTex[5] = VertexTextured( 1.0f, 1.0f, 0.0f, 0.0f, -1.0f);

    BorderLinesVB->Unlock();



    //-----------------------------------
    //Border Lines Array Verticies
    //-----------------------------------
    Device->CreateVertexBuffer(8 * GridSize3D * sizeof(VertexTextured), D3DUSAGE_WRITEONLY, VertexTextured::FVF, D3DPOOL_MANAGED, &BorderLinesArrayVB, 0);
    BorderLinesArrayVB->Lock(0, 0, (void**)&verticesTex, 0);
    
    quadSize = 1.0f;
    sliceSize = sqrt((float)GridSize3D);
    pixelSize = quadSize / GridSize2D / 1.0;
    sliceOffset = quadSize / sliceSize - 2 * pixelSize;
    
    x = -quadSize / 2.0 + pixelSize;
    y = -quadSize / 2.0 + pixelSize;
    index = 0;

    for (int i = 0; i < sliceSize; i++)
    {
        for (int j = 0; j < sliceSize; j++)
        {
        
            //Left
            verticesTex[index++] = VertexTextured(x, y,                                    0.0f,    1.0f, 0.0f);
            verticesTex[index++] = VertexTextured(x, y + sliceOffset,                    0.0f,    1.0f, 0.0f);
            
            //Right
            verticesTex[index++] = VertexTextured(x + sliceOffset, y + sliceOffset,        0.0f, -1.0f, 0.0f);
            verticesTex[index++] = VertexTextured(x + sliceOffset, y,                    0.0f, -1.0f, 0.0f);

            ////Botttom
            verticesTex[index++] = VertexTextured(x + sliceOffset,    y,                    0.0f, 0.0f, 1.0f);
            verticesTex[index++] = VertexTextured(x,                y,                    0.0f, 0.0f, 1.0f);

            ////Top
            verticesTex[index++] = VertexTextured(x,                y + sliceOffset,    0.0f, 0.0f, -1.0f);
            verticesTex[index++] = VertexTextured(x + sliceOffset,    y + sliceOffset,    0.0f, 0.0f, -1.0f);


            //Next quad
            x += quadSize / sliceSize ;
        }

        //Next column
        x = -quadSize / 2.0 + pixelSize;
        y += quadSize / sliceSize /*+ 2 * pixelSize*/;

    }
    BorderLinesArrayVB->Unlock();
    
}



//-------------------------------------------------------------------------
//    Init Textures
//-------------------------------------------------------------------------
void Fluid3D::InitTextures()
{
    Device->GetRenderTarget(0,&BackBuffer);

    Device->CreateTexture(GridSize2D, GridSize2D, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A16B16G16R16F, D3DPOOL_DEFAULT, &Velocity, NULL);
    Device->CreateTexture(GridSize2D, GridSize2D, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A16B16G16R16F, D3DPOOL_DEFAULT, &Pressure, NULL);
    Device->CreateTexture(GridSize2D, GridSize2D, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A16B16G16R16F, D3DPOOL_DEFAULT, &Density, NULL);
    Device->CreateTexture(GridSize2D, GridSize2D, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A16B16G16R16F, D3DPOOL_DEFAULT, &Divergence, NULL);
    Device->CreateTexture(GridSize2D, GridSize2D, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A16B16G16R16F, D3DPOOL_DEFAULT, &Vorticity, NULL);
    Device->CreateTexture(GridSize2D, GridSize2D, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A16B16G16R16F, D3DPOOL_DEFAULT, &TemporaryRenderTarget, NULL);
    
    ClearTexture(Velocity);
    ClearTexture(Pressure);
    ClearTexture(Density);
    ClearTexture(Divergence);    
    ClearTexture(Vorticity);
    ClearTexture(TemporaryRenderTarget);


        

    //------------------------------------
    //Lookup Tex for Z coord in shader
    //------------------------------------
    IDirect3DTexture9* ZLookupInSystemPool; //To use LockRect in System memory
    int height = 1; // Height for 1D texture


    //Create Lookup texture and its copy in System memory
    Device->CreateTexture(GridSize3D, height, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A32B32G32R32F, D3DPOOL_DEFAULT,        &ZLookup, NULL);
    Device->CreateTexture(GridSize3D, height, 1, D3DUSAGE_DYNAMIC,        D3DFMT_A32B32G32R32F, D3DPOOL_SYSTEMMEM,    &ZLookupInSystemPool, NULL);
    
    D3DLOCKED_RECT lockedRect; 
    ZLookupInSystemPool->LockRect( 0, &lockedRect, 0, 0);
    D3DXVECTOR4* imageData = (D3DXVECTOR4*)lockedRect.pBits; 

    //Copy offset values from VB
    Vertex3DTextured* verticesTex3D;
    QuadsArrayVB->Lock(0, 0, (void**)&verticesTex3D, 0);

    for (int i = 0, iV = 0; i < GridSize3D; i++)
    {
        imageData[i] = D3DXVECTOR4(verticesTex3D[iV]._x + 0.5f, 0.875f - (verticesTex3D[iV]._y + 0.5f), 0.0f, 0.0f);
        iV += 6;//Next Quad
    }
    
    QuadsArrayVB->Unlock();
    ZLookupInSystemPool->UnlockRect(0); 

    
    //Copy form System to Video memory
    Device->UpdateTexture(ZLookupInSystemPool, ZLookup);
    GameApp::Release<IDirect3DTexture9*>(ZLookupInSystemPool);

}




//-------------------------------------------------------------------------
//    Fluid class Destructor
//-------------------------------------------------------------------------
Fluid3D::~Fluid3D()
{
    //Free all Textures
    GameApp::Release<IDirect3DTexture9*>(Velocity);
    GameApp::Release<IDirect3DTexture9*>(Pressure);
    GameApp::Release<IDirect3DTexture9*>(Density);
    GameApp::Release<IDirect3DTexture9*>(ZLookup);
    GameApp::Release<IDirect3DTexture9*>(Divergence);
    GameApp::Release<IDirect3DTexture9*>(TemporaryRenderTarget);
    GameApp::Release<IDirect3DSurface9*>(BackBuffer);
    GameApp::Release<IDirect3DSurface9*>(RenderSurface);

    //Free all Vertex Buffers
    GameApp::Release<IDirect3DVertexBuffer9*>(QuadVB);
    GameApp::Release<IDirect3DVertexBuffer9*>(QuadsArrayVB);
    GameApp::Release<IDirect3DVertexBuffer9*>(BorderLinesVB);

    //Free all Effects
    GameApp::Release<ID3DXEffect*>(FluidEffect);
}




//-------------------------------------------------------------------------
//    Setup Effect
//-------------------------------------------------------------------------
void Fluid3D::SetEffectValues(float TimeScale)
{
    //Fluid Parameters
    FluidEffect->SetFloat("Timestep",    1.0f * (TimeScale * 10.0f)); //TimeScale * 50.0f
    FluidEffect->SetFloat("Rdx",        5.0f);
    FluidEffect->SetFloat("HalfRdx",    0.5f / 1.0f);
    FluidEffect->SetFloat("DXscale",    1.0f );// / GridSize
    FluidEffect->SetFloat("GridSize2D",    GridSize2D);
    FluidEffect->SetFloat("GridSize3D",    GridSize3D);
    FluidEffect->SetFloat("Scale",        1.0f);
    

    //Controls
    FluidEffect->SetFloat("XForce", 0.0f);
    FluidEffect->SetFloat("YForce", 0.0f);
    FluidEffect->SetFloat("ZForce", 0.0f);
    
    float force = 5.0f;
    if (::GetAsyncKeyState(VK_LEFT) & 0x8000f )        FluidEffect->SetFloat("XForce", -force);    
    if (::GetAsyncKeyState(VK_RIGHT) & 0x8000f )    FluidEffect->SetFloat("XForce", force);                
    if (::GetAsyncKeyState(VK_UP) & 0x8000f )        FluidEffect->SetFloat("YForce", force);            
    if (::GetAsyncKeyState(VK_DOWN) & 0x8000f )        FluidEffect->SetFloat("YForce", -force);    
    if (::GetAsyncKeyState(VK_END) & 0x8000f )        FluidEffect->SetFloat("ZForce", -force);


    //View in Vertex Shader
    float dist = 1.0f;
    static D3DXMATRIX orthoProj = *D3DXMatrixOrthoLH(&orthoProj, dist, dist, 1.0f, 1000.0f);
    static D3DXMATRIX translation    = *D3DXMatrixTranslation(&translation, 0.0f, 0.0f, 10.0f);
    FluidEffect->SetMatrix( "ModelViewProj", &(translation * orthoProj) );//translation * invView * view * orthoProj

    //Effect uniform samplers
    FluidEffect->SetTexture("VelocityTex", Velocity);
    FluidEffect->SetTexture("PressureTex", Pressure);
    FluidEffect->SetTexture("DensityTex", Density);
    FluidEffect->SetTexture("DivergenceTex", Divergence);
    FluidEffect->SetTexture("VorticityTex", Vorticity);
    FluidEffect->SetTexture("ZLookupTex", ZLookup);
}





//-------------------------------------------------------------------------
//    Fluid Update
//-------------------------------------------------------------------------
void Fluid3D::Update(float TimeScale)
{
    SetEffectValues(TimeScale);


    //----------------------------------------
    //Advection
    //----------------------------------------
    //Advection of Velocity
    FluidEffect->SetFloat( "Dissipation", 1.0f);
    ComputeStep(Velocity, "AdvectionVelocityStep");
    

    //Advection of Density
    FluidEffect->SetFloat( "Dissipation", 0.99f);
    ComputeStep(Density, "AdvectionDensityStep");



    //----------------------------------------
    //Add
    //----------------------------------------
    //Force
    ComputeStep(Velocity, "ForceStep");
    
    //Density
    if (true || ::GetAsyncKeyState(VK_SPACE)) 
    {
        ComputeStep(Density, "DensityStep");
    }
    


    //----------------------------------------
    //Diffusion
    //----------------------------------------
    //Velocity
    Viscosity    = 20.0f;
    FluidEffect->SetFloat( "Alpha", SqrGridScale / (Viscosity * TimeScale) );
    FluidEffect->SetFloat( "RBeta", 1.0f / (6.0f + SqrGridScale / (Viscosity * TimeScale)) );
    for (int i = 0; i < 25 /*JacobiIterations*/; i++)
    {
        ComputeStep(Velocity, "DiffuseStep");
    }
    

    //Density
    Viscosity    = 0.0001f;
    FluidEffect->SetFloat( "Alpha", SqrGridScale / (Viscosity * TimeScale) );
    FluidEffect->SetFloat( "RBeta", 1.0f / (4.0f + SqrGridScale / (Viscosity * TimeScale)) );
    for (int i = 0; i < JacobiIterations; i++)
    {
        ComputeStep(Density, "DiffuseDensityStep");
    }


    //----------------------------------------
    //    Projection
    //----------------------------------------
    ClearTexture(Pressure);

    //Divergence of W
    ComputeStep(Divergence, "DivergenceStep");

    //Poisson solve for P
    FluidEffect->SetFloat( "Alpha", -SqrGridScale );
    FluidEffect->SetFloat( "RBeta", 0.16f );

    for (int i = 0; i < JacobiIterations; i++)
    {
        ComputeStep(Pressure, "PoissonSolveStep");
    }

    //Gradient
    ComputeStep(Velocity, "GradientStep");


    //----------------------------------------
    //Vorticity 
    //----------------------------------------
    //Compute scalar Vorticity field
    ComputeStep(Vorticity, "VorticityStep");

    //Vorticity Force
    ComputeStep(Velocity, "VorticityForceStep");



    //Borders
    ComputeBorders(Velocity, "BoundaryVelocity");
    ComputeBorders(Pressure, "BoundaryPressure");



    //----------------------------------------
    //Debug 
    //----------------------------------------
    //Debug();

    //FluidEffect->SetFloat("ScaleColor", true);    RenderTextureToScreen(Velocity,        D3DXVECTOR3( 4.0, 3.0f, 0.0f));
    FluidEffect->SetFloat("ScaleColor", false);    RenderTextureToScreen(Density,        D3DXVECTOR3( 8.0, 3.0f, 0.0f));
    //RenderTextureToScreen(Vorticity,    D3DXVECTOR3( 2.5, 1.5f, 3.0f));
    //RenderTextureToScreen(ZLookup,    D3DXVECTOR3(-2.5, 1.5f, 3.0f));
}



//-------------------------------------------------------------------------
//    Computational step in Fluid (Init, Compute, Clean)
//-------------------------------------------------------------------------
void Fluid3D::ComputeStep(IDirect3DTexture9* renderTarget, string technique)
{    
    //Render in Temporary texture
    TemporaryRenderTarget->GetSurfaceLevel(0, &RenderSurface);
    Device->SetRenderTarget(0, RenderSurface);
    //Device->SetRenderTarget(0, BackBuffer);
    Device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL, D3DCOLOR_XRGB(200,200,55), 1.0f, 0);
    
    //Computation Step
    ChechTechnique( FluidEffect->SetTechnique(technique.c_str()), technique );
    FluidEffect->Begin(0, 0);
    FluidEffect->BeginPass(0);     
    
    Device->SetFVF(Vertex3DTextured::FVF);
    Device->SetStreamSource(0, QuadsArrayVB, 0, sizeof(Vertex3DTextured));
    Device->DrawPrimitive(D3DPT_TRIANGLELIST, 0, GridSize3D * 2.0);
    
    FluidEffect->EndPass();
    FluidEffect->End();


    //Copy Temporary tex to Output tex
    CopyTexture(renderTarget, TemporaryRenderTarget);


    //Restore States
    Device->SetRenderTarget(0, BackBuffer);

    //Debug
    //ChechTextureValues(renderTarget);
    //GameApp::SceneRender(0.01); 
}



//-------------------------------------------------------------------------
//    Activate Borders
//-------------------------------------------------------------------------
void Fluid3D::ComputeBorders(IDirect3DTexture9* renderTarget, string technique)
{
    //Render in Temporary texture
    TemporaryRenderTarget->GetSurfaceLevel(0, &RenderSurface);
    Device->SetRenderTarget(0, RenderSurface);
    
    ChechTechnique( FluidEffect->SetTechnique(technique.c_str()), technique );

    FluidEffect->Begin(0, 0);
    FluidEffect->BeginPass(0);     
    
    Device->SetFVF(VertexTextured::FVF);
    Device->SetStreamSource(0, BorderLinesArrayVB, 0, sizeof(VertexTextured));
    Device->DrawPrimitive(D3DPT_LINELIST, 0, 4 * GridSize3D);

    FluidEffect->EndPass();
    FluidEffect->End();


    //Copy Temporary tex to Output tex
    CopyTexture(renderTarget, TemporaryRenderTarget);


    //Restore States
    Device->SetRenderTarget(0, BackBuffer);
}




//-------------------------------------------------------------------------
//
//        Fluid3D::Service
//
//-------------------------------------------------------------------------



//-------------------------------------------------------------------------
//    ClearTexture
//-------------------------------------------------------------------------
void Fluid3D::ClearTexture(IDirect3DTexture9* texture)
{
    texture->GetSurfaceLevel(0, &RenderSurface);
    Device->SetRenderTarget(0, RenderSurface);
    Device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL, 0x00000000, 1.0f, 0);
    
    Device->SetRenderTarget(0, BackBuffer);
}



//-------------------------------------------------------------------------
//    Copy Textures
//-------------------------------------------------------------------------
void Fluid3D::CopyTexture(IDirect3DTexture9* destinationTex, IDirect3DTexture9* sourceTex)
{
    //Set destinationTex as Render Terget
    IDirect3DSurface9* destinationSurface;
    destinationTex->GetSurfaceLevel(0, &destinationSurface);
    Device->SetRenderTarget(0, destinationSurface);
    Device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL, D3DCOLOR_XRGB(150,150,55), 1.0f, 0);

    FluidEffect->SetTexture("CopySourceTex", sourceTex);

    //Draw in Render Terget
    FluidEffect->SetTechnique("CopyTexture"); 
    FluidEffect->Begin(0, 0);
    FluidEffect->BeginPass(0); 
    
    Device->SetStreamSource(0, QuadVB, 0, sizeof(VertexTextured));
    Device->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 2);

    FluidEffect->EndPass();
    FluidEffect->End();


    //Clean
    GameApp::Release<IDirect3DSurface9*>(destinationSurface);
}


//-------------------------------------------------------------------------
//    Screen Filling Transform
//-------------------------------------------------------------------------
void Fluid3D::SetScreenFillingTransform(bool isTransformSet)
{
    static float viewSize                = 1.0f;
    static D3DXMATRIX matProjection        = *D3DXMatrixOrthoLH(&matProjection, viewSize, viewSize, 1.0f, 1000.0f); 
    static D3DXMATRIX matOldProjection    = GameApp::m_pCamera->GetProjMatrix();
    static D3DXMATRIX translation        = *D3DXMatrixTranslation(&translation, 0.0f, 0.0f, 10.0f);


    if (isTransformSet)
    {
        //Set texture to filling viewport
        D3DXMATRIX invView = *D3DXMatrixInverse( &invView, 0, &GameApp::m_pCamera->GetViewMatrix() );
        Device->SetTransform(D3DTS_PROJECTION, &matProjection);
        Device->SetTransform( D3DTS_WORLD, &(translation * invView) );
    }
    else
    {    
        //Return Perpective projection
        Device->SetTransform(D3DTS_PROJECTION,&matOldProjection);
    }
}



//-------------------------------------------------------------------------
//    Render Texture To Screen
//-------------------------------------------------------------------------
void Fluid3D::RenderTextureToScreen(IDirect3DTexture9* texture, D3DXVECTOR3 position)
{
    D3DXMATRIX translation = *D3DXMatrixTranslation( &translation, position.x, position.y, position.z );
    D3DXMATRIX view = GameApp::m_pCamera->GetViewMatrix();
    static D3DXMATRIX proj = GameApp::m_pCamera->GetProjMatrix();
    static D3DXMATRIX scale = *D3DXMatrixScaling(&scale, scaleFactor, scaleFactor, 0);
    static D3DXMATRIX rotate = *D3DXMatrixRotationY(&rotate, 3.14 / 2.0);


    Device->Clear(0, 0,  D3DCLEAR_ZBUFFER , D3DCOLOR_XRGB(100,100,55), 1.0f, 0);
    Device->SetRenderTarget(0, BackBuffer);

    FluidEffect->SetMatrix( "ModelViewProj", &(scale * rotate * translation * view * proj) );
    FluidEffect->SetTexture("TextureToScreenTex", texture);

    FluidEffect->SetTechnique("RenderTextureToScreen"); 
    FluidEffect->Begin(0, 0);
    FluidEffect->BeginPass(0); 

    Device->SetStreamSource(0, QuadVB, 0, sizeof(VertexTextured));
    Device->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 2);

    FluidEffect->EndPass();
    FluidEffect->End();
}

//-------------------------------------------------------------------------
//    Chech Technique
//-------------------------------------------------------------------------
void Fluid3D::ChechTechnique(HRESULT Result, string& technique)
{
    if(FAILED(Result))
    {
        ::MessageBox(0, technique.c_str(), 0, 0); 
        return;
    }
}


//-------------------------------------------------------------------------
//    Debug
//-------------------------------------------------------------------------
void Fluid3D::Debug ()
{
    IDirect3DTexture9* renderTex;
    Device->CreateTexture(GridSize2D, GridSize2D, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A16B16G16R16F, D3DPOOL_DEFAULT, &renderTex, NULL);


    //Render in Temporary texture
    renderTex->GetSurfaceLevel(0, &RenderSurface);
    Device->SetRenderTarget(0, RenderSurface);

    float dist = 1.0f;
    static D3DXMATRIX orthoProj = *D3DXMatrixOrthoLH(&orthoProj, dist, dist, 1.0f, 1000.0f);
    static D3DXMATRIX translation    = *D3DXMatrixTranslation(&translation, 0.0f, 0.0f, 10.0f);
    FluidEffect->SetMatrix( "ModelViewProj", &(translation * orthoProj) );//translation * invView * view * orthoProj

    //Computation Step
    FluidEffect->SetTechnique("Debug");
    FluidEffect->Begin(0, 0);
    FluidEffect->BeginPass(0);     
    
    Device->SetFVF(Vertex3DTextured::FVF);
    Device->SetStreamSource(0, QuadsArrayVB, 0, sizeof(Vertex3DTextured));
    Device->DrawPrimitive(D3DPT_TRIANGLELIST, 0, GridSize3D * 2.0);
    
    FluidEffect->EndPass();
    FluidEffect->End();

    //Render results
    RenderTextureToScreen(renderTex,    D3DXVECTOR3(0.0, 6.0f, 3.0f));

    //Clean
    GameApp::Release<IDirect3DTexture9*>(renderTex);
}








//-------------------------------------------------------------------------
//
//        Ray Casing Render
//
//-------------------------------------------------------------------------

//-------------------------------------------------------------------------
//    Ray Casing Constructor
//-------------------------------------------------------------------------
RayCasting::RayCasting()
{
    BackfacesTexture = NULL;
    BackfacesSurface = NULL;
    FluidTexture = NULL;
    FluidSurface = NULL;
    BackBuffer = NULL;
    VolumeTexture = NULL;

    Device->GetRenderTarget(0,&BackBuffer);

    Device->CreateTexture(512, 512,1,D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &BackfacesTexture, NULL);
    BackfacesTexture->GetSurfaceLevel(0, &BackfacesSurface);

    Device->CreateTexture(512, 512,1,D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &FluidTexture, NULL);
    FluidTexture->GetSurfaceLevel(0, &FluidSurface);
    
    

    //-------------------------------
    //Geometry
    //-------------------------------

    //Bounding Box Verticies
    Device->CreateVertexBuffer(8 * sizeof(VertexColored), D3DUSAGE_WRITEONLY, VertexColored::FVF, D3DPOOL_MANAGED, &BoundingBoxVB, 0);
    Device->CreateIndexBuffer (36 * sizeof(WORD), D3DUSAGE_WRITEONLY, D3DFMT_INDEX16, D3DPOOL_MANAGED, &BoundingBoxIB, 0);

    VertexColored* vertices;
    BoundingBoxVB->Lock(0, 0, (void**)&vertices, 0);
    
    int size = 4.0f;
    vertices[0] = VertexColored(-size, -size, -size, 0.0f, 0.0f, D3DXCOLOR(D3DXVECTOR3(-1.0f, -1.0f, -1.0f)));
    vertices[1] = VertexColored(-size,  size, -size, 0.0f, 0.0f, D3DXCOLOR(D3DXVECTOR3(-1.0f,  1.0f, -1.0f)));
    vertices[2] = VertexColored( size,  size, -size, 0.0f, 0.0f, D3DXCOLOR(D3DXVECTOR3( 1.0f,  1.0f, -1.0f)));
    vertices[3] = VertexColored( size, -size, -size, 0.0f, 0.0f, D3DXCOLOR(D3DXVECTOR3( 1.0f, -1.0f, -1.0f)));
    vertices[4] = VertexColored(-size, -size,  size, 0.0f, 0.0f, D3DXCOLOR(D3DXVECTOR3(-1.0f, -1.0f,  1.0f)));
    vertices[5] = VertexColored(-size,  size,  size, 0.0f, 0.0f, D3DXCOLOR(D3DXVECTOR3(-1.0f,  1.0f,  1.0f)));
    vertices[6] = VertexColored( size,  size,  size, 0.0f, 0.0f, D3DXCOLOR(D3DXVECTOR3( 1.0f,  1.0f,  1.0f)));
    vertices[7] = VertexColored( size, -size,  size, 0.0f, 0.0f, D3DXCOLOR(D3DXVECTOR3( 1.0f, -1.0f,  1.0f)));

    BoundingBoxVB->Unlock();

    
    //Bounding Box Indices
    WORD* indices = 0;
    BoundingBoxIB->Lock(0, 0, (void**)&indices, 0);

    indices[0]  = 0; indices[1]  = 1; indices[2]  = 2;    indices[3]  = 0; indices[4]  = 2; indices[5]  = 3;
    indices[6]  = 4; indices[7]  = 6; indices[8]  = 5;    indices[9]  = 4; indices[10] = 7; indices[11] = 6;
    indices[12] = 4; indices[13] = 5; indices[14] = 1;    indices[15] = 4; indices[16] = 1; indices[17] = 0;
    indices[18] = 3; indices[19] = 2; indices[20] = 6;    indices[21] = 3; indices[22] = 6; indices[23] = 7;
    indices[24] = 1; indices[25] = 5; indices[26] = 6;    indices[27] = 1; indices[28] = 6; indices[29] = 2;
    indices[30] = 4; indices[31] = 0; indices[32] = 3;    indices[33] = 4; indices[34] = 3; indices[35] = 7;

    BoundingBoxIB->Unlock();


    //Textured Quad Verticies
    Device->CreateVertexBuffer(6 * sizeof(VertexTextured), D3DUSAGE_WRITEONLY, VertexTextured::FVF, D3DPOOL_MANAGED, &QuadVB, 0);

    VertexTextured* verticesTex;
    QuadVB->Lock(0, 0, (void**)&verticesTex, 0);


    float x = 4.0f;
    float y = 3.0f;
    verticesTex[0] = VertexTextured(-x, -y, 0.0f, 0.0f, 1.0f);
    verticesTex[1] = VertexTextured(-x,  y, 0.0f, 0.0f, 0.0f);
    verticesTex[2] = VertexTextured( x,  y, 0.0f, 1.0f, 0.0f);
    verticesTex[3] = VertexTextured(-x, -y, 0.0f, 0.0f, 1.0f);
    verticesTex[4] = VertexTextured( x,  y, 0.0f, 1.0f, 0.0f);
    verticesTex[5] = VertexTextured( x, -y, 0.0f, 1.0f, 1.0f);

    QuadVB->Unlock();
    
    
    //Position of Fluid
    Position = D3DXVECTOR3(-20.0f, 10.0f, 15.0f) + D3DXVECTOR3 (18.0f, -5.0f, -3.0f);;




    //-------------------------------
    //Effects Setup
    //-------------------------------
    HRESULT Result = 0;
    ID3DXBuffer* errorBuffer = 0; 

    Result = D3DXCreateEffectFromFile(Device,"- Sources/Mechanic/Fluid/RayCasting.fx", 0, 0, D3DXSHADER_DEBUG, 0, &RayCastingEffect, &errorBuffer);  

    if(errorBuffer) 
    { 
        ::MessageBox(0, (char*)errorBuffer->GetBufferPointer(),0, 0); 
        GameApp::Release<ID3DXBuffer*>(errorBuffer); 
    } 
    
    if(FAILED(Result)) 
    { 
        ::MessageBox(0, "D3DXCreateEffectFromFile() - FAILED", 0, 0); 
        return;
    } 
    
}



//-------------------------------------------------------------------------
//    Render class Destructor
//-------------------------------------------------------------------------
RayCasting::~RayCasting()
{
    GameApp::Release<IDirect3DVertexBuffer9*>(BoundingBoxVB);
    GameApp::Release<IDirect3DIndexBuffer9*> (BoundingBoxIB);
    GameApp::Release<IDirect3DVertexBuffer9*> (QuadVB);

    GameApp::Release<IDirect3DTexture9*>(BackfacesTexture);
    GameApp::Release<IDirect3DTexture9*>(FluidTexture);
    GameApp::Release<IDirect3DVolumeTexture9*>(VolumeTexture);
    GameApp::Release<LPDIRECT3DSURFACE9>(FluidSurface);
    GameApp::Release<LPDIRECT3DSURFACE9>(BackBuffer);
    GameApp::Release<LPDIRECT3DSURFACE9>(BackfacesSurface);

    GameApp::Release<ID3DXEffect*>(RayCastingEffect);

}



//-------------------------------------------------------------------------
//    Render Volume
//-------------------------------------------------------------------------
void RayCasting::Render(float TimeScale)
{
    //Prepare Data sources for render
    Fluid.Update(TimeScale);
    
    
    //-------------------------------
    //Step 0: Setup
    //-------------------------------
    //Setup States
    Device->SetRenderState(D3DRS_LIGHTING, false); 
    Device->SetStreamSource(0, BoundingBoxVB, 0, sizeof(VertexColored));
    Device->SetIndices(BoundingBoxIB);
     RayCastingEffect->SetTexture("BackfacesTex", BackfacesTexture);
    RayCastingEffect->SetTexture("VolumeTex", Fluid.GetDensity());
    RayCastingEffect->SetTexture("ZLookupTex", Fluid.GetZLookup());
    

    //Setup Effect
    D3DXMATRIX Translation;
    D3DXMatrixTranslation(&Translation, Position.x, Position.y, Position.z);
    D3DXMATRIX Temporary = Translation * GameApp::m_pCamera->GetViewMatrix();
    RayCastingEffect->SetMatrix("ModelView", &Temporary); 
    Temporary *= GameApp::m_pCamera->GetProjMatrix(); 
    RayCastingEffect->SetMatrix("ModelViewProj", &Temporary);

    RayCastingEffect->SetTechnique("RayCastingTechnique"); 
    RayCastingEffect->Begin(0, 0);


    
    //-------------------------------
    //Step 1: Render Cube Backfaces In Texture
    //-------------------------------
    Device->SetRenderTarget(0, BackfacesSurface);
    Device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL, D3DCOLOR_XRGB(150,150,150), 1.0f, 0);
    //Device->BeginScene();
    //Device->EndScene();

    RayCastingEffect->BeginPass(0); 
    Device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 8, 0, 12);
    RayCastingEffect->EndPass();
    


    //-------------------------------
    //Step 2: Render Cube Frontfaces + Do Raycasting In Texture
    //-------------------------------
    Device->SetRenderTarget(0, FluidSurface);
    //Device->SetRenderTarget(0, BackBuffer);
    Device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL, D3DCOLOR_ARGB(0, 255,255,255), 1.0f, 0);
    
    RayCastingEffect->BeginPass(1); 
    Device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 8, 0, 12);
    RayCastingEffect->EndPass();    

    RayCastingEffect->End();



    //-------------------------------
    //Step 3:  Compositing Fluid Texture in scene (Not worked now)
    //-------------------------------
    //GameApp::SceneRender(TimeScale);

    //Previous Render Target
    Device->SetRenderTarget(0, BackBuffer);
    

    //Render Texture
    RenderTexture(FluidTexture, D3DXVECTOR3(0.0f, 0.0f, 3.0f), TimeScale);
}

//-------------------------------------------------------------------------
//    Render Various Texture
//-------------------------------------------------------------------------
void RayCasting::RenderTexture(IDirect3DTexture9* texture, D3DXVECTOR3 Position, float timeDelta)
{
    if( !Device ) return;

    Device->Clear(0, 0,  D3DCLEAR_ZBUFFER , D3DCOLOR_XRGB(100,100,100), 1.0f, 0);
    
    Service::SetMaterial( D3DXCOLOR(1.0f, 1.0f, 1.0f, 0.0f) );

    D3DXMATRIX Translation = *D3DXMatrixTranslation(&Translation, Position.x, Position.y, Position.z);
    D3DXMATRIX invView = *D3DXMatrixInverse( &invView, 0, &GameApp::m_pCamera->GetViewMatrix() );
    Translation *= invView;
    
    //Set Render States
    Device->SetRenderState(D3DRS_ALPHABLENDENABLE, true);
    Device->SetTexture(0, texture);    
    
    Device->SetStreamSource(0, QuadVB, 0, sizeof(VertexTextured));
    Device->SetFVF(VertexTextured::FVF);
    Device->SetTransform( D3DTS_WORLD, &Translation);
    Device->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 2);
    
    Device->SetRenderState(D3DRS_ALPHABLENDENABLE, false);
    

    //Restore States
    Device->SetTexture(0, NULL);
}

Извините, я думал, в код автоматом добавится скроллинг

Здравствуйте, Northaunt, Вы писали:

из беглого просмотра

    static D3DXMATRIX proj = GameApp::m_pCamera->GetProjMatrix();
    static D3DXMATRIX scale = *D3DXMatrixScaling(&scale, scaleFactor, scaleFactor, 0);
    static D3DXMATRIX rotate = *D3DXMatrixRotationY(&rotate, 3.14 / 2.0);

....
    static D3DXMATRIX orthoProj = *D3DXMatrixOrthoLH(&orthoProj, dist, dist, 1.0f, 1000.0f);
    static D3DXMATRIX translation    = *D3DXMatrixTranslation(&translation, 0.0f, 0.0f, 10.0f);

такие статические переменные — очевидно плохо, сделайте их к примеру мемберами класса.

Возможно код будет кому-то в тему, но в общем случае я бы продпочел "чистый" код без идиотических API типа DirectX.

По сути:
1) Обилие "волшебных" констант в коде. Код изобилует захаркоденными цифрами:
Position = D3DXVECTOR3(-20.0f, 10.0f, 15.0f) + D3DXVECTOR3 (18.0f, -5.0f, -3.0f);;
Яркий пример кода написанного начинающим. По сути я на бейсике в школе писал проги
типа moveTo(120,450); lineTo(230,480); lineTo(520,170)

2) Местами выравнивание доминирует над кодом

3) Несколько операторов в строке. Может новичкам кажется это круто, но опытных программеров чаще раздражает.
_x = x; _y = y; _z = z; (кстати подчерки в переменных класса некрасивы)

4) Отсутствие консистентного стиля.
HRESULT Result = 0;
ID3DXBuffer* errorBuffer = 0;
А не пофиг что одна переменная названа c большой буквы а вторая с маленькой.
В одном классе
float VolumeSize;
float Viscosity;
В другом
float _x, _y, _z;
D3DCOLOR _color;

5) отсутствие общей идеи кода. Ну понятно что это аналог бейсика moveTo/lineTo

Навскидку. Если D3DXCreateEffectFromFile обломится в конструкторе, то объект окажется в не пойми каком состоянии. Пустым конструктором нужно сделать минимальную инициализацию, а загрузку откуда-нибудь (например, из файла) -- отдельными методами. Сейчас же, если на стеке завести несколько экземпляров Fluid3D, они все полезут в один и тот-же файл. Ну, и показывать "коробки" посреди конструктора тоже не очень правильно, -- обработка ошибок -- вопрос клиентского кода.

МессаджБокс из конструктора?
Сильно!

#include "..\..\- Mein\GameApp.h"
#include "..\..\Service\Service.h"

"- Mein" — так извращаться в названиях директорий не стоит.
И вообще, Mein — это не Main с ошибкой случайно?
Лучше настроить, чтобы путь к заголовкам указывался при сборке, а в коде писать так:

#include "GameApp.h"
#include "Service.h"

Вообще, заголовки, которые используются другими модулями программы, обычно кладут куда-нибудь в include в корне проекта, а не в директорию с реализацией.

if (true || ::GetAsyncKeyState(VK_SPACE))

Какой смысл у данной конструкции?

Закомментированный код я бы из демонстрационного примера убрал, чтобы он никого не смущал.

Здравствуйте, Northaunt, Вы писали:

N>Я начинающий программист на С++, ищу работу. Часто просят отослать пример кода. Вот только, после того как я пересылаю его, на другой стороне полная тишина. Я каждый раз объяснял, что сложных, хорошо написанных и спроектированных программ у меня нет (мои проекты связаны с 3D графикой, я акцентировал усилия только на ней, к сожалению) и просил тестовое задание, но не помогало. Посмотрите, пожалуйста, кто-нибудь код и укажите на самые фатальные ошибки, из-за которых меня сразу же посылали в черный список. Всего два класса. Все действия, которые там есть, это: инициализировать нужные ресурсы, установить различные состояния для отрисовки, посчитать и отрендерить, что нужно, затем удалить навсегда.

Из бросающегося в глаза:

— using std::string — не знаю, кому как, но я не люблю такие вещи. Либо уж std::string variable;, либо using namespace std;
— Почти полное отсутствие осмысленных комментариев, некий намёк на них есть только там, где очень длинный код разбивается на блоки. Правда, для этого лучше разбить код на относительно короткие функции;
— ИМХО, самый серьёзный недостаток: нет толковой обработки ошибок (например, пачка вызовов Device->CreateTexture);
— Зачем-то неровно оттабулированы парные скобки в объявлениях методов. С пробелами между параметрами и скобками вообще бардак какой-то: что-то отогнано чуть ли не за правую границу экрана, что-то навалено одно на одно;
— Сумасшедшая длина метода InitVertexBuffers.

Ну и, конечно, закомментированный код из демонстрационного примера лучше бы убрать. Не то, чтобы его не бывает в реальном продуктовом коде (бывает, ещё как бывает), просто здесь у тебя своего рода театр, так хоть сцену подмети.

Здравствуйте, RedUser, Вы писали:

RU>[/ccode]"- Mein" — так извращаться в названиях директорий не стоит.

IMHO, это не баг, это фича —
главная директория тогда получается первая по порядку, если стоит сортировка по алфавиту.

RU>И вообще, Mein — это не Main с ошибкой случайно?

Я думаю это на немецком ("Mein" = "My"). Может либа имеет немецкие корни?

RU>Лучше настроить, чтобы путь к заголовкам указывался при сборке, а в коде писать так:
RU>

RU>#include "GameApp.h"
RU>#include "Service.h"

Вообще, заголовки, которые используются другими модулями программы, обычно кладут куда-нибудь в include в корне проекта, а не в директорию с реализацией.

IMHO, то что он написал — вполне нормально.
Вдруг у тебя два файла с одинаковым именем в разных INCLUDE-папках? Получишь проблему на ровном месте.

Сразу не заметил:

— Довольно длинная D3DXVECTOR3 передаётся по значению. Скорее всего, это не страшно в данном случае, если бы не остальные наблюдения;
— Параметры типа string передаются по значению (const std::string & отменили?);
— В единственном месте, где string передаётся по ссылке эта ссылка должна быть константной, чтобы не морочить голову пользователю.

Кстати, автор знает про существование ключевого слова const?

Здравствуйте, Northaunt, Вы писали:

N>Я начинающий программист на С++, ищу работу. Часто просят отослать пример кода. Вот только, после того как я пересылаю его, на другой стороне полная тишина.

Это предсказуемо, так как много кода непонятного назначения. Вот у меня сразу вопрос — какую задачу решает код? Поэтому:
1. Выкинь свой код
2. Возьми стандарт кодирования серьезной организации (например от Qt), вызубри его и четко следуй тому, что там написано, а то от смешения стилей и дикого форматирования волосы шевелятся
3. Напиши например реализацию 2-3 дерева
4. Задокументируй открытые методы своего контейнера в стиле Doxygen
5. Напиши юнит-тесты и короткую демонстрационную программу, чтобы люди сразу видели как с этим работать.
После этого все будет выглядеть аккуратно и на слабое знание языка люди закроют глаза, так как будут думать, что парень толковый и аккуратный — научится.

Здравствуйте, Northaunt.

Думаю, мало кому из работодателей понравится замысловатый код, предназначенный, скажем, для обработки
видеопотока данных или шифрования, даже если он чрезвычайно эффективен. Лучше смотрится реализация
относительно простых алгоритмов, но выполненная в качественном стиле, с согласованными именами,
комментариями. Про юнит-тесты вообще молчу.

Ytz>Это предсказуемо, так как много кода непонятного назначения. Вот у меня сразу вопрос — какую задачу решает код? Поэтому:
Ytz>1. Выкинь свой код
...

К сожалению Ytz прав, таких людей чтобы заценили сложность программирования решения уравнений Навье-Стокса немного.

Да уж, отсылать это было ошибкой. Спасибо тем, кто заставил себя просмотреть все. Если я правильно понял, основные проблемы это: ужасный стиль, комментарии и непонятно что тут вообще делается. Я, скорее всего, последую советам Ytz, но это займет время. А в качестве временного варианта я откопал старый код, маленький класс управления камерой в 3D. Я постарался учесть все ошибки (константы, передачи по ссылкам, изврат в конструкторах, форматирование и т.д.), но, конечно же, наделав много новых. Это, надеюсь, последний раз, постараюсь больше не напрягать.

#ifndef __CCamera_H__
#define __CCamera_H__


#include <d3dx9.h>
#include "\Mechanic\CPlayer.h"


class CPlayer;



//-------------------------------------------------------------------------
// Base CCamera class
//-------------------------------------------------------------------------
class CCamera 
{ 

public: 

    // Constructors & Destructors 
    CCamera( const CCamera * pCamera ); 
    CCamera(); 
    virtual ~CCamera(); 
 

    // Public Functions 
    void  SetFOV        (float FOV) { FOV = FOV; ProjDirty = true; } 
    void  SetViewport   (long Left, long Top, long Width, long Height, float NearClip, 
                         float FarClip, LPDIRECT3DDEVICE9 pDevice = NULL ); 
 
    //Update States
    void  UpdateRenderView  ( LPDIRECT3DDEVICE9 pD3DDevice ); 
    void  UpdateRenderProj  ( LPDIRECT3DDEVICE9 pD3DDevice ); 
     
      
    // Get Functions
    float               GetFOV         ( ) const    { return FOV;  } 
    float               GetNearClip    ( ) const    { return NearClip; } 
    float               GetFarClip     ( ) const    { return FarClip; } 
 
    const D3DVIEWPORT9& GetViewport    ( ) const    { return Viewport; } 
    CPlayer *            GetPlayer      ( ) const    { return Player;  } 
    const D3DXVECTOR3&  GetPosition    ( ) const    { return Position;  } 
    const D3DXVECTOR3&  GetLook        ( ) const    { return Look;  } 
    const D3DXVECTOR3&  GetUp          ( ) const    { return Up;    } 
    const D3DXVECTOR3&  GetRight       ( ) const    { return Right; } 
    const D3DXMATRIX&   GetViewMatrix  ( ); 
    const D3DXMATRIX&   GetProjMatrix  ( ); 
     
 

    // Public virtual functions 
    virtual void   AttachToPlayer   ( CPlayer * pPlayer )                {}
    virtual void   SetPosition        (const D3DXVECTOR3& position)        {Position = position; ViewDirty = true;}
    virtual void   Move                (const D3DXVECTOR3& vecShift)        {Position += vecShift; ViewDirty = true;} 
    virtual void   Rotate            ( float x, float y, float z )        {}
    virtual void   RotateByMatrix    (const D3DXQUATERNION& Quaternion)    {}
    virtual void   Update            ( float TimeScale)                    {} 
    virtual void   SetCameraDetails    ( const CCamera * pCamera )            {} 
 


protected: 
     
    // Variables 
    CPlayer          *Player;        // The player object we are attached to 
    D3DXMATRIX       View;            // Cached view matrix 
    D3DXMATRIX       Proj;            // Cached projection matrix 
    bool             ViewDirty;     // View matrix dirty ? 
    bool             ProjDirty;     // Proj matrix dirty ? 
     

    // Perspective Projection parameters 
    float           FOV;            // FOV Angle. 
    float           NearClip;       // Near Clip Plane Distance 
    float           FarClip;        // Far Clip Plane Distance 
    D3DVIEWPORT9    Viewport;        // The viewport details into which we are rendering. 
 

    // Cameras current position & orientation 
    D3DXVECTOR3     Position;        // Camera Position 
    D3DXVECTOR3     Up;                // Camera Up Vector 
    D3DXVECTOR3     Look;            // Camera Look Vector 
    D3DXVECTOR3     Right;            // Camera Right Vector 
}; 



//-------------------------------------------------------------------------
// First Person
//-------------------------------------------------------------------------
class CCameraFirstPerson : public CCamera 
{ 

public: 

    //Contructors 
    CCameraFirstPerson    ( const CCamera * pCamera ); 
    CCameraFirstPerson    (); 
 
    
    //Public Base Class Overrides 
    void    Rotate           ( float x, float y, float z ); 
    void    RotateByMatrix   ( const D3DXQUATERNION& Quaternion);
    void    SetCameraDetails ( const CCamera * pCamera ); 
    void    AttachToPlayer   ( CPlayer * pPlayer ); 
};



#endif // __CCamera_H__

#include "CCamera.h"



//-------------------------------------------------------------------------
//
// Camera
//
//-------------------------------------------------------------------------

//-------------------------------------------------------------------------
// Default Constructor
//-------------------------------------------------------------------------
CCamera::CCamera() 
{ 
    // Reset / Clear all required values 
    Player         = NULL; 
    Right        = D3DXVECTOR3( 1.0f, 0.0f, 0.0f ); 
    Up           = D3DXVECTOR3( 0.0f, 1.0f, 0.0f ); 
    Look         = D3DXVECTOR3( 0.0f, 0.0f, 1.0f ); 
    Position     = D3DXVECTOR3( 0.0f, 3.0f, -5.0f ); 
 
    FOV            = 90.0f; 
    NearClip       = 1.0f; 
    FarClip        = 1000.0f;

    Viewport.X      = 0; 
    Viewport.Y      = 0; 
    Viewport.Width  = 1280; 
    Viewport.Height = 960; 
    Viewport.MinZ   = 0.0f; 
    Viewport.MaxZ   = 1.0f; 
 
    // Set matrices to identity 
    D3DXMatrixIdentity( &View ); 
    D3DXMatrixIdentity( &Proj ); 
}



//-------------------------------------------------------------------------
// Copy Constructor
//-------------------------------------------------------------------------
CCamera::CCamera( const CCamera * pCamera ) 
{ 
    // Reset / Clear all required values 
    Player      = NULL; 
    Right       = D3DXVECTOR3( 1.0f, 0.0f, 0.0f ); 
    Up          = D3DXVECTOR3( 0.0f, 1.0f, 0.0f ); 
    Look        = D3DXVECTOR3( 0.0f, 0.0f, 1.0f ); 
    Position    = D3DXVECTOR3( 0.0f, 0.0f, 0.0f ); 
 
    FOV            = 90.0f; 
    NearClip       = 1.0f; 
    FarClip            = 1000.0f; 

    Viewport.X      = 0; 
    Viewport.Y      = 0; 
    Viewport.Width  = 1280; 
    Viewport.Height = 960; 
    Viewport.MinZ   = 0.0f; 
    Viewport.MaxZ   = 1.0f; 
 
    // Set matrices to identity 
    D3DXMatrixIdentity( &View ); 
    D3DXMatrixIdentity( &Proj ); 
} 


//-------------------------------------------------------------------------
// Viewport parameters
//-------------------------------------------------------------------------
void CCamera::SetViewport( long Left, long Top, long Width, long Height, float NearClip,
                           float FarClip, LPDIRECT3DDEVICE9 pDevice ) 
{ 
    // Set viewport sizes 
    Viewport.X      = Left; 
    Viewport.Y      = Top; 
    Viewport.Width  = Width; 
    Viewport.Height = Height; 
    Viewport.MinZ   = 0.0f; 
    Viewport.MaxZ   = 1.0f; 
    NearClip       = NearClip; 
    FarClip        = FarClip; 
    ProjDirty      = true; 
 
    // Update device if requested 
    if ( pDevice ) pDevice->SetViewport( &Viewport ); 
} 


//-------------------------------------------------------------------------
// Return Perspective Projection matrix (Recalculate if dirty)
//-------------------------------------------------------------------------
const D3DXMATRIX& CCamera::GetProjMatrix()  
{ 
    // Only update matrix if something has changed 
    if ( ProjDirty )  
    {      
        float fAspect = (float)Viewport.Width / (float)Viewport.Height; 
 
        // Set the perspective projection matrix 
        D3DXMatrixPerspectiveFovLH(&Proj, D3DX_PI * 0.5f, (float)1280 / (float)960, 1.0f, 1000.0f);
             
        // Proj Matrix has been updated 
        ProjDirty = false;  
    } 

    // Return the projection matrix. 
    return Proj; 
}



//-------------------------------------------------------------------------
// Update Projection device transform
//-------------------------------------------------------------------------
void CCamera::UpdateRenderProj( LPDIRECT3DDEVICE9 pD3DDevice ) 
{   
    if (!pD3DDevice) return; 
    pD3DDevice->SetTransform( D3DTS_PROJECTION, &GetProjMatrix() ); 
} 



//-------------------------------------------------------------------------
// Update View device transform
//-------------------------------------------------------------------------
void CCamera::UpdateRenderView( LPDIRECT3DDEVICE9 pD3DDevice ) 
{   
    if (!pD3DDevice) return; 
    pD3DDevice->SetTransform( D3DTS_VIEW, &GetViewMatrix() ); 
} 



//-------------------------------------------------------------------------
// Return View matrix (Recalculate if dirty)
//-------------------------------------------------------------------------
const D3DXMATRIX& CCamera::GetViewMatrix() 
{ 
    // Only update matrix if something has changed 
    if ( ViewDirty )  
    { 
        D3DXVec3Normalize( &Look, &Look ); 
        D3DXVec3Cross( &Right, &Up, &Look ); 
        D3DXVec3Normalize( &Right, &Right ); 
        D3DXVec3Cross( &Up, &Look, &Right ); 
        D3DXVec3Normalize( &Up, &Up ); 
 
        //Set view matrix values 
        View._11 = Right.x;View._12 = Up.x;View._13 = Look.x; 
        View._21 = Right.y;View._22 = Up.y;View._23 = Look.y; 
        View._31 = Right.z;View._32 = Up.z;View._33 = Look.z; 
        View._41 =- D3DXVec3Dot( &Position, &Right ); 
        View._42 =- D3DXVec3Dot( &Position, &Up    ); 
        View._43 =- D3DXVec3Dot( &Position, &Look  );

        // View Matrix has been updated 
        ViewDirty = false; 
    }  

    // Return the view matrix. 
    return View; 
}



//-------------------------------------------------------------------------
//
// First Person
//
//-------------------------------------------------------------------------

//-------------------------------------------------------------------------
// Contructor
//-------------------------------------------------------------------------
CCameraFirstPerson::CCameraFirstPerson( const CCamera * pCamera ) 
{ 
    // Update the CCamera from the camera passed 
    SetCameraDetails( pCamera ); 
}



//-------------------------------------------------------------------------
// Setup First Person camera
//-------------------------------------------------------------------------
void CCameraFirstPerson::SetCameraDetails( const CCamera * pCamera ) 
{ 
    // Validate Parameters 
    if (!pCamera) return; 
 
    // Reset / Clear all required values 
    Position    = pCamera->GetPosition(); 
    Right   = pCamera->GetRight(); 
    Look    = pCamera->GetLook(); 
    Up      = pCamera->GetUp(); 
    FOV       = pCamera->GetFOV(); 
    NearClip  = pCamera->GetNearClip(); 
    FarClip   = pCamera->GetFarClip(); 
    Viewport   = pCamera->GetViewport(); 
    
    ViewDirty = true; 
    ProjDirty = true; 
}



//-------------------------------------------------------------------------
// Rotate camera
//-------------------------------------------------------------------------
void CCameraFirstPerson::Rotate( float x, float y, float z ) 
{ 
    D3DXMATRIX Rotate; 

    if ( x != 0 )  
    { 
        D3DXMatrixRotationAxis( &Rotate, &Player->GetRight(), D3DXToRadian( x ) ); 
        D3DXVec3TransformNormal( &Look, &Look, &Rotate ); 
        D3DXVec3TransformNormal( &Up, &Up, &Rotate ); 
        D3DXVec3TransformNormal( &Right, &Right, &Rotate );
    }  
 
    if ( y != 0 )  
    { 
        D3DXMatrixRotationAxis( &Rotate, &Player->GetUp(), D3DXToRadian( y ) ); 
        D3DXVec3TransformNormal( &Look, &Look, &Rotate ); 
        D3DXVec3TransformNormal( &Up, &Up, &Rotate ); 
        D3DXVec3TransformNormal( &Right, &Right, &Rotate ); 
    }  
 
    if ( z != 0 )  
    { 
        D3DXMatrixRotationAxis( &Rotate, &Player->GetLook(), D3DXToRadian( z ) ); 
        D3DXVec3TransformNormal( &Look, &Look, &Rotate ); 
        D3DXVec3TransformNormal( &Up, &Up, &Rotate ); 
        D3DXVec3TransformNormal( &Right, &Right, &Rotate ); 
    }  
         
    // Set view matrix as dirty
    ViewDirty = true; 
} 


//-------------------------------------------------------------------------
// Rotate camera by Quaternion
//-------------------------------------------------------------------------
void CCameraFirstPerson::RotateByMatrix(const D3DXQUATERNION& sQuaternion)
{
     D3DXMATRIX Rotate;
     static D3DXVECTOR3 Look(Look), Up(Up), Right(Right);

     //Get Rotation matrix from Quaternion
     D3DXMatrixRotationQuaternion(&Rotate,&Quaternion);    
     
     //Rotate
     D3DXVec3TransformNormal( &Look, &Look, &Rotate ); 
     D3DXVec3TransformNormal( &Up, &Up, &Rotate ); 
     D3DXVec3TransformNormal( &Right, &Right, &Rotate );

         
    // Set view matrix as dirty
    ViewDirty = true; 
}


//-------------------------------------------------------------------------
// COnnect camera to player
//-------------------------------------------------------------------------
void CCameraFirstPerson::AttachToPlayer( CPlayer * pPlayer )
{
    Player = pPlayer;
}

Кстати, глюки со смещением, не моих рук дело, в окне Visual Studio все ровно. Это при отправке сообщения строчки начинает косить

Здравствуйте, Northaunt, Вы писали:

N>Кстати, глюки со смещением, не моих рук дело, в окне Visual Studio все ровно. Это при отправке сообщения строчки начинает косить

Твоих. Ты явно выравниваешь колонки табуляциями, чего делать нельзя (расползется при другом размере табуляции).

Табуляции допустимы только для отступов, и то спорно (я вот использую пробелы вообще везде).

По моему мнению, хороший код для джуниора.

... << RSDN@Home 1.2.0 alpha 4 rev. 1237>>

Здравствуйте, Northaunt, Вы писали:

N>Кстати, глюки со смещением, не моих рук дело, в окне Visual Studio все ровно. Это при отправке сообщения строчки начинает косить

Твоих, твоих.

Ctrl-R,W — посмотри, где у тебя табуляции, где пробелы.

Здравствуйте, Northaunt, Вы писали:

N>Я начинающий программист на С++, ищу работу.

Одна проблема — приведенный код — это не C++ код. В лучшем случае это с натяжкой можно назвать "C с классами".
Если хочешь найти работу именно на C++, нужно придумать пример именно C++ кода.

Здравствуйте, Northaunt, Вы писали:

N>Да уж, отсылать это было ошибкой. Спасибо тем, кто заставил себя просмотреть все. Если я правильно понял, основные проблемы это: ужасный стиль, комментарии и непонятно что тут вообще делается. Я, скорее всего, последую советам Ytz, но это займет время. А в качестве временного варианта я откопал старый код, маленький класс управления камерой в 3D. Я постарался учесть все ошибки (константы, передачи по ссылкам, изврат в конструкторах, форматирование и т.д.), но, конечно же, наделав много новых. Это, надеюсь, последний раз, постараюсь больше не напрягать.

На мой взгляд, значительно лучше. Правда, обработка ошибок так и не появилась. Или это в графических приложениях не принято?

Насчёт code convention... Я, лично, не думаю, что сам по себе стиль кодирования играет большую роль при приёме на работу, за исключением, наверное, мешанины из пробелов с табуляциями — её может быть просто неудобно читать. То есть, предпочитаешь ты венгерку, Camel, или, там, stl-like — не суть важно. Это всё управляется внутрифирменными соглашениями, потому при необходимости может быть "перенастроено". Скорее, важно другое: на сколько последовательно ты сам придерживаешься выбранного тобой стиля. Если уж переменные-члены класса именуются с большой буквы, шут с ним, пусть именуются с большой буквы, но везде. Если ты отделяешь скобки пробелами — тоже, отделяй тогда уж везде. На практике, разумеется, не всегда всё шоколадно, но тут тебя никто не торопит с подготовкой примеров, можно отсмотреть и повнимательнее.

N>#include "..\..\- Mein\GameApp.h"
N>#include "..\..\Service\Service.h"
N>

Я бы дальше читать не стал. По ссылкам черти откуда черти куда видно, что в проекте полный бардак (некоторые "профессионалы", впрочем, так и пишут — поубивал бы!)

Конструктор копирования (канонический) принимает константную ссылку, а не указатель. Кстати, в данном случае CCamera::CCamera( const CCamera * pCamera ) ничего не берет от pCamera, а просто сбрасывает свои внутренности (так и задумывалось?). И, раз уж он принимает указатель, может быть, нужно его сделать explicit.

Ну, и дизайн.. SetViewport, будучи публичным, принимает тонну параметров, среди которых указатель на d3d-устройство. Много параметров в публичном методе -- это нездорово: во-первых, люди их попросту путают, а потом мучительно разбираются, в чем дело; во-вторых, не смотря на то, что их много, впоследствии их все равно может оказаться мало, и сломается дизайн -- поэтому более кошерно в данном случае было бы объявить интерфейсную структуру и передавать указатель на нее. Наконец, pDevice -- это вполне себе конкретный девайс, которого лучше бы представить доп.интерфейсом, чтобы можно было работать не только с d3d, но и с чем-нибудь еще. Это устройство, как видно, получает указатель на Viewport данной камеры. Вопрос в том, совпадает ли этот pDevice с теми, что передаются в качества параметров методам UpdateRenderXXX? Не следовало ли спрятать указатель на конкретное устройство (разумеется, представленное абстрактным интерфейсом) внутрь CCamera, поскольку связь между CCamera и тем устройством все равно устанавливается?
И последнее. Если я правильно понимаю, CCameraFirstPerson, видимо, предполагает, что если точек наблюдения будет пять, то для каждой придется делать свой класс, наследуемый от CCamera? Как-то это нездорово.

Здравствуйте, Геннадий Васильев, Вы писали:

ГВ>На мой взгляд, значительно лучше. Правда, обработка ошибок так и не появилась. Или это в графических приложениях не принято?

Принято не вылетать на не критических ошибках, ну там текстурка не подгрузилась и т. п.
Правда это делает обработку ошибок более сложной

Здравствуйте, Northaunt, Вы писали:

N>Я начинающий программист на С++, ищу работу. Часто просят отослать пример кода. Вот только, после того как я пересылаю его, на другой стороне полная тишина.

N>#include "..\..\- Mein\GameApp.h"
N>#include "..\..\Service\Service.h"
После этих строк — пришлось заставлять себя смотреть исходники дальше (впрочем, уже совершенно поверхностно), естественно, при реальном разборе — сразу "нет". В основном из-за пробела, но и вообще включение чего-то из .. — ? Плохо спроектированные модули, как минимум. (при этом то же самое как "Main/GameApp.h" — гораздо лучше уже)

Здравствуйте, Northaunt, Вы писали:

N>Да уж, отсылать это было ошибкой. Спасибо тем, кто заставил себя просмотреть все.

N>#include "\Mechanic\CPlayer.h"
Можете пояснить, что именно здесь включается?

Здравствуйте, Northaunt, Вы писали:

К уже сказанному добавлю, что передаваемые параметры нужно проверять. Вот в этом месте (и в некоторых других) всё упадёт, если переданный указатель окажется невалидным:

//-------------------------------------------------------------------------
//    ClearTexture
//-------------------------------------------------------------------------
void Fluid3D::ClearTexture(IDirect3DTexture9* texture)
{
    texture->GetSurfaceLevel(0, &RenderSurface);
    Device->SetRenderTarget(0, RenderSurface);
    Device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL, 0x00000000, 1.0f, 0);
    
    Device->SetRenderTarget(0, BackBuffer);
}

Здравствуйте, Handie, Вы писали:

H>Возможно код будет кому-то в тему, но в общем случае я бы продпочел "чистый" код без идиотических API типа DirectX.

+1 Я думаю, выложенный код плохо подходит для демонтсрации навыков и стиля программирования. API DirectX действительно идиотический, впрочем более чем все API идиотические.

Здравствуйте, Nuseraro, Вы писали:

Ytz>>Это предсказуемо, так как много кода непонятного назначения. Вот у меня сразу вопрос — какую задачу решает код? Поэтому:
Ytz>>1. Выкинь свой код
N>...

N>К сожалению Ytz прав, таких людей чтобы заценили сложность программирования решения уравнений Навье-Стокса немного.

Дык не в этом дело. Можно и чисто числодробительные алгоритмы записать красиво. Например, создать классы, шаблоны, перегрузку операторов и тд. А критерием качества кода может служить то, как быстро код могут разобрать окружающие.

Код на Си с искуственно вставленными классами, с заинлайненными операциями перемножения матриц и без использования контейнеров мало кому понравится.

Что-то тут все мусолят, то не то, это не то.
А помоему ненадо так глубоко копать, проблемма то в том, что этот демонстрационный код — демонстрирует использование Microsoft Direct3D, а не умение программировать 3D графику. аля DirectX SDK Sample.

Здравствуйте, Denis Mingulov, Вы писали:

N>>#include "\Mechanic\CPlayer.h"
DM>Можете пояснить, что именно здесь включается?

Класс, который представляет игрока в сцене и все что с ним связано. Он назван CPlayer, поскольку указатель на его экземпляр хочется назвать Player (указатель я юзаю чаще, чем имя класса, следовательно, идентификатор у него должен быть лаконичней), наверняка, решение не из лучших, но поиск по «Class and Variable same name» не дал результатов. Вроде ответил, но у меня такое ощущение, что вы про другое спрашивали?

Про обработку ошибок. Например, в случае использования DirectX. Если я не ошибаюсь, каждую библиотечную функцию, которая может меня подвести, не создав текстуру либо шейдер, нужно обернуть подходящей проверкой. Следовательно, получиться набор клонов библиотечных функций, но с проверкой. Много времени не займет, но это целый новый неймспейс, а в моем случае, целый новый неймспейс ошибок. В общем если я прав насчет схемы и это существенно улучшит общую картину, нужно сделать? Но я, конечно же, ошибаюсь, подскажите, пожалуйста, как сделать правильно.

Насчет использования API. В ближайшее время я напишу что-нибудь без сторонних библиотек, полностью для демонстрации. Ну а на данный момент, это все, что у меня есть. Тем более, я пока еще пытаюсь попасть в геймдев. Возможно, они иногда обращают внимание на работу с библиотеками (хотя не на что там смотреть)
Кстати, как минимум в одной компании мой код не вызывает жалость и слезы, хотя, наверняка, просто исходники криво прилепись к письму и никто не смог их прочитать, к счастью. Завтра узнаю.

Здравствуйте, Northaunt, Вы писали:

N>>>#include "\Mechanic\CPlayer.h"
DM>>Можете пояснить, что именно здесь включается?
N>Вроде ответил, но у меня такое ощущение, что вы про другое спрашивали?
Да.

В общем-то спрашивал, почему на '\' начинается.

Здравствуйте, Denis Mingulov, Вы писали:

DM>Да.

В общем-то спрашивал, почему на '\' начинается.

Да, виновен. Это из-за моих верхних конечностей, бывают ложные срабатывания, Ctrl+Z в данном случае.

Здравствуйте, Northaunt, Вы писали:

N>Да уж, отсылать это было ошибкой.

в обоих примерах нет комментариев. и оба используют "С с классами", что не годится если ты претендуешь на general-purpose C++ программиста. сразу видно что ты не знаком с boost, синхронизацией и прочими богами мира C++

ГВ>- using std::string — не знаю, кому как, но я не люблю такие вещи. Либо уж std::string variable;, либо using namespace std;

Код

using std::string;
string str;

на порядок лучше кода

using namespace std;
string str;

В первом варианте четко видно что используется только std::string. Во втором глобальное простанство имен "засирается" сотнями или тысячами символов из std. Второй код как минимум привел бы к куче вопросов. Рекомендация "using namespace std;" крайне безграмотная и вредная

Здравствуйте, Northaunt, Вы писали:

N>Посмотрите, пожалуйста, кто-нибудь код и укажите на самые фатальные ошибки, из-за которых меня сразу же посылали в черный список.

Деструкторы не виртуальные.

Здравствуйте, pvirk, Вы писали:

P>Здравствуйте, Northaunt, Вы писали:

N>>Посмотрите, пожалуйста, кто-нибудь код и укажите на самые фатальные ошибки, из-за которых меня сразу же посылали в черный список.

P>Деструкторы не виртуальные.

Протестую

virtual ~CCamera();

Здравствуйте, Northaunt, Вы писали:

P>>Деструкторы не виртуальные.

N>Протестую

Да это он не в прямом смысле наверное а в переносном

Здравствуйте, Handie, Вы писали:

ГВ>>- using std::string — не знаю, кому как, но я не люблю такие вещи. Либо уж std::string variable;, либо using namespace std;

[...]

H>В первом варианте четко видно что используется только std::string. Во втором глобальное простанство имен "засирается" сотнями или тысячами символов из std. Второй код как минимум привел бы к куче вопросов. Рекомендация "using namespace std;" крайне безграмотная и вредная

Медленно читаем написанное: "...не знаю, кому как, но я не люблю...". Объясню, почему мне это не нравится: по каждому чиху приходится писать дополнительный using type вместо одноразового включения хидеров всей STL куда-нибудь в .pch. Получается ворох совершенно не нужного мусора. Больше того, если в тексте программы написано "string x;", то опять таки, я "автоматически" предполагаю аналогичную доступность остальных типов, то есть я могу написать "ostringstream os;" без неожиданных эффектов в виде ошибок компиляции, ну, в крайнем случае, я готов добавить соответствующий include.

А чтобы не засирать глобальное пространство имён (если уж это становится проблемой), есть простой выход — завести свой собственный namespace.

ГВ>А чтобы не засирать глобальное пространство имён (если уж это становится проблемой), есть простой выход — завести свой собственный namespace.

Генадий, видимо Вы еще не дошли до разработки крупных систем.
Я всегда предпочитаю forward declaration вместо включения файла

если строка

class SuperClass;

позволяет избежать

#include "SuperClass.h"

я всегда предпочту первый вариант

если из неймспеса мне нужно пару сущьностей, я возьму только их:

using std::map;
using std::string;

вместо засирания неймспейса

using namespace std;

Не надо свое невежество выдавать за рекомендации гуру

Здравствуйте, Handie, Вы писали:

ГВ>>А чтобы не засирать глобальное пространство имён (если уж это становится проблемой), есть простой выход — завести свой собственный namespace.

H>Генадий, видимо Вы еще не дошли до разработки крупных систем.

Странное дело: разве до разработки крупных систем надо как-то специально "доходить"? Это просто работа, которая либо на тебя сваливается, либо ты сам её "пикапишь". Кстати, коль зашла такая пьянка: что ты имеешь в виду под крупными системами?

H>Я всегда предпочитаю forward declaration вместо включения файла

H>если строка

H>

H>class SuperClass;
H>

H>позволяет избежать

H>

H>#include "SuperClass.h"
H>

H>я всегда предпочту первый вариант

Да, это бывает полезно, если в проекте творится кавардак: все всех подозревают, левая рука не ведает, что творит правая, нет единообразного подхода к дизайну, толкового распределения задач и т.п. Короче говоря, когда все ото всех решительно изолируются самостоятельно. То есть, в общем, кое-какой шухер сбить такой подход позволяет. С другой стороны, ты лишаешься возможности включить экземпляр SuperClass-а по значению:

class SuperClass;

class MyClass : public SuperClass {...} // Болт!...

class MyClass1
{
...
  SuperClass superMember_; // ...с левой резьбой!
};

Придётся писать что-то в духе pImpl и т.п. Не то, чтобы это было плохо само по себе, но будучи принятым на уровне некоего "правила", сильно ограничивает разработчика.

Извини, что объясняю столь детально.

H>если из неймспеса мне нужно пару сущьностей, я возьму только их:

H>

H>using std::map;
H>using std::string;
H>

H>вместо засирания неймспейса

H>

H>using namespace std;
H>

Кстати, соответствующий инклюд всё равно придётся вставлять, если, конечно, ты не обходишься без использования значений соответствующих типов.

H>Не надо свое невежество выдавать за рекомендации гуру

Я не случайно оговорился в самом начале, что "я не люблю...". Всё вышесказанное как раз иллюстрирует отчасти вкусовой характер этой проблемы — для принятия точных решений нужна статистика использования типов той же STL. Не спорю, может быть, в твоём случае (да и в случае топикстартера тоже) вполне можно обойтись using-type, мне это обычно здорово мешало: писать по полтора десятка using-ов на каждом углу как-то шумновато.

Здравствуйте, Northaunt, Вы писали:

имхо, это как бы не демострационный код для С++.

Заверните что нить эдакое с интерфейсами\наследованием\темплейтами.
Покажите что понимаете области видимости, что такое константные обьекты\методы\мутабл,
исключения как работают, оператор перегрузите ну и т.д.
Вообщем возьмите учебник по С++, пройдитесь по разделам, и найдете много чего что можно
показать в своем демонстрационном коде по С++.

Здравствуйте, 8bit, Вы писали:

8>Вообщем возьмите учебник по С++, пройдитесь по разделам, и найдете много чего что можно
8>показать в своем демонстрационном коде по С++.

Представляешь, как встанут волосы дыбом у собеседователей, если последовать такому совету?

Здравствуйте, Геннадий Васильев, Вы писали:

ГВ>Представляешь, как встанут волосы дыбом у собеседователей, если последовать такому совету?

Всмысле?

Здравствуйте, 8bit, Вы писали:

ГВ>>Представляешь, как встанут волосы дыбом у собеседователей, если последовать такому совету?

8>Всмысле?

В прямом.

Здравствуйте, 8bit, Вы писали:

8>Здравствуйте, Геннадий Васильев, Вы писали:

ГВ>>Представляешь, как встанут волосы дыбом у собеседователей, если последовать такому совету?

8>Всмысле?

Ну вот смотри например — использование boost, как тут недавно советовали:

int main(int argc, char* argv[]) {
  typedef std::map<std::string, std::pair<int, int> > map_type;
  map_type files;
  files["0.txt"] = std::make_pair(0, 7);
  files["1.txt"] = std::make_pair(8, 41);
  files["2.txt"] = std::make_pair(42, 50);
  int num = 21;
  map_type::const_iterator elem;
  elem = std::find_if(
                      files.begin(),
                      files.end(),
                      boost::bind(
                                  std::logical_and<bool>(),
                                  boost::bind(
                                              std::less_equal<int>(),
                                              boost::bind(
                                                          &map_type::value_type::second_type::first,
                                                          boost::bind(
                                                                      &map_type::value_type::second,
                                                                      _1)
                                                          ),
                                              num),
                                  boost::bind(
                                              std::greater_equal<int>(),
                                              boost::bind(
                                                          &map_type::value_type::second_type::second,
                                                          boost::bind(
                                                                      &map_type::value_type::second,
                                                                      _1)
                                                          ),
                                              num)));
  if (elem != files.end())
    std::cout << "Found in " + (*elem).first + "\n";
  return 0;
}

Блэкджек и шлюхи отдыхают

IMHO, всякая заумь — это детская (?) болезнь, которой топикстартер к счастью не страдает.

Здравствуйте, Геннадий Васильев, Вы писали:

ГВ>Здравствуйте, 8bit, Вы писали:
8>Вообщем возьмите учебник по С++, пройдитесь по разделам, и найдете много чего что можно
8>показать в своем демонстрационном коде по С++.
ГВ>>>Представляешь, как встанут волосы дыбом у собеседователей, если последовать такому совету?

8>>Всмысле?

ГВ>В прямом.

От чего волосы-то дыбом?
Если что, я не имел ввиду переписать себе код из книжки или написать примеры для всего и вся

Здравствуйте, bnk, Вы писали:

bnk>Ну вот смотри например — использование boost, как тут недавно советовали:

bnk>

bnk>int main(int argc, char* argv[]) {
bnk>  typedef std::map<std::string, std::pair<int, int> > map_type;
bnk>  map_type files;
bnk>  files["0.txt"] = std::make_pair(0, 7);
bnk>  files["1.txt"] = std::make_pair(8, 41);
bnk>  files["2.txt"] = std::make_pair(42, 50);
bnk>  int num = 21;
bnk>  map_type::const_iterator elem;
bnk>  elem = std::find_if(
bnk>                      files.begin(),
bnk>                      files.end(),
bnk>                      boost::bind(
bnk>                                  std::logical_and<bool>(),
bnk>                                  boost::bind(
bnk>                                              std::less_equal<int>(),
bnk>                                              boost::bind(
bnk>                                                          &map_type::value_type::second_type::first,
bnk>                                                          boost::bind(
bnk>                                                                      &map_type::value_type::second,
bnk>                                                                      _1)
bnk>                                                          ),
bnk>                                              num),
bnk>                                  boost::bind(
bnk>                                              std::greater_equal<int>(),
bnk>                                              boost::bind(
bnk>                                                          &map_type::value_type::second_type::second,
bnk>                                                          boost::bind(
bnk>                                                                      &map_type::value_type::second,
bnk>                                                                      _1)
bnk>                                                          ),
bnk>                                              num)));
bnk>  if (elem != files.end())
bnk>    std::cout << "Found in " + (*elem).first + "\n";
bnk>  return 0;
bnk>}
bnk>

Знаешь поймал себя на мысли, что сделал бы примерно если бы приперло также только через операторы и константы

8>Всмысле?

В прямом смысле. По примеру кода (не скажу, что все, но почти все, с кем мне приходилось сталкиваться, да и я сам тоже) пытаются сделать вывод о том, как человек будет писать код в повседневных условиях. Не тогда, когда он специально готовится к показу своей крутизны, а как он будет день за днём лопатить килобайты своего и чужого кода. То есть здесь на самом деле важны не столько продвинутые техники, сколько нюансы вроде std::string, переданных по значению без особой нужды, последовательности в стиле оформления, стиль комментирования, подход к обработке ошибок, прочие подобные характеристики, которые "проходят через весь код". Потому что такие моменты человек вписывает полуавтоматически, чуть ли не на спинномозговых реакциях. Опять таки, могут быть применены и шаблоны, и исключения, и, не побоюсь этого слова, виртуальные деструкторы — но всё должно быть к месту и в меру. Потому, кстати, часто просят пример продуктового кода. Это вовсе не для того, чтобы спереть очередную великую идею гениального велосипеда на тэтраидальных колёсах, а чтобы посмотреть на вот те самые нюансы. Понятно, что код примера будет несколько подчищен, но я тебе ручаюсь — всех нюансов без специальной подготовки (которая равна, по сути, повышению квалификации) всё равно не вычистить.

Вот теперь представь, что в такой контекст ты закидываешь для анализа что-то вроде упражнения по книге Александреску, или сборник приёмов по главам из ARM.

Здравствуйте, Roman Odaisky, Вы писали:

RO>Здравствуйте, Northaunt, Вы писали:

N>>Кстати, глюки со смещением, не моих рук дело, в окне Visual Studio все ровно. Это при отправке сообщения строчки начинает косить

RO>Твоих. Ты явно выравниваешь колонки табуляциями, чего делать нельзя (расползется при другом размере табуляции).

RO>Табуляции допустимы только для отступов, и то спорно (я вот использую пробелы вообще везде).

Ложь, tab/spaces зависит от code-style принятого в проекте.

Здравствуйте, Геннадий Васильев, Вы писали:

ГВ>Вот теперь представь, что в такой контекст ты закидываешь для анализа что-то вроде упражнения по книге Александреску, или сборник приёмов по главам из ARM.

вон оно что, понятно

Ну так он же начинающий программист. Тут надо смотреть умеет ли он этим С++ вообще пользоваться.
А нюансы и тут видны будут.

Здравствуйте, 8bit, Вы писали:

ГВ>>Вот теперь представь, что в такой контекст ты закидываешь для анализа что-то вроде упражнения по книге Александреску, или сборник приёмов по главам из ARM.

8>вон оно что, понятно

Ну так он же начинающий программист. Тут надо смотреть умеет ли он этим С++ вообще пользоваться.
8>А нюансы и тут видны будут.

Угу, о чём и идёт речь с самого начала.

Немного в иносказательном стиле, но тем не менее.

Здравствуйте, bnk, Вы писали:

bnk>Блэкджек и шлюхи отдыхают

Мда... Православный буст головного мозга в полный рост.

Здравствуйте, Геннадий Васильев, Вы писали:

ГВ>Угу, о чём и идёт речь с самого начала.

Немного в иносказательном стиле, но тем не менее.

Так я и говорю, пусть напишет код как он знает С++, без перегибов конечно, и по нему и нюансы и знание С++ будет видно.
А сейчас у него три страницы DX кода и плюсов там совсем не видно.

Здравствуйте, 8bit, Вы писали:

ГВ>>Угу, о чём и идёт речь с самого начала.

Немного в иносказательном стиле, но тем не менее.

8>Так я и говорю, пусть напишет код как он знает С++, без перегибов конечно, и по нему и нюансы и знание С++ будет видно.
8>А сейчас у него три страницы DX кода и плюсов там совсем не видно.

Не-не-не, ты не понял. Смотрят в примере не столько на знание C++ (это можно определить собеседованием), сколько на то, правильно ли он используется в разных закоулках. Вопросы вида: "А знает ли автор об XXXXX?" — это уже вторая производная от суммы наблюдений. Ну и ещё играет роль общая культура программирования, которая от языка не зависит. Это может быть даже DX-код, нет проблем. C++ — объёмный язык, а задачи, которые решает данный кандидат вполне могут не требовать применения каких-то аспектов самого C++ (к примеру — volatile-модификаторы нужны очень не всегда, да и виртуальные деструкторы, не к ночи будь помянуты, тоже).

Так что, код тописктартера, ИМХО, вполне подходит для демо-кода, разве что длинноват, имело бы смысл выбрать что-то покороче. Но справедливости ради, в конечном итоге ТС так и поступил.

Здравствуйте, vpchelko, Вы писали:

N>>>Кстати, глюки со смещением, не моих рук дело, в окне Visual Studio все ровно. Это при отправке сообщения строчки начинает косить
RO>>Твоих. Ты явно выравниваешь колонки табуляциями, чего делать нельзя (расползется при другом размере табуляции).
RO>>Табуляции допустимы только для отступов, и то спорно (я вот использую пробелы вообще везде).

V>Ложь, tab/spaces зависит от code-style принятого в проекте.

Табуляции не в начале строки неприемлемы ни при каких условиях. Единственное преимущество табуляций — возможность настроить их размер — в этом случае сводится на нет.

Здравствуйте, Northaunt, Вы писали:

N>Fluid.h
N>

N>//-------------------------------------------------------------------------
N>//    Fluid class Destructor
N>//-------------------------------------------------------------------------
N>Fluid3D::~Fluid3D()
N>{
N>    //Free all Textures
N>    GameApp::Release<IDirect3DTexture9*>(Velocity);
N>    GameApp::Release<IDirect3DTexture9*>(Pressure);
N>    GameApp::Release<IDirect3DTexture9*>(Density);
N>    GameApp::Release<IDirect3DTexture9*>(ZLookup);
N>    GameApp::Release<IDirect3DTexture9*>(Divergence);
N>    GameApp::Release<IDirect3DTexture9*>(TemporaryRenderTarget);
N>    GameApp::Release<IDirect3DSurface9*>(BackBuffer);
N>    GameApp::Release<IDirect3DSurface9*>(RenderSurface);

N>    //Free all Vertex Buffers
N>    GameApp::Release<IDirect3DVertexBuffer9*>(QuadVB);
N>    GameApp::Release<IDirect3DVertexBuffer9*>(QuadsArrayVB);
N>    GameApp::Release<IDirect3DVertexBuffer9*>(BorderLinesVB);

N>    //Free all Effects
N>    GameApp::Release<ID3DXEffect*>(FluidEffect);
N>}
N>

Стоит использовать деструкторы и умные указатели, а не лепить явные Release.

Здравствуйте, Cyberax, Вы писали:

C>Стоит использовать деструкторы и умные указатели, а не лепить явные Release.

Кстати, это не всегда так. Был у меня случай, когда исключения летели как раз из Release, а в последовательности деструкторов умных указателей копаться — ой, неудобно.

8>Так я и говорю, пусть напишет код как он знает С++, без перегибов конечно, и по нему и нюансы и знание С++ будет видно.
8>А сейчас у него три страницы DX кода и плюсов там совсем не видно.
Плюсов там ровно столько сколько нужно в реальном проекте и это топикстартеру только в плюс. Смарт пойнтеры только еще желательно было бы использовать.

	От:	Northaunt
	Дата:	27.07.10 10:52
	Оценка:	7 (3)

	От:	Northaunt
	Дата:	27.07.10 10:56
	Оценка:

	От:	Sni4ok
	Дата:	27.07.10 11:03
	Оценка:

	От:	Handie
	Дата:	27.07.10 11:42
	Оценка:

	От:	A.Lokotkov
	Дата:	27.07.10 12:04
	Оценка:	+1

От:	Геннадий Васильев	http://www.livejournal.com/users/gesha_x
Дата:	27.07.10 15:10
Оценка:	1 (1) +1 -1

От:	bnk	http://unmanagedvisio.com/
Дата:	27.07.10 15:14
Оценка:

От:	Ytz	https://github.com/mtrempoltsev
Дата:	27.07.10 15:32
Оценка:	3 (3) +3

От:	okman	https://searchinform.ru/
Дата:	27.07.10 15:57
Оценка:

	От:	Roman Odaisky
	Дата:	27.07.10 20:37
	Оценка:	+1

От:	Pzz	https://github.com/alexpevzner
Дата:	28.07.10 00:49
Оценка:	+1

От:	Denis Mingulov	http://denis.mingulov.com
Дата:	28.07.10 07:10
Оценка:

От:	artem_korneev	https://www.linkedin.com/in/artemkorneev/
Дата:	28.07.10 09:42
Оценка:	+1

От:	denisko	http://sdeniskos.blogspot.com/
Дата:	30.07.10 13:58
Оценка:

	От:	pvirk
	Дата:	29.07.10 08:02
	Оценка: