blendo
/
quadrilateralcowboy
mirror of https://github.com/blendogames/quadrilateralcowboy.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
quadrilateralcowboy/ui/RegExp.cpp

403 lines
8.9 KiB
C++
Raw Permalink Blame History

/*
===========================================================================
Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).
Doom 3 Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Doom 3 Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
===========================================================================
*/
#include "../idlib/precompiled.h"
#pragma hdrstop
#include "RegExp.h"
#include "DeviceContext.h"
#include "Window.h"
#include "UserInterfaceLocal.h"
int idRegister::REGCOUNT[NUMTYPES] = {4, 1, 1, 1, 0, 2, 3, 4};
/*
====================
idRegister::SetToRegs
====================
*/
void idRegister::SetToRegs( float *registers ) {
int i;
idVec4 v;
idVec2 v2;
idVec3 v3;
idRectangle rect;
if ( !enabled || var == NULL || ( var && ( var->GetDict() || !var->GetEval() ) ) ) {
return;
}
switch( type ) {
case VEC4: {
v = *static_cast<idWinVec4*>(var);
break;
}
case RECTANGLE: {
rect = *static_cast<idWinRectangle*>(var);
v = rect.ToVec4();
break;
}
case VEC2: {
v2 = *static_cast<idWinVec2*>(var);
v[0] = v2[0];
v[1] = v2[1];
break;
}
case VEC3: {
v3 = *static_cast<idWinVec3*>(var);
v[0] = v3[0];
v[1] = v3[1];
v[2] = v3[2];
break;
}
case FLOAT: {
v[0] = *static_cast<idWinFloat*>(var);
break;
}
case INT: {
v[0] = *static_cast<idWinInt*>(var);
break;
}
case BOOL: {
v[0] = *static_cast<idWinBool*>(var);
break;
}
default: {
common->FatalError( "idRegister::SetToRegs: bad reg type" );
break;
}
}
for ( i = 0; i < regCount; i++ ) {
registers[ regs[ i ] ] = v[i];
}
}
/*
=================
idRegister::GetFromRegs
=================
*/
void idRegister::GetFromRegs( float *registers ) {
idVec4 v;
idRectangle rect;
if (!enabled || var == NULL || (var && (var->GetDict() || !var->GetEval()))) {
return;
}
for ( int i = 0; i < regCount; i++ ) {
v[i] = registers[regs[i]];
}
switch( type ) {
case VEC4: {
*dynamic_cast<idWinVec4*>(var) = v;
break;
}
case RECTANGLE: {
rect.x = v.x;
rect.y = v.y;
rect.w = v.z;
rect.h = v.w;
*static_cast<idWinRectangle*>(var) = rect;
break;
}
case VEC2: {
*static_cast<idWinVec2*>(var) = v.ToVec2();
break;
}
case VEC3: {
*static_cast<idWinVec3*>(var) = v.ToVec3();
break;
}
case FLOAT: {
*static_cast<idWinFloat*>(var) = v[0];
break;
}
case INT: {
*static_cast<idWinInt*>(var) = v[0];
break;
}
case BOOL: {
*static_cast<idWinBool*>(var) = ( v[0] != 0.0f );
break;
}
default: {
common->FatalError( "idRegister::GetFromRegs: bad reg type" );
break;
}
}
}
/*
=================
idRegister::ReadFromDemoFile
=================
*/
void idRegister::ReadFromDemoFile(idDemoFile *f) {
f->ReadBool( enabled );
f->ReadShort( type );
f->ReadInt( regCount );
for ( int i = 0; i < 4; i++ )
f->ReadUnsignedShort( regs[i] );
name = f->ReadHashString();
}
/*
=================
idRegister::WriteToDemoFile
=================
*/
void idRegister::WriteToDemoFile( idDemoFile *f ) {
f->WriteBool( enabled );
f->WriteShort( type );
f->WriteInt( regCount );
for (int i = 0; i < 4; i++)
f->WriteUnsignedShort( regs[i] );
f->WriteHashString( name );
}
/*
=================
idRegister::WriteToSaveGame
=================
*/
void idRegister::WriteToSaveGame( idFile *savefile ) {
int len;
savefile->Write( &enabled, sizeof( enabled ) );
savefile->Write( &type, sizeof( type ) );
savefile->Write( &regCount, sizeof( regCount ) );
savefile->Write( &regs[0], sizeof( regs ) );
len = name.Length();
savefile->Write( &len, sizeof( len ) );
savefile->Write( name.c_str(), len );
var->WriteToSaveGame( savefile );
}
/*
================
idRegister::ReadFromSaveGame
================
*/
void idRegister::ReadFromSaveGame( idFile *savefile ) {
int len;
savefile->Read( &enabled, sizeof( enabled ) );
savefile->Read( &type, sizeof( type ) );
savefile->Read( &regCount, sizeof( regCount ) );
savefile->Read( &regs[0], sizeof( regs ) );
savefile->Read( &len, sizeof( len ) );
name.Fill( ' ', len );
savefile->Read( &name[0], len );
var->ReadFromSaveGame( savefile );
}
/*
====================
idRegisterList::AddReg
====================
*/
void idRegisterList::AddReg( const char *name, int type, idVec4 data, idWindow *win, idWinVar *var ) {
if ( FindReg( name ) == NULL ) {
assert( type >= 0 && type < idRegister::NUMTYPES );
int numRegs = idRegister::REGCOUNT[type];
idRegister *reg = new idRegister( name, type );
reg->var = var;
for ( int i = 0; i < numRegs; i++ ) {
reg->regs[i] = win->ExpressionConstant(data[i]);
}
int hash = regHash.GenerateKey( name, false );
regHash.Add( hash, regs.Append( reg ) );
}
}
/*
====================
idRegisterList::AddReg
====================
*/
void idRegisterList::AddReg( const char *name, int type, idParser *src, idWindow *win, idWinVar *var ) {
idRegister* reg;
reg = FindReg( name );
if ( reg == NULL ) {
assert(type >= 0 && type < idRegister::NUMTYPES);
int numRegs = idRegister::REGCOUNT[type];
reg = new idRegister( name, type );
reg->var = var;
if ( type == idRegister::STRING ) {
idToken tok;
if ( src->ReadToken( &tok ) ) {
tok = common->GetLanguageDict()->GetString( tok );
var->Init( tok, win );
}
} else {
for ( int i = 0; i < numRegs; i++ ) {
reg->regs[i] = win->ParseExpression(src, NULL);
if ( i < numRegs-1 ) {
src->ExpectTokenString(",");
}
}
}
int hash = regHash.GenerateKey( name, false );
regHash.Add( hash, regs.Append( reg ) );
} else {
int numRegs = idRegister::REGCOUNT[type];
reg->var = var;
if ( type == idRegister::STRING ) {
idToken tok;
if ( src->ReadToken( &tok ) ) {
var->Init( tok, win );
}
} else {
for ( int i = 0; i < numRegs; i++ ) {
reg->regs[i] = win->ParseExpression( src, NULL );
if ( i < numRegs-1 ) {
src->ExpectTokenString(",");
}
}
}
}
}
/*
====================
idRegisterList::GetFromRegs
====================
*/
void idRegisterList::GetFromRegs(float *registers) {
for ( int i = 0; i < regs.Num(); i++ ) {
regs[i]->GetFromRegs( registers );
}
}
/*
====================
idRegisterList::SetToRegs
====================
*/
void idRegisterList::SetToRegs( float *registers ) {
int i;
for ( i = 0; i < regs.Num(); i++ ) {
regs[i]->SetToRegs( registers );
}
}
/*
====================
idRegisterList::FindReg
====================
*/
idRegister *idRegisterList::FindReg( const char *name ) {
int hash = regHash.GenerateKey( name, false );
for ( int i = regHash.First( hash ); i != -1; i = regHash.Next( i ) ) {
if ( regs[i]->name.Icmp( name ) == 0 ) {
return regs[i];
}
}
return NULL;
}
/*
====================
idRegisterList::Reset
====================
*/
void idRegisterList::Reset() {
regs.DeleteContents( true );
regHash.Clear();
}
/*
====================
idRegisterList::ReadFromSaveGame
====================
*/
void idRegisterList::ReadFromDemoFile(idDemoFile *f) {
int c;
f->ReadInt( c );
regs.DeleteContents( true );
for ( int i = 0; i < c; i++ ) {
idRegister *reg = new idRegister;
reg->ReadFromDemoFile( f );
regs.Append( reg );
}
}
/*
====================
idRegisterList::ReadFromSaveGame
====================
*/
void idRegisterList::WriteToDemoFile(idDemoFile *f) {
int c = regs.Num();
f->WriteInt( c );
for ( int i = 0 ; i < c; i++ ) {
regs[i]->WriteToDemoFile(f);
}
}
/*
=====================
idRegisterList::WriteToSaveGame
=====================
*/
void idRegisterList::WriteToSaveGame( idFile *savefile ) {
int i, num;
num = regs.Num();
savefile->Write( &num, sizeof( num ) );
for ( i = 0; i < num; i++ ) {
regs[i]->WriteToSaveGame( savefile );
}
}
/*
====================
idRegisterList::ReadFromSaveGame
====================
*/
void idRegisterList::ReadFromSaveGame( idFile *savefile ) {
int i, num;
savefile->Read( &num, sizeof( num ) );
for ( i = 0; i < num; i++ ) {
regs[i]->ReadFromSaveGame( savefile );
}
}
Reference in New Issue View Git Blame Copy Permalink