Direct3D

Windows 7 Direct3D9: (ERROR)

brucezhou — Fri, 20 Nov 2009 02:51:41 GMT

I am running a application on Windows 7. It does not work and gives me the messages:
Direct3D9: (ERROR) :Could not create exclusive mode mutex. exiting
The thread 0x95C has exited with code -1073741502 (0xC0000142).

I had download and installed the lasted directx 9c from microsoft website!
VC++ 6 and sp6

How can I do?

Thanks for all!

DirectX shader compiler can't unroll it's loops

Kayamon — Sat, 14 Nov 2009 04:29:30 GMT

The attached HLSL shader does not compile when using the shader compiler from the August 2009 DirectX SDK.

    
            //-- TEST.HLSL ------------------- <snip> ------------------------ 
        
            // Compiling with this command line: 
        
            // 
        
            // fxc test.hlsl /T ps_3_0 
        
            // 
        
            // Fails with this message: 
        
            // 
        
            // Microsoft (R) Direct3D Shader Compiler 9.27.952.3012 
        
            // Copyright (C) Microsoft Corporation 2002-2009. All rights reserved. 
        
            // 
        
            // D:\test.hlsl(18,16): error X3531: Can't unroll loops marked with loop attribute 
        
            // D:\test.hlsl(14,16): error X3531: Can't unroll loops marked with loop attribute 
        
            // 
        
            // compilation failed; no code produced 
        
            sampler2D smp0 : register(s0); 
        
            sampler2D smp1 : register(s1); 
        
            sampler2D smp2 : register(s2); 
        
            float4 fetch( sampler2D tex, float2 uv ) 
        
            { 
        
                return tex2Dlod( tex, float4( uv.xy, 0, 0 ) ); 
        
            } 
        
            float4 main() : COLOR 
        
            {     
        
                float result = 0; 
        
                [loop] while( result < 1 ) 
        
                { 
        
                    float2 nodeIndex = float2(result,0); 
        
                    [loop] while(true) 
        
                    { 
        
                        float2 nodeChildren = fetch( smp2, nodeIndex ).xy; 
        
                        float2 nodeInfo = fetch( smp1, nodeIndex ).xy; 
        
                        [flatten] if ( nodeChildren.x == 0 ) 
        
                            break; 
        
                        nodeIndex += nodeChildren; 
        
                    } 
        
                    result += fetch( smp0, nodeIndex ).x; 
        
                } 
        
                return result.xxxx; 
        
            }

imposters

Btrix — Wed, 18 Nov 2009 19:54:27 GMT

hi,.

I would like to create basic imposters that i can use to render far trees and later use to make volumetric clouds. I've read somethings. But they only explain the basic idea about it, which is pretty simple,

just render a model( or whatever you want in a texture that is rendered on a face) depenending on the angle chance they make a new texture so we can use them in many frames what seriously speedsup the framerate. I found this interesting article http://www.gamasutra.com/features/20060105/davis_01.shtml but it is written in c++.

But I don't have that much knowledge about shaders so who could i implement this the best way? all hints or information is Welcome.

Need lots of information to vertex shader

matieman — Tue, 17 Nov 2009 23:06:17 GMT

I am planning to implement photon mapping entirely on the vertex shader by representing each photon as a vertex, and drawing these vertices as points on a photon map texture.

The thing is, for the calculations to find where the photons hit the scene, I will need to supply the scene information to the vertex shader. This may sound impossible, but the scene is made of cubes aligned to a grid (think infiniminer), so simpler than triangles. I need to pass a large enough portion of these cubes to the vertex shader somehow, and it needs to be fast to access (as I need to find where rays intersect the scene.

Three things I was thinking of:

1) as a shader parameter:

it's fast, but very limited, I would have to compress the data a lot to try and fit it into 250 quadfloats.

2) as a volumetric texture:

extremely fill rate intensive, but I can fit a lot of information into it. probably the best way to do it.

3) as a second vertex stream:

maybe hack the hardware instancing technique a bit and try to get the scene info on a second vertex stream? is this possible?

What is the best way to do it?

Any other ideas?

Cheers.

[SOLVED] Restoring world space positions from linear depth buffer

Kjetil — Tue, 17 Nov 2009 22:55:12 GMT

Hi!
I tried posting this problem on Gamedev earlier, though it didn't get a lot of attention, so I hope it's not bad karma to post it here as well. The more readers the merrier :)

So I'm trying to reconstruct the world space postion from a linear depth buffer (depths between [0,1] in view space) in my deferred renderer for a bounding volume (namely a light sphere). I know this topic has been covered before in a few threads, though these have focused on the problem when using fullscreen quads, and not bounding volumes. Also, MJP has posted a nice technique in his blog here, but I don't really understand it and can't get it working. MJP proposes this method to get the view space position from the depth buffer:

float3 VSPositionFromDepth(float2 vTexCoord, float3 vPositionVS) {
// Calculate the frustum ray using the view-space position.
// farCip is the distance to the camera's far clipping plane.
// Negating the Z component only necessary for right-handed coordinates
float3 vFrustumRayVS = vPositionVS.xyz * (farClip/-vPositionVS.z);
return tex2D(depthSampler, vTexCoord).x * vFrustumRayVS;
}

So I create my texcoords, which after a litte cpu-testing/debugging seems to work just fine, like this:
input.ssPos.xy /= input.ssPos.w;
//Setup texture coordinates, transforming from [-1,1]->[1,-1] to [0,1]->[1,0]
float2 tex = (0.5f * (float2(input.ssPos.x, -input.ssPos.y) + 1)) - halfPixel;

where ssPos is output from the vertex shader computed normally as:
output.ssPos = mul(input.pos, WorldViewProj);

Okay...so after having run:

//View space position
float3 wsPos = VSPositionFromDepth(tex, input.vsPos);
//Transform to world space
float3 wsPos = mul(wsPos, InvertView);

the shader still produces incorrect results. I don't see why wsPos is incorrect, which is mysterious to me. Any thoughts on how to approach the problem?

Problem solved

Kode527 — Tue, 17 Nov 2009 16:24:20 GMT

No problem anymore, My program just didn't close because I was trying to release index buffer I didn't have.

How to handle Lock Screen ?

autumn — Tue, 17 Nov 2009 06:13:06 GMT

I have app written in C++ with DirectX9.0c, i found a problem, when I lock the screen by press Ctrl + Alt + Del, and return back, i found there is nothing in the app window! only left me the background color, how to handle this?
thanks in advance!

About vertex normals

Kode527 — Sun, 15 Nov 2009 16:51:41 GMT

Can I set more than just one normal for one vertex?
For example .obj format has 3 normals per face. How do I convert them to my FVF, which is (XYZ|NORMAL|COLOR).
If I can, how do I tell the device which one to use when rendering?

Heightmap rendering issue

Qzole — Mon, 16 Nov 2009 00:51:20 GMT

Hi everyone, I have a bit of a problem which is driving me crazy.
I wrote a heightmap class, it generally works good, but it's littered with weird shading artifacts, and I have absolutely no idea what can be the problem.

Enough talk, let's see the pictures.
The reference picture from wikipedia:
http://upload.wikimedia.org/wikipedia/commons/2/2f/Heightmap_rendered.png
And my scene, same heightmap, nearly same camera / light position:
http://img4.imageshack.us/img4/1699/myterrain.png

Ok, you might say that it looks ok, but if you look closer, you can see that there are many weird rectangles in the image, as if it would be converted into a low quality jpeg (which, almost nobody who I know would notice from this distance except me '-.-)

So I looked closer what could be the problem, and here is a close up with a vertex shader:
http://img690.imageshack.us/img690/2888/vertexshading.png
Uh well, yeah ugly linear interplorations of the color, I know, let's put diffuse intensity calculation into the pixelshader:
http://img35.imageshack.us/img35/8674/pixelshading.png
uh,... what? I am kinda new to shader programming, and I might not be used to look at things this close up, but shouldn't there be a change aside from the contour of the darkest parts?
Maybe there is something up with the normals?
http://img513.imageshack.us/img513/8238/normals.png
Well, alright it looks like a mess, but they don't seem to be off...

The wierdest thing is about the triangles near the camera, the ones that all 3 of their vertices are somewhat dark, but there is one edge that is bright :S
EDIT: looked at them with the eyedrop tool in photoshop, and the color is correctly interpolated linearly so it isn't brigther, altough still I thought that if I use pixel shading, and the normal is interpolated, the colors won't look like this.

So I'm out of ideas what could be the problem, I really don't know.

There was also a specular calculation, which changed depending if it was in the VS or PS, but I took it out for simplicity's sake.

Here is the hlsl code for the pixelshader:

    
            shared float4x4 World; 
        
            shared float4x4 View; 
        
            shared float4x4 Projection; 
        
            shared float3 cameraPosition; 
        
            struct VS_Output 
        
            { 
        
                 float4 Position : POSITION; 
        
                 float3 WorldNormal : TEXCOORD0; 
        
                 float3 WorldPosition : TEXCOORD1; 
        
            }; 
        
            VS_Output PerPixelDiffuseVS( 
        
                 float3 position : POSITION, 
        
                 float3 normal : NORMAL ) 
        
            { 
        
                 VS_Output output; 
        
                 //generate the World-View-Projection matrix 
        
                 float4x4 wvp = mul(mul(World, View), Projection); 
        
                 //transform the input position to the output 
        
                 output.Position = mul(float4(position, 1.0), wvp); 
        
                 output.WorldNormal =  mul(normal, World); 
        
                 float4 worldPosition =  mul(float4(position, 1.0), World); 
        
                 output.WorldPosition = worldPosition / worldPosition.w; 
        
                 //return the output structure 
        
                 return output; 
        
            } 
        
            float4 DiffuseAndPhongPS(VS_Output input) : COLOR 
        
            { 
        
                 float3 directionToLight = normalize(float3(0, 1, 1)); 
        
                 float diffuseIntensity = saturate( dot(directionToLight, input.WorldNormal)); 
        
                 float4 diffuse = float4(0.7, 0.7, 0.7, 1) * diffuseIntensity; 
        
                 //all color components are summed in the pixel shader 
        
                 float4 color = diffuse + float4(0.15, 0.15, 0.15, 15); 
        
                 color.a = 1.0; 
        
                 return color; 
        
            } 
        
            technique PerPixelDiffuseAndPhong 
        
            { 
        
                pass P0 
        
                { 
        
                      //set the VertexShader state to the basic 
        
                      //vertex shader that will set up inputs for 
        
                      //the pixel shader 
        
                      VertexShader = compile vs_2_0 PerPixelDiffuseVS(); 
        
                      //set the PixelShader state to the complete Phong Shading 
        
                      //implementation of the pixel shader        
        
                      PixelShader = compile ps_2_0 DiffuseAndPhongPS(); 
        
                } 
        
            }

And my normal calculation (vertex2Array is for drawing the green normal lines):

    
                    public void RecalculateNormals() 
        
                    { 
        
                        for (int y = 0; y < heightMapTexture.Height; ++y) 
        
                            for (int x = 0; x < heightMapTexture.Width; ++x) 
        
                            { 
        
                                Vector3 left = (x > 0) ? vertexArray[y * heightMapTexture.Width + x - 1].Position : vertexArray[y * heightMapTexture.Width + x].Position; 
        
                                Vector3 right = (x < heightMapTexture.Width - 1) ? vertexArray[y * heightMapTexture.Width + x + 1].Position : vertexArray[y * heightMapTexture.Width + x].Position; 
        
                                Vector3 up = (y < heightMapTexture.Height - 1) ? vertexArray[(y + 1) * heightMapTexture.Width + x].Position : vertexArray[y * heightMapTexture.Width + x].Position; 
        
                                Vector3 down = (y > 0) ? vertexArray[(y - 1) * heightMapTexture.Width + x].Position : vertexArray[y * heightMapTexture.Width + x].Position; 
        
                                vertexArray[y * heightMapTexture.Width + x].Normal = Vector3.Normalize(Vector3.Cross(Vector3.Normalize(right-left), Vector3.Normalize(up-down))); 
        
                                vertex2Array[y * heightMapTexture.Width * 2 + x * 2] = new VertexPositionNormalTexture(vertexArray[y * heightMapTexture.Width + x].Position, Vector3.Up, Vector2.One); 
        
                                vertex2Array[y * heightMapTexture.Width * 2 + x * 2 + 1] = new VertexPositionNormalTexture(vertexArray[y * heightMapTexture.Width + x].Position + vertexArray[y * heightMapTexture.Width + x].Normal * 0.05f, Vector3.Up, Vector2.One); 
        
                            } 
        
                    }

I tried 3 other ways to calculate the normals, and all had the same results...

I desperately need help, thank you in advance with any advice.

How to disable 3D device caps ?

Kroah — Fri, 06 Nov 2009 18:48:32 GMT

Hello everybody!

Here's my problem:

I'm currently developping a game using a 3D device (GeForce 7600GS) which has some 3D capabilities. This card runs my game flawlessly.
Some beta testers are testing my game with different 3D devices and old cards can't run my game because they are missing some caps.

I'm updating my game to make those older 3D devices compatible.
Unfortunately, i can only test my game with my 3D device and i don't want to release the new version to the beta testers without having tested it before on older 3D devices.

So my question is:
Do you know if there's a way to disable some capabilities of my 3D device to check if the new version of my game fix the problem of older devices?

In my case, the capabilities are D3DPTEXTURECAPS_POW2 (SupportsPower2 in C#) and D3DPTEXTURECAPS_NONPOW2CONDITIONAL (SupportsNonPower2Conditional in C#).

If i can disable both capabilities, i will be sure i wouldn't have missed something in my code.

Thank you for your help

Multidimensional Array for Texture3D.SetData(..)

ab2 — Sun, 15 Nov 2009 15:14:39 GMT

(How) Can I use multidimensional C#-Arrays like

"arr[5,6,7]"

"arr[5][6][7]"

for Texture3D.SetData<T[]>(..)-method?

Somehow it seems to be possible but I can not figure it out how.

The compiler tells me that there are generic types for SetData
available but if I try to use an multidimensional-array then there
are System.ValueType - errors.

Would'nt it be possible to use an multidimensional array like [][][] or [,,] that is accepted
somehow by the generic-SetData<>() ?

Thanks for some words about this.

cheers

How to render DirectX9 on my CLR customed control?

akira32 — Wed, 11 Nov 2009 11:05:59 GMT

My CLR project have many Split Containers, one Container has a customed user control.
I want to Render a cylinder with DirectX9 on the user control.
Could somebody tell how to get windows handle of user control or render with DirectX?

HLSL (sm2.0b) LOD

Orwell — Sat, 14 Nov 2009 12:26:14 GMT

    
            #define MAX_ALLOWED_DISTANCE_FLORA 200.0f 
        
            VS_OUTPUT_FLORA vs_flora(uniform const int PcfMode, float4 vPosition : POSITION, float4 vColor : COLOR, float2 tc : TEXCOORD0) { 
        
                VS_OUTPUT_FLORA Out = (VS_OUTPUT_FLORA)0; 
        
                float4 vWorldPos = (float4)mul(matWorld,vPosition); 
        
                float fDistance = distance(vCameraPos,vWorldPos);       // Distance between Camera and Vertex 
        
                if(fDistance < MAX_ALLOWED_DISTANCE_FLORA) {            // Near the camera 
        
                    Out.Pos = mul(matWorldViewProj, vPosition); 
        
                    Out.Color = vColor * (vAmbientColor + vSunColor * 0.06f); 
        
                    Out.Tex0 = tc; 
        
                    Out.SunLight = (vSunColor*0.34f)*vMaterialColor*vColor; 
        
                    if (PcfMode != PCF_NONE) { 
        
                        float4 ShadowPos = mul(matSunViewProj,vWorldPos); 
        
                        Out.ShadowTexCoord = ShadowPos; 
        
                        Out.ShadowTexCoord.z /= ShadowPos.w; 
        
                        Out.ShadowTexCoord.w = 1.0f; 
        
                        Out.TexelPos = Out.ShadowTexCoord * fShadowMapSize; 
        
                    } 
        
                    float3 P = mul(matWorldView,vPosition); 
        
                    Out.Fog = get_fog_amount(length(P)); 
        
                } else {                                                // NOT near the camera 
        
                    Out.Color.a = 0.0f;                                 // Optional, to remove the greyish goo left over by not Outputting anything 
        
                }                                                       // There's only one problem: vertices which are skipped stay at their origin (middle of the screen), while calculated vertices remain on their proper spot... 
        
                return Out;                                             // the lines connecting those vertices will then start tearing across the screen 
        
            } 

            As the comments say, it's not the best solution to make rendering go faster at a distance...

            Anyone know of a better approach?

Hello, just started d3d programming

Kode527 — Thu, 12 Nov 2009 18:33:37 GMT

Hi!
Allright, this seems to be some kind of direct3d forum. If I'm right I can ask for help here?
Started programming with direct3d and c++ about half a week ago, and what I have done is movable camera and 2 cubes.
Here is couple of questions I've been looking answer for:

The cubes I've created are stored in 2 vertexbuffers(6 verticles on each) and 2 indexbuffers
So is it the best way to create objects by using custom vertex FVF format with coordinates and so on?

I've been thinking about textures too.
I think its just storing the texture coordinates to the FVF and then something like somedevice->setTexture() or something... messing with TextureStages and so on.
Am I right?
But if there is 1 set of texture coordinates per vertex and theres something like 3 faces that has the vertex, how do you map the textures then?
Its 3 faces with textures, but only 1 set of coordinates.

How about if I have multiple textures, do I just set the texture again every time I need to use another one?

Supported file format(s)

Jonathan Archer — Mon, 26 Oct 2009 10:58:58 GMT

Hi there!

Is it correct, that .x is the only out-of-the-box file format that is supported by D3D9? I also have seen the obj example in the samples. But are there other formats directly supported?

And what about D3D10?

Thanks a lot in advance!

Antialiasing-State of the graphic card before the initialization of the device

shine47 — Wed, 11 Nov 2009 11:06:18 GMT

Is there a possibility to find out if the graphic card is using antialiasing (and what stage) before i create a device?
The problem is that if i create a device i set the stage of the antialiasing (2x, 4x...), but how
can i know which stage is used before that?

Thanks in advance,

Jens

Creating a cube map texture from 6 bitmap resource

Noekk — Mon, 26 Oct 2009 11:37:34 GMT

Hi,
I want to make an app (st like a screen saver) which must create a 3d environment from 6 images stored in its resouces(cube mapping) but as far as I know it is only possible to create a cube map texture from a .dds file created by dxtex tool.
so is there a way to create a cube map from anything other than that?

Problem getting a simple vertex shader to run

DarkBob — Fri, 07 Aug 2009 09:49:23 GMT

Hi,

I was trying to set up a simple vertex shader and get in running on two triangles but for some reason it doesn't seem to be applied to the vertices. As you'll be able to see if the shader was successfully run all the vertices would be white but unfortunately for me they are not.

I have the D3D_DEBUG_INFO preprocessor flag set for Direct3D. I get no warnings from Direct3D except if I run in software processing mode where it outputs saying there was a first chance exception. I have an NVidia Quadro FX 3700 graphics card that supports vertex shader 3.0. When I try to debug the vertex shaders using pix it says "An error occurred while attempting to debug shader". If I look at the mesh tab in PIX it says vertes shading disabled. All the Direct3D calls return D3D_OK.

If anyone would like to run the program for me and see if they get the same results, I've added all the includes and libraries by pragma calls so literally all you have to do is create a blank Win32 project and paste the code into your main file and put the SimpleHLSL.fx file in a subfolder called shaders.

I'm really at a loose end on this one, any help would be appreciated.

Thanks =)

SimpleHLSL.fx

    
            //--------------------------------------------------------------------------------------  
        
            // Global variables  
        
            //--------------------------------------------------------------------------------------  
        
            float4x4    gr4x4WorldViewProjection;  
        
            struct cOutputVS  
        
            {  
        
                float4  mPositionOut    : POSITION;  
        
                float4  mColourOut      : COLOR0;  
        
            };  
        
            cOutputVS MyVertexShaderVS(   
        
                    float4  lPositionIn     : POSITION,  
        
                    float4  lColourIn       : COLOR0 )  
        
            {  
        
                cOutputVS lOutputVS;  
        
                lOutputVS.mPositionOut = mul( lPositionIn, gr4x4WorldViewProjection );  
        
                lOutputVS.mColourOut = float4( 1.0f, 1.0f, 1.0f, 1.0f); //lColourIn;  
        
                return lOutputVS;  
        
            }  
        
            technique EntryPoint  
        
            {  
        
                pass P0  
        
                {  
        
                    VertexShader = compile vs_3_0 MyVertexShaderVS();  
        
                }  
        
            }

main.cpp

    
            #include "stdafx.h"  
        
            #include <stdio.h> 
        
            #define VC_EXTRALEAN  
        
            #define WIN32_LEAN_AND_MEAN 
        
            #include <Windows.h>  
        
            #include <d3d9.h> 
        
            #include <d3dx9Effect.h>  
        
            #pragma comment ( lib, "d3d9.lib" ) 
        
            #pragma comment ( lib, "d3dx9.lib" )  
        
            #pragma comment ( lib, "d3dcompiler.lib" )  
        
            typedef unsigned int U32; 
        
            #include <d3d9.h>  
        
            #pragma warning( disable : 4996 ) // disable deprecated warning   
        
            #include <strsafe.h> 
        
            #pragma warning( default : 4996 )  
        
            //-----------------------------------------------------------------------------  
        
            // Global variables  
        
            //-----------------------------------------------------------------------------  
        
            IDirect3D9*         gpD3d = NULL; // Used to create the D3DDevice  
        
            IDirect3DDevice9*   gpD3dDevice = NULL; // Our rendering device  
        
            class cVertex  
        
            {  
        
            public:  
        
                float   mrX;  
        
                float   mrY;  
        
                float   mrZ;  
        
                float   mrRHW;  
        
                U32     muColour;  
        
            };  
        
            cVertex gaVertices[ 4 ] =   
        
            {  
        
                { 0.0f, 0.0f, 0.0f, 1.0f, 0xffff0000 },  
        
                { 100.0f, 0.0f, 0.0f, 1.0f, 0xff0000ff },  
        
                { 0.0f, 100.0f, 0.0f, 1.0f, 0xff00ff00 },  
        
                { 100.0f, 100.0f, 0.0f, 1.0f, 0xffffffff }  
        
            };  
        
            IDirect3DVertexBuffer9* gpVertexBuffer = NULL;  
        
            U32 guVertexFormat = D3DFVF_XYZRHW | D3DFVF_DIFFUSE;  
        
            U32 guVertexSoftwareOrHardwareProcessing = D3DCREATE_HARDWARE_VERTEXPROCESSING;  
        
            //U32 guVertexSoftwareOrHardwareProcessing = D3DCREATE_SOFTWARE_VERTEXPROCESSING;  
        
            ID3DXEffect*    gpEffect = NULL;  
        
            //-----------------------------------------------------------------------------  
        
            // Name: InitD3D()  
        
            // Desc: Initializes Direct3D  
        
            //-----------------------------------------------------------------------------  
        
            HRESULT InitD3D( HWND hWnd )  
        
            {  
        
                // Create the D3D object, which is needed to create the D3DDevice.  
        
                if( NULL == ( gpD3d = Direct3DCreate9( D3D_SDK_VERSION ) ) )  
        
                    return E_FAIL;  
        
                // Set up the structure used to create the D3DDevice. Most parameters are  
        
                // zeroed out. We set Windowed to TRUE, since we want to do D3D in a  
        
                // window, and then set the SwapEffect to "discard", which is the most  
        
                // efficient method of presenting the back buffer to the display.  And   
        
                // we request a back buffer format that matches the current desktop display   
        
                // format.  
        
                D3DPRESENT_PARAMETERS d3dpp;  
        
                ZeroMemory( &d3dpp, sizeof( d3dpp ) );  
        
                d3dpp.Windowed = TRUE;  
        
                d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;  
        
                d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;  
        
                // Create the Direct3D device. Here we are using the default adapter (most  
        
                // systems only have one, unless they have multiple graphics hardware cards  
        
                // installed) and requesting the HAL (which is saying we want the hardware  
        
                // device rather than a software one). Software vertex processing is   
        
                // specified since we know it will work on all cards. On cards that support   
        
                // hardware vertex processing, though, we would see a big performance gain   
        
                // by specifying hardware vertex processing.  
        
                if( FAILED( gpD3d->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,  
        
                                                  guVertexSoftwareOrHardwareProcessing,  
        
                                                  &d3dpp, &gpD3dDevice ) ) )  
        
                {  
        
                    return E_FAIL;  
        
                }  
        
                // Check device capabilities  
        
                // Device state would normally be set here  
        
                gpD3dDevice->SetFVF( guVertexFormat );   
        
                gpD3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );  
        
                // Set up vertex buffer  
        
                gpD3dDevice->CreateVertexBuffer(   
        
                    sizeof( gaVertices ),  
        
                    guVertexSoftwareOrHardwareProcessing,  
        
                    guVertexFormat,  
        
                    D3DPOOL_DEFAULT,   
        
                    &gpVertexBuffer,  
        
                    NULL );  
        
                void* lpVertexBufferData;  
        
                gpVertexBuffer->Lock( 0, sizeof( gaVertices ), &lpVertexBufferData, 0 );  
        
                memcpy( lpVertexBufferData, gaVertices, sizeof( gaVertices ) );  
        
                gpVertexBuffer->Unlock();  
        
                // Vertex Shader Effect  
        
                ID3DXBuffer*    lpCompilationErrorsBuffer;  
        
                HRESULT lResult = D3DXCreateEffectFromFileA(  
        
                    gpD3dDevice,  
        
                    "Shaders/SimpleHLSL.fx",  
        
                    NULL,  
        
                    NULL, 
        
            #ifndef _DEBUG  
        
                    D3DXSHADER_OPTIMIZATION_LEVEL3, 
        
            #else  
        
                    D3DXSHADER_DEBUG | D3DXSHADER_SKIPOPTIMIZATION, 
        
            #endif  
        
                    NULL,  
        
                    &gpEffect,  
        
                    &lpCompilationErrorsBuffer );  
        
                if ( lResult != S_OK )  
        
                {  
        
                    printf( "%s", lpCompilationErrorsBuffer->GetBufferPointer() );  
        
                    return E_FAIL;  
        
                }  
        
                D3DXMATRIX lWorld;  
        
                D3DXMATRIX lView;  
        
                D3DXMATRIX lProjection;  
        
                D3DXMATRIX lWorldViewProjection;  
        
                gpD3dDevice->GetTransform( D3DTS_WORLD, &lWorld );  
        
                gpD3dDevice->GetTransform( D3DTS_VIEW, &lView );  
        
                gpD3dDevice->GetTransform( D3DTS_PROJECTION, &lProjection );  
        
                D3DXMatrixMultiply( &lWorldViewProjection, &lWorld, &lView );  
        
                D3DXMatrixMultiply( &lWorldViewProjection, &lWorldViewProjection, &lProjection );  
        
                lResult = gpEffect->SetMatrix( "gr4x4WorldViewProjection", &lWorldViewProjection );  
        
                lResult = gpEffect->SetTechnique( "EntryPoint" );  
        
                return S_OK;  
        
            }  
        
            //-----------------------------------------------------------------------------  
        
            // Name: Cleanup()  
        
            // Desc: Releases all previously initialized objects  
        
            //-----------------------------------------------------------------------------  
        
            VOID Cleanup()  
        
            {  
        
                if ( gpEffect != NULL )  
        
                {  
        
                    gpEffect->Release();  
        
                }  
        
                if ( gpVertexBuffer != NULL )  
        
                {  
        
                    gpVertexBuffer->Release();  
        
                }  
        
                if( gpD3dDevice != NULL )  
        
                    gpD3dDevice->Release();  
        
                if( gpD3d != NULL )  
        
                    gpD3d->Release();  
        
            }  
        
            //-----------------------------------------------------------------------------  
        
            // Name: Render()  
        
            // Desc: Draws the scene  
        
            //-----------------------------------------------------------------------------  
        
            VOID Render()  
        
            {  
        
                HRESULT lResult;  
        
                if( NULL == gpD3dDevice )  
        
                    return;  
        
                // Clear the backbuffer to a blue color  
        
                gpD3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB( 0, 0, 255 ), 1.0f, 0 );  
        
                // Begin the scene  
        
                if( SUCCEEDED( gpD3dDevice->BeginScene() ) )  
        
                {  
        
                    U32 luNumPasses;  
        
                    lResult = gpEffect->Begin( &luNumPasses, 0 );  
        
                    for( U32 luPass = 0; luPass < luNumPasses; luPass++ )  
        
                    {  
        
                        lResult = gpEffect->BeginPass( luPass );  
        
                        // The effect interface queues up the changes and performs them   
        
                        // with the CommitChanges call. You do not need to call CommitChanges if   
        
                        // you are not setting any parameters between the BeginPass and EndPass.  
        
                        // V( g_pEffect->CommitChanges() );  
        
                        // Render the mesh with the applied technique  
        
                        gpD3dDevice->SetStreamSource( 0, gpVertexBuffer, 0, sizeof( cVertex ) );   
        
                        gpD3dDevice->DrawPrimitive(   
        
                            D3DPT_TRIANGLESTRIP, // D3DPRIMITIVETYPE PrimitiveType,  
        
                            0, // UINT StartVertex,  
        
                            2 ); // UINT PrimitiveCount  
        
                        lResult = gpEffect->EndPass();  
        
                    }  
        
                    gpEffect->End();  
        
                    // End the scene  
        
                    gpD3dDevice->EndScene();  
        
                }  
        
                // Present the backbuffer contents to the display  
        
                gpD3dDevice->Present( NULL, NULL, NULL, NULL );  
        
            }  
        
            //-----------------------------------------------------------------------------  
        
            // Name: MsgProc()  
        
            // Desc: The window's message handler  
        
            //-----------------------------------------------------------------------------  
        
            LRESULT WINAPI MsgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )  
        
            {  
        
                switch( msg )  
        
                {  
        
                    case WM_DESTROY:  
        
                        Cleanup();  
        
                        PostQuitMessage( 0 );  
        
                        return 0;  
        
                    case WM_PAINT:  
        
                        Render();  
        
                        ValidateRect( hWnd, NULL );  
        
                        return 0;  
        
                }  
        
                return DefWindowProc( hWnd, msg, wParam, lParam );  
        
            }  
        
            //-----------------------------------------------------------------------------  
        
            // Name: wWinMain()  
        
            // Desc: The application's entry point  
        
            //-----------------------------------------------------------------------------  
        
            INT WINAPI wWinMain( HINSTANCE hInst, HINSTANCE, LPWSTR, INT )  
        
            {  
        
                // Register the window class  
        
                WNDCLASSEX wc =  
        
                {  
        
                    sizeof( WNDCLASSEX ), CS_CLASSDC, MsgProc, 0L, 0L,  
        
                    GetModuleHandle( NULL ), NULL, NULL, NULL, NULL,  
        
                    L"D3D Vertex Shader Test", NULL  
        
                };  
        
                RegisterClassEx( &wc );  
        
                // Create the application's window  
        
                HWND hWnd = CreateWindow( L"D3D Vertex Shader Test", L"D3D Vertex Shader Test",  
        
                                          WS_OVERLAPPEDWINDOW, 100, 100, 300, 300,  
        
                                          NULL, NULL, wc.hInstance, NULL );  
        
                // Initialize Direct3D  
        
                if( SUCCEEDED( InitD3D( hWnd ) ) )  
        
                {  
        
                    // Show the window  
        
                    ShowWindow( hWnd, SW_SHOWDEFAULT );  
        
                    UpdateWindow( hWnd );  
        
                    // Enter the message loop  
        
                    MSG msg;  
        
                    while( GetMessage( &msg, NULL, 0, 0 ) )  
        
                    {  
        
                        TranslateMessage( &msg );  
        
                        DispatchMessage( &msg );  
        
                    }  
        
                }  
        
                UnregisterClass( L"D3D Vertex Shader Test", wc.hInstance );  
        
                return 0;  
        
            }

Orthographic projection

MarvinF — Tue, 10 Nov 2009 23:26:22 GMT

hi

I am trying to implement an orthographic projection using Direct3D9. My first approach was to use the following FVF:
D3DFVF_XYZRHW | D3DFVF_TEX1 | D3DFVF_TEXCOORDSIZE2(0)

Then I simply composed a triangle array, set it as stream source and rendered it. It worked.

But this way I couldn't transform the vertices. Neither translation, nor rotation, nor scale worked. So I thought, I had to use an FVF without RHW like this:
D3DFVF_XYZ | D3DFVF_TEX1 | D3DFVF_TEXCOORDSIZE2(0)

Then I set up the matrices like this:
    D3DXMATRIX proj;
    D3DXMatrixOrthoLH( &proj, 1920, 1200, -1.0f, 1.0f );
    device->SetTransform( D3DTS_PROJECTION, &proj );

    D3DXMATRIX id;
    D3DXMatrixIdentity( &id );
    device->SetTransform( D3DTS_WORLD, &id );
    device->SetTransform( D3DTS_VIEW, &id );

So, I used the identity transformation for now. The vertices have the exact same absolute screen coordinates like in the version with the RHW=1, where it worked, but without this RHW.

Using this code, not a single fracment is shown on the screen. What could be my mistake?

Thanks in advance,
Marvin

SpriteBatch can mess up GPU RAM?

Wotan42 — Tue, 10 Nov 2009 20:18:25 GMT

I have my terrain data in the GPU RAM using the VertexBuffer and IndexBuffer with option BufferUsage.WriteOnly. Drawing works without problems.

In order to get some debug text displayed (execution time of the draw method and the-like) I have the option to enable debugging by pressing F1. This enables that the debug text is displayed using a SpriteBatch at the end of the Draw method.

      protected override void Draw(GameTime gameTime)
      {
         GraphicsDevice.Clear(Color.CornflowerBlue);

         terrain.Draw();

         base.Draw(gameTime);

         if (debug) {
            debugSprite.Begin();
            debugSprite.End();
         }
      }

However as soon as I call the Begin() and End() methods of the SpriteBatch class (debug becomes true) my terrain gets modified, even if I do not draw any text.

This led me to the conclusion that the SpriteBatch messed up my terrain data in the GPU RAM. Being a novice I might be completely wrong, but I have no other explanation why my terrain gets altered as soon as I enable that debug text is displayed.

Layers in DirectX?

VijayKamat — Tue, 10 Nov 2009 13:13:36 GMT

Hello everyone,

I am relatively new to DirectX and I have a question.

Is it possible to have layers in DirectX?
I am working on a project where I am displaying data in a curve format (graph).

I render the whole grid in the background and the data curve onto it every time.

Is it possible that I form two layers, the background layer I draw the grid so I have only to draw data line every time unless I modify the axis.

I read somewhere that managing back buffer efficiently I could do something similar, that is send only the data to GPU and keep the grid in a texture.

Is there any better way to do this?

Thanks in advance :)

Pixel/Vertex Shader

adamroper — Fri, 06 Nov 2009 13:19:02 GMT

Hi,

I'm writing a bit of software for an image capturing system, which basically projects a series of patterns (usually hoz/vert stripes) on to a physical object, captures images of that object, and emalgamates those images to create a 3D model that is viewable in a CAD system. Typically the sequence involves projecting 50 patterns on to the object, with an image being captured for each projection. The time to make the projection and capture the image needs to be of the order of ~10ms.

This is all working well, however I now need to vary the intensity of the light according to results that are returned from the previous image, so if the image contains a light spot in one corner then I need to project less light to that area on the next projection. I was thinking that it would be best to leave the patterns (stripes) as they are, and apply a texture that basically contained solid white but had variable opacity, i.e. I decrease the alpha in the bright spots. In order to achieve this in the required time periods I want to pass off as much as I can to the GPU, and I was wondering whether you thought like this should be best achieved through a vertex shader, a pixel shader, or none of the above. The system is based on XP Embedded, so it's D3D9 or earlier for me.

As you can see the system is not exactly stretched as it is only displaying a single quad that is updated 50 times a second, but this system will have to scale up in future and I would like to keep it as fast as possible.

Opinions?

Thanks

C++ Message Loop in DLL

Stefano5 — Tue, 10 Nov 2009 10:31:39 GMT

Hi Guys,

Please excuse my ignorance again..

I'm developing a custom control for one of my collegues which consists of a basic DirectX scene. The DirectX part is written in native C++ and compiled as a DLL, I'm also producing a Visual Basic wrapper so that my collegues can use the control within their .NET application. The constructor passes the 'handle' of a custom 'control' to the C++ code which uses it to draw the DirectX stuff. I'd like to have a message loop in the DLL so that I can respond to mouse clicks and drags without having to rely on the Visual Basic wrapper to deal with them.

I've tried to make this sound as simple as possible but I'm having trouble understanding it myself.

Many thanks in advance,

Stefan :)

Rendertarget texture is dark on my Xbox

Fabian Viking — Fri, 06 Nov 2009 20:25:16 GMT

I have a mesh with a texture from a rendertarget. On my PC it works perfect, but on my xbox the texture gets darker the further away I pull the camera, until it's only a black surface.
I tried different shaders, but it doesn't change anything.
Im pretty sure it have something to do with the rendertarget, if I use a normally loaded texture there is no darkness.

XNA: Graphics card not supported

cable729 — Thu, 05 Nov 2009 04:20:59 GMT

Alright, so I haven't ever been able to run XNA games on my school computer (I do have special privileges and administrative rights, so I can install things if needed).

The graphics card is a Radeon X1300/1550 series, and I've tried updating the graphics card, but I've never done it before, and I'm not sure I did it right, because it still doesn't work.

I want to come here and ask for your help instead of try random stuff, because it's not my computer.

I don't understand what I need to do. DirectX is also 9.0c.

I run dxdiag and 3d acceleration is disabled.

Thanks in advance, I sincerely hope you can help me solve this!