ObjMaster/VertexTextureElement.h at master · prenex/ObjMaster · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
//
// Created by rthier on 2016.04.11..
//

#ifndef NFTSIMPLEPROJ_VERTEXTEXTUREELEMENT_H
#define NFTSIMPLEPROJ_VERTEXTEXTUREELEMENT_H

#include "objmasterlog.h"
#include <string>

namespace ObjMaster {

    class VertexTextureElement final {
    public:
        float u;
        float v;

	// Copies are defeaulted
	VertexTextureElement(const VertexTextureElement &other) = default;
	VertexTextureElement& operator=(const VertexTextureElement &other) = default;
	// Moves are defaulted
	VertexTextureElement(VertexTextureElement &&other) = default;
	VertexTextureElement& operator=(VertexTextureElement &&other) = default;

        VertexTextureElement() {};

        VertexTextureElement(float uu, float vv) {u = uu; v = vv;};

        VertexTextureElement(char *fields);

        VertexTextureElement(const char *fields);

        static bool isParsable(const char *fields);

	/** Gets the textual representation */
	inline std::string asText() {
		return "vt " + std::to_string(u) + " " + std::to_string(v);
	}
    private:
        void constructionHelper(char *fields);
    };

// Very simple unit-testing approach
// it is better to have these run on the device itself and callable as normal functions than to
// test it compile-time with some unit testing framework as this way we rule out architectural
// differences better. Tests will start by logging test starts to error (when #DEBUG is set!)
// and info logs and the method returns false when anything has failed...
    /** testing output-related operations (like asText()) */
    static int TEST_VertexTextureElement_Output(){
        const char *vetest = "vt 1.0 2.0";
	// Parse
	VertexTextureElement v(vetest);
	// Get as string
	auto str = v.asText();
	// Reparse result
	VertexTextureElement v2(str.c_str());
	// Compare original and reparsed - this should test output reasonably well
	if((v.u == v2.u) && (v.v == v2.v)) {
		// OK
		return 0;
	} else {
		// ERROR
		OMLOGE("Bad VertexTextureElement output: %s instead of %s", str.c_str(), vetest);
		return 1;
	}
    }
    static bool TEST_VertexTextureElement() {
#ifdef DEBUG
        OMLOGI("TEST_VertexTextureElement...");
#endif
        const char *vnetest = "vt 1.0 2.0";
        const char *vnetest2 = "vn 1.0 2.0 3.0";
        const char *vnetest3 = "v 1.0 2.0 3.0";
        const char *vnetest4 = "f 1/1/1 2/2/2 3/3/3";
        const char *vnetest5 = nullptr;
        const char *vnetest6 = "";

        OMLOGI("TEST_VertexTextureElement testing: %s", vnetest);
        if(VertexTextureElement::isParsable(vnetest)) {
            VertexTextureElement v(vnetest);
#ifdef DEBUG
            OMLOGI("vt: (%f,%f)", v.u, v.v);
            OMLOGI("vt.asText(): %s", v.asText().c_str());
#endif
            if(v.u != 1.0) { OMLOGE("Bad u value: %f", v.u); return false; }
            if(v.v != 2.0) { OMLOGE("Bad v value: %f", v.v); return false; }
        } else {
            OMLOGE("Cannot parse: %s", vnetest);
            return false;
        }

        OMLOGI("TEST_VertexTextureElement testing: %s", vnetest2);
        if(VertexTextureElement::isParsable(vnetest2)) {
            OMLOGE("Mistakenly parsed: %s", vnetest2);
        }

        OMLOGI("TEST_VertexTextureElement testing: %s", vnetest3);
        if(VertexTextureElement::isParsable(vnetest3)) {
            OMLOGE("Mistakenly parsed: %s", vnetest3);
        }

        OMLOGI("TEST_VertexTextureElement testing: %s", vnetest4);
        if(VertexTextureElement::isParsable(vnetest4)) {
            OMLOGE("Mistakenly parsed: %s", vnetest4);
        }

        OMLOGI("TEST_VertexTextureElement testing: %s", vnetest5);
        if(VertexTextureElement::isParsable(vnetest5)) {
            OMLOGE("Mistakenly parsed: %s", vnetest5);
        }

        OMLOGI("TEST_VertexTextureElement testing: %s", vnetest6);
        if(VertexTextureElement::isParsable(vnetest6)) {
            OMLOGE("Mistakenly parsed: %s", vnetest6);
        }

#ifdef DEBUG
        OMLOGI("...TEST_VertexTextureElement completed (OK)");
#endif
        return true;
    }
}
#endif //NFTSIMPLEPROJ_VERTEXTEXTUREELEMENT_H