C++ ImageLoader::Load方法代码示例

void MainScreen::onInit(ScreenContext& sc)
{
    // Store engine ref
    mEngine = sc.GetEngine();

    // Store file data cache ref
    mFileDataCache = sc.GetFileDataCache();

    // Cube rotation state
    mRotationData.degreesInc = 0.05f;
    mRotationData.rotating = false;

    // Camera initial position
    mCamera.SetPos(glm::vec3(0, 0, 8));

    // Add sample UV Sphere
    ModelData sphereModel = GenUVSphere(1, 32, 32);
    mEngine->GetModelStore().Load("4", std::move(sphereModel));

    // Create world objects
    SetupWorld();

    // Create world lights
    SetupLights();

    // Cam shouldn't follow character initially
    mFollowingCharacter = false;

    // Initial choosen moving light
    mMovingLightIndex = 0;

    // Init character
    mCharacter.Init(&mEngine->GetWindow(), mScene.get());

    // Load the skybox
    ImageLoader imLoader;
    auto& cubemapStore = mEngine->GetCubemapStore();
    cubemapStore.Load(skybox, imLoader.Load(*(*mFileDataCache)["ext/Assets/Textures/Skybox/Bluesky/bluesky.tga"], "tga"));
    mEngine->GetSkyboxRenderer().SetCubemapId(cubemapStore[skybox]->id);

    // Load the irr map
    mEngine->GetCubemapStore().Load(irrmap, imLoader.Load(*(*mFileDataCache)["ext/Assets/Textures/Skybox/Bluesky/bluesky_irr.tga"], "tga"));

    // Load the rad map
    for (unsigned int i = 0; i < 9; ++i) {
        mEngine->GetCubemapStore().Load(
            radmap,
            imLoader.Load(*(*mFileDataCache)[
                              "ext/Assets/Textures/Skybox/Bluesky/bluesky_rad_" + std::to_string(i) + ".tga"], "tga"), i);
    }

    // Do not show AABBs by default
    mShowAABBs = false;

    // Do not show Debug info by default
    mShowDbgInfo = false;

    // Init renderform creator
    mRenderformCreator = std::make_unique<RenderformCreator>(&(mEngine->GetModelStore()), &(mEngine->GetMaterialStore()));
}

void CDefFile::loadFrame(size_t frame, size_t group, ImageLoader &loader) const
{
	std::map<size_t, std::vector <size_t> >::const_iterator it;
	it = offset.find(group);
	assert (it != offset.end());

	const ui8 * FDef = data+it->second[frame];

	const SSpriteDef sd = * reinterpret_cast<const SSpriteDef *>(FDef);
	SSpriteDef sprite;

	sprite.format = read_le_u32(&sd.format);
	sprite.fullWidth = read_le_u32(&sd.fullWidth);
	sprite.fullHeight = read_le_u32(&sd.fullHeight);
	sprite.width = read_le_u32(&sd.width);
	sprite.height = read_le_u32(&sd.height);
	sprite.leftMargin = read_le_u32(&sd.leftMargin);
	sprite.topMargin = read_le_u32(&sd.topMargin);

	ui32 currentOffset = sizeof(SSpriteDef);
	ui32 BaseOffset =    sizeof(SSpriteDef);

	loader.init(Point(sprite.width, sprite.height),
	            Point(sprite.leftMargin, sprite.topMargin),
	            Point(sprite.fullWidth, sprite.fullHeight), palette);

	switch (sprite.format)
	{
	case 0:
		{
			//pixel data is not compressed, copy data to surface
			for (ui32 i=0; i<sprite.height; i++)
			{
				loader.Load(sprite.width, FDef[currentOffset]);
				currentOffset += sprite.width;
				loader.EndLine();
			}
			break;
		}
	case 1:
		{
			//for each line we have offset of pixel data
			const ui32 * RWEntriesLoc = reinterpret_cast<const ui32 *>(FDef+currentOffset);
			currentOffset += sizeof(ui32) * sprite.height;

			for (ui32 i=0; i<sprite.height; i++)
			{
				//get position of the line
				currentOffset=BaseOffset + read_le_u32(RWEntriesLoc + i);
				ui32 TotalRowLength = 0;

				while (TotalRowLength<sprite.width)
				{
					ui8 type=FDef[currentOffset++];
					ui32 length=FDef[currentOffset++] + 1;

					if (type==0xFF)//Raw data
					{
						loader.Load(length, FDef + currentOffset);
						currentOffset+=length;
					}
					else// RLE
					{
						loader.Load(length, type);
					}
					TotalRowLength += length;
				}

				loader.EndLine();
			}
			break;
		}
	case 2:
		{
			currentOffset = BaseOffset + read_le_u16(FDef + BaseOffset);

			for (ui32 i=0; i<sprite.height; i++)
			{
				ui32 TotalRowLength=0;

				while (TotalRowLength<sprite.width)
				{
					ui8 SegmentType=FDef[currentOffset++];
					ui8 code = SegmentType / 32;
					ui8 length = (SegmentType & 31) + 1;

					if (code==7)//Raw data
					{
						loader.Load(length, FDef[currentOffset]);
						currentOffset += length;
					}
					else//RLE
					{
						loader.Load(length, code);
					}
					TotalRowLength+=length;
				}
				loader.EndLine();
			}
			break;
//.........这里部分代码省略.........

void* TextureProcessorMain(std::vector<std::string>* args)
{
	auto start = std::chrono::high_resolution_clock::now();

	std::string filename;
	int numArgs = args->size();
	if (numArgs > 0)
	{
		filename = (*args)[0];
	}
	else
	{
		cout << "ERROR : You must specify a filename.";
		cin.get();
	}

	if (numArgs > 1)
	{
		for (int i = 1; i < numArgs; ++i)
		{
			std::string argument = (*args)[i];

			if (argument.find("texformat") != string::npos)
			{
				if (numArgs >= i + 1)
					texFormat = (TEXTURE_FORMAT)atoi((*args)[i + 1].c_str());
				else cout << "Please provide a valid texture format.";
			}
			else if (argument.find("mipmaps") != string::npos)
			{
				generateMipmaps = true;
			}
			else if (argument.find("memory") != string::npos)
			{
				useMemory = true;
			}
			else if (argument.find("reverse") != string::npos)
			{
				reverseChannels = true;
			}
			else if (argument.find("flipvertical") != string::npos)
			{
				flipVertically = true;
			}

		}
	}

	string extension = filename.substr(filename.find(".") + 1);

	ImageLoader* loader = NULL;

	if (extension == "jpg" || extension == "jpeg")
	{
		loader = new JpegLoader();
	}
	else if (extension == "png")
	{
		loader = new PngLoader();
	}
	else if (extension == "bmp")
	{
		loader = new BmpLoader();
	}
	

	
	/*ilInit();

	ilEnable(IL_FILE_OVERWRITE);

	ilEnable(IL_ORIGIN_SET);
	ilSetInteger(IL_ORIGIN_MODE, IL_ORIGIN_UPPER_LEFT); */

	auto startLoad = std::chrono::high_resolution_clock::now();

	loader->Load(filename, reverseChannels == true ? ImageLoader::PixelChannelOrder::ORDER_BGR : ImageLoader::PixelChannelOrder::ORDER_RGB);

	if (flipVertically)
		loader->FlipVertically();


	auto endLoad = std::chrono::high_resolution_clock::now();

	long long  timeLoad = std::chrono::duration_cast<std::chrono::milliseconds>(endLoad - startLoad).count();

	//TextureLoader loader = TextureLoader(filename.c_str());
	
	//std::cout << "timeLoad : " << timeLoad << "\n";

	//loader.SetTextureFormat(texFormat);

	auto startMip = std::chrono::high_resolution_clock::now();

	if(generateMipmaps)
		loader->GenerateMipmaps();



	auto endMip = std::chrono::high_resolution_clock::now();
//.........这里部分代码省略.........

void MaterialScreen::onInit(ScreenContext& sc)
{
    // Store engine ref
    mEngine = sc.GetEngine();

    // Store file data cache ref
    mFileDataCache = sc.GetFileDataCache();

    // Add sample UV Sphere
    ModelData sphereModel = GenUVSphere(1, 32, 32);
    mEngine->GetModelStore().Load("sphere", std::move(sphereModel));

    // Create scene
    mScene = std::make_unique<Scene>();

    // Create materials
    int id = 0;
    for (int metallic = 0; metallic <= 1; ++metallic)
    {
        for (float roughness = 0.0f; roughness < 1.0f; roughness += 0.1f)
        {
            for (float reflectivity = 0.0f; reflectivity < 1.0; reflectivity += 0.1f)
            {
                // Create and store the material
                std::string materialName;
                materialName += metallic == 1 ? "m" : "d";
                materialName += "r" + std::to_string(roughness);
                materialName += "f" + std::to_string(reflectivity);
                Material m;
                m.SetMetallic(static_cast<float>(metallic));
                m.SetRoughness(roughness);
                m.SetFresnel(reflectivity);
                m.SetDiffuseColor(glm::vec3(255.0f, 0.0f, 0.0f));
                mEngine->GetMaterialStore().Load(materialName, m);

                // Create and store the object that will be made of the material previously defined
                SceneNode* node = mScene->CreateNode(
                    "sphere",
                    {materialName},
                    std::to_string(id),
                    Category::Normal,
                    sphereModel.boundingBox
                );
                node->Move(glm::vec3(roughness * 20.0f -10.0f + 22.0f * metallic, reflectivity * 20.0f - 10.0f, 0.0f));
                ++id;
            }
        }
    }

    // Setup scene lights
    Lights& lights = mEngine->GetRenderer().GetLights();

    // Add directional light
    DirLight dirLight;
    dirLight.direction = glm::vec3(-0.3f, -0.5f, -0.5f);
    dirLight.color = glm::vec3(0.9f);
    lights.dirLights.push_back(dirLight);

    // Camera initial position
    mCamera.SetPos(glm::vec3(-6, 8, 12));
    mCamera.Look(std::make_tuple(450.0f, 450.0f));

    // Load the skybox
    ImageLoader imLoader;
    auto& cubemapStore = mEngine->GetCubemapStore();
    cubemapStore.Load(skybox, imLoader.Load(*(*mFileDataCache)["ext/Assets/Textures/Skybox/Indoors/indoors.tga"], "tga"));
    mEngine->GetSkyboxRenderer().SetCubemapId(cubemapStore[skybox]->id);

    // Load the irr map
    mEngine->GetCubemapStore().Load(irrmap, imLoader.Load(*(*mFileDataCache)["ext/Assets/Textures/Skybox/Indoors/indoors_irr.tga"], "tga"));

    // Load the rad map
    for (unsigned int i = 0; i < 9; ++i) {
        mEngine->GetCubemapStore().Load(
            radmap,
            imLoader.Load(*(*mFileDataCache)[
                "ext/Assets/Textures/Skybox/Indoors/indoors_rad_" + std::to_string(i) + ".tga"], "tga"), i);
    }

    // Init renderform creator
    mRenderformCreator = std::make_unique<RenderformCreator>(&(mEngine->GetModelStore()), &(mEngine->GetMaterialStore()));
}