Refactor: materialvariant_t is now a class named de::MaterialVariant

MaterialVariant is the name of the opaque pointer used with the
C wrapper API for de::MaterialVariant

doomsday/engine/portable/include/resource/materialvariant.h

@@ -23,6 +23,7 @@
 #define LIBDENG_RESOURCE_MATERIALVARIANT_H
 
 #include "r_data.h"
+#include "materials.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -87,83 +88,152 @@ typedef struct materialvariant_layer_s {
     short tics;
 } materialvariant_layer_t;
 
-typedef struct materialvariant_s materialvariant_t;
+#ifdef __cplusplus
+} // extern "C"
+#endif
 
-materialvariant_t* MaterialVariant_New(struct material_s* generalCase,
-    const materialvariantspecification_t* spec);
+#ifdef __cplusplus
+namespace de {
+
+class MaterialVariant
+{
+public:
+    MaterialVariant(material_t& generalCase, const materialvariantspecification_t& spec,
+                    const ded_material_t& def);
+    ~MaterialVariant();
+
+    /**
+     * Process a system tick event.
+     * @param ticLength  Length of the tick in seconds.
+     */
+    void ticker(timespan_t time);
+
+    /**
+     * Reset the staged animation point for this Material.
+     */
+    void resetAnim();
+
+    /// @return  Material from which this variant is derived.
+    material_t* generalCase() const { return material; }
+
+    /// @return  MaterialVariantSpecification from which this variant is derived.
+    const materialvariantspecification_t* spec() const { return varSpec; }
+
+    /**
+     * Retrieve a handle for a staged animation layer form this variant.
+     * @param layer  Index of the layer to retrieve.
+     * @return  MaterialVariantLayer for the specified layer index.
+     */
+    const materialvariant_layer_t* layer(int layer);
+
+    /**
+     * Attach MaterialSnapshot data to this. MaterialVariant is given ownership of @a materialSnapshot.
+     * @return  Same as @a materialSnapshot for caller convenience.
+     */
+    materialsnapshot_t& attachSnapshot(materialsnapshot_t& materialSnapshot);
+
+    /**
+     * Detach MaterialSnapshot data from this. Ownership of the data is relinquished to the caller.
+     */
+    materialsnapshot_t* detachSnapshot();
+
+    /// @return  MaterialSnapshot data associated with this.
+    materialsnapshot_t* snapshot() const { return snapshot_; }
+
+    /// @return  Frame count when the snapshot was last prepared/updated.
+    int snapshotPrepareFrame() const { return snapshotPrepareFrame_; }
+
+    /**
+     * Change the frame when the snapshot was last prepared/updated.
+     * @param frame  Frame to mark the snapshot with.
+     */
+    void setSnapshotPrepareFrame(int frame);
+
+    /// @return  Translated 'next' (or target) MaterialVariant if set, else this.
+    MaterialVariant* translationNext();
+
+    /// @return  Translated 'current' MaterialVariant if set, else this.
+    MaterialVariant* translationCurrent();
+
+    /// @return  Translation position [0..1]
+    float translationPoint();
+
+    /**
+     * Change the translation target for this variant.
+     *
+     * @param current  Translated 'current' MaterialVariant.
+     * @param next  Translated 'next' (or target) MaterialVariant.
+     */
+    void setTranslation(MaterialVariant* current, MaterialVariant* next);
+
+    /**
+     * Change the translation point for this variant.
+     * @param inter  Translation point.
+     */
+    void setTranslationPoint(float inter);
+
+private:
+    /// Superior Material of which this is a derivative.
+    material_t* material;
+
+    /// For "smoothed" Material animation:
+    bool hasTranslation;
+    MaterialVariant* current;
+    MaterialVariant* next;
+    float inter;
+
+    /// Specification used to derive this variant.
+    const materialvariantspecification_t* varSpec;
+
+    /// Cached copy of current state if any.
+    materialsnapshot_t* snapshot_;
+
+    /// Frame count when the snapshot was last prepared/updated.
+    int snapshotPrepareFrame_;
+
+    materialvariant_layer_t layers[MATERIALVARIANT_MAXLAYERS];
+};
 
-void MaterialVariant_Delete(materialvariant_t* mat);
+} // namespace de
 
-/**
- * Process a system tick event.
- * @param ticLength  Length of the tick in seconds.
- */
-void MaterialVariant_Ticker(materialvariant_t* mat, timespan_t time);
+extern "C" {
+#endif
 
 /**
- * Reset the staged animation point for this Material.
+ * C wrapper API:
  */
-void MaterialVariant_ResetAnim(materialvariant_t* mat);
 
-/// @return  Material from which this variant is derived.
-struct material_s* MaterialVariant_GeneralCase(materialvariant_t* mat);
-
-/// @return  MaterialVariantSpecification from which this variant is derived.
-const materialvariantspecification_t* MaterialVariant_Spec(const materialvariant_t* mat);
-
-/**
- * Retrieve a handle for a staged animation layer form this variant.
- * @param layer  Index of the layer to retrieve.
- * @return  MaterialVariantLayer for the specified layer index.
- */
-const materialvariant_layer_t* MaterialVariant_Layer(materialvariant_t* mat, int layer);
+struct materialvariant_s; // The materialvariant instance (opaque).
+typedef struct materialvariant_s MaterialVariant;
 
-/**
- * Attach MaterialSnapshot data to this. MaterialVariant is given ownership of @a materialSnapshot.
- * @return  Same as @a materialSnapshot for caller convenience.
- */
-materialsnapshot_t* MaterialVariant_AttachSnapshot(materialvariant_t* mat, materialsnapshot_t* materialSnapshot);
+MaterialVariant* MaterialVariant_New(struct material_s* generalCase,
+    const materialvariantspecification_t* spec);
+void MaterialVariant_Delete(MaterialVariant* mat);
 
-/**
- * Detach MaterialSnapshot data from this. Ownership of the data is relinquished to the caller.
- */
-materialsnapshot_t* MaterialVariant_DetachSnapshot(materialvariant_t* mat);
+void MaterialVariant_Ticker(MaterialVariant* mat, timespan_t time);
 
-/// @return  MaterialSnapshot data associated with this.
-materialsnapshot_t* MaterialVariant_Snapshot(const materialvariant_t* mat);
+void MaterialVariant_ResetAnim(MaterialVariant* mat);
 
-/// @return  Frame count when the snapshot was last prepared/updated.
-int MaterialVariant_SnapshotPrepareFrame(const materialvariant_t* mat);
+material_t* MaterialVariant_GeneralCase(MaterialVariant* mat);
+const materialvariantspecification_t* MaterialVariant_Spec(const MaterialVariant* mat);
+const materialvariant_layer_t* MaterialVariant_Layer(MaterialVariant* mat, int layer);
 
-/**
- * Change the frame when the snapshot was last prepared/updated.
- * @param frame  Frame to mark the snapshot with.
- */
-void MaterialVariant_SetSnapshotPrepareFrame(materialvariant_t* mat, int frame);
+materialsnapshot_t* MaterialVariant_AttachSnapshot(MaterialVariant* mat, materialsnapshot_t* materialSnapshot);
+materialsnapshot_t* MaterialVariant_DetachSnapshot(MaterialVariant* mat);
+materialsnapshot_t* MaterialVariant_Snapshot(const MaterialVariant* mat);
 
-/// @return  Translated 'next' (or target) MaterialVariant if set, else this.
-materialvariant_t* MaterialVariant_TranslationNext(materialvariant_t* mat);
+int MaterialVariant_SnapshotPrepareFrame(const MaterialVariant* mat);
+void MaterialVariant_SetSnapshotPrepareFrame(MaterialVariant* mat, int frame);
 
-/// @return  Translated 'current' MaterialVariant if set, else this.
-materialvariant_t* MaterialVariant_TranslationCurrent(materialvariant_t* mat);
+MaterialVariant* MaterialVariant_TranslationNext(MaterialVariant* mat);
+MaterialVariant* MaterialVariant_TranslationCurrent(MaterialVariant* mat);
 
-/// @return  Translation position [0..1]
-float MaterialVariant_TranslationPoint(materialvariant_t* mat);
+float MaterialVariant_TranslationPoint(MaterialVariant* mat);
 
-/**
- * Change the translation target for this variant.
- *
- * @param current  Translated 'current' MaterialVariant.
- * @param next  Translated 'next' (or target) MaterialVariant.
- */
-void MaterialVariant_SetTranslation(materialvariant_t* mat,
-    materialvariant_t* current, materialvariant_t* next);
+void MaterialVariant_SetTranslation(MaterialVariant* mat,
+    MaterialVariant* current, MaterialVariant* next);
 
-/**
- * Change the translation point for this variant.
- * @param inter  Translation point.
- */
-void MaterialVariant_SetTranslationPoint(materialvariant_t* mat, float inter);
+void MaterialVariant_SetTranslationPoint(MaterialVariant* mat, float inter);
 
 #ifdef __cplusplus
 } // extern "C"

doomsday/engine/portable/include/resource/texture.h

@@ -134,7 +134,7 @@ class Texture
      * Retrieve the value of an identified @a analysis data pointer.
      * @return  Associated data pointer value.
      **/
-    void* analysis(texture_analysisid_t analysis) const;
+    void* analysisDataPointer(texture_analysisid_t analysis) const;
 
     /**
      * Set the value of an identified @a analysis data pointer. Ownership of

doomsday/engine/portable/src/r_things.c

@@ -1003,7 +1003,7 @@ static void setupSpriteParamsForVisSprite(rendspriteparams_t *params,
                                           boolean viewAligned)
 {
     const materialvariantspecification_t* spec;
-    materialvariant_t* variant;
+    MaterialVariant* variant;
 
     if(!params) return; // Wha?
 

doomsday/engine/portable/src/render/rend_main.c

@@ -480,7 +480,7 @@ mapSurfaceMaterialSpec(int wrapS, int wrapT)
  * rendered back-to-front, or there will be alpha artifacts along edges.
  */
 void Rend_AddMaskedPoly(const rvertex_t* rvertices, const ColorRawf* rcolors,
-    coord_t wallLength, materialvariant_t* material, float const texOffset[2],
+    coord_t wallLength, MaterialVariant* material, float const texOffset[2],
     blendmode_t blendMode, uint lightListIdx, float glow)
 {
     vissprite_t* vis = R_NewVisSprite();
@@ -700,10 +700,10 @@ static float getSnapshots(const materialsnapshot_t** msA,
     // Smooth Texture Animation?
     if(msB)
     {
-        materialvariant_t* variant = Materials_ChooseVariant(mat, spec, false, false);
+        MaterialVariant* variant = Materials_ChooseVariant(mat, spec, false, false);
         if(MaterialVariant_TranslationCurrent(variant) != MaterialVariant_TranslationNext(variant))
         {
-            materialvariant_t* matB = MaterialVariant_TranslationNext(variant);
+            MaterialVariant* matB = MaterialVariant_TranslationNext(variant);
 
             // Prepare the inter texture.
             *msB = Materials_PrepareVariant(matB);

doomsday/engine/portable/src/render/rend_sprite.c

@@ -916,7 +916,7 @@ void Rend_DrawMasked(void)
     }
 }
 
-static materialvariant_t* chooseSpriteMaterial(const rendspriteparams_t* p)
+static MaterialVariant* chooseSpriteMaterial(const rendspriteparams_t* p)
 {
     assert(p);
 
@@ -946,7 +946,7 @@ void Rend_RenderSprite(const rendspriteparams_t* params)
     boolean restoreZ = false;
     coord_t spriteCenter[3];
     coord_t surfaceNormal[3];
-    materialvariant_t* mat = NULL;
+    MaterialVariant* mat = NULL;
     const materialsnapshot_t* ms = NULL;
     float s = 1, t = 1; ///< Bottom right coords.
     int i;

doomsday/engine/portable/src/resource/material.cpp

@@ -1,5 +1,5 @@
 /**
- * @file material.c
+ * @file material.cpp
  * Logical material. @ingroup resource
  *
  * @authors Copyright &copy; 2009-2012 Daniel Swanson <danij@dengine.net>
@@ -32,7 +32,7 @@
 
 typedef struct material_variantlist_node_s {
     struct material_variantlist_node_s* next;
-    materialvariant_t* variant;
+    MaterialVariant* variant;
 } material_variantlist_node_t;
 
 static void destroyVariants(material_t* mat)
@@ -375,7 +375,7 @@ void Material_SetShinyMaskTexture(material_t* mat, Texture* tex)
     mat->_shinyMaskTex = tex;
 }
 
-materialvariant_t* Material_AddVariant(material_t* mat, materialvariant_t* variant)
+MaterialVariant* Material_AddVariant(material_t* mat, MaterialVariant* variant)
 {
     material_variantlist_node_t* node;
     assert(mat);
@@ -399,7 +399,7 @@ materialvariant_t* Material_AddVariant(material_t* mat, materialvariant_t* varia
 }
 
 int Material_IterateVariants(material_t* mat,
-    int (*callback)(materialvariant_t* variant, void* paramaters), void* paramaters)
+    int (*callback)(MaterialVariant* variant, void* paramaters), void* paramaters)
 {
     int result = 0;
     assert(mat);