TNormFactory::TNormFactory() {
registerClass(Minimum().className(), &(Minimum::constructor));
registerClass(AlgebraicProduct().className(), &(AlgebraicProduct::constructor));
registerClass(BoundedDifference().className(), &(BoundedDifference::constructor));
registerClass(DrasticProduct().className(), &(DrasticProduct::constructor));
registerClass(EinsteinProduct().className(), &(EinsteinProduct::constructor));
registerClass(HamacherProduct().className(), &(HamacherProduct::constructor));
}
/*!
As registerClass() but to be used by plugins; it automatically
allocates an id for the class by which it will be identified.
\return id > 0 on success, 0 on failure
*/
UT_uint32 GR_GraphicsFactory::registerPluginClass(GR_Allocator allocator, GR_Descriptor descriptor)
{
UT_return_val_if_fail(allocator && descriptor, 0);
static UT_uint32 iLastId = GRID_LAST_EXTENSION;
iLastId++;
while(iLastId < GRID_UNKNOWN && !registerClass(allocator,descriptor, iLastId))
iLastId++;
if(iLastId != GRID_UNKNOWN)
return iLastId;
return 0;
}
MemoryViewer::MemoryViewer()
{
address = 0;
addressSize = 0;
dataSize = 0;
editAddress = 0;
editNibble = 0;
displayedLines = 0;
hasCaret = false;
maxNibble = 0;
font = (HFONT)GetStockObject(SYSTEM_FIXED_FONT);
fontSize.cx = fontSize.cy = 0;
beginAscii = 0;
beginHex = 0;
dlg = NULL;
registerClass();
}
void Win32Window::createWindow() {
registerClass();
hwnd = CreateWindowEx(0,
"WindowClass",
"",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
HWND_DESKTOP,
(HMENU) NULL,
GetModuleHandle(NULL),
(LPVOID)NULL);
SetWindowLongPtr(hwnd, 0, (LONG_PTR)this);
SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR)MainWndProc);
}
NBEWindow::NBEWindow(RenderInfo* ri, HINSTANCE h)
:RendererWindow(h), m_renderInfo(ri)
{
registerClass(h);
DWORD style, exStyle;
RECT _windowRect = { 0, 0, LONG(ri->width), LONG(ri->height) };
if (ri->fullScreen)
{
style = WS_POPUP;
exStyle = WS_EX_TOPMOST | WS_EX_APPWINDOW;
HDC screen = GetDC(0);
_windowRect.right = GetDeviceCaps(screen, HORZRES);
_windowRect.bottom = GetDeviceCaps(screen, VERTRES);
}
else
{
style = WS_OVERLAPPEDWINDOW;
exStyle = WS_EX_APPWINDOW;
}
AdjustWindowRectEx(&_windowRect, style, false, exStyle);
m_hwnd = CreateWindowEx(exStyle, ri->className, ri->title, style,
CW_USEDEFAULT, CW_USEDEFAULT, (_windowRect.right - _windowRect.left),
(_windowRect.bottom - _windowRect.top), NULL, NULL, h, NULL);
ShowWindow(m_hwnd, SW_SHOWNORMAL);
UpdateWindow(m_hwnd);
if (!m_hwnd)
{
throw NException(CreateWindowError, String(TEXT("Create Window Error")));
}
}
void ProcessorFactory::initialize() const {
if (initialized_) {
LERROR("initializeClassList() already initialized");
return;
}
if (!VoreenApplication::app()) {
LERROR("initializeClassList() VoreenApplication not instantiated");
return;
}
// retrieve processors from modules and register them
const std::vector<VoreenModule*> modules = VoreenApplication::app()->getModules();
if (modules.empty())
LWARNING("No modules found");
for (size_t m=0; m<modules.size(); m++) {
for (size_t p=0; p < modules.at(m)->getProcessors().size(); p++) {
registerClass(modules.at(m)->getProcessors().at(p));
}
}
}
PaletteViewControl::PaletteViewControl()
{
memset(&bmpInfo.bmiHeader, 0, sizeof(bmpInfo.bmiHeader));
bmpInfo.bmiHeader.biSize = sizeof(bmpInfo.bmiHeader);
bmpInfo.bmiHeader.biWidth = 256;
bmpInfo.bmiHeader.biHeight = -256;
bmpInfo.bmiHeader.biPlanes = 1;
bmpInfo.bmiHeader.biBitCount = 24;
bmpInfo.bmiHeader.biCompression = BI_RGB;
data = (u8 *)malloc(3 * 256 * 256);
w = 256;
h = 256;
colors = 256;
paletteAddress = 0;
ZeroMemory(palette, 512);
selected = -1;
registerClass();
}
//! [18]
ModuleFactory::ModuleFactory()
{
registerClass( "ImageSource", &ImgSource::staticMetaObject);
...
}
void Repair::registerSelf()
{
boost::shared_ptr<Class> instance (new Repair);
registerClass (typeid (ESM::Repair).name(), instance);
}
ColorControl::ColorControl()
{
color = 0;
registerClass();
}
if(ai){
ai->unlink(this);
ai = NULL;
}
// delete ai;
}
const char *SpacePlane::idname()const{
return "SpacePlane";
}
const char *SpacePlane::classname()const{
return "SpacePlane";
}
const unsigned SpacePlane::classid = registerClass("SpacePlane", Conster<SpacePlane>);
Entity::EntityRegister<SpacePlane> SpacePlane::entityRegister("SpacePlane");
void SpacePlane::serialize(SerializeContext &sc){
st::serialize(sc);
sc.o << ai;
sc.o << undocktime;
sc.o << people;
}
void SpacePlane::unserialize(UnserializeContext &sc){
st::unserialize(sc);
sc.i >> ai;
sc.i >> undocktime;
sc.i >> people;
ColorButton::ColorButton()
{
color = 0;
registerClass();
}
void Armor::registerSelf()
{
std::shared_ptr<Class> instance (new Armor);
registerClass (typeid (ESM::Armor).name(), instance);
}
void initPhysicsFunctions() {
registerClass(engine->sqvm, EMO_PHYSICS_CLASS);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "newWorld", emoPhysicsNewWorld);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "newShape", emoPhysicsNewShape);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "createBody", emoPhysicsCreateBody);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "createGroundBody", emoPhysicsCreateGroundBody);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "destroyBody", emoPhysicsDestroyBody);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "createJoint", emoPhysicsCreateJoint);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "destroyJoint", emoPhysicsDestroyJoint);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "world_step", emoPhysicsWorld_Step);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "world_enableContactListener", emoPhysicsWorld_EnableContactListener);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "world_enableContactState", emoPhysicsWorld_EnableContactState);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "world_clearForces", emoPhysicsWorld_ClearForces);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "createFixture", emoPhysicsCreateFixture);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "destroyFixture",emoPhysicsDestroyFixture);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "newJointDef", emoPhysicsNewJointDef);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "world_setAutoClearForces", emoPhysicsWorld_SetAutoClearForces);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "world_getAutoClearForces", emoPhysicsWorld_GetAutoClearForces);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "world_setGravity", emoPhysicsWorld_SetGravity);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "world_getGravity", emoPhysicsWorld_GetGravity);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "polygonShape_set", emoPhysicsPolygonShape_Set);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "polygonShape_setAsBox", emoPhysicsPolygonShape_SetAsBox);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "polygonShape_setAsEdge", emoPhysicsPolygonShape_SetAsEdge);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "polygonShape_getVertex", emoPhysicsPolygonShape_GetVertex);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "polygonShape_getVertexCount", emoPhysicsPolygonShape_GetVertexCount);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "polygonShape_radius", emoPhysicsPolygonShape_radius);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "circleShape_radius", emoPhysicsCircleShape_radius);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "circleShape_position", emoPhysicsCircleShape_position);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_setTransform", emoPhysicsBody_SetTransform);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_getPosition", emoPhysicsBody_GetPosition);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_getAngle", emoPhysicsBody_GetAngle);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_getWorldCenter", emoPhysicsBody_GetWorldCenter);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_getLocalCenter", emoPhysicsBody_GetLocalCenter);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_setLinearVelocity", emoPhysicsBody_SetLinearVelocity);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_getLinearVelocity", emoPhysicsBody_GetLinearVelocity);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_setAngularVelocity", emoPhysicsBody_SetAngularVelocity);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_getAngularVelocity", emoPhysicsBody_GetAngularVelocity);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_applyForce", emoPhysicsBody_ApplyForce);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_applyTorque", emoPhysicsBody_ApplyTorque);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_applyLinearImpulse", emoPhysicsBody_ApplyLinearImpulse);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_applyAngularImpulse", emoPhysicsBody_ApplyAngularImpulse);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_getMass", emoPhysicsBody_GetMass);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_getInertia", emoPhysicsBody_GetInertia);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_getWorldPoint", emoPhysicsBody_GetWorldPoint);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_getWorldVector", emoPhysicsBody_GetWorldVector);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_getLocalPoint", emoPhysicsBody_GetLocalPoint);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_getLocalVector", emoPhysicsBody_GetLocalVector);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_getLinearVelocityFromWorldPoint", emoPhysicsBody_GetLinearVelocityFromWorldPoint);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_getLinearVelocityFromLocalPoint", emoPhysicsBody_GetLinearVelocityFromLocalPoint);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_getLinearDamping", emoPhysicsBody_GetLinearDamping);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_setLinearDamping", emoPhysicsBody_SetLinearDamping);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_getAngularDamping", emoPhysicsBody_GetAngularDamping);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_setAngularDamping", emoPhysicsBody_SetAngularDamping);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_setType", emoPhysicsBody_SetType);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_getType", emoPhysicsBody_GetType);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_setBullet", emoPhysicsBody_SetBullet);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_isBullet", emoPhysicsBody_IsBullet);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_setSleepingAllowed", emoPhysicsBody_SetSleepingAllowed);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_isSleepingAllowed", emoPhysicsBody_IsSleepingAllowed);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_setAwake", emoPhysicsBody_SetAwake);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_isAwake", emoPhysicsBody_IsAwake);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_setActive", emoPhysicsBody_SetActive);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_isActive", emoPhysicsBody_IsActive);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_setFixedRotation", emoPhysicsBody_SetFixedRotation);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "body_isFixedRotation", emoPhysicsBody_IsFixedRotation);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_getAnchorA", emoPhysicsJoint_GetAnchorA);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_getAnchorB", emoPhysicsJoint_GetAnchorB);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_getReactionForce", emoPhysicsJoint_GetReactionForce);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_getReactionTorque", emoPhysicsJoint_GetReactionTorque);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_setLength", emoPhysicsJoint_SetLength);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_getLength", emoPhysicsJoint_GetLength);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_setFrequency", emoPhysicsJoint_SetFrequency);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_getFrequency", emoPhysicsJoint_GetFrequency);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_setDampingRatio", emoPhysicsJoint_SetDampingRatio);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_getDampingRatio", emoPhysicsJoint_GetDampingRatio);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_setMaxForce", emoPhysicsJoint_SetMaxForce);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_getMaxForce", emoPhysicsJoint_GetMaxForce);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_setMaxTorque", emoPhysicsJoint_SetMaxTorque);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_getMaxTorque", emoPhysicsJoint_GetMaxTorque);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_setRatio", emoPhysicsJoint_SetRatio);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_getRatio", emoPhysicsJoint_GetRatio);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_getJointTranslation", emoPhysicsJoint_GetJointTranslation);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_getJointSpeed", emoPhysicsJoint_GetJointSpeed);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_getJointAngle", emoPhysicsJoint_GetJointAngle);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_isLimitedEnabled", emoPhysicsJoint_IsLimitedEnabled);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_enableLimit", emoPhysicsJoint_EnableLimit);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_getLowerLimit", emoPhysicsJoint_GetLowerLimit);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_getUpperLimit", emoPhysicsJoint_GetUpperLimit);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_setLimits", emoPhysicsJoint_SetLimits);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_isMotorEnabled", emoPhysicsJoint_IsMotorEnabled);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_enableMotor", emoPhysicsJoint_EnableMotor);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_setMotorSpeed", emoPhysicsJoint_SetMotorSpeed);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_setMaxMotorTorque", emoPhysicsJoint_SetMaxMotorTorque);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_getMotorForce", emoPhysicsJoint_GetMotorForce);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_setMaxMotorForce", emoPhysicsJoint_SetMaxMotorForce);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_getMotorTorque", emoPhysicsJoint_GetMotorTorque);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_getGroundAnchorA", emoPhysicsJoint_GetGroundAnchorA);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_getGroundAnchorB", emoPhysicsJoint_GetGroundAnchorB);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_getLength1", emoPhysicsJoint_GetLength1);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_getLength2", emoPhysicsJoint_GetLength2);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_setTarget", emoPhysicsJoint_SetTarget);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "joint_getTarget", emoPhysicsJoint_GetTarget);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "updateJointDef", emoPhysicsJointDef_Update);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "initDistanceJointDef", emoPhysicsInitDistanceJointDef);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "initFrictionJointDef", emoPhysicsInitFrictionJointDef);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "initLineJointDef", emoPhysicsInitLineJointDef);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "initPrismaticJointDef", emoPhysicsInitPrismaticJointDef);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "initPulleyJointDef", emoPhysicsInitPulleyJointDef);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "initRevoluteJointDef", emoPhysicsInitRevoluteJointDef);
registerClassFunc(engine->sqvm, EMO_PHYSICS_CLASS, "initWeldJointDef", emoPhysicsInitWeldJointDef);
}
void Lockpick::registerSelf()
{
boost::shared_ptr<Class> instance (new Lockpick);
registerClass (typeid (ESM::Tool).name(), instance);
}
void Static::registerSelf()
{
boost::shared_ptr<Class> instance (new Static);
registerClass (typeid (ESM::Static).name(), instance);
}
void Activator::registerSelf()
{
boost::shared_ptr<Class> instance (new Activator);
registerClass (typeid (ESM::Activator).name(), instance);
}
QtNamespaceProvider::QtNamespaceProvider()
{
registerClass( "Qt", 0, new QtNamespace() );
}
void OpenGLRenderer::SetupGLCore(HWND hWnd)
{
HINSTANCE hInstance = reinterpret_cast<HINSTANCE>(GetWindowLong(hWnd, GWL_HINSTANCE));
registerClass(hInstance);
HWND fakeWND = CreateWindow(
"Core", "Fake Window", // window class, title
WS_CLIPSIBLINGS | WS_CLIPCHILDREN, // style
0, 0, // position x, y
1, 1, // width, height
NULL, NULL, // parent window, menu
hInstance, NULL); // instance, param
HDC fakeDC = GetDC(fakeWND); // Device Context
PIXELFORMATDESCRIPTOR fakePFD;
ZeroMemory(&fakePFD, sizeof(fakePFD));
fakePFD.nSize = sizeof(fakePFD);
fakePFD.nVersion = 1;
fakePFD.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
fakePFD.iPixelType = PFD_TYPE_RGBA;
fakePFD.cColorBits = 32;
fakePFD.cAlphaBits = 8;
fakePFD.cDepthBits = 24;
int fakePFDID = ChoosePixelFormat(fakeDC, &fakePFD);
if (fakePFDID == 0) {
OutputDebugString("Error choosing pixel format.");
}
if (SetPixelFormat(fakeDC, fakePFDID, &fakePFD) == false) {
OutputDebugString("Error setting pixel format.");
}
HGLRC fakeRC = wglCreateContext(fakeDC); // Rendering Contex
if (fakeRC == 0) {
OutputDebugString("Error creating initial gl context.");
}
if (wglMakeCurrent(fakeDC, fakeRC) == false) {
OutputDebugString("Error setting initial gl context.");
}
const int pixelAttribs[] = {
WGL_DRAW_TO_WINDOW_ARB, GL_TRUE,
WGL_SUPPORT_OPENGL_ARB, GL_TRUE,
WGL_DOUBLE_BUFFER_ARB, GL_TRUE,
WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB,
WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB,
WGL_COLOR_BITS_ARB, 32,
WGL_ALPHA_BITS_ARB, 8,
WGL_DEPTH_BITS_ARB, 24,
WGL_STENCIL_BITS_ARB, 8,
WGL_SAMPLE_BUFFERS_ARB, GL_TRUE,
WGL_SAMPLES_ARB, 4,
0
};
PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = nullptr;
wglChoosePixelFormatARB = reinterpret_cast<PFNWGLCHOOSEPIXELFORMATARBPROC>(wglGetProcAddress("wglChoosePixelFormatARB"));
if (wglChoosePixelFormatARB == nullptr) {
}
PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribsARB = nullptr;
wglCreateContextAttribsARB = reinterpret_cast<PFNWGLCREATECONTEXTATTRIBSARBPROC>(wglGetProcAddress("wglCreateContextAttribsARB"));
if (wglCreateContextAttribsARB == nullptr) {
}
mHdc = GetDC(hWnd);
int pixelFormatID; UINT numFormats;
bool status = wglChoosePixelFormatARB(mHdc, pixelAttribs, NULL, 1, &pixelFormatID, &numFormats);
if (status == false || numFormats == 0) {
}
const int pixelAttribsModern[] = {
WGL_DRAW_TO_WINDOW_ARB, GL_TRUE,
WGL_SUPPORT_OPENGL_ARB, GL_TRUE,
WGL_DOUBLE_BUFFER_ARB, GL_TRUE,
WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB,
WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB,
WGL_COLOR_BITS_ARB, 32,
WGL_ALPHA_BITS_ARB, 8,
WGL_DEPTH_BITS_ARB, 24,
WGL_STENCIL_BITS_ARB, 8,
WGL_SAMPLE_BUFFERS_ARB, GL_TRUE,
WGL_SAMPLES_ARB, 4,
0
};
int pixelFormatIDModern; UINT numFormatsModern;
status = wglChoosePixelFormatARB(mHdc, pixelAttribsModern, NULL, 1, &pixelFormatIDModern, &numFormatsModern);
if (status == false || numFormats == 0) {
}
PIXELFORMATDESCRIPTOR PFD;
DescribePixelFormat(mHdc, pixelFormatID, sizeof(PFD), &PFD);
SetPixelFormat(mHdc, pixelFormatID, &PFD);
const int major_min = 4, minor_min = 5;
int contextAttribs[] = {
WGL_CONTEXT_MAJOR_VERSION_ARB, major_min,
WGL_CONTEXT_MINOR_VERSION_ARB, minor_min,
WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_CORE_PROFILE_BIT_ARB,
0
};
HGLRC RC = wglCreateContextAttribsARB(mHdc, 0, contextAttribs);
if (RC == NULL) {
}
wglMakeCurrent(NULL, NULL);
wglDeleteContext(fakeRC);
ReleaseDC(fakeWND, fakeDC);
DestroyWindow(fakeWND);
if (!wglMakeCurrent(mHdc, RC)) {
}
gladLoadGL();
}
int Window::create(HINSTANCE hInstance, int nCmdShow) {
windowClass = MAKEINTATOM(registerClass(hInstance));
if (windowClass == 0) {
showMessage("registerClass() failed.");
return 1;
}
// create temporary window
HWND fakeWND = CreateWindow(
windowClass, "Fake Window",
style,
0, 0, // position x, y
1, 1, // width, height
NULL, NULL, // parent window, menu
hInstance, NULL); // instance, param
HDC fakeDC = GetDC(fakeWND); // Device Context
PIXELFORMATDESCRIPTOR fakePFD;
ZeroMemory(&fakePFD, sizeof(fakePFD));
fakePFD.nSize = sizeof(fakePFD);
fakePFD.nVersion = 1;
fakePFD.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
fakePFD.iPixelType = PFD_TYPE_RGBA;
fakePFD.cColorBits = 32;
fakePFD.cAlphaBits = 8;
fakePFD.cDepthBits = 24;
const int fakePFDID = ChoosePixelFormat(fakeDC, &fakePFD);
if (fakePFDID == 0) {
showMessage("ChoosePixelFormat() failed.");
return 1;
}
if (SetPixelFormat(fakeDC, fakePFDID, &fakePFD) == false) {
showMessage("SetPixelFormat() failed.");
return 1;
}
HGLRC fakeRC = wglCreateContext(fakeDC); // Rendering Contex
if (fakeRC == 0) {
showMessage("wglCreateContext() failed.");
return 1;
}
if (wglMakeCurrent(fakeDC, fakeRC) == false) {
showMessage("wglMakeCurrent() failed.");
return 1;
}
// get pointers to functions (or init opengl loader here)
PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = nullptr;
wglChoosePixelFormatARB = reinterpret_cast<PFNWGLCHOOSEPIXELFORMATARBPROC>(wglGetProcAddress("wglChoosePixelFormatARB"));
if (wglChoosePixelFormatARB == nullptr) {
showMessage("wglGetProcAddress() failed.");
return 1;
}
PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribsARB = nullptr;
wglCreateContextAttribsARB = reinterpret_cast<PFNWGLCREATECONTEXTATTRIBSARBPROC>(wglGetProcAddress("wglCreateContextAttribsARB"));
if (wglCreateContextAttribsARB == nullptr) {
showMessage("wglGetProcAddress() failed.");
return 1;
}
if (config.windowed == true) {
adjustSize();
center();
}
// create a new window and context
WND = CreateWindow(
windowClass, "OpenGL Window", // class name, window name
style, // styles
config.posX, config.posY, // posx, posy. If x is set to CW_USEDEFAULT y is ignored
config.width, config.height, // width, height
NULL, NULL, // parent window, menu
hInstance, NULL); // instance, param
DC = GetDC(WND);
const int pixelAttribs[] = {
WGL_DRAW_TO_WINDOW_ARB, GL_TRUE,
WGL_SUPPORT_OPENGL_ARB, GL_TRUE,
WGL_DOUBLE_BUFFER_ARB, GL_TRUE,
WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB,
WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB,
WGL_COLOR_BITS_ARB, 32,
WGL_ALPHA_BITS_ARB, 8,
WGL_DEPTH_BITS_ARB, 24,
WGL_STENCIL_BITS_ARB, 8,
WGL_SAMPLE_BUFFERS_ARB, GL_TRUE,
WGL_SAMPLES_ARB, 4,
0
};
int pixelFormatID; UINT numFormats;
const bool status = wglChoosePixelFormatARB(DC, pixelAttribs, NULL, 1, &pixelFormatID, &numFormats);
if (status == false || numFormats == 0) {
showMessage("wglChoosePixelFormatARB() failed.");
return 1;
}
PIXELFORMATDESCRIPTOR PFD;
DescribePixelFormat(DC, pixelFormatID, sizeof(PFD), &PFD);
SetPixelFormat(DC, pixelFormatID, &PFD);
const int major_min = 4, minor_min = 0;
const int contextAttribs[] = {
WGL_CONTEXT_MAJOR_VERSION_ARB, major_min,
WGL_CONTEXT_MINOR_VERSION_ARB, minor_min,
WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_CORE_PROFILE_BIT_ARB,
// WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_DEBUG_BIT_ARB,
0
};
RC = wglCreateContextAttribsARB(DC, 0, contextAttribs);
if (RC == NULL) {
showMessage("wglCreateContextAttribsARB() failed.");
return 1;
}
// delete temporary context and window
wglMakeCurrent(NULL, NULL);
wglDeleteContext(fakeRC);
ReleaseDC(fakeWND, fakeDC);
DestroyWindow(fakeWND);
if (!wglMakeCurrent(DC, RC)) {
showMessage("wglMakeCurrent() failed.");
return 1;
}
// init opengl loader here (extra safe version)
SetWindowText(WND, reinterpret_cast<LPCSTR>(glGetString(GL_VERSION)));
ShowWindow(WND, nCmdShow);
return 0;
}
void Weapon::registerSelf()
{
boost::shared_ptr<Class> instance (new Weapon);
registerClass (typeid (ESM::Weapon).name(), instance);
}
Dispatcher::Dispatcher(LPCTSTR name) {
WNDCLASSEX cls = makeWndClass(name);
registerClass(cls);
}
void initRuntimeFunctions() {
registerClass(engine->sqvm, EMO_RUNTIME_CLASS);
registerClass(engine->sqvm, EMO_EVENT_CLASS);
registerClass(engine->sqvm, EMO_STOPWATCH_CLASS);
registerClassFunc(engine->sqvm, EMO_RUNTIME_CLASS, "import",
emoImportScript);
registerClassFunc(engine->sqvm, EMO_RUNTIME_CLASS, "setOptions",
emoSetOptions);
registerClassFunc(engine->sqvm, EMO_RUNTIME_CLASS, "echo", emoRuntimeEcho);
registerClassFunc(engine->sqvm, EMO_RUNTIME_CLASS, "test", emoRuntimeTest);
registerClassFunc(engine->sqvm, EMO_RUNTIME_CLASS, "log", emoRuntimeLog);
registerClassFunc(engine->sqvm, EMO_RUNTIME_CLASS, "info",
emoRuntimeLogInfo);
registerClassFunc(engine->sqvm, EMO_RUNTIME_CLASS, "error",
emoRuntimeLogError);
registerClassFunc(engine->sqvm, EMO_RUNTIME_CLASS, "warn",
emoRuntimeLogWarn);
registerClassFunc(engine->sqvm, EMO_RUNTIME_CLASS, "finish",
emoRuntimeFinish);
registerClassFunc(engine->sqvm, EMO_RUNTIME_CLASS, "os",
emoRuntimeGetOSName);
registerClassFunc(engine->sqvm, EMO_RUNTIME_CLASS, "device",
emoRuntimeGetDeviceName);
registerClassFunc(engine->sqvm, EMO_RUNTIME_CLASS, "isSimulator",
emoRuntimeIsSimulator);
registerClassFunc(engine->sqvm, EMO_RUNTIME_CLASS, "gc", emoRuntimeGC);
registerClassFunc(engine->sqvm, EMO_RUNTIME_CLASS, "clearTextureCache",
emoClearImageCache);
registerClassFunc(engine->sqvm, EMO_STOPWATCH_CLASS, "start",
emoRuntimeStopwatchStart);
registerClassFunc(engine->sqvm, EMO_STOPWATCH_CLASS, "restart",
emoRuntimeStopwatchRestart);
registerClassFunc(engine->sqvm, EMO_STOPWATCH_CLASS, "stop",
emoRuntimeStopwatchStop);
registerClassFunc(engine->sqvm, EMO_STOPWATCH_CLASS, "isStopped",
emoRuntimeStopwatchIsStopped);
registerClassFunc(engine->sqvm, EMO_STOPWATCH_CLASS, "elapsed",
emoRuntimeStopwatchElapsed);
registerClassFunc(engine->sqvm, EMO_STOPWATCH_CLASS, "realElapsed",
emoRuntimeStopwatchRealElapsed);
registerClassFunc(engine->sqvm, EMO_RUNTIME_CLASS, "setLogLevel",
emoRuntimeSetLogLevel);
#ifndef EMO_WITH_SANDBOX
registerClassFunc(engine->sqvm, EMO_RUNTIME_CLASS, "compilebuffer",
emoRuntimeCompileBuffer);
registerClassFunc(engine->sqvm, EMO_RUNTIME_CLASS, "compile",
emoRuntimeCompile);
#endif
registerClassFunc(engine->sqvm, EMO_RUNTIME_CLASS, "getDocumentDir",
emoRuntimeGetDocumentDir);
registerClassFunc(engine->sqvm, EMO_RUNTIME_CLASS, "isSandboxEnabled",
emoRuntimeIsSandboxEnabled);
registerClassFunc(engine->sqvm, EMO_RUNTIME_CLASS, "buildNumber",
emoRuntimeBuildNumber);
registerClassFunc(engine->sqvm, EMO_EVENT_CLASS, "registerSensors",
emoRegisterSensors);
registerClassFunc(engine->sqvm, EMO_EVENT_CLASS, "enableSensor",
emoEnableSensor);
registerClassFunc(engine->sqvm, EMO_EVENT_CLASS, "disableSensor",
emoDisableSensor);
registerClassFunc(engine->sqvm, EMO_EVENT_CLASS, "enableOnDrawCallback",
emoEnableOnDrawCallback);
registerClassFunc(engine->sqvm, EMO_EVENT_CLASS, "disableOnDrawCallback",
emoDisableOnDrawCallback);
registerClassFunc(engine->sqvm, EMO_EVENT_CLASS, "enableOnUpdateCallback",
emoEnableOnUpdateCallback);
registerClassFunc(engine->sqvm, EMO_EVENT_CLASS, "disableOnUpdateCallback",
emoDisableOnUpdateCallback);
registerClassFunc(engine->sqvm, EMO_EVENT_CLASS, "enableOnFpsCallback",
emoEnableOnFpsCallback);
registerClassFunc(engine->sqvm, EMO_EVENT_CLASS, "disableOnFpsCallback",
emoDisableOnFpsCallback);
registerClassFunc(engine->sqvm, EMO_RUNTIME_CLASS, "enableSimpleLog",
emoEnableSimpleLog);
registerClassFunc(engine->sqvm, EMO_RUNTIME_CLASS,
"enableSimpleLogWithLevel", emoEnableSimpleLogWithLevel);
registerClassFunc(engine->sqvm, EMO_RUNTIME_CLASS, "nativeRandom",
emoRuntimeNativeRandom);
registerClassFunc(engine->sqvm, EMO_RUNTIME_CLASS, "random",
emoRuntimeRandom);
registerClassFunc(engine->sqvm, EMO_RUNTIME_CLASS, "getDefaultLocale",
emoGetDefaultLocale);
}
#include "respawn.h"
#include <clib/aquat.h>
#include <clib/rseq.h>
const unsigned Respawn::classid = registerClass("Respawn", Conster<Respawn>);
const char *Respawn::classname()const{return "Respawn";}
double Respawn::getHitRadius()const{return 0.;}
bool Respawn::isTargettable()const{return false;}
Respawn::Respawn(WarField *aw, double ainterval, double initial_phase, int max_count, const char *childClassName) : st(aw), interval(ainterval), timer(ainterval - initial_phase), count(max_count), creator(childClassName){
init();
/* VECNULL(ret->pos);
VECNULL(ret->velo);
VECNULL(ret->pyr);
VECNULL(ret->omg);
QUATZERO(ret->rot);
ret->rot[3] = 1.;*/
mass = 100000.; /* kilograms */
moi = 15.; /* kilograms * kilometer^2 */
health = 0.;
}
void Respawn::anim(double dt){
if(count <= 0){
w = NULL;
return;
}
while(timer < dt){
void Clothing::registerSelf()
{
std::shared_ptr<Class> instance (new Clothing);
registerClass (typeid (ESM::Clothing).name(), instance);
}
void Probe::registerSelf()
{
boost::shared_ptr<Class> instance (new Probe);
registerClass (typeid (ESM::Probe).name(), instance);
}
void Light::registerSelf()
{
boost::shared_ptr<Class> instance (new Light);
registerClass (typeid (ESM::Light).name(), instance);
}
void Container::registerSelf()
{
boost::shared_ptr<Class> instance (new Container);
registerClass (typeid (ESM::Container).name(), instance);
}
void Apparatus::registerSelf()
{
boost::shared_ptr<Class> instance (new Apparatus);
registerClass (typeid (ESM::Apparatus).name(), instance);
}
void Creature::registerSelf()
{
boost::shared_ptr<Class> instance (new Creature);
registerClass (typeid (ESM::Creature).name(), instance);
}
