From ef6ef630a0e3c2b43c54117fe7b0e75c0ae402e7 Mon Sep 17 00:00:00 2001 From: danij Date: Tue, 10 Jan 2012 13:21:18 +0000 Subject: [PATCH] Refactor: Renamed texturevariant_t as TextureVariant --- .../engine/portable/include/texturevariant.h | 28 +++++++-------- doomsday/engine/portable/src/gl_texmanager.c | 34 +++++++++---------- doomsday/engine/portable/src/materials.c | 12 +++---- doomsday/engine/portable/src/texture.c | 8 ++--- doomsday/engine/portable/src/texturevariant.c | 30 ++++++++-------- 5 files changed, 56 insertions(+), 56 deletions(-) diff --git a/doomsday/engine/portable/include/texturevariant.h b/doomsday/engine/portable/include/texturevariant.h index 0f06aaf534..ad0eae38f2 100644 --- a/doomsday/engine/portable/include/texturevariant.h +++ b/doomsday/engine/portable/include/texturevariant.h @@ -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 */ diff --git a/doomsday/engine/portable/src/gl_texmanager.c b/doomsday/engine/portable/src/gl_texmanager.c index e02ca210b5..4dceb6cf05 100644 --- a/doomsday/engine/portable/src/gl_texmanager.c +++ b/doomsday/engine/portable/src/gl_texmanager.c @@ -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); @@ -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); @@ -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; @@ -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)) @@ -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) @@ -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; @@ -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; @@ -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) @@ -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; @@ -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 @@ -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)) { @@ -3301,7 +3301,7 @@ 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); } @@ -3309,7 +3309,7 @@ const texturevariant_t* GL_PrepareTextureVariant(texture_t* tex, texturevariants 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); } diff --git a/doomsday/engine/portable/src/materials.c b/doomsday/engine/portable/src/materials.c index 54e0be6abb..5b943041de 100644 --- a/doomsday/engine/portable/src/materials.c +++ b/doomsday/engine/portable/src/materials.c @@ -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) { @@ -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); @@ -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; @@ -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); @@ -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); @@ -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, diff --git a/doomsday/engine/portable/src/texture.c b/doomsday/engine/portable/src/texture.c index 9243516e5c..4279d0f1c8 100644 --- a/doomsday/engine/portable/src/texture.c +++ b/doomsday/engine/portable/src/texture.c @@ -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) @@ -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); @@ -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); @@ -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); diff --git a/doomsday/engine/portable/src/texturevariant.c b/doomsday/engine/portable/src/texturevariant.c index 97c3287cac..eaedc09bd2 100644 --- a/doomsday/engine/portable/src/texturevariant.c +++ b/doomsday/engine/portable/src/texturevariant.c @@ -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)); @@ -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;