DirectPython 11 Code

/*
    Copyright (C) 2010, Heikki Salo
    All rights reserved.
    
    Distributed under the BSD license:
    http://www.opensource.org/licenses/bsd-license.php
*/

#ifndef DP_UTILS_HPP
#define DP_UTILS_HPP

#include "stdafx.h"

typedef std::vector<D3D11_INPUT_ELEMENT_DESC> InputElementVector;

void ConvertLayoutDesc(python::object&, InputElementVector*);
python::object LayoutDescToPy(const InputElementVector&);

UINT GetElementByteSize(const InputElementVector&);

UINT GetFormatByteSize(DXGI_FORMAT, std::string* fstr=0);

void ConvertPyToC(python::object&, void*, const InputElementVector&);
python::list ConvertCToPy(void*, const InputElementVector&);

python::object CreateNamedTuple(const char* className, const char* attributes);

std::string GetLayoutFormatStr(const InputElementVector&);

void DPWarn(const char*);

inline XMVECTOR PyToXMV(const python::object& v)
{
    return XMVectorSet(python::extract<float>(v[0]), python::extract<float>(v[1]),
        python::extract<float>(v[2]), 0.0f);
}

//For Python 2.x - Python 3.x compability.

class pyunicode : boost::noncopyable {
public:
    ~pyunicode() { Py_XDECREF(value); }

    pyunicode(python::object& argument) { 
#if PY_VERSION_HEX >= 0x03000000
        value = PyObject_Str(argument.ptr());
#else
        value = PyObject_Unicode(argument.ptr());
#endif
        if (value == 0)
            DPThrow("Can't convert to unicode");
    }

    Py_ssize_t size() const { return PyUnicode_GET_SIZE(value); }
    const Py_UNICODE* c_str() const { return PyUnicode_AS_UNICODE(value); }
    const Py_UNICODE& operator [] (UINT index) const { return PyUnicode_AS_UNICODE(value)[index]; }

private:
    PyObject* value;
};


//Basic smart pointer class and some specializations.

#ifndef STRICT
    #error "scoped_object needs STRICT-handles."
#endif

template<typename T> 
struct DPReleaser { };

template<>
struct DPReleaser<HFONT> {
    void operator () (HFONT arg) { if (arg) DeleteObject(arg); }
};

//Assume COM-interface.
template<typename T> 
struct DPReleaser<T*> { 
    void operator () (T* arg) { if (arg) arg->Release(); } 
};

template<typename T>
class scoped_object {
public:
    ~scoped_object() { releaser(value); }
    scoped_object(T v = T()) : value(v) { }

    T get() { return value; }

    T* operator & () { return &value; }
    operator T () { return value; }
    T operator -> () { return value; }

private:
    T value;
    DPReleaser<T> releaser;

    const scoped_object& operator = (scoped_object&);
    scoped_object(const scoped_object&);
};

//Simple formatter helper class.

class DPFormatter {
public:

    template<typename T>
    std::ostringstream& operator << (const T& value) {
        stream << value;
        return stream;
    }

    void raise() {
        DPThrow(stream.str().c_str());
        //PyErr_SetString(PyExc_RuntimeError, stream.str().c_str());
        //python::throw_error_already_set();
    }

    void warn() {
        if (PyErr_WarnEx(PyExc_RuntimeWarning, stream.str().c_str(), 1) == -1) {
            python::throw_error_already_set();
        }
    }

private:
    std::ostringstream stream;
};

#endif