void ZoomCamera::adjust(const Bounds2D& bounds) {
adjust(bounds, true);
}
// multiple merge sort
bool externalSort::mergeSort() {
if (fileNum <= 0) {
return false;
}
// make sure file won't be written twice
remove("sorted_cust.dat");
remove("sorted_order.dat");
FILE *fout_cust = fopen("sorted_cust.dat", "ab+");
FILE *fout_order = fopen("sorted_order.dat", "ab+");
FILE* *farray = new FILE*[fileNum]; // point pointers to temp files
// creat pointers to each temp file
for (int i = 0; i < fileNum; ++i) {
char* tempFile = fileName(i);
farray[i] = fopen(tempFile, "rb");
free(tempFile);
}
int *dataCust = new int[fileNum + 1]; // leaves node
int *dataOrder = new int[fileNum];
int *ls = new int[fileNum]; // loser tree, stores the position of parents
int MINKEY = 0;
int MAXKEY = 999999999;
memset(dataCust, 0, sizeof(int) * (fileNum + 1));
memset(dataOrder, 0, sizeof(int) * fileNum);
memset(ls, 0, sizeof(int) * fileNum);
//read data
for (int i = 0; i < fileNum; i++) {
fread(&dataCust[i], sizeof(int), 1, farray[i]);
fread(&dataOrder[i], sizeof(int), 1, farray[i]);
}
dataCust[fileNum] = MINKEY; // use for create loser tree
createLoserTree(ls, dataCust);
// sort
while(dataCust[ls[0]] != MAXKEY) {
int index = ls[0]; // position stores the file index of minimum custkey
// writes the custkey and orderkey of winner
fwrite(&dataCust[index], sizeof(int), 1, fout_cust);
fwrite(&dataOrder[index], sizeof(int), 1, fout_order);
// read new data
fread(&dataCust[index], sizeof(int), 1, farray[index]);
if (feof(farray[index]) != 0) {
dataCust[index] = MAXKEY; // set end mark
} else {
fread(&dataOrder[index], sizeof(int), 1, farray[index]);
}
adjust(ls,index,dataCust);
}
// close file
delete [] dataCust;
delete [] dataOrder;
for (int i = 0; i < fileNum; ++i) {
fclose(farray[i]);
}
// delete the temporary file
for (int i = 0; i < fileNum; ++i) {
remove(fileName(i));
}
delete [] farray;
fclose(fout_cust);
fclose(fout_order);
return true;
}
//////////////////////
// Maximize the likelihood when dealing with a single parameter
//////////////////////
void ML_single_NewtonRaphson::find_maximum() {
history.clear();
RatePVector& rpv = branch_rate_manager.get_ratepvector();
assert(rpv.size() == 1);
int thisparm = 0;
Likelihood::RatePBounds& b = bounds[thisparm];
b.delta = determine_machine_delta();
// double b.delta = 0.0000001;
double parameter = (b.lowerbound +
b.upperbound) / 2.0;
double logL_m_delta = compute_for_single_parameter(parameter -
b.delta);
// double logL_m_05delta = compute_for_single_parameter(parameter -
// (0.5*b.delta));
double logL = compute_for_single_parameter(parameter);
// double logL_p_05delta = compute_for_single_parameter(parameter +
// (0.5*b.delta));
double logL_p_delta = compute_for_single_parameter(parameter +
b.delta);
history.add(parameter, b.accuracy, b.delta,
b.lowerbound, b.upperbound,
logL_m_delta,
// logL_m_05delta,
logL,
// logL_p_05delta,
logL_p_delta);
do {
parameter = adjust();
if (parameter < b.lowerbound || parameter > b.upperbound) {
std::cout << "warning: exceeded bound" << std::endl;
}
logL_m_delta = compute_for_single_parameter(parameter - b.delta);
// logL_m_05delta = compute_for_single_parameter(parameter - (0.5*b.delta));
logL = compute_for_single_parameter(parameter);
// logL_p_05delta = compute_for_single_parameter(parameter + (0.5*b.delta));
logL_p_delta = compute_for_single_parameter(parameter + b.delta);
history.add(parameter, b.accuracy, b.delta, b.lowerbound,
b.upperbound, logL_m_delta,
// logL_m_05delta,
logL,
// logL_p_05delta,
logL_p_delta);
if (MAXDEBUG) {
std::cout << "History complete:" << std::endl;
// history.print();
history.simple_print();
}
} while (! converged());
if (MAXDEBUG_HISTORY_AT_CONVERGENCE) {
history.simple_print();
}
int hsz = history.size();
if (compute_for_single_parameter(b.lowerbound) > history[hsz - 1].logL) {
std::cerr << "log-Likelihood(b.lowerbound) > log-Likelihood(converged)"
<< std::endl;
}
if (compute_for_single_parameter(b.upperbound) > history[hsz - 1].logL) {
std::cerr << "log-Likelihood(b.upperbound) > log-Likelihood(converged)"
<< std::endl;
}
rpv[thisparm].set_ratep(history[hsz - 1].parameter);
set_log_likelihood(history[hsz - 1].logL);
}
void QHexEditPrivate::setAsciiArea(bool asciiArea)
{
_asciiArea = asciiArea;
adjust();
}
void QHexEditPrivate::keyPressEvent(QKeyEvent *event)
{
int charX = (_cursorX - _xPosHex) / _charWidth;
int posX = (charX / 3) * 2 + (charX % 3);
int posBa = (_cursorY / _charHeight) * BYTES_PER_LINE + posX / 2;
/*****************************************************************************/
/* Cursor movements */
/*****************************************************************************/
if (event->matches(QKeySequence::MoveToNextChar))
{
setCursorPos(_cursorPosition + 1);
resetSelection(_cursorPosition);
}
if (event->matches(QKeySequence::MoveToPreviousChar))
{
setCursorPos(_cursorPosition - 1);
resetSelection(_cursorPosition);
}
if (event->matches(QKeySequence::MoveToEndOfLine))
{
setCursorPos(_cursorPosition | (2 * BYTES_PER_LINE -1));
resetSelection(_cursorPosition);
}
if (event->matches(QKeySequence::MoveToStartOfLine))
{
setCursorPos(_cursorPosition - (_cursorPosition % (2 * BYTES_PER_LINE)));
resetSelection(_cursorPosition);
}
if (event->matches(QKeySequence::MoveToPreviousLine))
{
setCursorPos(_cursorPosition - (2 * BYTES_PER_LINE));
resetSelection(_cursorPosition);
}
if (event->matches(QKeySequence::MoveToNextLine))
{
setCursorPos(_cursorPosition + (2 * BYTES_PER_LINE));
resetSelection(_cursorPosition);
}
if (event->matches(QKeySequence::MoveToNextPage))
{
setCursorPos(_cursorPosition + (((_scrollArea->viewport()->height() / _charHeight) - 1) * 2 * BYTES_PER_LINE));
resetSelection(_cursorPosition);
}
if (event->matches(QKeySequence::MoveToPreviousPage))
{
setCursorPos(_cursorPosition - (((_scrollArea->viewport()->height() / _charHeight) - 1) * 2 * BYTES_PER_LINE));
resetSelection(_cursorPosition);
}
if (event->matches(QKeySequence::MoveToEndOfDocument))
{
setCursorPos(_data.size() * 2);
resetSelection(_cursorPosition);
}
if (event->matches(QKeySequence::MoveToStartOfDocument))
{
setCursorPos(0);
resetSelection(_cursorPosition);
}
/*****************************************************************************/
/* Select commands */
/*****************************************************************************/
if (event->matches(QKeySequence::SelectAll))
{
resetSelection(0);
setSelection(2*_data.length() + 1);
}
if (event->matches(QKeySequence::SelectNextChar))
{
int pos = _cursorPosition + 1;
setCursorPos(pos);
setSelection(pos);
}
if (event->matches(QKeySequence::SelectPreviousChar))
{
int pos = _cursorPosition - 1;
setSelection(pos);
setCursorPos(pos);
}
if (event->matches(QKeySequence::SelectEndOfLine))
{
int pos = _cursorPosition - (_cursorPosition % (2 * BYTES_PER_LINE)) + (2 * BYTES_PER_LINE);
setCursorPos(pos);
setSelection(pos);
}
if (event->matches(QKeySequence::SelectStartOfLine))
{
int pos = _cursorPosition - (_cursorPosition % (2 * BYTES_PER_LINE));
setCursorPos(pos);
setSelection(pos);
}
if (event->matches(QKeySequence::SelectPreviousLine))
{
int pos = _cursorPosition - (2 * BYTES_PER_LINE);
setCursorPos(pos);
setSelection(pos);
}
if (event->matches(QKeySequence::SelectNextLine))
{
int pos = _cursorPosition + (2 * BYTES_PER_LINE);
setCursorPos(pos);
setSelection(pos);
}
if (event->matches(QKeySequence::SelectNextPage))
{
int pos = _cursorPosition + (((_scrollArea->viewport()->height() / _charHeight) - 1) * 2 * BYTES_PER_LINE);
setCursorPos(pos);
setSelection(pos);
}
if (event->matches(QKeySequence::SelectPreviousPage))
{
int pos = _cursorPosition - (((_scrollArea->viewport()->height() / _charHeight) - 1) * 2 * BYTES_PER_LINE);
setCursorPos(pos);
setSelection(pos);
}
if (event->matches(QKeySequence::SelectEndOfDocument))
{
int pos = _data.size() * 2;
setCursorPos(pos);
setSelection(pos);
}
if (event->matches(QKeySequence::SelectStartOfDocument))
{
int pos = 0;
setCursorPos(pos);
setSelection(pos);
}
/*****************************************************************************/
/* Edit Commands */
/*****************************************************************************/
if (!_readOnly)
{
/* Hex input */
int key = int(event->text()[0].toAscii());
if ((key>='0' && key<='9') || (key>='a' && key <= 'f'))
{
if (getSelectionBegin() != getSelectionEnd())
{
posBa = getSelectionBegin();
remove(posBa, getSelectionEnd() - posBa);
setCursorPos(2*posBa);
resetSelection(2*posBa);
}
// If insert mode, then insert a byte
if (_overwriteMode == false)
if ((charX % 3) == 0)
{
insert(posBa, char(0));
adjust();
}
// Change content
if (_data.size() > 0)
{
QByteArray hexValue = _data.mid(posBa, 1).toHex();
if ((charX % 3) == 0)
hexValue[0] = key;
else
hexValue[1] = key;
replace(posBa, 1, QByteArray().fromHex(hexValue));
setCursorPos(_cursorPosition + 1);
resetSelection(_cursorPosition);
}
}
/* Cut & Paste */
if (event->matches(QKeySequence::Cut))
{
QString result = QString();
for (int idx = getSelectionBegin(); idx < getSelectionEnd(); idx++)
{
result += _data.mid(idx, 1).toHex() + " ";
if ((idx % 16) == 15)
result.append("\n");
}
remove(getSelectionBegin(), getSelectionEnd());
QClipboard *clipboard = QApplication::clipboard();
clipboard->setText(result);
setCursorPos(getSelectionBegin());
resetSelection(getSelectionBegin());
}
if (event->matches(QKeySequence::Paste))
{
QClipboard *clipboard = QApplication::clipboard();
QByteArray ba = QByteArray().fromHex(clipboard->text().toLatin1());
insert(_cursorPosition / 2, ba);
setCursorPos((_cursorPosition + (2 * ba.length()) + 1) & 0xfffffffe);
resetSelection(getSelectionBegin());
}
/* Delete char */
if (event->matches(QKeySequence::Delete))
{
if (getSelectionBegin() != getSelectionEnd())
{
posBa = getSelectionBegin();
remove(posBa, getSelectionEnd() - posBa);
setCursorPos(2*posBa);
resetSelection(2*posBa);
}
else
{
remove(posBa);
}
}
/* Backspace */
if ((event->key() == Qt::Key_Backspace) && (event->modifiers() == Qt::NoModifier))
{
if (getSelectionBegin() != getSelectionEnd())
{
posBa = getSelectionBegin();
remove(posBa, getSelectionEnd() - posBa);
setCursorPos(2*posBa);
resetSelection(2*posBa);
}
else
{
remove(posBa - 1);
setCursorPos(_cursorPosition - 2);
}
}
}
if (event->matches(QKeySequence::Copy))
{
QString result = QString();
for (int idx = getSelectionBegin(); idx < getSelectionEnd(); idx++)
{
result += _data.mid(idx, 1).toHex() + " ";
if ((idx % 16) == 15)
result.append('\n');
}
QClipboard *clipboard = QApplication::clipboard();
clipboard->setText(result);
}
// Switch between insert/overwrite mode
if ((event->key() == Qt::Key_Insert) && (event->modifiers() == Qt::NoModifier))
{
setOverwriteMode(!_overwriteMode);
setCursorPos(_cursorPosition);
}
_scrollArea->ensureVisible(_cursorX, _cursorY + _charHeight/2, 3, _charHeight/2 + 2);
update();
}
const ScaleMat &ScaleMat::adjust( const float pct ) {
return adjust( pct, pct, pct );
}
void make_heap() {
int len = size / 2;
for(int i = len; i >= 1; i--) {
adjust(i);
}
}
void heap::heapify()
{
//for ( int i = (int)floor(double(count())/2); i>=1; adjust(i--) );
for ( int i = count()/2; i>=1; adjust(i--) );
}
int
set_variable(char *variable, int on, char *val_string)
{
int value;
register struct variable_defs *var;
if (strncmp(variable, "no", 2) == 0) {
on = !on;
variable += 2;
if (variable[0] == '-')
variable++;
}
if ((var = lookup_variable(variable)) == NULL)
return 0;
if (!in_init && (var->var_flags & (V_INIT | V_SAFE))) {
if (var->var_flags & V_INIT) {
msg("'%s' can only be set in the init file", variable);
return 0;
}
if (shell_restrictions) {
msg("Restricted operation - cannot change");
return 0;
}
}
if (var->var_flags & V_LOCKED) {
msg("Variable '%s' is locked", variable);
return 0;
}
if (!on || val_string == NULL)
value = 0;
else
value = atoi(val_string);
var->var_flags |= V_MODIFIED;
switch (VAR_TYPE) {
case V_STRING:
if (on)
adjust(val_string);
switch (VAR_OP) {
case 0:
STR_VAR = (on && val_string) ? copy_str(val_string) : (char *) NULL;
break;
case 1:
strcpy(CBUF_VAR, (on && val_string) ? val_string : "");
break;
case 2:
if (on) {
char exp_buf[FILENAME];
if (val_string) {
if (expand_file_name(exp_buf, val_string, 1))
STR_VAR = home_relative(exp_buf);
}
} else
STR_VAR = (char *) NULL;
break;
case 3:
case 4:
if (!on || val_string == NULL) {
msg("Cannot unset string `%s'", variable);
break;
}
if (VAR_OP == 4) {
char exp_buf[FILENAME];
if (expand_file_name(exp_buf, val_string, 1)) {
STR_VAR = copy_str(exp_buf);
break;
}
}
STR_VAR = copy_str(val_string);
break;
case 5:
STR_VAR = (on && val_string) ? copy_str(val_string) : "";
break;
}
break;
case V_BOOLEAN:
adjust(val_string);
if (val_string && *val_string != NUL) {
if (val_string[0] == 'o')
on = val_string[1] == 'n'; /* on */
else
on = val_string[0] == 't'; /* true */
}
switch (VAR_OP) {
case 0:
BOOL_VAR = on;
break;
case 1:
BOOL_VAR = on;
return 1;
case 2:
if (BOOL_VAR) { /* don't change if already ok */
if (!on)
break;
} else if (on)
break;
BOOL_VAR = !on;
if (!in_init) {
sort_articles(BOOL_VAR ? 0 : -1);
return 1;
}
break;
case 4:
BOOL_VAR = !on;
break;
}
break;
case V_INTEGER:
switch (VAR_OP) {
case 0:
case 1:
INT_VAR = value;
break;
case 2:
case 3:
if (!on)
value = -1;
INT_VAR = value;
break;
}
return (VAR_OP & 1);
case V_KEY:
switch (VAR_OP) {
case 0:
if (val_string) {
if (*val_string)
adjust(val_string + 1); /* #N is valid */
KEY_VAR = parse_key(val_string);
}
break;
}
break;
case V_SPECIAL:
switch (VAR_OP) {
case 1:
if (val_string) {
adjust(val_string);
news_record = home_relative(val_string);
mail_record = news_record;
var->var_flags &= ~V_MODIFIED;
lookup_variable("mail-record")->var_flags |= V_MODIFIED;
lookup_variable("news-record")->var_flags |= V_MODIFIED;
}
break;
case 2:
also_read_articles = on;
article_limit = (on && value > 0) ? value : -1;
break;
case 3:
{
struct chset *csp;
struct variable_defs *dbvar;
dbvar = lookup_variable("data-bits");
if (on && val_string) {
if ((csp = getchset(val_string)) == NULL)
msg("Illegal value for `%s' variable", variable);
else {
curchset = csp;
data_bits = csp->cs_width ? csp->cs_width : 7;
dbvar->var_flags &= ~V_MODIFIED;
}
} else
msg("Cannot unset special `%s' variable", variable);
}
break;
}
break;
case V_CODES:
{
char codes[80], code[16], *sp, *cp, *vs;
if (val_string == NULL)
on = 0;
if (on) {
adjust(val_string);
if (val_string[0] == NUL)
on = 0;
}
if (on) {
sp = codes;
vs = val_string;
while (*vs) {
while (*vs && (!isascii(*vs) || isspace(*vs)))
vs++;
if (*vs == NUL)
break;
cp = code;
while (*vs && isascii(*vs) && !isspace(*vs))
*cp++ = *vs++;
*cp = NUL;
*sp++ = parse_key(code);
}
*sp = NUL;
if (codes[0] == NUL)
on = 0;
}
freeobj(code_strings[VAR_OP]);
code_strings[VAR_OP] = on ? copy_str(val_string) : NULL;
STR_VAR = on ? copy_str(codes) : (char *) NULL;
break;
}
}
return 0;
}
inline Date Calendar::endOfMonth(const Date& d) const {
return adjust(Date::endOfMonth(d), Preceding);
}
int main(int argc, char *argv[])
{
int MAXLINES = 1000;
FILE *fp;
char buf[BUFSIZ];
int i;
char **olptr;
int done = FALSE;
int length = 0;
#if CAN_RESIZE
bool use_resize = TRUE;
#endif
while ((i = getopt(argc, argv, "n:rtT:")) != EOF) {
switch (i) {
case 'n':
if ((MAXLINES = atoi(optarg)) < 1)
usage();
break;
#if CAN_RESIZE
case 'r':
use_resize = FALSE;
break;
#endif
#ifdef TRACE
case 'T':
trace(atoi(optarg));
break;
case 't':
trace(TRACE_CALLS);
break;
#endif
default:
usage();
}
}
if (optind + 1 != argc)
usage();
if ((lines = (char **)calloc(MAXLINES+2, sizeof(*lines))) == 0)
usage();
fname = argv[optind];
if ((fp = fopen(fname, "r")) == 0) {
perror(fname);
return EXIT_FAILURE;
}
(void) signal(SIGINT, finish); /* arrange interrupts to terminate */
#if CAN_RESIZE
if (use_resize)
(void) signal(SIGWINCH, adjust); /* arrange interrupts to resize */
#endif
/* slurp the file */
for (lptr = &lines[0]; (lptr - lines) < MAXLINES; lptr++) {
char temp[BUFSIZ], *s, *d;
int col;
if (fgets(buf, sizeof(buf), fp) == 0)
break;
/* convert tabs so that shift will work properly */
for (s = buf, d = temp, col = 0; (*d = *s) != '\0'; s++) {
if (*d == '\n') {
*d = '\0';
break;
} else if (*d == '\t') {
col = (col | 7) + 1;
while ((d-temp) != col)
*d++ = ' ';
} else if (isprint(*d)) {
col++;
d++;
} else {
sprintf(d, "\\%03o", *s & 0xff);
d += strlen(d);
col = (d - temp);
}
}
*lptr = strdup(temp);
}
(void) fclose(fp);
length = lptr - lines;
(void) initscr(); /* initialize the curses library */
keypad(stdscr, TRUE); /* enable keyboard mapping */
(void) nonl(); /* tell curses not to do NL->CR/NL on output */
(void) cbreak(); /* take input chars one at a time, no wait for \n */
(void) noecho(); /* don't echo input */
idlok(stdscr, TRUE); /* allow use of insert/delete line */
lptr = lines;
while (!done) {
int n, c;
bool got_number;
show_all();
got_number = FALSE;
n = 0;
for (;;) {
#if CAN_RESIZE
if (interrupted)
adjust(0);
#endif
waiting = TRUE;
c = getch();
waiting = FALSE;
if ((c < 127) && isdigit(c)) {
if (!got_number) {
mvprintw(0,0, "Count: ");
clrtoeol();
}
addch(c);
n = 10 * n + (c - '0');
got_number = TRUE;
}
else
break;
}
if (!got_number && n == 0)
n = 1;
switch(c) {
case KEY_DOWN:
case 'n':
olptr = lptr;
for (i = 0; i < n; i++)
if ((lptr - lines) < (length - LINES + 1))
lptr++;
else
break;
wscrl(stdscr, lptr - olptr);
break;
case KEY_UP:
case 'p':
olptr = lptr;
for (i = 0; i < n; i++)
if (lptr > lines)
lptr--;
else
break;
wscrl(stdscr, lptr - olptr);
break;
case 'h':
case KEY_HOME:
lptr = lines;
break;
case 'e':
case KEY_END:
if (length > LINES)
lptr = lines + length - LINES + 1;
else
lptr = lines;
break;
case 'r':
case KEY_RIGHT:
shift++;
break;
case 'l':
case KEY_LEFT:
if (shift)
shift--;
else
beep();
break;
case 'q':
done = TRUE;
break;
#ifdef KEY_RESIZE
case KEY_RESIZE: /* ignore this; ncurses will repaint */
break;
#endif
#if CAN_RESIZE
case ERR:
break;
#endif
default:
beep();
}
}
finish(0); /* we're done */
}
inline bool Calendar::isEndOfMonth(const Date& d) const {
return (d.month() != adjust(d+1).month());
}
void CChatLog::output(enum CHAT type, BYTE* buf, ...)
{
SYSTEMTIME t = _gettime(NULL);
if (_checkdate(&t) == false)
return; // ファイル関連の障害ぐらい...
va_list ap;
va_start(ap, buf);
switch (type)
{
case CT_ZONEINFO:
{
int p1 = va_arg(ap, int); // mapname
TCHAR* name = va_arg(ap, TCHAR*);
adjust(_T("SYS %s has connected\r\n"), name);
adjust(_T("MAP %s (%04d-%02d-%02d %02d:%02d:%02d)\r\n"), buf+p1, t.wYear, t.wMonth, t.wDay, t.wHour, t.wMinute, t.wSecond);
}
break;
case CT_CHANGEMAP:
case CT_CHANGEZONE:
{
int p1 = va_arg(ap, int); // mapname
adjust(_T("MAP %s (%04d-%02d-%02d %02d:%02d:%02d)\r\n"), buf+p1, t.wYear, t.wMonth, t.wDay, t.wHour, t.wMinute, t.wSecond);
}
break;
case CT_MVP:
{
DWORD AID = va_arg(ap, DWORD); // AID
adjust(_T("MVP %02d:%02d:%02d AID=%08X\r\n"), t.wHour, t.wMinute, t.wSecond, AID);
}
break;
case CT_NORMALCHAT:
case CT_NORMALCHAT_OWN:
{
int p1 = va_arg(ap, int); // body
adjust(_T("%s %02d:%02d:%02d %s\r\n"), _T("NOR"), t.wHour, t.wMinute, t.wSecond, buf+p1);
}
break;
case CT_SENDWHISPER:
{
int p1 = va_arg(ap, int); // name
int p2 = va_arg(ap, int); // body
adjust(_T("WIS %02d:%02d:%02d TO %s : %s\r\n"), t.wHour, t.wMinute, t.wSecond, buf+p1, buf+p2);
}
break;
case CT_RECVWHISPER:
{
int p1 = va_arg(ap, int); // name
int p2 = va_arg(ap, int); // body
adjust(_T("WIS %02d:%02d:%02d FROM %s : %s\r\n"), t.wHour, t.wMinute, t.wSecond, buf+p1, buf+p2);
}
break;
case CT_BROADCAST:
{
int p1 = va_arg(ap, int); // body
adjust(_T("%s %02d:%02d:%02d %s\r\n"), _T("GOD"), t.wHour, t.wMinute, t.wSecond, buf+p1);
}
break;
case CT_PTCHAT:
{
int p1 = va_arg(ap, int); // body
adjust(_T("%s %02d:%02d:%02d %s\r\n"), _T("PRT"), t.wHour, t.wMinute, t.wSecond, buf+p1);
}
break;
case CT_GUILDCHAT:
{
int p1 = va_arg(ap, int); // body
adjust(_T("%s %02d:%02d:%02d %s\r\n"), _T("GLD"), t.wHour, t.wMinute, t.wSecond, buf+p1);
}
break;
case CT_TALKIE:
{
int p1 = va_arg(ap, int); // body
adjust(_T("%s %02d:%02d:%02d %s\r\n"), _T("TLK"), t.wHour, t.wMinute, t.wSecond, buf+p1);
}
break;
case CT_LOCALBROADCAST:
{
int p1 = va_arg(ap, int); // body
adjust(_T("%s %02d:%02d:%02d %s\r\n"), _T("LBC"), t.wHour, t.wMinute, t.wSecond, buf+p1);
}
break;
}
va_end(ap);
}
void ViewEngineering::onRender( RenderContext & context, const RectInt & window )
{
GameDocument * pDoc = (GameDocument *)document();
if ( pDoc == NULL )
return;
UniverseContext * pContext = pDoc->context();
ASSERT( pContext );
NounShip * pShip = pDoc->ship();
ASSERT( pShip );
// get the time elapsed
float t = context.elapsed();
// calculate the distance from the ship based upon it's radius
float cameraDistance = pShip->radius() * 2.5f;
// calculate the camera frame and position
Matrix33 cameraFrame( pShip->frame() );
cameraFrame.rotate( PI / 4, ViewGame::s_CameraTime * (PI / 4), 0 );
Vector3 cameraPosition( pShip->worldPosition() - (cameraFrame.k * cameraDistance) );
if ( ViewGame::s_CameraTime < CAMERA_SNAP_TIME )
{
// if ship is moving, keep it from jumping around while the camera is animating
if ( m_Adjust )
{
Vector3 position( pShip->worldPosition() );
Vector3 adjust( position - m_AdjustPosition );
m_AdjustPosition = position;
ViewGame::s_CameraPosition += adjust;
}
else
{
m_AdjustPosition = pShip->worldPosition();
m_Adjust = true;
}
float d = ViewGame::s_CameraTime / CAMERA_SNAP_TIME;
// move the camera
Vector3 deltaPosition( cameraPosition - ViewGame::s_CameraPosition );
ViewGame::s_CameraPosition += deltaPosition * d;
// update the camera frame
ViewGame::s_CameraFrame.i += (cameraFrame.i - ViewGame::s_CameraFrame.i) * d;
ViewGame::s_CameraFrame.j += (cameraFrame.j - ViewGame::s_CameraFrame.j) * d;
ViewGame::s_CameraFrame.k += (cameraFrame.k - ViewGame::s_CameraFrame.k) * d;
ViewGame::s_CameraFrame.orthoNormalizeXY();
}
else
{
// animation is over, snap directly to the desired frame/position
ViewGame::s_CameraFrame = cameraFrame;
ViewGame::s_CameraPosition = cameraPosition;
m_Adjust = false;
}
m_UpdateStatus += t;
if ( m_UpdateStatus > 1.0f )
{
m_UpdateStatus = 0.0f;
// update the ship status
String shipStatus;
shipStatus += String().format("Hull:<X;75;Color;ff00ffff>%d%%</Color>\n", int(pShip->damageRatioInv() * 100) );
shipStatus += String().format("Energy:<X;75;Color;ff00ffff>%d / %d</Color>\n", pShip->energy(), pShip->maxEnergy() );
shipStatus += String().format("Velocity:<X;75;Color;ff00ffff>%.1f / %.1f</Color>\n", pShip->velocity(), pShip->maxVelocity() );
shipStatus += String().format("Signature:<X;75;Color;ff00ffff>%.1f</Color>\n", pShip->signature() );
shipStatus += "\nSYSTEMS:\n";
// display armor status
for(int i=0;i<pShip->childCount();i++)
if ( WidgetCast<GadgetArmor>( pShip->child(i) ) )
{
GadgetArmor * pArmor = (GadgetArmor *)pShip->child(i);
shipStatus += String().format("%s<X;100>%d%%\n",
pArmor->nounContext()->name(),
(pArmor->armor() * 100 ) / pArmor->strength() );
}
// display shield status
for(i=0;i<pShip->childCount();i++)
if ( WidgetCast<GadgetShield>( pShip->child(i) ) )
{
GadgetShield * pShield = (GadgetShield *)pShip->child(i);
shipStatus += String().format("%s<X;100>%d%%\n",
pShield->nounContext()->name(),
(pShield->charge() * 100 ) / pShield->maxCharge() );
}
for(i=0;i<pShip->childCount();i++)
if ( WidgetCast<NounGadget>( pShip->child(i) ) )
{
NounGadget * pGadget = (NounGadget *)pShip->child(i);
if ( WidgetCast<GadgetArmor>( pGadget ) )
continue;
if ( WidgetCast<GadgetShield>( pGadget ) )
continue;
shipStatus += String().format("%s<X;100>%d%%\n",
pGadget->nounContext()->name(),
int( pGadget->damageRatioInv() * 100 ) );
}
m_pShipStatus->setText( shipStatus );
}
if ( m_pLayoutRepair->visible() )
{
for(int i=0;i<pShip->repairCount();i++)
GetButton<ButtonGadget>( m_pRepairQueue, i )->setGadget( pShip->repair( i ) );
// remove excess buttons
m_pRepairQueue->cullChildren( pShip->repairCount() );
}
//----------------------------------------------------------------------------
// update the active zone
pContext->setActiveZone( ViewGame::s_CameraPosition );
// create our render context
RenderContext engineeringContext( context );
engineeringContext.setPosition( ViewGame::s_CameraPosition );
engineeringContext.setFrame( ViewGame::s_CameraFrame );
engineeringContext.setTime( pContext->tick() * TICK_DURATION_S );
//----------------------------------------------------------------------------
// render the universe
pContext->render( engineeringContext,
~ViewGame::s_CameraFrame, ViewGame::s_CameraFrame * (-ViewGame::s_CameraPosition) );
}
void Batch::Prepare(View* view, bool setModelTransform) const
{
if (!vertexShader_ || !pixelShader_)
return;
Graphics* graphics = view->GetGraphics();
Renderer* renderer = view->GetRenderer();
Node* cameraNode = camera_ ? camera_->GetNode() : 0;
Light* light = lightQueue_ ? lightQueue_->light_ : 0;
Texture2D* shadowMap = lightQueue_ ? lightQueue_->shadowMap_ : 0;
// Set pass / material-specific renderstates
if (pass_ && material_)
{
bool isShadowPass = pass_->GetType() == PASS_SHADOW;
BlendMode blend = pass_->GetBlendMode();
// Turn additive blending into subtract if the light is negative
if (light && light->IsNegative())
{
if (blend == BLEND_ADD)
blend = BLEND_SUBTRACT;
else if (blend == BLEND_ADDALPHA)
blend = BLEND_SUBTRACTALPHA;
}
graphics->SetBlendMode(blend);
renderer->SetCullMode(isShadowPass ? material_->GetShadowCullMode() : material_->GetCullMode(), camera_);
if (!isShadowPass)
{
const BiasParameters& depthBias = material_->GetDepthBias();
graphics->SetDepthBias(depthBias.constantBias_, depthBias.slopeScaledBias_);
}
graphics->SetDepthTest(pass_->GetDepthTestMode());
graphics->SetDepthWrite(pass_->GetDepthWrite());
}
// Set shaders first. The available shader parameters and their register/uniform positions depend on the currently set shaders
graphics->SetShaders(vertexShader_, pixelShader_);
// Set global (per-frame) shader parameters
if (graphics->NeedParameterUpdate(SP_FRAME, (void*)0))
view->SetGlobalShaderParameters();
// Set camera shader parameters
unsigned cameraHash = overrideView_ ? (unsigned)(size_t)camera_ + 4 : (unsigned)(size_t)camera_;
if (graphics->NeedParameterUpdate(SP_CAMERA, reinterpret_cast<void*>(cameraHash)))
view->SetCameraShaderParameters(camera_, true, overrideView_);
// Set viewport shader parameters
IntVector2 rtSize = graphics->GetRenderTargetDimensions();
IntRect viewport = graphics->GetViewport();
unsigned viewportHash = (viewport.left_) | (viewport.top_ << 8) | (viewport.right_ << 16) | (viewport.bottom_ << 24);
if (graphics->NeedParameterUpdate(SP_VIEWPORT, reinterpret_cast<void*>(viewportHash)))
{
float rtWidth = (float)rtSize.x_;
float rtHeight = (float)rtSize.y_;
float widthRange = 0.5f * viewport.Width() / rtWidth;
float heightRange = 0.5f * viewport.Height() / rtHeight;
#ifdef URHO3D_OPENGL
Vector4 bufferUVOffset(((float)viewport.left_) / rtWidth + widthRange,
1.0f - (((float)viewport.top_) / rtHeight + heightRange), widthRange, heightRange);
#else
Vector4 bufferUVOffset((0.5f + (float)viewport.left_) / rtWidth + widthRange,
(0.5f + (float)viewport.top_) / rtHeight + heightRange, widthRange, heightRange);
#endif
graphics->SetShaderParameter(VSP_GBUFFEROFFSETS, bufferUVOffset);
float sizeX = 1.0f / rtWidth;
float sizeY = 1.0f / rtHeight;
graphics->SetShaderParameter(PSP_GBUFFERINVSIZE, Vector4(sizeX, sizeY, 0.0f, 0.0f));
}
// Set model or skinning transforms
if (setModelTransform && graphics->NeedParameterUpdate(SP_OBJECTTRANSFORM, worldTransform_))
{
if (geometryType_ == GEOM_SKINNED)
{
graphics->SetShaderParameter(VSP_SKINMATRICES, reinterpret_cast<const float*>(worldTransform_),
12 * numWorldTransforms_);
}
else
graphics->SetShaderParameter(VSP_MODEL, *worldTransform_);
// Set the orientation for billboards, either from the object itself or from the camera
if (geometryType_ == GEOM_BILLBOARD)
{
if (numWorldTransforms_ > 1)
graphics->SetShaderParameter(VSP_BILLBOARDROT, worldTransform_[1].RotationMatrix());
else
graphics->SetShaderParameter(VSP_BILLBOARDROT, cameraNode->GetWorldRotation().RotationMatrix());
}
}
// Set zone-related shader parameters
BlendMode blend = graphics->GetBlendMode();
// If the pass is additive, override fog color to black so that shaders do not need a separate additive path
bool overrideFogColorToBlack = blend == BLEND_ADD || blend == BLEND_ADDALPHA;
unsigned zoneHash = (unsigned)(size_t)zone_;
if (overrideFogColorToBlack)
zoneHash += 0x80000000;
if (zone_ && graphics->NeedParameterUpdate(SP_ZONE, reinterpret_cast<void*>(zoneHash)))
{
graphics->SetShaderParameter(VSP_AMBIENTSTARTCOLOR, zone_->GetAmbientStartColor());
graphics->SetShaderParameter(VSP_AMBIENTENDCOLOR, zone_->GetAmbientEndColor().ToVector4() - zone_->GetAmbientStartColor().ToVector4());
const BoundingBox& box = zone_->GetBoundingBox();
Vector3 boxSize = box.Size();
Matrix3x4 adjust(Matrix3x4::IDENTITY);
adjust.SetScale(Vector3(1.0f / boxSize.x_, 1.0f / boxSize.y_, 1.0f / boxSize.z_));
adjust.SetTranslation(Vector3(0.5f, 0.5f, 0.5f));
Matrix3x4 zoneTransform = adjust * zone_->GetInverseWorldTransform();
graphics->SetShaderParameter(VSP_ZONE, zoneTransform);
graphics->SetShaderParameter(PSP_AMBIENTCOLOR, zone_->GetAmbientColor());
graphics->SetShaderParameter(PSP_FOGCOLOR, overrideFogColorToBlack ? Color::BLACK : zone_->GetFogColor());
float farClip = camera_->GetFarClip();
float fogStart = Min(zone_->GetFogStart(), farClip);
float fogEnd = Min(zone_->GetFogEnd(), farClip);
if (fogStart >= fogEnd * (1.0f - M_LARGE_EPSILON))
fogStart = fogEnd * (1.0f - M_LARGE_EPSILON);
float fogRange = Max(fogEnd - fogStart, M_EPSILON);
Vector4 fogParams(fogEnd / farClip, farClip / fogRange, 0.0f, 0.0f);
Node* zoneNode = zone_->GetNode();
if (zone_->GetHeightFog() && zoneNode)
{
Vector3 worldFogHeightVec = zoneNode->GetWorldTransform() * Vector3(0.0f, zone_->GetFogHeight(), 0.0f);
fogParams.z_ = worldFogHeightVec.y_;
fogParams.w_ = zone_->GetFogHeightScale() / Max(zoneNode->GetWorldScale().y_, M_EPSILON);
}
graphics->SetShaderParameter(PSP_FOGPARAMS, fogParams);
}
// Set light-related shader parameters
if (lightQueue_)
{
if (graphics->NeedParameterUpdate(SP_VERTEXLIGHTS, lightQueue_) && graphics->HasShaderParameter(VS, VSP_VERTEXLIGHTS))
{
Vector4 vertexLights[MAX_VERTEX_LIGHTS * 3];
const PODVector<Light*>& lights = lightQueue_->vertexLights_;
for (unsigned i = 0; i < lights.Size(); ++i)
{
Light* vertexLight = lights[i];
Node* vertexLightNode = vertexLight->GetNode();
LightType type = vertexLight->GetLightType();
// Attenuation
float invRange, cutoff, invCutoff;
if (type == LIGHT_DIRECTIONAL)
invRange = 0.0f;
else
invRange = 1.0f / Max(vertexLight->GetRange(), M_EPSILON);
if (type == LIGHT_SPOT)
{
cutoff = Cos(vertexLight->GetFov() * 0.5f);
invCutoff = 1.0f / (1.0f - cutoff);
}
else
{
cutoff = -1.0f;
invCutoff = 1.0f;
}
// Color
float fade = 1.0f;
float fadeEnd = vertexLight->GetDrawDistance();
float fadeStart = vertexLight->GetFadeDistance();
// Do fade calculation for light if both fade & draw distance defined
if (vertexLight->GetLightType() != LIGHT_DIRECTIONAL && fadeEnd > 0.0f && fadeStart > 0.0f && fadeStart < fadeEnd)
fade = Min(1.0f - (vertexLight->GetDistance() - fadeStart) / (fadeEnd - fadeStart), 1.0f);
Color color = vertexLight->GetEffectiveColor() * fade;
vertexLights[i * 3] = Vector4(color.r_, color.g_, color.b_, invRange);
// Direction
vertexLights[i * 3 + 1] = Vector4(-(vertexLightNode->GetWorldDirection()), cutoff);
// Position
vertexLights[i * 3 + 2] = Vector4(vertexLightNode->GetWorldPosition(), invCutoff);
}
if (lights.Size())
graphics->SetShaderParameter(VSP_VERTEXLIGHTS, vertexLights[0].Data(), lights.Size() * 3 * 4);
}
}
if (light && graphics->NeedParameterUpdate(SP_LIGHT, light))
{
// Deferred light volume batches operate in a camera-centered space. Detect from material, zone & pass all being null
bool isLightVolume = !material_ && !pass_ && !zone_;
Matrix3x4 cameraEffectiveTransform = camera_->GetEffectiveWorldTransform();
Vector3 cameraEffectivePos = cameraEffectiveTransform.Translation();
Node* lightNode = light->GetNode();
Matrix3 lightWorldRotation = lightNode->GetWorldRotation().RotationMatrix();
graphics->SetShaderParameter(VSP_LIGHTDIR, lightWorldRotation * Vector3::BACK);
float atten = 1.0f / Max(light->GetRange(), M_EPSILON);
graphics->SetShaderParameter(VSP_LIGHTPOS, Vector4(lightNode->GetWorldPosition(), atten));
if (graphics->HasShaderParameter(VS, VSP_LIGHTMATRICES))
{
switch (light->GetLightType())
{
case LIGHT_DIRECTIONAL:
{
Matrix4 shadowMatrices[MAX_CASCADE_SPLITS];
unsigned numSplits = lightQueue_->shadowSplits_.Size();
for (unsigned i = 0; i < numSplits; ++i)
CalculateShadowMatrix(shadowMatrices[i], lightQueue_, i, renderer, Vector3::ZERO);
graphics->SetShaderParameter(VSP_LIGHTMATRICES, shadowMatrices[0].Data(), 16 * numSplits);
}
break;
case LIGHT_SPOT:
{
Matrix4 shadowMatrices[2];
CalculateSpotMatrix(shadowMatrices[0], light, Vector3::ZERO);
bool isShadowed = shadowMap && graphics->HasTextureUnit(TU_SHADOWMAP);
if (isShadowed)
CalculateShadowMatrix(shadowMatrices[1], lightQueue_, 0, renderer, Vector3::ZERO);
graphics->SetShaderParameter(VSP_LIGHTMATRICES, shadowMatrices[0].Data(), isShadowed ? 32 : 16);
}
break;
case LIGHT_POINT:
{
Matrix4 lightVecRot(lightNode->GetWorldRotation().RotationMatrix());
// HLSL compiler will pack the parameters as if the matrix is only 3x4, so must be careful to not overwrite
// the next parameter
#ifdef URHO3D_OPENGL
graphics->SetShaderParameter(VSP_LIGHTMATRICES, lightVecRot.Data(), 16);
#else
graphics->SetShaderParameter(VSP_LIGHTMATRICES, lightVecRot.Data(), 12);
#endif
}
break;
}
}
float fade = 1.0f;
float fadeEnd = light->GetDrawDistance();
float fadeStart = light->GetFadeDistance();
// Do fade calculation for light if both fade & draw distance defined
if (light->GetLightType() != LIGHT_DIRECTIONAL && fadeEnd > 0.0f && fadeStart > 0.0f && fadeStart < fadeEnd)
fade = Min(1.0f - (light->GetDistance() - fadeStart) / (fadeEnd - fadeStart), 1.0f);
// Negative lights will use subtract blending, so write absolute RGB values to the shader parameter
graphics->SetShaderParameter(PSP_LIGHTCOLOR, Color(light->GetEffectiveColor().Abs(),
light->GetEffectiveSpecularIntensity()) * fade);
graphics->SetShaderParameter(PSP_LIGHTDIR, lightWorldRotation * Vector3::BACK);
graphics->SetShaderParameter(PSP_LIGHTPOS, Vector4((isLightVolume ? (lightNode->GetWorldPosition() -
cameraEffectivePos) : lightNode->GetWorldPosition()), atten));
if (graphics->HasShaderParameter(PS, PSP_LIGHTMATRICES))
{
switch (light->GetLightType())
{
case LIGHT_DIRECTIONAL:
{
Matrix4 shadowMatrices[MAX_CASCADE_SPLITS];
unsigned numSplits = lightQueue_->shadowSplits_.Size();
for (unsigned i = 0; i < numSplits; ++i)
{
CalculateShadowMatrix(shadowMatrices[i], lightQueue_, i, renderer, isLightVolume ? cameraEffectivePos :
Vector3::ZERO);
}
graphics->SetShaderParameter(PSP_LIGHTMATRICES, shadowMatrices[0].Data(), 16 * numSplits);
}
break;
case LIGHT_SPOT:
{
Matrix4 shadowMatrices[2];
CalculateSpotMatrix(shadowMatrices[0], light, cameraEffectivePos);
bool isShadowed = lightQueue_->shadowMap_ != 0;
if (isShadowed)
{
CalculateShadowMatrix(shadowMatrices[1], lightQueue_, 0, renderer, isLightVolume ? cameraEffectivePos :
Vector3::ZERO);
}
graphics->SetShaderParameter(PSP_LIGHTMATRICES, shadowMatrices[0].Data(), isShadowed ? 32 : 16);
}
break;
case LIGHT_POINT:
{
Matrix4 lightVecRot(lightNode->GetWorldRotation().RotationMatrix());
// HLSL compiler will pack the parameters as if the matrix is only 3x4, so must be careful to not overwrite
// the next parameter
#ifdef URHO3D_OPENGL
graphics->SetShaderParameter(PSP_LIGHTMATRICES, lightVecRot.Data(), 16);
#else
graphics->SetShaderParameter(PSP_LIGHTMATRICES, lightVecRot.Data(), 12);
#endif
}
break;
}
}
// Set shadow mapping shader parameters
if (shadowMap)
{
{
// Calculate point light shadow sampling offsets (unrolled cube map)
unsigned faceWidth = shadowMap->GetWidth() / 2;
unsigned faceHeight = shadowMap->GetHeight() / 3;
float width = (float)shadowMap->GetWidth();
float height = (float)shadowMap->GetHeight();
#ifdef URHO3D_OPENGL
float mulX = (float)(faceWidth - 3) / width;
float mulY = (float)(faceHeight - 3) / height;
float addX = 1.5f / width;
float addY = 1.5f / height;
#else
float mulX = (float)(faceWidth - 4) / width;
float mulY = (float)(faceHeight - 4) / height;
float addX = 2.5f / width;
float addY = 2.5f / height;
#endif
// If using 4 shadow samples, offset the position diagonally by half pixel
if (renderer->GetShadowQuality() & SHADOWQUALITY_HIGH_16BIT)
{
addX -= 0.5f / width;
addY -= 0.5f / height;
}
graphics->SetShaderParameter(PSP_SHADOWCUBEADJUST, Vector4(mulX, mulY, addX, addY));
}
{
// Calculate shadow camera depth parameters for point light shadows and shadow fade parameters for
// directional light shadows, stored in the same uniform
Camera* shadowCamera = lightQueue_->shadowSplits_[0].shadowCamera_;
float nearClip = shadowCamera->GetNearClip();
float farClip = shadowCamera->GetFarClip();
float q = farClip / (farClip - nearClip);
float r = -q * nearClip;
const CascadeParameters& parameters = light->GetShadowCascade();
float viewFarClip = camera_->GetFarClip();
float shadowRange = parameters.GetShadowRange();
float fadeStart = parameters.fadeStart_ * shadowRange / viewFarClip;
float fadeEnd = shadowRange / viewFarClip;
float fadeRange = fadeEnd - fadeStart;
graphics->SetShaderParameter(PSP_SHADOWDEPTHFADE, Vector4(q, r, fadeStart, 1.0f / fadeRange));
}
{
float intensity = light->GetShadowIntensity();
float fadeStart = light->GetShadowFadeDistance();
float fadeEnd = light->GetShadowDistance();
if (fadeStart > 0.0f && fadeEnd > 0.0f && fadeEnd > fadeStart)
intensity = Lerp(intensity, 1.0f, Clamp((light->GetDistance() - fadeStart) / (fadeEnd - fadeStart), 0.0f, 1.0f));
float pcfValues = (1.0f - intensity);
float samples = renderer->GetShadowQuality() >= SHADOWQUALITY_HIGH_16BIT ? 4.0f : 1.0f;
graphics->SetShaderParameter(PSP_SHADOWINTENSITY, Vector4(pcfValues / samples, intensity, 0.0f, 0.0f));
}
float sizeX = 1.0f / (float)shadowMap->GetWidth();
float sizeY = 1.0f / (float)shadowMap->GetHeight();
graphics->SetShaderParameter(PSP_SHADOWMAPINVSIZE, Vector4(sizeX, sizeY, 0.0f, 0.0f));
Vector4 lightSplits(M_LARGE_VALUE, M_LARGE_VALUE, M_LARGE_VALUE, M_LARGE_VALUE);
if (lightQueue_->shadowSplits_.Size() > 1)
lightSplits.x_ = lightQueue_->shadowSplits_[0].farSplit_ / camera_->GetFarClip();
if (lightQueue_->shadowSplits_.Size() > 2)
lightSplits.y_ = lightQueue_->shadowSplits_[1].farSplit_ / camera_->GetFarClip();
if (lightQueue_->shadowSplits_.Size() > 3)
lightSplits.z_ = lightQueue_->shadowSplits_[2].farSplit_ / camera_->GetFarClip();
graphics->SetShaderParameter(PSP_SHADOWSPLITS, lightSplits);
}
}
// Set material-specific shader parameters and textures
if (material_)
{
if (graphics->NeedParameterUpdate(SP_MATERIAL, material_))
{
// Update shader parameter animations
material_->UpdateShaderParameterAnimations();
const HashMap<StringHash, MaterialShaderParameter>& parameters = material_->GetShaderParameters();
for (HashMap<StringHash, MaterialShaderParameter>::ConstIterator i = parameters.Begin(); i != parameters.End(); ++i)
graphics->SetShaderParameter(i->first_, i->second_.value_);
}
const SharedPtr<Texture>* textures = material_->GetTextures();
for (unsigned i = 0; i < MAX_MATERIAL_TEXTURE_UNITS; ++i)
{
TextureUnit unit = (TextureUnit)i;
if (textures[i] && graphics->HasTextureUnit(unit))
graphics->SetTexture(i, textures[i]);
}
}
// Set light-related textures
if (light)
{
if (shadowMap && graphics->HasTextureUnit(TU_SHADOWMAP))
graphics->SetTexture(TU_SHADOWMAP, shadowMap);
if (graphics->HasTextureUnit(TU_LIGHTRAMP))
{
Texture* rampTexture = light->GetRampTexture();
if (!rampTexture)
rampTexture = renderer->GetDefaultLightRamp();
graphics->SetTexture(TU_LIGHTRAMP, rampTexture);
}
if (graphics->HasTextureUnit(TU_LIGHTSHAPE))
{
Texture* shapeTexture = light->GetShapeTexture();
if (!shapeTexture && light->GetLightType() == LIGHT_SPOT)
shapeTexture = renderer->GetDefaultLightSpot();
graphics->SetTexture(TU_LIGHTSHAPE, shapeTexture);
}
}
}
//! show on scene
void Edge::show()
{
adjust();
QGraphicsItem::show();
name->show();
}
//現在値を強制変更
void setNow(const float now)
{
m_now = now;
adjust();
}
void Edge::setSourceNode(Node *node)
{
source = node;
adjust();
}
const RotMat &RotMat::rotateZ( GLfloat theta, bool postmult ) {
return adjust( Angel::RotateZ( theta ), postmult );
}
void Edge::setDestNode(Node *node)
{
dest = node;
adjust();
}
void QHexEditPrivate::setAddressArea(bool addressArea)
{
_addressArea = addressArea;
adjust();
setCursorPos(_cursorPosition);
}
void pop(Node *heap, int p, int &len)
{
heap[p] = heap[--len];
adjust(heap, p, len);
}
void QHexEditPrivate::setFont(const QFont &font)
{
QWidget::setFont(font);
adjust();
}
void
ACE_SizeCDR::adjust (size_t size)
{
adjust (size, size);
}
void QHexEditPrivate::setAddressOffset(int offset)
{
_addressOffset = offset;
adjust();
}
void
StereoHarm::processReplacing (float **inputs,
float **outputs,
int sampleFrames)
{
int i;
param->PERIOD = sampleFrames;
param->fPERIOD = param->PERIOD;
adjust(DS_state);
float *inputs2[2];
inputs2[0] = new float[nPERIOD+100];
inputs2[1] = new float[nPERIOD+100];
if(DS_state != 0) {
memcpy(templ, inputs[0],sizeof(float)*param->PERIOD);
memcpy(tempr, inputs[1],sizeof(float)*param->PERIOD);
U_Resample->out(templ,tempr,inputs2[0],inputs2[1],param->PERIOD,u_up);
}
else
{
memcpy(inputs2[0], inputs[0],sizeof(float)*param->PERIOD);
memcpy(inputs2[1], inputs[1],sizeof(float)*param->PERIOD);
}
for (i = 0; i < nPERIOD; i++) {
outil[i] = inputs2[0][i] * (1.0f - lrcross) + inputs2[1][i] * lrcross;
if (outil[i] > 1.0)
outil[i] = 1.0f;
if (outil[i] < -1.0)
outil[i] = -1.0f;
outir[i] = inputs2[1][i] * (1.0f - lrcross) + inputs2[0][i] * lrcross;
if (outir[i] > 1.0)
outir[i] = 1.0f;
if (outir[i] < -1.0)
outir[i] = -1.0f;
}
if ((PMIDI) || (PSELECT)) {
PSl->ratio = param->r__ratio[1];
PSr->ratio = param->r__ratio[2];
}
if (PSl->ratio != 1.0f) {
PSl->smbPitchShift (PSl->ratio, nPERIOD, window, hq, nfSAMPLE_RATE, outil, outol);
} else
memcpy(outol,outil,sizeof(float)*nPERIOD);
if (PSr->ratio != 1.0f) {
PSr->smbPitchShift (PSr->ratio, nPERIOD, window, hq, nfSAMPLE_RATE, outir, outor);
} else
memcpy(outor,outir,sizeof(float)*nPERIOD);
if(DS_state != 0) {
D_Resample->out(outol,outor,templ,tempr,nPERIOD,u_down);
} else {
memcpy(templ, outol,sizeof(float)*param->PERIOD);
memcpy(tempr, outor,sizeof(float)*param->PERIOD);
}
for (i = 0; i < param->PERIOD; i++) {
outputs[0][i] = templ[i] * gainl;
outputs[1][i] = tempr[i] * gainr;
}
delete[] inputs2[0];
delete[] inputs2[1];
};
bool SessionImpl::getIncoming(IncomingMessages::Handler& handler, qpid::messaging::Duration timeout)
{
return incoming.get(handler, adjust(timeout));
}
heapify(struct node *a[],int n)
{
int i;
for(i=n/2;i>=1;i--)
adjust(a,i,n);
}
void QHexEdit::resizeEvent(QResizeEvent *)
{
adjust();
}
Vector Orientation::variance_from_sd(float sdx, float sdy, float sdz) const {
Vector result(sdx, sdy, sdz);
adjust(result);
for (int n = 0; n < 3; n++) result[n] *= result[n];
return result;
}
