Thread: Combining templates with..err.. macros and overloading?

O_o

You can do this with partial specialization. You can do this with tables. You can do this with macros.

Have you considered that the functions signatures are nearly identical? That the are polymorphic by nature?

What is the purpose of an abstraction if it only duplicates complexity? What do you gain?

Have you considered that communication with shaders is elemental by nature? Have you considered that those elements are rather naturally expressed as associated with primitives like `vector' and `matrix'?

Soma

Originally Posted by phantomotap

Have you considered that the functions signatures are nearly identical? That the are polymorphic by nature?

The word 'polymorphic' along with "associated with primitives like `vector' and `matrix' " gives me some new ideas to try out, thanks.

What is the purpose of an abstraction if it only duplicates complexity? What do you gain?

Now I realize that my previous line of thought on this was rather mechanical.

Have you considered that communication with shaders is elemental by nature?

Elemental ?

Elemental ?

Communication with shaders is indivisible from the content being expressed.

Code:

uniform mat4 some_transformation;

Code:

class Matrix;
// ...
Matrix my_transform;
// ...
whatever->setUniform("some_transformation", my_transform);

Soma

This is what my design looks like :
(this approach would take a lot of manual, duplicated work (which I can't see an way out, in any other way) to implement, but should have a very clean interface)

Code:

    template<typename T,int D>
    class Vector
    {/*Would implement a generic array*/};
    
    template<> 
    class Vector<float,2>
    {
    public:
        Vector(float x_,float y_):x(x_),y(y_){};
        void sendTo(Program& p,const std::string& name)
        {
            Program::Use use(p.getHandle());
            auto location = glGetUniformLocation(p.getHandle(),name.c_str());
            glUniform2f(location,x,y);
        }
        float x,y;
    };
    typedef Vector<float,2> vec2;

I don't really see an utility of keeping the vectors generic, but this could be useful later.

O_o

You can't see a way that you can reduce the duplication even though my post shows you most of the keywords?

What if I added "CRTP", "partial functional specialization through traits", and this example?

*shrug*

Don't be confused though, I still question the utility of duplicating functionality in something is supposed to be an abstraction.

I'm just saying that you can eliminate some of the duplication cleanly by isolating the changed functionality and relying on an interface to that functionality at a higher level.

Soma

Code:

template<typename T>
struct tables
// ...
template<typename T,int D>
struct vector
// ...
STATIC_ASSERT(D >= 2 && D <= 4);
// ...
void sendTo(Program& p,const std::string& name)
{
    // ...
    tables<T>::glUniformv[D](location, D, values);
    // ...
}
// ...

O_o

It has nothing to do with the declarations of functions because they aren't functions within "GLEW".

They are pointers to functions. Specifically, they are global, probably shared, pointers to functions which get the "initialized to null" treatment with values only set during library initialization.

Your array treats these pointers as immediate values. That is a problem. (You are essentially initializing your array to null using named variables.) Treat them as references and you'll be fine. (That means declaring the array as being a pointer to the declared type and chasing the pointer at the relevant index.)

If you are worried about the indirection, make the array constant and most every compiler will give you the exact same performance.

Soma

Thanks, it worked.
I don't know if you meant an array of pointers or a a pointer itself.
I went for the former because I won't have to allocate memory explicitly for that, at the cost of having the code use another layer of indirection.

The only thing, hopefully, remaining is the constructors.
Now it takes an std::initializer_list and std::copy 's the arguments into the private std::array .
But that seems rather ficke. (as does using variable arguments)

Is there a way, say.. by using something like std::enable_if , so that the constructor 'enabled' depends on a template argument of the class ?

Also, where does CRTP figure into this? Aren't things like this based on SFINAE (like std::conditional or enable_if )?

Is there a way, say.. by using something like std::enable_if , so that the constructor 'enabled' depends on a template argument of the class?

Yes. That's one of a precious few ways to get reasonable heterogeneous parameter selection in template constructors.

However, it doesn't buy you anything here. The "SFINAE" buys you optional implementation possibilities depending on the availability of other facilities.

Consider which of the structures in the included example (C++11) gives the most reasonable feedback.

You see, "SFINAE" works here just fine, but attempting to use a facility that isn't enabled produces ugly error messages.

"SFINAE" offers a lot of possibilities, but it usually adds the overhead of the dreaded "template error messages" with which some of your clients (even if you are your only client) may not be able to cope. This will probably sound weird, but don't consider "SFINAE" an implementation technique in and of itself; it is, again, a facility that offers the possibility of selecting implementations based on the available facilities.

Also, be aware that `std::enable_if' brings problems to the table as well.

Also, where does CRTP figure into this?

I can think of about eight more ways to do this without manually duplicating all the class code for every "collision" without venturing in to macros.

You've chosen a way that you could see based on this hints I gave you.

That just isn't the way I would've done it.

What you've done as a table I would have done with traits and "CRTP" which implies something like the shorter example below (still borrowing heavily from posted code).

Code:

template<typename T>
struct typebias
// ...
template<typename T,int D>
struct countbias
// ...
template<typename B, typename T, int D>
gluniform_imp
// ...
template<typename B>
gluniform_int: public gluniform_imp<B, B::T, B::D>
//
template<typename T,int D>
struct vector: private gluniform_int<vector<T,D> >
{
// ...
STATIC_ASSERT(D >= 2 && D <= 4);
// ...
void sendTo(Program& p,const std::string& name)
{
    // ...
    glUniform(location, D, values); // a member function
    // ...
}
// ...
};
// ...

Soma

Code:

#include <iostream>
#include <type_traits>

template
<
    typename FType
  , std::size_t FElements
>
struct STest1
{
    template
    <
        typename FUnused = FType
    >
    STest1
    (
        FType fOne
      , typename std::enable_if<(FElements == 1) && std::is_same<FType, FUnused>::value>::type * fUnused = 0
    )
    {
    }
    template
    <
        typename FUnused = FType
    >
    STest1
    (
        FType fOne
      , FType fTwo
      , typename std::enable_if<(FElements == 2) && std::is_same<FType, FUnused>::value>::type * fUnused = 0
    )
    {
    }
};

template
<
    typename FType
  , std::size_t FElements
>
struct STest2
{
    STest2
    (
        FType fOne
    )
    {
        static_assert(FElements == 1, "STest constructor called with wrong number of arguments");
    }
    STest2
    (
        FType fOne
      , FType fTwo
    )
    {
        static_assert(FElements == 2, "STest constructor called with wrong number of arguments");
    }
};

int main()
{
    STest1<int, 1> s1(1);
    //STest1<int, 1> s2(1, 2);
    STest1<int, 2> s3(1, 2);
    //STest1<int, 2> s4(1);
    STest2<int, 1> s5(1);
    //STest2<int, 1> s6(1, 2);
    STest2<int, 2> s7(1, 2);
    //STest2<int, 2> s8(1);
    return(0);
}