andreas/DSTEngine
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

First commit

Browse Source
This commit is contained in:
Hion-V
2021-03-07 05:58:59 +01:00
committed by Andreas Schaafsma
commit 5d4c4a054e
18475 changed files with 3309357 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

99
hGameTest/bin/linux/obj/include/openfl/display/_internal/AbstractNoise.h Normal file
View File

@@ -0,0 +1,99 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal_AbstractNoise
#define INCLUDED_openfl_display__internal_AbstractNoise
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS2(openfl,display,BitmapData)
HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
HX_DECLARE_CLASS3(openfl,display,_internal,AbstractNoise)
namespace openfl{
namespace display{
namespace _internal{
class HXCPP_CLASS_ATTRIBUTES AbstractNoise_obj : public hx::Object
{
public:
typedef hx::Object super;
typedef AbstractNoise_obj OBJ_;
AbstractNoise_obj();
public:
enum { _hx_ClassId = 0x2fc3b48e };
void __construct(int seed,int octaves,int channels,bool grayScale,Float falloff,hx::Null< bool > __o_stitch,hx::Null< Float > __o_stitch_threshold);
inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display._internal.AbstractNoise")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,true,"openfl.display._internal.AbstractNoise"); }
static hx::ObjectPtr< AbstractNoise_obj > __new(int seed,int octaves,int channels,bool grayScale,Float falloff,hx::Null< bool > __o_stitch,hx::Null< Float > __o_stitch_threshold);
static hx::ObjectPtr< AbstractNoise_obj > __alloc(hx::Ctx *_hx_ctx,int seed,int octaves,int channels,bool grayScale,Float falloff,hx::Null< bool > __o_stitch,hx::Null< Float > __o_stitch_threshold);
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~AbstractNoise_obj();
HX_DO_RTTI_ALL;
hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
void __GetFields(Array< ::String> &outFields);
static void __register();
void __Mark(HX_MARK_PARAMS);
void __Visit(HX_VISIT_PARAMS);
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("AbstractNoise",38,1b,91,2b); }
static void __boot();
static ::Dynamic __meta__;
int octaves;
bool stitch;
Float stitch_threshold;
int channels;
bool grayscale;
::Array< Float > octaves_frequencies;
::Array< Float > octaves_persistences;
Float persistence_max;
virtual void fill( ::openfl::display::BitmapData bitmap,Float _scale_x,Float _scale_y,Float _scale_z);
::Dynamic fill_dyn();
int stitching( ::openfl::display::BitmapData bitmap,int color,int px,int py,int stitch_w,int stitch_h,int width,int height);
::Dynamic stitching_dyn();
int color( ::Dynamic r_noise, ::Dynamic g_noise, ::Dynamic b_noise);
::Dynamic color_dyn();
int noiseToColor(Float noise);
::Dynamic noiseToColor_dyn();
Float fade(Float t);
::Dynamic fade_dyn();
int mixI(int x,int y,Float t);
::Dynamic mixI_dyn();
Float mix(Float x,Float y,Float t);
::Dynamic mix_dyn();
int fastfloor(Float x);
::Dynamic fastfloor_dyn();
Float dot2d(::Array< int > grad,Float x,Float y);
::Dynamic dot2d_dyn();
Float dot(::Array< int > grad,Float x,Float y,Float z);
::Dynamic dot_dyn();
void calculateOctaves(Float fPersistence);
::Dynamic calculateOctaves_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
#endif /* INCLUDED_openfl_display__internal_AbstractNoise */

73
hGameTest/bin/linux/obj/include/openfl/display/_internal/CairoBitmap.h Normal file
View File

@@ -0,0 +1,73 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal_CairoBitmap
#define INCLUDED_openfl_display__internal_CairoBitmap
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS2(openfl,display,Bitmap)
HX_DECLARE_CLASS2(openfl,display,CairoRenderer)
HX_DECLARE_CLASS2(openfl,display,DisplayObject)
HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
HX_DECLARE_CLASS3(openfl,display,_internal,CairoBitmap)
HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
namespace openfl{
namespace display{
namespace _internal{
class HXCPP_CLASS_ATTRIBUTES CairoBitmap_obj : public hx::Object
{
public:
typedef hx::Object super;
typedef CairoBitmap_obj OBJ_;
CairoBitmap_obj();
public:
enum { _hx_ClassId = 0x00e65e69 };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.CairoBitmap")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.CairoBitmap"); }
inline static hx::ObjectPtr< CairoBitmap_obj > __new() {
hx::ObjectPtr< CairoBitmap_obj > __this = new CairoBitmap_obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< CairoBitmap_obj > __alloc(hx::Ctx *_hx_ctx) {
CairoBitmap_obj *__this = (CairoBitmap_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(CairoBitmap_obj), false, "openfl.display._internal.CairoBitmap"));
*(void **)__this = CairoBitmap_obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~CairoBitmap_obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("CairoBitmap",77,62,57,c1); }
static void __boot();
static ::Dynamic __meta__;
static void render( ::openfl::display::Bitmap bitmap, ::openfl::display::CairoRenderer renderer);
static ::Dynamic render_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
#endif /* INCLUDED_openfl_display__internal_CairoBitmap */

72
hGameTest/bin/linux/obj/include/openfl/display/_internal/CairoDisplayObject.h Normal file
View File

@@ -0,0 +1,72 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal_CairoDisplayObject
#define INCLUDED_openfl_display__internal_CairoDisplayObject
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS2(openfl,display,CairoRenderer)
HX_DECLARE_CLASS2(openfl,display,DisplayObject)
HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
HX_DECLARE_CLASS3(openfl,display,_internal,CairoDisplayObject)
HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
namespace openfl{
namespace display{
namespace _internal{
class HXCPP_CLASS_ATTRIBUTES CairoDisplayObject_obj : public hx::Object
{
public:
typedef hx::Object super;
typedef CairoDisplayObject_obj OBJ_;
CairoDisplayObject_obj();
public:
enum { _hx_ClassId = 0x76d80f67 };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.CairoDisplayObject")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.CairoDisplayObject"); }
inline static hx::ObjectPtr< CairoDisplayObject_obj > __new() {
hx::ObjectPtr< CairoDisplayObject_obj > __this = new CairoDisplayObject_obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< CairoDisplayObject_obj > __alloc(hx::Ctx *_hx_ctx) {
CairoDisplayObject_obj *__this = (CairoDisplayObject_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(CairoDisplayObject_obj), false, "openfl.display._internal.CairoDisplayObject"));
*(void **)__this = CairoDisplayObject_obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~CairoDisplayObject_obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("CairoDisplayObject",19,c9,11,01); }
static void __boot();
static ::Dynamic __meta__;
static void render( ::openfl::display::DisplayObject displayObject, ::openfl::display::CairoRenderer renderer);
static ::Dynamic render_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
#endif /* INCLUDED_openfl_display__internal_CairoDisplayObject */

137
hGameTest/bin/linux/obj/include/openfl/display/_internal/CairoGraphics.h Normal file
View File

@@ -0,0 +1,137 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal_CairoGraphics
#define INCLUDED_openfl_display__internal_CairoGraphics
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS3(lime,graphics,cairo,Cairo)
HX_DECLARE_CLASS2(lime,math,Matrix3)
HX_DECLARE_CLASS2(openfl,_Vector,FloatVector)
HX_DECLARE_CLASS2(openfl,_Vector,IVector)
HX_DECLARE_CLASS2(openfl,display,BitmapData)
HX_DECLARE_CLASS2(openfl,display,CairoRenderer)
HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
HX_DECLARE_CLASS2(openfl,display,Graphics)
HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
HX_DECLARE_CLASS3(openfl,display,_internal,CairoGraphics)
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandBuffer)
HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
HX_DECLARE_CLASS2(openfl,geom,Matrix)
HX_DECLARE_CLASS2(openfl,geom,Rectangle)
namespace openfl{
namespace display{
namespace _internal{
class HXCPP_CLASS_ATTRIBUTES CairoGraphics_obj : public hx::Object
{
public:
typedef hx::Object super;
typedef CairoGraphics_obj OBJ_;
CairoGraphics_obj();
public:
enum { _hx_ClassId = 0x0e4596a9 };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.CairoGraphics")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.CairoGraphics"); }
inline static hx::ObjectPtr< CairoGraphics_obj > __new() {
hx::ObjectPtr< CairoGraphics_obj > __this = new CairoGraphics_obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< CairoGraphics_obj > __alloc(hx::Ctx *_hx_ctx) {
CairoGraphics_obj *__this = (CairoGraphics_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(CairoGraphics_obj), false, "openfl.display._internal.CairoGraphics"));
*(void **)__this = CairoGraphics_obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~CairoGraphics_obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("CairoGraphics",53,fd,12,0a); }
static void __boot();
static ::Dynamic __meta__;
static Float SIN45;
static Float TAN22;
static bool allowSmoothing;
static ::openfl::display::BitmapData bitmapFill;
static bool bitmapRepeat;
static ::openfl::geom::Rectangle bounds;
static ::lime::graphics::cairo::Cairo cairo;
static ::openfl::display::_internal::DrawCommandBuffer fillCommands;
static ::Dynamic fillPattern;
static ::openfl::geom::Matrix fillPatternMatrix;
static ::openfl::display::Graphics graphics;
static bool hasFill;
static bool hasStroke;
static bool hitTesting;
static ::openfl::geom::Matrix inversePendingMatrix;
static ::openfl::geom::Matrix pendingMatrix;
static ::openfl::display::_internal::DrawCommandBuffer strokeCommands;
static ::Dynamic strokePattern;
static ::lime::math::Matrix3 tempMatrix3;
static Float worldAlpha;
static void closePath(hx::Null< bool > strokeBefore);
static ::Dynamic closePath_dyn();
static ::Dynamic createGradientPattern( ::Dynamic type,::cpp::VirtualArray colors,::cpp::VirtualArray alphas,::cpp::VirtualArray ratios, ::openfl::geom::Matrix matrix, ::Dynamic spreadMethod, ::Dynamic interpolationMethod,Float focalPointRatio);
static ::Dynamic createGradientPattern_dyn();
static ::Dynamic createImagePattern( ::openfl::display::BitmapData bitmapFill, ::openfl::geom::Matrix matrix,bool bitmapRepeat,bool smooth);
static ::Dynamic createImagePattern_dyn();
static void drawRoundRect(Float x,Float y,Float width,Float height,Float ellipseWidth, ::Dynamic ellipseHeight);
static ::Dynamic drawRoundRect_dyn();
static void endFill();
static ::Dynamic endFill_dyn();
static void endStroke();
static ::Dynamic endStroke_dyn();
static bool hitTest( ::openfl::display::Graphics graphics,Float x,Float y);
static ::Dynamic hitTest_dyn();
static bool isCCW(Float x1,Float y1,Float x2,Float y2,Float x3,Float y3);
static ::Dynamic isCCW_dyn();
static ::Dynamic normalizeUVT( ::openfl::_Vector::FloatVector uvt,hx::Null< bool > skipT);
static ::Dynamic normalizeUVT_dyn();
static void playCommands( ::openfl::display::_internal::DrawCommandBuffer commands,hx::Null< bool > stroke);
static ::Dynamic playCommands_dyn();
static void quadraticCurveTo(Float cx,Float cy,Float x,Float y);
static ::Dynamic quadraticCurveTo_dyn();
static void render( ::openfl::display::Graphics graphics, ::openfl::display::CairoRenderer renderer);
static ::Dynamic render_dyn();
static void renderMask( ::openfl::display::Graphics graphics, ::openfl::display::CairoRenderer renderer);
static ::Dynamic renderMask_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
#endif /* INCLUDED_openfl_display__internal_CairoGraphics */

75
hGameTest/bin/linux/obj/include/openfl/display/_internal/CairoShape.h Normal file
View File

@@ -0,0 +1,75 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal_CairoShape
#define INCLUDED_openfl_display__internal_CairoShape
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS2(lime,math,Matrix3)
HX_DECLARE_CLASS2(openfl,display,CairoRenderer)
HX_DECLARE_CLASS2(openfl,display,DisplayObject)
HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
HX_DECLARE_CLASS3(openfl,display,_internal,CairoShape)
HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
namespace openfl{
namespace display{
namespace _internal{
class HXCPP_CLASS_ATTRIBUTES CairoShape_obj : public hx::Object
{
public:
typedef hx::Object super;
typedef CairoShape_obj OBJ_;
CairoShape_obj();
public:
enum { _hx_ClassId = 0x16f30e83 };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.CairoShape")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.CairoShape"); }
inline static hx::ObjectPtr< CairoShape_obj > __new() {
hx::ObjectPtr< CairoShape_obj > __this = new CairoShape_obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< CairoShape_obj > __alloc(hx::Ctx *_hx_ctx) {
CairoShape_obj *__this = (CairoShape_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(CairoShape_obj), false, "openfl.display._internal.CairoShape"));
*(void **)__this = CairoShape_obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~CairoShape_obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("CairoShape",99,39,1d,ac); }
static void __boot();
static ::Dynamic __meta__;
static ::lime::math::Matrix3 sourceTransform;
static void render( ::openfl::display::DisplayObject shape, ::openfl::display::CairoRenderer renderer);
static ::Dynamic render_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
#endif /* INCLUDED_openfl_display__internal_CairoShape */

73
hGameTest/bin/linux/obj/include/openfl/display/_internal/CanvasBitmap.h Normal file
View File

@@ -0,0 +1,73 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal_CanvasBitmap
#define INCLUDED_openfl_display__internal_CanvasBitmap
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS2(openfl,display,Bitmap)
HX_DECLARE_CLASS2(openfl,display,CanvasRenderer)
HX_DECLARE_CLASS2(openfl,display,DisplayObject)
HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
HX_DECLARE_CLASS3(openfl,display,_internal,CanvasBitmap)
HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
namespace openfl{
namespace display{
namespace _internal{
class HXCPP_CLASS_ATTRIBUTES CanvasBitmap_obj : public hx::Object
{
public:
typedef hx::Object super;
typedef CanvasBitmap_obj OBJ_;
CanvasBitmap_obj();
public:
enum { _hx_ClassId = 0x25e7f79d };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.CanvasBitmap")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.CanvasBitmap"); }
inline static hx::ObjectPtr< CanvasBitmap_obj > __new() {
hx::ObjectPtr< CanvasBitmap_obj > __this = new CanvasBitmap_obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< CanvasBitmap_obj > __alloc(hx::Ctx *_hx_ctx) {
CanvasBitmap_obj *__this = (CanvasBitmap_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(CanvasBitmap_obj), false, "openfl.display._internal.CanvasBitmap"));
*(void **)__this = CanvasBitmap_obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~CanvasBitmap_obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("CanvasBitmap",07,57,88,64); }
static void __boot();
static ::Dynamic __meta__;
static void render( ::openfl::display::Bitmap bitmap, ::openfl::display::CanvasRenderer renderer);
static ::Dynamic render_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
#endif /* INCLUDED_openfl_display__internal_CanvasBitmap */

72
hGameTest/bin/linux/obj/include/openfl/display/_internal/CanvasDisplayObject.h Normal file
View File

@@ -0,0 +1,72 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal_CanvasDisplayObject
#define INCLUDED_openfl_display__internal_CanvasDisplayObject
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS2(openfl,display,CanvasRenderer)
HX_DECLARE_CLASS2(openfl,display,DisplayObject)
HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
HX_DECLARE_CLASS3(openfl,display,_internal,CanvasDisplayObject)
HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
namespace openfl{
namespace display{
namespace _internal{
class HXCPP_CLASS_ATTRIBUTES CanvasDisplayObject_obj : public hx::Object
{
public:
typedef hx::Object super;
typedef CanvasDisplayObject_obj OBJ_;
CanvasDisplayObject_obj();
public:
enum { _hx_ClassId = 0x1294c497 };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.CanvasDisplayObject")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.CanvasDisplayObject"); }
inline static hx::ObjectPtr< CanvasDisplayObject_obj > __new() {
hx::ObjectPtr< CanvasDisplayObject_obj > __this = new CanvasDisplayObject_obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< CanvasDisplayObject_obj > __alloc(hx::Ctx *_hx_ctx) {
CanvasDisplayObject_obj *__this = (CanvasDisplayObject_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(CanvasDisplayObject_obj), false, "openfl.display._internal.CanvasDisplayObject"));
*(void **)__this = CanvasDisplayObject_obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~CanvasDisplayObject_obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("CanvasDisplayObject",89,86,07,65); }
static void __boot();
static ::Dynamic __meta__;
static void render( ::openfl::display::DisplayObject displayObject, ::openfl::display::CanvasRenderer renderer);
static ::Dynamic render_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
#endif /* INCLUDED_openfl_display__internal_CanvasDisplayObject */

135
hGameTest/bin/linux/obj/include/openfl/display/_internal/CanvasGraphics.h Normal file
View File

@@ -0,0 +1,135 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal_CanvasGraphics
#define INCLUDED_openfl_display__internal_CanvasGraphics
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS2(openfl,_Vector,FloatVector)
HX_DECLARE_CLASS2(openfl,_Vector,IVector)
HX_DECLARE_CLASS2(openfl,display,BitmapData)
HX_DECLARE_CLASS2(openfl,display,CanvasRenderer)
HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
HX_DECLARE_CLASS2(openfl,display,Graphics)
HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
HX_DECLARE_CLASS3(openfl,display,_internal,CanvasGraphics)
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandBuffer)
HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
HX_DECLARE_CLASS2(openfl,geom,Matrix)
HX_DECLARE_CLASS2(openfl,geom,Rectangle)
namespace openfl{
namespace display{
namespace _internal{
class HXCPP_CLASS_ATTRIBUTES CanvasGraphics_obj : public hx::Object
{
public:
typedef hx::Object super;
typedef CanvasGraphics_obj OBJ_;
CanvasGraphics_obj();
public:
enum { _hx_ClassId = 0x3ae9c7cd };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.CanvasGraphics")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.CanvasGraphics"); }
inline static hx::ObjectPtr< CanvasGraphics_obj > __new() {
hx::ObjectPtr< CanvasGraphics_obj > __this = new CanvasGraphics_obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< CanvasGraphics_obj > __alloc(hx::Ctx *_hx_ctx) {
CanvasGraphics_obj *__this = (CanvasGraphics_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(CanvasGraphics_obj), false, "openfl.display._internal.CanvasGraphics"));
*(void **)__this = CanvasGraphics_obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~CanvasGraphics_obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("CanvasGraphics",e3,35,d6,92); }
static void __boot();
static ::Dynamic __meta__;
static Float SIN45;
static Float TAN22;
static bool allowSmoothing;
static ::openfl::display::BitmapData bitmapFill;
static ::openfl::display::BitmapData bitmapStroke;
static bool bitmapRepeat;
static ::openfl::geom::Rectangle bounds;
static ::openfl::display::_internal::DrawCommandBuffer fillCommands;
static ::openfl::display::Graphics graphics;
static bool hasFill;
static bool hasStroke;
static bool hitTesting;
static ::openfl::geom::Matrix inversePendingMatrix;
static ::openfl::geom::Matrix pendingMatrix;
static ::openfl::display::_internal::DrawCommandBuffer strokeCommands;
static ::Dynamic windingRule;
static Float worldAlpha;
static void closePath(hx::Null< bool > strokeBefore);
static ::Dynamic closePath_dyn();
static ::Dynamic createBitmapFill( ::openfl::display::BitmapData bitmap,bool bitmapRepeat,bool smooth);
static ::Dynamic createBitmapFill_dyn();
static void createGradientPattern( ::Dynamic type,::cpp::VirtualArray colors,::cpp::VirtualArray alphas,::cpp::VirtualArray ratios, ::openfl::geom::Matrix matrix, ::Dynamic spreadMethod, ::Dynamic interpolationMethod,Float focalPointRatio);
static ::Dynamic createGradientPattern_dyn();
static void createTempPatternCanvas( ::openfl::display::BitmapData bitmap,bool repeat,int width,int height);
static ::Dynamic createTempPatternCanvas_dyn();
static void drawRoundRect(Float x,Float y,Float width,Float height,Float ellipseWidth, ::Dynamic ellipseHeight);
static ::Dynamic drawRoundRect_dyn();
static void endFill();
static ::Dynamic endFill_dyn();
static void endStroke();
static ::Dynamic endStroke_dyn();
static bool hitTest( ::openfl::display::Graphics graphics,Float x,Float y);
static ::Dynamic hitTest_dyn();
static bool isCCW(Float x1,Float y1,Float x2,Float y2,Float x3,Float y3);
static ::Dynamic isCCW_dyn();
static ::Dynamic normalizeUVT( ::openfl::_Vector::FloatVector uvt,hx::Null< bool > skipT);
static ::Dynamic normalizeUVT_dyn();
static void playCommands( ::openfl::display::_internal::DrawCommandBuffer commands,hx::Null< bool > stroke);
static ::Dynamic playCommands_dyn();
static void render( ::openfl::display::Graphics graphics, ::openfl::display::CanvasRenderer renderer);
static ::Dynamic render_dyn();
static void renderMask( ::openfl::display::Graphics graphics, ::openfl::display::CanvasRenderer renderer);
static ::Dynamic renderMask_dyn();
static void setSmoothing(bool smooth);
static ::Dynamic setSmoothing_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
#endif /* INCLUDED_openfl_display__internal_CanvasGraphics */

76
hGameTest/bin/linux/obj/include/openfl/display/_internal/Context3DBitmap.h Normal file
View File

@@ -0,0 +1,76 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal_Context3DBitmap
#define INCLUDED_openfl_display__internal_Context3DBitmap
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS2(openfl,display,Bitmap)
HX_DECLARE_CLASS2(openfl,display,DisplayObject)
HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
HX_DECLARE_CLASS2(openfl,display,OpenGLRenderer)
HX_DECLARE_CLASS3(openfl,display,_internal,Context3DBitmap)
HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
namespace openfl{
namespace display{
namespace _internal{
class HXCPP_CLASS_ATTRIBUTES Context3DBitmap_obj : public hx::Object
{
public:
typedef hx::Object super;
typedef Context3DBitmap_obj OBJ_;
Context3DBitmap_obj();
public:
enum { _hx_ClassId = 0x5a034d41 };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.Context3DBitmap")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.Context3DBitmap"); }
inline static hx::ObjectPtr< Context3DBitmap_obj > __new() {
hx::ObjectPtr< Context3DBitmap_obj > __this = new Context3DBitmap_obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< Context3DBitmap_obj > __alloc(hx::Ctx *_hx_ctx) {
Context3DBitmap_obj *__this = (Context3DBitmap_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Context3DBitmap_obj), false, "openfl.display._internal.Context3DBitmap"));
*(void **)__this = Context3DBitmap_obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~Context3DBitmap_obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("Context3DBitmap",4f,70,e2,50); }
static void __boot();
static ::Dynamic __meta__;
static void render( ::openfl::display::Bitmap bitmap, ::openfl::display::OpenGLRenderer renderer);
static ::Dynamic render_dyn();
static void renderMask( ::openfl::display::Bitmap bitmap, ::openfl::display::OpenGLRenderer renderer);
static ::Dynamic renderMask_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
#endif /* INCLUDED_openfl_display__internal_Context3DBitmap */

85
hGameTest/bin/linux/obj/include/openfl/display/_internal/Context3DBuffer.h Normal file
View File

@@ -0,0 +1,85 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal_Context3DBuffer
#define INCLUDED_openfl_display__internal_Context3DBuffer
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS2(lime,utils,ArrayBufferView)
HX_DECLARE_CLASS3(openfl,display,_internal,Context3DBuffer)
HX_DECLARE_CLASS3(openfl,display,_internal,Context3DElementType)
HX_DECLARE_CLASS2(openfl,display3D,Context3D)
HX_DECLARE_CLASS2(openfl,display3D,IndexBuffer3D)
HX_DECLARE_CLASS2(openfl,display3D,VertexBuffer3D)
HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
namespace openfl{
namespace display{
namespace _internal{
class HXCPP_CLASS_ATTRIBUTES Context3DBuffer_obj : public hx::Object
{
public:
typedef hx::Object super;
typedef Context3DBuffer_obj OBJ_;
Context3DBuffer_obj();
public:
enum { _hx_ClassId = 0x398bfa52 };
void __construct( ::openfl::display3D::Context3D context3D, ::openfl::display::_internal::Context3DElementType elementType,int elementCount,int dataPerVertex);
inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display._internal.Context3DBuffer")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,true,"openfl.display._internal.Context3DBuffer"); }
static hx::ObjectPtr< Context3DBuffer_obj > __new( ::openfl::display3D::Context3D context3D, ::openfl::display::_internal::Context3DElementType elementType,int elementCount,int dataPerVertex);
static hx::ObjectPtr< Context3DBuffer_obj > __alloc(hx::Ctx *_hx_ctx, ::openfl::display3D::Context3D context3D, ::openfl::display::_internal::Context3DElementType elementType,int elementCount,int dataPerVertex);
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~Context3DBuffer_obj();
HX_DO_RTTI_ALL;
hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
void __GetFields(Array< ::String> &outFields);
static void __register();
void __Mark(HX_MARK_PARAMS);
void __Visit(HX_VISIT_PARAMS);
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("Context3DBuffer",60,1d,6b,30); }
static void __boot();
static ::Dynamic __meta__;
static int MAX_INDEX_BUFFER_LENGTH;
static int MAX_QUADS_PER_INDEX_BUFFER;
static int MAX_QUAD_INDEX_BUFFER_LENGTH;
int dataPerVertex;
int elementCount;
::openfl::display::_internal::Context3DElementType elementType;
::Array< ::Dynamic> indexBufferData;
::Array< ::Dynamic> indexBuffers;
int indexCount;
::openfl::display3D::VertexBuffer3D vertexBuffer;
::lime::utils::ArrayBufferView vertexBufferData;
int vertexCount;
::openfl::display3D::Context3D context3D;
void drawElements(int start,hx::Null< int > length);
::Dynamic drawElements_dyn();
void flushVertexBufferData();
::Dynamic flushVertexBufferData_dyn();
void resize(int elementCount,hx::Null< int > dataPerVertex);
::Dynamic resize_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
#endif /* INCLUDED_openfl_display__internal_Context3DBuffer */

75
hGameTest/bin/linux/obj/include/openfl/display/_internal/Context3DDisplayObject.h Normal file
View File

@@ -0,0 +1,75 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal_Context3DDisplayObject
#define INCLUDED_openfl_display__internal_Context3DDisplayObject
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS2(openfl,display,DisplayObject)
HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
HX_DECLARE_CLASS2(openfl,display,OpenGLRenderer)
HX_DECLARE_CLASS3(openfl,display,_internal,Context3DDisplayObject)
HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
namespace openfl{
namespace display{
namespace _internal{
class HXCPP_CLASS_ATTRIBUTES Context3DDisplayObject_obj : public hx::Object
{
public:
typedef hx::Object super;
typedef Context3DDisplayObject_obj OBJ_;
Context3DDisplayObject_obj();
public:
enum { _hx_ClassId = 0x1b79322b };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.Context3DDisplayObject")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.Context3DDisplayObject"); }
inline static hx::ObjectPtr< Context3DDisplayObject_obj > __new() {
hx::ObjectPtr< Context3DDisplayObject_obj > __this = new Context3DDisplayObject_obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< Context3DDisplayObject_obj > __alloc(hx::Ctx *_hx_ctx) {
Context3DDisplayObject_obj *__this = (Context3DDisplayObject_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Context3DDisplayObject_obj), false, "openfl.display._internal.Context3DDisplayObject"));
*(void **)__this = Context3DDisplayObject_obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~Context3DDisplayObject_obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("Context3DDisplayObject",41,a6,42,1b); }
static void __boot();
static ::Dynamic __meta__;
static void render( ::openfl::display::DisplayObject displayObject, ::openfl::display::OpenGLRenderer renderer);
static ::Dynamic render_dyn();
static void renderMask( ::openfl::display::DisplayObject displayObject, ::openfl::display::OpenGLRenderer renderer);
static ::Dynamic renderMask_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
#endif /* INCLUDED_openfl_display__internal_Context3DDisplayObject */

41
hGameTest/bin/linux/obj/include/openfl/display/_internal/Context3DElementType.h Normal file
View File

@@ -0,0 +1,41 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal_Context3DElementType
#define INCLUDED_openfl_display__internal_Context3DElementType
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS3(openfl,display,_internal,Context3DElementType)
namespace openfl{
namespace display{
namespace _internal{
class Context3DElementType_obj : public hx::EnumBase_obj
{
typedef hx::EnumBase_obj super;
typedef Context3DElementType_obj OBJ_;
public:
Context3DElementType_obj() {};
HX_DO_ENUM_RTTI;
static void __boot();
static void __register();
static bool __GetStatic(const ::String &inName, Dynamic &outValue, hx::PropertyAccess inCallProp);
::String GetEnumName( ) const { return HX_("openfl.display._internal.Context3DElementType",12,f8,d9,53); }
::String __ToString() const { return HX_("Context3DElementType.",38,30,f0,03) + _hx_tag; }
static ::openfl::display::_internal::Context3DElementType QUADS;
static inline ::openfl::display::_internal::Context3DElementType QUADS_dyn() { return QUADS; }
static ::openfl::display::_internal::Context3DElementType TRIANGLES;
static inline ::openfl::display::_internal::Context3DElementType TRIANGLES_dyn() { return TRIANGLES; }
static ::openfl::display::_internal::Context3DElementType TRIANGLE_INDICES;
static inline ::openfl::display::_internal::Context3DElementType TRIANGLE_INDICES_dyn() { return TRIANGLE_INDICES; }
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
#endif /* INCLUDED_openfl_display__internal_Context3DElementType */

93
hGameTest/bin/linux/obj/include/openfl/display/_internal/Context3DGraphics.h Normal file
View File

@@ -0,0 +1,93 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal_Context3DGraphics
#define INCLUDED_openfl_display__internal_Context3DGraphics
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS2(openfl,display,BitmapData)
HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
HX_DECLARE_CLASS2(openfl,display,Graphics)
HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
HX_DECLARE_CLASS2(openfl,display,OpenGLRenderer)
HX_DECLARE_CLASS3(openfl,display,_internal,Context3DGraphics)
HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
HX_DECLARE_CLASS2(openfl,geom,ColorTransform)
namespace openfl{
namespace display{
namespace _internal{
class HXCPP_CLASS_ATTRIBUTES Context3DGraphics_obj : public hx::Object
{
public:
typedef hx::Object super;
typedef Context3DGraphics_obj OBJ_;
Context3DGraphics_obj();
public:
enum { _hx_ClassId = 0x15a6ae9d };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.Context3DGraphics")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.Context3DGraphics"); }
inline static hx::ObjectPtr< Context3DGraphics_obj > __new() {
hx::ObjectPtr< Context3DGraphics_obj > __this = new Context3DGraphics_obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< Context3DGraphics_obj > __alloc(hx::Ctx *_hx_ctx) {
Context3DGraphics_obj *__this = (Context3DGraphics_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Context3DGraphics_obj), false, "openfl.display._internal.Context3DGraphics"));
*(void **)__this = Context3DGraphics_obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~Context3DGraphics_obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("Context3DGraphics",2b,31,df,dc); }
static void __boot();
static ::Dynamic __meta__;
static ::openfl::display::BitmapData blankBitmapData;
static bool maskRender;
static ::openfl::geom::ColorTransform tempColorTransform;
static void buildBuffer( ::openfl::display::Graphics graphics, ::openfl::display::OpenGLRenderer renderer);
static ::Dynamic buildBuffer_dyn();
static bool isCompatible( ::openfl::display::Graphics graphics);
static ::Dynamic isCompatible_dyn();
static void render( ::openfl::display::Graphics graphics, ::openfl::display::OpenGLRenderer renderer);
static ::Dynamic render_dyn();
static void renderMask( ::openfl::display::Graphics graphics, ::openfl::display::OpenGLRenderer renderer);
static ::Dynamic renderMask_dyn();
static void resizeIndexBuffer( ::openfl::display::Graphics graphics,bool isQuad,int length);
static ::Dynamic resizeIndexBuffer_dyn();
static void resizeVertexBuffer( ::openfl::display::Graphics graphics,bool hasUVTData,int length);
static ::Dynamic resizeVertexBuffer_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
#endif /* INCLUDED_openfl_display__internal_Context3DGraphics */

70
hGameTest/bin/linux/obj/include/openfl/display/_internal/Context3DMaskShader.h Normal file
View File

@@ -0,0 +1,70 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal_Context3DMaskShader
#define INCLUDED_openfl_display__internal_Context3DMaskShader
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
#ifndef INCLUDED_openfl_display_Shader
#include <openfl/display/Shader.h>
#endif
HX_DECLARE_CLASS2(openfl,display,BitmapData)
HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
HX_DECLARE_CLASS2(openfl,display,Shader)
HX_DECLARE_CLASS2(openfl,display,ShaderInput_openfl_display_BitmapData)
HX_DECLARE_CLASS2(openfl,display,ShaderParameter_Float)
HX_DECLARE_CLASS3(openfl,display,_internal,Context3DMaskShader)
namespace openfl{
namespace display{
namespace _internal{
class HXCPP_CLASS_ATTRIBUTES Context3DMaskShader_obj : public ::openfl::display::Shader_obj
{
public:
typedef ::openfl::display::Shader_obj super;
typedef Context3DMaskShader_obj OBJ_;
Context3DMaskShader_obj();
public:
enum { _hx_ClassId = 0x74e43b67 };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display._internal.Context3DMaskShader")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,true,"openfl.display._internal.Context3DMaskShader"); }
static hx::ObjectPtr< Context3DMaskShader_obj > __new();
static hx::ObjectPtr< Context3DMaskShader_obj > __alloc(hx::Ctx *_hx_ctx);
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~Context3DMaskShader_obj();
HX_DO_RTTI_ALL;
hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
void __GetFields(Array< ::String> &outFields);
static void __register();
void __Mark(HX_MARK_PARAMS);
void __Visit(HX_VISIT_PARAMS);
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("Context3DMaskShader",91,fd,02,f3); }
static void __boot();
static ::openfl::display::BitmapData opaqueBitmapData;
::openfl::display::ShaderParameter_Float openfl_Position;
::openfl::display::ShaderParameter_Float openfl_TextureCoord;
::openfl::display::ShaderParameter_Float openfl_Matrix;
::openfl::display::ShaderInput_openfl_display_BitmapData openfl_Texture;
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
#endif /* INCLUDED_openfl_display__internal_Context3DMaskShader */

75
hGameTest/bin/linux/obj/include/openfl/display/_internal/Context3DShape.h Normal file
View File

@@ -0,0 +1,75 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal_Context3DShape
#define INCLUDED_openfl_display__internal_Context3DShape
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS2(openfl,display,DisplayObject)
HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
HX_DECLARE_CLASS2(openfl,display,OpenGLRenderer)
HX_DECLARE_CLASS3(openfl,display,_internal,Context3DShape)
HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
namespace openfl{
namespace display{
namespace _internal{
class HXCPP_CLASS_ATTRIBUTES Context3DShape_obj : public hx::Object
{
public:
typedef hx::Object super;
typedef Context3DShape_obj OBJ_;
Context3DShape_obj();
public:
enum { _hx_ClassId = 0x4bf02b73 };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.Context3DShape")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.Context3DShape"); }
inline static hx::ObjectPtr< Context3DShape_obj > __new() {
hx::ObjectPtr< Context3DShape_obj > __this = new Context3DShape_obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< Context3DShape_obj > __alloc(hx::Ctx *_hx_ctx) {
Context3DShape_obj *__this = (Context3DShape_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Context3DShape_obj), false, "openfl.display._internal.Context3DShape"));
*(void **)__this = Context3DShape_obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~Context3DShape_obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("Context3DShape",c1,ae,98,08); }
static void __boot();
static ::Dynamic __meta__;
static void render( ::openfl::display::DisplayObject shape, ::openfl::display::OpenGLRenderer renderer);
static ::Dynamic render_dyn();
static void renderMask( ::openfl::display::DisplayObject shape, ::openfl::display::OpenGLRenderer renderer);
static ::Dynamic renderMask_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
#endif /* INCLUDED_openfl_display__internal_Context3DShape */

82
hGameTest/bin/linux/obj/include/openfl/display/_internal/DOMBitmap.h Normal file
View File

@@ -0,0 +1,82 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal_DOMBitmap
#define INCLUDED_openfl_display__internal_DOMBitmap
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS2(openfl,display,Bitmap)
HX_DECLARE_CLASS2(openfl,display,DOMRenderer)
HX_DECLARE_CLASS2(openfl,display,DisplayObject)
HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
HX_DECLARE_CLASS3(openfl,display,_internal,DOMBitmap)
HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
namespace openfl{
namespace display{
namespace _internal{
class HXCPP_CLASS_ATTRIBUTES DOMBitmap_obj : public hx::Object
{
public:
typedef hx::Object super;
typedef DOMBitmap_obj OBJ_;
DOMBitmap_obj();
public:
enum { _hx_ClassId = 0x5ff00e47 };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.DOMBitmap")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.DOMBitmap"); }
inline static hx::ObjectPtr< DOMBitmap_obj > __new() {
hx::ObjectPtr< DOMBitmap_obj > __this = new DOMBitmap_obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< DOMBitmap_obj > __alloc(hx::Ctx *_hx_ctx) {
DOMBitmap_obj *__this = (DOMBitmap_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(DOMBitmap_obj), false, "openfl.display._internal.DOMBitmap"));
*(void **)__this = DOMBitmap_obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~DOMBitmap_obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("DOMBitmap",f1,57,46,56); }
static void __boot();
static ::Dynamic __meta__;
static void clear( ::openfl::display::Bitmap bitmap, ::openfl::display::DOMRenderer renderer);
static ::Dynamic clear_dyn();
static void render( ::openfl::display::Bitmap bitmap, ::openfl::display::DOMRenderer renderer);
static ::Dynamic render_dyn();
static void renderCanvas( ::openfl::display::Bitmap bitmap, ::openfl::display::DOMRenderer renderer);
static ::Dynamic renderCanvas_dyn();
static void renderImage( ::openfl::display::Bitmap bitmap, ::openfl::display::DOMRenderer renderer);
static ::Dynamic renderImage_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
#endif /* INCLUDED_openfl_display__internal_DOMBitmap */

75
hGameTest/bin/linux/obj/include/openfl/display/_internal/DOMDisplayObject.h Normal file
View File

@@ -0,0 +1,75 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal_DOMDisplayObject
#define INCLUDED_openfl_display__internal_DOMDisplayObject
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS2(openfl,display,DOMRenderer)
HX_DECLARE_CLASS2(openfl,display,DisplayObject)
HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
HX_DECLARE_CLASS3(openfl,display,_internal,DOMDisplayObject)
HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
namespace openfl{
namespace display{
namespace _internal{
class HXCPP_CLASS_ATTRIBUTES DOMDisplayObject_obj : public hx::Object
{
public:
typedef hx::Object super;
typedef DOMDisplayObject_obj OBJ_;
DOMDisplayObject_obj();
public:
enum { _hx_ClassId = 0x10b13749 };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.DOMDisplayObject")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.DOMDisplayObject"); }
inline static hx::ObjectPtr< DOMDisplayObject_obj > __new() {
hx::ObjectPtr< DOMDisplayObject_obj > __this = new DOMDisplayObject_obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< DOMDisplayObject_obj > __alloc(hx::Ctx *_hx_ctx) {
DOMDisplayObject_obj *__this = (DOMDisplayObject_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(DOMDisplayObject_obj), false, "openfl.display._internal.DOMDisplayObject"));
*(void **)__this = DOMDisplayObject_obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~DOMDisplayObject_obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("DOMDisplayObject",df,d6,25,8f); }
static void __boot();
static ::Dynamic __meta__;
static void clear( ::openfl::display::DisplayObject displayObject, ::openfl::display::DOMRenderer renderer);
static ::Dynamic clear_dyn();
static void render( ::openfl::display::DisplayObject displayObject, ::openfl::display::DOMRenderer renderer);
static ::Dynamic render_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
#endif /* INCLUDED_openfl_display__internal_DOMDisplayObject */

159
hGameTest/bin/linux/obj/include/openfl/display/_internal/DrawCommandBuffer.h Normal file
View File

@@ -0,0 +1,159 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal_DrawCommandBuffer
#define INCLUDED_openfl_display__internal_DrawCommandBuffer
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS2(openfl,_Vector,FloatVector)
HX_DECLARE_CLASS2(openfl,_Vector,IVector)
HX_DECLARE_CLASS2(openfl,_Vector,IntVector)
HX_DECLARE_CLASS2(openfl,display,BitmapData)
HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandBuffer)
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandType)
HX_DECLARE_CLASS3(openfl,display,_internal,ShaderBuffer)
HX_DECLARE_CLASS2(openfl,geom,Matrix)
namespace openfl{
namespace display{
namespace _internal{
class HXCPP_CLASS_ATTRIBUTES DrawCommandBuffer_obj : public hx::Object
{
public:
typedef hx::Object super;
typedef DrawCommandBuffer_obj OBJ_;
DrawCommandBuffer_obj();
public:
enum { _hx_ClassId = 0x4dc0dc75 };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display._internal.DrawCommandBuffer")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,true,"openfl.display._internal.DrawCommandBuffer"); }
static hx::ObjectPtr< DrawCommandBuffer_obj > __new();
static hx::ObjectPtr< DrawCommandBuffer_obj > __alloc(hx::Ctx *_hx_ctx);
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~DrawCommandBuffer_obj();
HX_DO_RTTI_ALL;
hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
void __GetFields(Array< ::String> &outFields);
static void __register();
void __Mark(HX_MARK_PARAMS);
void __Visit(HX_VISIT_PARAMS);
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("DrawCommandBuffer",e7,dd,9a,b4); }
static void __boot();
static ::Dynamic __meta__;
static ::openfl::display::_internal::DrawCommandBuffer empty;
::Array< ::Dynamic> types;
::Array< bool > b;
bool copyOnWrite;
::Array< Float > f;
::Array< ::Dynamic> ff;
::Array< int > i;
::Array< ::Dynamic> ii;
::cpp::VirtualArray o;
::openfl::display::_internal::DrawCommandBuffer append( ::openfl::display::_internal::DrawCommandBuffer other);
::Dynamic append_dyn();
void beginBitmapFill( ::openfl::display::BitmapData bitmap, ::openfl::geom::Matrix matrix,bool repeat,bool smooth);
::Dynamic beginBitmapFill_dyn();
void beginFill(int color,Float alpha);
::Dynamic beginFill_dyn();
void beginGradientFill( ::Dynamic type,::Array< int > colors,::Array< Float > alphas,::Array< int > ratios, ::openfl::geom::Matrix matrix, ::Dynamic spreadMethod, ::Dynamic interpolationMethod,Float focalPointRatio);
::Dynamic beginGradientFill_dyn();
void beginShaderFill( ::openfl::display::_internal::ShaderBuffer shaderBuffer);
::Dynamic beginShaderFill_dyn();
void clear();
::Dynamic clear_dyn();
::openfl::display::_internal::DrawCommandBuffer copy();
::Dynamic copy_dyn();
void cubicCurveTo(Float controlX1,Float controlY1,Float controlX2,Float controlY2,Float anchorX,Float anchorY);
::Dynamic cubicCurveTo_dyn();
void curveTo(Float controlX,Float controlY,Float anchorX,Float anchorY);
::Dynamic curveTo_dyn();
void destroy();
::Dynamic destroy_dyn();
void drawCircle(Float x,Float y,Float radius);
::Dynamic drawCircle_dyn();
void drawEllipse(Float x,Float y,Float width,Float height);
::Dynamic drawEllipse_dyn();
void drawQuads( ::openfl::_Vector::FloatVector rects, ::openfl::_Vector::IntVector indices, ::openfl::_Vector::FloatVector transforms);
::Dynamic drawQuads_dyn();
void drawRect(Float x,Float y,Float width,Float height);
::Dynamic drawRect_dyn();
void drawRoundRect(Float x,Float y,Float width,Float height,Float ellipseWidth, ::Dynamic ellipseHeight);
::Dynamic drawRoundRect_dyn();
void drawTriangles( ::openfl::_Vector::FloatVector vertices, ::openfl::_Vector::IntVector indices, ::openfl::_Vector::FloatVector uvtData, ::Dynamic culling);
::Dynamic drawTriangles_dyn();
void endFill();
::Dynamic endFill_dyn();
void lineBitmapStyle( ::openfl::display::BitmapData bitmap, ::openfl::geom::Matrix matrix,bool repeat,bool smooth);
::Dynamic lineBitmapStyle_dyn();
void lineGradientStyle( ::Dynamic type,::Array< int > colors,::Array< Float > alphas,::Array< int > ratios, ::openfl::geom::Matrix matrix, ::Dynamic spreadMethod, ::Dynamic interpolationMethod,Float focalPointRatio);
::Dynamic lineGradientStyle_dyn();
void lineStyle( ::Dynamic thickness,int color,Float alpha,bool pixelHinting, ::Dynamic scaleMode, ::Dynamic caps, ::Dynamic joints,Float miterLimit);
::Dynamic lineStyle_dyn();
void lineTo(Float x,Float y);
::Dynamic lineTo_dyn();
void moveTo(Float x,Float y);
::Dynamic moveTo_dyn();
void prepareWrite();
::Dynamic prepareWrite_dyn();
void overrideBlendMode( ::Dynamic blendMode);
::Dynamic overrideBlendMode_dyn();
void overrideMatrix( ::openfl::geom::Matrix matrix);
::Dynamic overrideMatrix_dyn();
void windingEvenOdd();
::Dynamic windingEvenOdd_dyn();
void windingNonZero();
::Dynamic windingNonZero_dyn();
int get_length();
::Dynamic get_length_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
#endif /* INCLUDED_openfl_display__internal_DrawCommandBuffer */

163
hGameTest/bin/linux/obj/include/openfl/display/_internal/DrawCommandReader.h Normal file
View File

@@ -0,0 +1,163 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal_DrawCommandReader
#define INCLUDED_openfl_display__internal_DrawCommandReader
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandBuffer)
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandReader)
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandType)
namespace openfl{
namespace display{
namespace _internal{
class HXCPP_CLASS_ATTRIBUTES DrawCommandReader_obj : public hx::Object
{
public:
typedef hx::Object super;
typedef DrawCommandReader_obj OBJ_;
DrawCommandReader_obj();
public:
enum { _hx_ClassId = 0x195f439c };
void __construct( ::openfl::display::_internal::DrawCommandBuffer buffer);
inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display._internal.DrawCommandReader")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,true,"openfl.display._internal.DrawCommandReader"); }
static hx::ObjectPtr< DrawCommandReader_obj > __new( ::openfl::display::_internal::DrawCommandBuffer buffer);
static hx::ObjectPtr< DrawCommandReader_obj > __alloc(hx::Ctx *_hx_ctx, ::openfl::display::_internal::DrawCommandBuffer buffer);
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~DrawCommandReader_obj();
HX_DO_RTTI_ALL;
hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
void __GetFields(Array< ::String> &outFields);
static void __register();
void __Mark(HX_MARK_PARAMS);
void __Visit(HX_VISIT_PARAMS);
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("DrawCommandReader",2a,c6,97,e0); }
static void __boot();
static ::Dynamic __meta__;
::openfl::display::_internal::DrawCommandBuffer buffer;
int bPos;
int iiPos;
int iPos;
int ffPos;
int fPos;
int oPos;
::openfl::display::_internal::DrawCommandType prev;
int tsPos;
void advance();
::Dynamic advance_dyn();
bool _hx_bool(int index);
::Dynamic _hx_bool_dyn();
void destroy();
::Dynamic destroy_dyn();
::Array< Float > fArr(int index);
::Dynamic fArr_dyn();
Float _hx_float(int index);
::Dynamic _hx_float_dyn();
::Array< int > iArr(int index);
::Dynamic iArr_dyn();
int _hx_int(int index);
::Dynamic _hx_int_dyn();
::Dynamic obj(int index);
::Dynamic obj_dyn();
::openfl::display::_internal::DrawCommandReader readBeginBitmapFill();
::Dynamic readBeginBitmapFill_dyn();
::openfl::display::_internal::DrawCommandReader readBeginFill();
::Dynamic readBeginFill_dyn();
::openfl::display::_internal::DrawCommandReader readBeginGradientFill();
::Dynamic readBeginGradientFill_dyn();
::openfl::display::_internal::DrawCommandReader readBeginShaderFill();
::Dynamic readBeginShaderFill_dyn();
::openfl::display::_internal::DrawCommandReader readCubicCurveTo();
::Dynamic readCubicCurveTo_dyn();
::openfl::display::_internal::DrawCommandReader readCurveTo();
::Dynamic readCurveTo_dyn();
::openfl::display::_internal::DrawCommandReader readDrawCircle();
::Dynamic readDrawCircle_dyn();
::openfl::display::_internal::DrawCommandReader readDrawEllipse();
::Dynamic readDrawEllipse_dyn();
::openfl::display::_internal::DrawCommandReader readDrawQuads();
::Dynamic readDrawQuads_dyn();
::openfl::display::_internal::DrawCommandReader readDrawRect();
::Dynamic readDrawRect_dyn();
::openfl::display::_internal::DrawCommandReader readDrawRoundRect();
::Dynamic readDrawRoundRect_dyn();
::openfl::display::_internal::DrawCommandReader readDrawTriangles();
::Dynamic readDrawTriangles_dyn();
::openfl::display::_internal::DrawCommandReader readEndFill();
::Dynamic readEndFill_dyn();
::openfl::display::_internal::DrawCommandReader readLineBitmapStyle();
::Dynamic readLineBitmapStyle_dyn();
::openfl::display::_internal::DrawCommandReader readLineGradientStyle();
::Dynamic readLineGradientStyle_dyn();
::openfl::display::_internal::DrawCommandReader readLineStyle();
::Dynamic readLineStyle_dyn();
::openfl::display::_internal::DrawCommandReader readLineTo();
::Dynamic readLineTo_dyn();
::openfl::display::_internal::DrawCommandReader readMoveTo();
::Dynamic readMoveTo_dyn();
::openfl::display::_internal::DrawCommandReader readOverrideBlendMode();
::Dynamic readOverrideBlendMode_dyn();
::openfl::display::_internal::DrawCommandReader readOverrideMatrix();
::Dynamic readOverrideMatrix_dyn();
::openfl::display::_internal::DrawCommandReader readWindingEvenOdd();
::Dynamic readWindingEvenOdd_dyn();
::openfl::display::_internal::DrawCommandReader readWindingNonZero();
::Dynamic readWindingNonZero_dyn();
void reset();
::Dynamic reset_dyn();
void skip( ::openfl::display::_internal::DrawCommandType type);
::Dynamic skip_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
#endif /* INCLUDED_openfl_display__internal_DrawCommandReader */

83
hGameTest/bin/linux/obj/include/openfl/display/_internal/DrawCommandType.h Normal file
View File

@@ -0,0 +1,83 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal_DrawCommandType
#define INCLUDED_openfl_display__internal_DrawCommandType
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandType)
namespace openfl{
namespace display{
namespace _internal{
class DrawCommandType_obj : public hx::EnumBase_obj
{
typedef hx::EnumBase_obj super;
typedef DrawCommandType_obj OBJ_;
public:
DrawCommandType_obj() {};
HX_DO_ENUM_RTTI;
static void __boot();
static void __register();
static bool __GetStatic(const ::String &inName, Dynamic &outValue, hx::PropertyAccess inCallProp);
::String GetEnumName( ) const { return HX_("openfl.display._internal.DrawCommandType",85,10,25,e2); }
::String __ToString() const { return HX_("DrawCommandType.",2d,29,07,6b) + _hx_tag; }
static ::openfl::display::_internal::DrawCommandType BEGIN_BITMAP_FILL;
static inline ::openfl::display::_internal::DrawCommandType BEGIN_BITMAP_FILL_dyn() { return BEGIN_BITMAP_FILL; }
static ::openfl::display::_internal::DrawCommandType BEGIN_FILL;
static inline ::openfl::display::_internal::DrawCommandType BEGIN_FILL_dyn() { return BEGIN_FILL; }
static ::openfl::display::_internal::DrawCommandType BEGIN_GRADIENT_FILL;
static inline ::openfl::display::_internal::DrawCommandType BEGIN_GRADIENT_FILL_dyn() { return BEGIN_GRADIENT_FILL; }
static ::openfl::display::_internal::DrawCommandType BEGIN_SHADER_FILL;
static inline ::openfl::display::_internal::DrawCommandType BEGIN_SHADER_FILL_dyn() { return BEGIN_SHADER_FILL; }
static ::openfl::display::_internal::DrawCommandType CUBIC_CURVE_TO;
static inline ::openfl::display::_internal::DrawCommandType CUBIC_CURVE_TO_dyn() { return CUBIC_CURVE_TO; }
static ::openfl::display::_internal::DrawCommandType CURVE_TO;
static inline ::openfl::display::_internal::DrawCommandType CURVE_TO_dyn() { return CURVE_TO; }
static ::openfl::display::_internal::DrawCommandType DRAW_CIRCLE;
static inline ::openfl::display::_internal::DrawCommandType DRAW_CIRCLE_dyn() { return DRAW_CIRCLE; }
static ::openfl::display::_internal::DrawCommandType DRAW_ELLIPSE;
static inline ::openfl::display::_internal::DrawCommandType DRAW_ELLIPSE_dyn() { return DRAW_ELLIPSE; }
static ::openfl::display::_internal::DrawCommandType DRAW_QUADS;
static inline ::openfl::display::_internal::DrawCommandType DRAW_QUADS_dyn() { return DRAW_QUADS; }
static ::openfl::display::_internal::DrawCommandType DRAW_RECT;
static inline ::openfl::display::_internal::DrawCommandType DRAW_RECT_dyn() { return DRAW_RECT; }
static ::openfl::display::_internal::DrawCommandType DRAW_ROUND_RECT;
static inline ::openfl::display::_internal::DrawCommandType DRAW_ROUND_RECT_dyn() { return DRAW_ROUND_RECT; }
static ::openfl::display::_internal::DrawCommandType DRAW_TILES;
static inline ::openfl::display::_internal::DrawCommandType DRAW_TILES_dyn() { return DRAW_TILES; }
static ::openfl::display::_internal::DrawCommandType DRAW_TRIANGLES;
static inline ::openfl::display::_internal::DrawCommandType DRAW_TRIANGLES_dyn() { return DRAW_TRIANGLES; }
static ::openfl::display::_internal::DrawCommandType END_FILL;
static inline ::openfl::display::_internal::DrawCommandType END_FILL_dyn() { return END_FILL; }
static ::openfl::display::_internal::DrawCommandType LINE_BITMAP_STYLE;
static inline ::openfl::display::_internal::DrawCommandType LINE_BITMAP_STYLE_dyn() { return LINE_BITMAP_STYLE; }
static ::openfl::display::_internal::DrawCommandType LINE_GRADIENT_STYLE;
static inline ::openfl::display::_internal::DrawCommandType LINE_GRADIENT_STYLE_dyn() { return LINE_GRADIENT_STYLE; }
static ::openfl::display::_internal::DrawCommandType LINE_STYLE;
static inline ::openfl::display::_internal::DrawCommandType LINE_STYLE_dyn() { return LINE_STYLE; }
static ::openfl::display::_internal::DrawCommandType LINE_TO;
static inline ::openfl::display::_internal::DrawCommandType LINE_TO_dyn() { return LINE_TO; }
static ::openfl::display::_internal::DrawCommandType MOVE_TO;
static inline ::openfl::display::_internal::DrawCommandType MOVE_TO_dyn() { return MOVE_TO; }
static ::openfl::display::_internal::DrawCommandType OVERRIDE_BLEND_MODE;
static inline ::openfl::display::_internal::DrawCommandType OVERRIDE_BLEND_MODE_dyn() { return OVERRIDE_BLEND_MODE; }
static ::openfl::display::_internal::DrawCommandType OVERRIDE_MATRIX;
static inline ::openfl::display::_internal::DrawCommandType OVERRIDE_MATRIX_dyn() { return OVERRIDE_MATRIX; }
static ::openfl::display::_internal::DrawCommandType UNKNOWN;
static inline ::openfl::display::_internal::DrawCommandType UNKNOWN_dyn() { return UNKNOWN; }
static ::openfl::display::_internal::DrawCommandType WINDING_EVEN_ODD;
static inline ::openfl::display::_internal::DrawCommandType WINDING_EVEN_ODD_dyn() { return WINDING_EVEN_ODD; }
static ::openfl::display::_internal::DrawCommandType WINDING_NON_ZERO;
static inline ::openfl::display::_internal::DrawCommandType WINDING_NON_ZERO_dyn() { return WINDING_NON_ZERO; }
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
#endif /* INCLUDED_openfl_display__internal_DrawCommandType */

78
hGameTest/bin/linux/obj/include/openfl/display/_internal/PerlinNoise.h Normal file
View File

@@ -0,0 +1,78 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal_PerlinNoise
#define INCLUDED_openfl_display__internal_PerlinNoise
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
#ifndef INCLUDED_openfl_display__internal_AbstractNoise
#include <openfl/display/_internal/AbstractNoise.h>
#endif
HX_DECLARE_CLASS2(openfl,display,BitmapData)
HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
HX_DECLARE_CLASS3(openfl,display,_internal,AbstractNoise)
HX_DECLARE_CLASS3(openfl,display,_internal,PerlinNoise)
namespace openfl{
namespace display{
namespace _internal{
class HXCPP_CLASS_ATTRIBUTES PerlinNoise_obj : public ::openfl::display::_internal::AbstractNoise_obj
{
public:
typedef ::openfl::display::_internal::AbstractNoise_obj super;
typedef PerlinNoise_obj OBJ_;
PerlinNoise_obj();
public:
enum { _hx_ClassId = 0x0e4f2070 };
void __construct(int seed,int octaves,int channels,bool grayScale,Float falloff,hx::Null< bool > __o_stitch,hx::Null< Float > __o_stitch_threshold);
inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display._internal.PerlinNoise")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,true,"openfl.display._internal.PerlinNoise"); }
static hx::ObjectPtr< PerlinNoise_obj > __new(int seed,int octaves,int channels,bool grayScale,Float falloff,hx::Null< bool > __o_stitch,hx::Null< Float > __o_stitch_threshold);
static hx::ObjectPtr< PerlinNoise_obj > __alloc(hx::Ctx *_hx_ctx,int seed,int octaves,int channels,bool grayScale,Float falloff,hx::Null< bool > __o_stitch,hx::Null< Float > __o_stitch_threshold);
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~PerlinNoise_obj();
HX_DO_RTTI_ALL;
hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
void __GetFields(Array< ::String> &outFields);
static void __register();
void __Mark(HX_MARK_PARAMS);
void __Visit(HX_VISIT_PARAMS);
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("PerlinNoise",46,1c,2b,70); }
static void __boot();
static ::Dynamic __meta__;
static ::Array< int > P;
::Array< int > p_perm;
Float x_offset;
Float y_offset;
Float z_offset;
Float base_factor;
void fill( ::openfl::display::BitmapData bitmap,Float _scale_x,Float _scale_y,Float _scale_z);
Float noise(Float x,Float y,Float z);
::Dynamic noise_dyn();
void setSeed(int seed);
::Dynamic setSeed_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
#endif /* INCLUDED_openfl_display__internal_PerlinNoise */

106
hGameTest/bin/linux/obj/include/openfl/display/_internal/SamplerState.h Normal file
View File

@@ -0,0 +1,106 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal_SamplerState
#define INCLUDED_openfl_display__internal_SamplerState
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_STACK_FRAME(_hx_pos_2927c9d004f07aab_25_new)
HX_DECLARE_CLASS3(openfl,display,_internal,SamplerState)
namespace openfl{
namespace display{
namespace _internal{
class HXCPP_CLASS_ATTRIBUTES SamplerState_obj : public hx::Object
{
public:
typedef hx::Object super;
typedef SamplerState_obj OBJ_;
SamplerState_obj();
public:
enum { _hx_ClassId = 0x1348bc3b };
void __construct( ::Dynamic __o_wrap, ::Dynamic __o_filter, ::Dynamic __o_mipfilter,hx::Null< Float > __o_lodBias,hx::Null< bool > __o_ignoreSampler,hx::Null< bool > __o_centroid,hx::Null< bool > __o_textureAlpha);
inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display._internal.SamplerState")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,true,"openfl.display._internal.SamplerState"); }
inline static hx::ObjectPtr< SamplerState_obj > __new( ::Dynamic __o_wrap, ::Dynamic __o_filter, ::Dynamic __o_mipfilter,hx::Null< Float > __o_lodBias,hx::Null< bool > __o_ignoreSampler,hx::Null< bool > __o_centroid,hx::Null< bool > __o_textureAlpha) {
hx::ObjectPtr< SamplerState_obj > __this = new SamplerState_obj();
__this->__construct(__o_wrap,__o_filter,__o_mipfilter,__o_lodBias,__o_ignoreSampler,__o_centroid,__o_textureAlpha);
return __this;
}
inline static hx::ObjectPtr< SamplerState_obj > __alloc(hx::Ctx *_hx_ctx, ::Dynamic __o_wrap, ::Dynamic __o_filter, ::Dynamic __o_mipfilter,hx::Null< Float > __o_lodBias,hx::Null< bool > __o_ignoreSampler,hx::Null< bool > __o_centroid,hx::Null< bool > __o_textureAlpha) {
SamplerState_obj *__this = (SamplerState_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(SamplerState_obj), true, "openfl.display._internal.SamplerState"));
*(void **)__this = SamplerState_obj::_hx_vtable;
{
::Dynamic wrap = __o_wrap;
if (hx::IsNull(__o_wrap)) wrap = 0;
::Dynamic filter = __o_filter;
if (hx::IsNull(__o_filter)) filter = 5;
::Dynamic mipfilter = __o_mipfilter;
if (hx::IsNull(__o_mipfilter)) mipfilter = 2;
Float lodBias = __o_lodBias.Default(((Float)0.0));
bool ignoreSampler = __o_ignoreSampler.Default(false);
bool centroid = __o_centroid.Default(false);
bool textureAlpha = __o_textureAlpha.Default(false);
HX_STACKFRAME(&_hx_pos_2927c9d004f07aab_25_new)
HXLINE( 26) ( ( ::openfl::display::_internal::SamplerState)(__this) )->wrap = wrap;
HXLINE( 27) ( ( ::openfl::display::_internal::SamplerState)(__this) )->filter = filter;
HXLINE( 28) ( ( ::openfl::display::_internal::SamplerState)(__this) )->mipfilter = mipfilter;
HXLINE( 29) ( ( ::openfl::display::_internal::SamplerState)(__this) )->lodBias = lodBias;
HXLINE( 30) ( ( ::openfl::display::_internal::SamplerState)(__this) )->ignoreSampler = ignoreSampler;
HXLINE( 31) ( ( ::openfl::display::_internal::SamplerState)(__this) )->centroid = centroid;
HXLINE( 32) ( ( ::openfl::display::_internal::SamplerState)(__this) )->textureAlpha = textureAlpha;
}
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~SamplerState_obj();
HX_DO_RTTI_ALL;
hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
void __GetFields(Array< ::String> &outFields);
static void __register();
void __Mark(HX_MARK_PARAMS);
void __Visit(HX_VISIT_PARAMS);
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("SamplerState",09,30,d2,83); }
static void __boot();
static ::Dynamic __meta__;
bool centroid;
::Dynamic filter;
bool ignoreSampler;
Float lodBias;
::Dynamic mipfilter;
bool mipmapGenerated;
bool textureAlpha;
::Dynamic wrap;
::openfl::display::_internal::SamplerState clone();
::Dynamic clone_dyn();
void copyFrom( ::openfl::display::_internal::SamplerState other);
::Dynamic copyFrom_dyn();
bool equals( ::openfl::display::_internal::SamplerState other);
::Dynamic equals_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
#endif /* INCLUDED_openfl_display__internal_SamplerState */

110
hGameTest/bin/linux/obj/include/openfl/display/_internal/ShaderBuffer.h Normal file
View File

@@ -0,0 +1,110 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal_ShaderBuffer
#define INCLUDED_openfl_display__internal_ShaderBuffer
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS3(lime,graphics,opengl,GLObject)
HX_DECLARE_CLASS2(lime,utils,ArrayBufferView)
HX_DECLARE_CLASS2(openfl,display,BitmapData)
HX_DECLARE_CLASS2(openfl,display,GraphicsShader)
HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
HX_DECLARE_CLASS2(openfl,display,Shader)
HX_DECLARE_CLASS2(openfl,display,ShaderInput_openfl_display_BitmapData)
HX_DECLARE_CLASS2(openfl,display,ShaderParameter_Bool)
HX_DECLARE_CLASS2(openfl,display,ShaderParameter_Float)
HX_DECLARE_CLASS2(openfl,display,ShaderParameter_Int)
HX_DECLARE_CLASS3(openfl,display,_internal,ShaderBuffer)
namespace openfl{
namespace display{
namespace _internal{
class HXCPP_CLASS_ATTRIBUTES ShaderBuffer_obj : public hx::Object
{
public:
typedef hx::Object super;
typedef ShaderBuffer_obj OBJ_;
ShaderBuffer_obj();
public:
enum { _hx_ClassId = 0x3434098f };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display._internal.ShaderBuffer")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,true,"openfl.display._internal.ShaderBuffer"); }
static hx::ObjectPtr< ShaderBuffer_obj > __new();
static hx::ObjectPtr< ShaderBuffer_obj > __alloc(hx::Ctx *_hx_ctx);
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~ShaderBuffer_obj();
HX_DO_RTTI_ALL;
hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
void __GetFields(Array< ::String> &outFields);
static void __register();
void __Mark(HX_MARK_PARAMS);
void __Visit(HX_VISIT_PARAMS);
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("ShaderBuffer",25,a6,8f,08); }
static void __boot();
static ::Dynamic __meta__;
int inputCount;
::Array< ::Dynamic> inputRefs;
::Array< ::Dynamic> inputFilter;
::Array< ::Dynamic> inputMipFilter;
::Array< ::Dynamic> inputs;
::Array< ::Dynamic> inputWrap;
int overrideBoolCount;
::Array< ::String > overrideBoolNames;
::Array< ::Dynamic> overrideBoolValues;
int overrideFloatCount;
::Array< ::String > overrideFloatNames;
::Array< ::Dynamic> overrideFloatValues;
int overrideIntCount;
::Array< ::String > overrideIntNames;
::Array< ::Dynamic> overrideIntValues;
int paramBoolCount;
int paramCount;
::lime::utils::ArrayBufferView paramData;
::lime::graphics::opengl::GLObject paramDataBuffer;
int paramDataLength;
int paramFloatCount;
int paramIntCount;
::Array< int > paramLengths;
::Array< int > paramPositions;
::Array< ::Dynamic> paramRefs_Bool;
::Array< ::Dynamic> paramRefs_Float;
::Array< ::Dynamic> paramRefs_Int;
::Array< int > paramTypes;
::openfl::display::GraphicsShader shader;
void addBoolOverride(::String name,::Array< bool > values);
::Dynamic addBoolOverride_dyn();
void addFloatOverride(::String name,::Array< Float > values);
::Dynamic addFloatOverride_dyn();
void addIntOverride(::String name,::Array< int > values);
::Dynamic addIntOverride_dyn();
void clearOverride();
::Dynamic clearOverride_dyn();
void update( ::openfl::display::GraphicsShader shader);
::Dynamic update_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
#endif /* INCLUDED_openfl_display__internal_ShaderBuffer */

82
hGameTest/bin/linux/obj/include/openfl/display/_internal/_DrawCommandReader/BeginBitmapFillView_Impl_.h Normal file
View File

@@ -0,0 +1,82 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal__DrawCommandReader_BeginBitmapFillView_Impl_
#define INCLUDED_openfl_display__internal__DrawCommandReader_BeginBitmapFillView_Impl_
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS2(openfl,display,BitmapData)
HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandReader)
HX_DECLARE_CLASS4(openfl,display,_internal,_DrawCommandReader,BeginBitmapFillView_Impl_)
HX_DECLARE_CLASS2(openfl,geom,Matrix)
namespace openfl{
namespace display{
namespace _internal{
namespace _DrawCommandReader{
class HXCPP_CLASS_ATTRIBUTES BeginBitmapFillView_Impl__obj : public hx::Object
{
public:
typedef hx::Object super;
typedef BeginBitmapFillView_Impl__obj OBJ_;
BeginBitmapFillView_Impl__obj();
public:
enum { _hx_ClassId = 0x0f797dab };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal._DrawCommandReader.BeginBitmapFillView_Impl_")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal._DrawCommandReader.BeginBitmapFillView_Impl_"); }
inline static hx::ObjectPtr< BeginBitmapFillView_Impl__obj > __new() {
hx::ObjectPtr< BeginBitmapFillView_Impl__obj > __this = new BeginBitmapFillView_Impl__obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< BeginBitmapFillView_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
BeginBitmapFillView_Impl__obj *__this = (BeginBitmapFillView_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(BeginBitmapFillView_Impl__obj), false, "openfl.display._internal._DrawCommandReader.BeginBitmapFillView_Impl_"));
*(void **)__this = BeginBitmapFillView_Impl__obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~BeginBitmapFillView_Impl__obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("BeginBitmapFillView_Impl_",20,66,b3,b0); }
static ::openfl::display::_internal::DrawCommandReader _new( ::openfl::display::_internal::DrawCommandReader d);
static ::Dynamic _new_dyn();
static ::openfl::display::BitmapData get_bitmap( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_bitmap_dyn();
static ::openfl::geom::Matrix get_matrix( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_matrix_dyn();
static bool get_repeat( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_repeat_dyn();
static bool get_smooth( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_smooth_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
} // end namespace _DrawCommandReader
#endif /* INCLUDED_openfl_display__internal__DrawCommandReader_BeginBitmapFillView_Impl_ */

73
hGameTest/bin/linux/obj/include/openfl/display/_internal/_DrawCommandReader/BeginFillView_Impl_.h Normal file
View File

@@ -0,0 +1,73 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal__DrawCommandReader_BeginFillView_Impl_
#define INCLUDED_openfl_display__internal__DrawCommandReader_BeginFillView_Impl_
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandReader)
HX_DECLARE_CLASS4(openfl,display,_internal,_DrawCommandReader,BeginFillView_Impl_)
namespace openfl{
namespace display{
namespace _internal{
namespace _DrawCommandReader{
class HXCPP_CLASS_ATTRIBUTES BeginFillView_Impl__obj : public hx::Object
{
public:
typedef hx::Object super;
typedef BeginFillView_Impl__obj OBJ_;
BeginFillView_Impl__obj();
public:
enum { _hx_ClassId = 0x55670294 };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal._DrawCommandReader.BeginFillView_Impl_")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal._DrawCommandReader.BeginFillView_Impl_"); }
inline static hx::ObjectPtr< BeginFillView_Impl__obj > __new() {
hx::ObjectPtr< BeginFillView_Impl__obj > __this = new BeginFillView_Impl__obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< BeginFillView_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
BeginFillView_Impl__obj *__this = (BeginFillView_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(BeginFillView_Impl__obj), false, "openfl.display._internal._DrawCommandReader.BeginFillView_Impl_"));
*(void **)__this = BeginFillView_Impl__obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~BeginFillView_Impl__obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("BeginFillView_Impl_",11,09,a8,37); }
static ::openfl::display::_internal::DrawCommandReader _new( ::openfl::display::_internal::DrawCommandReader d);
static ::Dynamic _new_dyn();
static int get_color( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_color_dyn();
static Float get_alpha( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_alpha_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
} // end namespace _DrawCommandReader
#endif /* INCLUDED_openfl_display__internal__DrawCommandReader_BeginFillView_Impl_ */

92
hGameTest/bin/linux/obj/include/openfl/display/_internal/_DrawCommandReader/BeginGradientFillView_Impl_.h Normal file
View File

@@ -0,0 +1,92 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal__DrawCommandReader_BeginGradientFillView_Impl_
#define INCLUDED_openfl_display__internal__DrawCommandReader_BeginGradientFillView_Impl_
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandReader)
HX_DECLARE_CLASS4(openfl,display,_internal,_DrawCommandReader,BeginGradientFillView_Impl_)
HX_DECLARE_CLASS2(openfl,geom,Matrix)
namespace openfl{
namespace display{
namespace _internal{
namespace _DrawCommandReader{
class HXCPP_CLASS_ATTRIBUTES BeginGradientFillView_Impl__obj : public hx::Object
{
public:
typedef hx::Object super;
typedef BeginGradientFillView_Impl__obj OBJ_;
BeginGradientFillView_Impl__obj();
public:
enum { _hx_ClassId = 0x2d533c6c };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal._DrawCommandReader.BeginGradientFillView_Impl_")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal._DrawCommandReader.BeginGradientFillView_Impl_"); }
inline static hx::ObjectPtr< BeginGradientFillView_Impl__obj > __new() {
hx::ObjectPtr< BeginGradientFillView_Impl__obj > __this = new BeginGradientFillView_Impl__obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< BeginGradientFillView_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
BeginGradientFillView_Impl__obj *__this = (BeginGradientFillView_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(BeginGradientFillView_Impl__obj), false, "openfl.display._internal._DrawCommandReader.BeginGradientFillView_Impl_"));
*(void **)__this = BeginGradientFillView_Impl__obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~BeginGradientFillView_Impl__obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("BeginGradientFillView_Impl_",21,ec,2f,ff); }
static ::openfl::display::_internal::DrawCommandReader _new( ::openfl::display::_internal::DrawCommandReader d);
static ::Dynamic _new_dyn();
static ::Dynamic get_type( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_type_dyn();
static ::Array< int > get_colors( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_colors_dyn();
static ::Array< Float > get_alphas( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_alphas_dyn();
static ::Array< int > get_ratios( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_ratios_dyn();
static ::openfl::geom::Matrix get_matrix( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_matrix_dyn();
static ::Dynamic get_spreadMethod( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_spreadMethod_dyn();
static ::Dynamic get_interpolationMethod( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_interpolationMethod_dyn();
static Float get_focalPointRatio( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_focalPointRatio_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
} // end namespace _DrawCommandReader
#endif /* INCLUDED_openfl_display__internal__DrawCommandReader_BeginGradientFillView_Impl_ */

71
hGameTest/bin/linux/obj/include/openfl/display/_internal/_DrawCommandReader/BeginShaderFillView_Impl_.h Normal file
View File

@@ -0,0 +1,71 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal__DrawCommandReader_BeginShaderFillView_Impl_
#define INCLUDED_openfl_display__internal__DrawCommandReader_BeginShaderFillView_Impl_
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandReader)
HX_DECLARE_CLASS3(openfl,display,_internal,ShaderBuffer)
HX_DECLARE_CLASS4(openfl,display,_internal,_DrawCommandReader,BeginShaderFillView_Impl_)
namespace openfl{
namespace display{
namespace _internal{
namespace _DrawCommandReader{
class HXCPP_CLASS_ATTRIBUTES BeginShaderFillView_Impl__obj : public hx::Object
{
public:
typedef hx::Object super;
typedef BeginShaderFillView_Impl__obj OBJ_;
BeginShaderFillView_Impl__obj();
public:
enum { _hx_ClassId = 0x25d61f61 };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal._DrawCommandReader.BeginShaderFillView_Impl_")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal._DrawCommandReader.BeginShaderFillView_Impl_"); }
inline static hx::ObjectPtr< BeginShaderFillView_Impl__obj > __new() {
hx::ObjectPtr< BeginShaderFillView_Impl__obj > __this = new BeginShaderFillView_Impl__obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< BeginShaderFillView_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
BeginShaderFillView_Impl__obj *__this = (BeginShaderFillView_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(BeginShaderFillView_Impl__obj), false, "openfl.display._internal._DrawCommandReader.BeginShaderFillView_Impl_"));
*(void **)__this = BeginShaderFillView_Impl__obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~BeginShaderFillView_Impl__obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("BeginShaderFillView_Impl_",d6,07,10,c7); }
static ::openfl::display::_internal::DrawCommandReader _new( ::openfl::display::_internal::DrawCommandReader d);
static ::Dynamic _new_dyn();
static ::openfl::display::_internal::ShaderBuffer get_shaderBuffer( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_shaderBuffer_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
} // end namespace _DrawCommandReader
#endif /* INCLUDED_openfl_display__internal__DrawCommandReader_BeginShaderFillView_Impl_ */

85
hGameTest/bin/linux/obj/include/openfl/display/_internal/_DrawCommandReader/CubicCurveToView_Impl_.h Normal file
View File

@@ -0,0 +1,85 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal__DrawCommandReader_CubicCurveToView_Impl_
#define INCLUDED_openfl_display__internal__DrawCommandReader_CubicCurveToView_Impl_
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandReader)
HX_DECLARE_CLASS4(openfl,display,_internal,_DrawCommandReader,CubicCurveToView_Impl_)
namespace openfl{
namespace display{
namespace _internal{
namespace _DrawCommandReader{
class HXCPP_CLASS_ATTRIBUTES CubicCurveToView_Impl__obj : public hx::Object
{
public:
typedef hx::Object super;
typedef CubicCurveToView_Impl__obj OBJ_;
CubicCurveToView_Impl__obj();
public:
enum { _hx_ClassId = 0x5e6d37de };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal._DrawCommandReader.CubicCurveToView_Impl_")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal._DrawCommandReader.CubicCurveToView_Impl_"); }
inline static hx::ObjectPtr< CubicCurveToView_Impl__obj > __new() {
hx::ObjectPtr< CubicCurveToView_Impl__obj > __this = new CubicCurveToView_Impl__obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< CubicCurveToView_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
CubicCurveToView_Impl__obj *__this = (CubicCurveToView_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(CubicCurveToView_Impl__obj), false, "openfl.display._internal._DrawCommandReader.CubicCurveToView_Impl_"));
*(void **)__this = CubicCurveToView_Impl__obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~CubicCurveToView_Impl__obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("CubicCurveToView_Impl_",e5,20,46,a0); }
static ::openfl::display::_internal::DrawCommandReader _new( ::openfl::display::_internal::DrawCommandReader d);
static ::Dynamic _new_dyn();
static Float get_controlX1( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_controlX1_dyn();
static Float get_controlY1( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_controlY1_dyn();
static Float get_controlX2( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_controlX2_dyn();
static Float get_controlY2( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_controlY2_dyn();
static Float get_anchorX( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_anchorX_dyn();
static Float get_anchorY( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_anchorY_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
} // end namespace _DrawCommandReader
#endif /* INCLUDED_openfl_display__internal__DrawCommandReader_CubicCurveToView_Impl_ */

79
hGameTest/bin/linux/obj/include/openfl/display/_internal/_DrawCommandReader/CurveToView_Impl_.h Normal file
View File

@@ -0,0 +1,79 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal__DrawCommandReader_CurveToView_Impl_
#define INCLUDED_openfl_display__internal__DrawCommandReader_CurveToView_Impl_
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandReader)
HX_DECLARE_CLASS4(openfl,display,_internal,_DrawCommandReader,CurveToView_Impl_)
namespace openfl{
namespace display{
namespace _internal{
namespace _DrawCommandReader{
class HXCPP_CLASS_ATTRIBUTES CurveToView_Impl__obj : public hx::Object
{
public:
typedef hx::Object super;
typedef CurveToView_Impl__obj OBJ_;
CurveToView_Impl__obj();
public:
enum { _hx_ClassId = 0x68b3d72e };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal._DrawCommandReader.CurveToView_Impl_")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal._DrawCommandReader.CurveToView_Impl_"); }
inline static hx::ObjectPtr< CurveToView_Impl__obj > __new() {
hx::ObjectPtr< CurveToView_Impl__obj > __this = new CurveToView_Impl__obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< CurveToView_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
CurveToView_Impl__obj *__this = (CurveToView_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(CurveToView_Impl__obj), false, "openfl.display._internal._DrawCommandReader.CurveToView_Impl_"));
*(void **)__this = CurveToView_Impl__obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~CurveToView_Impl__obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("CurveToView_Impl_",4f,1d,e9,aa); }
static ::openfl::display::_internal::DrawCommandReader _new( ::openfl::display::_internal::DrawCommandReader d);
static ::Dynamic _new_dyn();
static Float get_controlX( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_controlX_dyn();
static Float get_controlY( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_controlY_dyn();
static Float get_anchorX( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_anchorX_dyn();
static Float get_anchorY( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_anchorY_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
} // end namespace _DrawCommandReader
#endif /* INCLUDED_openfl_display__internal__DrawCommandReader_CurveToView_Impl_ */

76
hGameTest/bin/linux/obj/include/openfl/display/_internal/_DrawCommandReader/DrawCircleView_Impl_.h Normal file
View File

@@ -0,0 +1,76 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal__DrawCommandReader_DrawCircleView_Impl_
#define INCLUDED_openfl_display__internal__DrawCommandReader_DrawCircleView_Impl_
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandReader)
HX_DECLARE_CLASS4(openfl,display,_internal,_DrawCommandReader,DrawCircleView_Impl_)
namespace openfl{
namespace display{
namespace _internal{
namespace _DrawCommandReader{
class HXCPP_CLASS_ATTRIBUTES DrawCircleView_Impl__obj : public hx::Object
{
public:
typedef hx::Object super;
typedef DrawCircleView_Impl__obj OBJ_;
DrawCircleView_Impl__obj();
public:
enum { _hx_ClassId = 0x210e438e };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal._DrawCommandReader.DrawCircleView_Impl_")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal._DrawCommandReader.DrawCircleView_Impl_"); }
inline static hx::ObjectPtr< DrawCircleView_Impl__obj > __new() {
hx::ObjectPtr< DrawCircleView_Impl__obj > __this = new DrawCircleView_Impl__obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< DrawCircleView_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
DrawCircleView_Impl__obj *__this = (DrawCircleView_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(DrawCircleView_Impl__obj), false, "openfl.display._internal._DrawCommandReader.DrawCircleView_Impl_"));
*(void **)__this = DrawCircleView_Impl__obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~DrawCircleView_Impl__obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("DrawCircleView_Impl_",39,2f,a7,15); }
static ::openfl::display::_internal::DrawCommandReader _new( ::openfl::display::_internal::DrawCommandReader d);
static ::Dynamic _new_dyn();
static Float get_x( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_x_dyn();
static Float get_y( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_y_dyn();
static Float get_radius( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_radius_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
} // end namespace _DrawCommandReader
#endif /* INCLUDED_openfl_display__internal__DrawCommandReader_DrawCircleView_Impl_ */

79
hGameTest/bin/linux/obj/include/openfl/display/_internal/_DrawCommandReader/DrawEllipseView_Impl_.h Normal file
View File

@@ -0,0 +1,79 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal__DrawCommandReader_DrawEllipseView_Impl_
#define INCLUDED_openfl_display__internal__DrawCommandReader_DrawEllipseView_Impl_
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandReader)
HX_DECLARE_CLASS4(openfl,display,_internal,_DrawCommandReader,DrawEllipseView_Impl_)
namespace openfl{
namespace display{
namespace _internal{
namespace _DrawCommandReader{
class HXCPP_CLASS_ATTRIBUTES DrawEllipseView_Impl__obj : public hx::Object
{
public:
typedef hx::Object super;
typedef DrawEllipseView_Impl__obj OBJ_;
DrawEllipseView_Impl__obj();
public:
enum { _hx_ClassId = 0x6bbbc48a };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal._DrawCommandReader.DrawEllipseView_Impl_")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal._DrawCommandReader.DrawEllipseView_Impl_"); }
inline static hx::ObjectPtr< DrawEllipseView_Impl__obj > __new() {
hx::ObjectPtr< DrawEllipseView_Impl__obj > __this = new DrawEllipseView_Impl__obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< DrawEllipseView_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
DrawEllipseView_Impl__obj *__this = (DrawEllipseView_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(DrawEllipseView_Impl__obj), false, "openfl.display._internal._DrawCommandReader.DrawEllipseView_Impl_"));
*(void **)__this = DrawEllipseView_Impl__obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~DrawEllipseView_Impl__obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("DrawEllipseView_Impl_",7f,0e,f1,7c); }
static ::openfl::display::_internal::DrawCommandReader _new( ::openfl::display::_internal::DrawCommandReader d);
static ::Dynamic _new_dyn();
static Float get_x( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_x_dyn();
static Float get_y( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_y_dyn();
static Float get_width( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_width_dyn();
static Float get_height( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_height_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
} // end namespace _DrawCommandReader
#endif /* INCLUDED_openfl_display__internal__DrawCommandReader_DrawEllipseView_Impl_ */

79
hGameTest/bin/linux/obj/include/openfl/display/_internal/_DrawCommandReader/DrawQuadsView_Impl_.h Normal file
View File

@@ -0,0 +1,79 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal__DrawCommandReader_DrawQuadsView_Impl_
#define INCLUDED_openfl_display__internal__DrawCommandReader_DrawQuadsView_Impl_
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS2(openfl,_Vector,FloatVector)
HX_DECLARE_CLASS2(openfl,_Vector,IVector)
HX_DECLARE_CLASS2(openfl,_Vector,IntVector)
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandReader)
HX_DECLARE_CLASS4(openfl,display,_internal,_DrawCommandReader,DrawQuadsView_Impl_)
namespace openfl{
namespace display{
namespace _internal{
namespace _DrawCommandReader{
class HXCPP_CLASS_ATTRIBUTES DrawQuadsView_Impl__obj : public hx::Object
{
public:
typedef hx::Object super;
typedef DrawQuadsView_Impl__obj OBJ_;
DrawQuadsView_Impl__obj();
public:
enum { _hx_ClassId = 0x48e66b70 };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal._DrawCommandReader.DrawQuadsView_Impl_")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal._DrawCommandReader.DrawQuadsView_Impl_"); }
inline static hx::ObjectPtr< DrawQuadsView_Impl__obj > __new() {
hx::ObjectPtr< DrawQuadsView_Impl__obj > __this = new DrawQuadsView_Impl__obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< DrawQuadsView_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
DrawQuadsView_Impl__obj *__this = (DrawQuadsView_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(DrawQuadsView_Impl__obj), false, "openfl.display._internal._DrawCommandReader.DrawQuadsView_Impl_"));
*(void **)__this = DrawQuadsView_Impl__obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~DrawQuadsView_Impl__obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("DrawQuadsView_Impl_",ed,71,27,2b); }
static ::openfl::display::_internal::DrawCommandReader _new( ::openfl::display::_internal::DrawCommandReader d);
static ::Dynamic _new_dyn();
static ::openfl::_Vector::FloatVector get_rects( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_rects_dyn();
static ::openfl::_Vector::IntVector get_indices( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_indices_dyn();
static ::openfl::_Vector::FloatVector get_transforms( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_transforms_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
} // end namespace _DrawCommandReader
#endif /* INCLUDED_openfl_display__internal__DrawCommandReader_DrawQuadsView_Impl_ */

79
hGameTest/bin/linux/obj/include/openfl/display/_internal/_DrawCommandReader/DrawRectView_Impl_.h Normal file
View File

@@ -0,0 +1,79 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal__DrawCommandReader_DrawRectView_Impl_
#define INCLUDED_openfl_display__internal__DrawCommandReader_DrawRectView_Impl_
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandReader)
HX_DECLARE_CLASS4(openfl,display,_internal,_DrawCommandReader,DrawRectView_Impl_)
namespace openfl{
namespace display{
namespace _internal{
namespace _DrawCommandReader{
class HXCPP_CLASS_ATTRIBUTES DrawRectView_Impl__obj : public hx::Object
{
public:
typedef hx::Object super;
typedef DrawRectView_Impl__obj OBJ_;
DrawRectView_Impl__obj();
public:
enum { _hx_ClassId = 0x683aba2a };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal._DrawCommandReader.DrawRectView_Impl_")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal._DrawCommandReader.DrawRectView_Impl_"); }
inline static hx::ObjectPtr< DrawRectView_Impl__obj > __new() {
hx::ObjectPtr< DrawRectView_Impl__obj > __this = new DrawRectView_Impl__obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< DrawRectView_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
DrawRectView_Impl__obj *__this = (DrawRectView_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(DrawRectView_Impl__obj), false, "openfl.display._internal._DrawCommandReader.DrawRectView_Impl_"));
*(void **)__this = DrawRectView_Impl__obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~DrawRectView_Impl__obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("DrawRectView_Impl_",4d,d2,8e,ef); }
static ::openfl::display::_internal::DrawCommandReader _new( ::openfl::display::_internal::DrawCommandReader d);
static ::Dynamic _new_dyn();
static Float get_x( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_x_dyn();
static Float get_y( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_y_dyn();
static Float get_width( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_width_dyn();
static Float get_height( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_height_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
} // end namespace _DrawCommandReader
#endif /* INCLUDED_openfl_display__internal__DrawCommandReader_DrawRectView_Impl_ */

85
hGameTest/bin/linux/obj/include/openfl/display/_internal/_DrawCommandReader/DrawRoundRectView_Impl_.h Normal file
View File

@@ -0,0 +1,85 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal__DrawCommandReader_DrawRoundRectView_Impl_
#define INCLUDED_openfl_display__internal__DrawCommandReader_DrawRoundRectView_Impl_
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandReader)
HX_DECLARE_CLASS4(openfl,display,_internal,_DrawCommandReader,DrawRoundRectView_Impl_)
namespace openfl{
namespace display{
namespace _internal{
namespace _DrawCommandReader{
class HXCPP_CLASS_ATTRIBUTES DrawRoundRectView_Impl__obj : public hx::Object
{
public:
typedef hx::Object super;
typedef DrawRoundRectView_Impl__obj OBJ_;
DrawRoundRectView_Impl__obj();
public:
enum { _hx_ClassId = 0x5eaa7cfe };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal._DrawCommandReader.DrawRoundRectView_Impl_")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal._DrawCommandReader.DrawRoundRectView_Impl_"); }
inline static hx::ObjectPtr< DrawRoundRectView_Impl__obj > __new() {
hx::ObjectPtr< DrawRoundRectView_Impl__obj > __this = new DrawRoundRectView_Impl__obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< DrawRoundRectView_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
DrawRoundRectView_Impl__obj *__this = (DrawRoundRectView_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(DrawRoundRectView_Impl__obj), false, "openfl.display._internal._DrawCommandReader.DrawRoundRectView_Impl_"));
*(void **)__this = DrawRoundRectView_Impl__obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~DrawRoundRectView_Impl__obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("DrawRoundRectView_Impl_",33,ee,3d,1f); }
static ::openfl::display::_internal::DrawCommandReader _new( ::openfl::display::_internal::DrawCommandReader d);
static ::Dynamic _new_dyn();
static Float get_x( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_x_dyn();
static Float get_y( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_y_dyn();
static Float get_width( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_width_dyn();
static Float get_height( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_height_dyn();
static Float get_ellipseWidth( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_ellipseWidth_dyn();
static ::Dynamic get_ellipseHeight( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_ellipseHeight_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
} // end namespace _DrawCommandReader
#endif /* INCLUDED_openfl_display__internal__DrawCommandReader_DrawRoundRectView_Impl_ */

82
hGameTest/bin/linux/obj/include/openfl/display/_internal/_DrawCommandReader/DrawTrianglesView_Impl_.h Normal file
View File

@@ -0,0 +1,82 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal__DrawCommandReader_DrawTrianglesView_Impl_
#define INCLUDED_openfl_display__internal__DrawCommandReader_DrawTrianglesView_Impl_
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS2(openfl,_Vector,FloatVector)
HX_DECLARE_CLASS2(openfl,_Vector,IVector)
HX_DECLARE_CLASS2(openfl,_Vector,IntVector)
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandReader)
HX_DECLARE_CLASS4(openfl,display,_internal,_DrawCommandReader,DrawTrianglesView_Impl_)
namespace openfl{
namespace display{
namespace _internal{
namespace _DrawCommandReader{
class HXCPP_CLASS_ATTRIBUTES DrawTrianglesView_Impl__obj : public hx::Object
{
public:
typedef hx::Object super;
typedef DrawTrianglesView_Impl__obj OBJ_;
DrawTrianglesView_Impl__obj();
public:
enum { _hx_ClassId = 0x14007657 };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal._DrawCommandReader.DrawTrianglesView_Impl_")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal._DrawCommandReader.DrawTrianglesView_Impl_"); }
inline static hx::ObjectPtr< DrawTrianglesView_Impl__obj > __new() {
hx::ObjectPtr< DrawTrianglesView_Impl__obj > __this = new DrawTrianglesView_Impl__obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< DrawTrianglesView_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
DrawTrianglesView_Impl__obj *__this = (DrawTrianglesView_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(DrawTrianglesView_Impl__obj), false, "openfl.display._internal._DrawCommandReader.DrawTrianglesView_Impl_"));
*(void **)__this = DrawTrianglesView_Impl__obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~DrawTrianglesView_Impl__obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("DrawTrianglesView_Impl_",8c,e7,93,d4); }
static ::openfl::display::_internal::DrawCommandReader _new( ::openfl::display::_internal::DrawCommandReader d);
static ::Dynamic _new_dyn();
static ::openfl::_Vector::FloatVector get_vertices( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_vertices_dyn();
static ::openfl::_Vector::IntVector get_indices( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_indices_dyn();
static ::openfl::_Vector::FloatVector get_uvtData( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_uvtData_dyn();
static ::Dynamic get_culling( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_culling_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
} // end namespace _DrawCommandReader
#endif /* INCLUDED_openfl_display__internal__DrawCommandReader_DrawTrianglesView_Impl_ */

67
hGameTest/bin/linux/obj/include/openfl/display/_internal/_DrawCommandReader/EndFillView_Impl_.h Normal file
View File

@@ -0,0 +1,67 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal__DrawCommandReader_EndFillView_Impl_
#define INCLUDED_openfl_display__internal__DrawCommandReader_EndFillView_Impl_
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandReader)
HX_DECLARE_CLASS4(openfl,display,_internal,_DrawCommandReader,EndFillView_Impl_)
namespace openfl{
namespace display{
namespace _internal{
namespace _DrawCommandReader{
class HXCPP_CLASS_ATTRIBUTES EndFillView_Impl__obj : public hx::Object
{
public:
typedef hx::Object super;
typedef EndFillView_Impl__obj OBJ_;
EndFillView_Impl__obj();
public:
enum { _hx_ClassId = 0x72d889ea };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal._DrawCommandReader.EndFillView_Impl_")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal._DrawCommandReader.EndFillView_Impl_"); }
inline static hx::ObjectPtr< EndFillView_Impl__obj > __new() {
hx::ObjectPtr< EndFillView_Impl__obj > __this = new EndFillView_Impl__obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< EndFillView_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
EndFillView_Impl__obj *__this = (EndFillView_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(EndFillView_Impl__obj), false, "openfl.display._internal._DrawCommandReader.EndFillView_Impl_"));
*(void **)__this = EndFillView_Impl__obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~EndFillView_Impl__obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("EndFillView_Impl_",43,3e,96,56); }
static ::openfl::display::_internal::DrawCommandReader _new( ::openfl::display::_internal::DrawCommandReader d);
static ::Dynamic _new_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
} // end namespace _DrawCommandReader
#endif /* INCLUDED_openfl_display__internal__DrawCommandReader_EndFillView_Impl_ */

82
hGameTest/bin/linux/obj/include/openfl/display/_internal/_DrawCommandReader/LineBitmapStyleView_Impl_.h Normal file
View File

@@ -0,0 +1,82 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal__DrawCommandReader_LineBitmapStyleView_Impl_
#define INCLUDED_openfl_display__internal__DrawCommandReader_LineBitmapStyleView_Impl_
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS2(openfl,display,BitmapData)
HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandReader)
HX_DECLARE_CLASS4(openfl,display,_internal,_DrawCommandReader,LineBitmapStyleView_Impl_)
HX_DECLARE_CLASS2(openfl,geom,Matrix)
namespace openfl{
namespace display{
namespace _internal{
namespace _DrawCommandReader{
class HXCPP_CLASS_ATTRIBUTES LineBitmapStyleView_Impl__obj : public hx::Object
{
public:
typedef hx::Object super;
typedef LineBitmapStyleView_Impl__obj OBJ_;
LineBitmapStyleView_Impl__obj();
public:
enum { _hx_ClassId = 0x14042f36 };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal._DrawCommandReader.LineBitmapStyleView_Impl_")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal._DrawCommandReader.LineBitmapStyleView_Impl_"); }
inline static hx::ObjectPtr< LineBitmapStyleView_Impl__obj > __new() {
hx::ObjectPtr< LineBitmapStyleView_Impl__obj > __this = new LineBitmapStyleView_Impl__obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< LineBitmapStyleView_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
LineBitmapStyleView_Impl__obj *__this = (LineBitmapStyleView_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(LineBitmapStyleView_Impl__obj), false, "openfl.display._internal._DrawCommandReader.LineBitmapStyleView_Impl_"));
*(void **)__this = LineBitmapStyleView_Impl__obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~LineBitmapStyleView_Impl__obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("LineBitmapStyleView_Impl_",73,b1,c8,6b); }
static ::openfl::display::_internal::DrawCommandReader _new( ::openfl::display::_internal::DrawCommandReader d);
static ::Dynamic _new_dyn();
static ::openfl::display::BitmapData get_bitmap( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_bitmap_dyn();
static ::openfl::geom::Matrix get_matrix( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_matrix_dyn();
static bool get_repeat( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_repeat_dyn();
static bool get_smooth( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_smooth_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
} // end namespace _DrawCommandReader
#endif /* INCLUDED_openfl_display__internal__DrawCommandReader_LineBitmapStyleView_Impl_ */

92
hGameTest/bin/linux/obj/include/openfl/display/_internal/_DrawCommandReader/LineGradientStyleView_Impl_.h Normal file
View File

@@ -0,0 +1,92 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal__DrawCommandReader_LineGradientStyleView_Impl_
#define INCLUDED_openfl_display__internal__DrawCommandReader_LineGradientStyleView_Impl_
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandReader)
HX_DECLARE_CLASS4(openfl,display,_internal,_DrawCommandReader,LineGradientStyleView_Impl_)
HX_DECLARE_CLASS2(openfl,geom,Matrix)
namespace openfl{
namespace display{
namespace _internal{
namespace _DrawCommandReader{
class HXCPP_CLASS_ATTRIBUTES LineGradientStyleView_Impl__obj : public hx::Object
{
public:
typedef hx::Object super;
typedef LineGradientStyleView_Impl__obj OBJ_;
LineGradientStyleView_Impl__obj();
public:
enum { _hx_ClassId = 0x7286abdd };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal._DrawCommandReader.LineGradientStyleView_Impl_")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal._DrawCommandReader.LineGradientStyleView_Impl_"); }
inline static hx::ObjectPtr< LineGradientStyleView_Impl__obj > __new() {
hx::ObjectPtr< LineGradientStyleView_Impl__obj > __this = new LineGradientStyleView_Impl__obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< LineGradientStyleView_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
LineGradientStyleView_Impl__obj *__this = (LineGradientStyleView_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(LineGradientStyleView_Impl__obj), false, "openfl.display._internal._DrawCommandReader.LineGradientStyleView_Impl_"));
*(void **)__this = LineGradientStyleView_Impl__obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~LineGradientStyleView_Impl__obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("LineGradientStyleView_Impl_",92,5b,63,44); }
static ::openfl::display::_internal::DrawCommandReader _new( ::openfl::display::_internal::DrawCommandReader d);
static ::Dynamic _new_dyn();
static ::Dynamic get_type( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_type_dyn();
static ::Array< int > get_colors( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_colors_dyn();
static ::Array< Float > get_alphas( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_alphas_dyn();
static ::Array< int > get_ratios( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_ratios_dyn();
static ::openfl::geom::Matrix get_matrix( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_matrix_dyn();
static ::Dynamic get_spreadMethod( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_spreadMethod_dyn();
static ::Dynamic get_interpolationMethod( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_interpolationMethod_dyn();
static Float get_focalPointRatio( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_focalPointRatio_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
} // end namespace _DrawCommandReader
#endif /* INCLUDED_openfl_display__internal__DrawCommandReader_LineGradientStyleView_Impl_ */

91
hGameTest/bin/linux/obj/include/openfl/display/_internal/_DrawCommandReader/LineStyleView_Impl_.h Normal file
View File

@@ -0,0 +1,91 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal__DrawCommandReader_LineStyleView_Impl_
#define INCLUDED_openfl_display__internal__DrawCommandReader_LineStyleView_Impl_
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandReader)
HX_DECLARE_CLASS4(openfl,display,_internal,_DrawCommandReader,LineStyleView_Impl_)
namespace openfl{
namespace display{
namespace _internal{
namespace _DrawCommandReader{
class HXCPP_CLASS_ATTRIBUTES LineStyleView_Impl__obj : public hx::Object
{
public:
typedef hx::Object super;
typedef LineStyleView_Impl__obj OBJ_;
LineStyleView_Impl__obj();
public:
enum { _hx_ClassId = 0x63f1ad25 };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal._DrawCommandReader.LineStyleView_Impl_")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal._DrawCommandReader.LineStyleView_Impl_"); }
inline static hx::ObjectPtr< LineStyleView_Impl__obj > __new() {
hx::ObjectPtr< LineStyleView_Impl__obj > __this = new LineStyleView_Impl__obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< LineStyleView_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
LineStyleView_Impl__obj *__this = (LineStyleView_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(LineStyleView_Impl__obj), false, "openfl.display._internal._DrawCommandReader.LineStyleView_Impl_"));
*(void **)__this = LineStyleView_Impl__obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~LineStyleView_Impl__obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("LineStyleView_Impl_",a2,b3,32,46); }
static ::openfl::display::_internal::DrawCommandReader _new( ::openfl::display::_internal::DrawCommandReader d);
static ::Dynamic _new_dyn();
static ::Dynamic get_thickness( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_thickness_dyn();
static int get_color( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_color_dyn();
static Float get_alpha( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_alpha_dyn();
static bool get_pixelHinting( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_pixelHinting_dyn();
static ::Dynamic get_scaleMode( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_scaleMode_dyn();
static ::Dynamic get_caps( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_caps_dyn();
static ::Dynamic get_joints( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_joints_dyn();
static Float get_miterLimit( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_miterLimit_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
} // end namespace _DrawCommandReader
#endif /* INCLUDED_openfl_display__internal__DrawCommandReader_LineStyleView_Impl_ */

73
hGameTest/bin/linux/obj/include/openfl/display/_internal/_DrawCommandReader/LineToView_Impl_.h Normal file
View File

@@ -0,0 +1,73 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal__DrawCommandReader_LineToView_Impl_
#define INCLUDED_openfl_display__internal__DrawCommandReader_LineToView_Impl_
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandReader)
HX_DECLARE_CLASS4(openfl,display,_internal,_DrawCommandReader,LineToView_Impl_)
namespace openfl{
namespace display{
namespace _internal{
namespace _DrawCommandReader{
class HXCPP_CLASS_ATTRIBUTES LineToView_Impl__obj : public hx::Object
{
public:
typedef hx::Object super;
typedef LineToView_Impl__obj OBJ_;
LineToView_Impl__obj();
public:
enum { _hx_ClassId = 0x7f9823a1 };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal._DrawCommandReader.LineToView_Impl_")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal._DrawCommandReader.LineToView_Impl_"); }
inline static hx::ObjectPtr< LineToView_Impl__obj > __new() {
hx::ObjectPtr< LineToView_Impl__obj > __this = new LineToView_Impl__obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< LineToView_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
LineToView_Impl__obj *__this = (LineToView_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(LineToView_Impl__obj), false, "openfl.display._internal._DrawCommandReader.LineToView_Impl_"));
*(void **)__this = LineToView_Impl__obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~LineToView_Impl__obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("LineToView_Impl_",54,58,1f,2c); }
static ::openfl::display::_internal::DrawCommandReader _new( ::openfl::display::_internal::DrawCommandReader d);
static ::Dynamic _new_dyn();
static Float get_x( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_x_dyn();
static Float get_y( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_y_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
} // end namespace _DrawCommandReader
#endif /* INCLUDED_openfl_display__internal__DrawCommandReader_LineToView_Impl_ */

73
hGameTest/bin/linux/obj/include/openfl/display/_internal/_DrawCommandReader/MoveToView_Impl_.h Normal file
View File

@@ -0,0 +1,73 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal__DrawCommandReader_MoveToView_Impl_
#define INCLUDED_openfl_display__internal__DrawCommandReader_MoveToView_Impl_
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandReader)
HX_DECLARE_CLASS4(openfl,display,_internal,_DrawCommandReader,MoveToView_Impl_)
namespace openfl{
namespace display{
namespace _internal{
namespace _DrawCommandReader{
class HXCPP_CLASS_ATTRIBUTES MoveToView_Impl__obj : public hx::Object
{
public:
typedef hx::Object super;
typedef MoveToView_Impl__obj OBJ_;
MoveToView_Impl__obj();
public:
enum { _hx_ClassId = 0x0d46e0c6 };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal._DrawCommandReader.MoveToView_Impl_")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal._DrawCommandReader.MoveToView_Impl_"); }
inline static hx::ObjectPtr< MoveToView_Impl__obj > __new() {
hx::ObjectPtr< MoveToView_Impl__obj > __this = new MoveToView_Impl__obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< MoveToView_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
MoveToView_Impl__obj *__this = (MoveToView_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(MoveToView_Impl__obj), false, "openfl.display._internal._DrawCommandReader.MoveToView_Impl_"));
*(void **)__this = MoveToView_Impl__obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~MoveToView_Impl__obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("MoveToView_Impl_",f1,da,9f,86); }
static ::openfl::display::_internal::DrawCommandReader _new( ::openfl::display::_internal::DrawCommandReader d);
static ::Dynamic _new_dyn();
static Float get_x( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_x_dyn();
static Float get_y( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_y_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
} // end namespace _DrawCommandReader
#endif /* INCLUDED_openfl_display__internal__DrawCommandReader_MoveToView_Impl_ */

70
hGameTest/bin/linux/obj/include/openfl/display/_internal/_DrawCommandReader/OverrideBlendModeView_Impl_.h Normal file
View File

@@ -0,0 +1,70 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal__DrawCommandReader_OverrideBlendModeView_Impl_
#define INCLUDED_openfl_display__internal__DrawCommandReader_OverrideBlendModeView_Impl_
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandReader)
HX_DECLARE_CLASS4(openfl,display,_internal,_DrawCommandReader,OverrideBlendModeView_Impl_)
namespace openfl{
namespace display{
namespace _internal{
namespace _DrawCommandReader{
class HXCPP_CLASS_ATTRIBUTES OverrideBlendModeView_Impl__obj : public hx::Object
{
public:
typedef hx::Object super;
typedef OverrideBlendModeView_Impl__obj OBJ_;
OverrideBlendModeView_Impl__obj();
public:
enum { _hx_ClassId = 0x75e9ff78 };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal._DrawCommandReader.OverrideBlendModeView_Impl_")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal._DrawCommandReader.OverrideBlendModeView_Impl_"); }
inline static hx::ObjectPtr< OverrideBlendModeView_Impl__obj > __new() {
hx::ObjectPtr< OverrideBlendModeView_Impl__obj > __this = new OverrideBlendModeView_Impl__obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< OverrideBlendModeView_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
OverrideBlendModeView_Impl__obj *__this = (OverrideBlendModeView_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(OverrideBlendModeView_Impl__obj), false, "openfl.display._internal._DrawCommandReader.OverrideBlendModeView_Impl_"));
*(void **)__this = OverrideBlendModeView_Impl__obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~OverrideBlendModeView_Impl__obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("OverrideBlendModeView_Impl_",2d,af,c6,47); }
static ::openfl::display::_internal::DrawCommandReader _new( ::openfl::display::_internal::DrawCommandReader d);
static ::Dynamic _new_dyn();
static ::Dynamic get_blendMode( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_blendMode_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
} // end namespace _DrawCommandReader
#endif /* INCLUDED_openfl_display__internal__DrawCommandReader_OverrideBlendModeView_Impl_ */

71
hGameTest/bin/linux/obj/include/openfl/display/_internal/_DrawCommandReader/OverrideMatrixView_Impl_.h Normal file
View File

@@ -0,0 +1,71 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal__DrawCommandReader_OverrideMatrixView_Impl_
#define INCLUDED_openfl_display__internal__DrawCommandReader_OverrideMatrixView_Impl_
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandReader)
HX_DECLARE_CLASS4(openfl,display,_internal,_DrawCommandReader,OverrideMatrixView_Impl_)
HX_DECLARE_CLASS2(openfl,geom,Matrix)
namespace openfl{
namespace display{
namespace _internal{
namespace _DrawCommandReader{
class HXCPP_CLASS_ATTRIBUTES OverrideMatrixView_Impl__obj : public hx::Object
{
public:
typedef hx::Object super;
typedef OverrideMatrixView_Impl__obj OBJ_;
OverrideMatrixView_Impl__obj();
public:
enum { _hx_ClassId = 0x663173c7 };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal._DrawCommandReader.OverrideMatrixView_Impl_")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal._DrawCommandReader.OverrideMatrixView_Impl_"); }
inline static hx::ObjectPtr< OverrideMatrixView_Impl__obj > __new() {
hx::ObjectPtr< OverrideMatrixView_Impl__obj > __this = new OverrideMatrixView_Impl__obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< OverrideMatrixView_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
OverrideMatrixView_Impl__obj *__this = (OverrideMatrixView_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(OverrideMatrixView_Impl__obj), false, "openfl.display._internal._DrawCommandReader.OverrideMatrixView_Impl_"));
*(void **)__this = OverrideMatrixView_Impl__obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~OverrideMatrixView_Impl__obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("OverrideMatrixView_Impl_",f2,10,a1,26); }
static ::openfl::display::_internal::DrawCommandReader _new( ::openfl::display::_internal::DrawCommandReader d);
static ::Dynamic _new_dyn();
static ::openfl::geom::Matrix get_matrix( ::openfl::display::_internal::DrawCommandReader this1);
static ::Dynamic get_matrix_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
} // end namespace _DrawCommandReader
#endif /* INCLUDED_openfl_display__internal__DrawCommandReader_OverrideMatrixView_Impl_ */

67
hGameTest/bin/linux/obj/include/openfl/display/_internal/_DrawCommandReader/WindingEvenOddView_Impl_.h Normal file
View File

@@ -0,0 +1,67 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal__DrawCommandReader_WindingEvenOddView_Impl_
#define INCLUDED_openfl_display__internal__DrawCommandReader_WindingEvenOddView_Impl_
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandReader)
HX_DECLARE_CLASS4(openfl,display,_internal,_DrawCommandReader,WindingEvenOddView_Impl_)
namespace openfl{
namespace display{
namespace _internal{
namespace _DrawCommandReader{
class HXCPP_CLASS_ATTRIBUTES WindingEvenOddView_Impl__obj : public hx::Object
{
public:
typedef hx::Object super;
typedef WindingEvenOddView_Impl__obj OBJ_;
WindingEvenOddView_Impl__obj();
public:
enum { _hx_ClassId = 0x1474e055 };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal._DrawCommandReader.WindingEvenOddView_Impl_")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal._DrawCommandReader.WindingEvenOddView_Impl_"); }
inline static hx::ObjectPtr< WindingEvenOddView_Impl__obj > __new() {
hx::ObjectPtr< WindingEvenOddView_Impl__obj > __this = new WindingEvenOddView_Impl__obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< WindingEvenOddView_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
WindingEvenOddView_Impl__obj *__this = (WindingEvenOddView_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(WindingEvenOddView_Impl__obj), false, "openfl.display._internal._DrawCommandReader.WindingEvenOddView_Impl_"));
*(void **)__this = WindingEvenOddView_Impl__obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~WindingEvenOddView_Impl__obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("WindingEvenOddView_Impl_",80,7d,e4,d4); }
static ::openfl::display::_internal::DrawCommandReader _new( ::openfl::display::_internal::DrawCommandReader d);
static ::Dynamic _new_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
} // end namespace _DrawCommandReader
#endif /* INCLUDED_openfl_display__internal__DrawCommandReader_WindingEvenOddView_Impl_ */

67
hGameTest/bin/linux/obj/include/openfl/display/_internal/_DrawCommandReader/WindingNonZeroView_Impl_.h Normal file
View File

@@ -0,0 +1,67 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_openfl_display__internal__DrawCommandReader_WindingNonZeroView_Impl_
#define INCLUDED_openfl_display__internal__DrawCommandReader_WindingNonZeroView_Impl_
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandReader)
HX_DECLARE_CLASS4(openfl,display,_internal,_DrawCommandReader,WindingNonZeroView_Impl_)
namespace openfl{
namespace display{
namespace _internal{
namespace _DrawCommandReader{
class HXCPP_CLASS_ATTRIBUTES WindingNonZeroView_Impl__obj : public hx::Object
{
public:
typedef hx::Object super;
typedef WindingNonZeroView_Impl__obj OBJ_;
WindingNonZeroView_Impl__obj();
public:
enum { _hx_ClassId = 0x6495a075 };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal._DrawCommandReader.WindingNonZeroView_Impl_")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal._DrawCommandReader.WindingNonZeroView_Impl_"); }
inline static hx::ObjectPtr< WindingNonZeroView_Impl__obj > __new() {
hx::ObjectPtr< WindingNonZeroView_Impl__obj > __this = new WindingNonZeroView_Impl__obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< WindingNonZeroView_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
WindingNonZeroView_Impl__obj *__this = (WindingNonZeroView_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(WindingNonZeroView_Impl__obj), false, "openfl.display._internal._DrawCommandReader.WindingNonZeroView_Impl_"));
*(void **)__this = WindingNonZeroView_Impl__obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~WindingNonZeroView_Impl__obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("WindingNonZeroView_Impl_",a0,3d,05,25); }
static ::openfl::display::_internal::DrawCommandReader _new( ::openfl::display::_internal::DrawCommandReader d);
static ::Dynamic _new_dyn();
};
} // end namespace openfl
} // end namespace display
} // end namespace _internal
} // end namespace _DrawCommandReader
#endif /* INCLUDED_openfl_display__internal__DrawCommandReader_WindingNonZeroView_Impl_ */