Skip to content

Commit

Permalink
Refactor: Renamed texturevariant_t as TextureVariant
Browse files Browse the repository at this point in the history
  • Loading branch information
@danij-deng
danij-deng committed Jan 10, 2012
1 parent ec4bc15 commit ef6ef63
Show file tree
Hide file tree
Showing 5 changed files with 56 additions and 56 deletions.
28 changes: 14 additions & 14 deletions doomsday/engine/portable/include/texturevariant.h
View file
Expand Up @@ -37,36 +37,36 @@ struct texture_s;
/**@}*/

struct texturevariant_s; // The texturevariant instance (opaque).
typedef struct texturevariant_s texturevariant_t;
typedef struct texturevariant_s TextureVariant;

/**
* @param generalCase Texture from which this variant is derived.
* @param spec Specification used to derive this variant. Ownership of
* specifcation is NOT given to the resultant TextureVariant
*/
texturevariant_t* TextureVariant_New(struct texture_s* generalCase,
TextureVariant* TextureVariant_New(struct texture_s* generalCase,
texturevariantspecification_t* spec);

void TextureVariant_Delete(texturevariant_t* tex);
void TextureVariant_Delete(TextureVariant* tex);

/// @return Superior Texture of which this is a derivative.
struct texture_s* TextureVariant_GeneralCase(const texturevariant_t* tex);
struct texture_s* TextureVariant_GeneralCase(const TextureVariant* tex);

/// @return TextureVariantSpecification used to derive this variant.
texturevariantspecification_t* TextureVariant_Spec(const texturevariant_t* tex);
texturevariantspecification_t* TextureVariant_Spec(const TextureVariant* tex);

boolean TextureVariant_IsMasked(const texturevariant_t* tex);
void TextureVariant_FlagMasked(texturevariant_t* tex, boolean yes);
boolean TextureVariant_IsMasked(const TextureVariant* tex);
void TextureVariant_FlagMasked(TextureVariant* tex, boolean yes);

boolean TextureVariant_IsUploaded(const texturevariant_t* tex);
void TextureVariant_FlagUploaded(texturevariant_t* tex, boolean yes);
boolean TextureVariant_IsUploaded(const TextureVariant* tex);
void TextureVariant_FlagUploaded(TextureVariant* tex, boolean yes);

boolean TextureVariant_IsPrepared(const texturevariant_t* tex);
boolean TextureVariant_IsPrepared(const TextureVariant* tex);

void TextureVariant_Coords(const texturevariant_t* tex, float* s, float* t);
void TextureVariant_SetCoords(texturevariant_t* tex, float s, float t);
void TextureVariant_Coords(const TextureVariant* tex, float* s, float* t);
void TextureVariant_SetCoords(TextureVariant* tex, float s, float t);

DGLuint TextureVariant_GLName(const texturevariant_t* tex);
void TextureVariant_SetGLName(texturevariant_t* tex, DGLuint glName);
DGLuint TextureVariant_GLName(const TextureVariant* tex);
void TextureVariant_SetGLName(TextureVariant* tex, DGLuint glName);

#endif /* LIBDENG_REFRESH_TEXTUREVARIANT_H */
34 changes: 17 additions & 17 deletions doomsday/engine/portable/src/gl_texmanager.c
View file
Expand Up @@ -479,7 +479,7 @@ static void emptyVariantSpecificationList(variantspecificationlist_t* list)
}
}

static int compareTextureVariantWithVariantSpecification(texturevariant_t* tex, void* paramaters)
static int compareTextureVariantWithVariantSpecification(TextureVariant* tex, void* paramaters)
{
texturevariantspecification_t* spec = (texturevariantspecification_t*)paramaters;
return (TextureVariant_Spec(tex) == spec? 1 : 0);
Expand Down Expand Up @@ -560,10 +560,10 @@ typedef enum {
typedef struct {
choosevariantmethod_t method;
const texturevariantspecification_t* spec;
texturevariant_t* chosen;
TextureVariant* chosen;
} choosevariantworker_paramaters_t;

static int chooseVariantWorker(texturevariant_t* variant, void* context)
static int chooseVariantWorker(TextureVariant* variant, void* context)
{
choosevariantworker_paramaters_t* p = (choosevariantworker_paramaters_t*) context;
const texturevariantspecification_t* cand = TextureVariant_Spec(variant);
Expand All @@ -589,7 +589,7 @@ static int chooseVariantWorker(texturevariant_t* variant, void* context)
return 0; // Continue iteration.
}

static texturevariant_t* chooseVariant(choosevariantmethod_t method, texture_t* tex,
static TextureVariant* chooseVariant(choosevariantmethod_t method, texture_t* tex,
const texturevariantspecification_t* spec)
{
choosevariantworker_paramaters_t params;
Expand All @@ -602,7 +602,7 @@ static texturevariant_t* chooseVariant(choosevariantmethod_t method, texture_t*
return params.chosen;
}

static int releaseVariantGLTexture(texturevariant_t* variant, void* paramaters)
static int releaseVariantGLTexture(TextureVariant* variant, void* paramaters)
{
texturevariantspecification_t* spec = (texturevariantspecification_t*)paramaters;
if(!spec || spec == TextureVariant_Spec(variant))
Expand Down Expand Up @@ -634,7 +634,7 @@ static void uploadContent(uploadcontentmethod_t uploadMethod, const textureconte
}

static uploadcontentmethod_t uploadContentForVariant(uploadcontentmethod_t uploadMethod,
const texturecontent_t* content, texturevariant_t* variant)
const texturecontent_t* content, TextureVariant* variant)
{
assert(content && variant);
if(!novideo)
Expand Down Expand Up @@ -838,7 +838,7 @@ static byte loadSourceImage(texture_t* tex, const texturevariantspecification_t*
return loadResult;
}

static uploadcontentmethod_t prepareVariant(texturevariant_t* tex, image_t* image)
static uploadcontentmethod_t prepareVariant(TextureVariant* tex, image_t* image)
{
const variantspecification_t* spec = TS_GENERAL(TextureVariant_Spec(tex));
boolean monochrome = (spec->flags & TSF_MONOCHROME) != 0;
Expand Down Expand Up @@ -1041,7 +1041,7 @@ static uploadcontentmethod_t prepareVariant(texturevariant_t* tex, image_t* imag
return uploadContentForVariant(chooseContentUploadMethod(&c), &c, tex);
}

static uploadcontentmethod_t prepareDetailVariant(texturevariant_t* tex, image_t* image)
static uploadcontentmethod_t prepareDetailVariant(TextureVariant* tex, image_t* image)
{
const detailvariantspecification_t* spec = TS_DETAIL(TextureVariant_Spec(tex));
float baMul, hiMul, loMul, s, t;
Expand Down Expand Up @@ -2949,7 +2949,7 @@ void GL_ReleaseTexturesForRawImages(void)
Z_Free(rawTexs);
}

static int setVariantMinFilter(texturevariant_t* tex, void* paramaters)
static int setVariantMinFilter(TextureVariant* tex, void* paramaters)
{
DGLuint glName = TextureVariant_GLName(tex);
if(glName)
Expand Down Expand Up @@ -3133,8 +3133,8 @@ static void performImageAnalyses(texture_t* tex, const image_t* image,
}
}

static texturevariant_t* tryLoadImageAndPrepareVariant(texture_t* tex,
texturevariantspecification_t* spec, texturevariant_t* variant,
static TextureVariant* tryLoadImageAndPrepareVariant(texture_t* tex,
texturevariantspecification_t* spec, TextureVariant* variant,
byte* result)
{
uploadcontentmethod_t uploadMethod;
Expand Down Expand Up @@ -3252,11 +3252,11 @@ static texturevariant_t* tryLoadImageAndPrepareVariant(texture_t* tex,
return variant;
}

static texturevariant_t* findVariantForSpec(texture_t* tex,
static TextureVariant* findVariantForSpec(texture_t* tex,
const texturevariantspecification_t* spec)
{
// Look for an exact match.
texturevariant_t* variant = chooseVariant(METHOD_MATCH, tex, spec);
TextureVariant* variant = chooseVariant(METHOD_MATCH, tex, spec);
#if _DEBUG
// 07/04/2011 dj: The "fuzzy selection" features are yet to be implemented.
// As such, the following should NOT return a valid variant iff the rest of
Expand All @@ -3273,11 +3273,11 @@ static texturevariant_t* findVariantForSpec(texture_t* tex,
return variant;
}

const texturevariant_t* GL_PrepareTextureVariant2(texture_t* tex, texturevariantspecification_t* spec,
const TextureVariant* GL_PrepareTextureVariant2(texture_t* tex, texturevariantspecification_t* spec,
preparetextureresult_t* returnOutcome)
{
// Have we already prepared something suitable?
texturevariant_t* variant = findVariantForSpec(tex, spec);
TextureVariant* variant = findVariantForSpec(tex, spec);

if(variant && TextureVariant_IsPrepared(variant))
{
Expand All @@ -3301,15 +3301,15 @@ const texturevariant_t* GL_PrepareTextureVariant2(texture_t* tex, texturevariant
return variant;
}

const texturevariant_t* GL_PrepareTextureVariant(texture_t* tex, texturevariantspecification_t* spec)
const TextureVariant* GL_PrepareTextureVariant(texture_t* tex, texturevariantspecification_t* spec)
{
return GL_PrepareTextureVariant2(tex, spec, NULL);
}

DGLuint GL_PrepareTexture2(struct texture_s* tex, texturevariantspecification_t* spec,
preparetextureresult_t* returnOutcome)
{
const texturevariant_t* variant = GL_PrepareTextureVariant2(tex, spec, returnOutcome);
const TextureVariant* variant = GL_PrepareTextureVariant2(tex, spec, returnOutcome);
if(!variant) return 0;
return TextureVariant_GLName(variant);
}
Expand Down
12 changes: 6 additions & 6 deletions doomsday/engine/portable/src/materials.c
View file
Expand Up @@ -1142,7 +1142,7 @@ static void updateMaterialTextureLinks(materialbind_t* mb)
Material_SetShinyStrength(mat, (refDef? refDef->shininess : 0));
}

static void setTexUnit(materialsnapshot_t* ms, byte unit, const texturevariant_t* texture,
static void setTexUnit(materialsnapshot_t* ms, byte unit, const TextureVariant* texture,
blendmode_t blendMode, int magMode, float sScale, float tScale, float sOffset,
float tOffset, float opacity)
{
Expand Down Expand Up @@ -1181,7 +1181,7 @@ const materialsnapshot_t* updateMaterialSnapshot(materialvariant_t* variant,
materialsnapshot_t* snapshot)
{
static struct materialtextureunit_s {
const texturevariant_t* tex;
const TextureVariant* tex;
} texUnits[NUM_MATERIAL_TEXTURE_UNITS];
material_t* mat = MaterialVariant_GeneralCase(variant);
const materialvariantspecification_t* spec = MaterialVariant_Spec(variant);
Expand Down Expand Up @@ -1267,7 +1267,7 @@ const materialsnapshot_t* updateMaterialSnapshot(materialvariant_t* variant,
// Setup the primary texture unit.
if(texUnits[MTU_PRIMARY].tex)
{
const texturevariant_t* tex = texUnits[MTU_PRIMARY].tex;
const TextureVariant* tex = texUnits[MTU_PRIMARY].tex;
int magMode = glmode[texMagMode];
float sScale, tScale;

Expand All @@ -1291,7 +1291,7 @@ const materialsnapshot_t* updateMaterialSnapshot(materialvariant_t* variant,
// Setup the detail texture unit?
if(texUnits[MTU_DETAIL].tex && snapshot->isOpaque)
{
const texturevariant_t* tex = texUnits[MTU_DETAIL].tex;
const TextureVariant* tex = texUnits[MTU_DETAIL].tex;
const float width = Texture_Width(TextureVariant_GeneralCase(tex));
const float height = Texture_Height(TextureVariant_GeneralCase(tex));
float scale = Material_DetailScale(mat);
Expand All @@ -1307,7 +1307,7 @@ const materialsnapshot_t* updateMaterialSnapshot(materialvariant_t* variant,
// Setup the shiny texture units?
if(texUnits[MTU_REFLECTION].tex)
{
const texturevariant_t* tex = texUnits[MTU_REFLECTION].tex;
const TextureVariant* tex = texUnits[MTU_REFLECTION].tex;
const blendmode_t blendmode = Material_ShinyBlendmode(mat);
const float strength = Material_ShinyStrength(mat);

Expand All @@ -1316,7 +1316,7 @@ const materialsnapshot_t* updateMaterialSnapshot(materialvariant_t* variant,

if(texUnits[MTU_REFLECTION_MASK].tex)
{
const texturevariant_t* tex = texUnits[MTU_REFLECTION_MASK].tex;
const TextureVariant* tex = texUnits[MTU_REFLECTION_MASK].tex;

setTexUnit(snapshot, MTU_REFLECTION_MASK, tex, BM_NORMAL,
snapshot->units[MTU_PRIMARY].magMode,
Expand Down
8 changes: 4 additions & 4 deletions doomsday/engine/portable/src/texture.c
View file
Expand Up @@ -35,7 +35,7 @@

typedef struct texture_variantlist_node_s {
struct texture_variantlist_node_s* next;
texturevariant_t* variant;
TextureVariant* variant;
} texture_variantlist_node_t;

texture_t* Texture_New(int flags, textureid_t bindId, void* userData)
Expand Down Expand Up @@ -67,7 +67,7 @@ static void destroyVariants(texture_t* tex)
assert(tex);
while(tex->_variants)
{
texturevariant_t* variant = tex->_variants->variant;
TextureVariant* variant = tex->_variants->variant;
texture_variantlist_node_t* next = tex->_variants->next;
#if _DEBUG
DGLuint glName = TextureVariant_GLName(variant);
Expand Down Expand Up @@ -153,7 +153,7 @@ void Texture_ClearVariants(texture_t* tex)
destroyVariants(tex);
}

texturevariant_t* Texture_AddVariant(texture_t* tex, texturevariant_t* variant)
TextureVariant* Texture_AddVariant(texture_t* tex, TextureVariant* variant)
{
texture_variantlist_node_t* node;
assert(tex);
Expand Down Expand Up @@ -235,7 +235,7 @@ void Texture_SetSize(texture_t* tex, const Size2Raw* size)
}

int Texture_IterateVariants(texture_t* tex,
int (*callback)(texturevariant_t* variant, void* paramaters), void* paramaters)
int (*callback)(TextureVariant* variant, void* paramaters), void* paramaters)
{
int result = 0;
assert(tex);
Expand Down
30 changes: 15 additions & 15 deletions doomsday/engine/portable/src/texturevariant.c
View file
Expand Up @@ -45,17 +45,17 @@ struct texturevariant_s {
texturevariantspecification_t* _spec;
};

texturevariant_t* TextureVariant_New(texture_t* generalCase,
TextureVariant* TextureVariant_New(texture_t* generalCase,
texturevariantspecification_t* spec)
{
texturevariant_t* tex;
TextureVariant* tex;

if(!generalCase)
Con_Error("TextureVariant::New: Attempted with invalid generalCase reference (=NULL).");
if(!spec)
Con_Error("TextureVariant::New: Attempted with invalid spec reference (=NULL).");

tex = (texturevariant_t*) malloc(sizeof(*tex));
tex = (TextureVariant*) malloc(sizeof(*tex));
if(!tex)
Con_Error("TextureVariant::Construct: Failed on allocation of %lu bytes for "
"new TextureVariant.", (unsigned long) sizeof(*tex));
Expand All @@ -68,76 +68,76 @@ texturevariant_t* TextureVariant_New(texture_t* generalCase,
return tex;
}

void TextureVariant_Delete(texturevariant_t* tex)
void TextureVariant_Delete(TextureVariant* tex)
{
assert(tex);
free(tex);
}

struct texture_s* TextureVariant_GeneralCase(const texturevariant_t* tex)
struct texture_s* TextureVariant_GeneralCase(const TextureVariant* tex)
{
assert(tex);
return tex->_generalCase;
}

boolean TextureVariant_IsMasked(const texturevariant_t* tex)
boolean TextureVariant_IsMasked(const TextureVariant* tex)
{
assert(tex);
return (tex->_flags & TVF_IS_MASKED) != 0;
}

void TextureVariant_FlagMasked(texturevariant_t* tex, boolean yes)
void TextureVariant_FlagMasked(TextureVariant* tex, boolean yes)
{
assert(tex);
// if(yes) tex->_flags |= TVF_IS_MASKED; else tex->_flags &= ~TVF_IS_MASKED;
tex->_flags ^= (-yes ^ tex->_flags) & TVF_IS_MASKED;
}

boolean TextureVariant_IsUploaded(const texturevariant_t* tex)
boolean TextureVariant_IsUploaded(const TextureVariant* tex)
{
assert(tex);
return (tex->_flags & TVF_IS_UPLOADED) != 0;
}

void TextureVariant_FlagUploaded(texturevariant_t* tex, boolean yes)
void TextureVariant_FlagUploaded(TextureVariant* tex, boolean yes)
{
assert(tex);
// if(yes) tex->_flags |= TVF_IS_UPLOADED; else tex->_flags &= ~TVF_IS_UPLOADED;
tex->_flags ^= (-yes ^ tex->_flags) & TVF_IS_UPLOADED;
}

boolean TextureVariant_IsPrepared(const texturevariant_t* tex)
boolean TextureVariant_IsPrepared(const TextureVariant* tex)
{
return TextureVariant_IsUploaded(tex) && 0 != TextureVariant_GLName(tex);
}

void TextureVariant_Coords(const texturevariant_t* tex, float* s, float* t)
void TextureVariant_Coords(const TextureVariant* tex, float* s, float* t)
{
assert(tex);
if(s) *s = tex->_s;
if(t) *t = tex->_t;
}

void TextureVariant_SetCoords(texturevariant_t* tex, float s, float t)
void TextureVariant_SetCoords(TextureVariant* tex, float s, float t)
{
assert(tex);
tex->_s = s;
tex->_t = t;
}

texturevariantspecification_t* TextureVariant_Spec(const texturevariant_t* tex)
texturevariantspecification_t* TextureVariant_Spec(const TextureVariant* tex)
{
assert(tex);
return tex->_spec;
}

DGLuint TextureVariant_GLName(const texturevariant_t* tex)
DGLuint TextureVariant_GLName(const TextureVariant* tex)
{
assert(tex);
return tex->_glName;
}

void TextureVariant_SetGLName(texturevariant_t* tex, DGLuint glName)
void TextureVariant_SetGLName(TextureVariant* tex, DGLuint glName)
{
assert(tex);
tex->_glName = glName;
Expand Down

0 comments on commit ef6ef63

Please sign in to comment.