void HSWDisplay::LoadGraphics()
{
// As of this writing, we don't yet have an abstraction for Textures, Buffers, and Shaders like we do for D3D11, D3D11, and OpenGL.
#if defined(OVR_BUILD_DEBUG)
if(!pTexture)
pTexture = *LoadTextureTga(RenderParams, "C:\\TestPath\\TestFile.tga", 255);
#endif
if(!pTexture)
{
D3DCAPS9 caps;
RenderParams.Device->GetDeviceCaps(&caps);
if(caps.TextureCaps & (D3DPTEXTURECAPS_SQUAREONLY | D3DPTEXTURECAPS_POW2))
{ HSWDISPLAY_LOG(("[HSWDisplay D3D9] Square textures allowed only.")); }
size_t textureSize;
const uint8_t* TextureData = GetDefaultTexture(textureSize);
pTexture = *LoadTextureTga(RenderParams, TextureData, (int)textureSize, 255);
OVR_ASSERT(pTexture);
}
if(!pVB)
{
HRESULT hResult = RenderParams.Device->CreateVertexBuffer(4 * sizeof(HASWVertex), NULL, HASWVertexD3D9Format, D3DPOOL_MANAGED, &pVB.GetRawRef(), NULL);
if(FAILED(hResult))
{ HSWDISPLAY_LOG(("[HSWDisplay D3D9] CreateVertexBuffer failed. %d (%x)", hResult, hResult)); }
else
{
void* pVerticesVoid;
hResult = pVB->Lock(0, 0, (void**)&pVerticesVoid, 0);
if(FAILED(hResult))
{ HSWDISPLAY_LOG(("[HSWDisplay D3D9] Lock failed. %d (%x)", hResult, hResult)); }
else
{
HASWVertex* pVertices = reinterpret_cast<HASWVertex*>(pVerticesVoid);
const bool flip = ((RenderState.DistortionCaps & ovrDistortionCap_FlipInput) != 0);
const float left = -1.0f;
const float top = -1.1f;
const float right = +1.0f;
const float bottom = +0.9f;
pVertices[0] = HASWVertex(left, top, 0.f, Color(255, 255, 255, 255), 0.f, flip ? 1.f : 0.f); // To do: Make this branchless
pVertices[1] = HASWVertex(left, bottom, 0.f, Color(255, 255, 255, 255), 0.f, flip ? 0.f : 1.f);
pVertices[2] = HASWVertex(right, top, 0.f, Color(255, 255, 255, 255), 1.f, flip ? 1.f : 0.f);
pVertices[3] = HASWVertex(right, bottom, 0.f, Color(255, 255, 255, 255), 1.f, flip ? 0.f : 1.f);
pVB->Unlock();
}
}
}
}
void OculusWorldDemoApp::PopulatePreloadScene()
{
// Load-screen screen shot image
String fileName = MainFilePath;
fileName.StripExtension();
Ptr<File> imageFile = *new SysFile(fileName + "_LoadScreen.tga");
Ptr<Texture> imageTex;
if (imageFile->IsValid())
imageTex = *LoadTextureTga(pRender, imageFile);
// Image is rendered as a single quad.
if (imageTex)
{
imageTex->SetSampleMode(Sample_Anisotropic|Sample_Repeat);
Ptr<Model> m = *new Model(Prim_Triangles);
m->AddVertex(-0.5f, 0.5f, 0.0f, Color(255,255,255,255), 0.0f, 0.0f);
m->AddVertex( 0.5f, 0.5f, 0.0f, Color(255,255,255,255), 1.0f, 0.0f);
m->AddVertex( 0.5f, -0.5f, 0.0f, Color(255,255,255,255), 1.0f, 1.0f);
m->AddVertex(-0.5f, -0.5f, 0.0f, Color(255,255,255,255), 0.0f, 1.0f);
m->AddTriangle(2,1,0);
m->AddTriangle(0,3,2);
Ptr<ShaderFill> fill = *new ShaderFill(*pRender->CreateShaderSet());
fill->GetShaders()->SetShader(pRender->LoadBuiltinShader(Shader_Vertex, VShader_MVP));
fill->GetShaders()->SetShader(pRender->LoadBuiltinShader(Shader_Fragment, FShader_Texture));
fill->SetTexture(0, imageTex);
m->Fill = fill;
LoadingScene.World.Add(m);
}
}
// Loads a texture from a disk TGA file.
IDirect3DTexture9* LoadTextureTga(HSWRenderParams& rParams, const char* pFilePath, uint8_t alpha)
{
SysFile sysFile;
if(sysFile.Open(pFilePath, FileConstants::Open_Read | FileConstants::Open_Buffered))
return LoadTextureTga(rParams, &sysFile, alpha);
return NULL;
}
Fill* CreateTextureFill(RenderDevice* prender, const String& filename)
{
Ptr<File> imageFile = *new SysFile(filename);
Ptr<Texture> imageTex;
if (imageFile->IsValid())
imageTex = *LoadTextureTga(prender, imageFile);
// Image is rendered as a single quad.
ShaderFill* fill = 0;
if (imageTex)
{
imageTex->SetSampleMode(Sample_Anisotropic|Sample_Repeat);
fill = new ShaderFill(*prender->CreateShaderSet());
fill->GetShaders()->SetShader(prender->LoadBuiltinShader(Shader_Vertex, VShader_MVP));
fill->GetShaders()->SetShader(prender->LoadBuiltinShader(Shader_Fragment, FShader_Texture));
fill->SetTexture(0, imageTex);
}
return fill;
}
void HSWDisplay::LoadGraphics()
{
// We assume here that the current GL context is the one our resources will be associated with.
if(GLVersionInfo.MajorVersion == 0)
GetGLVersionAndExtensions(GLVersionInfo);
if (FrameBuffer == 0)
{
glGenFramebuffers(1, &FrameBuffer);
}
if (!pTexture) // To do: Add support for .dds files, which would be significantly smaller than the size of the tga.
{
size_t textureSize;
const uint8_t* TextureData = GetDefaultTexture(textureSize);
pTexture = *LoadTextureTga(RenderParams, Sample_Linear | Sample_Clamp, TextureData, (int)textureSize, 255);
}
if (!pShaderSet)
{
pShaderSet = *new ShaderSet();
}
if(!pVertexShader)
{
OVR::String strShader((GLVersionInfo.MajorVersion >= 3) ? glsl3Prefix : glsl2Prefix);
strShader += SimpleTexturedQuad_vs;
pVertexShader = *new VertexShader(&RenderParams, const_cast<char*>(strShader.ToCStr()), strShader.GetLength(), SimpleTexturedQuad_vs_refl, OVR_ARRAY_COUNT(SimpleTexturedQuad_vs_refl));
pShaderSet->SetShader(pVertexShader);
}
if(!pFragmentShader)
{
OVR::String strShader((GLVersionInfo.MajorVersion >= 3) ? glsl3Prefix : glsl2Prefix);
strShader += SimpleTexturedQuad_ps;
pFragmentShader = *new FragmentShader(&RenderParams, const_cast<char*>(strShader.ToCStr()), strShader.GetLength(), SimpleTexturedQuad_ps_refl, OVR_ARRAY_COUNT(SimpleTexturedQuad_ps_refl));
pShaderSet->SetShader(pFragmentShader);
}
if(!pVB)
{
pVB = *new Buffer(&RenderParams);
pVB->Data(Buffer_Vertex, NULL, 4 * sizeof(HASWVertex));
HASWVertex* pVertices = (HASWVertex*)pVB->Map(0, 4 * sizeof(HASWVertex), Map_Discard);
OVR_ASSERT(pVertices);
if(pVertices)
{
const bool flip = ((RenderState.DistortionCaps & ovrDistortionCap_FlipInput) != 0);
const float left = -1.0f; // We currently draw this in normalized device coordinates with an stereo translation
const float top = -1.1f; // applied as a vertex shader uniform. In the future when we have a more formal graphics
const float right = 1.0f; // API abstraction we may move this draw to an overlay layer or to a more formal
const float bottom = 0.9f; // model/mesh scheme with a perspective projection.
pVertices[0] = HASWVertex(left, top, 0.f, Color(255, 255, 255, 255), 0.f, flip ? 1.f : 0.f);
pVertices[1] = HASWVertex(left, bottom, 0.f, Color(255, 255, 255, 255), 0.f, flip ? 0.f : 1.f);
pVertices[2] = HASWVertex(right, top, 0.f, Color(255, 255, 255, 255), 1.f, flip ? 1.f : 0.f);
pVertices[3] = HASWVertex(right, bottom, 0.f, Color(255, 255, 255, 255), 1.f, flip ? 0.f : 1.f);
pVB->Unmap(pVertices);
}
}
// We don't generate the vertex arrays here
if (!VAO && GLVersionInfo.SupportsVAO)
{
OVR_ASSERT(!VAOInitialized);
#ifdef OVR_OS_MAC
if(GLVersionInfo.WholeVersion >= 302)
glGenVertexArrays(1, &VAO);
else
glGenVertexArraysAPPLE(1, &VAO);
#else
glGenVertexArrays(1, &VAO);
#endif
}
}
// Loads a texture from a memory image of a TGA file.
Texture* LoadTextureTga(RenderParams& rParams, int samplerMode, const uint8_t* pData, int dataSize, uint8_t alpha)
{
MemoryFile memoryFile("", pData, dataSize);
return LoadTextureTga(rParams, samplerMode, &memoryFile, alpha);
}
bool XmlHandler::ReadFile(const char* fileName, OVR::Render::RenderDevice* pRender,
OVR::Render::Scene* pScene,
OVR::Array<Ptr<CollisionModel> >* pCollisions,
OVR::Array<Ptr<CollisionModel> >* pGroundCollisions)
{
if(pXmlDocument->LoadFile(fileName) != 0)
{
return false;
}
// Extract the relative path to our working directory for loading textures
filePath[0] = 0;
SPInt pos = 0;
SPInt len = strlen(fileName);
for(SPInt i = len; i > 0; i--)
{
if (fileName[i-1]=='\\' || fileName[i-1]=='/')
{
memcpy(filePath, fileName, i);
filePath[i] = 0;
break;
}
}
// Load the textures
OVR_DEBUG_LOG_TEXT(("Loading textures..."));
XMLElement* pXmlTexture = pXmlDocument->FirstChildElement("scene")->FirstChildElement("textures");
if (pXmlTexture)
{
pXmlTexture->QueryIntAttribute("count", &textureCount);
pXmlTexture = pXmlTexture->FirstChildElement("texture");
}
for(int i = 0; i < textureCount; ++i)
{
const char* textureName = pXmlTexture->Attribute("fileName");
SPInt dotpos = strcspn(textureName, ".");
char fname[300];
if (pos == len)
{
OVR_sprintf(fname, 300, "%s", textureName);
}
else
{
OVR_sprintf(fname, 300, "%s%s", filePath, textureName);
}
SysFile* pFile = new SysFile(fname);
Ptr<Texture> texture;
if (textureName[dotpos + 1] == 'd' || textureName[dotpos + 1] == 'D')
{
// DDS file
texture.SetPtr(*LoadTextureDDS(pRender, pFile));
}
else
{
texture.SetPtr(*LoadTextureTga(pRender, pFile));
}
Textures.PushBack(texture);
pFile->Close();
pFile->Release();
pXmlTexture = pXmlTexture->NextSiblingElement("texture");
}
OVR_DEBUG_LOG_TEXT(("Done.\n"));
// Load the models
pXmlDocument->FirstChildElement("scene")->FirstChildElement("models")->
QueryIntAttribute("count", &modelCount);
OVR_DEBUG_LOG(("Loading models... %i models to load...", modelCount));
XMLElement* pXmlModel = pXmlDocument->FirstChildElement("scene")->
FirstChildElement("models")->FirstChildElement("model");
for(int i = 0; i < modelCount; ++i)
{
if (i % 15 == 0)
{
OVR_DEBUG_LOG_TEXT(("%i models remaining...", modelCount - i));
}
Models.PushBack(*new Model(Prim_Triangles));
bool isCollisionModel = false;
pXmlModel->QueryBoolAttribute("isCollisionModel", &isCollisionModel);
Models[i]->IsCollisionModel = isCollisionModel;
if (isCollisionModel)
{
Models[i]->Visible = false;
}
//read the vertices
OVR::Array<Vector3f> *vertices = new OVR::Array<Vector3f>();
ParseVectorString(pXmlModel->FirstChildElement("vertices")->FirstChild()->
ToText()->Value(), vertices);
for (unsigned int vertexIndex = 0; vertexIndex < vertices->GetSize(); ++vertexIndex)
{
vertices->At(vertexIndex).x *= -1.0f;
}
//read the normals
OVR::Array<Vector3f> *normals = new OVR::Array<Vector3f>();
ParseVectorString(pXmlModel->FirstChildElement("normals")->FirstChild()->
ToText()->Value(), normals);
for (unsigned int normalIndex = 0; normalIndex < normals->GetSize(); ++normalIndex)
{
normals->At(normalIndex).z *= -1.0f;
}
//read the textures
OVR::Array<Vector3f> *diffuseUVs = new OVR::Array<Vector3f>();
OVR::Array<Vector3f> *lightmapUVs = new OVR::Array<Vector3f>();
int diffuseTextureIndex = -1;
int lightmapTextureIndex = -1;
XMLElement* pXmlCurMaterial = pXmlModel->FirstChildElement("material");
while(pXmlCurMaterial != NULL)
{
if(pXmlCurMaterial->Attribute("name", "diffuse"))
{
pXmlCurMaterial->FirstChildElement("texture")->
QueryIntAttribute("index", &diffuseTextureIndex);
if(diffuseTextureIndex > -1)
{
ParseVectorString(pXmlCurMaterial->FirstChildElement("texture")->
FirstChild()->ToText()->Value(), diffuseUVs, true);
}
}
else if(pXmlCurMaterial->Attribute("name", "lightmap"))
{
pXmlCurMaterial->FirstChildElement("texture")->
QueryIntAttribute("index", &lightmapTextureIndex);
if(lightmapTextureIndex > -1)
{
XMLElement* firstChildElement = pXmlCurMaterial->FirstChildElement("texture");
XMLNode* firstChild = firstChildElement->FirstChild();
XMLText* text = firstChild->ToText();
const char* value = text->Value();
ParseVectorString(value, lightmapUVs, true);
}
}
pXmlCurMaterial = pXmlCurMaterial->NextSiblingElement("material");
}
//set up the shader
Ptr<ShaderFill> shader = *new ShaderFill(*pRender->CreateShaderSet());
shader->GetShaders()->SetShader(pRender->LoadBuiltinShader(Shader_Vertex, VShader_MVP));
if(diffuseTextureIndex > -1)
{
shader->SetTexture(0, Textures[diffuseTextureIndex]);
if(lightmapTextureIndex > -1)
{
shader->GetShaders()->SetShader(pRender->LoadBuiltinShader(Shader_Fragment, FShader_MultiTexture));
shader->SetTexture(1, Textures[lightmapTextureIndex]);
}
else
{
shader->GetShaders()->SetShader(pRender->LoadBuiltinShader(Shader_Fragment, FShader_Texture));
}
}
else
{
shader->GetShaders()->SetShader(pRender->LoadBuiltinShader(Shader_Fragment, FShader_LitGouraud));
}
Models[i]->Fill = shader;
//add all the vertices to the model
const UPInt numVerts = vertices->GetSize();
for(UPInt v = 0; v < numVerts; ++v)
{
if(diffuseTextureIndex > -1)
{
if(lightmapTextureIndex > -1)
{
Models[i]->AddVertex(vertices->At(v).z, vertices->At(v).y, vertices->At(v).x, Color(255, 255, 255),
diffuseUVs->At(v).x, diffuseUVs->At(v).y, lightmapUVs->At(v).x, lightmapUVs->At(v).y,
normals->At(v).x, normals->At(v).y, normals->At(v).z);
}
else
{
Models[i]->AddVertex(vertices->At(v).z, vertices->At(v).y, vertices->At(v).x, Color(255, 255, 255),
diffuseUVs->At(v).x, diffuseUVs->At(v).y, 0, 0,
normals->At(v).x, normals->At(v).y, normals->At(v).z);
}
}
else
{
Models[i]->AddVertex(vertices->At(v).z, vertices->At(v).y, vertices->At(v).x, Color(255, 0, 0, 128),
0, 0, 0, 0,
normals->At(v).x, normals->At(v).y, normals->At(v).z);
}
}
// Read the vertex indices for the triangles
const char* indexStr = pXmlModel->FirstChildElement("indices")->
FirstChild()->ToText()->Value();
UPInt stringLength = strlen(indexStr);
for(UPInt j = 0; j < stringLength; )
{
UPInt k = j + 1;
for(; k < stringLength; ++k)
{
if (indexStr[k] == ' ')
break;
}
char text[20];
for(UPInt l = 0; l < k - j; ++l)
{
text[l] = indexStr[j + l];
}
text[k - j] = '\0';
Models[i]->Indices.PushBack((unsigned short)atoi(text));
j = k + 1;
}
// Reverse index order to match original expected orientation
Array<UInt16>& indices = Models[i]->Indices;
UPInt indexCount = indices.GetSize();
for (UPInt revIndex = 0; revIndex < indexCount/2; revIndex++)
{
unsigned short itemp = indices[revIndex];
indices[revIndex] = indices[indexCount - revIndex - 1];
indices[indexCount - revIndex - 1] = itemp;
}
delete vertices;
delete normals;
delete diffuseUVs;
delete lightmapUVs;
pScene->World.Add(Models[i]);
pScene->Models.PushBack(Models[i]);
pXmlModel = pXmlModel->NextSiblingElement("model");
}
OVR_DEBUG_LOG(("Done."));
//load the collision models
OVR_DEBUG_LOG(("Loading collision models... "));
XMLElement* pXmlCollisionModel = pXmlDocument->FirstChildElement("scene")->FirstChildElement("collisionModels");
if (pXmlCollisionModel)
{
pXmlCollisionModel->QueryIntAttribute("count", &collisionModelCount);
pXmlCollisionModel = pXmlCollisionModel->FirstChildElement("collisionModel");
}
XMLElement* pXmlPlane = NULL;
for(int i = 0; i < collisionModelCount; ++i)
{
Ptr<CollisionModel> cm = *new CollisionModel();
int planeCount = 0;
pXmlCollisionModel->QueryIntAttribute("planeCount", &planeCount);
pXmlPlane = pXmlCollisionModel->FirstChildElement("plane");
for(int j = 0; j < planeCount; ++j)
{
Vector3f norm;
pXmlPlane->QueryFloatAttribute("nx", &norm.x);
pXmlPlane->QueryFloatAttribute("ny", &norm.y);
pXmlPlane->QueryFloatAttribute("nz", &norm.z);
float D;
pXmlPlane->QueryFloatAttribute("d", &D);
D -= 0.5f;
Planef p(norm.z, norm.y, norm.x * -1.0f, D);
cm->Add(p);
pXmlPlane = pXmlPlane->NextSiblingElement("plane");
}
pCollisions->PushBack(cm);
pXmlCollisionModel = pXmlCollisionModel->NextSiblingElement("collisionModel");
}
OVR_DEBUG_LOG(("done."));
//load the ground collision models
OVR_DEBUG_LOG(("Loading ground collision models..."));
pXmlCollisionModel = pXmlDocument->FirstChildElement("scene")->FirstChildElement("groundCollisionModels");
if (pXmlCollisionModel)
{
pXmlCollisionModel->QueryIntAttribute("count", &groundCollisionModelCount);
pXmlCollisionModel = pXmlCollisionModel->FirstChildElement("collisionModel");
}
pXmlPlane = NULL;
for(int i = 0; i < groundCollisionModelCount; ++i)
{
Ptr<CollisionModel> cm = *new CollisionModel();
int planeCount = 0;
pXmlCollisionModel->QueryIntAttribute("planeCount", &planeCount);
pXmlPlane = pXmlCollisionModel->FirstChildElement("plane");
for(int j = 0; j < planeCount; ++j)
{
Vector3f norm;
pXmlPlane->QueryFloatAttribute("nx", &norm.x);
pXmlPlane->QueryFloatAttribute("ny", &norm.y);
pXmlPlane->QueryFloatAttribute("nz", &norm.z);
float D;
pXmlPlane->QueryFloatAttribute("d", &D);
Planef p(norm.z, norm.y, norm.x * -1.0f, D);
cm->Add(p);
pXmlPlane = pXmlPlane->NextSiblingElement("plane");
}
pGroundCollisions->PushBack(cm);
pXmlCollisionModel = pXmlCollisionModel->NextSiblingElement("collisionModel");
}
OVR_DEBUG_LOG(("done."));
return true;
}
// Loads a texture from a memory image of a TGA file.
IDirect3DTexture9* LoadTextureTga(HSWRenderParams& rParams, const uint8_t* pData, int dataSize, uint8_t alpha)
{
MemoryFile memoryFile("", pData, dataSize);
return LoadTextureTga(rParams, &memoryFile, alpha);
}
