• Create Account

cozzie

Member Since 13 Oct 2004
Offline Last Active Today, 03:10 AM

Topics I've Started

07 February 2016 - 05:24 AM

Hi all,

I'm trying to 'extrude' 4 sides of a cube, from a linestrip with 4 vertices.

After playing around I think I'm almost there, but I'm missing something crucial.

This is what I do:

- create 4 vertices (VTX buffer)

- draw them as a linestrip

- execute my Geometry Shader, taking line[2] as input and a trianglestream as output

The result so far is that 2 of the 4 sides of the extracted cube (without 'caps'/ top-bottom) are drawn correct.

It might be something with the normals, not sure.

Here's the code, can someone help me out?

```[maxvertexcount(4)]
void GSStrip(line VertexOut gin[2], inout TriangleStream<GeoOut> stream)
{
/* 4 vertices as input, 1 linestrip

1	.-----------.	2		0 = -1, 0, -1
|			|			1 = -1, 0,  1
|			|			2 =  1, 0,  1
|			|			3 =  1, 0, -1
0	.-----------.	3

create 4 new vertices 'above' 0 to 3 and draw sides of the cube using trianglestrips
the input linestrip is dimension[2] -> meaning the GS processes 'per line' / 2 connected vertices

2 .---------. 3
|			|		Y = up (2 and 3 are XZ == 0 and 1)
|			|
0 .---------. 1

Strip1: 2, 3, 0
Strip2: 3, 0, 1

*/
float4 v[4];
v[0] = float4(gin[0].CenterW, 1.0f);
v[1] = float4(gin[1].CenterW, 1.0f);

v[2] = v[0];
v[2].y = 15.0f;

v[3] = v[1];
v[3].y = 15.0f;

GeoOut gout;
[unroll]

for(int i = 0;i<4;++i)
{
gout.PosH     = mul(v[i], gViewProj);
gout.PosW     = v[i].xyz;
gout.NormalW  = float3(-1.0f, 0.0f, 0.0f);
gout.Tex      = gTexC[i];

stream.Append(gout);
}
//	stream.RestartStrip();
}

```
```// in the code, creating the vtx buffer
vertices[0].Pos = XMFLOAT3(-5.0, 0.0f, -5.0f);
vertices[1].Pos = XMFLOAT3(-5.0, 0.0f, 5.0f);
vertices[2].Pos = XMFLOAT3(5.0, 0.0f, 5.0f);
vertices[3].Pos = XMFLOAT3(5.0, 0.0f, -5.0f);

```

18 January 2016 - 03:48 PM

Hi all,

I've managed to get a geometry shader working, with a vertex as input, outputting a cube in a trianglestream

As a next step/ practice, I've tried to change my code/ approach to achieve the following (book exercise):

- input: linestrip of vertices

- output: a cylinder going upwards, from the viewpoint of the linestrip

(people who worked through Luna's d3d11 book might recognize the exercise)

I think I did what I should, but I don't get any visible results.

The vertices going into the vtx buffer look OK (debugged).

Any idea what I'm doing wrong?

```struct GeoOut
{
float4 PosH    : SV_POSITION;
float3 PosW    : POSITION;
float3 NormalW : NORMAL;
float2 Tex     : TEXCOORD;
};

// geometry shader for linestrip as input (cylinder, exercise 1)
[maxvertexcount(7)]
void GSStrip(line VertexOut gin[2], inout LineStream<GeoOut> stream)
{
float4 v[2];
float4 b[1];

v[0] = float4(gin[0].CenterW.xyz, 1.0f);
v[1] = float4(gin[1].CenterW.xyz, 1.0f);

const float StripWidth = 0.5f;

float2 dir = normalize(v[1].xy - v[0].xy);
float4 off = float4(-dir.y, dir.x, 0, 0);

GeoOut gout;

// only to prevent not completely initialized (UV's and normals not needed)
gout.Tex = float2(0.0f, 1.0f);
gout.NormalW = float3(1.0f, 0.0f, 0.0f);

// 2 vertices at a time to create 2 triangles out of the quad (between non existing top/ bottom caps)
gout.PosW	=    (v[0]-off*5).xyz;
gout.PosH	= mul(v[0]-off*5, gViewProj);
stream.Append(gout);

gout.PosW	=    (v[0]+off*5).xyz;
gout.PosH	= mul(v[0]+off*5, gViewProj);
stream.Append(gout);

gout.PosW	=    (v[1]-off*5).xyz;
gout.PosH	= mul(v[1]-off*5, gViewProj);
stream.Append(gout);

stream.RestartStrip();

gout.PosW	=    (v[0]-off*5).xyz;
gout.PosH	= mul(v[0]-off*5, gViewProj);
stream.Append(gout);

gout.PosW	=    (v[1]-off*5).xyz;
gout.PosH	= mul(v[1]-off*5, gViewProj);
stream.Append(gout);

stream.RestartStrip();

gout.PosW	=    (v[0]+off*5).xyz;
gout.PosH	= mul(v[0]+off*5, gViewProj);
stream.Append(gout);

gout.PosW	=    (v[1]+off*5).xyz;
gout.PosH	= mul(v[1]+off*5, gViewProj);
stream.Append(gout);
}

// the application code (relevant parts)

{
md3dImmediateContext->ClearRenderTargetView(mRenderTargetView, reinterpret_cast<const float*>(&Colors::Silver));
md3dImmediateContext->ClearDepthStencilView(mDepthStencilView, D3D11_CLEAR_DEPTH|D3D11_CLEAR_STENCIL, 1.0f, 0);

float blendFactor[] = {0.0f, 0.0f, 0.0f, 0.0f};

XMMATRIX viewProj = view*proj;

// draw cube and/or circle
//DrawCube(viewProj);
DrawCircle(viewProj);

HR(mSwapChain->Present(0, 0));
}

{
Effects::mTreeSpriteFX->SetDirLights(mDirLights);
Effects::mTreeSpriteFX->SetEyePosW(mEyePosW);
Effects::mTreeSpriteFX->SetFogColor(Colors::Silver);
Effects::mTreeSpriteFX->SetFogStart(15.0f);
Effects::mTreeSpriteFX->SetFogRange(175.0f);
Effects::mTreeSpriteFX->SetViewProj(viewProj);
Effects::mTreeSpriteFX->SetMaterial(mBoxMat);
Effects::mTreeSpriteFX->SetDiffuseMap( mCircleMapSRV);

md3dImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP);
md3dImmediateContext->IASetInputLayout(InputLayouts::mTreePointSprite);

UINT stride = sizeof(Vertex::TreePointSprite);
UINT offset = 0;

ID3DX11EffectTechnique* circleTech = Effects::mTreeSpriteFX->mLight3Tech;
switch(mRenderOptions)
{
case RenderOptions::Lighting:
circleTech = Effects::mTreeSpriteFX->mLight3Tech;
break;

case RenderOptions::Textures:
circleTech = Effects::mTreeSpriteFX->mLight3TexAlphaClipTech;
break;

case RenderOptions::TexturesAndFog:
circleTech = Effects::mTreeSpriteFX->mLight3TexAlphaClipFogTech;
break;
}

D3DX11_TECHNIQUE_DESC techDesc;
circleTech->GetDesc(&techDesc);
for(UINT p=0;p<techDesc.Passes;++p)
{
md3dImmediateContext->IASetVertexBuffers(0, 1, &mCircleVtxBuffer, &stride, &offset);

circleTech->GetPassByIndex(p)->Apply(0, md3dImmediateContext);
md3dImmediateContext->Draw(NUM_VERTS, 0);
}
}

{
const UINT numSlices = 32;

const UINT numCircleVerts = 33;
float dTheta = 2.0f * XM_PI/numSlices;

Vertex::TreePointSprite vertices[numCircleVerts];

for(UINT i=0;i<numCircleVerts;++i)
{
float x = 5*cosf(i*dTheta);
float z = 5*sinf(i*dTheta);

vertices[i].Pos    = XMFLOAT3(x, 0.0f, z);
}

D3D11_BUFFER_DESC vbd;
vbd.Usage = D3D11_USAGE_IMMUTABLE;
vbd.ByteWidth = sizeof(Vertex::TreePointSprite) * numCircleVerts;
vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
vbd.CPUAccessFlags = 0;
vbd.MiscFlags = 0;
D3D11_SUBRESOURCE_DATA vinitData;
vinitData.pSysMem = vertices;
HR(md3dDevice->CreateBuffer(&vbd, &vinitData, &mCircleVtxBuffer));
}
```

Vertex to cube using geometry shader

14 January 2016 - 11:20 AM

Hi all,
While playing around/ experimenting with geometry shaders, I tried to "expand" a point/ vertex (input) to rendering a cube (output). I managed to do this like this:

- create 14 vertices in the GS
- give them all their correct normals and own UV's
- output all vertices as one big triangle strip

Functionally this gives the aimed result.
Although I'm curious if there are better/ other to achieve this with a geometry shader, for example by using a triangle list (indices) or some other way.

Let me know what you think.

Masters of Doom

05 January 2016 - 02:13 PM

Hey guys,
I just wanted to share an experience I've had, and maybe trigger others to do also.
About one and a half week ago, I received a book I bought, called "Masters of Doom".
It tells the real story of the two Johns (Romero and Carmack).

What happened for me is that I got pulled into the book completely, I couldn't wait to find out what happened next, and next etc. (finished it yesterday).

Some things it brought and tought me:
- motiviation
- lessons learned, being stubborn can both bring a lot and take a lot
- they're a big fundation of what we now know as the FPS
- Doom still feels great although dated, I've just finished Doom 1 completely in before last difficulty. Next up is completely playing Doom2, Quake and Quake2 again

In short; a great book for inspiration and fun

what's wrong with screenshot showdown?

29 December 2015 - 10:58 AM

Hi guys,

I've been trying screenshot show down last 2 weeks, but it appears there's no (valid) data behind it.

Any idea what's wrong?

PARTNERS