void CLoadASE::GetTextureInfo (tMaterialInfo *pTexture, int desiredMaterial)
{
char strWord[255] = {0};
int materialCount= 0;
rewind(m_FilePointer);
while (!feof(m_FilePointer))
{
fscanf(m_FilePointer, "%s", &strWord);
if (!strcmp(strWord, MATERIAL))
{
materialCount++;
if(materialCount == desiredMaterial)
break;
}
else
{
fgets(strWord, 100, m_FilePointer);
}
}
while (!feof(m_FilePointer))
{
fscanf(m_FilePointer, "%s", &strWord);
if (!strcmp (strWord, MATERIAL))
{
return;
}
else if (!strcmp(strWord, MATERIAL_COLOR))
{
fscanf(m_FilePointer, " %f %f %f", &(pTexture->fColor[0]),
&(pTexture->fColor[1]),
&(pTexture->fColor[2]));
}
else if (!strcmp(strWord, TEXTURE))
{
GetTextureName(pTexture);
}
else if (!strcmp(strWord, MATERIAL_NAME))
{
GetMaterialName(pTexture);
}
else if(!strcmp(strWord, UTILE))
{
pTexture->uTile = ReadFloat();
}
else if(!strcmp(strWord, VTILE))
{
pTexture->vTile = ReadFloat();
}
else
{
fgets (strWord, 100, m_FilePointer);
}
}
}
void BillboardMarker::LoadResources(Ogre::SceneManager* ogreMgr)
{
if(!_loaded)
{
auto def = GetBillboardMarkerDefinition();
Ogre::BillboardSet* billSet= ogreMgr->createBillboardSet(def->GetPoolSize());
billSet->setMaterialName(def->GetMaterialName(), def->GetMaterialGroup());
billSet->setBillboardType((Ogre::BillboardType)def->GetBillboardType());
billSet->setCommonUpVector(def->GetCommonUpVector());
billSet->setCommonDirection(def->GetCommonDirection());
billSet->setBillboardsInWorldSpace(def->GetIsBillboardInWorldSpace());
billSet->setBillboardOrigin((Ogre::BillboardOrigin)def->GetBillboardOrigin());
billSet->setDefaultDimensions(def->GetDefaultBillboardSize().x,
def->GetDefaultBillboardSize().y);
billSet->setAutoextend(true);
billSet->setAutoUpdate(def->GetBillboardAutoUpdate());
billSet->setUseIdentityProjection(def->GetUseIdentityProjection());
billSet->setUseIdentityView(def->GetUseIdentityView());
billSet->Ogre::MovableObject::setUserAny(Ogre::Any(this));
billSet->setBillboardRotationType(Ogre::BBR_VERTEX);
_sceneObject = billSet;
SceneMarker::LoadResources(ogreMgr);
_loaded = true;
}
}
static inline const program_t& Create(const std::string& mat_name , const std::string& preprocessorDefinitions = std::string())
{
const uint16_t version = GLSL_VERSION;
const std::string comp_str = GLSL_VERSION>=150 ?" compatibility":"";
const std::string mat_name_cut = GetMaterialName(mat_name);
if(GetPrograms().find(mat_name_cut)==GetPrograms().end())
{
program_t p;
p.program = new osg::Program;
p.program->setName(mat_name_cut);
static osg::Shader* ssv = AddShader(shaders::VS, "shadow", version, comp_str, string());
static osg::Shader* ssf = AddShader(shaders::FS, "shadow", version, comp_str, string());
p.program->addShader( ssv );
p.program->addShader( ssf );
p.program->addShader( AddShader(shaders::VS, mat_name_cut, version, comp_str, preprocessorDefinitions));
p.program->addShader( AddShader(shaders::FS, mat_name_cut, version, comp_str, preprocessorDefinitions));
p.program->addBindAttribLocation( "tangent" , 6 );
p.program->addBindAttribLocation( "binormal", 7 );
GetPrograms()[mat_name_cut]=p;
}
return GetPrograms()[mat_name_cut];
}
void CParticleSystem::Load()
{
if (IsLoaded())
return;
m_iReferences = 1;
m_bLoaded = true;
if (GetMaterialName().length() > 0)
SetMaterial(CMaterialLibrary::AddMaterial(GetMaterialName()));
if (GetModelName().length() > 0)
SetModel(CModelLibrary::AddModel(GetModelName()));
CParticleSystemLibrary::Get()->m_iParticleSystemsLoaded++;
for (size_t i = 0; i < GetNumChildren(); i++)
CParticleSystemLibrary::Get()->GetParticleSystem(GetChild(i))->Load();
}
int SkpModel::AddMaterial(SUMaterialRef mat){
std::string name = GetMaterialName(mat);
if (name=="")
return 0;
for (auto& x: mmap_){
if (x.first==name)
return 0;
}
//std::cout << name << "\n";
Material* MyMat = new Material(mat);
//std::cout << "Material Created" << "\n";
mmap_.emplace(name, MyMat);
//std::cout << "Material Added" << "\n";
return 0;
}
void ParseMD3File(char *pBuffer, uint32 bufferSize, const char *pFilename, const char *pSkin)
{
int a,b;
F3DMeshChunk *pMC = pModel->GetMeshChunk();
F3DSkeletonChunk *pSC = pModel->GetSkeletonChunk();
MD3Header *pHeader = (MD3Header*)pBuffer;
// DBGASSERT(pHeader->ident == (('3'<<24) | ('P'<<16) | ('D'<<8) | 'I'), "Invalid MD3 header.");
// DBGASSERT(pHeader->version == 15, "Invalid MD3 version.");
// DBGASSERT(pHeader->offsetEnd == bufferSize, "Incorrect MD3 Size.");
(char*&)pHeader->pTags += (uintp)pBuffer;
(char*&)pHeader->pSurfaces += (uintp)pBuffer;
// read materials
if(pSkin)
{
char *pT, *pTok = MFString_Chr(pSkin, ',');
while(pTok)
{
++pTok;
for(pT = pTok; *pT != 0 && *pT != '\r' && *pT != '\n'; ++pT) { }
// get texture name
char *pTT = pT - (uintp)pTok;
char *pMaterialName = (char*)MFStrN(pTok, (int&)pTT);
for(pT = pMaterialName+MFString_Length(pMaterialName); pT > pMaterialName && pT[-1] != '/' && pT[-1] != '\\' && pT[-1] != '\n' && pT[-1] != '\r'; --pT) { }
pT[MFString_Length(pT) - 4] = 0;
if(*pT && pModel->GetMaterialChunk()->GetMaterialIndexByName(pT) == -1)
{
F3DMaterial &mat = pModel->GetMaterialChunk()->materials.push();
mat.name = pT;
mat.maps[0] = pT;
}
pTok = MFString_Chr(pTok, ',');
}
}
// process bones
for(a=0; a<pHeader->numTags; a++)
{
F3DBone &bone = pSC->bones.push();
bone.name = pHeader->pTags[a].tagName;
bone.worldMatrix.SetXAxis3(MakeVector(pHeader->pTags[a].rotationMatrix[0][0], pHeader->pTags[a].rotationMatrix[0][1], pHeader->pTags[a].rotationMatrix[0][2]));
bone.worldMatrix.SetYAxis3(MakeVector(pHeader->pTags[a].rotationMatrix[1][0], pHeader->pTags[a].rotationMatrix[1][1], pHeader->pTags[a].rotationMatrix[1][2]));
bone.worldMatrix.SetZAxis3(MakeVector(pHeader->pTags[a].rotationMatrix[2][0], pHeader->pTags[a].rotationMatrix[2][1], pHeader->pTags[a].rotationMatrix[2][2]));
bone.worldMatrix.SetTrans3(MakeVector(pHeader->pTags[a].origin[0], pHeader->pTags[a].origin[1], pHeader->pTags[a].origin[2]));
}
// process mesh
for(a=0; a<pHeader->numSurfaces; a++)
{
// DBGASSERT(pHeader->pSurfaces->identity == (('3'<<24) | ('P'<<16) | ('D'<<8) | 'I'), "Invalid MD3 surface header.");
(char*&)pHeader->pSurfaces->pTextureCoords += (uintp)pHeader->pSurfaces;
(char*&)pHeader->pSurfaces->pTriangles += (uintp)pHeader->pSurfaces;
(char*&)pHeader->pSurfaces->pVertices += (uintp)pHeader->pSurfaces;
F3DSubObject &sub = pMC->subObjects.push();
F3DMaterialSubobject &matSub = sub.matSubobjects[0];
// read subobject name
sub.name = pHeader->pSurfaces->surfaceName;
// find material info
matSub.materialIndex = pModel->GetMaterialChunk()->GetMaterialIndexByName(GetMaterialName(pSkin, sub.name.CStr()));
// create one colour (white)
sub.colours.resize(1);
sub.colours[0] = MFVector::one;
// read vertex data
sub.uvs.resize(pHeader->pSurfaces->numVertices);
sub.positions.resize(pHeader->pSurfaces->numVertices);
sub.normals.resize(pHeader->pSurfaces->numVertices);
for(b=0; b<pHeader->pSurfaces->numVertices; b++)
{
sub.uvs[b] = MakeVector(pHeader->pSurfaces->pTextureCoords[b].u, pHeader->pSurfaces->pTextureCoords[b].v);
sub.normals[b] = MD3DecodeNormal(pHeader->pSurfaces->pVertices[b].encodedNormal);
sub.positions[b] = MakeVector(pHeader->pSurfaces->pVertices[b].x, pHeader->pSurfaces->pVertices[b].y, pHeader->pSurfaces->pVertices[b].z);
// scale vertex appropriately..
// sub.positions[b].Mul3(sub.positions[b], 1.0f/6400.0f);
sub.positions[b].Mul3(sub.positions[b], 1.0f/64.0f);
matSub.vertices[b].colour = 0;
matSub.vertices[b].normal = b;
matSub.vertices[b].uv[0] = b;
matSub.vertices[b].position = b;
}
// read triangles
matSub.triangles.resize(pHeader->pSurfaces->numTriangles);
for(b=0; b<pHeader->pSurfaces->numTriangles; b++)
{
matSub.triangles[b].v[0] = pHeader->pSurfaces->pTriangles[b].indices[0];
matSub.triangles[b].v[1] = pHeader->pSurfaces->pTriangles[b].indices[2];
matSub.triangles[b].v[2] = pHeader->pSurfaces->pTriangles[b].indices[1];
}
// skip to next surface
(char*&)pHeader->pSurfaces += pHeader->pSurfaces->surfaceSize;
}
}
void C3DS::ParseChunk(stChunk* Chunk){
while(Chunk->bytesRead < Chunk->length){
stChunk tempChunk = {0, 0, 0};
ReadChunk(&tempChunk);
switch( tempChunk.ID){
// HEADER OUR ENTRY POINT
case EDIT3DS: //0x3D3D
ParseChunk(&tempChunk);
break;
// MATERIALS
case MATERIAL: //0xAFFF
stMaterial newMaterial;
m_pMaterials.push_back(newMaterial);
m_iNumMaterials++;
ParseChunk(&tempChunk);
break;
case MAT_NAME: //0xA000 - sz for hte material name "e.g. default 2"
GetMaterialName(&tempChunk);
break;
case MAT_DIFFUSE: // Diffuse Colour //0xA020
GetDiffuseColour(&tempChunk);
break;
case MAT_TEXMAP: //0xA200 - if there's a texture wrapped to it where here
ParseChunk(&tempChunk);
break;
case MAT_TEXFLNM: // 0xA300 - get filename of the material
GetTexFileName(&tempChunk);
break;
// OBJECT - MESH'S
case NAMED_OBJECT:{
stMesh newMesh;
m_pMeshs.push_back(newMesh);
m_iNumMeshs++;
GetMeshObjectName(&tempChunk);
}
break;
case OBJ_MESH: //0x4100
ParseChunk(&tempChunk);
break;
case MESH_VERTICES: //0x4110
ReadMeshVertices(&tempChunk);
break;
case MESH_FACES: //0x4120
ReadMeshFaces(&tempChunk);
break;
case MESH_TEX_VERT: //0x4140
ReadMeshTexCoords(&tempChunk);
break;
case MESH_MATER: //0x4130
ReadMeshMaterials(&tempChunk);
break;
default:
SkipChunk(&tempChunk);
}
Chunk->bytesRead += tempChunk.length;
}
}
void C3DS::ParseChunk(stChunk* Chunk)
{
while(Chunk->bytesRead < Chunk->length)
{
stChunk tempChunk = {0};
ReadChunk(&tempChunk);
// DEBUG CHUNKS
//char buf[2000];
//sprintf(buf, "Chunk ID: %.4x\t Size: %d\n", tempChunk.ID, tempChunk.length);
//debug_op(buf);
switch( tempChunk.ID)
{
// HEADER OUR ENTRY POINT
case EDIT3DS: //0x3D3D
ParseChunk(&tempChunk);
break;
// MATERIALS
case MATERIAL: //0xAFFF
{
stMaterial newMaterial;
m_pMaterials.push_back(newMaterial);
m_iNumMaterials++;
}
ParseChunk(&tempChunk);
break;
case MAT_NAME: //0xA000 - sz for hte material name "e.g. default 2"
GetMaterialName(&tempChunk);
break;
case MAT_AMBIENT:
GetAmbientColour(&tempChunk);
break;
case MAT_SPECULAR:
GetSpecularColour(&tempChunk);
break;
case MAT_DIFFUSE: // Diffuse Colour //0xA020
GetDiffuseColour(&tempChunk);
break;
case MAT_TEXMAP: //0xA200 - if there's a texture wrapped to it where here
ParseChunk(&tempChunk);
break;
case MAT_TEXFLNM: // 0xA300 - get filename of the material
GetTexFileName(&tempChunk);
break;
// OBJECT - MESH'S
case NAMED_OBJECT: //0x4000
{
stMesh newMesh;
m_pMeshs.push_back(newMesh);
m_iNumMeshs++;
GetMeshObjectName(&tempChunk);
}
break;
case OBJ_MESH: //0x4100
ParseChunk(&tempChunk);
break;
case MESH_VERTICES: //0x4110
ReadMeshVertices(&tempChunk);
break;
case MESH_FACES: //0x4120
ReadMeshFaces(&tempChunk);
break;
case MESH_TEX_VERT: //0x4140
ReadMeshTexCoords(&tempChunk);
break;
case MESH_MATER: //0x4130
ReadMeshMaterials(&tempChunk);
break;
// ANIMATION
case KEYF3DS: //0xB000
ParseChunk(&tempChunk);
break;
case ANIM_S_E_TIME: //0xB008
StartEndFrames(&tempChunk);
break;
case ANIM_OBJ: //0xB002
{
stAnimation newAnimation;
m_pAnimation.push_back(newAnimation);
m_iNumAnimObjects++;
}
ParseChunk(&tempChunk);
break;
case ANIM_NAME:
ReadNameOfObjectToAnimate(&tempChunk);
break;
case ANIM_PIVOT: // 0xB013
ReadPivotPoint(&tempChunk);
break;
case ANIM_POS: // 0xB020
ReadAnimPos(&tempChunk);
break;
case ANIM_ROT: // 0xB021
ReadAnimRot(&tempChunk);
break;
case ANIM_SCALE: // 0xB022
ReadAnimScale(&tempChunk);
break;
default:
SkipChunk(&tempChunk);
}
Chunk->bytesRead += tempChunk.length;
}
}
