//-------------------------------------------------------------------------------------------
//!
//-------------------------------------------------------------------------------------------
tPageBase::tPageBase( const Page::ePageId id, const QString& title, tIInstrumentProductFactory* pProductFactory, tInstrumentState* pAppState , QWidget* pParent )
: QWidget( pParent )
,m_Id( id )
,m_Title( title )
,m_pProductFactory( pProductFactory )
,m_pAppState( pAppState )
{
Assert( m_pProductFactory );
setAutoFillBackground( true );
m_InstanceCount++;
m_pMainLayout = new QGridLayout( this );
m_pMainLayout->setContentsMargins( 0, 0, 0, 0 );
m_pMainLayout->setSpacing( 0 );
m_pTitleLabel = new QLabel( m_Title, this );
m_pTitleLabel->hide();
m_pMainLayout->addWidget( m_pTitleLabel, 0, 0, Qt::AlignCenter );
setLayout( m_pMainLayout );
CreateCommonActions();
Connect( tInstrumentUiSettings::Instance(), SIGNAL( ColorChanged() ), this, SLOT( UpdateColors() ) );
Connect( tSystemSettings::Instance(), SIGNAL( NightModeChanged(bool,bool) ), this, SLOT( UpdateColors() ) );
Connect( tUiSettings::Instance(), SIGNAL( NightModeTextColorChanged( eNightModeTextColor ) ), this, SLOT( UpdateColors() ) );
UpdateColors();
}
void CWidget::InitDraw()
{
if (m_bSizeChanged)
{
m_bSizeChanged = false;
MoveWindow(0, 0); // Move to a safe position first
WindowResize(this, Width(), Height());
MoveWindow(X(), Y());
UpdateSize();
TUI.QueueRefresh();
}
if (m_bColorsChanged)
{
if (m_bFocused)
wbkgdset(m_pNCursWin, ' ' | TUI.GetColorPair(m_FColors.first, m_FColors.second) | A_BOLD);
else
wbkgdset(m_pNCursWin, ' ' | TUI.GetColorPair(m_DFColors.first, m_DFColors.second) | A_BOLD);
m_bColorsChanged = false;
UpdateColors();
}
WindowErase(this);
if (HasBox())
Border(this);
}
ibool Launcher::Colors::OnCmdDefault(Param&)
{
background.color = DEF_BACKGROUND_COLOR;
foreground.color = DEF_FOREGROUND_COLOR;
UpdateColors();
return true;
}
void CGUIControl::SetInitialVisibility()
{
if (m_visibleCondition)
{
m_visibleFromSkinCondition = m_visibleCondition->Get();
m_visible = m_visibleFromSkinCondition ? VISIBLE : HIDDEN;
// CLog::Log(LOGDEBUG, "Set initial visibility for control %i: %s", m_controlID, m_visible == VISIBLE ? "visible" : "hidden");
}
else if (m_visible == DELAYED)
m_visible = VISIBLE;
// and handle animation conditions as well
for (unsigned int i = 0; i < m_animations.size(); i++)
{
CAnimation &anim = m_animations[i];
if (anim.GetType() == ANIM_TYPE_CONDITIONAL)
anim.SetInitialCondition();
}
// and check for conditional enabling - note this overrides SetEnabled() from the code currently
// this may need to be reviewed at a later date
if (m_enableCondition)
m_enabled = m_enableCondition->Get();
m_allowHiddenFocus.Update();
UpdateColors();
MarkDirtyRegion();
}
ibool Preferences::OnCmdMenuColorChange(Param& param)
{
if (param.Button().Clicked())
{
static COLORREF customColors[16] = {0};
Object::Pod<CHOOSECOLOR> cc;
MenuColorWindow& type = menuColorWindows[param.Button().GetId() == IDC_PREFERENCES_MENUCOLOR_FULLSCREEN_CHANGE];
cc.lStructSize = sizeof(cc);
cc.hwndOwner = dialog;
cc.lpCustColors = customColors;
cc.rgbResult = type.color;
cc.Flags = CC_FULLOPEN|CC_RGBINIT;
if (::ChooseColor( &cc ))
{
type.color = cc.rgbResult;
UpdateColors();
}
}
return true;
}
void Button::SetAcionDownState(){
if(is_toggle_button)
state_clicked = !state_clicked;
else
state_clicked = true;
UpdateColors();
}
ibool Preferences::OnInitDialog(Param&)
{
for (uint i=0; i < 2; ++i)
{
MenuColorWindow& type = menuColorWindows[i];
type.color = i ? settings.menuLookFullscreen.color : settings.menuLookDesktop.color;
type.rect = dialog.Control(i ? IDC_PREFERENCES_MENUCOLOR_FULLSCREEN_CHANGE : IDC_PREFERENCES_MENUCOLOR_DESKTOP_CHANGE).GetWindow().Coordinates();
type.rect.Position() -= Point(type.rect.Width()+8,0);
type.rect.ClientTransform( dialog );
}
dialog.Control( IDC_PREFERENCES_MENUCOLOR_DESKTOP_CHANGE ).Enable( settings.menuLookDesktop.enabled );
dialog.Control( IDC_PREFERENCES_MENUCOLOR_FULLSCREEN_CHANGE ).Enable( settings.menuLookFullscreen.enabled );
dialog.CheckBox( IDC_PREFERENCES_MENUCOLOR_DESKTOP_DEFAULT ).Check( !settings.menuLookDesktop.enabled );
dialog.CheckBox( IDC_PREFERENCES_MENUCOLOR_FULLSCREEN_DEFAULT ).Check( !settings.menuLookFullscreen.enabled );
for (uint i=0; i < NUM_SETTINGS; ++i)
{
if (i != SAVE_SETTINGS)
dialog.CheckBox( IDC_PREFERENCES_STARTUP_FULLSCREEN + i ).Check( settings[i] );
}
{
Association association;
for (uint i=0; i < Association::NUM_EXTENSIONS; ++i)
dialog.CheckBox( IDC_PREFERENCES_ASSOCIATE_NES + i ).Check( association.Enabled(i) );
}
dialog.RadioButton( IDC_PREFERENCES_FAVORED_NES_NTSC ).Check( settings.favoredSystem == Nes::Machine::FAVORED_NES_NTSC );
dialog.RadioButton( IDC_PREFERENCES_FAVORED_NES_PAL ).Check( settings.favoredSystem == Nes::Machine::FAVORED_NES_PAL );
dialog.RadioButton( IDC_PREFERENCES_FAVORED_FAMICOM ).Check( settings.favoredSystem == Nes::Machine::FAVORED_FAMICOM );
dialog.RadioButton( IDC_PREFERENCES_FAVORED_DENDY ).Check( settings.favoredSystem == Nes::Machine::FAVORED_DENDY );
dialog.CheckBox( IDC_PREFERENCES_FAVORED_ALWAYS_ASK ).Check( settings.alwaysAskSystem );
{
Control::ComboBox priorities( dialog.ComboBox( IDC_PREFERENCES_PRIORITY ) );
for (uint i=IDS_PRIORITY_NORMAL; i <= IDS_PRIORITY_HIGH; ++i)
priorities.Add( Resource::String(i) );
priorities[settings.priority].Select();
}
dialog.RadioButton( IDC_PREFERENCES_STYLE_NES ).Check( Application::Instance::GetIconStyle() == Application::Instance::ICONSTYLE_NES );
dialog.RadioButton( IDC_PREFERENCES_STYLE_FAMICOM ).Check( Application::Instance::GetIconStyle() == Application::Instance::ICONSTYLE_FAMICOM );
UpdateIconStyle();
UpdateColors();
return true;
}
void CPathDialog::InitDialogBar()
{
CW3ZMapEditApp *pTheApp = (CW3ZMapEditApp *)AfxGetApp();
ASSERT_VALID(pTheApp);
m_iPenSize = pTheApp->m_ToolPathEdit.GetToolSize();
UpdateData(FALSE);
m_btnNoWalk.SetTriState(TRUE);
m_btnNoWalk.SetTextOnly(TRUE);
m_btnNoWalk.SetWindowText(STR_PATH_NOWALK);
m_btnNoWalk.SetState(EB_STATE0);
m_btnNoWalk.SetColorState2(0x0000C000);
m_btnNoBuild.SetTriState(TRUE);
m_btnNoBuild.SetTextOnly(TRUE);
m_btnNoBuild.SetState(EB_STATE0);
m_btnNoBuild.SetColorState2(0x0000C000);
m_btnNoFly.SetTriState(TRUE);
m_btnNoFly.SetTextOnly(TRUE);
m_btnNoFly.SetState(EB_STATE0);
m_btnNoFly.SetColorState2(0x0000C000);
m_btnBlight.SetTriState(TRUE);
m_btnBlight.SetTextOnly(TRUE);
m_btnBlight.SetState(EB_STATE0);
m_btnBlight.SetColorState2(0x0000C000);
m_btnNoWater.SetTriState(TRUE);
m_btnNoWater.SetTextOnly(TRUE);
m_btnNoWater.SetState(EB_STATE0);
m_btnNoWater.SetColorState2(0x0000C000);
m_btnUnknown.SetTriState(TRUE);
m_btnUnknown.SetTextOnly(TRUE);
m_btnUnknown.SetState(EB_STATE0);
m_btnUnknown.SetColorState2(0x0000C000);
m_btnUnkn01.SetTriState(TRUE);
m_btnUnkn01.SetTextOnly(TRUE);
m_btnUnkn01.SetState(EB_STATE0);
m_btnUnkn01.SetColorState2(0x0000C000);
m_btnUnkn02.SetTriState(TRUE);
m_btnUnkn02.SetTextOnly(TRUE);
m_btnUnkn02.SetState(EB_STATE0);
m_btnUnkn02.SetColorState2(0x0000C000);
UpdateColors();
UpdateCurrentColor();
}
void DeskbarPulseView::MessageReceived(BMessage *message) {
switch (message->what) {
case PV_NORMAL_MODE:
SetMode(true);
Remove();
break;
case PV_MINI_MODE:
SetMode(false);
Remove();
break;
case PV_PREFERENCES:
if (prefswindow != NULL) {
prefswindow->Activate(true);
break;
}
prefswindow = new PrefsWindow(prefs->prefs_window_rect,
"Pulse settings", new BMessenger(this), prefs);
prefswindow->Show();
break;
case PV_ABOUT: {
PulseApp::ShowAbout(false);
break;
}
case PV_QUIT:
Remove();
break;
case PRV_DESKBAR_CHANGE_COLOR:
UpdateColors(message);
break;
case PRV_DESKBAR_ICON_WIDTH: {
int width = message->FindInt32("width");
ResizeTo(width - 1, 15);
Draw(Bounds());
break;
}
case PV_REPLICANT_PULSE:
Update();
Draw(Bounds());
break;
case PRV_QUIT:
prefswindow = NULL;
break;
case PV_CPU_MENU_ITEM:
ChangeCPUState(message);
break;
default:
BView::MessageReceived(message);
break;
}
}
void LaserScanPlugin::SelectMaxColor()
{
QColorDialog dialog(max_color_, config_widget_);
dialog.exec();
if (dialog.result() == QDialog::Accepted)
{
max_color_ = dialog.selectedColor();
ui_.selectMaxColor->setStyleSheet("background: " + max_color_.name() + ";");
DrawIcon();
UpdateColors();
canvas_->update();
}
}
tTripDialog::tTripDialog( tIInstrumentProductFactory* pProductFactory, QWidget* pParent, int tripNumber )
: tDialog( tDialog::Full, pParent )
, m_TripNumber(tripNumber)
{
Assert( pProductFactory );
if ( pProductFactory )
{
QString title = tr( "Trip", "[title]" );
title += QString(" %1").arg(tripNumber + 1);
setWindowTitle( title );
QGridLayout* pGridLayout = new QGridLayout();
pGridLayout->setContentsMargins( 0, 0, 0, 0 );
pGridLayout->setSpacing( 0 );
int row = 0;
int col = 0;
m_pGauge1 = pProductFactory->GetDigitalGauge( tDataId(DATA_TYPE_TRIP_DISTANCE, m_TripNumber), this );
m_pGauge1->SetBorders( false, false, true, true );
pGridLayout->addWidget( m_pGauge1, row++, col );
m_pGauge2 = pProductFactory->GetDigitalGauge( tDataId(DATA_TYPE_SPEED_TRIP_AVG, m_TripNumber), this );
m_pGauge2->SetBorders( false, false, true, false );
pGridLayout->addWidget( m_pGauge2, row++, col );
row = 0;
col++;
m_pGauge3 = pProductFactory->GetDigitalGauge( tDataId(DATA_TYPE_TRIP_TIME, m_TripNumber), this );
m_pGauge3->SetBorders( false, false, false, true );
pGridLayout->addWidget( m_pGauge3, row++, col );
m_pGauge4 = pProductFactory->GetDigitalGauge( tDataId(DATA_TYPE_SPEED_TRIP_MAX, m_TripNumber), this );
m_pGauge4->SetBorders( false );
pGridLayout->addWidget( m_pGauge4, row++, col );
setLayout( pGridLayout );
CreateActions();
Connect( tSystemSettings::Instance(), SIGNAL( NightModeChanged(bool,bool) ), this, SLOT( UpdateColors() ) );
Connect( tUiSettings::Instance(), SIGNAL( NightModeTextColorChanged( eNightModeTextColor ) ), this, SLOT( UpdateColors() ) );
UpdateColors();
}
}
void CGUIControl::UpdateVisibility(const CGUIListItem *item)
{
if (m_visibleCondition)
{
bool bWasVisible = m_visibleFromSkinCondition;
m_visibleFromSkinCondition = m_visibleCondition->Get(item);
if (!bWasVisible && m_visibleFromSkinCondition)
{ // automatic change of visibility - queue the in effect
// CLog::Log(LOGDEBUG, "Visibility changed to visible for control id %i", m_controlID);
QueueAnimation(ANIM_TYPE_VISIBLE);
}
else if (bWasVisible && !m_visibleFromSkinCondition)
{ // automatic change of visibility - do the out effect
// CLog::Log(LOGDEBUG, "Visibility changed to hidden for control id %i", m_controlID);
QueueAnimation(ANIM_TYPE_HIDDEN);
}
}
// check for conditional animations
for (unsigned int i = 0; i < m_animations.size(); i++)
{
CAnimation &anim = m_animations[i];
if (anim.GetType() == ANIM_TYPE_CONDITIONAL)
anim.UpdateCondition(item);
}
// and check for conditional enabling - note this overrides SetEnabled() from the code currently
// this may need to be reviewed at a later date
bool enabled = m_enabled;
if (m_enableCondition)
m_enabled = m_enableCondition->Get(item);
if (m_enabled != enabled)
MarkDirtyRegion();
m_allowHiddenFocus.Update(item);
if (UpdateColors())
MarkDirtyRegion();
// and finally, update our control information (if not pushed)
if (!m_pushedUpdates)
UpdateInfo(item);
}
ibool Preferences::OnCmdDefault(Param&)
{
dialog.CheckBox( IDC_PREFERENCES_BEGIN_EMULATION ).Check( true );
dialog.CheckBox( IDC_PREFERENCES_RUN_IN_BACKGROUND ).Check( false );
dialog.CheckBox( IDC_PREFERENCES_STARTUP_FULLSCREEN ).Check( false );
dialog.CheckBox( IDC_PREFERENCES_DISABLE_ROM_WARNINGS ).Check( false );
dialog.CheckBox( IDC_PREFERENCES_CLOSE_POWER_OFF ).Check( false );
dialog.CheckBox( IDC_PREFERENCES_CONFIRM_EXIT ).Check( true );
dialog.CheckBox( IDC_PREFERENCES_CONFIRM_RESET ).Check( false );
dialog.CheckBox( IDC_PREFERENCES_MULTIPLE_INSTANCES ).Check( false );
dialog.CheckBox( IDC_PREFERENCES_SAVE_LOGFILE ).Check( true );
dialog.CheckBox( IDC_PREFERENCES_SAVE_LAUNCHER ).Check( true );
dialog.CheckBox( IDC_PREFERENCES_SAVE_CHEATCODES ).Check( true );
dialog.CheckBox( IDC_PREFERENCES_SAVE_NETPLAY_GAMELIST ).Check( true );
dialog.CheckBox( IDC_PREFERENCES_SAVE_WINDOWPOS ).Check( false );
dialog.CheckBox( IDC_PREFERENCES_SAVE_LAUNCHERSIZE ).Check( false );
dialog.ComboBox( IDC_PREFERENCES_PRIORITY )[ PRIORITY_NORMAL ].Select();
dialog.RadioButton( IDC_PREFERENCES_FAVORED_NES_NTSC ).Check( true );
dialog.RadioButton( IDC_PREFERENCES_FAVORED_NES_PAL ).Check( false );
dialog.RadioButton( IDC_PREFERENCES_FAVORED_FAMICOM ).Check( false );
dialog.RadioButton( IDC_PREFERENCES_FAVORED_DENDY ).Check( false );
dialog.CheckBox( IDC_PREFERENCES_FAVORED_ALWAYS_ASK ).Check( false );
dialog.CheckBox( IDC_PREFERENCES_MENUCOLOR_DESKTOP_DEFAULT ).Check( true );
dialog.CheckBox( IDC_PREFERENCES_MENUCOLOR_FULLSCREEN_DEFAULT ).Check( true );
dialog.Control( IDC_PREFERENCES_MENUCOLOR_DESKTOP_CHANGE ).Enable( false );
dialog.Control( IDC_PREFERENCES_MENUCOLOR_FULLSCREEN_CHANGE ).Enable( false );
menuColorWindows[0].color = DEFAULT_DESKTOP_MENU_COLOR;
menuColorWindows[1].color = DEFAULT_FULLSCREEN_MENU_COLOR;
UpdateColors();
return true;
}
LRESULT CALLBACK WndProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam) {
switch(msg) {
case WM_SIZE:
swidth=LOWORD(lParam); sheight=HIWORD(lParam);
resize(LOWORD(lParam),HIWORD(lParam));
releaseDIB(dibDC);
initDIB(dibDC,LOWORD(lParam),HIWORD(lParam));
InvalidateRect(hWnd,NULL,FALSE);
break;
case WM_KEYDOWN:
keyDown(wParam);
break;
case WM_KEYUP:
keyUp(wParam);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
case WM_QUERYNEWPALETTE:
if(!hPalette)
break;
SelectPalette(hdc,hPalette,FALSE);
RealizePalette(hdc);
InvalidateRect(hWnd,NULL,FALSE);
break;
case WM_PALETTECHANGED:
if(!hPalette||(HWND)wParam==hWnd)
break;
SelectPalette(hdc,hPalette,FALSE);
RealizePalette(hdc);
UpdateColors(hdc);
break;
default:
return DefWindowProc(hWnd,msg,wParam,lParam);
}
return 0;
}
LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static BITMAPINFO * pPackedDib ;
static HPALETTE hPalette ;
static int cxClient, cyClient ;
static OPENFILENAME ofn ;
static TCHAR szFileName [MAX_PATH], szTitleName [MAX_PATH] ;
static TCHAR szFilter[] = TEXT ("Bitmap Files (*.BMP)\0*.bmp\0")
TEXT ("All Files (*.*)\0*.*\0\0") ;
HDC hdc ;
PAINTSTRUCT ps ;
switch (message)
{
case WM_CREATE:
ofn.lStructSize = sizeof (OPENFILENAME) ;
ofn.hwndOwner = hwnd ;
ofn.hInstance = NULL ;
ofn.lpstrFilter = szFilter ;
ofn.lpstrCustomFilter = NULL ;
ofn.nMaxCustFilter = 0 ;
ofn.nFilterIndex = 0 ;
ofn.lpstrFile = szFileName ;
ofn.nMaxFile = MAX_PATH ;
ofn.lpstrFileTitle = szTitleName ;
ofn.nMaxFileTitle = MAX_PATH ;
ofn.lpstrInitialDir = NULL ;
ofn.lpstrTitle = NULL ;
ofn.Flags = 0 ;
ofn.nFileOffset = 0 ;
ofn.nFileExtension = 0 ;
ofn.lpstrDefExt = TEXT ("bmp") ;
ofn.lCustData = 0 ;
ofn.lpfnHook = NULL ;
ofn.lpTemplateName = NULL ;
// Create the All-Purpose Palette
hdc = GetDC (hwnd) ;
hPalette = CreateHalftonePalette (hdc) ;
ReleaseDC (hwnd, hdc) ;
return 0 ;
case WM_SIZE:
cxClient = LOWORD (lParam) ;
cyClient = HIWORD (lParam) ;
return 0 ;
case WM_COMMAND:
switch (LOWORD (wParam))
{
case IDM_FILE_OPEN:
// Show the File Open dialog box
if (!GetOpenFileName (&ofn))
return 0 ;
// If there's an existing packed DIB, free the memory
if (pPackedDib)
{
free (pPackedDib) ;
pPackedDib = NULL ;
}
// Load the packed DIB into memory
SetCursor (LoadCursor (NULL, IDC_WAIT)) ;
ShowCursor (TRUE) ;
pPackedDib = PackedDibLoad (szFileName) ;
ShowCursor (FALSE) ;
SetCursor (LoadCursor (NULL, IDC_ARROW)) ;
if (!pPackedDib)
{
MessageBox (hwnd, TEXT ("Cannot load DIB file"),
szAppName, 0) ;
}
InvalidateRect (hwnd, NULL, TRUE) ;
return 0 ;
}
break ;
case WM_PAINT:
hdc = BeginPaint (hwnd, &ps) ;
if (pPackedDib)
{
// Set halftone stretch mode
SetStretchBltMode (hdc, HALFTONE) ;
SetBrushOrgEx (hdc, 0, 0, NULL) ;
// Select and realize halftone palette
SelectPalette (hdc, hPalette, FALSE) ;
RealizePalette (hdc) ;
// StretchDIBits rather than SetDIBitsToDevice
StretchDIBits (hdc,
0,
0,
PackedDibGetWidth (pPackedDib),
PackedDibGetHeight (pPackedDib),
0,
0,
PackedDibGetWidth (pPackedDib),
PackedDibGetHeight (pPackedDib),
PackedDibGetBitsPtr (pPackedDib),
pPackedDib,
DIB_RGB_COLORS,
SRCCOPY) ;
}
EndPaint (hwnd, &ps) ;
return 0 ;
case WM_QUERYNEWPALETTE:
hdc = GetDC (hwnd) ;
SelectPalette (hdc, hPalette, FALSE) ;
RealizePalette (hdc) ;
InvalidateRect (hwnd, NULL, TRUE) ;
ReleaseDC (hwnd, hdc) ;
return TRUE ;
case WM_PALETTECHANGED:
if ((HWND) wParam != hwnd)
hdc = GetDC (hwnd) ;
SelectPalette (hdc, hPalette, FALSE) ;
RealizePalette (hdc) ;
UpdateColors (hdc) ;
ReleaseDC (hwnd, hdc) ;
break ;
case WM_DESTROY:
if (pPackedDib)
free (pPackedDib) ;
DeleteObject (hPalette) ;
PostQuitMessage (0) ;
return 0 ;
}
return DefWindowProc (hwnd, message, wParam, lParam) ;
}
VOID vTestXlates(HDC hdc, RECT *prcl)
{
HPALETTE ahpal[4];
HPALETTE hPalOld;
DWORD ulTemp;
LOGPALETTE256 alog256[4];
alog256[0].palVersion = 0x300;
alog256[0].palNumEntries = 256;
alog256[1].palVersion = 0x300;
alog256[1].palNumEntries = 256;
alog256[2].palVersion = 0x300;
alog256[2].palNumEntries = 256;
alog256[3].palVersion = 0x300;
alog256[3].palNumEntries = 256;
for (ulTemp = 0; ulTemp < 256; ulTemp++)
{
alog256[0].palPalEntry[ulTemp].peRed = ulTemp;
alog256[0].palPalEntry[ulTemp].peBlue = 0;
alog256[0].palPalEntry[ulTemp].peGreen = 0;
alog256[0].palPalEntry[ulTemp].peFlags = 0;
alog256[1].palPalEntry[ulTemp].peRed = 0;
alog256[1].palPalEntry[ulTemp].peBlue = ulTemp;
alog256[1].palPalEntry[ulTemp].peGreen = 0;
alog256[1].palPalEntry[ulTemp].peFlags = 0;
alog256[2].palPalEntry[ulTemp].peRed = 0;
alog256[2].palPalEntry[ulTemp].peBlue = 0;
alog256[2].palPalEntry[ulTemp].peGreen = ulTemp;
alog256[2].palPalEntry[ulTemp].peFlags = PC_RESERVED;
alog256[3].palPalEntry[ulTemp].peRed = ulTemp;
alog256[3].palPalEntry[ulTemp].peBlue = ulTemp;
alog256[3].palPalEntry[ulTemp].peGreen = ulTemp;
alog256[3].palPalEntry[ulTemp].peFlags = PC_RESERVED;
}
ahpal[0] = CreatePalette((LOGPALETTE *) &alog256[0]);
ahpal[1] = CreatePalette((LOGPALETTE *) &alog256[1]);
ahpal[2] = CreatePalette((LOGPALETTE *) &alog256[2]);
ahpal[3] = CreatePalette((LOGPALETTE *) &alog256[3]);
hPalOld = SelectPalette(hdc,ahpal[0],0);
for (ulTemp = 0; ulTemp < 20; ulTemp++)
{
SelectPalette(hdc, ahpal[ulTemp % 4], 0);
RealizePalette(hdc);
UpdateColors(hdc);
SetPaletteEntries(ahpal[ulTemp % 4], 0, 256, alog256[ulTemp % 4].palPalEntry);
RealizePalette(hdc);
UpdateColors(hdc);
}
SelectPalette(hdc,hPalOld,0);
DeleteObject(ahpal[0]);
DeleteObject(ahpal[1]);
DeleteObject(ahpal[2]);
DeleteObject(ahpal[3]);
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT messg,
WPARAM wParam, LPARAM lParam)
{
int i;
static bool palette_changed = false;
switch (messg) {
case WM_PAINT:
if (hdc[0] == 0) {
hdc[0] = BeginPaint(hWnd, &ps);
SelectPalette(hdc[0], hPalette, FALSE);
RealizePalette(hdc[0]);
hdc[1] = CreateCompatibleDC(hdc[0]);
SelectPalette(hdc[1], hPalette, FALSE);
hdc[2] = CreateCompatibleDC(hdc[0]);
SelectPalette(hdc[2], hPalette, FALSE);
hdc[3] = CreateCompatibleDC(hdc[0]);
SelectPalette(hdc[3], hPalette, FALSE);
screen_width = GetDeviceCaps(hdc[0], HORZRES);
screen_height = GetDeviceCaps(hdc[0], VERTRES);
hBitmap[active_page] =
CreateCompatibleBitmap(hdc[0], screen_width, screen_height);
SelectObject(hdc[1], hBitmap[active_page]);
SetTextColor(hdc[0], PALETTEINDEX(text_color+BG));
SetTextColor(hdc[1], PALETTEINDEX(text_color+BG));
SetBkColor(hdc[0], PALETTEINDEX(BG));
SetBkColor(hdc[1], PALETTEINDEX(BG));
SelectObject(hdc[0], hBrush[fill_settings.pattern]);
SelectObject(hdc[1], hBrush[fill_settings.pattern]);
RECT scr;
scr.left = -view_settings.left;
scr.top = -view_settings.top;
scr.right = screen_width-view_settings.left-1;
scr.bottom = screen_height-view_settings.top-1;
FillRect(hdc[1], &scr, hBackgroundBrush);
}
if (hRgn != NULL) {
SelectClipRgn(hdc[0], NULL);
}
if (visual_page != active_page) {
SelectObject(hdc[1], hBitmap[visual_page]);
}
BitBlt(hdc[0], -view_settings.left,
-view_settings.top, window_width, window_height,
hdc[1], -view_settings.left, -view_settings.top,
SRCCOPY);
if (hRgn != NULL) {
SelectClipRgn(hdc[0], hRgn);
}
if (visual_page != active_page) {
SelectObject(hdc[1], hBitmap[active_page]);
}
ValidateRect(hWnd, NULL);
break;
case WM_SETFOCUS:
if (palette_changed) {
HPALETTE new_palette = CreatePalette(pPalette);
SelectPalette(hdc[0], new_palette, FALSE);
RealizePalette(hdc[0]);
SelectPalette(hdc[1], new_palette, FALSE);
SelectPalette(hdc[2], new_palette, FALSE);
SelectPalette(hdc[3], new_palette, FALSE);
DeleteObject(hPalette);
hPalette = new_palette;
palette_changed = false;
}
break;
case WM_PALETTECHANGED:
RealizePalette(hdc[0]);
UpdateColors(hdc[0]);
palette_changed = true;
break;
case WM_DESTROY:
EndPaint(hWnd, &ps);
hdc[0] = 0;
DeleteObject(hdc[1]);
DeleteObject(hdc[2]);
DeleteObject(hdc[3]);
if (hPutimageBitmap) {
DeleteObject(hPutimageBitmap);
hPutimageBitmap = NULL;
}
for (i = 0; i < MAX_PAGES; i++) {
if (hBitmap[i] != NULL) {
DeleteObject(hBitmap[i]);
hBitmap[i] = 0;
}
}
DeleteObject(hPalette);
hPalette = 0;
PostQuitMessage(0);
break;
case WM_SIZE:
window_width = LOWORD(lParam);
window_height = HIWORD(lParam);
break;
case WM_TIMER:
KillTimer(hWnd, TIMER_ID);
timeout_expired = true;
break;
case WM_CHAR:
kbd_queue.put((TCHAR) wParam);
break;
// Handle some mouse events, too (1-Oct-2000, Matthew Weathers, Erik Habbestad)
case WM_LBUTTONDOWN:
iClickedMouseX = LOWORD(lParam);
iClickedMouseY = HIWORD(lParam);
bMouseDown = true;
iWhichMouseButton = LEFT_BUTTON;
break;
case WM_LBUTTONUP:
iClickedMouseX = LOWORD(lParam);
iClickedMouseY = HIWORD(lParam);
bMouseUp = true;
iWhichMouseButton = LEFT_BUTTON;
break;
case WM_RBUTTONDOWN:
iClickedMouseX = LOWORD(lParam);
iClickedMouseY = HIWORD(lParam);
bMouseDown = true;
iWhichMouseButton = RIGHT_BUTTON;
break;
case WM_RBUTTONUP:
iClickedMouseX = LOWORD(lParam);
iClickedMouseY = HIWORD(lParam);
bMouseUp = true;
iWhichMouseButton = RIGHT_BUTTON;
break;
case WM_MOUSEMOVE:
iCurrentMouseX = LOWORD(lParam);
iCurrentMouseY = HIWORD(lParam);
break;
default:
return DefWindowProc(hWnd, messg, wParam, lParam);
}
return 0;
}
LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static HBITMAP hBitmap ;
static HPALETTE hPalette ;
static int cxClient, cyClient ;
static OPENFILENAME ofn ;
static PBYTE pBits ;
static TCHAR szFileName [MAX_PATH], szTitleName [MAX_PATH] ;
static TCHAR szFilter[] = TEXT ("Bitmap Files (*.BMP)\0*.bmp\0")
TEXT ("All Files (*.*)\0*.*\0\0") ;
BITMAP bitmap ;
BITMAPINFO * pPackedDib ;
HDC hdc, hdcMem ;
PAINTSTRUCT ps ;
switch (message)
{
case WM_CREATE:
ofn.lStructSize = sizeof (OPENFILENAME) ;
ofn.hwndOwner = hwnd ;
ofn.hInstance = NULL ;
ofn.lpstrFilter = szFilter ;
ofn.lpstrCustomFilter = NULL ;
ofn.nMaxCustFilter = 0 ;
ofn.nFilterIndex = 0 ;
ofn.lpstrFile = szFileName ;
ofn.nMaxFile = MAX_PATH ;
ofn.lpstrFileTitle = szTitleName ;
ofn.nMaxFileTitle = MAX_PATH ;
ofn.lpstrInitialDir = NULL ;
ofn.lpstrTitle = NULL ;
ofn.Flags = 0 ;
ofn.nFileOffset = 0 ;
ofn.nFileExtension = 0 ;
ofn.lpstrDefExt = TEXT ("bmp") ;
ofn.lCustData = 0 ;
ofn.lpfnHook = NULL ;
ofn.lpTemplateName = NULL ;
return 0 ;
case WM_SIZE:
cxClient = LOWORD (lParam) ;
cyClient = HIWORD (lParam) ;
return 0 ;
case WM_COMMAND:
switch (LOWORD (wParam))
{
case IDM_FILE_OPEN:
// Show the File Open dialog box
if (!GetOpenFileName (&ofn))
return 0 ;
// If there's an existing packed DIB, free the memory
if (hBitmap)
{
DeleteObject (hBitmap) ;
hBitmap = NULL ;
}
// If there's an existing logical palette, delete it
if (hPalette)
{
DeleteObject (hPalette) ;
hPalette = NULL ;
}
// Load the packed DIB into memory
SetCursor (LoadCursor (NULL, IDC_WAIT)) ;
ShowCursor (TRUE) ;
pPackedDib = PackedDibLoad (szFileName) ;
ShowCursor (FALSE) ;
SetCursor (LoadCursor (NULL, IDC_ARROW)) ;
if (pPackedDib)
{
// Create the DIB section from the DIB
hBitmap = CreateDIBSection (NULL,
pPackedDib,
DIB_RGB_COLORS,
&pBits,
NULL, 0) ;
// Copy the bits
CopyMemory (pBits, PackedDibGetBitsPtr (pPackedDib),
PackedDibGetBitsSize (pPackedDib)) ;
// Create palette from the DIB
hPalette = PackedDibCreatePalette (pPackedDib) ;
// Free the packed-DIB memory
free (pPackedDib) ;
}
else
{
MessageBox (hwnd, TEXT ("Cannot load DIB file"),
szAppName, 0) ;
}
InvalidateRect (hwnd, NULL, TRUE) ;
return 0 ;
}
break ;
case WM_PAINT:
hdc = BeginPaint (hwnd, &ps) ;
if (hPalette)
{
SelectPalette (hdc, hPalette, FALSE) ;
RealizePalette (hdc) ;
}
if (hBitmap)
{
GetObject (hBitmap, sizeof (BITMAP), &bitmap) ;
hdcMem = CreateCompatibleDC (hdc) ;
SelectObject (hdcMem, hBitmap) ;
BitBlt (hdc, 0, 0, bitmap.bmWidth, bitmap.bmHeight,
hdcMem, 0, 0, SRCCOPY) ;
DeleteDC (hdcMem) ;
}
EndPaint (hwnd, &ps) ;
return 0 ;
case WM_QUERYNEWPALETTE:
if (!hPalette)
return FALSE ;
hdc = GetDC (hwnd) ;
SelectPalette (hdc, hPalette, FALSE) ;
RealizePalette (hdc) ;
InvalidateRect (hwnd, NULL, TRUE) ;
ReleaseDC (hwnd, hdc) ;
return TRUE ;
case WM_PALETTECHANGED:
if (!hPalette || (HWND) wParam == hwnd)
break ;
hdc = GetDC (hwnd) ;
SelectPalette (hdc, hPalette, FALSE) ;
RealizePalette (hdc) ;
UpdateColors (hdc) ;
ReleaseDC (hwnd, hdc) ;
break ;
case WM_DESTROY:
if (hBitmap)
DeleteObject (hBitmap) ;
if (hPalette)
DeleteObject (hPalette) ;
PostQuitMessage (0) ;
return 0 ;
}
return DefWindowProc (hwnd, message, wParam, lParam) ;
}
void M2Object::DrawZOnly( const noMat4& world, const mat4& view, const mat4& proj )
{
view_ = view;
if (!animated) {
}
else {
static size_t fps = 0;
mat4* frameMatrices = NULL;
M2Mesh* mesh = Owner_->mesh_;
renderer->resetToDefaults();
if (animGeom)
{
std::vector<noMat4> temp;
temp.resize(header.nBones);
for (size_t i=0; i<header.nBones; i++)
temp[i] = bones[i].mat;
//float ClearColor[4] = { 0.0f, 0.125f, 0.3f, 1.0f }; // red,green,blue,alpha
//renderer->clear(true, true, false, ClearColor, 1.f);
int num = numPass;
//num = 2;
noVec4 ocolor, ecolor;
for (int i = 0; i < num; i++)
{
const RenderData& rd = render_data[i];
if (!UpdateColors(rd.colorIndex, rd.opacity, rd.unlit, ocolor, ecolor))
continue;
renderer->reset();
renderer->setVertexFormat(rd.vf);
renderer->setVertexBuffer(0, rd.vb);
renderer->setIndexBuffer(rd.ib);
renderer->apply();
if (AppSettings::ShadowModeEnum == SHADOW_SSAO)
GetApp()->SSAORender_->SetSkinDepthShader((noMat4*)&world, &temp[0], header.nBones);
else
LIDRenderer::GetSingletonPtr()->BeginDepthSkinRender(GetApp()->ActiveCam_, D3D11Context(), world.ToFloatPtr(), &temp[0], header.nBones);
renderer->drawElements(rd.prim, rd.startIndex, rd.endIndex, 0, rd.vertexEnd);
}
}
else
{
noVec4 ocolor, ecolor;
for (int i = 0; i < numPass; i++)
{
const RenderData& rd = render_data[i];
if (!UpdateColors(rd.colorIndex, rd.opacity, rd.unlit, ocolor, ecolor))
continue;
renderer->reset();
renderer->setVertexFormat(rd.vf);
renderer->setVertexBuffer(0, rd.vb);
renderer->setIndexBuffer(rd.ib);
renderer->apply();
if (AppSettings::ShadowModeEnum == SHADOW_SSAO)
GetApp()->SSAORender_->SetDepthShader((noMat4*)&world);
else
LIDRenderer::GetSingletonPtr()->BeginDepthRender(GetApp()->ActiveCam_, D3D11Context(), world.ToFloatPtr());
renderer->drawElements(rd.prim, rd.startIndex, rd.endIndex, 0, rd.vertexEnd);
}
}
}
}
void M2Object::DrawModel( const mat4& world, const mat4& view, const mat4& proj )
{
view_ = view;
if (!animated) {
}
else {
static int i = 0;
static int currAnim = 3;
/*if (currAnim >= header.nAnimations)
{
currAnim = 0;
}*/
/*animManager->SetAnim(0, currAnim, 0);
animManager->Play(); */
static size_t fps = 0;
mat4* frameMatrices = NULL;
#if 0
if (animManager->GetCurrAnim())
{
if (fps++ >= 3)
{
i++;
fps = 0;
}
if (i >= animManager->GetCurrAnim()->GetNumFrames())
{
i = 0;
//++currAnim;
}
frameMatrices = animManager->GetCurrAnim()->GetFrame2(i);
}
#endif
renderer->resetToDefaults();
if (animGeom)
{
std::vector<mat4> temp;
temp.resize(header.nBones);
for (size_t i=0; i<header.nBones; i++)
temp[i] = bones[i].rdmat;
//float ClearColor[4] = { 0.0f, 0.125f, 0.3f, 1.0f }; // red,green,blue,alpha
//renderer->clear(true, true, false, ClearColor, 1.f);
int num = numPass;
noVec4 ocolor, ecolor;
for (int i = 0; i < num; i++)
{
const RenderData& rd = render_data[i];
if (!UpdateColors(rd.colorIndex, rd.opacity, rd.unlit, ocolor, ecolor) || !rd.visible)
continue;
LIDRenderer::GetSingletonPtr()->UpdateMaterial(D3D11Context(), ecolor, ocolor, noVec3(0.5f, 0.5f, 0.5f), 0);
renderer->reset();
renderer->setVertexFormat(rd.vf);
renderer->setVertexBuffer(0, rd.vb);
renderer->setIndexBuffer(rd.ib);
renderer->setRasterizerState(rd.cull);
renderer->setShader(rd.shader);
//renderer->setShaderConstant3f("g_localLightPos", vec3(gLight.m_mInvView.rows[3].x, gLight.m_mInvView.rows[3].y, gLight.m_mInvView.rows[3].z));
renderer->setSamplerState("g_samLinear", render_data[0].diffuseSampler);
renderer->setTexture("g_txDiffuse", rd.baseTex);
//if (rd.bumpTex != -1) renderer->setTexture("g_txBump", rd.bumpTex);
if (rd.blendMode != -1) renderer->setBlendState(rd.blendMode);
else
{
float blendFactor[4] = {1, 1, 1, 1};
D3D11Context()->OMSetBlendState(GetApp()->blendStates_->BlendDisabled(), blendFactor, 0xFFFFFFF);
}
if (rd.depthMode != -1) renderer->setDepthState(rd.depthMode);
else
{
D3D11Context()->OMSetDepthStencilState(GetApp()->depthStencilStates_->DepthDisabled(), 0.f);
}
renderer->setShaderConstant4x4f("g_mWorld", world);
//renderer->setShaderConstant4x4f("g_mViewProj", view * proj);
renderer->setShaderConstant4x4f("g_mView", view);
//mat4 invView = transpose(view);
//renderer->setShaderConstant4x4f("InvView", invView);
//renderer->setShaderConstant3f("g_localEye", invView.getTrans());
renderer->setShaderConstant4x4f("g_mWorldViewProjection", world *view * proj);
//renderer->setShaderConstant4x4f("View", view);
//renderer->setShaderConstant4x4f("Projection", proj);
//renderer->setShaderConstantArray4x4f("g_matrices", frameMatrices, header.nBones);
renderer->setShaderConstantArray4x4f("g_matrices", &temp[0], header.nBones);
renderer->apply();
renderer->drawElements(PRIM_TRIANGLES, rd.startIndex, rd.endIndex, rd.vertexStart, rd.vertexEnd);
}
}
else
{
noVec4 ocolor, ecolor;
for (int i = 0; i < numPass; i++)
{
const RenderData& rd = render_data[i];
if (!UpdateColors(rd.colorIndex, rd.opacity, rd.unlit, ocolor, ecolor))
continue;
LIDRenderer::GetSingletonPtr()->UpdateMaterial(D3D11Context(), ecolor, ocolor);
renderer->reset();
renderer->setVertexFormat(rd.vf);
renderer->setVertexBuffer(0, rd.vb);
renderer->setIndexBuffer(rd.ib);
renderer->setRasterizerState(rd.cull);
renderer->setShader(rd.shader);
//renderer->setSamplerState("g_samShadowMap", gPassmSampler);
renderer->setSamplerState("g_samLinear", render_data[0].diffuseSampler);
renderer->setTexture("g_txDiffuse", rd.baseTex);
if (rd.blendMode != -1) renderer->setBlendState(rd.blendMode);
else
{
float blendFactor[4] = {1, 1, 1, 1};
D3D11Context()->OMSetBlendState(GetApp()->blendStates_->BlendDisabled(), blendFactor, 0xFFFFFFF);
}
if (rd.depthMode != -1) renderer->setDepthState(rd.depthMode);
else
{
D3D11Context()->OMSetDepthStencilState(GetApp()->depthStencilStates_->DepthDisabled(), 0.f);
}
renderer->setShaderConstant4x4f("World", world);
renderer->setShaderConstant4x4f("View", view);
renderer->setShaderConstant4x4f("Projection", proj);
vec3 eye;
GetApp()->ActiveCam_->getFrom((float*)eye);
renderer->setShaderConstant3f("vecEye", eye);
vec3 Lightdir(gSun.GetDir().x, gSun.GetDir().y, gSun.GetDir().z);
renderer->setShaderConstant3f("vecLightDir", Lightdir);
//vec4 diffuse(0.25098f, 0.435294f, 0.901961f, 1.f);
renderer->setShaderConstant4f("vDIC", vec4(gSun.m_diffuseColor.x , gSun.m_diffuseColor.y, gSun.m_diffuseColor.z, 1));
vec4 specular(0.135f, 0.135f, 0.135f, 10.f);
renderer->setShaderConstant4f("vSpecIC", specular);
renderer->apply();
renderer->drawElements(PRIM_TRIANGLES, rd.startIndex, rd.endIndex, rd.vertexStart, rd.vertexEnd);
}
}
}
}
ibool Launcher::Colors::OnPaint(Param&)
{
UpdateColors();
return false;
}
ibool Launcher::Colors::OnInitDialog(Param&)
{
UpdateColors();
return true;
}
void M2Object::DrawCascaded()
{
/*if (!animated) {
}
else*/ {
static size_t fps = 0;
mat4* frameMatrices = NULL;
M2Mesh* mesh = Owner_->mesh_;
renderer->resetToDefaults();
Direct3D11Renderer* Dx11R = (Direct3D11Renderer*)renderer;
if (animGeom)
{
std::vector<mat4> temp;
temp.resize(header.nBones);
for (size_t i=0; i<header.nBones; i++)
temp[i] = bones[i].rdmat;
//float ClearColor[4] = { 0.0f, 0.125f, 0.3f, 1.0f }; // red,green,blue,alpha
//renderer->clear(true, true, false, ClearColor, 1.f);
int num = numPass;
//num = 2;
noVec4 ocolor, ecolor;
for (int i = 0; i < num; i++)
{
const RenderData& rd = render_data[i];
if (!UpdateColors(rd.colorIndex, rd.opacity, rd.unlit, ocolor, ecolor))
continue;
renderer->reset();
renderer->changeVertexFormat(rd.vf);
renderer->changeVertexBuffer(0, rd.vb);
renderer->changeIndexBuffer(rd.ib);
//renderer->setShaderConstantArray4x4f("g_matrices", &temp[0], header.nBones);
renderer->drawElements(rd.prim, rd.startIndex, rd.endIndex, 0, rd.vertexEnd);
ID3D11ShaderResourceView* srv = Dx11R->getTextureSRV(rd.baseTex);
D3D11Context()->PSSetShaderResources(0, 1, &srv);
}
}
else
{
noVec4 ocolor, ecolor;
for (int i = 0; i < numPass; i++)
{
const RenderData& rd = render_data[i];
if (!UpdateColors(rd.colorIndex, rd.opacity, rd.unlit, ocolor, ecolor))
continue;
renderer->reset();
renderer->changeVertexFormat(rd.vf);
renderer->changeVertexBuffer(0, rd.vb);
renderer->changeIndexBuffer(rd.ib);
ID3D11ShaderResourceView* srv = Dx11R->getTextureSRV(rd.baseTex);
D3D11Context()->PSSetShaderResources(0, 1, &srv);
renderer->drawElements(rd.prim, rd.startIndex, rd.endIndex, 0, rd.vertexEnd);
}
}
}
}
LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static HPALETTE hPalette ;
static int cxClient, cyClient ;
HBRUSH hBrush ;
HDC hdc ;
int i ;
LOGPALETTE * plp ;
PAINTSTRUCT ps ;
RECT rect ;
switch (message)
{
case WM_CREATE:
// Set up a LOGPALETTE structure and create a palette
plp = malloc (sizeof (LOGPALETTE) + 64 * sizeof (PALETTEENTRY)) ;
plp->palVersion = 0x0300 ;
plp->palNumEntries = 65 ;
for (i = 0 ; i < 65 ; i++)
{
plp->palPalEntry[i].peRed = (BYTE) min (255, 4 * i) ;
plp->palPalEntry[i].peGreen = (BYTE) min (255, 4 * i) ;
plp->palPalEntry[i].peBlue = (BYTE) min (255, 4 * i) ;
plp->palPalEntry[i].peFlags = 0 ;
}
hPalette = CreatePalette (plp) ;
free (plp) ;
return 0 ;
case WM_SIZE:
cxClient = LOWORD (lParam) ;
cyClient = HIWORD (lParam) ;
return 0 ;
case WM_PAINT:
hdc = BeginPaint (hwnd, &ps) ;
// Select and realize the palette in the device context
SelectPalette (hdc, hPalette, FALSE) ;
RealizePalette (hdc) ;
// Draw the fountain of grays
for (i = 0 ; i < 65 ; i++)
{
rect.left = i * cxClient / 64 ;
rect.top = 0 ;
rect.right = (i + 1) * cxClient / 64 ;
rect.bottom = cyClient ;
hBrush = CreateSolidBrush (PALETTERGB (min (255, 4 * i),
min (255, 4 * i),
min (255, 4 * i))) ;
FillRect (hdc, &rect, hBrush) ;
DeleteObject (hBrush) ;
}
EndPaint (hwnd, &ps) ;
return 0 ;
case WM_QUERYNEWPALETTE:
if (!hPalette)
return FALSE ;
hdc = GetDC (hwnd) ;
SelectPalette (hdc, hPalette, FALSE) ;
RealizePalette (hdc) ;
InvalidateRect (hwnd, NULL, TRUE) ;
ReleaseDC (hwnd, hdc) ;
return TRUE ;
case WM_PALETTECHANGED:
if (!hPalette || (HWND) wParam == hwnd)
break ;
hdc = GetDC (hwnd) ;
SelectPalette (hdc, hPalette, FALSE) ;
RealizePalette (hdc) ;
UpdateColors (hdc) ;
ReleaseDC (hwnd, hdc) ;
break ;
case WM_DESTROY:
DeleteObject (hPalette) ;
PostQuitMessage (0) ;
return 0 ;
}
return DefWindowProc (hwnd, message, wParam, lParam) ;
}
void Button::SetAcionUpState(){
if(!is_toggle_button)
state_clicked = false;
UpdateColors();
}
void M2Object::DrawShadow( const mat4& world, const mat4& view, const mat4& proj )
{
view_ = view;
if (!animated) {
}
else {
static size_t fps = 0;
mat4* frameMatrices = NULL;
M2Mesh* mesh = Owner_->mesh_;
renderer->resetToDefaults();
if (animGeom)
{
std::vector<mat4> temp;
temp.resize(header.nBones);
for (size_t i=0; i<header.nBones; i++)
temp[i] = bones[i].rdmat;
//float ClearColor[4] = { 0.0f, 0.125f, 0.3f, 1.0f }; // red,green,blue,alpha
//renderer->clear(true, true, false, ClearColor, 1.f);
int num = numPass;
//num = 2;
noVec4 ocolor, ecolor;
for (int i = 0; i < num; i++)
{
const RenderData& rd = render_data[i];
if (!UpdateColors(rd.colorIndex, rd.opacity, rd.unlit, ocolor, ecolor))
continue;
renderer->reset();
renderer->setVertexFormat(rd.vf);
renderer->setVertexBuffer(0, rd.vb);
renderer->setIndexBuffer(rd.ib);
renderer->setRasterizerState(rd.cull);
renderer->setShader(gPssmSkinned);
if (rd.blendMode != -1) renderer->setBlendState(rd.blendMode);
if (rd.depthMode != -1) renderer->setDepthState(rd.depthMode);
// set split range
renderer->setShaderConstant1i("g_iFirstSplit", mesh->m_iFirstSplit);
renderer->setShaderConstant1i("g_iLastSplit", mesh->m_iLastSplit);
renderer->setShaderConstant4x4f("g_mWorld", world);
renderer->setShaderConstant4x4f("g_mViewProj", view * proj);
renderer->setShaderConstantArray4x4f("g_mCropMatrix", &mCropMatrix[0], 4);
//renderer->setShaderConstant4x4f("View", view);
//renderer->setShaderConstant4x4f("Projection", proj);
renderer->setShaderConstantArray4x4f("g_matrices", &temp[0], header.nBones);
renderer->apply();
GetApp()->GetContext()->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
int iNumInstances = mesh->m_iLastSplit - mesh->m_iFirstSplit + 1;
D3D11Context()->DrawIndexedInstanced(rd.endIndex, iNumInstances, rd.startIndex, 0, 0);
}
}
else
{
noVec4 ocolor, ecolor;
for (int i = 0; i < numPass; i++)
{
const RenderData& rd = render_data[i];
if (!UpdateColors(rd.colorIndex, rd.opacity, rd.unlit, ocolor, ecolor))
continue;
renderer->reset();
renderer->setVertexFormat(rd.vf);
renderer->setVertexBuffer(0, rd.vb);
renderer->setIndexBuffer(rd.ib);
renderer->setRasterizerState(rd.cull);
renderer->setShader(gPssm);
//renderer->setSamplerState("samLinear", render_data[0].linear);
//renderer->setTexture("txDiffuse", rd.baseTex);
if (rd.blendMode != -1) renderer->setBlendState(rd.blendMode);
if (rd.depthMode != -1) renderer->setDepthState(rd.depthMode);
renderer->setShaderConstant1i("g_iFirstSplit", mesh->m_iFirstSplit);
renderer->setShaderConstant1i("g_iLastSplit", mesh->m_iLastSplit);
renderer->setShaderConstantArray4x4f("g_mCropMatrix", &mCropMatrix[0], 4);
renderer->setShaderConstant4x4f("g_mWorld", world);
renderer->setShaderConstant4x4f("g_mViewProj", view * proj);
renderer->apply();
GetApp()->GetContext()->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
int iNumInstances = mesh->m_iLastSplit - mesh->m_iFirstSplit + 1;
D3D11Context()->DrawIndexedInstanced(rd.endIndex, iNumInstances, rd.startIndex, 0, 0);
}
}
}
}
// Window procedure, handles all messages for this program
LRESULT CALLBACK WndProc(HWND hWnd,
UINT message,
WPARAM wParam,
LPARAM lParam)
{
static HGLRC hRC; // Permenant Rendering context
static HDC hDC; // Private GDI Device context
switch (message)
{
// Window creation, setup for OpenGL
case WM_CREATE:
SetTimer(hWnd, 1002, Tools::refreshFreq, NULL);
// Store the device context
hDC = GetDC(hWnd);
// Select the pixel format
SetDCPixelFormat(hDC);
// Create palette if needed
hPalette = GetOpenGLPalette(hDC);
// Create the rendering context and make it current
hRC = wglCreateContext(hDC);
wglMakeCurrent(hDC, hRC);
SetupRC();
nazwa = "Moon.bmp";
const char* bitmapFileName;
bitmapFileName =nazwa.c_str();
glGenTextures(1, &texture); // tworzy obiekt tekstury
// 3aduje pierwszy obraz tekstury:
bitmapData = LoadBitmapFile((char*)bitmapFileName, &bitmapInfoHeader);
glBindTexture(GL_TEXTURE_2D, texture); // aktywuje obiekt tekstury
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// tworzy obraz tekstury
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, bitmapInfoHeader.biWidth,
bitmapInfoHeader.biHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, bitmapData);
//if (bitmapData)
//free(bitmapData);
/*
GLuint texture;
int width, height;
unsigned char* image;
// Load textures
glGenTextures(1, &texture);
image = LoadBitmapFile("Bitmapy//Moon.bmp",&bitmapInfoHeader);
// select our current texture
glBindTexture(GL_TEXTURE_2D, texture);
// select modulate to mix texture with color for shading
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, bitmapInfoHeader.biWidth,
bitmapInfoHeader.biHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, bitmapData);
*/
// 3aduje drugi obraz tekstury:
/*
bitmapData = LoadBitmapFile("Bitmapy\\crate.bmp", &bitmapInfoHeader);
glBindTexture(GL_TEXTURE_2D, texture[1]); // aktywuje obiekt tekstury
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
// tworzy obraz tekstury
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, bitmapInfoHeader.biWidth,
bitmapInfoHeader.biHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, bitmapData);
if (bitmapData)
free(bitmapData);
*/
// ustalenie sposobu mieszania tekstury z t3em
//glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
break;
// Window is being destroyed, cleanup
case WM_DESTROY:
// Deselect the current rendering context and delete it
wglMakeCurrent(hDC, NULL);
wglDeleteContext(hRC);
// Delete the palette if it was created
if (hPalette != NULL)
DeleteObject(hPalette);
// Tell the application to terminate after the window
// is gone.
PostQuitMessage(0);
break;
// Window is resized.
case WM_SIZE:
// Call our function which modifies the clipping
// volume and viewport
ChangeSize(LOWORD(lParam), HIWORD(lParam));
break;
// The painting function. This message sent by Windows
// whenever the screen needs updating.
case WM_PAINT:
{
}
case WM_TIMER:
{
// Call OpenGL drawing code
position = world->getPosition();
v = world->getVelocity();
fuel = 1000 * world->getFuel();
velocity = v.y;
velocityx = v.x / 2;
velocityz = v.z / 2;
height = position.y / 20;
score = world->getHighscore();
if (score > highscore)
{
highscore = score;
}
RenderScene();
SwapBuffers(hDC);
if (spisSet)
{
world->control[0] = true;
}
else
{
world->control[0] = false;
}
if (s)
{
world->control[3] = true;
}
else
{
world->control[3] = false;
}
if (a)
{
world->control[2] = true;
}
else
{
world->control[2] = false;
}
if (d)
{
world->control[1] = true;
}
else
{
world->control[1] = false;
}
if (w)
{
world->control[4] = true;
}
else
{
world->control[4] = false;
}
// Validate the newly painted client area
ValidateRect(hWnd, NULL);
}
// Windows is telling the application that it may modify
// the system palette. This message in essance asks the
// application for a new palette.
case WM_QUERYNEWPALETTE:
// If the palette was created.
if (hPalette)
{
int nRet;
// Selects the palette into the current device context
SelectPalette(hDC, hPalette, FALSE);
// Map entries from the currently selected palette to
// the system palette. The return value is the number
// of palette entries modified.
nRet = RealizePalette(hDC);
// Repaint, forces remap of palette in current window
InvalidateRect(hWnd, NULL, FALSE);
return nRet;
}
break;
// This window may set the palette, even though it is not the
// currently active window.
case WM_PALETTECHANGED:
// Don't do anything if the palette does not exist, or if
// this is the window that changed the palette.
if ((hPalette != NULL) && ((HWND)wParam != hWnd))
{
// Select the palette into the device context
SelectPalette(hDC, hPalette, FALSE);
// Map entries to system palette
RealizePalette(hDC);
// Remap the current colors to the newly realized palette
UpdateColors(hDC);
return 0;
}
break;
// Key press, check for arrow keys to do cube rotation.
case WM_KEYDOWN:
{
if (wParam == VK_UP)
xRot -= 5.0f;
if (wParam == VK_DOWN)
xRot += 5.0f;
if (wParam == VK_LEFT)
yRot -= 5.0f;
if (wParam == VK_RIGHT)
yRot += 5.0f;
if (wParam == VK_SPACE)
spisSet = true;
if (wParam == 0x41)
a = true;
if (wParam == 0x44)
d = true;
if (wParam == 0x57)
w = true;
if (wParam == 0x53)
s = true;
if (wParam == 0x52)
world->tryRefuel();
xRot = GLfloat((const int)xRot % 360);
yRot = GLfloat((const int)yRot % 360);
InvalidateRect(hWnd, NULL, FALSE);
}
break;
case WM_KEYUP:
{
if (wParam == VK_SPACE)
spisSet = false;
if (wParam == 0x41)
a = false;
if (wParam == 0x44)
d = false;
if (wParam == 0x57)
w = false;
if (wParam == 0x53)
s = false;
}
case WM_MOUSEMOVE:
{
int posX = GET_X_LPARAM(lParam);
int posY = GET_Y_LPARAM(lParam);
float xAngle = 0.2f;
float yAngle = 0.2f;
int angle = 1.0f;
if (GetKeyState(VK_LBUTTON) & 0x80)
{
/*
if (posX > mousePosX)
world->changeCamera(0.0f, angle, 0.0f);
if (posX < mousePosX)
world->changeCamera(0.0f, -angle, 0.0f);
if (posY > mousePosY)
world->changeCamera(angle, 0.0f, 0.0f);
if (posY < mousePosY)
world->changeCamera(-angle, 0.0f, 0.0f);*/
world->changeCamera((posY - mousePosY)*yAngle, (posX - mousePosX)*xAngle, 0.0f);
}
mousePosX = posX;
mousePosY = posY;
}
break;
case WM_MOUSEWHEEL:
{
int x = GET_Y_LPARAM(wParam);
if (x > 0)
world->changeCamera(0.0f, 0.0f, -20.0f);
if (x < 0)
world->changeCamera(0.0f, 0.0f, 20.0f);
}
break;
// A menu command
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
// Exit the program
case ID_FILE_EXIT:
DestroyWindow(hWnd);
break;
// Display the about box
case ID_HELP_ABOUT:
DialogBox(hInstance,
MAKEINTRESOURCE(IDD_DIALOG_ABOUT),
hWnd,
(DLGPROC)AboutDlgProc);
break;
}
}
break;
default: // Passes it on if unproccessed
return (DefWindowProc(hWnd, message, wParam, lParam));
}
return (0L);
}
void LaserScanPlugin::MaxIntensityChanged(double value)
{
max_intensity_ = value;
UpdateColors();
canvas_->update();
}
void M2Object::DrawShadowModel( const mat4& world, const mat4& view, const mat4& proj )
{
view_ = view;
if (!animated) {
}
else {
static int i = 0;
static int currAnim = 3;
/*if (currAnim >= header.nAnimations)
{
currAnim = 0;
}*/
/*animManager->SetAnim(0, currAnim, 0);
animManager->Play(); */
static size_t fps = 0;
mat4* frameMatrices = NULL;
#if 0
if (animManager->GetCurrAnim())
{
if (fps++ >= 3)
{
i++;
fps = 0;
}
if (i >= animManager->GetCurrAnim()->GetNumFrames())
{
i = 0;
//++currAnim;
}
frameMatrices = animManager->GetCurrAnim()->GetFrame2(i);
}
#endif
renderer->resetToDefaults();
M2Mesh* mesh = Owner_->mesh_;
if (animGeom)
{
std::vector<mat4> temp;
temp.resize(header.nBones);
for (size_t i=0; i<header.nBones; i++)
temp[i] = bones[i].rdmat;
//float ClearColor[4] = { 0.0f, 0.125f, 0.3f, 1.0f }; // red,green,blue,alpha
//renderer->clear(true, true, false, ClearColor, 1.f);
int num = numPass;
//num = 2;
noVec4 ocolor, ecolor;
for (int i = 0; i < num; i++)
{
const RenderData& rd = render_data[i];
if (!UpdateColors(rd.colorIndex, rd.opacity, rd.unlit, ocolor, ecolor))
continue;
gSun.Apply(1);
LIDRenderer::GetSingletonPtr()->UpdateMaterial(D3D11Context(), ecolor, ocolor);
renderer->reset();
renderer->setVertexFormat(rd.vf);
renderer->setVertexBuffer(0, rd.vb);
renderer->setIndexBuffer(rd.ib);
//renderer->setRasterizerState(rd.cull);
renderer->setShader(rd.shader);
ID3D11SamplerState* ss[] = { LIDRenderer::GetSingletonPtr()->GetSamplerState().ShadowMap() };
D3D11Context()->PSSetSamplers(0, 1, ss);
D3D11Context()->PSSetShaderResources(0, 1, &GetShadowMap<PSSMShadowMapDx11>()->m_pSRV);
renderer->setSamplerState("g_samLinear", render_data[0].diffuseSampler);
renderer->setTexture("g_txDiffuse", rd.baseTex);
if (rd.bumpTex != -1)
{
//renderer->setTexture("g_txBump", rd.bumpTex);
}
if (rd.blendMode != -1) renderer->setBlendState(rd.blendMode);
else
{
float blendFactor[4] = {1, 1, 1, 1};
D3D11Context()->OMSetBlendState(GetApp()->blendStates_->BlendDisabled(), blendFactor, 0xFFFFFFF);
}
if (rd.depthMode != -1) renderer->setDepthState(rd.depthMode);
else
{
D3D11Context()->OMSetDepthStencilState(GetApp()->depthStencilStates_->DepthDisabled(), 0.f);
}
// set split range
renderer->setShaderConstant4x4f("g_mWorld", world);
renderer->setShaderConstant4x4f("g_mViewProj", view * proj);
renderer->setShaderConstant4x4f("g_mView", view);
mat4 invView = transpose(view);
//renderer->setShaderConstant4x4f("InvView", invView);
renderer->setShaderConstant3f("g_localEye", invView.getTrans());
renderer->setShaderConstant3f("g_vLightDir", gSun.GetDir().ToFloatPtr());
renderer->setShaderConstant3f("g_vLightColor", vec3(gSun.m_diffuseColor.ToFloatPtr()));
renderer->setShaderConstant3f("g_vAmbient", vec3(gSun.m_ambientColor.ToFloatPtr()));
renderer->setShaderConstantArray1f("g_fSplitPlane", &g_fSplitPos[1], g_iNumSplits);
renderer->setShaderConstant4x4f("g_mWorldViewProjection", world * view * proj);
renderer->setShaderConstantArray4x4f("g_matrices", &temp[0], header.nBones);
renderer->setShaderConstantArray4x4f("g_mTextureMatrix", &mTextureMatrix[0], g_iNumSplits);
renderer->apply();
renderer->drawElements(rd.prim, rd.startIndex, rd.endIndex, 0, rd.vertexEnd);
}
}
else
{
noVec4 ocolor, ecolor;
for (int i = 0; i < numPass; i++)
{
const RenderData& rd = render_data[i];
if (!UpdateColors(rd.colorIndex, rd.opacity, rd.unlit, ocolor, ecolor))
continue;
renderer->reset();
renderer->setVertexFormat(rd.vf);
renderer->setVertexBuffer(0, rd.vb);
renderer->setIndexBuffer(rd.ib);
//renderer->setRasterizerState(rd.cull);
renderer->setShader(rd.shader);
renderer->setSamplerState("g_samLinear", render_data[0].diffuseSampler);
renderer->setTexture("g_txDiffuse", rd.baseTex);
//if (rd.blendMode != -1) renderer->setBlendState(GetApp()->GetBlendMode(5));
//if (rd.depthMode != -1) renderer->setDepthState(rd.depthMode);
if (rd.blendMode != -1) renderer->setBlendState(rd.blendMode);
else
{
float blendFactor[4] = {1, 1, 1, 1};
D3D11Context()->OMSetBlendState(GetApp()->blendStates_->BlendDisabled(), blendFactor, 0xFFFFFFF);
}
if (rd.depthMode != -1) renderer->setDepthState(rd.depthMode);
else
{
D3D11Context()->OMSetDepthStencilState(GetApp()->depthStencilStates_->DepthDisabled(), 0.f);
}
// set split range
renderer->setShaderConstant4x4f("g_mWorld", world);
renderer->setShaderConstant4x4f("g_mViewProj", view * proj);
renderer->setShaderConstant4x4f("g_mView", view);
renderer->setShaderConstant3f("g_vLightDir", gSun.GetDir().ToFloatPtr());
renderer->setShaderConstant3f("g_vLightColor", vec3(gSun.m_diffuseColor.ToFloatPtr()));
renderer->setShaderConstant3f("g_vAmbient", vec3(gSun.m_ambientColor.ToFloatPtr()));
renderer->setShaderConstantArray1f("g_fSplitPlane", &g_fSplitPos[1], g_iNumSplits);
renderer->setShaderConstant4x4f("g_mWorldViewProjection", world * view * proj);
renderer->setShaderConstantArray4x4f("g_mTextureMatrix", &mTextureMatrix[0], g_iNumSplits);
renderer->apply();
ID3D11SamplerState* ss[] = { LIDRenderer::GetSingletonPtr()->GetSamplerState().ShadowMap() };
D3D11Context()->PSSetSamplers(1, 1, ss);
D3D11Context()->PSSetShaderResources(1, 1, &GetShadowMap<PSSMShadowMapDx11>()->m_pSRV);
renderer->drawElements(rd.prim, rd.startIndex, rd.endIndex, 0, rd.vertexEnd);
}
}
}
// Unbind shader resources
ID3D11ShaderResourceView* nullViews[8] = {0, 0, 0, 0, 0, 0, 0, 0};
GetApp()->GetContext()->PSSetShaderResources(0, 8, nullViews);
}
void M2Object::DrawSSAO( const mat4& world, const mat4& view, const mat4& proj ) {
/*if (!animated) {
}
else*/ {
static size_t fps = 0;
mat4* frameMatrices = NULL;
M2Mesh* mesh = Owner_->mesh_;
renderer->resetToDefaults();
Direct3D11Renderer* Dx11R = (Direct3D11Renderer*)renderer;
if (animGeom)
{
std::vector<mat4> temp;
temp.resize(header.nBones);
for (size_t i=0; i<header.nBones; i++)
temp[i] = bones[i].rdmat;
//float ClearColor[4] = { 0.0f, 0.125f, 0.3f, 1.0f }; // red,green,blue,alpha
//renderer->clear(true, true, false, ClearColor, 1.f);
int num = numPass;
//num = 2;
noVec4 ocolor, ecolor;
for (int i = 0; i < num; i++)
{
const RenderData& rd = render_data[i];
if (!UpdateColors(rd.colorIndex, rd.opacity, rd.unlit, ocolor, ecolor))
continue;
renderer->reset();
renderer->setShader(rd.shader);
renderer->setVertexFormat(rd.vf);
renderer->setVertexBuffer(0, rd.vb);
renderer->setIndexBuffer(rd.ib);
renderer->setShaderConstant4x4f("g_mWorld", world);
//renderer->setShaderConstant4x4f("g_mViewProj", view * proj);
renderer->setShaderConstant4x4f("g_mView", view);
//mat4 invView = transpose(view);
//renderer->setShaderConstant4x4f("InvView", invView);
//renderer->setShaderConstant3f("g_localEye", invView.getTrans());
renderer->setShaderConstant4x4f("g_mWorldViewProjection", world *view * proj);
//renderer->setShaderConstant4x4f("View", view);
//renderer->setShaderConstant4x4f("Projection", proj);
renderer->setShaderConstantArray4x4f("g_matrices", &temp[0], header.nBones);
renderer->setTexture("g_txDiffuse", rd.baseTex);
renderer->setSamplerState("g_samLinear", render_data[0].diffuseSampler);
renderer->apply();
//ID3D11ShaderResourceView* srv = Dx11R->getTextureSRV(rd.baseTex);
//D3D11Context()->PSSetShaderResources(0, 1, &srv);
ID3D11ShaderResourceView* aoSRV[] ={ GetApp()->SSAORender_->GetAOSRV() };
D3D11Context()->PSSetShaderResources(1, 1, aoSRV);
//renderer->setShaderConstantArray4x4f("g_matrices", &temp[0], header.nBones);
renderer->drawElements(rd.prim, rd.startIndex, rd.endIndex, 0, rd.vertexEnd);
}
}
else
{
noVec4 ocolor, ecolor;
for (int i = 0; i < numPass; i++)
{
const RenderData& rd = render_data[i];
if (!UpdateColors(rd.colorIndex, rd.opacity, rd.unlit, ocolor, ecolor))
continue;
renderer->reset();
renderer->setShader(rd.shader);
renderer->setVertexFormat(rd.vf);
renderer->setVertexBuffer(0, rd.vb);
renderer->setIndexBuffer(rd.ib);
renderer->setShaderConstant4x4f("World", world);
//renderer->setShaderConstant4x4f("g_mViewProj", view * proj);
renderer->setShaderConstant4x4f("View", view);
//mat4 invView = transpose(view);
//renderer->setShaderConstant4x4f("InvView", invView);
//renderer->setShaderConstant3f("g_localEye", invView.getTrans());
renderer->setShaderConstant4x4f("Projection", proj);
renderer->setTexture("g_txDiffuse", rd.baseTex);
renderer->setSamplerState("g_samLinear", render_data[0].diffuseSampler);
renderer->apply();
//ID3D11ShaderResourceView* srv = Dx11R->getTextureSRV(rd.baseTex);
//D3D11Context()->PSSetShaderResources(0, 1, &srv);
ID3D11ShaderResourceView* aoSRV[] ={ GetApp()->SSAORender_->GetAOSRV() };
D3D11Context()->PSSetShaderResources(1, 1, aoSRV);
renderer->drawElements(rd.prim, rd.startIndex, rd.endIndex, 0, rd.vertexEnd);
}
}
}
}
