source: GTP/trunk/App/Demos/Illum/StochasticIteration/ObjectVector.cpp @ 1808

#include "dxstdafx.h"
#include "d3ddefs.h"
#include <cstdio>
#include <ctime>
#include <ostream>
#include <cstdlib>
#include <cmath>
#include <vector>
#include "vector4d.h"
#include "color.h"
#include "object.h"
#include "ObjectVector.h"

ObjectVector::ObjectVector(){
        offsetSum=1;
}
        
ObjectVector::~ObjectVector(){
        vector <ObjectModel*>::iterator iter;
        for(iter=models.begin();iter!=models.end();iter++){
                SAFE_DELETE(*iter);
        }
        models.clear();
}

ObjectModel* ObjectVector::getObjectModel(UINT modelNum){
        return (models.at(modelNum));
}

void ObjectVector::resetAllObjects(LPDIRECT3DDEVICE9 device){
        vector <ObjectModel*>::iterator iter;
        for(iter=models.begin();iter!=models.end();iter++){
                (*iter)->resetDeviceObjects(device);
        }
}

void ObjectVector::initAllObjects(LPDIRECT3DDEVICE9 device){
        vector <ObjectModel*>::iterator iter;
        for(iter=models.begin();iter!=models.end();iter++){
                (*iter)->initDeviceObjects(device);
        }
}

HRESULT ObjectVector::RenderAllWithFX(LPD3DXEFFECT m_pEffect,bool renderToAtlas,D3DXMATRIX modelview,D3DXMATRIX modelviewproj){
        HRESULT hr;
        vector <ObjectModel*>::iterator iter;
        for(iter=models.begin();iter!=models.end();iter++){
                V_RETURN((*iter)->RenderWithFX(m_pEffect,renderToAtlas,modelview,modelviewproj))
        }
        return S_OK;
}

void ObjectVector::getTriangleByIndex(UINT shooterIndex,Triangle& tri,Vector& vertex1,Vector& vertex2,Vector& vertex3,Vector& texcoord1,Vector& texcoord2,Vector& texcoord3){
        UINT shooterSum=1;
        if(models.size()<1){
                return;
        }
        vector <ObjectModel*>::iterator iter;
        for(iter=models.begin();iter!=models.end();iter++){
                if(shooterIndex<shooterSum+(*iter)->ntriangles){
                        assert(shooterIndex-shooterSum<(*iter)->ntriangles);
                        int index=shooterIndex-shooterSum;
                        tri=(*iter)->triangles[index];
                        vertex1=(*iter)->vertices[tri.v[0]];
                        vertex2=(*iter)->vertices[tri.v[1]];
                        vertex3=(*iter)->vertices[tri.v[2]];
                        texcoord1=(*iter)->texcoords[tri.t[0]];
                        texcoord2=(*iter)->texcoords[tri.t[1]];
                        texcoord3=(*iter)->texcoords[tri.t[2]];
                        return;
                }
                else{
                        shooterSum+=(*iter)->ntriangles;
                }
        }
}
        
vector<ObjectModel*> ObjectVector::getAllObjectModels(){
        return this->models;
}
        
void ObjectVector::addObjectModel(ObjectModel& objectModel){
        objectModel.setOffset(offsetSum);
        offsetSum+=objectModel.ntriangles;
        models.push_back(&objectModel);
}

bool ObjectVector::createAllD3DVertices(){
        vector <ObjectModel*>::iterator iter;
        for(iter=models.begin();iter!=models.end();iter++){
                if((*iter)->isLoaded()){
                        (*iter)->CreateD3DVertices();
                }
                else{
                        return false;
                }
        }
        return true;
}

void ObjectVector::removeObjectModel(UINT modelNum){
        vector <ObjectModel*>::iterator iter;
        int number=1;
        bool found=false;
        offsetSum=1;
        for(iter=models.begin();iter!=models.end();iter++){
                if(number==modelNum){
                        models.erase(iter);
                        found=true;
                }
                else{
                        number++;
                        (*iter)->setOffset(offsetSum);
                        offsetSum+=(*iter)->ntriangles;
                        if(found){
                                (*iter)->CreateD3DVertices();
                        }
                }
        }
}

void ObjectVector::removeAllObjectModels(){
        models.clear();
}