You are doing it wrong. You should be registering default prototypes for your types (i.e. Drawable* and MeshDrawable*) and not your prototypes. Then you should be exposing instances of your types and not the prototypes. Furthermore you'll have problems while casting objects containing virtual methods.

Qt Code: 
  1. #include <QCoreApplication>
  2. #include <QScriptEngine>
  3. #include <QScriptable>
  4. #include <QPoint>
  5.  
  6. class Drawable {
  7. public:
  8.     int x() const { return pt.x(); }
  9.     int y() const { return pt.y(); }
  10.     void setX(int xx) { pt.setX(xx); }
  11.     void setY(int yy) { pt.setY(yy); }
  12. private:
  13.     QPoint pt;
  14. };
  15.  
  16. class MeshDrawable : public Drawable {
  17. public:
  18.  
  19. };
  20.  
  21. class DrawablePrototype : public QObject, public QScriptable {
  22.     Q_OBJECT
  23. public:
  24.     DrawablePrototype(QObject *parent = 0) : QObject(parent) {}
  25. public slots:
  26.     void setX(int x) {
  27.         Drawable *drawable = qscriptvalue_cast<Drawable*>(thisObject());
  28.         drawable->setX(x);
  29.     }
  30.     void setY(int y) {
  31.         Drawable *drawable = qscriptvalue_cast<Drawable*>(thisObject());
  32.         drawable->setY(y);
  33.     }
  34. public:
  35.     Q_INVOKABLE virtual int x() const {
  36.         Drawable *drawable = qscriptvalue_cast<Drawable*>(thisObject());
  37.         return drawable->x();
  38.     }
  39.     Q_INVOKABLE virtual int y() const {
  40.         Drawable *drawable = qscriptvalue_cast<Drawable*>(thisObject());
  41.         return drawable->y();
  42.     }
  43.  
  44. private:
  45.  
  46. };
  47.  
  48. class MeshDrawablePrototype : public QObject, public QScriptable {
  49.     Q_OBJECT
  50. public:
  51.     MeshDrawablePrototype(QObject *parent = 0) : QObject(parent) {}
  52. public:
  53.     Q_INVOKABLE virtual int x() const {
  54.         MeshDrawable *drawable = qscriptvalue_cast<MeshDrawable*>(thisObject());
  55.         return -drawable->x();
  56.     }
  57.     Q_INVOKABLE virtual int y() const {
  58.         MeshDrawable *drawable = qscriptvalue_cast<MeshDrawable*>(thisObject());
  59.         return -drawable->y();
  60.     }
  61.  
  62. };
  63.  
  64. //QScriptValue constructDrawable(QScriptContext *context, QScriptEngine *engine) {
  65. //    if (!context->isCalledAsConstructor())
  66. //            return context->throwError(QScriptContext::SyntaxError, "please use the 'new' operator");
  67.  
  68. //    return engine->newVariant(context->thisObject(), qVariantFromValue(new Drawable));
  69. //}
  70.  
  71.  
  72. Q_DECLARE_METATYPE(Drawable*)
  73. Q_DECLARE_METATYPE(MeshDrawable*)
  74.  
  75. #include "main.moc"
  76. #include <QtDebug>
  77.  
  78. int main(int argc, char *argv[])
  79. {
  80.     QCoreApplication a(argc, argv);
  81.     QScriptEngine engine;
  82.     DrawablePrototype drawableProto;
  83.     MeshDrawablePrototype meshProto;
  84.     QScriptValue dPValue = engine.newQObject(&drawableProto);
  85.     QScriptValue mPValue = engine.newQObject(&meshProto);
  86.     engine.setDefaultPrototype(qMetaTypeId<Drawable*>(), dPValue);
  87.     engine.setDefaultPrototype(qMetaTypeId<MeshDrawable*>(), mPValue);
  88.  
  89.     mPValue.setPrototype(dPValue);
  90.  
  91.     Drawable *drawable = new Drawable;
  92.     MeshDrawable *meshDrawable = new MeshDrawable;
  93.  
  94.     QScriptValue drawableObj = engine.newVariant(qVariantFromValue<Drawable*>(drawable));
  95.     QScriptValue meshDrawableObj = engine.newVariant(qVariantFromValue<MeshDrawable*>(meshDrawable));
  96.     engine.globalObject().setProperty("drawable", drawableObj);
  97.     engine.globalObject().setProperty("meshDrawable", meshDrawableObj);
  98.  
  99.  
  100.  
  101.     qDebug() << engine.evaluate("drawable.setX(7); drawable.x()").toString();
  102.     //qDebug() << engine.evaluate("meshDrawable.setX(7); meshDrawable.x()").toString();
  103.     delete drawable;
  104.     delete meshDrawable;
  105. }
To copy to clipboard, switch view to plain text mode 

Uncommenting the second qDebug() line crashes the app, probably because the cast in setX() malforms the object.

Anyway, if the only thing you want is to indeed have wrappers for your classes then you can do so:

Qt Code: 
  1. class Drawable_Wrapper : public QObject {
  2.   Q_OBJECT
  3. public:
  4.   Drawable_Wrapper(Drawable *drawable, QObject *parent = 0) : QObject(parent) { m_drawable = drawable; }
  5. public slots:
  6.   virtual void setX(int x) { m_drawable->setX(x); }
  7. private:
  8.   Drawable *m_drawable;
  9. };
  10.  
  11. class MeshDrawable_Wrapper : public Drawable_Wrapper {
  12. Q_OBJECT
  13. public:
  14.   MeshDrawable_Wrapper(MeshDrawable *meshDrawable, QObject *parent = 0) : Drawable_Wrapper(meshDrawable, parent) {}
  15. public slots:
  16.   virtual void setX(int x) { Drawable_Wrapper::setX(-x); }
  17. };
  18.  
  19. Drawable_Wrapper wrapper(new Drawable);
  20. MeshDrawable_Wrapper wrapper2(new MeshDrawable);
  21. engine.globalObject()->setProperty("drawable", engine.newQObject(&wrapper));
  22. engine.globalObject()->setProperty("meshDrawable", engine.newQObject(&wrapper2));
To copy to clipboard, switch view to plain text mode 

Then you have inheritance on C++ side instead of using prototypes. Not exactly the same functionality though.