'01_vertex_program.exe': caricato 'C:\Program Files\NVIDIA Corporation\Cg\examples\Direct3D9\basic\01_vertex_program\01_vertex_program.exe'
'01_vertex_program.exe': caricato 'C:\Windows\System32\ntdll.dll', Esportazioni caricate.
'01_vertex_program.exe': caricato 'C:\Windows\System32\kernel32.dll', Esportazioni caricate.
'01_vertex_program.exe': caricato 'C:\Program Files\Autodesk\Maya2008\bin\cg.dll', Esportazioni caricate.
'01_vertex_program.exe': caricato 'C:\Program Files\NVIDIA Corporation\Cg\bin\cgD3D9.dll', Esportazioni caricate.
Debugger:: durante il caricamento del processo è stata generata un'eccezione critica non gestita.
Il programma '[2952] 01_vertex_program.exe: Nativo' è terminato con il codice -1073741511 (0xc0000139).

Ogre::ConfigFile config;
String value;

config.load(filename);

Vector3 dimensions = Vector3::UNIT_SCALE;

value = config.getSetting( "PageWorldX" );

if ( ! value.empty() )
dimensions.x = atof( value.c_str() );

value = config.getSetting( "MaxHeight" );

if ( ! value.empty() )
dimensions.y = atof( value.c_str() );

value = config.getSetting( "PageWorldZ" );

if ( ! value.empty() )
dimensions.z = atof( value.c_str() );

float pageSize, tileSize;

value = config.getSetting( "PageSize" );

if ( ! value.empty() )
pageSize = atoi( value.c_str() );
else
LogManager::getSingleton().logMessage("Terrain says: Missing option \"PageSize\" in terrain config!");

value = config.getSetting( "TileSize" );

if ( ! value.empty() )
tileSize = atoi( value.c_str() );
else
LogManager::getSingleton().logMessage("Terrain says: Missing option \"TileSize\" in terrain config!");

dimensions.x /= pageSize - 1;
dimensions.z /= pageSize - 1;

String imageFilename = config.getSetting( "Heightmap.image" );

if (imageFilename.empty())
LogManager::getSingleton().logMessage("Terrain says: No image for heightField!"); else
LogManager::getSingleton().logMessage("Terrain says: Loading image: " + imageFilename);

// current variant of loading heightfield
Image image;

image.load(imageFilename, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);

size_t sizeX = image.getWidth();
size_t sizeZ = image.getHeight();

size_t numHeightfieldVerts = sizeX * sizeZ;
size_t numHeightfieldFaces = ( sizeX + 1 ) * ( sizeZ + 1 );

Real invScale;

PixelFormat pf = image.getFormat();

bool is16bit = (pf == Ogre::PF_L16);

if( pf != Ogre::PF_L8 && pf != Ogre::PF_L16 )
{
LogManager::getSingleton().logMessage("Terrain says: HeightMap image is not a grayscale one!");
}

LogManager::getSingleton().logMessage("Terrain says: My size is " + StringConverter::toString(sizeX) + "x" + StringConverter::toString(sizeZ));

if ( is16bit )
{
invScale = 1.0f / 65535.0f;
}
else
{
invScale = 1.0f / 255.0f;
}

uchar* pSrc = image.getData();

LogManager::getSingleton().logMessage("Terrain says: My heightmap size is " + StringConverter::toString(sizeof(pSrc)));

NxVec3* gTerrainVerts = new NxVec3[numHeightfieldVerts];
NxU32 y, numVerts = 0;

for(y = 0; y < sizeX; y++)
{
for(NxU32 x = 0; x < sizeX; x++)
{
//gTerrainVerts[x + (y * sizeZ)] = NxVec3(x, pSrc[x + (y * sizeX)] * invScale, y);
gTerrainVerts[numVerts++] = NxVec3(x, pSrc[numVerts] / (image.getBPP() * 2), y);
}
}

LogManager::getSingleton().logMessage("Terrain says: My Y-scale is " + StringConverter::toString(invScale));

// Initialize terrain faces
NxU32* gTerrainFaces = new NxU32[numHeightfieldFaces * 6];
NxU32 k = 0;

for(NxU32 j = 0; j < sizeX - 1; j++)
{
for(NxU32 i = 0; i < sizeX - 1; i++)
{
// Create first triangle
gTerrainFaces[k++] = i + j * sizeX;
gTerrainFaces[k++] = i + (j + 1) * sizeX;
gTerrainFaces[k++] = i + 1 + (j + 1) * sizeX;

// Create second triangle
gTerrainFaces[k++] = i + j * sizeX;
gTerrainFaces[k++] = i + 1 + (j + 1) * sizeX;
gTerrainFaces[k++] = i + 1 + j * sizeX;
}
}

// Build physical model
NxTriangleMeshDesc terrainDesc;
//terrainDesc.numVertices = numHeightfieldVerts;
terrainDesc.numVertices = numVerts - 1;
terrainDesc.numTriangles = numHeightfieldFaces;
terrainDesc.pointStrideBytes = sizeof(NxVec3);
terrainDesc.triangleStrideBytes = 3 * sizeof(NxU32);
terrainDesc.points = gTerrainVerts;
terrainDesc.triangles = gTerrainFaces;
terrainDesc.flags = 0;

terrainDesc.heightFieldVerticalAxis = NX_Y;
terrainDesc.heightFieldVerticalExtent = -1000.0f;

NxTriangleMeshShapeDesc terrainShapeDesc;

NxInitCooking();

MemoryWriteBuffer buf;
bool status = NxCookTriangleMesh(terrainDesc, buf);
NxTriangleMesh* triangleMesh = gPhysicsSDK->createTriangleMesh(MemoryReadBuffer(buf.data));

terrainShapeDesc.meshData = triangleMesh;

NxActorDesc actorDesc;
actorDesc.shapes.pushBack(&terrainShapeDesc);
actorDesc.body = NULL;
NxActor* newActor = gScene->createActor(actorDesc);

delete []gTerrainVerts;
delete []gTerrainFaces;

NxHeightFieldDesc heightFieldDesc;
heightFieldDesc.nbColumns = sizeX;
heightFieldDesc.nbRows = sizeZ;
heightFieldDesc.thickness = -1000;
heightFieldDesc.convexEdgeThreshold = 0;
heightFieldDesc.samples = new NxU32[sizeX * sizeZ];
heightFieldDesc.sampleStride = sizeof(NxU32);

NxU8* currentByte = (NxU8*) heightFieldDesc.samples;

for (NxU32 row = 0; row < sizeX; row++)
{
for (NxU32 column = 0; column < sizeZ; column++)
{
NxHeightFieldSample* currentSample = (NxHeightFieldSample*) currentByte;

//currentSample->height = 0;
currentSample->height = pSrc[(row * sizeZ) + column] / 16;

currentSample->materialIndex0 = 1;
currentSample->materialIndex1 = 1;
currentSample->tessFlag = 0;

currentByte += heightFieldDesc.sampleStride;
}
}

NxHeightField* heightField = gPhysicsSDK()->createHeightField(heightFieldDesc);

delete[] heightFieldDesc.samples;

NxHeightFieldShapeDesc heightFieldShapeDesc;
heightFieldShapeDesc.heightField = heightField;
heightFieldShapeDesc.heightScale = 1;
heightFieldShapeDesc.rowScale = dimensions.x / sizeX; // tileSize
heightFieldShapeDesc.columnScale = dimensions.z / sizeZ; // tileSize
heightFieldShapeDesc.materialIndexHighBits = 0;
heightFieldShapeDesc.skinWidth = 0.001f;

// Create body of the box
    NxBodyDesc bodyDesc;
    bodyDesc.angularDamping    = 0.5f;

    //make the box shape
    NxBoxShapeDesc boxShapeDesc;
    boxShapeDesc.mass=3;

            NxActorDesc actorDesc;
    actorDesc.shapes.pushBack(&boxShapeDesc);
    actorDesc.body            = &bodyDesc;
    actorDesc.density        = 10.0f;
    NxActor* boxActor=gScene->createActor(actorDesc);

NxPlaneShapeDesc planeDesc;
// plane equation : ax + by + cz + d = 0
planeDesc.normal = NxVec3 ( 0, 0, 1 );
planeDesc.d = 0.0f;
// actor descriptor with collection of shapes
NxActorDesc pactorDesc;
pactorDesc.shapes.pushBack( &planeDesc );
// NxScene creates actor and returns a pointer.
NxActor* pActor = gScene->createActor( pactorDesc );
pActor->userData = NULL;

cubepos=boxActor->getGlobalPosition();
        cout<<cubepos.y <<endl;
        gScene->setTiming(myTimestep / 4.0f, 4, NX_TIMESTEP_FIXED);

        gScene->simulate(myTimestep); //perform 4 substeps to advance simulation by 1/60th of a second.
        gScene->flushStream();        //...perform useful work here using previous frame's state data        
        gScene->fetchResults(NX_RIGID_BODY_FINISHED, true);

efd::Point3 shape;
m_pOwningEntity->GetPropertyValue("KyDimensions", shape);
NxRay ray(NxVec3(currentPosition.x, currentPosition.y, currentPosition.z+shape.z),  // origin
          NxVec3(0.0, 0.0, -1.0));  // direction
NxRaycastHit hit;
NxShape* closestShape = pkScene->raycastClosestShape(ray, NX_STATIC_SHAPES, hit);

// If close to the surface, snap Z position to the ground
NxShape *closestShape = pkScene->raycastClosestShape(ray, NX_STATIC_SHAPES, hit, 0xffffffff, maxDist, 0xffffffff, NULL, NULL);
if (closestShape)
{
    newPosition.z = hit.worldImpact.z + 0.002f;
}

// Cast ray towards ground and find closest static object it intersects.
//
// NOTE: On the XBox 360, passing maxDist does not work (NULL result always).
//       Workaround is to raycast to infinity and check hit info after return. -- DCNefd::Point3 shape;
efd::Point3 shape;
m_pOwningEntity->GetPropertyValue("KyDimensions", shape);
NxRay ray(NxVec3(currentPosition.x, currentPosition.y, currentPosition.z+shape.z),  // origin
          NxVec3(0.0, 0.0, -1.0));  // direction
NxRaycastHit hit;
NxShape* closestShape = pkScene->raycastClosestShape(ray, NX_STATIC_SHAPES, hit);

// If close to the surface, snap Z position to the ground
NxReal hitDist = fabs(ray.orig.z - hit.worldImpact.z);
NxReal maxDist = (NxReal)(shape.z + 3.5f);  // surface must be within 3.5 meters from character
if (closestShape  &&  hitDist < maxDist)
{
    newPosition.z = hit.worldImpact.z + 0.002f;
}

- System

- Provider

[ Name] Microsoft-Windows-ApplicationExperienceInfrastructure
[ Guid] {5EC13D8E-4B3F-422E-A7E7-3121A1D90C7A}

EventID 1

Version 0

Level 3

Task 0

Opcode 2

Keywords 0x8000000000000000

- TimeCreated

[ SystemTime] 2009-11-06T18:46:49.151367100Z

EventRecordID 3581

Correlation

- Execution

[ ProcessID] 1608
[ ThreadID] 2180

Channel Application

Computer

- Security

[ UserID] S-1-5-21-1057919540-1362870897-3904713084-1000


- EventData

DBType 15
AppNameCount 62
AppName nVidia Display drivers/nView Desktop Manager (NVIDIA Drivers)
VendorNameCount 7
VendorName NVidia
SummaryCount 171
Summary Программа nVidia Display drivers/nView Desktop Manager (NVIDIA Drivers) несовместима с данной версией Windows. Для получения дополнительных сведений обращайтесь к NVidia.

    // Create body
    NxBodyDesc bodyDesc;
    bodyDesc.mass = 1; // i have to remove it otherwise we get acces violation a->doSomething because createActor returns 0
    bodyDesc.angularDamping    = 0.5f;
    if(initialVelocity)
        bodyDesc.linearVelocity = *initialVelocity;

    NxBoxShapeDesc boxDesc;
    boxDesc.group = GROUP_COLLIDABLE_PUSHABLE;
    boxDesc.dimensions = NxVec3((float)size, (float)size, (float)size);
    NxActorDesc actorDesc;
    actorDesc.shapes.pushBack(&boxDesc);
    actorDesc.body            = &bodyDesc;
    actorDesc.density        = 10.0f;
    actorDesc.globalPose.t  = pos;
    NxActor *a = gScene->createActor(actorDesc);
        a->doSomething /// acces violation, a == 0 !

struct fragment
{
float4 position : POSITION;
float4 colour : COLOR0;
float2 texcoord0 : TEXCOORD0;
float pointSize : PSIZE;
};


fragment main(float3 pInitial : POSITION,
float3 vInitial : TEXCOORD0,
float tInitial : TEXCOORD1,
uniform float globalTime,
uniform float particleSize,
uniform float4x4 modelViewProj)
{
fragment OUT;
float t = globalTime - tInitial;
float4 final = float4(pInitial, 1) + (float4(vInitial, 0) + float4(0, (-4.9f), 0, 0) * t * t;
OUT.position = mul(modelViewProj, final);
OUT.texcoord0 = OUT.position; // store the position for the pixel shader
OUT.pointSize = particleSize;
return OUT;
}

struct fragment
{
float4 position : POSITION;
float4 colour0 : COLOR0;
float2 texcoord0 : TEXCOORD0;
};

struct pixel
{
float4 colour : COLOR;
};



pixel main( fragment IN,
uniform sampler2D inputTexture,
uniform float brightness,
uniform float contrast,
uniform float gamma)
{
pixel OUT;
OUT.colour = tex2D(inputTexture, IN.texcoord0);
return OUT;
}

    NxPlaneShapeDesc planeDesc;    
    planeDesc.group = GROUP_COLLIDABLE_NON_PUSHABLE;
    NxActorDesc actorDesc;
    actorDesc.shapes.pushBack(&planeDesc);
    ac = gScene->createActor(actorDesc);

void RenderCallback()
{
if(MonitorSetRequest3DUpdate)
{
MonitorSetRequest3DUpdate=false;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
ProcessCameraKeys();
SetupCamera();
if (gScene && !bPause)
{
GetPhysicsResults();
ProcessInputs();
StartPhysics();
}
// Display scene
RenderActors(bShadows);
RenderFluid();
//RenderFluid();
if (bForceMode)
DrawForce(gSelectedActor, gForceVec, NxVec3(1,1,0));
else
DrawForce(gSelectedActor, gForceVec, NxVec3(0,1,1));
gForceVec = NxVec3(0,0,0);
glFlush();
glutSwapBuffers();
updateJoints();
}
}

void LoadModel()
    {
        NXU::NxuPhysicsCollection *c = NXU::loadCollection("mymodel.nxb", NXU::FT_BINARY );

        if ( c )
        {
          
                NXU::instantiateCollection( c, *gPhysicsSDK, gScene, 0, 0 );
          
            NXU::releaseCollection(c);
        }
    }

1>------ Build started: Project: Lesson101_Primary_Shape, Configuration: Debug Win32 ------
1>Linking...
1>Lesson101.obj : error LNK2019: unresolved external symbol "void __cdecl NXU::releaseCollection(class NXU::NxuPhysicsCollection *)" (?releaseCollection@NXU@@YAXPAVNxuPhysicsCollection@1@@Z) referenced in function "void __cdecl LoadLand(void)" (?LoadLand@@YAXXZ)
1>Lesson101.obj : error LNK2019: unresolved external symbol "bool __cdecl NXU::instantiateCollection(class NXU::NxuPhysicsCollection *,class NxPhysicsSDK &,class NxScene *,class NxMat34 const *,class NXU_userNotify *)" (?instantiateCollection@NXU@@YA_NPAVNxuPhysicsCollection@1@AAVNxPhysicsSDK@@PAVNxS
cene@@PBVNxMat34@@PAVNXU_userNotify@@@Z) referenced in function "void __cdecl LoadLand(void)" (?LoadLand@@YAXXZ)
1>Lesson101.obj : error LNK2019: unresolved external symbol "class NXU::NxuPhysicsCollection * __cdecl NXU::loadCollection(char const *,enum NXU::NXU_FileType,void *,int)" (?loadCollection@NXU@@YAPAVNxuPhysicsCollection@1@PBDW4NXU_FileType@1@PAXH@Z) referenced in function "void __cdecl LoadLand(void)" (?LoadLand@@YAXXZ)
1>../../../../../bin/Win32/Lesson101_Primary_Shape_DEBUG.exe : fatal error LNK1120: 3 unresolved externals
1>Build log was saved at "file://c:\NVIDIA PhysX SDKv2.8.1\TrainingPrograms\Programs\Chapter1_Rigid_Bodies\compiler\vc8win32\build\Win32\Lesson101_Primary_Shape\Debug\BuildLog.htm"
1>Lesson101_Primary_Shape - 4 error(s), 0 warning(s)
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

struct Light
{
float4 Color;
float4 Position;
...
};
uniform Light lights[256];

technique Main
{
pass MakeShadow
{
VertexProgram = compile vp40 shadVS( gWorldITXf, gWorldXf, gViewIXf, gWvpXf,
gLampViewXf, mul(gLampProjXf, gLampViewXf), gNearClip, gClipSize );
DepthTestEnable = true;
DepthMask = true;
CullFaceEnable = false;
BlendEnable = false;
DepthFunc = LEqual;
FragmentProgram = compile arbfp1 shadPS();
}
pass DrawShadow
{
VertexProgram = compile arbvp1 drawShadVS(gWvpXf);
DepthTestEnable = true;
DepthMask = true;
CullFaceEnable = false;
BlendEnable = false;
DepthFunc = LEqual;
FragmentProgram = compile arbfp1 drawShadPS( gShadSampler );
}
. . .
}

void vs(
  float4 pos : POSITION,
  out float4 output : POSITION,
  uniform float a,
  uniform float b)
{
  output = a * b * pos;
}

void fs(
  out float4 color : COLOR,
  uniform float a,
  uniform float _b)
{
  color = a * _b;
}

uniform float _a1;
uniform float _b1;

// main procedure, the original name was vs
void main()
{
    vec4 _output;
    _output = (_a1*_b1)*gl_Vertex;
    gl_Position = _output;
} // main end

uniform float _a1;
uniform float _b1;

// main procedure, the original name was fs
void main()
{
    vec4 _color;
    _color = vec4(_a1*_b1, _a1*_b1, _a1*_b1, _a1*_b1);
    gl_FragColor = _color;
} // main end

/*************************************
*
* Fragment Shader
* ---------------
*
**************************************/

void main(in float4 iColour : COLOR,
in float3 iVertex : TEXCOORD0, // Fine
in float3 iNormal : TEXCOORD1, // Fine
in float2 iXZCoords : TEXCOORD2, // Fine
in float2 iXYCoords : TEXCOORD3, // No!
in float2 iZYCoords : TEXCOORD4, // No!

in uniform sampler2D iTexXZ : TEX0,

out float4 oColour : COLOR)
{
float2 xzPlaneCoords = iXZCoords;
float2 xyPlaneCoords = iXYCoords;
float2 zyPlaneCoords = iZYCoords;

// Nothing... or with the other 2 coords
float4 diffuse = tex2D(iTexXZ, xyPlaneCoords);

oColour = diffuse;

}

/*************************************
*
* Fragment Shader
* ---------------
*
**************************************/

void main(in float4 iFragColour : COLOR0,
in float2 iTexCoord : TEXCOORD0,
in float4 iSplatWeight1to4 : TEXCOORD1,
in float4 iSplatWeight5to7 : TEXCOORD2,
in float3 iFragPosition : TEXCOORD3, // Frag position interpolated from vertex position

in uniform sampler2D iTexBase : TEX0,
in uniform sampler2D iTexGrass : TEX1,
in uniform sampler2D iTexRock : TEX2,
in uniform sampler2D iTexSand : TEX3,
in uniform sampler2D iTexWater : TEX4,
in uniform sampler2D iTexDetail1 : TEX5, // Detail textures 1-4 (ground, grass, rock, sand)
in uniform sampler2D iTexDetail2 : TEX6, // Detail textures 5-8 (water)

in uniform bool useSplat, // Toggle hi res textures on/off
in uniform bool useDetail, // Toggle hi res textures on/off
in uniform bool useColour, // Toggle vertex colours on/off
in uniform bool useFog, // Toggle fog on/off

in uniform float maxDist, // Max distance at which the detail splats will be blended over the low re splats
in uniform float medDist, // Distance at which the blending o hi res splats rapidly falls off for smooth transition

in uniform float4 iFogColour : state.fog.color,
in uniform float4 iFogParams : state.fog.params,

out float4 oColour : COLOR)
{
float4 base;
float4 grass;
float4 rock;
float4 sand;
float4 water;
float4 detail1;
float4 detail2;

float4 finalBase;
float4 finalGrass;
float4 finalRock;
float4 finalSand;
float4 finalWater;

base = tex2D(iTexBase, iTexCoord);
grass = tex2D(iTexGrass, iTexCoord);
rock = tex2D(iTexRock, iTexCoord);
sand = tex2D(iTexSand, iTexCoord);
water = tex2D(iTexWater, iTexCoord);
detail1 = tex2D(iTexDetail1, iTexCoord);
detail2 = tex2D(iTexDetail2, iTexCoord);

// Cam is at origin as vert/frag pos is in projected world space
float3 CamPos = float3(0.0,0.0,0.0);

// Cut-off distance for the high res detail texture
//float maxDist = 50.0;

// Calculate the frag's distance from the viewer
float fragDist = distance(CamPos, iFragPosition);

// Are we close enough to use the hi-res texture?
if(true == useDetail && fragDist < maxDist)
{
// Amount of hi-res detail texture blended onto grass texture
float hiresAmount;

// Max distance = 15. Therefore, any frags within 0 to 15 units is hi-res. However, in order to stop the
// hi-res texture "popping" into place, we will blend the hi res amount over the last 2 thirds of the distance
// range. The further away the frag, the less hi res detail blended in. This gives us a smooth transition
// as we zoom in and out, making the hi-res "popping" non-existent
if(fragDist > medDist)
{
hiresAmount = 0.35 * (((maxDist - fragDist) / maxDist) + 0.5);
}
else
{
hiresAmount = 0.35;
}

// Yes. Add the high-detail texture in the 2nd texture unit to the base texture from the appropriate colour channel
finalBase = ((1 - hiresAmount) * base) + (hiresAmount * detail1.r);
finalGrass = ((1 - hiresAmount) * grass) + (hiresAmount * detail1.g);
finalRock = ((1 - hiresAmount) * rock) + (hiresAmount * detail1.;
finalSand = ((1 - hiresAmount) * sand) + (hiresAmount * detail1.a);
finalWater = ((1 - hiresAmount) * water) + (hiresAmount * detail2.r);
}
else
{
// No. Only use the lo res textures
finalBase = base;
finalGrass = grass;
finalRock = rock;
finalSand = sand;
finalWater = water;
}

float4 result = lerp(finalBase, finalGrass, iSplatWeight1to4.x);
oColour = lerp(result, finalRock, iSplatWeight1to4.y);
result = lerp(oColour,finalSand, iSplatWeight1to4.z);
oColour = lerp(result, finalWater, iSplatWeight1to4.w);

if(true == useSplat)
{
if(true == useColour)
{
oColour *= iFragColour;
}
}
else
{
oColour = iFragColour;
}

// Linear fog equation
if(true == useFog)
{
// iFogParams.y = fog start
// iFogParams.z = fog end
float fogFactor = (iFogParams.z - iFragPosition.z) / (iFogParams.z - iFogParams.y);

fogFactor = clamp(fogFactor, 0.0, 1.0);

float4 texColour = oColour;

// Blend fog in with coloured & lit splat fragment
oColour = lerp(iFogColour, texColour, fogFactor);
}
}

/ Vert shader
cgGLEnableProfile(CG_PROFILE_ARBVP1);
cgGLBindProgram(vertProgram);

// Frag shader
cgGLEnableProfile(CG_PROFILE_ARBFP1);
cgGLBindProgram(fragProgram);

m3dMesh.Draw();


// Disable shaders
cgGLDisableProfile(CG_PROFILE_ARBFP1);
cgGLDisableProfile(CG_PROFILE_ARBVP1);

bool SGLMesh3d::Draw()
{
if(!meshVertData || !meshIndexData) return false;

// Filled rendering
glEnableVertexAttribArrayARB( 0 );
glEnableVertexAttribArrayARB( 1 );
glEnableVertexAttribArrayARB( 2 );
glEnableVertexAttribArrayARB( 3 );
glEnableVertexAttribArrayARB( 4 );
glEnableVertexAttribArrayARB( 5 );
glEnableVertexAttribArrayARB( 6 );
glEnableVertexAttribArrayARB( 7 );

glVertexAttribPointerARB(0, 3, GL_FLOAT, GL_FALSE, sizeof(SMeshVertex), &meshVertData->xyzPos.x ); // x,y,z
glVertexAttribPointerARB(1, 3, GL_FLOAT, GL_FALSE, sizeof(SMeshVertex), &meshVertData->xyzTangent.x ); // tx,ty,tz
glVertexAttribPointerARB(2, 3, GL_FLOAT, GL_FALSE, sizeof(SMeshVertex), &meshVertData->xyzBiNormal.x ); // bnx,bny,bnz
glVertexAttribPointerARB(3, 3, GL_FLOAT, GL_FALSE, sizeof(SMeshVertex), &meshVertData->xyzNormal.x ); // nx,ny,nz
glVertexAttribPointerARB(4, 4, GL_FLOAT, GL_FALSE, sizeof(SMeshVertex), &meshVertData->rgbaColour.r); // r,g,b,a
glVertexAttribPointerARB(5, 2, GL_FLOAT, GL_FALSE, sizeof(SMeshVertex), &meshVertData->texCoord0.u ); // texU0, texV0
glVertexAttribPointerARB(6, 2, GL_FLOAT, GL_FALSE, sizeof(SMeshVertex), &meshVertData->texCoord1.u ); // texU1, texV1
glVertexAttribPointerARB(7, 4, GL_FLOAT, GL_FALSE, sizeof(SMeshVertex), &meshVertData->customData ); // custom data

glDrawElements(GL_TRIANGLES, numIndices, GL_UNSIGNED_INT, meshIndexData);
glPopMatrix();

glDisableVertexAttribArrayARB( 0 );
glDisableVertexAttribArrayARB( 1 );
glDisableVertexAttribArrayARB( 2 );
glDisableVertexAttribArrayARB( 3 );
glDisableVertexAttribArrayARB( 4 );
glDisableVertexAttribArrayARB( 5 );
glDisableVertexAttribArrayARB( 6 );
glDisableVertexAttribArrayARB( 7 );

return true;
}

/*************************************
*
* Vertex Shader
* -------------
*
**************************************/

void main(in float4 iPosition : ATTR0,
in float4 iTangent : ATTR1,
in float4 iBiNormal : ATTR2,
in float4 iNormal : ATTR3,
in float4 iColour : ATTR4,
in float2 iTexCoord0 : ATTR5,
in float2 iTexCoord1 : ATTR6,
in float4 iCustomData : ATTR7,

out float4 oPosition : POSITION,
out float4 oColour : COLOR,
out float4 t0 : TEXCOORD0,
out float4 t1 : TEXCOORD1,
out float4 t2 : TEXCOORD2,

uniform float4x4 ModelViewProj : state.matrix.mvp)
{
oPosition = mul(ModelViewProj, iPosition);

t0 = float4(1,0,0,1);
t1 = float4(0,1,0,1);
t2 = float4(0,0,1,1);

oColour = iColour;

}

/*************************************
*
* Fragment Shader
* ---------------
*
**************************************/

void main(in float4 iColour : COLOR,
in float4 t0 : TEXCOORD0,
in float4 t1 : TEXCOORD1,
in float4 t2 : TEXCOORD2,
out float4 oColour : COLOR)
{

oColour = t0;

}

// Load shaders, as before...

...

glBegin(GL_TRIANGLES);

glColor3f(1.0f,1.0f,1.0f);

for(UInt32 ctr = 0; ctr < m3dMesh.numIndices; ctr++)
{
glVertex3fv(&m3dMesh.meshVertData[m3dMesh.meshIndexData[ctr]].xyzPos.x);
}

glEnd();

// Unload shaders, as before...

/*************************************
*
* Vertex Shader
* -------------
*
**************************************/

void main(
in float4 iPosition : POSITION,
in float4 iColour : COLOR,

out float4 oPosition : POSITION, // Translated and projected vertex position
out float4 oColour : COLOR,
out float4 t0 : TEXCOORD0,
out float4 t1 : TEXCOORD1,
out float4 t2 : TEXCOORD2,

uniform float4x4 ModelViewProj : state.matrix.mvp) // ModelViewPorojection matrix
{
// Translate and project the vertex
oPosition = mul(ModelViewProj, iPosition);

t0 = float4(1,0,0,1);
t1 = float4(0,1,0,1);
t2 = float4(0,0,1,1);

oColour = iColour;
}

/*************************************
*
* Fragment Shader
* ---------------
*
**************************************/

void main(in float4 iColour : COLOR,
in float4 t0 : TEXCOORD0,
in float4 t1 : TEXCOORD1,
in float4 t2 : TEXCOORD2,
out float4 oColour : COLOR)
{
// output is white... should be blue?
oColour = t2;

}

// the shader is bound at this point via cgSetPassState
// CGparameter param = a sampler parameter supplied from elsewhere
// GLuint glTextureA & glTextureB are textures supplied from elsewhere
cgGLSetTextureParameter( param, glTextureA );
cgGLEnableTextureParameter( param );

glBegin( GL_QUADS );
glTexCoord2f( 0, 0 );
glVertex3f( 0, 0, 0 );
glTexCoord2f( 0, 1 );
glVertex3f( 0, 1, 0 );
glTexCoord2f( 1, 1 );
glVertex3f( 1, 1, 0 );
glTexCoord2f( 1, 0 );
glVertex3f( 1, 0, 0 );
glEnd();

cgGLSetTextureParameter( param, glTextureB );
cgGLEnableTextureParameter( param );

glBegin( GL_QUADS );
glTexCoord2f( 0, 0 );
glVertex3f( 1, 0, 0 );
glTexCoord2f( 0, 1 );
glVertex3f( 1, 1, 0 );
glTexCoord2f( 1, 1 );
glVertex3f( 2, 1, 0 );
glTexCoord2f( 1, 0 );
glVertex3f( 2, 0, 0 );
glEnd();

NxVec3 center;
NxVec3 extents;
NxBounds3 bounds;

center.x = point.x;
center.y = point.y;
center.z = point.z;
extents.x = 1;
extents.y = 1;
extents.z = 1;

bounds.setCenterExtents(center, extents);

NxU32 numberTetras;
NxU32 const**indices;
indices = (NxU32 const**) new NxU32[maxIndices];

pSoftBody->->overlapAABBTetrahedra(bounds, numberTetras, *indices);

//Overlapping is 3, should be 1

bounds.setCenterExtents(center, extents);
bounds.scale(0.000001);

NxU32 numberTetras;
NxU32 const**indices;
indices = (NxU32 const**) new NxU32[maxIndices];

pSoftBody->->overlapAABBTetrahedra(bounds, numberTetras, *indices);

//Overlapping still 3, should be 1 or 0!

void DrawModelUsingProgrammablePipeline()
{
    const ModelOBJ::Mesh *pMesh = 0;
    const ModelOBJ::Material *pMaterial = 0;
    const ModelOBJ::Vertex *pVertices = 0;
    ModelTextures::const_iterator iter;
    GLuint texture = 0;

    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    for (int i = 0; i < g_model.getNumberOfMeshes(); ++i)
    {
        pMesh = &g_model.getMesh(i);
        pMaterial = pMesh->pMaterial;
        pVertices = g_model.getVertexBuffer();

        glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, pMaterial->ambient);
        glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, pMaterial->diffuse);
        glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, pMaterial->specular);
        glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, pMaterial->shininess * 128.0f);

        if (pMaterial->bumpMapFilename.empty())
        {
          // Per fragment Blinn-Phong code path.

            glUseProgram(g_blinnPhongShader);
            glAttachShader(g_blinnPhongShader,cgVertexProfile);

             Bind the color map texture.

            texture = g_nullTexture;

            if (g_enableTextures)
            {
                iter = g_modelTextures.find(pMaterial->colorMapFilename);

                if (iter != g_modelTextures.end())
                    texture = iter->second;
            }

            glActiveTexture(GL_TEXTURE0);
            glEnable(GL_TEXTURE_2D);
            glBindTexture(GL_TEXTURE_2D, texture);

            // Update shader parameters.

            glUniform1i(glGetUniformLocation(
                g_blinnPhongShader, "colorMap"), 0);
            glUniform1f(glGetUniformLocation(
                g_blinnPhongShader, "materialAlpha"), pMaterial->alpha);
        }
        else
        {
            // Normal mapping code path.

            glUseProgram(g_normalMappingShader);

            // Bind the normal map texture.

            iter = g_modelTextures.find(pMaterial->bumpMapFilename);

            if (iter != g_modelTextures.end())
            {
                glActiveTexture(GL_TEXTURE1);
                glEnable(GL_TEXTURE_2D);
                glBindTexture(GL_TEXTURE_2D, iter->second);
            }

            // Bind the color map texture.

            texture = g_nullTexture;

            if (g_enableTextures)
            {
                iter = g_modelTextures.find(pMaterial->colorMapFilename);

                if (iter != g_modelTextures.end())
                    texture = iter->second;
            }

            glActiveTexture(GL_TEXTURE0);
            glEnable(GL_TEXTURE_2D);
            glBindTexture(GL_TEXTURE_2D, texture);

            // Update shader parameters.

            glUniform1i(glGetUniformLocation(
                g_normalMappingShader, "colorMap"), 0);
            glUniform1i(glGetUniformLocation(
                g_normalMappingShader, "normalMap"), 1);
            glUniform1f(glGetUniformLocation(
                g_normalMappingShader, "materialAlpha"), pMaterial->alpha);
        }        

        // Render mesh.

        if (g_model.hasPositions())
        {
            glEnableClientState(GL_VERTEX_ARRAY);
            glVertexPointer(3, GL_FLOAT, g_model.getVertexSize(),
                g_model.getVertexBuffer()->position);
        }

        if (g_model.hasTextureCoords())
        {
            glClientActiveTexture(GL_TEXTURE0);
            glEnableClientState(GL_TEXTURE_COORD_ARRAY);
            glTexCoordPointer(2, GL_FLOAT, g_model.getVertexSize(),
                g_model.getVertexBuffer()->texCoord);
        }

        if (g_model.hasNormals())
        {
            glEnableClientState(GL_NORMAL_ARRAY);
            glNormalPointer(GL_FLOAT, g_model.getVertexSize(),
               g_model.getVertexBuffer()->normal);
        }

        if (g_model.hasTangents())
        {
            glClientActiveTexture(GL_TEXTURE1);
            glEnableClientState(GL_TEXTURE_COORD_ARRAY);
            glTexCoordPointer(4, GL_FLOAT, g_model.getVertexSize(),
                g_model.getVertexBuffer()->tangent);
        }

        
        glDrawElements(GL_TRIANGLES, pMesh->triangleCount * 3, GL_UNSIGNED_INT,
            g_model.getIndexBuffer() + pMesh->startIndex);

        if (g_model.hasTangents())
        {
            glClientActiveTexture(GL_TEXTURE1);
            glDisableClientState(GL_TEXTURE_COORD_ARRAY);
        }

        if (g_model.hasNormals())
            glDisableClientState(GL_NORMAL_ARRAY);

        if (g_model.hasTextureCoords())
        {
            glClientActiveTexture(GL_TEXTURE0);
            glDisableClientState(GL_TEXTURE_COORD_ARRAY);
        }

        if (g_model.hasPositions())
            glDisableClientState(GL_VERTEX_ARRAY);
    }

    glBindTexture(GL_TEXTURE_2D, 0);
    glUseProgram(0);
    glDisable(GL_BLEND);
}

if (a<5) b=0;

b = (a<5)?0:b;

struct VertOut{
float4 Position: POSITION;
float4 Color: COLOR;
float4 ShadowTexCoord: TEXCOORD0;

};
uniform float4x4 WorldViewProj;
uniform float4x4 WorldView;
uniform float4x4 TextureMatrix;
uniform float4x4 ModelViewIT;
uniform float4 GlobalAmbient;
uniform float4 Ma, Md;
uniform float4 LightPos;
uniform float4 La,Ld;



VertOut mainVS(float4 pos : POSITION,/* float2 TC:TEXCOORD1,*/
float4 Color:COLOR,
float4 Normal: NORMAL){
VertOut vo;
vo.Position = mul(WorldViewProj, pos);


vo.ShadowTexCoord = mul(TextureMatrix,pos);
pos.z += .5f;

vo.ShadowTexCoord *= 1.0f/vo.ShadowTexCoord.w;
float4 EyeVertex = mul(WorldView, pos);
float4 LightDir = normalize(LightPos - pos);
float Cosine = max(dot(mul(ModelViewIT,Normal),LightDir),0);
vo.Color = (GlobalAmbient + Ld) * Ma + Md * Ld * Cosine;

return vo;
}

uniform sampler2D ShadowMap;
const float Resolution = 1.0f / 512.0f;
#define SHADOW_COMPARISON 0.04

float ShadowStep(float2 TexCoords, float FragmentDepth)
{
float Result = 0;
float Depth = tex2D(ShadowMap, TexCoords).r;

return (FragmentDepth < Depth + SHADOW_COMPARISON);
}
float4 mainPS(float4 ShadowTexCoord: TEXCOORD0,
float4 Color:COLOR) : COLOR {

float2 ShadowCoord = ShadowTexCoord.xy;
float FragmentDepth = ShadowTexCoord.z;


float ShadowAccum = ShadowStep(ShadowCoord + float2(-Resolution,0),FragmentDepth);
ShadowAccum += ShadowStep(ShadowCoord + float2(Resolution,0),FragmentDepth);

ShadowAccum += ShadowStep(ShadowCoord + float2(0,-Resolution),FragmentDepth);

ShadowAccum += ShadowStep(ShadowCoord + float2(0,Resolution) ,FragmentDepth);
ShadowAccum += ShadowStep(ShadowCoord,FragmentDepth);
ShadowAccum *= 0.2;

return ShadowAccum* Color;
}

technique technique0 {
pass p0 {
CullFaceEnable = false;
VertexProgram = compile vp30 mainVS();
FragmentProgram = compile fp30 mainPS();
}
}

float4x4 mvp;
float4 bones[80 * 3];

struct SkinningVertIn
{
float3 position : POSITION;
float2 tcoord : TEXCOORD0;
float4 weights : TEXCOORD4;
float4 boneIndices : TEXCOORD5;
};

struct SkinningVertOut
{
float4 hpos : HPOS;
float3 color : COLOR0;
float2 tcoord : TEXCOORD0;
};

float3x4 getBoneMatrix(int index)
{
return float3x4(bones[index * 3 + 0],
bones[index * 3 + 1],
bones[index * 3 + 2]);
}

// Skinning vertex program
SkinningVertOut skinningVP(SkinningVertIn IN)
{
SkinningVertOut OUT;

OUT.tcoord = IN.tcoord;

float4 pos = mul(getBoneMatrix(indices.x), float4(IN.position,1)).xyz;

OUT.color = 1;

OUT.hpos = mul(mvp,float4(pos,1));
return OUT;
}

technique Skinning
{
pass
{
VertexProgram = compile gp4vp skinningVP();
}
}

FragOutput main(float2 texCoord : TEXCOORD0,
                uniform sampler2D tex : TEXTURE_2D,
                uniform sampler1D map : TEXTURE_1D)
{
  FragOutput OUT;
  OUT.color = tex2D(tex,texCoord);
  OUT.color = tex1D(map, OUT.color.r);
  return OUT;
}

hr = Gfx::CreateTexture(m_width, m_height, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &m_renderTarget);
m_renderTarget->GetSurfaceLevel(0, &m_renderSurface);

hr = Gfx::CreateTexture(m_width, m_height,1, D3DUSAGE_DEPTHSTENCIL, D3DFMT_D32, D3DPOOL_DEFAULT,&m_depthTexture);
m_depthTexture->GetSurfaceLevel(0,&m_depthStencil);

void zbufferPS( in float2 Texture    : TEXCOORD0,
                out float4 color: COLOR0,
                out float depth : DEPTH0)
{
    color = tex2D(DetailSampler, Texture);
    depth = tex2D(ZSampler, Texture).r;
}