int PBLineEdit::OnDraw(bool force)
{
PBGraphics *graphics;
if (IsVisible() && (IsChanged() || force) && (graphics = GetGraphics()) != NULL)
{
graphics->FillArea(GetClientLeft() + PBEDIT_BORDER,
GetClientTop() + PBEDIT_BORDER,
GetClientWidth() - (PBEDIT_BORDER << 1),
GetClientHeight() - (PBEDIT_BORDER << 1),
WHITE);
if (m_text[0])
{
SetFont(m_font, BLACK);
graphics->DrawTextRect(GetClientLeft() + PBEDIT_BORDER,
GetClientTop() + PBEDIT_BORDER,
GetClientWidth() - (PBEDIT_BORDER << 1),
GetClientHeight() - (PBEDIT_BORDER << 1),
m_text,
ALIGN_LEFT | VALIGN_MIDDLE | DOTS);
}
graphics->DrawRect(GetLeft(), GetTop(), GetWidth(), GetHeight(), BLACK);
}
return 0;
}
int PBListBox::MainHandler(int type, int par1, int par2)
{
int fcX1, fcX2, fcY1, fcY2;
int clickedElem;
int result = 0;
if (IsVisible() && type == EVT_POINTERUP)
{
PBPoint clientPoint = m_pParent->ScreenToClient(PBPoint(par1, par2));
fcX1 = GetClientLeft() + PBLIST_BORDER;
fcX2 = fcX1 + GetClientWidth() - (PBLIST_BORDER << 1);
fcY1 = GetClientTop() + PBLIST_BORDER;
fcY2 = fcY1 + GetClientHeight() - (PBLIST_BORDER << 1);
if (clientPoint.GetX() > fcX1 && clientPoint.GetX() < fcX2 &&
clientPoint.GetY() > fcY1 && clientPoint.GetY() < fcY2 &&
(clickedElem = m_listOffset + (clientPoint.GetY() - fcY1) / m_itemHeight) < count())
{
if (m_selected != -1)
DrawSelect(m_selected, WHITE);
m_selected = clickedElem;
DrawSelect(m_selected, BLACK);
if (m_pParent)
m_pParent->OnCommand(PBLISTBOX, PBSTATECHANGED, (int) this);
result = 1;
}
else result = PBWindow::MainHandler(type, par1, par2);
}
return result;
}
void ElementDataGrid::ProcessEvent(Core::Event& event)
{
Core::Element::ProcessEvent(event);
if (event == "columnadd")
{
if (event.GetTargetElement() == this)
{
root->RefreshRows();
DirtyLayout();
}
}
else if (event == "resize")
{
if (event.GetTargetElement() == this)
{
SetScrollTop(GetScrollHeight() - GetClientHeight());
for (int i = 0; i < header->GetNumChildren(); i++)
{
Core::Element* child = header->GetChild(i);
columns[i].current_width = child->GetBox().GetSize(Core::Box::MARGIN).x;
}
}
}
}
void Window::HandleSizeMessage()
{
WINDOWINFO info;
GetWindowInfo(m_handle, &info);
bool resized = false;
if (GetRectWidth(info.rcClient) != GetRectWidth(m_clientRect))
resized = true;
else if (GetRectHeight(info.rcClient) != GetRectHeight(m_clientRect))
resized = true;
m_clientRect = info.rcClient;
m_windowRect = info.rcWindow;
if (resized)
{
unsigned int clientWidth = GetClientWidth();
unsigned int clientHeight = GetClientHeight();
unsigned int windowWidth = GetWindowWidth();
unsigned int windowHeight = GetWindowHeight();
for (size_t i = 0; i < m_eventListeners.size(); ++i)
{
m_eventListeners[i]->WindowResized(clientWidth, clientHeight, windowWidth, windowHeight);
}
}
}
/////////////////////////////////////////////////////////////////////////////
//
// CONSTRUCTOR: Tab/Notebook control
//
/////////////////////////////////////////////////////////////////////////////
// ctor
TZNoteBook::TZNoteBook( TZPainterWindow *pPainterWindow,
TZPainterCtrl *pCtrlParent,
CWnd *pWndParent,
CRect& rect,
zVIEW vCtrl,
zLONG lType,
zBOOL bPlaceHolder,
zLONG lZKey,
zLONG lTabStopNbr,
zLONG lCtrlID,
zPCHAR pchTag,
zPCHAR pchText ) :
CTabCtrl( ),
TZPainterCtrl( pPainterWindow, pCtrlParent, pWndParent,
rect, vCtrl, this, pchTag, pchText,
lType, bPlaceHolder, lZKey, lTabStopNbr, lCtrlID )
{
#ifdef DEBUG_ALL
TraceLineS( "TZNoteBook::ctor ", m_csTag );
#endif
zLONG lTabsPerRow = 0;
m_bDeletable = TRUE; // mark it as deletable
m_bInitialized = FALSE;
m_pZNotePage = 0;
m_nPageCnt = 0;
m_nTabNbrMax = 1;
Attr.Style = WS_CHILD | WS_VISIBLE | WS_TABSTOP;
if ( vCtrl )
{
OrderEntityForView( vCtrl, szlCtrlCtrl, "Type A" );
zCHAR szBlob[ 5 * sizeof( zLONG ) ];
zULONG ulLth = zsizeof( szBlob );
GetBlobFromAttribute( szBlob, &ulLth, vCtrl, "Control", "CtrlBOI" );
// TraceLineI( "TZNoteBook ctor Blob Lth = ", ulLth );
if ( ulLth >= 3 * sizeof( zLONG ) )
{
lTabsPerRow = *((zPLONG) (szBlob + sizeof( zLONG ) * 2));
}
}
// if ( lTabsPerRow )
// Attr.Style |= TCS_MULTILINE,
CreateZ( );
ShowWindow( SW_SHOW );
#if 0
CRect r;
r.top = GetClientTop( );
r.left = GetClientLeft( );
r.right = r.left + GetClientWidth( );
r.bottom = r.top + GetClientHeight( );
TraceRect( "TZNoteBook ctor Client Rect:", r );
#endif
}
int PBImage::OnDraw(bool force)
{
if (IsVisible() && (IsChanged() || force))
{
PBGraphics *graphics = GetGraphics();
if (m_Fill)
graphics->FillArea(GetLeft(), GetTop(), GetWidth(), GetHeight(), m_Background);
if (m_BW)
{
graphics->DrawBitmapRectBW(GetClientLeft(), GetClientTop(), GetClientWidth(), GetClientHeight(), GetBitmap(), GetProperties());
}
else
{
graphics->DrawBitmapRect(GetClientLeft(), GetClientTop(), GetClientWidth(), GetClientHeight(), GetBitmap(), GetProperties());
}
}
return 0;
}
int PBLineEdit::MainHandler(int type, int par1, int par2)
{
int fcX1, fcX2, fcY1, fcY2;
int flags;
int result = 0;
if (IsVisible() && type == EVT_POINTERUP)
{
PBPoint clientPoint = m_pParent->ScreenToClient(PBPoint(par1, par2));
fcX1 = GetClientLeft() + PBEDIT_BORDER;
fcX2 = fcX1 + GetClientWidth() - (PBEDIT_BORDER << 1);
fcY1 = GetClientTop() + PBEDIT_BORDER;
fcY2 = fcY1 + GetClientHeight() - (PBEDIT_BORDER << 1);
if (clientPoint.GetX() > fcX1 && clientPoint.GetX() < fcX2 &&
clientPoint.GetY() > fcY1 && clientPoint.GetY() < fcY2)
{
switch(m_enterstyle)
{
case PBES_PHONE:
flags = KBD_PHONE;
break;
case PBES_NUMERIC:
flags = KBD_NUMERIC;
break;
case PBES_IPADDR:
flags = KBD_IPADDR;
break;
case PBES_URL:
flags = KBD_URL;
break;
case PBES_DATETIME:
flags = KBD_DATETIME;
break;
case PBES_TEXT:
default:
flags = KBD_ENTEXT;
break;
}
s_pThis = this;
m_pParent->OnChildFocusChanged(this);
OpenKeyboard("VK", m_text, PBEDIT_MAXENTER, flags, enttext_handler);
result = 1;
}
else result = PBWindow::MainHandler(type, par1, par2);
}
return result;
}
bool PBImage::LoadImage(const char *path)
{
if (m_pPath != NULL && path != NULL && strcmp(m_pPath, path) == 0)
{
return true;
}
FreeData();
MarkAsChanged();
if (path != NULL)
{
char *p = strrchr((char *)path, '.');
if (p != NULL && (
strncmp(p, ".jpg", 4) == 0 ||
strncmp(p, ".jpeg", 5) == 0 ||
strncmp(p, ".JPG", 4) == 0 ||
strncmp(p, ".JPEG", 5) == 0
))
{
m_ImgLoad = true;
m_pImage = LoadJPEG(path, GetClientWidth(), GetClientHeight(), 64, 128, 1);
if (m_pImage != NULL)
{
m_pPath = strdup(path);
return true;
}
return false;
}
if (p != NULL && (
strncmp(p, ".bmp", 4) == 0 ||
strncmp(p, ".BMP", 4) == 0
))
{
m_ImgLoad = true;
m_pImage = LoadBitmap(path);
if (m_pImage != NULL)
{
m_pPath = strdup(path);
return true;
}
return false;
}
}
return false;
}
bool EngineApp::OnInit()
{
m_pCore = CoreApiPtr(new CoreApi);
SysSetting setting;
setting.graphics.sysMod = L"./d11graphics.dll";
setting.graphics.backBufferCount = 2;
setting.graphics.depthStencilFormat = G_FORMAT_D24_UNORM_S8_UINT;
setting.graphics.frameBufferFormat = G_FORMAT_R8G8B8A8_UNORM;
setting.graphics.frameBufferHeight = GetClientHeight();
setting.graphics.frameBufferWidth = GetClientWidth();
setting.graphics.multiSampleCount = 1;
setting.graphics.multiSampleQuality = 0;
setting.graphics.windowed = true;
setting.graphics.wnd = GetWnd();
setting.input.sysMod = L"";
setting.input.wnd = GetWnd();
setting.sound.maxChannels = 100;
setting.sound.sysMod = L"./fmod_sound.dll";
setting.physics.sysMod = L"";
if(false == m_pCore->Initialize(setting))
{
return false;
}
m_pGameManager = m_pCore->GetAllocator()->AllocObject<GameManager>();
if(false == m_pGameManager->Initialize(L"./game.dll"))
{
return false;
}
if(false == m_pGameManager->GetGame()->Initialize(m_pCore))
{
return false;
}
return true;
}
BOOL
PaletteWindow::Paint(
void
) {
PaintWindowUpdate pwu(Handle());
PaintCompatibleWindow pcw(pwu.DC());
HPALETTE hOldPalette;
HPALETTE hOldPalette2;
Cursor cursor(IDC_WAIT);
cursor.Select();
{
/*
** Fast paint, just BitBlt image to screen.
*/
hOldPalette = SelectPalette(pwu.DC(), hPalette, FALSE);
hOldPalette2 = SelectPalette(pcw.DC(), hPalette, FALSE);
(void) RealizePalette(pwu.DC());
ASSERT(pClientBitmap != NULL);
pcw.SelectBitmap(pClientBitmap);
{
/*
** Copy memory bitmap to real window.
*/
(void) BitBlt( pwu.DC(),
0, 0,
GetClientWidth(), GetClientHeight(),
pcw.DC(),
0, 0,
SRCCOPY
);
}
pcw.DeselectBitmap();
(void) SelectPalette(pwu.DC(), hOldPalette, FALSE);
(void) SelectPalette(pcw.DC(), hOldPalette2, FALSE);
}
cursor.Deselect();
return TRUE;
}
int PBListBox::OnDraw(bool force)
{
int elem_iter;
int elem_render_count, elem_count;
if ( IsVisible() && (IsChanged() || force) && m_font)
{
PBGraphics *graphics = GetGraphics();
if (m_properties & DRAW_BORDER)
graphics->DrawRect(GetLeft(), GetTop(), GetWidth(), GetHeight(), BLACK);
graphics->FillArea(GetClientLeft() + PBLIST_BORDER, GetClientTop() + PBLIST_BORDER, GetClientWidth() - (PBLIST_BORDER << 1), GetClientHeight() - (PBLIST_BORDER << 1), WHITE);
elem_count = count();
elem_render_count = calcListCapacity();
// corect elements for render
if (elem_render_count > elem_count)
elem_render_count = elem_count;
if (elem_render_count)
{
if (m_AutoScroll)
{
if (elem_render_count < elem_count)
{
if (m_listOffset > m_selected) m_listOffset = m_selected;
if (m_selected > (m_listOffset + elem_render_count)) m_listOffset = m_selected - elem_render_count;
}
}
else m_AutoScroll = 1;
updateScrollBar();
if (m_selected != -1)
DrawSelect(m_selected, BLACK);
SetFont(m_font, BLACK);
elem_iter = 0;
while( elem_iter < elem_render_count)
{
graphics->DrawTextRect(GetClientLeft() + (PBLIST_BORDER << 2),
GetClientTop() + PBLIST_BORDER + elem_iter * m_itemHeight,
GetClientWidth() - (PBLIST_BORDER << 3),
m_itemHeight,
text(elem_iter + m_listOffset), // m_stringList[elem_iter + m_listOffset].c_str(),
ALIGN_LEFT | VALIGN_MIDDLE | DOTS);
elem_iter++;
}
}
}
return 0;//PBWindow::Draw();
}
int PBListBox::calcListCapacity()
{
return ((GetClientHeight() - (PBLIST_BORDER << 1)) / m_itemHeight);
}
void Camera::RebuildProjection()
{
// Build the projection matrix
XMMATRIX proj = XMMatrixPerspectiveFovLH(XM_PI * 0.25, (float)GetClientWidth()/(float)GetClientHeight(), 1.0f, 1000.0f);
XMStoreFloat4x4(&mProj, proj);
}
//! Constructor.
Camera::Camera()
{
// Set the sensitivity and speed
SetLookSensitivity(2.0f);
SetMovementSpeed(0.6f);
SetLocked(false);
// Default position and target
mPosition = XMFLOAT3(-30, 60, 0);
mTarget = XMFLOAT3(0.0f, 0.0f, 0.0f);
mUp = XMFLOAT3(0.0f, 1.0f, 0.0f); // Weird up vector
// Calculate the new direction.
UpdatePitchYaw();
// Build the projection matrix
XMMATRIX proj = XMMatrixPerspectiveFovLH(XM_PI * 0.25, (float)GetClientWidth()/(float)GetClientHeight(), 1.0f, 1000.0f);
XMStoreFloat4x4(&mProj, proj);
UpdateViewMatrix();
// Build the camera frustum.
XNA::ComputeFrustumFromProjection(&mFrustum, &XMLoadFloat4x4(&GetProjectionMatrix()));
}
////////////////////////////////////////////////////////////////////////////////
// Render them shadowmapz
void cGraphicsEngine::cShadowRenderer::RenderShadowMaps(Scene& sceneManager) {
//// set states
tBlendDesc blend = blendDefault;
blend[0].writeMask = 0;
gApi->SetBlendState(blend);
tDepthStencilDesc dsState = depthStencilDefault;
dsState.depthCompare = eComparisonFunc::LESS;
gApi->SetDepthStencilState(dsState, 0x00);
// render lights
auto& lights = sceneManager.GetLights();
for (auto& v : lights) {
// get light components
auto& light = *v;
auto* shadowMap = light.GetShadowMap();
// check shadow map parameters
//if (!light.enabled && light.shadowQuality != cGraphicsLight::eShadowQuality::DISABLED) {
// continue;
//}
//continue;
//if (light.shadowResolution < 256) {
// light.shadowResolution = 256;
//}
// light type
//switch (light.type) {
// case cGraphicsLight::DIRECTIONAL : {
// set sh map type
//shadowMap->SetType(light.type);
//shadowMap->ClearUnneeded();
// get map for type
auto& shadowMapDir = *(cShadowMapDir*)shadowMap;
// init map if not compatible with currently inited
//auto resolution = 2048;//== light.shadowResolution;
//auto nCascadeQuality = light.shadowQuality;
//try {
// if (!shadowMapDir.IsValid(gApi, resolution, eFormat::R24_UNORM_X8_TYPELESS, eFormat::D24_UNORM_S8_UINT, nCascadeQuality)) {
// shadowMapDir.Init(gApi, resolution, eFormat::R24_UNORM_X8_TYPELESS, eFormat::D24_UNORM_S8_UINT, nCascadeQuality);
// }
//}
//catch (std::exception& e) {
// std::cerr << e.what() << std::endl;
// break; // breaks switch case label
//}
// generate cascade splits
size_t nCascades = shadowMapDir.GetNumCascades();
std::vector<float> cascadeSplits(nCascades + 1, 0.0f);
float near = parent.camera->GetNearPlane();
float far = parent.camera->GetFarPlane();
for (size_t i = 0; i <= nCascades; i++) {
cascadeSplits[i] = near*pow((far / near), float(i) / float(nCascades));
}
for (float& v : cascadeSplits) {
v -= near;
v /= (far - near);
}
auto win = parent.GetTargetWindow();
float aspectRatio = (float)win->GetClientWidth() / win->GetClientHeight();
// foreach cascade
for (size_t i = 0; i < nCascades; i++) {
// compute transforms
auto& transform = shadowMapDir.GetTransforms()[i];
bool isGoodTransform = shadowMapDir.Transform(
transform.projMat,
transform.viewMat,
light.GetDirection(),
sceneManager.GetCamera()->GetViewMatrix(), sceneManager.GetCamera()->GetProjMatrix(aspectRatio),
cascadeSplits[i], cascadeSplits[i+1]);
if (!isGoodTransform)
continue;
// setup render
gApi->SetShaderProgram(shaderDirectional);
ITexture2D* textureSlice = shadowMapDir.GetTexture()->GetArraySlice(i);
gApi->SetRenderTargets(0, nullptr, textureSlice);
gApi->ClearTexture(textureSlice);
// foreach inst grp
for (auto& entity : sceneManager.GetEntities())
{
Mesh* mesh = (Mesh*)entity->GetMesh();
Material& mtl = *(Material*)entity->GetMaterial();
// set geom params
for (int j = 0; j < mesh->GetNumVertexBuffers(); j++)
{
auto stream = mesh->GetVertexBuffers()[j];
gApi->SetVertexBuffers(&stream.vb, &stream.stride, &stream.offset, j, 1);
}
gApi->SetIndexBuffer(mesh->GetIndexBuffer());
mm::mat4 posMat = mm::create_translation(entity->GetPos());
mm::mat4 rotMat = mm::mat4(entity->GetRot());
mm::mat4 skewMat = mm::mat4(entity->GetSkew());
mm::mat4 worldMat = posMat * (rotMat * skewMat);
//auto win = parent.GetTargetWindow();
//float aspectRatio = (float)win->GetClientWidth() / win->GetClientHeight();
//mm::mat4 projMat = sceneManager.GetCamera()->GetProjMatrix(aspectRatio);
//mm::mat4 viewMat = sceneManager.GetCamera()->GetViewMatrix();
mm::mat4 viewProjMat = transform.projMat * transform.viewMat;// projMat * viewMat;
//mm::mat4 invViewProjMat = mm::inverse(viewProjMat);
//mm::mat4 invProjMat = mm::inverse(projMat);
mm::mat4 worldViewProj = viewProjMat * worldMat;
gApi->SetVSConstantBuffer(&worldViewProj, sizeof(worldViewProj), 0);
for (auto& matGroup : mesh->GetMaterialIds())
{
gApi->DrawIndexed((matGroup.endFace - matGroup.beginFace) * 3, matGroup.beginFace * 3);
}
}
//gGapi->SaveTextureToFile(textureSlice, ITexture2D::BMP, "teszt.bmp");
textureSlice->Release();
}
//break;
//}
//case cGraphicsLight::SPOT:{
//
// break;
//}
//case cGraphicsLight::POINT:{
//
// break;
//}
//}
}
}
