Graphics::Graphics(const RECT& rect) : stage(rect) {
linePainter = new LinePainter(rect);
AssertEx(rect.bottom - rect.top == rect.right - rect.left, "only square stage is supported");
camera = new Camera(moveSpeed, rotateSpeed, rect.bottom - rect.top);
LightAttribute lightAttr;
lightAttr.diffuse = Color(255, 255, 255);
lightAttr.direction = Vector3::right;
lightAttr.lightOn = true;
lightAttr.lightType = LightTypeDirection;
lightAttr.position.Set(200, 0, 0);
camera->AddLight(Light(lightAttr));
lightAttr.ambient = Color(90, 90, 90);
lightAttr.lightType = LightTypeAmbient;
lightAttr.lightOn = true;
camera->AddLight(Light(lightAttr));
zBuffer = new ZBuffer(stage.right - stage.left, stage.bottom - stage.top);
VertexContainer vertices;
IndexedTriangleContainer triangles;
CreatePlane(vertices, triangles, Texture("bmp/metal.bmp"), 2, 3);
street = new Object();
//street->Initialize(vertices, triangles, 5.f, 12.f, Vector3(), Vector3());
AddObject(street);
xmin = stage.left + 1;
xmax = stage.right - 2;
ymin = stage.top + 1;
ymax = stage.bottom - 2;
}
//-------------------------------------------------------------------------------
// @ Player::Player()
//-------------------------------------------------------------------------------
// Constructor
//-------------------------------------------------------------------------------
Player::Player()
{
mRotate.Identity();
mScale = 1.0f;
mTranslate.Zero();
mPlaneIndices = nullptr;
mPlaneVerts = nullptr;
mColorTexture = nullptr;
mNormalTexture = nullptr;
// Load the color and normal textures
IvImage* image = IvImage::CreateFromFile("brickwork-texture.tga");
if (image)
{
mColorTexture = IvRenderer::mRenderer->GetResourceManager()->CreateTexture(
(image->GetBytesPerPixel() == 4) ? kRGBA32TexFmt : kRGB24TexFmt,
image->GetWidth(), image->GetHeight(), image->GetPixels(), kImmutableUsage);
delete image;
image = 0;
}
mColorTexture->SetMagFiltering(kBilerpTexMagFilter);
mColorTexture->SetMinFiltering(kBilerpTexMinFilter);
mColorTexture->SetAddressingU(kWrapTexAddr);
mColorTexture->SetAddressingV(kWrapTexAddr);
image = IvImage::CreateFromFile("brickwork_normal-map.tga");
if (image)
{
mNormalTexture = IvRenderer::mRenderer->GetResourceManager()->CreateTexture(
(image->GetBytesPerPixel() == 4) ? kRGBA32TexFmt : kRGB24TexFmt,
image->GetWidth(), image->GetHeight(), image->GetPixels(), kImmutableUsage);
delete image;
image = 0;
}
mNormalTexture->SetMagFiltering(kBilerpTexMagFilter);
mNormalTexture->SetMinFiltering(kBilerpTexMinFilter);
mNormalTexture->SetAddressingU(kWrapTexAddr);
mNormalTexture->SetAddressingV(kWrapTexAddr);
mShader = IvRenderer::mRenderer->GetResourceManager()->CreateShaderProgram(
IvRenderer::mRenderer->GetResourceManager()->CreateVertexShaderFromFile(
"normalShader"),
IvRenderer::mRenderer->GetResourceManager()->CreateFragmentShaderFromFile(
"normalShader"));
mShader->GetUniform("NormalTexture")->SetValue(mNormalTexture);
mShader->GetUniform("ColorTexture")->SetValue(mColorTexture);
mLightPos = IvVector3(-0.8f, 0.8f, 0.8f);
mLightPos.Normalize();
IvRenderer::mRenderer->SetShaderProgram(mShader);
CreatePlane();
} // End of Player::Player()
void BaseMesh::CreateViewPlane(float EyeDist, UINT slices, MatrixController &MC)
{
Matrix4 Perspective = MC.Perspective, PInverse;
PInverse = Perspective.Inverse();
Vec3f PerspectiveCoord(0.0f, 0.0f, EyeDist);
PerspectiveCoord = Perspective.TransformPoint(PerspectiveCoord); //get the top-left coord in persp. space
PerspectiveCoord.x = 1.0f;
PerspectiveCoord.y = -1.0f;
PerspectiveCoord = PInverse.TransformPoint(PerspectiveCoord); //get the bottom-right coord in persp. space
CreatePlane(2.0f, slices, slices); //create the X-Y plane
Matrix4 Scale = Matrix4::Scaling(Vec3f(PerspectiveCoord.x, PerspectiveCoord.y, 1.0f)); //scale it appropriately,
Matrix4 Translate = Matrix4::Translation(Vec3f(0.0f,0.0f,PerspectiveCoord.z)); //translate it away from the eye,
Matrix4 VInverse = MC.View.Inverse(); //we need to transform our mesh and we want to fact the view and world transforms in
Matrix4 WInverse = MC.World.Inverse();
//
// Translate and scale, then go into object space by multiplying through the inverse of view/world.
//
ApplyMatrix(Translate * Scale * VInverse * WInverse);
}
cBackWall::cBackWall()
{
m_pVB=NULL;
m_pIB=NULL;
m_pTexture=NULL;
CreatePlane();
GetPlane()->Make(D3DXVECTOR3(0.0f,0.0f,-1.0f),250);
}
CWaterEntity::CWaterEntity(float32 waterHeight, CTexture* normaTexture, const vec2f& dimension)
: m_fWaterHeight(waterHeight), m_pOffscreenRT(NULL), m_iScreenHeight(480), m_iScreenWidth(320), m_pNormalTexture(normaTexture)
{
m_pOffscreenRT = new COffscreenRenderTarget();
m_pOffscreenRT->Initialize(kCONTEXT_COLOR | kCONTEXT_DEPTH, 256);
m_mMirror.identity();
m_mMirror[5] = -1.f;
m_mTransformationMatrix = mat4f::createTranslation(0, 0, waterHeight);
CreatePlane(dimension);
}
//----------------------------------------------------------------------------
bool WaterDropFormation::OnInitialize ()
{
if ( !Application::OnInitialize() )
return false;
// create scene
m_spkScene = new Node;
m_spkTrnNode = new Node(3);
m_spkScene->AttachChild(m_spkTrnNode);
CreatePlane();
CreateWall();
CreateWaterRoot();
// wireframe
m_spkWireframe = new WireframeState;
m_spkScene->SetRenderState(m_spkWireframe);
// depth buffer
ZBufferState* pkZBuffer = new ZBufferState;
pkZBuffer->Enabled() = true;
pkZBuffer->Writeable() = true;
pkZBuffer->Compare() = ZBufferState::CF_LEQUAL;
m_spkScene->SetRenderState(pkZBuffer);
Configuration0();
// center-and-fit for camera viewing
m_spkScene->UpdateGS(0.0f);
Bound kWBound = m_spkScene->WorldBound();
m_spkTrnNode->Translate() = -kWBound.Center();
ms_spkCamera->SetFrustum(0.1f,1000.0f,-0.055f,0.055f,0.04125f,-0.04125f);
float fAngle = 0.01f*Mathf::PI;
float fCos = Mathf::Cos(fAngle), fSin = Mathf::Sin(fAngle);
Vector3f kCUp(fSin,0.0f,-fCos);
Vector3f kCDir(-fCos,0.0f,-fSin);
Vector3f kCLeft(0.0f,1.0f,0.0f);
Vector3f kCLoc = -0.9f*kWBound.Radius()*kCDir;
ms_spkCamera->SetFrame(kCLoc,kCLeft,kCUp,kCDir);
// initial update of objects
ms_spkCamera->Update();
m_spkScene->UpdateGS(0.0f);
m_spkScene->UpdateRS();
m_spkMotionObject = m_spkScene;
m_bTurretActive = true;
SetTurretAxes();
m_fTrnSpeed = 0.01f;
m_fRotSpeed = 0.001f;
m_fLastSeconds = GetTimeInSeconds();
return true;
}
//----------------------------------------------------------------------------
void PolyhedronDistance::CreateScene ()
{
// ** layout of scene graph **
// scene
// tetra[4]
// plane
// line[2]
// Create the objects.
mScene = new0 Node();
mWireState = new0 WireState();
mRenderer->SetOverrideWireState(mWireState);
TriMesh* plane = CreatePlane();
int i;
for (i = 0; i < 2; ++i)
{
// Build the display tetrahedra.
float size = 0.3f + 0.2f*(i + 1);
if (i == 0)
{
mEdgeLength = size;
}
mTetras[i] = CreateTetra(size, false);
mSegments[i] = CreateSegment();
// Build the point tetrahedra.
mSmall = 0.02f;
mTetras[i + 2] = CreateTetra(mSmall, true);
}
// Tetrahedra faces.
mFaces = new1<Tuple<3,int> >(4);
mFaces[0][0] = 1; mFaces[0][1] = 2; mFaces[0][2] = 0;
mFaces[1][0] = 0; mFaces[1][1] = 3; mFaces[1][2] = 2;
mFaces[2][0] = 0; mFaces[2][1] = 1; mFaces[2][2] = 3;
mFaces[3][0] = 1; mFaces[3][1] = 2; mFaces[3][2] = 3;
// Transform the tetrahedra.
mTetras[0]->LocalTransform.SetRotate(HMatrix(AVector::UNIT_Z, 1.1f));
mTetras[0]->LocalTransform.SetTranslate(APoint(-0.25f, 0.1f, 0.3f));
mTetras[1]->LocalTransform.SetRotate(HMatrix(AVector::UNIT_Z, 0.3f));
mTetras[1]->LocalTransform.SetTranslate(APoint(0.25f, 0.4f, 0.5f));
// Set parent-child links.
mScene->AttachChild(plane);
for (i = 0; i < 2; ++i)
{
mScene->AttachChild(mTetras[i]);
mScene->AttachChild(mSegments[i]);
mScene->AttachChild(mTetras[i + 2]);
}
}
void Lighting::buildScene()
{
// the root of our scenegraph.
m_rootGroup = new osg::Group;
// Load the cow model.
m_rootGroup->addChild( LoadModel().get() );
m_rootGroup->addChild( CreatePlane().get() );
m_rootGroup->addChild( CreateLight().get() );
}
static void CreateFrustrum(EERIE_FRUSTRUM & frustrum, const Vec3f & pos,
const EERIEPOLY & ep, bool cull) {
if(cull) {
CreatePlane(frustrum, 0, pos, ep.v[0].p, ep.v[1].p);
CreatePlane(frustrum, 1, pos, ep.v[3].p, ep.v[2].p);
CreatePlane(frustrum, 2, pos, ep.v[1].p, ep.v[3].p);
CreatePlane(frustrum, 3, pos, ep.v[2].p, ep.v[0].p);
} else {
CreatePlane(frustrum, 0, pos, ep.v[1].p, ep.v[0].p);
CreatePlane(frustrum, 1, pos, ep.v[2].p, ep.v[3].p);
CreatePlane(frustrum, 2, pos, ep.v[3].p, ep.v[1].p);
CreatePlane(frustrum, 3, pos, ep.v[0].p, ep.v[2].p);
}
}
//----------------------------------------------------------------------------
void WaterDropFormation::CreateScene ()
{
mScene = new0 Node();
mTrnNode = new0 Node();
mScene->AttachChild(mTrnNode);
mWireState = new0 WireState();
mRenderer->SetOverrideWireState(mWireState);
CreatePlane();
CreateWall();
CreateWaterRoot();
Configuration0();
}
static unsigned int
AddPlane(GArray * planes, const position * a, const position * b, const position * c)
{
unsigned int index;
plane p;
CreatePlane(&p, a, b, c);
for (index = 0; index < planes->len; index++) {
if (!memcmp(&p, &g_array_index(planes, plane, index), sizeof(plane)))
return index;
}
g_array_append_val(planes, p);
return planes->len - 1;
}
bool Scene::Startup()
{
MobileCamera* camera = new MobileCamera(100.0f, 0.1f);
camera->SetInputWindow(window);
camera->SetupPerspective(glm::pi<float>() * 0.25f, 16.0f / 9.0f, 0.1f, 10000.0f);
camera->LookAt(glm::vec3(100, 100, 100), glm::vec3(0, 0, 0), glm::vec3(0, 1, 0));
m_camera = camera;
//SHADERS
//procedural gen
terrainShader = ShaderHandler::Get()->LoadShader((string)"TerrainShader", "Data/shaders/proceduralGen.vert", "Data/shaders/proceduralGen.frag");
planeShader = ShaderHandler::Get()->LoadShader((string) "PlaneShader", "Data/shaders/bluePlane.vert", "Data/shaders/bluePlane.frag");
//particles
//objects
//AntBar init
/*TwInit(TW_OPENGL_CORE, nullptr);
TwWindowSize(1280, 720);
glfwSetMouseButtonCallback(window, OnMouseButton);
glfwSetCursorPosCallback(window, OnMousePosition);
glfwSetScrollCallback(window, OnMouseScroll);
glfwSetKeyCallback(window, OnKey);
glfwSetCharCallback(window, OnChar);
glfwSetWindowSizeCallback(window, OnWindowResize);*/
tweakBar = TwNewBar("World_Editor");
TwAddVarRW(tweakBar, "Terrain Amplitude", TW_TYPE_FLOAT, &editAmplitude, "");
TwAddVarRW(tweakBar, "Terrain Persistance", TW_TYPE_FLOAT, &editScale, "");
//variable init
barChanged = false;
editAmplitude = 3.0f;
editScale = 8;
perlinSeed = 10;
GenerateTerrain(64, editScale, editAmplitude);
CreatePlane(64);
return true;
}
void BaseMesh::CreatePlane(const Vec3f &_start, const Vec3f &_end, UINT slicesX, UINT slicesY)
{
Vec3f start = _start, end = _end;
CreatePlane(1.0f, slicesX, slicesY);
if(start.x > end.x)
{
Utility::Swap(start.x, end.x);
}
if(start.y > end.y)
{
Utility::Swap(start.y, end.y);
}
Matrix4 T1 = Matrix4::Translation(Vec3f(0.5f,0.5f,0.0f));
Matrix4 Scale = Matrix4::Scaling(Vec3f((end.x-start.x),(end.y-start.y),1.0f));
Matrix4 T2 = Matrix4::Translation(start);
ApplyMatrix(T1 * Scale * T2);
}
void mitk::PlanesPerpendicularToLinesFilter::GenerateData()
{
mitk::Mesh::ConstPointer input = this->GetInput();
mitk::GeometryData::Pointer output = this->GetOutput();
if(m_Plane.IsNotNull())
{
targetRight = m_Plane->GetMatrixColumn(0);
targetSpacing = m_Plane->GetSpacing();
bounds = m_Plane->GetBoundingBox()->GetBounds();
halfWidthInMM = m_Plane->GetExtentInMM(0)*0.5;
halfHeightInMM = m_Plane->GetExtentInMM(1)*0.5;
}
else
{
FillVector3D(targetRight, 1.0, 0.0, 0.0);
targetSpacing.Fill(1.0);
halfWidthInMM=halfHeightInMM=100.0;
ScalarType stdBounds[6] = {0.0, 2.0*halfWidthInMM, 0.0, 2.0*halfHeightInMM, 0.0, 0.0};
bounds = stdBounds;
}
if(m_UseAllPoints==false)
{
int i, size;
//iterate through all cells and build planes
Mesh::ConstCellIterator cellIt, cellEnd;
cellEnd = input->GetMesh()->GetCells()->End();
for( cellIt = input->GetMesh()->GetCells()->Begin(); cellIt != cellEnd; ++cellIt )
{
Mesh::CellType& cell = *cellIt->Value();
Mesh::PointIdIterator ptIt, ptEnd;
ptEnd = cell.PointIdsEnd();
size=cell.GetNumberOfPoints();
if(size<=1)
continue;
ptIt = cell.PointIdsBegin();
last = input->GetPoint(*ptIt);
++ptIt;
for(i=1;i<size;++i, ++ptIt)
{
CreatePlane(input->GetPoint(*ptIt));
}
}
}
else //m_UseAllPoints==true
{
//iterate through all points and build planes
mitk::PointSet::PointsConstIterator it, pend = input->GetPointSet()->GetPoints()->End();
it=input->GetPointSet()->GetPoints()->Begin();
last = it.Value();
++it;
for(;it!=pend;++it)
{
CreatePlane(it.Value());
}
}
if(planes.size()>0)
{
//initialize sliced-geometry for the number of created planes
m_CreatedGeometries->InitializeSlicedGeometry(planes.size()+1);
//set last plane at last point with same normal as the one before the last
PlaneGeometry::Pointer plane = static_cast<PlaneGeometry*>((*planes.rbegin())->Clone().GetPointer());
itk2vtk(last.GetVnlVector()-right*halfWidthInMM-down*halfHeightInMM, origin);
plane->SetOrigin(origin);
m_CreatedGeometries->SetGeometry2D(plane, planes.size());
//add all planes to sliced-geometry
int s;
for(s=0; planes.empty()==false; planes.pop_front(), ++s)
{
m_CreatedGeometries->SetGeometry2D(planes.front(), s);
}
m_CreatedGeometries->SetEvenlySpaced(false);
if(m_FrameGeometry.IsNotNull())
{
m_CreatedGeometries->SetIndexToWorldTransform(m_FrameGeometry->GetIndexToWorldTransform());
m_CreatedGeometries->SetBounds(m_FrameGeometry->GetBounds());
m_CreatedGeometries->SetReferenceGeometry(m_FrameGeometry);
}
}
output->SetGeometry(m_CreatedGeometries);
}
void Setup(CPlatform * const pPlatform)
{
//for the shapes
unsigned int nTorusFloats;
float *pTorusVertices = 0;
float *pPlaneVertices = 0;
float colour[] = {1.0f,0.0f,0.0f, 0.0f,1.0f,0.0f, 0.0f,0.0f,1.0f};
unsigned int torusSegments = 36, torusTubeSegments = 36;
//for the shaders
const char *pVertStr[3] = {0,0,0}, *pFragStr = 0;
const char *pFragTexStr = 0, *pVertTexStr = 0;
//fbo stuff
WRender::Texture::SDescriptor descDepth = {WRender::Texture::TEX_2D, WRender::Texture::DEPTH_COMPONENT, TEX_DIMENSIONS, TEX_DIMENSIONS, 0, 0, WRender::Texture::DONT_GEN_MIPMAP};
WRender::Texture::SParam param[] ={
{ WRender::Texture::MIN_FILTER, WRender::Texture::LINEAR},
{ WRender::Texture::MAG_FILTER, WRender::Texture::LINEAR},
{ WRender::Texture::WRAP_S, WRender::Texture::CLAMP_TO_EDGE},
{ WRender::Texture::WRAP_T, WRender::Texture::CLAMP_TO_EDGE},
};
glswInit();
glswSetPath("../resources/", ".glsl");
WRender::SetClearColour(0,0,0,0);
WRender::EnableCulling(true);
// - - - - - - - - - -
//setup the shaders
// - - - - - - - - - -
//normal shader
glswGetShadersAlt("shaders.Version+shaders.Shared+shaders.SingleShadow.Vertex", pVertStr, 3);
pFragStr = glswGetShaders("shaders.Version+shaders.SingleShadow.Fragment");
CShader vertexShader(CShader::VERT, pVertStr, 3);
CShader fragmentShader(CShader::FRAG, &pFragStr, 1);
program.Initialise();
program.AddShader(&vertexShader);
program.AddShader(&fragmentShader);
program.Link();
uShadowMtx = program.GetUniformLocation("shadowMtx");
program.Start();
program.SetTextureUnit("shadowMap", 0);
program.Stop();
//debug shader for textures in screen space
pVertTexStr = glswGetShaders("shaders.Version+shaders.Dbg.ScreenSpaceTexture.Vertex");
pFragTexStr = glswGetShaders("shaders.Version+shaders.Dbg.ScreenSpaceTexture.Fragment");
CShader vTexShader(CShader::VERT, &pVertTexStr, 1);
CShader fTexShader(CShader::FRAG, &pFragTexStr, 1);
textureShader.Initialise();
textureShader.AddShader(&vTexShader);
textureShader.AddShader(&fTexShader);
textureShader.Link();
textureShader.Start();
textureShader.SetTextureUnit("texture",0);
textureShader.Stop();
// - - - - - - - - - -
//set up shapes
// - - - - - - - - - -
//shared colours
abColour = WRender::CreateBuffer(WRender::ARRAY, WRender::STATIC, sizeof(colour), colour);
//Torus
nTorusVertices = 2*torusTubeSegments*torusSegments*3;
nTorusFloats = nTorusVertices*3;
pTorusVertices = new float[nTorusFloats];
CreateTorus(pTorusVertices, torusSegments, 3.0f, torusTubeSegments, 1.0f);
vaoTorus = WRender::CreateVertexArrayObject();
abTorus = WRender::CreateBuffer(WRender::ARRAY, WRender::STATIC, sizeof(float)*nTorusFloats, pTorusVertices);
WRender::BindVertexArrayObject(vaoTorus);
WRender::VertexAttribute vaTorus[2] = {
{abTorus, 0, 3, WRender::FLOAT, 0, sizeof(float)*3, 0, 0},
{abColour, 1, 3, WRender::FLOAT, 0, sizeof(float)*9, sizeof(float)*6, 1},
};
WRender::SetAttributeFormat( vaTorus, 2, 0);
delete[] pTorusVertices;
//Plane
pPlaneVertices = new float[4*3*3];
CreatePlane(pPlaneVertices, 20.0f, 20.0f);
vaoPlane = WRender::CreateVertexArrayObject();
abPlane = WRender::CreateBuffer(WRender::ARRAY, WRender::STATIC, sizeof(float)*4*3*3, pPlaneVertices);
WRender::BindVertexArrayObject(vaoPlane);
WRender::VertexAttribute vaFrustum[2] = {
{abPlane, 0, 3, WRender::FLOAT, 0, sizeof(float)*3, 0, 0},
{abColour, 1, 3, WRender::FLOAT, 0, sizeof(float)*9, sizeof(float)*3, 1},
};
WRender::SetAttributeFormat( vaFrustum, 2, 0);
delete[] pPlaneVertices;
//for screen aligned texture
sqVao = WRender::CreateVertexArrayObject();
sqEab = WRender::CreateBuffer(WRender::ELEMENTS, WRender::STATIC, sizeof(sqIndices), sqIndices);
sqAb = WRender::CreateBuffer(WRender::ARRAY, WRender::STATIC, sizeof(sqVertices), sqVertices);
WRender::BindVertexArrayObject(sqVao);
WRender::BindBuffer(WRender::ELEMENTS, sqEab);
WRender::VertexAttribute sqVa[2] = {
{sqAb, 0, 3, WRender::FLOAT, 0, sizeof(float)*5, 0, 0}, //vertices
{sqAb, 1, 2, WRender::FLOAT, 0, sizeof(float)*5, sizeof(float)*3, 0}, //texture coordinates
};
WRender::SetAttributeFormat( sqVa, 2, 0);
WRender::UnbindVertexArrayObject();
// - - - - - - - - - -
//ubo for cameras etc
// - - - - - - - - - -
ubo = WRender::CreateBuffer(WRender::UNIFORM, WRender::DYNAMIC, sizeof(Transforms), &transform);
WRender::BindBufferToIndex(WRender::UNIFORM, ubo, 1);
//create the texture and FBO for rendering to when drawing
//during shadow stage
WRender::CreateBaseTexture(depthTexture, descDepth);
WRender::SetTextureParams(depthTexture,param,4);
WRender::CreateFrameBuffer(fbo);
WRender::AddTextureRenderBuffer(fbo, depthTexture, WRender::ATT_DEPTH, 0);
WRender::BindFrameBuffer(WRender::FrameBuffer::DRAW, fbo);
WRender::SetDrawBuffer(WRender::DB_NONE);
WRender::CheckFrameBuffer(fbo);
//set the projection matrix
Transform::CreateProjectionMatrix(transforms.proj, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 50.0f);
WRender::BindTexture(depthTexture,WRender::Texture::UNIT_0);
}
HRESULT HelloShadowVolume::RestoreDeviceObjects()
{
HRESULT hr;
IDirect3DDevice8* device;
hr = m_spD3D->CreateDevice(
D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
m_hWnd,
D3DCREATE_HARDWARE_VERTEXPROCESSING,
&m_dpps,
&device);
if (FAILED(hr))
{
MessageBox(0, L"CreateDevice failed", 0, 0);
return E_FAIL;
}
m_spDevice.reset(device, [](IDirect3DDevice8* device) {
device->Release();
});
m_spDevice->SetRenderState(D3DRS_ZENABLE, TRUE);
m_spDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
m_spDevice->SetRenderState(D3DRS_DITHERENABLE, TRUE);
D3DVIEWPORT8 viewport = { 0, 0, m_iWidth, m_iHeight };
m_spDevice->SetViewport(&viewport);
D3DXVECTOR3 eye(0.0f, 0.0f, 30.0f);
D3DXVECTOR3 target(0.0f, 0.0f, 0.0f);
D3DXVECTOR3 up(0.0f, 1.0f, 0.0f);
D3DXMatrixLookAtLH(&m_mtView, &eye, &target, &up);
D3DXMatrixPerspectiveFovLH(&m_mtProj, 0.2*D3DX_PI, (float)m_iWidth / (float)m_iHeight, 1.0f, 100.f);
m_cPlaneTint = { 0.7f, 0.6f, 0.4f, 1.0f };
ID3DXMesh* plane;
//D3DXCreatePolygon(m_spDevice.get(), 2.0f, 4, &plane, NULL);
CreatePlane(m_spDevice.get(), 15.0f, 10, &plane);
//D3DXCreateSphere(m_spDevice.get(), 1.0f,20,20, &plane, NULL);
IDirect3DVertexBuffer8* vb;
IDirect3DIndexBuffer8* ib;
plane->GetVertexBuffer(&vb);
plane->GetIndexBuffer(&ib);
m_spPlaneVB.reset(vb, [](IDirect3DVertexBuffer8* vb) {
vb->Release();
});
m_spPlaneIB.reset(ib, [](IDirect3DIndexBuffer8* ib) {
ib->Release();
});
m_dwPlaneNumVertices = plane->GetNumVertices();
m_dwPlaneNumFaces = plane->GetNumFaces();
plane->Release();
DWORD decl[] = {
D3DVSD_STREAM(0),
D3DVSD_REG(0, D3DVSDT_FLOAT3),
D3DVSD_REG(3, D3DVSDT_FLOAT3),
D3DVSD_END()
};
hr = CreateVSFromBinFile(m_spDevice.get(), decl, L"plane.vso", &m_dwPlaneVSH);
if (FAILED(hr))
{
MessageBox(0, 0, L"CreateVSFromBinFile failed", 0);
return E_FAIL;
}
hr = CreatePSFromBinFile(m_spDevice.get(), L"plane.pso", &m_dwPlanePSH);
if (FAILED(hr))
{
MessageBox(0, 0, L"CreatePSFromBinFile failed", 0);
return E_FAIL;
}
D3DXMATRIX Rx, Tz;
D3DXMatrixRotationX(&Rx, D3DX_PI*0.5f);
D3DXMatrixTranslation(&Tz, 0.0f, -3.0f, 0.0f);
m_mtPlaneWorld = Rx * Tz;
ID3DXMesh* occluder;
CreateOccluder(m_spDevice.get(), &occluder);
IDirect3DVertexBuffer8* vbOccluder;
IDirect3DIndexBuffer8* ibOccluder;
occluder->GetVertexBuffer(&vbOccluder);
occluder->GetIndexBuffer(&ibOccluder);
m_spOccluderVB.reset(vbOccluder, [](IDirect3DVertexBuffer8* vb) {
vb->Release();
});
m_spOccluderIB.reset(ibOccluder, [](IDirect3DIndexBuffer8* ib) {
ib->Release();
});
m_dwOccluderNumVertices = occluder->GetNumVertices();
m_dwOccluderNumFaces = occluder->GetNumFaces();
occluder->Release();
hr = CreateVSFromBinFile(m_spDevice.get(), decl, L"occluder.vso", &m_dwOccluderVSH);
if (FAILED(hr))
{
MessageBox(0, 0, L"CreateVSFromBinFile failed", 0);
return E_FAIL;
}
hr = CreatePSFromBinFile(m_spDevice.get(), L"occluder.pso", &m_dwOccluderPSH);
if (FAILED(hr))
{
MessageBox(0, 0, L"CreatePSFromBinFile failed", 0);
return E_FAIL;
}
m_cOccluderTint = { 0.3f, 0.0f, 0.8f, 1.0f };
D3DXMATRIX Rz, T;
D3DXMatrixTranslation(&T, 5.1f * cosf(0.5), 0.0f, 5.1f * sinf(0.5));
D3DXMatrixIdentity(&m_mtVolumeWorld);
D3DXMatrixRotationZ(&Rz, 0.5f);
m_mtOccluderWorld = T * Rz;
ID3DXMesh* volume;
CreateVolume(m_spDevice.get(), &volume);
IDirect3DVertexBuffer8* vbVolume;
IDirect3DIndexBuffer8* ibVolume;
volume->GetVertexBuffer(&vbVolume);
volume->GetIndexBuffer(&ibVolume);
m_spVolumeVB.reset(vbVolume, [](IDirect3DVertexBuffer8* vb) {
vb->Release();
});
m_spVolumeIB.reset(ibVolume, [](IDirect3DIndexBuffer8* ib) {
ib->Release();
});
m_dwVolumeNumVertices = volume->GetNumVertices();
m_dwVolumeNumFaces = volume->GetNumFaces();
volume->Release();
hr = CreateVSFromBinFile(m_spDevice.get(), decl, L"volume.vso", &m_dwVolumeVSH);
if (FAILED(hr))
{
MessageBox(0, 0, L"CreateVSFromBinFile failed", 0);
return E_FAIL;
}
hr = CreatePSFromBinFile(m_spDevice.get(), L"volume.pso", &m_dwVolumePSH);
if (FAILED(hr))
{
MessageBox(0, 0, L"CreatePSFromBinFile failed", 0);
return E_FAIL;
}
m_cVolumeTint = { 0.7f, 0.0f, 0.0f, 1.0f };
D3DXMATRIX Sx;
D3DXMatrixIdentity(&m_mtVolumeWorld);
D3DXMatrixScaling(&Sx, 6.0f, 1.0f, 1.0f);
D3DXMatrixRotationZ(&Rz, 0.5f);
m_mtVolumeWorld = Sx * Rz;
return S_OK;
}
MeshWeakPtr CMeshManager::CreateMesh(xst_castring& strName, const IInputLayout* pIL, BASIC_SHAPE eShape, xst_unknown pShapeOptions, xst_castring& strGroupName)
{
MeshWeakPtr pMesh = CreateMesh( strName, pIL, strGroupName );
if( pMesh->m_bIsCloned )
{
return pMesh;
}
switch( eShape )
{
case BasicShapes::BOX:
{
SBoxOptions Options;
if( pShapeOptions != xst_null )
Options = *(SBoxOptions*)pShapeOptions;
if( XST_FAILED( CreateBox( pMesh.GetPtr(), pIL, Options ) ) )
{
this->DestroyResource( pMesh );
pMesh = xst_null;
}
}
break;
case BasicShapes::LINE_BOX:
{
SLineBoxOptions Options;
if( pShapeOptions != xst_null )
Options = *(SLineBoxOptions*)pShapeOptions;
if( XST_FAILED( CreateBox( pMesh.GetPtr(), pIL, Options ) ) )
{
this->DestroyResource( pMesh );
pMesh = xst_null;
}
}
break;
case BasicShapes::CIRCLE:
{
SCircleOptions Options;
if( pShapeOptions != xst_null )
Options = *(SCircleOptions*)pShapeOptions;
if( XST_FAILED( CreateCircle( pMesh.GetPtr(), pIL, Options ) ) )
{
this->DestroyResource( pMesh );
pMesh = xst_null;
}
}
break;
case BasicShapes::PLANE:
{
SPlaneOptions Options;
if( pShapeOptions != xst_null ) Options = *(SPlaneOptions*)pShapeOptions;
if( XST_FAILED( CreatePlane( pMesh.GetPtr(), pIL, Options ) ) )
{
this->DestroyResource( pMesh );
pMesh = xst_null;
}
}
break;
case BasicShapes::RECT_2D:
{
SRect2DOptions Options;
if( pShapeOptions != xst_null ) Options = *(SRect2DOptions*)pShapeOptions;
if( XST_FAILED( CreateRect2D( pMesh.GetPtr(), pIL, Options ) ) )
{
this->DestroyResource( pMesh );
pMesh = xst_null;
}
}
break;
default:
{
this->DestroyResource( pMesh );
pMesh = xst_null;
}
break;
};
return pMesh;
}
//----------------------------------------------------------------------------
bool InverseKinematics::OnInitialize ()
{
if ( !Application::OnInitialize() )
return false;
// set up camera
ms_spkCamera->SetFrustum(1.0f,1000.0f,-0.55f,0.55f,0.4125f,-0.4125f);
Vector3f kCamLoc(0.0f,-2.0f,0.5f);
Matrix3f kCamOrient(-1.0f,0.0f,0.0f,0.0f,0.0f,1.0f,0.0f,1.0f,0.0f);
ms_spkCamera->SetFrame(kCamLoc,kCamOrient);
// ** layout of scene graph **
// scene
// line
// iknode
// plane
// target
// goal
// root
// origin
// effector
// end
// create objects
m_spkScene = new Node(2);
Node* pkIKNode = new Node(3);
m_spkRoot = new Node(2);
m_spkEffector = new Node(1);
m_spkTarget = new Node;
m_spkLine = CreateLine();
TriMesh* pkPlane = CreatePlane();
TriMesh* pkGoal = CreateCube();
TriMesh* pkOrigin = CreateCube();
TriMesh* pkEnd = CreateCube();
// transform objects
pkIKNode->Rotate().FromAxisAngle(Vector3f::UNIT_Y,0.1f);
pkIKNode->Translate() = Vector3f(0.1f,0.1f,0.1f);
m_spkTarget->Translate() = 2.0f*Vector3f::UNIT_Y;
m_spkEffector->Translate() = Vector3f::UNIT_X;
// set parent-child links
m_spkScene->AttachChild(m_spkLine);
m_spkScene->AttachChild(pkIKNode);
pkIKNode->AttachChild(pkPlane);
pkIKNode->AttachChild(m_spkTarget);
pkIKNode->AttachChild(m_spkRoot);
m_spkTarget->AttachChild(pkGoal);
m_spkRoot->AttachChild(pkOrigin);
m_spkRoot->AttachChild(m_spkEffector);
m_spkEffector->AttachChild(pkEnd);
// create joints
IKJoint** apkJoint = new IKJoint*[2];
apkJoint[0] = new IKJoint(m_spkRoot);
apkJoint[0]->AllowRotation(2) = true;
apkJoint[1] = new IKJoint(m_spkEffector);
apkJoint[1]->AllowTranslation(2) = true;
// create goal
IKGoal** apkGoal = new IKGoal*[1];
apkGoal[0] = new IKGoal(m_spkTarget,m_spkEffector,1.0f);
// create IK controller
m_pkIKCtrl = new IKController(2,apkJoint,1,apkGoal,1);
m_pkIKCtrl->Active() = false;
m_spkRoot->AttachControl(m_pkIKCtrl);
// set desired render state
m_spkWireframeState = new WireframeState;
m_spkScene->SetRenderState(m_spkWireframeState);
m_spkZBufferState = new ZBufferState;
m_spkZBufferState->Enabled() = true;
m_spkZBufferState->Writeable() = true;
m_spkZBufferState->Compare() = ZBufferState::CF_LEQUAL;
m_spkScene->SetRenderState(m_spkZBufferState);
// initial update of objects
ms_spkCamera->Update();
m_spkScene->UpdateGS(0.0f);
m_spkScene->UpdateRS();
UpdateLine();
m_bTurretActive = true;
SetTurretAxes();
m_fTrnSpeed = 0.1f;
m_fRotSpeed = 0.01f;
return true;
}
void BaseMesh::CreatePlane(const Plane &p, float length, UINT slices)
{
CreatePlane(p, length, slices, p.Normal()*-p.d);
}
void BaseMesh::CreatePlane(const Plane &P, float Length, UINT Slices, const Vec3f &Center)
{
CreatePlane(Length, Slices, Slices);
ApplyMatrix(Matrix4::Face(Vec3f(0.0f, 0.0f, 1.0f), P.Normal()) * Matrix4::Translation(Center));
}
