void GameObjectView::setViewSize( float x, float y, float z ) {
wrld.updateIntent(this);
for( size_t i=0; i<view.size(); ++i ){
setViewSize( view[i], getClass().view[i], x, y, z );
}
for( size_t i=0; i<smallViews.size(); ++i ){
setViewSize( *smallViews[i], smallViews[i]->view, x, y, z );
}
double ss[3] = { m.radius*x, m.radius*y, z };
m.selectionSize[2] = ss[2];
if( getClass().view.size() ){
for( int i=0; i<2; ++i )
m.selectionSize[i] = ss[i]*getClass().view[0].size[i]/1.44;
}
//selection.setVisible( m.isMouseOwer );
double s = m.selectionSize[0];
for( int i=0; i<2; ++i )
s = std::min(s, m.selectionSize[i] );
selection[0]->setSize( s );
for( int i=1; i<selectModelsCount; ++i )
selection[i]->setSize( s*1.05 );
}
void DirectXRenderManager::initialise(IDirect3DDevice9* _device)
{
MYGUI_PLATFORM_ASSERT(!mIsInitialise, getClassTypeName() << " initialised twice");
MYGUI_PLATFORM_LOG(Info, "* Initialise: " << getClassTypeName());
mpD3DDevice = _device;
mVertexFormat = VertexColourType::ColourARGB;
memset(&mInfo, 0, sizeof(mInfo));
if (mpD3DDevice != nullptr)
{
D3DVIEWPORT9 vp;
mpD3DDevice->GetViewport(&vp);
setViewSize(vp.Width, vp.Height);
}
mUpdate = false;
if (mpD3DDevice != nullptr)
{
D3DCAPS9 caps;
mpD3DDevice->GetDeviceCaps(&caps);
if (caps.TextureCaps & D3DPTEXTURECAPS_SQUAREONLY)
{
MYGUI_PLATFORM_LOG(Warning, "Non-squared textures not supported.");
}
}
MYGUI_PLATFORM_LOG(Info, getClassTypeName() << " successfully initialized");
mIsInitialise = true;
}
/*
* This removes a single item from a scrolling list.
*/
void deleteCDKScrollItem (CDKSCROLL *scrollp, int position)
{
int x;
if (position >= 0 && position < scrollp->listSize)
{
freeChtype (scrollp->item[position]);
/* Adjust the list. */
for (x = position; x < scrollp->listSize; x++)
{
scrollp->item[x] = scrollp->item[x + 1];
scrollp->itemLen[x] = scrollp->itemLen[x + 1];
scrollp->itemPos[x] = scrollp->itemPos[x + 1];
}
setViewSize (scrollp, scrollp->listSize - 1);
if (scrollp->listSize > 0)
resequence (scrollp);
if (scrollp->listSize < maxViewSize (scrollp))
werase (scrollp->win); /* force the next redraw to be complete */
/* do this to update the view size, etc. */
setCDKScrollPosition (scrollp, scrollp->currentItem);
}
}
//------------------------------------------------------------------------
bool CCheckBox::sizeToFit ()
{
if (title == 0)
return false;
IFontPainter* painter = font ? font->getFontPainter () : 0;
if (painter)
{
CRect fitSize (getViewSize ());
if (getDrawBackground ())
{
fitSize.setWidth (getDrawBackground ()->getWidth ());
fitSize.setHeight (getDrawBackground ()->getHeight () / 6);
}
else
{
fitSize.setWidth (fitSize.getHeight ());
}
fitSize.right += kCheckBoxTitleMargin;
fitSize.right += painter->getStringWidth (0, title, true);
setViewSize (fitSize);
setMouseableArea (fitSize);
return true;
}
return false;
}
/*
* This adds a single item to a scrolling list, at the end of the list.
*/
void addCDKScrollItem (CDKSCROLL *scrollp, const char *item)
{
int itemNumber = scrollp->listSize;
int widestItem = WidestItem (scrollp);
char *temp = 0;
size_t have = 0;
if (allocListArrays (scrollp, scrollp->listSize, scrollp->listSize + 1) &&
allocListItem (scrollp,
itemNumber,
&temp,
&have,
scrollp->numbers ? (itemNumber + 1) : 0,
item))
{
/* Determine the size of the widest item. */
widestItem = MAXIMUM (scrollp->itemLen[itemNumber], widestItem);
updateViewWidth (scrollp, widestItem);
setViewSize (scrollp, scrollp->listSize + 1);
}
freeChecked (temp);
}
void kdvi::makeToolBar2(QWidget *parent)
{
QPixmap pm;
toolBar2 = new QFrame( parent );
QBoxLayout * gl = new QBoxLayout( toolBar2, QBoxLayout::Down );
sbox = new ScrollBox( toolBar2 );
connect( sbox, SIGNAL(valueChanged(QPoint)),
dviwin, SLOT(scroll(QPoint)) );
connect( sbox, SIGNAL(button3Pressed()), dviwin, SLOT(nextPage()) );
connect( sbox, SIGNAL(button2Pressed()), dviwin, SLOT(prevPage()) );
connect( dviwin, SIGNAL(pageSizeChanged( QSize )),
sbox, SLOT(setPageSize( QSize )) );
connect( dviwin, SIGNAL(viewSizeChanged( QSize )),
sbox, SLOT(setViewSize( QSize )) );
connect( dviwin, SIGNAL(currentPosChanged( QPoint )),
sbox, SLOT(setViewPos( QPoint )) );
QToolTip::add( sbox, 0, tipgroup, i18n("Scroll window and switch the page") );
sbox->setFixedSize(70,80);
gl->addWidget( sbox );
// Create a MarkList
marklist = new MarkList( toolBar2 );
connect( marklist, SIGNAL(selected(const char *)),
SLOT(pageActivated(const char *)) );
QToolTip::add( marklist, 0, tipgroup, i18n("Select page and mark pages for printing") );
gl->addWidget( marklist );
gl->activate();
sbox->setPageSize( dviwin->pageSize() );
}
void Cocos2dRenderManager::initialise()
{
CCDirector *pDirector = CCDirector::sharedDirector();
MYGUI_PLATFORM_ASSERT(!mIsInitialise, getClassTypeName() << " initialised twice");
MYGUI_PLATFORM_LOG(Info, "* Initialise: " << getClassTypeName());
CCSize s = pDirector->getWinSizeInPixels();
this->setPosition(0, 0);
this->setContentSize(s);
setViewSize(int(s.width), int(s.height));
// 绑定到cocos2d节点
pDirector->setNotificationNode(this);
mInfo.pixWidth = s.width;
mInfo.pixHeight = s.height;
mVertexFormat = VertexColourType::ColourABGR;
mUpdate = true;
kmMat4 tmp;
kmGLGetMatrix(KM_GL_PROJECTION, &tmp);
kmMat4Inverse(&mMatrix, &tmp);
MYGUI_PLATFORM_LOG(Info, getClassTypeName() << " successfully initialized");
mIsInitialise = true;
CCNotificationCenter::sharedNotificationCenter()->addObserver(this,
callfuncO_selector(Cocos2dRenderManager::listenForeToBackground),
EVENT_COME_TO_BACKGROUND,
NULL);
pDirector->getScheduler()->scheduleUpdateForTarget(this, kCCPriorityNonSystemMin, false);
}
void MGUI_RenderSystem::initialise()
{
d_assert (!mIsInitialise);
MYGUI_PLATFORM_LOG(Info, "* Initialise: " << getClassTypeName());
mVertexFormat = MyGUI::VertexColourType::ColourARGB;
memset(&mInfo, 0, sizeof(mInfo));
setViewSize(Engine::Instance()->GetDeviceProperty()->Width,
Engine::Instance()->GetDeviceProperty()->Height);
mUpdate = false;
mShaderLib = ShaderLibManager::Instance()->LoadShaderLib("Shaders\\MGUI.ShaderLib", "Shaders\\MGUI.ShaderLib");
d_assert (mShaderLib);
mDefaultTech = mShaderLib->GetTechnique("MGUI_Default");
d_assert (mDefaultTech);
mVertexDecl = VideoBufferManager::Instance()->CreateVertexDeclaration();
mVertexDecl->AddElement(0, 0, DT_FLOAT3, DU_POSITION, 0);
mVertexDecl->AddElement(0, 12, DT_COLOR, DU_COLOR, 0);
mVertexDecl->AddElement(0, 16, DT_FLOAT2, DU_TEXCOORD, 0);
mVertexDecl->Init();
MYGUI_PLATFORM_LOG(Info, getClassTypeName() << " successfully initialized");
mIsInitialise = true;
}
/*
* This adds a single item to a scrolling list, before the current item.
*/
void insertCDKScrollItem (CDKSCROLL *scrollp, const char *item)
{
int widestItem = WidestItem (scrollp);
char *temp = 0;
size_t have = 0;
if (allocListArrays (scrollp, scrollp->listSize, scrollp->listSize + 1) &&
insertListItem (scrollp, scrollp->currentItem) &&
allocListItem (scrollp,
scrollp->currentItem,
&temp,
&have,
scrollp->numbers ? (scrollp->currentItem + 1) : 0,
item))
{
/* Determine the size of the widest item. */
widestItem = MAXIMUM (scrollp->itemLen[scrollp->currentItem], widestItem);
updateViewWidth (scrollp, widestItem);
setViewSize (scrollp, scrollp->listSize + 1);
resequence (scrollp);
}
freeChecked (temp);
}
void GameObjectView::loadView( const Resource &r, Physics & p, bool env ) {
m.initalModelHeight = 0;
physic = &p;
view.clear();
m.radius = 0;
float ksize = rand()/float(RAND_MAX);//getClass().sizeBounds;
double *sz = m.rndSize;
for( int i=0; i<3; ++i ){
double diff = getClass().sizeBounds.max[i]-getClass().sizeBounds.min[i];
sz[i] = getClass().sizeBounds.min[i]+diff*ksize;
}
for( size_t i=0; i<getClass().view.size(); ++i ){
const ProtoObject::View &v = getClass().view[i];
size_t envC = this->env.size();
loadView( r, v, env );
for( size_t r=envC; r<this->env.size(); ++r )
this->env[r].viewID = i;
}
bool res = false;
for( size_t i=0; i<getClass().behaviors.size(); ++i )
if( getClass().behaviors[i]=="resource" )
res = true;
if( !getClass().data.isBackground || res ){
{ const ProtoObject::View & v = prototypes.get("selection.green").view[0];
setupMaterials( *selection[0], v );
}
{ const ProtoObject::View & v = prototypes.get("selection.over").view[0];
setupMaterials( *selection[1], v );
}
{ const ProtoObject::View & v = prototypes.get("selection.moveTo").view[0];
setupMaterials( *selection[2], v );
}
{ const ProtoObject::View & v = prototypes.get("selection.moveTo").view[0];
setupMaterials( *selection[3], v );
}
{ const ProtoObject::View & v = prototypes.get("selection.atkTo").view[0];
setupMaterials( *selection[4], v );
}
for( int i=0; i<selectModelsCount; ++i )
r.model("quad/model").setTo( *selection[i] );
}
setViewSize(1, 1, 1);
//rotate( 180 );
}
//------------------------------------------------------------------------
void CSlider::setHandle (CBitmap *_pHandle)
{
if (pHandle)
pHandle->forget ();
pHandle = _pHandle;
if (pHandle)
{
pHandle->remember ();
widthOfSlider = pHandle->getWidth ();
heightOfSlider = pHandle->getHeight ();
setViewSize (getViewSize (), true);
}
}
//------------------------------------------------------------------------
bool CKickButton::sizeToFit ()
{
if (getDrawBackground ())
{
CRect vs (getViewSize ());
vs.setHeight (heightOfOneImage);
vs.setWidth (getDrawBackground ()->getWidth ());
setViewSize (vs, true);
setMouseableArea (vs);
return true;
}
return false;
}
//------------------------------------------------------------------------
bool CSlider::sizeToFit ()
{
if (getDrawBackground ())
{
CRect vs (getViewSize ());
vs.setWidth (getDrawBackground ()->getWidth ());
vs.setHeight (getDrawBackground ()->getHeight ());
setViewSize (vs, true);
setMouseableArea (vs);
return true;
}
return false;
}
//-----------------------------------------------------------------------------------------------
bool CMovieBitmap::sizeToFit ()
{
if (getDrawBackground ())
{
CRect vs (getViewSize ());
vs.setWidth (getDrawBackground ()->getWidth ());
vs.setHeight (getHeightOfOneImage ());
setViewSize (vs);
setMouseableArea (vs);
return true;
}
return false;
}
/*
Ham xay dung noi dung cua dialog
*/
void SkillDetailDialog::createDisplaySkillInfo(Sprite* parent)
{
// Create skill image
auto skillImage = Sprite::create(_skillInfo.imagePath);
skillImage->setPosition(Vec2(skillImage->getContentSize().width + 40, parent->getContentSize().height / 2));
skillImage->setScale(2.0f);
parent->addChild(skillImage);
std::stringstream info;
info << "Name : " << _skillInfo.name << "\nId: " << _skillInfo.id << "\nMP: " << _skillInfo.mp_cost;
_statusLabel = LabelTTF::create(info.str().c_str(), "fonts/arial.ttf", 30);
_statusLabel->setColor(Color3B::RED);
_statusLabel->setHorizontalAlignment(TextHAlignment::LEFT);
// create scroll view info
if (_statusLabel->getContentSize().height > (parent->getContentSize().height - 200))
{
// Create scroll
auto scrollInfo = extension::ScrollView::create();
scrollInfo->setDirection(extension::ScrollView::Direction::VERTICAL); // cho scroll di chuyen theo chieu doc
scrollInfo->setViewSize(Size(parent->getContentSize().width / 2, 300));
scrollInfo->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
scrollInfo->setPosition(Vec2(parent->getContentSize().width / 2 - 70, 30));
scrollInfo->updateInset();
scrollInfo->setVisible(true);
parent->addChild(scrollInfo);
// Add layer to scroll
auto layer = Layer::create();
layer->setAnchorPoint(Vec2::ANCHOR_TOP_LEFT);
layer->setContentSize(Size(parent->getContentSize().width / 2, _statusLabel->getContentSize().height + 50));
layer->setPosition(Vec2(0, -(layer->getContentSize().height / 2)));
scrollInfo->setContainer(layer);
// Add _statusLabel to layer
auto height = layer->getContentSize().height;
scrollInfo->setContentOffset(scrollInfo->minContainerOffset());
_statusLabel->setAnchorPoint(Vec2::ANCHOR_TOP_LEFT);
_statusLabel->setPosition(Vec2(0, height - 20));
layer->addChild(_statusLabel);
}
else
{
_statusLabel->setPosition(Vec2(parent->getContentSize().width / 2 - 70, parent->getContentSize().height - 100));
_statusLabel->setAnchorPoint(Vec2::ANCHOR_TOP_LEFT);
parent->addChild(_statusLabel);
}
}
//------------------------------------------------------------------------
bool CTextButton::sizeToFit ()
{
if (title.empty ())
return false;
IFontPainter* painter = font ? font->getFontPainter () : 0;
if (painter)
{
CRect fitSize (getViewSize ());
fitSize.right = fitSize.left + (roundRadius + 1.) * 4.;
fitSize.right += painter->getStringWidth (0, title.c_str (), true);
setViewSize (fitSize);
setMouseableArea (fitSize);
return true;
}
return false;
}
//------------------------------------------------------------------------
bool CTextLabel::sizeToFit ()
{
if (fontID == 0 || fontID->getPlatformFont () == 0 || fontID->getPlatformFont ()->getPainter () == 0)
return false;
CCoord width = fontID->getPlatformFont ()->getPainter ()->getStringWidth (0, text, true);
if (width > 0)
{
width += (getTextInset ().x * 2.);
CRect newSize = getViewSize ();
newSize.setWidth (width);
setViewSize (newSize);
setMouseableArea (newSize);
return true;
}
return false;
}
void CATextView::updateImage()
{
std::string text;
if (m_szText.empty())
{
text = m_sPlaceHolder;
}
else
{
text = m_szText;
}
m_cFontColor = m_szText.empty() ? m_cSpaceHolderColor : m_cTextColor;
if (m_pImageView)
{
m_pImageView->setColor(m_cFontColor);
}
float width = this->getBounds().size.width;
CAImage* image = g_AFTFontCache.initWithString(text.c_str(),
m_szFontName.c_str(),
m_iFontSize,
width,
0,
CATextAlignmentLeft,
CAVerticalTextAlignmentTop,
m_bWordWrap,
m_iLineSpacing,
false,
false,
false,
&m_vLinesTextView);
if (image == NULL || m_szText.empty())
{
m_vLinesTextView.clear();
}
m_pImageView->setColor(m_cFontColor);
m_pImageView->setImage(image);
CCRect rect = CCRectZero;
rect.size = image->getContentSize();
m_pImageView->setImageRect(rect);
m_pImageView->setFrame(rect);
setViewSize(rect.size);
calcCursorPosition();
}
bool MDragDownView::init(float fViewWith, float fViewMinHeight, float fViewMaxHeight, CCNode *pContainer)
{
if(!CCLayer::init())
{
return false;
}
setTouchMode(kCCTouchesOneByOne);
setTouchEnabled(true);
setViewSize(fViewWith, fViewMinHeight, fViewMaxHeight);
setContainer(pContainer);
schedule(schedule_selector(MDragDownView::step));
return true;
}
/*
* This sets the scrolling list items.
*/
void setCDKScrollItems (CDKSCROLL *scrollp, CDK_CSTRING2 list, int listSize, boolean numbers)
{
int x = 0;
if (createCDKScrollItemList (scrollp, numbers, list, listSize) <= 0)
return;
/* Clean up the display. */
for (x = 0; x < scrollp->viewSize; x++)
{
writeBlanks (scrollp->win, 1, SCREEN_YPOS (scrollp, x),
HORIZONTAL, 0, scrollp->boxWidth - 2);
}
setViewSize (scrollp, listSize);
setCDKScrollPosition (scrollp, 0);
scrollp->leftChar = 0;
}
void CATextView::updateImage()
{
std::string text;
if (m_szText.empty())
{
text = m_sPlaceHolder;
this->setFontColor(m_cSpaceHolderColor);
}
else
{
text = m_szText;
this->setFontColor(m_cTextColor);
}
float width = this->getBounds().size.width;
float height = this->getBounds().size.height;
CCSize size = CCSizeMake(width, 0);
CAImage* image = NULL;
#if (CC_TARGET_PLATFORM != CC_PLATFORM_LINUX)
image = g_AFTFontCache.initWithStringEx(text.c_str(),
m_szFontName.c_str(),
m_iFontSize,
width,
0,
m_vLinesTextView,
m_iLineSpacing,
m_bWordWrap);
#endif
if (image == NULL || m_szText.empty())
{
m_vLinesTextView.clear();
}
m_pImageView->initWithImage(image);
setViewSize(m_pImageView->getBounds().size);
calcCursorPosition();
}
void DirectXRenderManager::initialise(IDirect3DDevice9 *_device)
{
MYGUI_PLATFORM_ASSERT(false == mIsInitialise, INSTANCE_TYPE_NAME << " initialised twice");
MYGUI_PLATFORM_LOG(Info, "* Initialise: " << INSTANCE_TYPE_NAME);
mpD3DDevice = _device;
mVertexFormat = VertexColourType::ColourARGB;
memset(&mInfo, 0, sizeof(mInfo));
if (mpD3DDevice != nullptr)
{
D3DVIEWPORT9 vp;
mpD3DDevice->GetViewport(&vp);
setViewSize(vp.Width, vp.Height);
}
mUpdate = false;
MYGUI_PLATFORM_LOG(Info, INSTANCE_TYPE_NAME << " successfully initialized");
mIsInitialise = true;
}
//------------------------------------------------------------------------
bool COptionMenu::popup (CFrame* frame, const CPoint& frameLocation)
{
if (frame == 0)
return false;
if (isAttached ())
return false;
CBaseObjectGuard guard (this);
CView* oldFocusView = frame->getFocusView ();
CBaseObjectGuard ofvg (oldFocusView);
CRect size (frameLocation, CPoint (0, 0));
setViewSize (size);
frame->addView (this);
popup ();
frame->removeView (this, false);
frame->setFocusView (oldFocusView);
int32_t index;
if (getLastItemMenu (index))
return true;
return false;
}
bool CCCGameScrollView::createContainer(CCCGameScrollViewDelegate *pDele, int nCount, const cocos2d::CCSize &oSize )
{
CCAssert(m_bSetDirection, "must call setDirection first!!!");
m_nPageCount = nCount;
m_CellSize = oSize;
setDelegate(pDele);
if (nCount==1) {
}
CCLayer *pContainer = CCLayer::create();
CCSize winSize =CCSizeZero ; //CCDirector::sharedDirector()->getVisibleSize();
for (int i = 0; i < nCount; ++i)
{
CCNode *pNode = CCNode::create();
pNode->setAnchorPoint(ccp(0, 0));
pDele->scrollViewInitPage(this, pNode, i);
if (m_eDirection == kCCScrollViewDirectionHorizontal)
{
pNode->setPosition(ccp( i * oSize.width, 0));
}
else
{
pNode->setPosition(ccp(0,i * oSize.height));
}
pNode->setContentSize(m_CellSize);
pNode->setTag(i);
pContainer->addChild(pNode);
}
setViewSize(m_CellSize);
setContainer(pContainer);
return true;
}
//------------------------------------------------------------------------
bool CAnimationSplashScreen::sizeToFit ()
{
if (modalView && modalView->getBackground ())
{
CRect r = modalView->getViewSize ();
r.setWidth (modalView->getBackground ()->getWidth ());
r.setHeight (modalView->getBackground ()->getHeight ());
if (getFrame ())
{
r.centerInside (getFrame ()->getViewSize ());
}
modalView->setViewSize (r);
modalView->setMouseableArea (r);
}
if (getBackground ())
{
CRect r = getViewSize ();
r.setWidth (getBackground ()->getWidth ());
r.setHeight (getBackground ()->getHeight ());
setViewSize (r);
setMouseableArea (r);
}
return true;
}
void GameObject::setViewSize(float s) {
setViewSize(s,s,s);
}
void Window::updateView() {
setViewSize(getSize());
}
void DirectX11RenderManager::initialise(ID3D11Device* _device)
{
MYGUI_PLATFORM_ASSERT(!mIsInitialise, getClassTypeName() << " initialised twice");
MYGUI_PLATFORM_LOG(Info, "* Initialise: " << getClassTypeName());
mpD3DDevice = _device;
_device->GetImmediateContext(&mpD3DContext);
mVertexFormat = VertexColourType::ColourABGR;
std::string vertexProfile, pixelProfile;
if ( mpD3DDevice->GetFeatureLevel() == D3D_FEATURE_LEVEL_11_0 )
{
vertexProfile = "vs_5_0";
pixelProfile = "ps_5_0";
}
else if ( mpD3DDevice->GetFeatureLevel() == D3D_FEATURE_LEVEL_10_1 )
{
vertexProfile = "vs_4_1";
pixelProfile = "ps_4_1";
}
else if ( mpD3DDevice->GetFeatureLevel() == D3D_FEATURE_LEVEL_10_0 )
{
vertexProfile = "vs_4_0";
pixelProfile = "ps_4_0";
}
else if ( mpD3DDevice->GetFeatureLevel() == D3D_FEATURE_LEVEL_9_3 )
{
vertexProfile = "vs_4_0_level_9_3";
pixelProfile = "ps_4_0_level_9_3";
}
else if ( mpD3DDevice->GetFeatureLevel() == D3D_FEATURE_LEVEL_9_2 )
{
vertexProfile = "vs_4_0_level_9_1";
pixelProfile = "ps_4_0_level_9_1";
}
else if ( mpD3DDevice->GetFeatureLevel() == D3D_FEATURE_LEVEL_9_1 )
{
vertexProfile = "vs_4_0_level_9_1";
pixelProfile = "ps_4_0_level_9_1";
}
// Get Current viewports
memset(&mInfo, 0, sizeof(mInfo));
UINT numViewports = 0;
D3D11_VIEWPORT viewports[8];
mpD3DContext->RSGetViewports(&numViewports, viewports);
MYGUI_PLATFORM_ASSERT(numViewports == 0, getClassTypeName() << " 0 viewport sets");
setViewSize((int)viewports[0].Width, (int)viewports[0].Height);
UINT flags = (1 << 11) | (1 << 15);
// Build Flat Vertex Shader
ID3DBlob* bytecode = 0, *errors = 0, *signature0 = 0, *signature1 = 0;
HRESULT hr = D3DCompile(vsSource, strlen(vsSource), "VertexShader0", 0, 0, "main", vertexProfile.c_str(), flags, 0, &bytecode, &errors);
MYGUI_PLATFORM_ASSERT(hr == S_OK, (errors ? (char*)errors->GetBufferPointer() : "Vertex Shader Compilation failed, unknown errors!"));
hr = D3DGetInputSignatureBlob(bytecode->GetBufferPointer(), bytecode->GetBufferSize(), &signature0);
MYGUI_PLATFORM_ASSERT(hr == S_OK, (errors ? (char*)errors->GetBufferPointer() : "Vertex Shader Compilation failed, failed to get input signature!"));
hr = mpD3DDevice->CreateVertexShader(bytecode->GetBufferPointer(), bytecode->GetBufferSize(), 0, &mVertexShader0);
MYGUI_PLATFORM_ASSERT(hr == S_OK, (errors ? (char*)errors->GetBufferPointer() : "Vertex Shader Create failed!"));
if ( bytecode ) bytecode->Release();
if ( errors ) errors->Release();
// Build Textured Vertex Shader
bytecode = 0;
errors = 0;
hr = D3DCompile(vsTexturedSource, strlen(vsTexturedSource), "VertexShader1", 0, 0, "main", vertexProfile.c_str(), flags, 0, &bytecode, &errors);
MYGUI_PLATFORM_ASSERT(hr == S_OK, (errors ? (char*)errors->GetBufferPointer() : "Vertex Shader Compilation failed, unknown errors!"));
hr = D3DGetInputSignatureBlob(bytecode->GetBufferPointer(), bytecode->GetBufferSize(), &signature1);
MYGUI_PLATFORM_ASSERT(hr == S_OK, (errors ? (char*)errors->GetBufferPointer() : "Vertex Shader Compilation failed, failed to get input signature!"));
hr = mpD3DDevice->CreateVertexShader(bytecode->GetBufferPointer(), bytecode->GetBufferSize(), 0, &mVertexShader1);
MYGUI_PLATFORM_ASSERT(hr == S_OK, (errors ? (char*)errors->GetBufferPointer() : "Vertex Shader Create failed!"));
if ( bytecode ) bytecode->Release();
if ( errors ) errors->Release();
// Build Flat Pixel Shader
bytecode = 0;
errors = 0;
hr = D3DCompile(psSource, strlen(psSource), "PixelShader0", 0, 0, "main", pixelProfile.c_str(), flags, 0, &bytecode, &errors);
MYGUI_PLATFORM_ASSERT(hr == S_OK, (errors ? (char*)errors->GetBufferPointer() : "Vertex Shader Compilation failed, unknown errors!"));
hr = mpD3DDevice->CreatePixelShader(bytecode->GetBufferPointer(), bytecode->GetBufferSize(), 0, &mPixelShader0);
MYGUI_PLATFORM_ASSERT(hr == S_OK, (errors ? (char*)errors->GetBufferPointer() : "Vertex Shader Create failed!"));
if ( bytecode ) bytecode->Release();
if ( errors ) errors->Release();
// Build Textured Pixel Shader
bytecode = 0;
errors = 0;
hr = D3DCompile(psTexturedSource, strlen(psTexturedSource), "PixelShader1", 0, 0, "main", pixelProfile.c_str(), flags, 0, &bytecode, &errors);
MYGUI_PLATFORM_ASSERT(hr == S_OK, (errors ? (char*)errors->GetBufferPointer() : "Vertex Shader Compilation failed, unknown errors!"));
hr = mpD3DDevice->CreatePixelShader(bytecode->GetBufferPointer(), bytecode->GetBufferSize(), 0, &mPixelShader1);
MYGUI_PLATFORM_ASSERT(hr == S_OK, (errors ? (char*)errors->GetBufferPointer() : "Vertex Shader Create failed!"));
if ( bytecode ) bytecode->Release();
if ( errors ) errors->Release();
// Create Sampler State
D3D11_SAMPLER_DESC samplerDesc;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.BorderColor[0] = samplerDesc.BorderColor[1] = samplerDesc.BorderColor[2] = samplerDesc.BorderColor[3] = 0.0f;
samplerDesc.ComparisonFunc = (D3D11_COMPARISON_FUNC)0;
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
samplerDesc.MaxAnisotropy = 1;
samplerDesc.MaxLOD = 0;
samplerDesc.MinLOD = 0;
samplerDesc.MipLODBias = 0.0f;
hr = mpD3DDevice->CreateSamplerState(&samplerDesc, &mSamplerState);
MYGUI_PLATFORM_ASSERT(hr == S_OK, "Sampler State Create failed!");
// Create Blend State
D3D11_BLEND_DESC blendDesc;
blendDesc.AlphaToCoverageEnable = false;
blendDesc.IndependentBlendEnable = false;
blendDesc.RenderTarget[0].BlendEnable = true;
blendDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
blendDesc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
blendDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
blendDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_SRC_ALPHA;
blendDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA;
blendDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
blendDesc.RenderTarget[0].RenderTargetWriteMask = 0x0f;
hr = mpD3DDevice->CreateBlendState(&blendDesc, &mBlendState);
MYGUI_PLATFORM_ASSERT(hr == S_OK, "Blend State Create failed!");
// Create Depth Stencil State
D3D11_DEPTH_STENCIL_DESC depthDesc;
depthDesc.DepthEnable = false;
depthDesc.DepthFunc = D3D11_COMPARISON_ALWAYS;
depthDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
depthDesc.StencilEnable = false;
depthDesc.StencilReadMask = depthDesc.StencilWriteMask = 0;
depthDesc.BackFace.StencilDepthFailOp = depthDesc.BackFace.StencilFailOp = depthDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
depthDesc.FrontFace = depthDesc.BackFace;
hr = mpD3DDevice->CreateDepthStencilState(&depthDesc, &mDepthStencilState);
MYGUI_PLATFORM_ASSERT(hr == S_OK, "Depth Stencil State Create failed!");
// Create Rasterizer State
D3D11_RASTERIZER_DESC rastDesc;
rastDesc.FillMode = D3D11_FILL_SOLID;
rastDesc.CullMode = D3D11_CULL_NONE;
rastDesc.FrontCounterClockwise = FALSE;
rastDesc.DepthBias = 0;
rastDesc.DepthBiasClamp = 0;
rastDesc.SlopeScaledDepthBias = 0;
rastDesc.ScissorEnable = FALSE;
rastDesc.MultisampleEnable = FALSE;
rastDesc.AntialiasedLineEnable = FALSE;
hr = mpD3DDevice->CreateRasterizerState(&rastDesc, &mRasterizerState);
MYGUI_PLATFORM_ASSERT(hr == S_OK, "Rasterizer State Create failed!");
// Create Input Layout
hr = mpD3DDevice->CreateInputLayout(vertexLayout, 3, signature0->GetBufferPointer(), signature0->GetBufferSize(), &mInputLayout0);
MYGUI_PLATFORM_ASSERT(hr == S_OK, "Input Layout Create failed!");
signature0->Release();
// Create Input Layout
hr = mpD3DDevice->CreateInputLayout(vertexLayout, 3, signature1->GetBufferPointer(), signature1->GetBufferSize(), &mInputLayout1);
MYGUI_PLATFORM_ASSERT(hr == S_OK, "Input Layout Create failed!");
signature1->Release();
mUpdate = false;
MYGUI_PLATFORM_LOG(Info, getClassTypeName() << " successfully initialized");
mIsInitialise = true;
}
/*
* This function creates a new scrolling list widget.
*/
CDKSCROLL *newCDKScroll (CDKSCREEN *cdkscreen,
int xplace,
int yplace,
int splace,
int height,
int width,
const char *title,
CDK_CSTRING2 list,
int listSize,
boolean numbers,
chtype highlight,
boolean Box,
boolean shadow)
{
/* *INDENT-EQLS* */
CDKSCROLL *scrollp = 0;
int parentWidth = getmaxx (cdkscreen->window);
int parentHeight = getmaxy (cdkscreen->window);
int boxWidth = width;
int boxHeight = height;
int xpos = xplace;
int ypos = yplace;
int scrollAdjust = 0;
int x;
/* *INDENT-OFF* */
static const struct { int from; int to; } bindings[] = {
{ CDK_BACKCHAR, KEY_PPAGE },
{ CDK_FORCHAR, KEY_NPAGE },
{ 'g', KEY_HOME },
{ '1', KEY_HOME },
{ 'G', KEY_END },
{ '<', KEY_HOME },
{ '>', KEY_END },
};
/* *INDENT-ON* */
if ((scrollp = newCDKObject (CDKSCROLL, &my_funcs)) == 0)
{
destroyCDKObject (scrollp);
return (0);
}
setCDKScrollBox (scrollp, Box);
/*
* If the height is a negative value, the height will
* be ROWS-height, otherwise, the height will be the
* given height.
*/
boxHeight = setWidgetDimension (parentHeight, height, 0);
/*
* If the width is a negative value, the width will
* be COLS-width, otherwise, the width will be the
* given width.
*/
boxWidth = setWidgetDimension (parentWidth, width, 0);
boxWidth = setCdkTitle (ObjOf (scrollp), title, boxWidth);
/* Set the box height. */
if (TitleLinesOf (scrollp) > boxHeight)
{
boxHeight = (TitleLinesOf (scrollp)
+ MINIMUM (listSize, 8)
+ 2 * BorderOf (scrollp));
}
/* Adjust the box width if there is a scrollp bar. */
if ((splace == LEFT) || (splace == RIGHT))
{
scrollp->scrollbar = TRUE;
boxWidth += 1;
}
else
{
scrollp->scrollbar = FALSE;
}
/*
* Make sure we didn't extend beyond the dimensions of the window.
*/
scrollp->boxWidth = (boxWidth > parentWidth
? (parentWidth - scrollAdjust)
: boxWidth);
scrollp->boxHeight = (boxHeight > parentHeight
? parentHeight
: boxHeight);
setViewSize (scrollp, listSize);
/* Rejustify the x and y positions if we need to. */
alignxy (cdkscreen->window, &xpos, &ypos, scrollp->boxWidth, scrollp->boxHeight);
/* Make the scrolling window */
scrollp->win = newwin (scrollp->boxHeight, scrollp->boxWidth, ypos, xpos);
/* Is the scrolling window null?? */
if (scrollp->win == 0)
{
destroyCDKObject (scrollp);
return (0);
}
/* Turn the keypad on for the window. */
keypad (scrollp->win, TRUE);
/* Create the scrollbar window. */
if (splace == RIGHT)
{
scrollp->scrollbarWin = subwin (scrollp->win,
maxViewSize (scrollp), 1,
SCREEN_YPOS (scrollp, ypos),
xpos + scrollp->boxWidth
- BorderOf (scrollp) - 1);
}
else if (splace == LEFT)
{
scrollp->scrollbarWin = subwin (scrollp->win,
maxViewSize (scrollp), 1,
SCREEN_YPOS (scrollp, ypos),
SCREEN_XPOS (scrollp, xpos));
}
else
{
scrollp->scrollbarWin = 0;
}
/* create the list window */
scrollp->listWin = subwin (scrollp->win,
maxViewSize (scrollp),
scrollp->boxWidth
- 2 * BorderOf (scrollp) - scrollAdjust,
SCREEN_YPOS (scrollp, ypos),
SCREEN_XPOS (scrollp, xpos)
+ (splace == LEFT ? 1 : 0));
/* *INDENT-EQLS* Set the rest of the variables */
ScreenOf (scrollp) = cdkscreen;
scrollp->parent = cdkscreen->window;
scrollp->shadowWin = 0;
scrollp->scrollbarPlacement = splace;
scrollp->maxLeftChar = 0;
scrollp->leftChar = 0;
scrollp->highlight = highlight;
initExitType (scrollp);
ObjOf (scrollp)->acceptsFocus = TRUE;
ObjOf (scrollp)->inputWindow = scrollp->win;
scrollp->shadow = shadow;
setCDKScrollPosition (scrollp, 0);
/* Create the scrolling list item list and needed variables. */
if (createCDKScrollItemList (scrollp, numbers, list, listSize) <= 0)
{
destroyCDKObject (scrollp);
return (0);
}
/* Do we need to create a shadow? */
if (shadow)
{
scrollp->shadowWin = newwin (scrollp->boxHeight,
boxWidth,
ypos + 1,
xpos + 1);
}
/* Setup the key bindings. */
for (x = 0; x < (int)SIZEOF (bindings); ++x)
bindCDKObject (vSCROLL,
scrollp,
(chtype)bindings[x].from,
getcCDKBind,
(void *)(long)bindings[x].to);
registerCDKObject (cdkscreen, vSCROLL, scrollp);
/* Return the scrolling list */
return scrollp;
}
