/**
 * Raw Texture API object - should always correspond with the Texture Schema
 * @param id
 * @param typeId
 * @param name
 * @param imagePath
 * @param wrapS
 * @param wrapT
 * @param repeat
 * @param data
 * @param format
 * @param mapping
 * @param magFilter
 * @param minFilter
 * @param textureType
 * @param anisotropy
 * @param offset
 * @param generateMipmaps
 * @param flipY
 * @param mipmaps
 * @param unpackAlignment
 * @param premultiplyAlpha
 * @param encoding
 * @constructor
 */
GameLib.D3.API.Texture = function(
    id,
    typeId,
    name,
    imagePath,
    wrapS,
    wrapT,
    repeat,
    data,
    format,
    mapping,
    magFilter,
    minFilter,
    textureType,
    anisotropy,
    offset,
    generateMipmaps,
    flipY,
    mipmaps,
    unpackAlignment,
    premultiplyAlpha,
    encoding
) {
    if (GameLib.Utils.UndefinedOrNull(id)) {
        id = GameLib.Utils.RandomId();
    }
    this.id = id;

    if (GameLib.Utils.UndefinedOrNull(typeId)) {
        typeId = GameLib.D3.Texture.TEXTURE_TYPE_DIFFUSE;
    }
    this.typeId = typeId;

    if (GameLib.Utils.UndefinedOrNull(name)) {
        name = 'Texture (' + typeId + ')';
    }
    this.name = name;

    if (GameLib.Utils.UndefinedOrNull(imagePath)) {
        imagePath = null;
    }
    this.imagePath = imagePath;

    if (GameLib.Utils.UndefinedOrNull(wrapS)) {
        wrapS = GameLib.D3.Texture.TYPE_REPEAT_WRAPPING;
    }
    this.wrapS = wrapS;

    if (GameLib.Utils.UndefinedOrNull(wrapT)) {
        wrapT = GameLib.D3.Texture.TYPE_REPEAT_WRAPPING;
    }
    this.wrapT = wrapT;

    if (GameLib.Utils.UndefinedOrNull(repeat)) {
        repeat = new GameLib.API.Vector2(1, 1);
    }
    this.repeat = repeat;

    if (GameLib.Utils.UndefinedOrNull(data)) {
        data = null;
    }
    this.data = data;

    if (GameLib.Utils.UndefinedOrNull(format)) {
        format = GameLib.D3.Texture.TYPE_RGBA_FORMAT;
    }
    this.format = format;

    if (GameLib.Utils.UndefinedOrNull(mapping)) {
        mapping = GameLib.D3.Texture.TYPE_UV_MAPPING;
    }
    this.mapping = mapping;

    if (GameLib.Utils.UndefinedOrNull(magFilter)) {
        magFilter = GameLib.D3.Texture.TYPE_LINEAR_FILTER;
    }
    this.magFilter = magFilter;

    if (GameLib.Utils.UndefinedOrNull(minFilter)) {
        minFilter = GameLib.D3.Texture.TYPE_LINEAR_MIPMAP_LINEAR_FILTER;
    }
    this.minFilter = minFilter;

    if (GameLib.Utils.UndefinedOrNull(textureType)) {
        textureType = GameLib.D3.Texture.TYPE_UNSIGNED_BYTE;
    }
    this.textureType = textureType;

    if (GameLib.Utils.UndefinedOrNull(anisotropy)) {
        anisotropy = 1;
    }
    this.anisotropy = anisotropy;

    if (GameLib.Utils.UndefinedOrNull(offset)) {
        offset = new GameLib.API.Vector2(0, 0);
    }
    this.offset = offset;

    if (GameLib.Utils.UndefinedOrNull(generateMipmaps)) {
        generateMipmaps = true;
    }
    this.generateMipmaps = generateMipmaps;

    if (GameLib.Utils.UndefinedOrNull(flipY)) {
        flipY = true;
    }
    this.flipY = flipY;

    if (GameLib.Utils.UndefinedOrNull(mipmaps)) {
        mipmaps = [];
    }
    this.mipmaps = mipmaps;

    if (GameLib.Utils.UndefinedOrNull(unpackAlignment)) {
        unpackAlignment = 4;
    }
    this.unpackAlignment = unpackAlignment;

    if (GameLib.Utils.UndefinedOrNull(premultiplyAlpha)) {
        premultiplyAlpha = false;
    }
    this.premultiplyAlpha = premultiplyAlpha;

    if (GameLib.Utils.UndefinedOrNull(encoding)) {
        encoding = GameLib.D3.Texture.TYPE_LINEAR_ENCODING;
    }
    this.encoding = encoding;
};

/**
 * Creates an API texture from Object data
 * @param objectTexture
 * @constructor
 */
GameLib.D3.API.Texture.FromObjectTexture = function(objectTexture) {
    new GameLib.D3.API.Texture(
        objectTexture.id,
        objectTexture.textureType,
        objectTexture.name,
        objectTexture.imagePath,
        objectTexture.wrapS,
        objectTexture.wrapT,
        GameLib.API.Vector2.FromObjectVector(objectTexture.repeat),
        objectTexture.data,
        objectTexture.format,
        objectTexture.mapping,
        objectTexture.magFilter,
        objectTexture.minFilter,
        objectTexture.textureType,
        objectTexture.anisotropy,
        GameLib.API.Vector2.FromObjectVector(objectTexture.offset),
        objectTexture.generateMipmaps,
        objectTexture.flipY,
        objectTexture.mipmaps,
        objectTexture.unpackAlignment,
        objectTexture.premultiplyAlpha,
        objectTexture.encoding
    )
};