C++ LoadModel函数代码示例

bool Model::Initialize(
    const ModelType& modelDesc,
    ComPtr<ID3D11Device> const device,
    const void* shaderBCode,
    const size_t bcodeLength,
    const std::shared_ptr<MaterialFactory> materialFactory)
{
    dimensions = {};
    initDimensions = {};

    if (!LoadModel(modelDesc.modelFilename, device, shaderBCode, bcodeLength))
    {
        return false;
    }

    material = materialFactory->getMaterial(device, modelDesc.materialFilename);
    if (!material) return false;

    return true;
}

/*
================
idClipModel::idClipModel
================
*/
idClipModel::idClipModel( const idClipModel *model ) {
	enabled = model->enabled;
	entity = model->entity;
	id = model->id;
	owner = model->owner;
	origin = model->origin;
	axis = model->axis;
	bounds = model->bounds;
	absBounds = model->absBounds;
	material = model->material;
	contents = model->contents;
	collisionModelHandle = model->collisionModelHandle;
	traceModelIndex = -1;
	if ( model->traceModelIndex != -1 ) {
		LoadModel( *GetCachedTraceModel( model->traceModelIndex ) );
	}
	renderModelHandle = model->renderModelHandle;
	clipLinks = NULL;
	touchCount = -1;
}

void SpawnPlayer(float x,float y,float z)
{
  

  entity *testmap;
  
  testmap = newentity();
  testmap->model = LoadModel("models/ship.obj", 0,0.4f);
  if(testmap->model != NULL)
    testmap->shown = 1;
  else testmap->shown = 0;

  testmap->texture = LoadModelTexture("models/ship.png",256,256);
  testmap->self = testmap;
  testmap->shown = 1;
  testmap->alpha = 255;
  testmap->sprite_model = 2;
  testmap->scale.x = 1.0f;
  testmap->scale.y = 1.0f;
  testmap->scale.z = 1.0f;
  testmap->s.x = x;
  testmap->s.y = y;
  testmap->s.z = z;
  testmap->v.x = 1;
  testmap->box.x = testmap->model->center[0];
  testmap->box.y = testmap->model->center[1];
  testmap->box.z = testmap->model->center[2];
  testmap->box.w = testmap->model->dimensions[0];
  testmap->box.h = testmap->model->dimensions[1];
  testmap->box.d = testmap->model->dimensions[2];
  testmap->state=0;
  testmap->think = tileThink;
  testmap->touch = PlayerTouch;
  testmap->frame=0;
  testmap->health=1;
  testmap->solid=1;
  testmap->totalframes=10;
  testmap->keyframe=0;
  testmap->nextkeyframe=1;
  playdead=0;
}

bool ModelClass::Initialize(ID3D10Device* device, char* modelFilename)
{
    bool result;


    // Load in the model data.
    result = LoadModel(modelFilename);
    if(!result)
    {
        return false;
    }

    // Initialize the vertex and index buffer that hold the geometry for the model.
    result = InitializeBuffers(device);
    if(!result)
    {
        return false;
    }

    return true;
}

void CRichModel::Preprocess()
{
    if (fBePreprocessed)
        return;
    if (!m_fBeLoaded)
    {
        LoadModel();
    }

    if (!fLocked)
    {
        fLocked = true;
        CreateEdgesFromVertsAndFaces();
        CollectAndArrangeNeighs();
        ComputeNumOfHoles();
        ComputeAnglesAroundVerts();
        ComputePlanarCoordsOfIncidentVertForEdges();
        fBePreprocessed = true;
        fLocked = false;
    }
}

Model* LoadModelPlus(const char* name/*,
			GLuint program,
			char* vertexVariableName,
			char* normalVariableName,
			char* texCoordVariableName*/)
{
	Model *m;
	
	m = LoadModel(name);
	
	glGenVertexArrays(1, &m->vao);
	glGenBuffers(1, &m->vb);
	glGenBuffers(1, &m->ib);
	glGenBuffers(1, &m->nb);
	if (m->texCoordArray != NULL)
		glGenBuffers(1, &m->tb);
		
	ReloadModelData(m);
	
	return m;
}

	void CoreDelegateImpl::OnCreate()
	{
		Core::GetGlobalObject<InputSystem>()->AddSubscriber(&m_input_subs);
		Core::GetGlobalObject<InputSystem>()->AddSubscriber(&g_camera_controller);
		auto p_load_manager = Core::GetGlobalObject<Resources::ResourceManager>();
		p_load_manager->LoadResourceSet("..\\..\\..\\Samples\\Resources\\ResourceSets\\render_testing.res");

		LoadModel();		
		CreateMesh();
		Core::GetGlobalObject<Render::FontManager>()->LoadFont("Arial", Render::FontSettings(), "..\\..\\..\\Samples\\Resources\\Fonts\\arial.ttf");
		auto& world = Core::GetApplication()->GetWorld();
		auto& camera = world.GetCamera();
		static SDK::Vector3 shift{ 5.f, -5.f, -50.f };
		static SDK::Vector3 look_at{ -500,-500, 1500 };
		camera.LookAt(shift, look_at);

		world.GetFrustum().SetFOV(80 * Math::DEG2RAD);
		world.GetFrustum().SetFarClipDistance(1000.f);
		world.GetFrustum().SetNearClipDistance(0.5f);
		Core::GetRenderer()->SetClearColor(Color(128, 112, 112, 255));
	}

void SpawnMine(float x,float y,float z, float vx, float vy, float vz, float side)
{
  

  entity *testmap;
  
  testmap = newentity();
  testmap->model = LoadModel("models/mine.obj", 0,1.0f);
  if(testmap->model != NULL)
    testmap->shown = 1;
  else testmap->shown = 0;

  testmap->texture = LoadModelTexture("models/mine.png",256,256);
  testmap->self = testmap;
  testmap->shown = 1;
  testmap->alpha = 255;
  testmap->sprite_model = 4;
  testmap->scale.x = 1.0f;
  testmap->scale.y = 1.0f;
  testmap->scale.z = 1.0f;
  testmap->s.x = x;
  testmap->s.y = y;
  testmap->s.z = z;
  testmap->v.x = vx;
  testmap->v.y = vy;
  testmap->v.z = vz;
  testmap->state=side;
  testmap->box.x = testmap->model->center[0];
  testmap->box.y = testmap->model->center[1];
  testmap->box.z = testmap->model->center[2];
  testmap->box.w = testmap->model->dimensions[0];
  testmap->box.h = testmap->model->dimensions[1];
  testmap->box.d = testmap->model->dimensions[2];
  testmap->think = mineThink;
  testmap->frame=0;
  testmap->solid=1;
  testmap->totalframes=10;
  testmap->keyframe=0;
  testmap->nextkeyframe=1;
}

BulletModel::BulletModel(glm::vec3 dir) : Lib3dsModel(), mAge(0)
{
	SetPhysicsType(Model::Dynamic);
	SetScaling(glm::vec3(0.5, 0.5, 0.5));

	mDirection = glm::normalize(dir);

	float verticalAngle = -glm::asin(mDirection.y); // approximately good
	float horizontalAngle = -((-3.14159 / 2.0) + glm::atan(mDirection.z / mDirection.x));

	// ATAN2
	if (mDirection.x < 0){
		if (mDirection.z >= 0){
			horizontalAngle -= 3.14159;
		}
		else{
			horizontalAngle += 3.14159;
		}
	}

	//std::cout << "Bullet model vAngle: " << verticalAngle << " hAngle " << horizontalAngle  << " x:  " << direction.x << " z: " << direction.z << std::endl;

	q3Quaternion rot_vert( q3Vec3(1,0,0), verticalAngle);
	q3Quaternion rot_horiz(q3Vec3(0,1,0), horizontalAngle);

	mRotation = rot_horiz * rot_vert;

	mScaling = glm::vec3(0.01, 0.01, 0.01);
	mMeshes.insert(13);
	mFileName = "../Assets/Objects/bombs.3ds";

	LoadModel();



	//mMaxAge = 90; // 90 second exipr date

}

void Game::processMapFileLine(string line)	{

	char* token;
	char str[512];

	strncpy(str, line.c_str(), 512);
	token = strtok(str, WHITESPACE);

	if( token == NULL )
		return;

	if( !strcmp(token, "map") )	{
		token = strtok(NULL, WHITESPACE);
		LoadMap(token);
		Con_print("MAP: Loading OBJ Map: %s", token);
	}
	else if( !strcmp(token, "md2") )	{
		token = strtok(NULL, WHITESPACE);
		LoadModel(token);
		Con_print("MAP: Loading MD2 Model: %s", token);
	}

}

bool LoadAssets()
{
	// 텍스처 로딩
	gpStoneDM = LoadTexture("Fieldstone_DM.tga");
	if (!gpStoneDM)
	{
		return false;
	}

	gpStoneSM = LoadTexture("Fieldstone_SM.tga");
	if (!gpStoneSM)
	{
		return false;
	}

	gpStoneNM = LoadTexture("Fieldstone_NM.tga");
	if (!gpStoneNM)
	{
		return false;
	}

	// 쉐이더 로딩
	gpNormalMappingShader = LoadShader("NormalMapping.fx");
	if (!gpNormalMappingShader)
	{
		return false;
	}

	// 모델 로딩
	gpSphere = LoadModel("spherewithtangent.x");
	if (!gpSphere)
	{
		return false;
	}

	return true;
}

void playergraphic(float x,float y,float z)
{

  entity *player;
  
  player = newentity();
  player->model = LoadModel(playerModel, 3,playerModelScale);
  if(player->model != NULL)
    player->shown = 1;
  else player->shown = 0;

  player->shaderTexture = loadShader("Shader.txt");
  player->self = player;
  player->sprite_model = 7;
  player->scale.x = 8.0f;
  player->scale.y = 8.0f;
  player->scale.z = 8.0f;
  player->modelColor[0] = playerColor.x;
  player->modelColor[1] = playerColor.y;
  player->modelColor[2] = playerColor.z;
  player->modelColor[3] = 1.0f;
  player->s.x = x;
  player->s.y = y;
  player->s.z = z;
  player->think=graplayerupdate;

  player->frame=0;
  player->totalframes=10;
  player->keyframe=0;
  player->nextkeyframe=0;
  player->rotation.x=0.0f;
  player->rotation.y=0.0f;
  player->rotation.z=0.0f;


}

bool StaticMeshComponent::Initialise(ID3D11Device* device, char* modelFilename, WCHAR* textureFilename)
{
	bool result;
	
	result = LoadModel(modelFilename);
	if (!result)
	{
		return false;
	}

	result = InitialiseBuffers(device);
	if (!result)
	{
		return false;
	}

	result = LoadTexture(device, textureFilename);
	if (!result)
	{
		return false;
	}

	return true;
}

void Pong::LoadAssets(void)
{
	std::cout << "\nLoading Assets..." << std::endl;
	LoadModel("Assets/Meshes/Cube.obj");
	LoadModel("Assets/Meshes/Paddle.obj");
	LoadModel("Assets/Meshes/WorldBounds.obj");
	LoadModel("Assets/Meshes/Skybox.obj");
	LoadModel("Assets/Meshes/Horse.obj");
	LoadModel("Assets/Meshes/Elephant.obj");
	
	gameObjectRegister.push_back(new Ball(modelRegister[0], "Assets/Textures/WhiteTexture.bmp"));
	gameObjectRegister.push_back(new Paddle(glm::vec3(-25.0f, 0.0f, 0.0f), modelRegister[1], "Assets/Textures/WhiteTexture.bmp"));
	gameObjectRegister.push_back(new Paddle(glm::vec3(25.0f, 0.0f, 0.0f), modelRegister[1], "Assets/Textures/WhiteTexture.bmp"));
	gameObjectRegister.push_back(new WorldBounds(modelRegister[2], "Assets/Textures/WhiteTexture.bmp"));
	gameObjectRegister.push_back(new GUI(glm::vec3(0.0f, 25.0f, 0.0f), modelRegister[0], "Assets/Textures/WhiteTexture.bmp"));
	gameObjectRegister.push_back(new Skybox(modelRegister[0], "Assets/Textures/BlackTexture.bmp"));
	std::cout << "Assets Loaded OK!" << std::endl;

	std::cout << "\nInitialising Vertex Arrays and Buffers..." << std::endl;
	for (int i = 0; i < gameObjectRegister.size(); i++)
	{
		gameObjectRegister[i]->Init_ShaderObjects(shaderLocations);
	}
}

BOOL Crecord_playerApp::InitInstance() {

    AfxEnableControlContainer();

#ifdef _AFXDLL
    Enable3dControls();         // Call this when using MFC in a shared DLL
#else
    Enable3dControlsStatic();   // Call this when linking to MFC statically
#endif

    g_main_dlg = new Crecord_playerDlg;
  m_pMainWnd = g_main_dlg;

  g_main_dlg->Create(IDD_record_player_DIALOG,NULL);
    
    // create a new world
  world = new cWorld();

  // set background color
  world->setBackgroundColor(0.0f,0.0f,0.0f);

  // Create a camera
  camera = new cCamera(world);
  world->addChild(camera);

  // Create a light source and attach it to camera
  light = new cLight(world);
  light->setEnabled(true);
  light->setPos(cVector3d(2,1,1));

  // define camera position
  flagCameraInMotion = false;

  camera->set(cVector3d(2,0,1), cVector3d(0,0,0), cVector3d(0,0,1));

  // create a display for graphic rendering
  viewport = new cViewport(g_main_dlg->m_gl_area_hwnd, camera, true);
  viewport->setStereoOn(false);

  // init var
  m_rotPos = 0;
  m_rotVel = 0;
  m_inertia = 0.04;
  m_clock.initialize();
  m_lastGoodPosition = 0.0;

  m_reduction = 5.4*10;
  m_cpt = 120*4;          
  m_desiredPos = 0.0;
  m_P = 0.4;
  m_I = 0.0014;
  m_integratorVal = 0.0;
  m_D = 0.02;

  m_lastAngle = 0.0;

  m_velocity = 0;
  m_velocityOld = 0;

  m_RFDInitialAngle = 0.0;
  m_inContact = false;

  LoadModel(TURNTABLE_MODEL);

  object->translate(0,0,-0.3);

  // set stiffness
  double stiffness = (double)35;
  object->setStiffness(stiffness, true);

  // Initialize sound device and create audio stream
  if (!BASS_Init(1,44100,0,0,NULL))
      _cprintf("Init error %d\n", BASS_ErrorGetCode());
    
  // Load a record onto the record player
  load_record(0);
  
  object->computeGlobalPositions(false);
  world->computeGlobalPositions(false);

  return TRUE;
}