ATOM_CellData::ATOM_CellData (ATOM_Widget *parent, const ATOM_Rect2Di &rect, unsigned style, int id, ATOM_Widget::ShowState showState)
: ATOM_Label (parent, rect, (style & ~ATOM_Widget::TitleBar) | ATOM_Widget::Control | ATOM_Widget::NonLayoutable, id, showState)
{
ATOM_STACK_TRACE(ATOM_CellData::ATOM_CellData);
ATOM_ASSERT(parent);
ATOM_ASSERT(getRenderer());
_cooldown = 0;
_cooldownMax = 0;
_cooldownImageId = ATOM_INVALID_IMAGEID;
_selectImageId = ATOM_INVALID_IMAGEID;
_frameImageId = ATOM_INVALID_IMAGEID;
_subscriptImageId = ATOM_INVALID_IMAGEID;
_frameOffset = 0;
_oldPosition = rect.point;
_clientDragging = false;
_subscirptTextDirty = false;
_subscriptText = ATOM_HARDREF(ATOM_Text)();
_subscriptText->setFont (ATOM_GUIFont::getFontHandle(getFont()));
_subscriptText->setCharMargin (ATOM_GUIFont::getFontCharMargin(getFont()));
_subscriptText->setZValue (1.f);
_subscriptText->setDisplayMode (ATOM_Text::DISPLAYMODE_2D);
_subscriptRect = ATOM_Rect2Di(0,0,0,0);
_subscriptTextPosition.x = _subscriptTextPosition.y = 0;
setBorderMode (ATOM_Widget::Raise);
resize (rect);
#if defined(USE_WIDGET_DEBUG_INFO)
ATOM_Widget::registerWidgetDebugInfo (this);
#endif
}
bool ATOM_TerrainQuadtreeNode::initialize (ATOM_TerrainQuadtree *quadtree, ATOM_TerrainQuadtreeNode *parent, ATOM_TerrainPatch::PatchPosition position, ATOM_VertexArray *baseVertices)
{
ATOM_STACK_TRACE(ATOM_TerrainQuadtreeNode::initialize);
ATOM_ASSERT(!_parent);
ATOM_ASSERT(!_patch);
_parent = parent;
_patch = ATOM_NEW(ATOM_TerrainPatch);
if (!_patch->initialize (quadtree, _parent ? _parent->_patch : 0, position, baseVertices))
{
return false;
}
if (_patch->getStep () > 1)
{
for (unsigned i = 0; i < 4; ++i)
{
_children[i] = ATOM_NEW(ATOM_TerrainQuadtreeNode);
if (!_children[i]->initialize (quadtree, this, (ATOM_TerrainPatch::PatchPosition)i, baseVertices))
{
return false;
}
}
}
return true;
}
void ATOM_SpatialCell::detachNode (ATOM_Node *node)
{
if (node)
{
NodeInfo *info = node->getCellNodeInfo ();
ATOM_ASSERT(info);
if (info->prev)
{
ATOM_ASSERT(info != _M_nodes);
info->prev->next = info->next;
if (info->next)
{
info->next->prev = info->prev;
}
}
else
{
ATOM_ASSERT(info == _M_nodes);
_M_nodes = info->next;
if (_M_nodes)
{
_M_nodes->prev = 0;
}
}
ATOM_DELETE(info);
node->setCellNodeInfo (0);
}
}
ATOM_Button::ATOM_Button (ATOM_Widget *parent, const ATOM_Rect2Di &rect, unsigned style, int id, ATOM_Widget::ShowState showState)
:
ATOM_Label (parent, rect, (style & ~ATOM_Widget::TitleBar)|ATOM_Widget::Control, id, showState)
{
ATOM_STACK_TRACE(ATOM_Button::ATOM_Button);
ATOM_ASSERT(parent);
ATOM_ASSERT(getRenderer());
_mouseOn = false;
_mouseEnterAnimator = NULL;
_mouseLeaveAnimator = NULL;
_currentAnimator = NULL;
_clickSound = INVALID_AUDIOID;
_hoverSound = INVALID_AUDIOID;
setBorderMode (ATOM_Widget::Raise);
resize (rect);
#if defined(USE_WIDGET_DEBUG_INFO)
ATOM_Widget::registerWidgetDebugInfo (this);
#endif
}
ATOM_PropertyList::ATOM_PropertyList (ATOM_Widget *parent, const ATOM_Rect2Di &rect, unsigned style, int id, ATOM_Widget::ShowState showState)
: ATOM_ListView (parent, rect, style|ATOM_Widget::Control, id, showState)
{
ATOM_STACK_TRACE(ATOM_PropertyList::ATOM_PropertyList);
ATOM_ASSERT(parent);
ATOM_ASSERT(getRenderer());
setColumnCount(2);
#if defined(USE_WIDGET_DEBUG_INFO)
ATOM_Widget::registerWidgetDebugInfo (this);
#endif
}
ATOM_Edit::ATOM_Edit (ATOM_Widget *parent, const ATOM_Rect2Di &rect, unsigned style, int id, ATOM_Widget::ShowState showState)
: ATOM_Widget (parent, rect, style|ATOM_Widget::Control|ATOM_Widget::ClipChildren, id, showState)
{
ATOM_STACK_TRACE(ATOM_Edit::ATOM_Edit);
ATOM_ASSERT(parent);
ATOM_ASSERT(getRenderer());
_text = ATOM_HARDREF(ATOM_Text) ();
_text->setFont (ATOM_GUIFont::getFontHandle(getFont()));
_text->setCharMargin (0);
_text->setZValue (1.f);
_text->setDisplayMode (ATOM_Text::DISPLAYMODE_2D);
//_outlineColor.setRaw(0);
_textPosition.x = 0;
_textPosition.y = 0;
_textDirty = false;
_textDefault = ATOM_HARDREF(ATOM_Text) ();
_textDefault->setFont (ATOM_GUIFont::getFontHandle(getFont()));
_textDefault->setCharMargin (0);
_textDefault->setZValue (1.f);
_textDefault->setDisplayMode (ATOM_Text::DISPLAYMODE_2D);
_fontDefualtColor = ATOM_ColorARGB(1.f, 1.f, 1.f, 1.f);
_textDefaultPosition.x = 0;
_textDefaultPosition.y = 0;
_startPosition = 0;
_cursor = 0;
_cursorImageId = ATOM_IMAGEID_EDIT_CURSOR;
_cursorOffset = 0;
_cursorWidth = 2;
_cursorPosition.x = 0;
_cursorPosition.y = 0;
_cusorNewPosition = _cusorOldPosition = _cursorPosition;
_offsetX = 0;
_editType = 0;
_maxLength = 0;
_frontImageId = 1;
_selectStart = -1;
resize (rect);
#if defined(USE_WIDGET_DEBUG_INFO)
ATOM_Widget::registerWidgetDebugInfo (this);
#endif
}
void ATOM_Octree::initialize (float rootsize, float leafsize)
{
ATOM_ASSERT (rootsize >= leafsize && leafsize > 0);
finalize ();
_M_root_size = rootsize;
_M_leaf_size = leafsize;
unsigned n = 1;
for (; rootsize >= leafsize * 2.f; leafsize *= 2.f, ++n)
;
_M_chunks.resize (n);
for (unsigned i = 0; i < n; ++i, rootsize *= 0.5f)
{
_M_chunks[i] = ATOM_NEW(ATOM_OctreeNodeChunk, this);
_M_chunks[i]->setLevel (i);
_M_chunks[i]->setNodeSize (rootsize);
_M_chunks[i]->setNodeSizeLoosed (rootsize * 1.5f);
_M_chunks[i]->setDimension (1 << i);
if (i > 0)
{
_M_chunks[i-1]->setNext (_M_chunks[i]);
_M_chunks[i]->setPrev (_M_chunks[i-1]);
}
}
_M_chunks.back ()->setNext (0);
}
ATOM_AUTOREF(ATOM_RenderWindow) ATOM_Renderer::createRenderWindow(const char *title, int w, int h, bool naked, bool resizable, int multisample, ATOM_RenderWindow::ShowMode showMode, void* windowid, void *parentid, bool contentBackup, void *instance)
{
ATOM_STACK_TRACE(ATOM_Renderer::createRenderWindow);
if (!device)
{
return 0;
}
ATOM_HARDREF(ATOM_D3D9Window) window;
ATOM_ASSERT(window);
ATOM_RenderWindow::Hints hints;
hints.accel = true;
hints.bounds.first = w;
hints.bounds.second = h;
hints.resizable = resizable;
hints.naked = naked;
hints.bpp = 32;
hints.samples = multisample;
if (!window->open (device, title ? title : "", &hints, showMode, windowid, parentid, 0, instance))
{
return 0;
}
return window;
}
void ATOM_TerrainPatch::render (ATOM_RenderDevice *device)
{
ATOM_STACK_TRACE(ATOM_TerrainPatch::render);
ATOM_ASSERT(_quadtree);
_geometry->draw (device, _quadtree->getPrimitiveType(), _quadtree->getPrimitiveCount(), 0);
}
ATOM_InstanceMesh::ATOM_InstanceMesh (ATOM_Node *node, ATOM_Mesh *mesh): _node(node), _mesh(mesh)
{
ATOM_STACK_TRACE(ATOM_InstanceMesh::ATOM_InstanceMesh);
ATOM_ASSERT(_mesh);
_id = 0;
_index = -1;
_visible = true;
_billboardNormal = mesh->billboardNormal;
_billboardXAxis = mesh->billboardXAxis;
_billboardCenter = mesh->billboardCenter;
_worldMatrix = mesh->worldMatrix;
_jointMapOk = false;
_currentMapping = 0;
_glareTexture = 0;
_glareVelocity.set(0.f, 0.f, 0.f, 0.f);
_glareRepeat.set(1.f, 1.f, 0.f, 0.f);
_albedoTexture = _mesh->diffuseTexture;
_lastAnimationFrame = -1.f;
_updateFrameStamp = 0;
_currentTrack = 0;
_currentTrackFrame = -1.f;
_diffuseColor = mesh->diffuseColor;
_alpharef = mesh->alpharef;
_shininess = mesh->shininess;
_animationContext = 0;
}
void ATOM_SpatialCell::attachNode (ATOM_Node *node, unsigned updateStamp)
{
if (node)
{
ATOM_SpatialCell::NodeInfo *nodeInfo = node->getCellNodeInfo ();
ATOM_ASSERT(!nodeInfo || nodeInfo->node == node);
if (nodeInfo && nodeInfo->cell == this)
{
nodeInfo->lastUpdateStamp = updateStamp;
}
else
{
if (nodeInfo)
{
nodeInfo->cell->detachNode (node);
}
nodeInfo = ATOM_NEW(NodeInfo);
nodeInfo->prev = 0;
nodeInfo->next = _M_nodes;
if (_M_nodes)
{
_M_nodes->prev = nodeInfo;
}
_M_nodes = nodeInfo;
nodeInfo->cell = this;
nodeInfo->node = node;
nodeInfo->lastUpdateStamp = updateStamp;
node->setCellNodeInfo (nodeInfo);
}
}
}
void ATOM_OctreeNodeChunk::freeNode (ATOM_OctreeNode *node)
{
if (node)
{
ATOM_ASSERT (node->getChunk () == this);
freeNode (node->getPosition());
}
}
ATOM_OctreeNode *ATOM_OctreeNode::getChild (Placement placement) const
{
ATOM_ASSERT (_M_chunk);
if (_M_chunk->getNext())
{
return _M_chunk->getNext()->getNode (_M_chunk->getChildIndex(_M_position, placement));
}
return 0;
}
ATOM_OctreeNode *ATOM_OctreeNode::getOrCreateParent (void) const
{
ATOM_ASSERT (_M_chunk);
if (_M_chunk->getPrev())
{
return _M_chunk->getPrev()->getOrCreateNode (_M_chunk->getParentIndex(_M_position));
}
return 0;
}
void ATOM_BaseImage::init (unsigned width, unsigned height, ATOM_PixelFormat format, const void* data, int mipcount)
{
ATOM_STACK_TRACE(ATOM_BaseImage::init);
if ( width == 0 || height == 0)
{
fini ();
return;
}
if ( !ATOM_IS_VALID_FORMAT(format))
{
ATOM_LOGGER::error ("[ATOM_BaseImage::init] Bad arguments: %d, %d, %d.\n", width, height, format);
return;
}
unsigned buffersize = 0;
const int blockdiv = 4;
switch (format)
{
case ATOM_PIXEL_FORMAT_DXT1:
case ATOM_PIXEL_FORMAT_DXT3:
case ATOM_PIXEL_FORMAT_DXT5:
{
int blocksize = (format == ATOM_PIXEL_FORMAT_DXT1) ? 8 : 16;
unsigned w = width;
unsigned h = height;
for (int i = 0; i < mipcount; ++i)
{
buffersize += ATOM_max2(blockdiv, w)/blockdiv * ATOM_max2(blockdiv, h)/blockdiv * blocksize;
w = (w+1)>>1;
h = (h+1)>>1;
}
break;
}
default:
{
unsigned bpp = ATOM_PIXEL_FORMAT(format).bpp / 8;
buffersize = width * height * bpp;
break;
}
}
if (_M_contents && buffersize > _M_actual_size)
{
fini();
}
_M_buffersize = buffersize;
if (!_M_contents)
{
_M_contents = ATOM_NEW_ARRAY(unsigned char, _M_buffersize);
ATOM_ASSERT (_M_contents);
_M_actual_size = _M_buffersize;
}
void *ATOM_HWInstancingGeometry::addInstance (void)
{
ATOM_STACK_TRACE(ATOM_HWInstancingGeometry::addInstance);
//--- wangjian added ---//
if( ATOM_RenderSettings::isUseInstancingStaticBuffer() )
return 0;
//----------------------//
if (_instanceDataStreamAttrib == 0)
{
return 0;
}
int streamIndex = _numInstances / MAX_BATCH_COUNT;
if (streamIndex != _lockedStreamIndex)
{
if (_lockedStreamIndex >= 0)
{
_instanceDataStreams[_lockedStreamIndex]->unlock ();
_lockPtr = 0;
}
if (streamIndex >= _instanceDataStreams.size())
{
_instanceDataStreams.resize (streamIndex+1);
}
if (!_instanceDataStreams[streamIndex])
{
_instanceDataStreams[streamIndex] = ATOM_GetRenderDevice()->allocVertexArray (_instanceDataStreamAttrib, ATOM_USAGE_DYNAMIC, MAX_BATCH_COUNT);
if (!_instanceDataStreams[streamIndex])
{
return 0;
}
}
_lockPtr = _instanceDataStreams[streamIndex]->lock (ATOM_LOCK_WRITEONLY, 0, 0, true);
if (!_lockPtr)
{
return 0;
}
_lockedStreamIndex = streamIndex;
}
ATOM_ASSERT(_lockPtr);
char *data = (char*)_lockPtr;
_lockPtr = data + _instanceDataSize;
_numInstances++;
return data;
}
float ATOM_TerrainPatch::getHeight (unsigned x, unsigned z) const
{
unsigned patchSize = _quadtree->getPatchSize ();
unsigned dimension = (patchSize - 1) * _step;
ATOM_ASSERT (x >= _offsetX && x <= _offsetX + dimension);
ATOM_ASSERT (z >= _offsetZ && z <= _offsetZ + dimension);
unsigned startX = _offsetX + _step * ((x - _offsetX) / _step);
unsigned startZ = _offsetZ + _step * ((z - _offsetZ) / _step);
unsigned endX = startX == x ? startX : startX + _step;
unsigned endZ = startZ == z ? startZ : startZ + _step;
unsigned rootSize = _quadtree->getRootSize ();
float lt_height = _quadtree->getHeightField()->getHeight(startX, startZ);
float rt_height = _quadtree->getHeightField()->getHeight(endX, startZ);
float lb_height = _quadtree->getHeightField()->getHeight(startX, endZ);
float rb_height = _quadtree->getHeightField()->getHeight(endX, endZ);;
float t1 = float(x - startX) / float(_step);
float t2 = float(z - startZ) / float(_step);
float h1 = lt_height + (rt_height - lt_height) * t1;
float h2 = lb_height + (rb_height - lb_height) * t1;
return h1 + (h2 - h1) * t2;
}
ATOM_Vector3f ATOM_OctreeNode::getMaxPoint (void) const
{
ATOM_ASSERT (_M_chunk);
unsigned d = _M_chunk->getDimension ();
float nodesize = _M_chunk->getNodeSize ();
float half_worldsize = _M_chunk->getWorldSize () * 0.5f;
NodeIndex px = (_M_position % d) + 1;
NodeIndex py = ((_M_position / d) % d) + 1;
NodeIndex pz = (_M_position / d / d) + 1;
return ATOM_Vector3f (px * nodesize, py * nodesize, pz * nodesize)
- ATOM_Vector3f (half_worldsize, half_worldsize, half_worldsize);
}
bool ATOM_D3DVertexArray::realize (void) {
ATOM_STACK_TRACE(ATOM_D3DVertexArray::realize);
if (!_M_vertexbuffer)
{
if (!_internalCreateVertexBuffer (_M_size_bytes))
{
ATOM_LOGGER::error ("%s() Create vertex buffer failed!\n", __FUNCTION__);
return false;
}
ATOM_ASSERT (_M_vertexbuffer);
}
return true;
}
bool ATOM_TerrainPatch::initialize (ATOM_TerrainQuadtree *quadtree, ATOM_TerrainPatch *parent, PatchPosition position, ATOM_VertexArray *baseVertices)
{
ATOM_STACK_TRACE(ATOM_TerrainPatch::initialize);
ATOM_ASSERT(quadtree);
unsigned patchSize = quadtree->getPatchSize ();
unsigned rootSize = quadtree->getRootSize ();
float scaleX = quadtree->getScaleX ();
float scaleZ = quadtree->getScaleZ ();
_mipLevel = parent ? parent->getMipLevel() + 1 : 0;
unsigned step = ((rootSize - 1) / (patchSize - 1)) >> _mipLevel;
unsigned interval = (patchSize - 1) * step;
unsigned parentOffsetX = parent ? parent->getOffsetX() : 0;
unsigned parentOffsetZ = parent ? parent->getOffsetZ() : 0;
switch (position)
{
case ATOM_TerrainPatch::LeftTop:
_offsetX = parentOffsetX;
_offsetZ = parentOffsetZ;
break;
case ATOM_TerrainPatch::RightTop:
_offsetX = parentOffsetX + interval;
_offsetZ = parentOffsetZ;
break;
case ATOM_TerrainPatch::LeftBottom:
_offsetX = parentOffsetX;
_offsetZ = parentOffsetZ + interval;
break;
case ATOM_TerrainPatch::RightBottom:
_offsetX = parentOffsetX + interval;
_offsetZ = parentOffsetZ + interval;
break;
default:
return false;
}
_position = position;
_quadtree = quadtree;
_step = step;
_parent = parent;
_maxError = computeMaxError ();
setupVertices (computeSkirtLength (), baseVertices);
_boxRadius = computeBoundingBox (_boundingBox);
return true;
}
float ATOM_TerrainPatch::computeBoundingBox (ATOM_BBox &bbox) const
{
ATOM_ASSERT(_quadtree);
float maxHeight, minHeight;
computeHeightBound (maxHeight, minHeight);
float scaleX = _quadtree->getScaleX ();
float scaleZ = _quadtree->getScaleZ ();
ATOM_Vector3f minPoint(_offsetX * scaleX, minHeight, _offsetZ * scaleZ);
ATOM_Vector3f maxPoint(_offsetX * scaleX + (_quadtree->getPatchSize() - 1) * _step * scaleX, maxHeight, _offsetZ * scaleZ + (_quadtree->getPatchSize() - 1) * _step * scaleZ);
bbox.setMax (maxPoint);
bbox.setMin (minPoint);
return (maxPoint - minPoint).getLength() * 0.5f;
}
//--- wangjian added ---//
void ATOM_Decal::setupSortFlag(int queueid)
{
//_material->autoSetActiveEffect (queueid);
unsigned sf_ac = 0;
unsigned sf_mt = 0;
unsigned sf_matid = 0;
#if 0
ULONGLONG matFlag = (ULONGLONG)_material->getActiveEffect();
ULONGLONG miscFlag = 0;
if( _texture )
miscFlag = (ULONGLONG)_texture.get();
ULONGLONG sf = ( matFlag << 32 ) + miscFlag;
#else
//unsigned matFlag = (unsigned)_material->getActiveEffect();
/*int effectid = getEffectIdEnd(ATOM_RenderScheme::getCurrentRenderScheme());
ATOM_ASSERT(effectid!=-1);
unsigned matFlag = (unsigned)_material->getCoreMaterial()->getEffect(effectid);
matFlag <<= 16;
matFlag /= 100000;
matFlag *= 100000;
unsigned miscFlag = 0;
if( _texture )
{
miscFlag = (unsigned)_texture.get();
}
unsigned sf = matFlag + ( miscFlag & 0x0000ffff );*/
int effectid = getEffectIdEnd(ATOM_RenderScheme::getCurrentRenderScheme());
ATOM_ASSERT(effectid>=0);
sf_ac = (unsigned)_material->getCoreMaterial()->getEffect(effectid);
if( _texture )
{
sf_mt = (unsigned)_texture.get();
}
#endif
//setSortFlag(sf);
setSortFlag(sf_ac,sf_mt,sf_matid);
}
int ATOM_ModelLoader::unlock (void)
{
ATOM_STACK_TRACE(ATOM_ModelLoader::unlock);
ATOM_ModelLockStruct *s = _model->getLockStruct ();
ATOM_ASSERT(s);
if (!s->wait)
{
s->wait = true;
_model->unlock ();
_model->initMaterials (true, true);
}
bool loadFailed = false;
for (unsigned i = 0; i < s->depends.size(); ++i)
{
ATOM_LoadInterface::LoadingState state = s->depends[i]->getLoadingState();
if (state == ATOM_LoadInterface::LS_LOADING)
{
return LOADINGSTAGE_TRYAGAIN;
}
else if (state != ATOM_LoadInterface::LS_LOADED)
{
ATOM_TextureLoadInterface *textureLoadInterface = dynamic_cast<ATOM_TextureLoadInterface*>(s->depends[i]);
if (textureLoadInterface)
{
ATOM_LOGGER::error ("Texture <%s> load failed\n", textureLoadInterface->getFileName());
textureLoadInterface->setTexture (ATOM_GetColorTexture (0xFFFFFFFF));
textureLoadInterface->setLoadingState (ATOM_LoadInterface::LS_LOADED);
}
else
{
loadFailed = true;
}
}
}
s->depends.clear ();
return loadFailed ? LOADINGSTAGE_NOTLOADED : LOADINGSTAGE_FINISH;
}
void ATOM_GameEntity::attachNode (ATOM_Node *node)
{
ATOM_ASSERT(node);
class AttachVisitor: public ATOM_Visitor
{
public:
AttachVisitor (ATOM_GameEntity *entity): _entity (entity) {}
ATOM_GameEntity *_entity;
public:
virtual void visit (ATOM_Node &node)
{
//ATOM_ASSERT(!node.getGameEntity());
node.setGameEntity (_entity);
}
};
// _node = node;
AttachVisitor v(this);
v.traverse (*node);
}
void ATOM_CellData::onPaint (ATOM_WidgetDrawClientEvent *event)
{
ATOM_STACK_TRACE(ATOM_CellData::onPaint);
ATOM_Rect2Di outRect(ATOM_Point2Di(0, 0), event->canvas->getSize());
ATOM_Rect2Di inRect(_frameOffset, _frameOffset, outRect.size.w-_frameOffset*2, outRect.size.h-_frameOffset*2);
bool inCD = (ATOM_INVALID_IMAGEID != _cooldownImageId) && _cooldownMax;
if (_frameImageId != ATOM_INVALID_IMAGEID)
{
ATOM_GUIImage *image = getValidImage (_frameImageId);
image->draw (event->state, event->canvas, outRect);
}
if (_clientImageId != ATOM_INVALID_IMAGEID)
{
ATOM_GUIImage *image = getValidImage (_clientImageId);
if (!image)
{
image = ATOM_GUIImageList::getDefaultImageList().getImage (ATOM_IMAGEID_WINDOW_BKGROUND);
ATOM_ASSERT(image);
}
if(_customColor)
{
image->draw (event->state, event->canvas, inRect, &_customColor);
}
else
{
image->draw (event->state, event->canvas, inRect);
}
}
if (!_caption.empty())
{
if (_textDirty)
{
calcTextLayout ();
_textDirty = false;
}
ATOM_GUICanvas::DrawTextInfo info;
info.textObject = _text.get();
info.textString = _text->getString();
info.font = _text->getFont();
info.x = _textPosition.x;
info.y = _textPosition.y;
info.shadowOffsetX = 0;
info.shadowOffsetY = 0;
info.textColor = getFontColor();
info.outlineColor = _widgetFontOutLineColor;
info.shadowColor = 0;
info.underlineColor = _underlineColor;
info.flags = ATOM_GUICanvas::DRAWTEXT_TEXTOBJECT;
if(_widgetFontOutLineColor.getByteA())
{
info.flags |= ATOM_GUICanvas::DRAWTEXT_OUTLINE;
}
if(_underlineColor.getByteA())
{
info.flags |= ATOM_GUICanvas::DRAWTEXT_UNDERLINE;
}
event->canvas->drawTextEx(&info);
//event->canvas->drawText (_text.get(), _textPosition.x, _textPosition.y, getFontColor());
}
//»æÖÆϱê×ÖÌå
if (!_subscriptStr.empty())
{
if (_subscirptTextDirty)
{
calcSubscriptTextLayout();
_subscirptTextDirty = false;
}
ATOM_GUICanvas::DrawTextInfo info;
info.textObject = _subscriptText.get();
info.textString = _subscriptText->getString();
info.font = _subscriptText->getFont();
info.x = _subscriptTextPosition.x;
info.y = _subscriptTextPosition.y;
info.shadowOffsetX = 0;
info.shadowOffsetY = 0;
info.textColor = getFontColor();
info.outlineColor = _widgetFontOutLineColor;
info.shadowColor = 0;
info.underlineColor = _underlineColor;
info.flags = ATOM_GUICanvas::DRAWTEXT_TEXTOBJECT;
if(_widgetFontOutLineColor.getByteA())
{
info.flags |= ATOM_GUICanvas::DRAWTEXT_OUTLINE;
}
if(_underlineColor.getByteA())
{
info.flags |= ATOM_GUICanvas::DRAWTEXT_UNDERLINE;
}
event->canvas->drawTextEx(&info);
//event->canvas->drawText (_text.get(), _textPosition.x, _textPosition.y, getFontColor());
}
//»æÖÆϱêͼƬ
if(_subscriptImageId != ATOM_INVALID_IMAGEID)
{
ATOM_GUIImage *image = getValidImage (_subscriptImageId);
if(!image)
{
image = ATOM_GUIImageList::getDefaultImageList().getImage(ATOM_IMAGEID_WINDOW_BKGROUND);
ATOM_ASSERT(image);
}
image->draw(event->state,event->canvas,ATOM_Rect2Di(inRect.point.x+_subscriptRect.point.x,
inRect.point.y+_subscriptRect.point.y,_subscriptRect.size.w,_subscriptRect.size.h));
}
if (_selectImageId != ATOM_INVALID_IMAGEID)
{
#if 1
ATOM_GUIImage *image = getValidImage (_selectImageId);
#else
const ATOM_GUIImageList *imagelist = getValidImageList ();
ATOM_GUIImage *image = imagelist->getImage (_selectImageId);
#endif
if (!image)
{
image = ATOM_GUIImageList::getDefaultImageList().getImage (ATOM_IMAGEID_WINDOW_BKGROUND);
ATOM_ASSERT(image);
}
image->draw (event->state, event->canvas, outRect);
}
//
//bool inCD = (ATOM_INVALID_IMAGEID != _cooldownImageId) && _cooldownMax;
//// »CELL±³¾°
//if(cell->_texture.pointer)
//{
// unsigned color = inCD ? 0xFF808080 : 0xFFFFFFFF;
// canvas->drawTexturedRectEx(ATOM_Rect2Di(x*(xCellWidth+_xSpace), y*(yCellWidth+_ySpace), xCellWidth, yCellWidth), color, cell->_texture.pointer, cell->_region, false);
//}
//else if (_clientImageId != ATOM_INVALID_IMAGEID)
//{
// imageDefault->draw (event->state, event->canvas, ATOM_Rect2Di(x*(xCellWidth+_xSpace), y*(yCellWidth+_ySpace), xCellWidth, yCellWidth));
//}
//if(cell->_text.pointer)
//{
// const char* str = cell->_text->getString();
// if (strcmp (str, ""))
// {
// ATOM_FontHandle font = ATOM_GUIFont::getFontHandle (getFont());
// int charmargin = ATOM_GUIFont::getFontCharMargin (getFont());
// int charset = ATOM_GUIFont::getFontCharSet (getFont());
// ATOM_SetCharMargin (charmargin);
// int l, t, w, h;
// ATOM_CalcStringBounds (font, charset, str, strlen(str), &l, &t, &w, &h);
// canvas->drawText (cell->_text.pointer, x*(xCellWidth+_xSpace), y*(yCellWidth+_ySpace)-t, _fontColor);
// }
//}
// »CD
if(inCD)
{
#if 1
ATOM_GUIImage *image = getValidImage (_cooldownImageId);
#else
ATOM_GUIImage* image = getValidImageList()->getImage (_cooldownImageId);
#endif
if(image)
{
ATOM_Texture* texture = image->getTexture(WST_NORMAL);
if(texture)
{
ATOM_CircleDrawer drawer(event->canvas, texture);
drawer.DrawRemove(inRect, float(_cooldown)/float(_cooldownMax));
}
}
#if 0
char buffer[256];
sprintf (buffer, "%d", _cooldown);
event->canvas->drawText (buffer, ATOM_GUIFont::getFontHandle(ATOM_GUIFont::getDefaultFont(10, 0)), 0, 0, 0xFFFFFFFF);
#endif
}
}
const ATOM_BBox &ATOM_TerrainQuadtreeNode::getBoundingbox (void) const
{
ATOM_ASSERT(_patch);
return _patch->getBoundingbox ();
}
bool ATOM_D3DVertexArray::_internalCreateVertexBuffer (unsigned bytes) {
ATOM_STACK_TRACE(ATOM_D3DVertexArray::_internalCreateVertexBuffer);
if (_M_device && _M_device->isDeviceReady ())
{
ATOM_D3D9Device *device = (ATOM_D3D9Device*)_M_device;
if (!device->getD3DDevice())
return false;
DWORD usage = D3DUSAGE_WRITEONLY;
D3DPOOL pool = D3DPOOL_MANAGED;
switch (_M_usage)
{
case ATOM_USAGE_STATIC:
usage = D3DUSAGE_WRITEONLY;
break;
case ATOM_USAGE_DYNAMIC:
usage = D3DUSAGE_WRITEONLY|D3DUSAGE_DYNAMIC;
pool = D3DPOOL_DEFAULT;
break;
case ATOM_USAGE_STOREONLY:
return false;
break;
}
HRESULT hr = device->getD3DDevice()->CreateVertexBuffer (bytes, usage, 0, pool, &_M_vertexbuffer, 0);
if (FAILED(hr))
{
if (pool == D3DPOOL_DEFAULT && hr == D3DERR_OUTOFVIDEOMEMORY)
{
ATOM_LOGGER::error ("%s(%d) CreateVertexBuffer() failed because there is not enough video memory, evicting managed resources and try again...\n", __FUNCTION__, bytes);
ATOM_CHECK_D3D_RESULT(device->getD3DDevice()->EvictManagedResources ());
hr = device->getD3DDevice()->CreateVertexBuffer (bytes, usage, 0, pool, &_M_vertexbuffer, 0);
if (FAILED(hr))
{
ATOM_LOGGER::error ("CreateVertexBuffer() still failed!\n");
ATOM_CHECK_D3D_RESULT(hr);
return false;
}
}
else
{
ATOM_LOGGER::error ("%s(%d) CreateVertexBuffer() failed!\n", __FUNCTION__, bytes);
ATOM_CHECK_D3D_RESULT(hr);
return false;
}
return false;
}
ATOM_ASSERT (_M_vertexbuffer);
_M_locked = 0;
if (getRenderDevice()->isContentBackupEnabled())
{
_preservedContent = ATOM_MALLOC(bytes);
}
return true;
}
return false;
}
void ATOM_Edit::onPaint (ATOM_WidgetDrawClientEvent *event)
{
ATOM_STACK_TRACE(ATOM_Edit::onPaint);
ATOM_GUICanvas* canvas = event->canvas;
ATOM_WidgetState state = event->state;
if (_textDirty)
{
calcTextLayout ();
_textDirty = false;
}
callParentHandler (event);
//render select image
// 绘制前景
if(_cusorOldPosition != _cusorNewPosition)
{
ATOM_GUIImage *image = getValidImage (_frontImageId);
ATOM_ASSERT(image);
if(_cursorPosition.x - _cusorOldPosition.x > 0)
{
image->draw (event->state, event->canvas, ATOM_Rect2Di(_cusorOldPosition.x, _cursorPosition.y, _cursorPosition.x - _cusorOldPosition.x, _clientRect.size.h));
}
else
image->draw (event->state, event->canvas, ATOM_Rect2Di( _cursorPosition.x , _cursorPosition.y, _cusorOldPosition.x - _cursorPosition.x, _clientRect.size.h));
}
// render text
const char *text = _text->getString();
if (strcmp (text, ""))
{
if(_widgetFontOutLineColor.getByteA())
{
canvas->drawTextOutline (_text.get(), _textPosition.x, _textPosition.y, getFontColor(), _widgetFontOutLineColor);
}
else
{
canvas->drawText (_text.get(), _textPosition.x, _textPosition.y, getFontColor());
}
}
// render cursor
if(0 == (EDITTYPE_READONLY & _editType))
{ // 只读的时候，不显示光标
if (_cursorImageId != ATOM_INVALID_IMAGEID)
{
if((getRenderer()->getFocus() == this) && (ATOM_APP->getFrameStamp().currentTick % 1000 < 500))
{
#if 1
ATOM_GUIImage *image = getValidImage (_cursorImageId);
#else
const ATOM_GUIImageList *imagelist = getValidImageList ();
ATOM_GUIImage *image = imagelist->getImage (_cursorImageId);
#endif
if (!image)
{
image = ATOM_GUIImageList::getDefaultImageList().getImage (ATOM_IMAGEID_WINDOW_BKGROUND);
ATOM_ASSERT(image);
}
image->draw (event->state, event->canvas, ATOM_Rect2Di(_cursorPosition.x, _cursorPosition.y, _cursorWidth, _clientRect.size.h));
}
}
}
// render default text
if(0 == (EDITTYPE_READONLY & _editType))
{ // 只读的时候，不显示默认字体
if((getRenderer()->getFocus() != this) && !strcmp (_text->getString(), ""))
{
const char *textDefault = _textDefault->getString();
if (strcmp (textDefault, ""))
{
if(_widgetFontOutLineColor.getByteA())
{
canvas->drawTextOutline (_textDefault.get(), _textDefaultPosition.x, _textDefaultPosition.y, _fontDefualtColor, _widgetFontOutLineColor);
}
else
{
canvas->drawText (_textDefault.get(), _textDefaultPosition.x, _textDefaultPosition.y, _fontDefualtColor);
}
}
}
}
}
bool ATOM_HWInstancingGeometry::draw (ATOM_RenderDevice *device, int type, int prim_count, int offset)
{
ATOM_STACK_TRACE(ATOM_HWInstancingGeometry::draw);
if (!_enableInstancing)
{
return ATOM_InterleavedStreamGeometry::draw (device, type, prim_count, offset);
}
if (_lockPtr)
{
_instanceDataStreams[_lockedStreamIndex]->unlock ();
_lockedStreamIndex = -1;
_lockPtr = 0;
}
if (_numInstances && _stream && _indices)
{
if (!_instancedVertexDecl)
{
createVertexDecl ();
}
if (_instancedVertexDecl)
{
device->setStreamSource (0, _stream.get());
//--- wangjian modified ---//
#if 0
if (_numInstances && _instanceDataStreams.size() > 0)
{
unsigned rem = _numInstances;
unsigned stream = 0;
device->setVertexDecl (_instancedVertexDecl);
while (rem)
{
if (_instanceDataStreams[stream])
{
unsigned count = (rem > MAX_BATCH_COUNT) ? MAX_BATCH_COUNT : rem;
device->setStreamSourceFreq (0, ATOM_STREAMSOURCE_INDEXEDDATA|count);
device->setStreamSource (1, _instanceDataStreams[stream].get());
device->setStreamSourceFreq (1, ATOM_STREAMSOURCE_INSTANCEDATA|1);
device->renderStreamsIndexed(_indices.get(), type, prim_count, offset);
rem -= count;
}
++stream;
}
device->setStreamSourceFreq (0, 1);
device->setStreamSourceFreq (1, 1);
}
#else
// use static instance buffer
if( ATOM_RenderSettings::isUseInstancingStaticBuffer() )
{
if( !_instanceData_staticbuffer )
createStaticInstanceBuffer();
if( _instanceData_staticbuffer )
{
device->setVertexDecl (_instancedVertexDecl);
ATOM_ASSERT( _numInstances <= ATOM_RenderSettings::getInstancingSBCountThreshold() );
device->setStreamSourceFreq (0, ATOM_STREAMSOURCE_INDEXEDDATA|_numInstances);
device->setStreamSource (1, _instanceData_staticbuffer.get());
device->setStreamSourceFreq (1, ATOM_STREAMSOURCE_INSTANCEDATA|1);
device->renderStreamsIndexed(_indices.get(), type, prim_count, offset);
}
}
else
{
if (_instanceDataStreams.size() > 0)
{
unsigned rem = _numInstances;
unsigned stream = 0;
device->setVertexDecl (_instancedVertexDecl);
while (rem)
{
if (_instanceDataStreams[stream])
{
unsigned count = (rem > MAX_BATCH_COUNT) ? MAX_BATCH_COUNT : rem;
device->setStreamSourceFreq (0, ATOM_STREAMSOURCE_INDEXEDDATA|count);
device->setStreamSource (1, _instanceDataStreams[stream].get());
device->setStreamSourceFreq (1, ATOM_STREAMSOURCE_INSTANCEDATA|1);
device->renderStreamsIndexed(_indices.get(), type, prim_count, offset);
rem -= count;
}
++stream;
}
}
}
device->setStreamSourceFreq (0, 1);
device->setStreamSourceFreq (1, 1);
device->setStreamSource (0, 0);
device->setStreamSource (1, 0);
#endif
//---------------------------------------------------------------------//
}
_numInstances = 0;
return true;
}
return false;
}
Material* MaterialManager::GetMaterial( char const* name )
{
ATOM_ASSERT(m_materials[name], "material does not exist");
return m_materials[name];
}
